Do PPB_FileIO Query and Read in the plugin process.

ppapi/proxy/file_io_resource.h

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef PPAPI_PROXY_FILE_IO_RESOURCE_H_
 #define PPAPI_PROXY_FILE_IO_RESOURCE_H_
 
 #include <string>
 
 #include "ppapi/c/private/pp_file_handle.h"
@@ skipping 49 matching lines @@
       PP_FileHandle* handle,
       scoped_refptr<TrackedCallback> callback) OVERRIDE;
   virtual int32_t WillWrite(int64_t offset,
                             int32_t bytes_to_write,
                             scoped_refptr<TrackedCallback> callback) OVERRIDE;
   virtual int32_t WillSetLength(
       int64_t length,
       scoped_refptr<TrackedCallback> callback) OVERRIDE;
 
  private:
+  // Class to share file read state between threads.
+  class ReadData : public base::RefCountedThreadSafe<ReadData> {
+   public:
+    explicit ReadData(int32_t bytes_to_read);
+
+    char* buffer() const { return buffer_.get(); }
+    int32_t bytes_read() const { return bytes_read_; }
+    void set_bytes_read(int32_t bytes_read) { bytes_read_ = bytes_read; }
+
+   private:
+    friend class base::RefCountedThreadSafe<ReadData>;
+    virtual ~ReadData();
+
+    // We can't read directly into the plugin's buffer, since we can't be sure
+    // that the call hasn't already aborted. Read into this buffer instead.
+    scoped_ptr<char[]> buffer_;
+    int32_t bytes_read_;
+  };
+
   int32_t ReadValidated(int64_t offset,
                         int32_t bytes_to_read,
                         const PP_ArrayOutput& array_output,
                         scoped_refptr<TrackedCallback> callback);
 
   void CloseFileHandle();
 
+  // File tasks. These are called on the file thread (for non-blocking calls)
+  // and on the plugin's thread (for blocking calls).

[dmichael (off chromium), 2013/08/09 17:37:42]

maybe note that they run without the ProxyLock?

[bbudge, 2013/08/09 21:43:24]

I removed these and put them on the ops classes.

+  void DoQuery();
+  void DoRead(int64_t offset,
+              int32_t bytes_to_read,
+              scoped_refptr<ReadData> read_data);
+
+  void OnFileTaskComplete(scoped_refptr<TrackedCallback> callback);
+
+  // Completion tasks for file operations that are done in the plugin.
+  int32_t OnQueryComplete(PP_FileInfo* info, int32_t result);
+  int32_t OnReadComplete(scoped_refptr<ReadData> read_data,
+                         PP_ArrayOutput array_output, int32_t result);
+
   // Reply message handlers for operations that are done in the host.
   void OnPluginMsgGeneralComplete(scoped_refptr<TrackedCallback> callback,
                                   const ResourceMessageReplyParams& params);
   void OnPluginMsgOpenFileComplete(scoped_refptr<TrackedCallback> callback,
                                    const ResourceMessageReplyParams& params);
-  void OnPluginMsgQueryComplete(scoped_refptr<TrackedCallback> callback,
-                                PP_FileInfo* output_info_,
-                                const ResourceMessageReplyParams& params,
-                                const PP_FileInfo& info);
-  void OnPluginMsgReadComplete(scoped_refptr<TrackedCallback> callback,
-                               PP_ArrayOutput array_output,
-                               const ResourceMessageReplyParams& params,
-                               const std::string& data);
   void OnPluginMsgRequestOSFileHandleComplete(
       scoped_refptr<TrackedCallback> callback,
       PP_FileHandle* output_handle,
       const ResourceMessageReplyParams& params);
 
   PP_FileHandle file_handle_;
   PP_FileSystemType file_system_type_;
   FileIOStateManager state_manager_;
 
+  // Temporary state for Query. These are written by the file thread (for
+  // non-blocking calls) or the plugin's thread (for blocking calls), and read
+  // only on the plugin's thread.
+  base::PlatformFileInfo file_info_;
+  int32_t query_result_;

[dmichael (off chromium), 2013/08/09 17:37:42]

These aren't *that* big. What about making them parameters to OnQueryComplete
instead and letting them copy, so that we don't have to use members on >1
thread?

[bbudge, 2013/08/09 21:43:24]

Added a QueryOp ref counted class to remove these warts.

+
   DISALLOW_COPY_AND_ASSIGN(FileIOResource);
 };
 
 }  // namespace proxy
 }  // namespace ppapi
 
 #endif  // PPAPI_PROXY_FILE_IO_RESOURCE_H_