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 perform file query operations across multiple threads.
+  class QueryOp : public base::RefCountedThreadSafe<QueryOp> {
+   public:
+    QueryOp(PP_FileHandle file_handle);

[dmichael (off chromium), 2013/08/09 22:20:56]

nit: explicit

[bbudge, 2013/08/09 23:05:28]

Done.

+
+    // Queries the file. Called on the file thread (non-blocking) or the plugin
+    // thread (blocking).

[dmichael (off chromium), 2013/08/09 22:20:56]

please note it does not hold the ProxyLock (same for ReadOp)

[bbudge, 2013/08/09 23:05:28]

Done.

+    int32_t DoWork();
+
+    const base::PlatformFileInfo& file_info() const { return file_info_; }
+
+   private:
+    friend class base::RefCountedThreadSafe<QueryOp>;
+    virtual ~QueryOp();

[dmichael (off chromium), 2013/08/09 22:20:56]

FWIW...  You don't actually need to make it virtual with
RefCounted/RefCountedThreadSafe. That's only necessary if you plan to derive
from QueryOp. (same holds for ReadOp)

[bbudge, 2013/08/09 23:05:28]

Done.

+
+    PP_FileHandle file_handle_;
+    base::PlatformFileInfo file_info_;
+  };
+
+  // Class to perform file read operations across multiple threads.
+  class ReadOp : public base::RefCountedThreadSafe<ReadOp> {
+   public:
+    ReadOp(PP_FileHandle file_handle, int64_t offset, int32_t bytes_to_read);
+
+    // Reads the file. Called on the file thread (non-blocking) or the plugin
+    // thread (blocking).
+    int32_t DoWork();
+
+    char* buffer() const { return buffer_.get(); }
+
+   private:
+    friend class base::RefCountedThreadSafe<ReadOp>;
+    virtual ~ReadOp();
+
+    PP_FileHandle file_handle_;
+    int64_t offset_;
+    int32_t bytes_to_read_;
+    scoped_ptr<char[]> buffer_;
+  };
+
   int32_t ReadValidated(int64_t offset,
                         int32_t bytes_to_read,
                         const PP_ArrayOutput& array_output,
                         scoped_refptr<TrackedCallback> callback);
 
   void CloseFileHandle();
 
+
+  void OnFileTaskComplete(scoped_refptr<TrackedCallback> callback,
+                          int32_t result);
+
+  // Completion tasks for file operations that are done in the plugin.
+  int32_t OnQueryComplete(scoped_refptr<QueryOp> query_op,
+                          PP_FileInfo* info,
+                          int32_t result);
+  int32_t OnReadComplete(scoped_refptr<ReadOp> read_op,
+                         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_;
 
   DISALLOW_COPY_AND_ASSIGN(FileIOResource);
 };
 
 }  // namespace proxy
 }  // namespace ppapi
 
 #endif  // PPAPI_PROXY_FILE_IO_RESOURCE_H_