1// Copyright (c) 2012 The Chromium Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#ifndef PPAPI_PROXY_FILE_IO_RESOURCE_H_
6#define PPAPI_PROXY_FILE_IO_RESOURCE_H_
7
8#include <string>
9
10#include "base/files/file.h"
11#include "base/memory/ref_counted.h"
12#include "base/memory/scoped_ptr.h"
13#include "ppapi/c/private/pp_file_handle.h"
14#include "ppapi/proxy/connection.h"
15#include "ppapi/proxy/plugin_resource.h"
16#include "ppapi/proxy/ppapi_proxy_export.h"
17#include "ppapi/shared_impl/file_io_state_manager.h"
18#include "ppapi/shared_impl/resource.h"
19#include "ppapi/shared_impl/scoped_pp_resource.h"
20#include "ppapi/thunk/ppb_file_io_api.h"
21
22namespace ppapi {
23
24class TrackedCallback;
25
26namespace proxy {
27
28class PPAPI_PROXY_EXPORT FileIOResource
29    : public PluginResource,
30      public thunk::PPB_FileIO_API {
31 public:
32  FileIOResource(Connection connection, PP_Instance instance);
33  virtual ~FileIOResource();
34
35  // Resource overrides.
36  virtual thunk::PPB_FileIO_API* AsPPB_FileIO_API() OVERRIDE;
37
38  // PPB_FileIO_API implementation.
39  virtual int32_t Open(PP_Resource file_ref,
40                       int32_t open_flags,
41                       scoped_refptr<TrackedCallback> callback) OVERRIDE;
42  virtual int32_t Query(PP_FileInfo* info,
43                        scoped_refptr<TrackedCallback> callback) OVERRIDE;
44  virtual int32_t Touch(PP_Time last_access_time,
45                        PP_Time last_modified_time,
46                        scoped_refptr<TrackedCallback> callback) OVERRIDE;
47  virtual int32_t Read(int64_t offset,
48                       char* buffer,
49                       int32_t bytes_to_read,
50                       scoped_refptr<TrackedCallback> callback) OVERRIDE;
51  virtual int32_t ReadToArray(int64_t offset,
52                              int32_t max_read_length,
53                              PP_ArrayOutput* array_output,
54                              scoped_refptr<TrackedCallback> callback) OVERRIDE;
55  virtual int32_t Write(int64_t offset,
56                        const char* buffer,
57                        int32_t bytes_to_write,
58                        scoped_refptr<TrackedCallback> callback) OVERRIDE;
59  virtual int32_t SetLength(int64_t length,
60                            scoped_refptr<TrackedCallback> callback) OVERRIDE;
61  virtual int64_t GetMaxWrittenOffset() const OVERRIDE;
62  virtual int64_t GetAppendModeWriteAmount() const OVERRIDE;
63  virtual void SetMaxWrittenOffset(int64_t max_written_offset) OVERRIDE;
64  virtual void SetAppendModeWriteAmount(
65      int64_t append_mode_write_amount) OVERRIDE;
66  virtual int32_t Flush(scoped_refptr<TrackedCallback> callback) OVERRIDE;
67  virtual void Close() OVERRIDE;
68  virtual int32_t RequestOSFileHandle(
69      PP_FileHandle* handle,
70      scoped_refptr<TrackedCallback> callback) OVERRIDE;
71
72  // FileHolder is used to guarantee that file operations will have a valid FD
73  // to operate on, even if they're in a different thread.
74  // If instead we just passed the raw FD, the FD could be closed before the
75  // file operation has a chance to run. It could interact with an invalid FD,
76  // or worse, the FD value could be reused if another file is opened quickly
77  // (POSIX is required to provide the lowest available value when opening a
78  // file). This could result in strange problems such as writing data to the
79  // wrong file.
80  //
81  // Operations that run on a background thread should hold one of these to
82  // ensure they have a valid file descriptor. The file handle is only closed
83  // when the last reference to the FileHolder is removed, so we are guaranteed
84  // to operate on the correct file descriptor. It *is* still possible that the
85  // FileIOResource will be destroyed and "Abort" callbacks just before the
86  // operation does its task (e.g., Reading). In that case, we might for example
87  // Read from a file even though the FileIO has been destroyed and the plugin's
88  // callback got a PP_ERROR_ABORTED result. In the case of a write, we could
89  // write some data to the file despite the plugin receiving a
90  // PP_ERROR_ABORTED instead of a successful result.
91  class FileHolder : public base::RefCountedThreadSafe<FileHolder> {
92   public:
93    explicit FileHolder(PP_FileHandle file_handle);
94    base::File* file() {
95      return &file_;
96    }
97    static bool IsValid(
98        const scoped_refptr<FileIOResource::FileHolder>& handle);
99   private:
100    friend class base::RefCountedThreadSafe<FileHolder>;
101    ~FileHolder();
102    base::File file_;
103  };
104
105  scoped_refptr<FileHolder> file_holder() {
106    return file_holder_;
107  }
108
109 private:
110  // Class to perform file query operations across multiple threads.
111  class QueryOp : public base::RefCountedThreadSafe<QueryOp> {
112   public:
113    explicit QueryOp(scoped_refptr<FileHolder> file_holder);
114
115    // Queries the file. Called on the file thread (non-blocking) or the plugin
116    // thread (blocking). This should not be called when we hold the proxy lock.
117    int32_t DoWork();
118
119    const base::File::Info& file_info() const { return file_info_; }
120
121   private:
122    friend class base::RefCountedThreadSafe<QueryOp>;
123    ~QueryOp();
124
125    scoped_refptr<FileHolder> file_holder_;
126    base::File::Info file_info_;
127  };
128
129  // Class to perform file read operations across multiple threads.
130  class ReadOp : public base::RefCountedThreadSafe<ReadOp> {
131   public:
132    ReadOp(scoped_refptr<FileHolder> file_holder,
133           int64_t offset,
134           int32_t bytes_to_read);
135
136    // Reads the file. Called on the file thread (non-blocking) or the plugin
137    // thread (blocking). This should not be called when we hold the proxy lock.
138    int32_t DoWork();
139
140    char* buffer() const { return buffer_.get(); }
141
142   private:
143    friend class base::RefCountedThreadSafe<ReadOp>;
144    ~ReadOp();
145
146    scoped_refptr<FileHolder> file_holder_;
147    int64_t offset_;
148    int32_t bytes_to_read_;
149    scoped_ptr<char[]> buffer_;
150  };
151
152  // Class to perform file write operations across multiple threads.
153  class WriteOp : public base::RefCountedThreadSafe<WriteOp> {
154   public:
155    WriteOp(scoped_refptr<FileHolder> file_holder,
156            int64_t offset,
157            scoped_ptr<char[]> buffer,
158            int32_t bytes_to_write,
159            bool append);
160
161    // Writes the file. Called on the file thread (non-blocking) or the plugin
162    // thread (blocking). This should not be called when we hold the proxy lock.
163    int32_t DoWork();
164
165   private:
166    friend class base::RefCountedThreadSafe<WriteOp>;
167    ~WriteOp();
168
169    scoped_refptr<FileHolder> file_holder_;
170    int64_t offset_;
171    scoped_ptr<char[]> buffer_;
172    int32_t bytes_to_write_;
173    bool append_;
174  };
175
176  void OnRequestWriteQuotaComplete(int64_t offset,
177                                   scoped_ptr<char[]> buffer,
178                                   int32_t bytes_to_write,
179                                   scoped_refptr<TrackedCallback> callback,
180                                   int64_t granted);
181  void OnRequestSetLengthQuotaComplete(int64_t length,
182                                       scoped_refptr<TrackedCallback> callback,
183                                       int64_t granted);
184
185  int32_t ReadValidated(int64_t offset,
186                        int32_t bytes_to_read,
187                        const PP_ArrayOutput& array_output,
188                        scoped_refptr<TrackedCallback> callback);
189  int32_t WriteValidated(int64_t offset,
190                         const char* buffer,
191                         int32_t bytes_to_write,
192                         scoped_refptr<TrackedCallback> callback);
193  void SetLengthValidated(int64_t length,
194                          scoped_refptr<TrackedCallback> callback);
195
196  // Completion tasks for file operations that are done in the plugin.
197  int32_t OnQueryComplete(scoped_refptr<QueryOp> query_op,
198                          PP_FileInfo* info,
199                          int32_t result);
200  int32_t OnReadComplete(scoped_refptr<ReadOp> read_op,
201                         PP_ArrayOutput array_output,
202                         int32_t result);
203  int32_t OnWriteComplete(int32_t result);
204
205  // Reply message handlers for operations that are done in the host.
206  void OnPluginMsgGeneralComplete(scoped_refptr<TrackedCallback> callback,
207                                  const ResourceMessageReplyParams& params);
208  void OnPluginMsgOpenFileComplete(scoped_refptr<TrackedCallback> callback,
209                                   const ResourceMessageReplyParams& params,
210                                   PP_Resource quota_file_system,
211                                   int64_t max_written_offset);
212  void OnPluginMsgRequestOSFileHandleComplete(
213      scoped_refptr<TrackedCallback> callback,
214      PP_FileHandle* output_handle,
215      const ResourceMessageReplyParams& params);
216
217  scoped_refptr<FileHolder> file_holder_;
218  PP_FileSystemType file_system_type_;
219  scoped_refptr<Resource> file_system_resource_;
220  FileIOStateManager state_manager_;
221
222  scoped_refptr<Resource> file_ref_;
223
224  int32_t open_flags_;
225  int64_t max_written_offset_;
226  int64_t append_mode_write_amount_;
227  bool check_quota_;
228  bool called_close_;
229
230  DISALLOW_COPY_AND_ASSIGN(FileIOResource);
231};
232
233}  // namespace proxy
234}  // namespace ppapi
235
236#endif  // PPAPI_PROXY_FILE_IO_RESOURCE_H_
237