Pepper quota support

webkit/plugins/ppapi/ppb_file_io_impl.h

 // Copyright (c) 2011 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 WEBKIT_PLUGINS_PPAPI_PPB_FILE_IO_IMPL_H_
 #define WEBKIT_PLUGINS_PPAPI_PPB_FILE_IO_IMPL_H_
 
 #include <queue>
 
 #include "base/basictypes.h"
+#include "base/callback.h"
 #include "base/file_path.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_callback_factory.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/platform_file.h"
 #include "ppapi/c/pp_file_info.h"
 #include "ppapi/c/pp_time.h"
 #include "ppapi/thunk/ppb_file_io_api.h"
 #include "webkit/plugins/ppapi/callbacks.h"
 #include "webkit/plugins/ppapi/plugin_delegate.h"
 #include "webkit/plugins/ppapi/resource.h"
 
 struct PP_CompletionCallback;
 struct PPB_FileIO;
 struct PPB_FileIOTrusted;
 
 namespace webkit {
 namespace ppapi {
 
 class PluginModule;
 class PPB_FileRef_Impl;
 
 class PPB_FileIO_Impl : public Resource,

[michaeln, 2011/07/19 23:54:58]

I'm kinda wondering if for the TEMP and PERSISTENT file_system_types_, this
entire interface should be implemented in terms of our existing file reading and
writing IPCs and ultimately handled in the browser process.

Has that approach been considered?

[kinuko, 2011/07/20 13:39:35]

I suspected we may want to do that.  Not sure if we need to re-implement the
entire interface but at least as for the setlength/write part.

(Btw which code do you mean by 'existing file reading IPC'?)

                         public ::ppapi::thunk::PPB_FileIO_API {
  public:
   explicit PPB_FileIO_Impl(PluginInstance* instance);
   virtual ~PPB_FileIO_Impl();
 
   // ResourceObjectBase overrides.
   virtual ::ppapi::thunk::PPB_FileIO_API* AsPPB_FileIO_API() OVERRIDE;
 
   // PPB_FileIO_API implementation.
   virtual int32_t Open(PP_Resource file_ref,
                        int32_t open_flags,
                        PP_CompletionCallback callback) OVERRIDE;
   virtual int32_t Query(PP_FileInfo* info,
                         PP_CompletionCallback callback) OVERRIDE;
   virtual int32_t Touch(PP_Time last_access_time,
                         PP_Time last_modified_time,
                         PP_CompletionCallback callback) OVERRIDE;
   virtual int32_t Read(int64_t offset,
                        char* buffer,
                        int32_t bytes_to_read,
                        PP_CompletionCallback callback) OVERRIDE;
   virtual int32_t Write(int64_t offset,
                         const char* buffer,
                         int32_t bytes_to_write,
                         PP_CompletionCallback callback) OVERRIDE;
   virtual int32_t SetLength(int64_t length,
                             PP_CompletionCallback callback) OVERRIDE;
   virtual int32_t Flush(PP_CompletionCallback callback) OVERRIDE;
   virtual void Close() OVERRIDE;
   virtual int32_t GetOSFileDescriptor() OVERRIDE;

[michaeln, 2011/07/19 23:54:58]

How is this used i wonder... will do some grepping?

   virtual int32_t WillWrite(int64_t offset,
                             int32_t bytes_to_write,
                             PP_CompletionCallback callback) OVERRIDE;
   virtual int32_t WillSetLength(int64_t length,

[michaeln, 2011/07/19 23:54:58]

What are WillWrite() and WillSetLength() about... deadcode?

[brettw, 2011/07/20 04:08:06]

 The proxy gets the OS file descriptor to duplicate it into the other process.
This is a trusted API only so can't be called by normal plugins.

The intention of WillWrite and WillSetLength was that the proxy would use this
to keep the quota management system appraised of file operations it's performing
in the plugin process so we don't have to proxy every single file I/O operation.

                                 PP_CompletionCallback callback) OVERRIDE;
 
  private:
   struct CallbackEntry {
     CallbackEntry();
     CallbackEntry(const CallbackEntry& entry);
     ~CallbackEntry();
 
     scoped_refptr<TrackedCompletionCallback> callback;
     // Pointer back to the caller's read buffer; only used by |Read()|.
     // Not owned.
     char* read_buffer;
   };
 
+  struct PendingWrite {
+    int64_t offset;
+    const char* buffer;
+    int32_t bytes_to_write;
+  };
+
   enum OperationType {
     // If there are pending reads, any other kind of async operation is not
     // allowed.
     OPERATION_READ,
     // If there are pending writes, any other kind of async operation is not
     // allowed.
     OPERATION_WRITE,
     // If there is a pending operation that is neither read nor write, no
     // further async operation is allowed.
     OPERATION_EXCLUSIVE,
@@ skipping 16 matching lines @@
   // that |PP_OK_COMPLETIONPENDING| will be returned.
   // |read_buffer| is only used by read operations.
   void RegisterCallback(OperationType op,
                         PP_CompletionCallback callback,
                         char* rend_buffer);
 
   void RunAndRemoveFirstPendingCallback(int32_t result);
 
   void StatusCallback(base::PlatformFileError error_code);
   void AsyncOpenFileCallback(base::PlatformFileError error_code,
-                             base::PassPlatformFile file);
+                             base::PassPlatformFile file,
+                             int64 file_size);

[michaeln, 2011/07/19 22:01:45]

Seems that this class mostly uses int64_t in place of int64 (not sure why), but
for consistency this probably should too.

[kinuko, 2011/07/20 13:39:35]

Done.

   void QueryInfoCallback(base::PlatformFileError error_code,
                          const base::PlatformFileInfo& file_info);
   void ReadCallback(base::PlatformFileError error_code,
                     const char* data, int bytes_read);
   void WriteCallback(base::PlatformFileError error_code, int bytes_written);
+  void SetLengthCallback(base::PlatformFileError error_code);
+
+  void DidCheckQuotaForWrite(bool success);
+  void DidCheckQuotaForSetLength(bool success);
 
   base::ScopedCallbackFactory<PPB_FileIO_Impl> callback_factory_;
 
   base::PlatformFile file_;
   PP_FileSystemType file_system_type_;
 
+  // They are valid only for files of
+  // PP_FILESYSTEMTYPE_LOCAL{PERSISTENT,TEMPORARY}.
+  GURL origin_url_;
+  int64 file_size_;
+
   std::queue<CallbackEntry> callbacks_;
   OperationType pending_op_;
 
   // Output buffer pointer for |Query()|; only non-null when a callback is
   // pending for it.
   PP_FileInfo* info_;
 
+  std::queue<PendingWrite> pending_writes_;

[yzshen1, 2011/07/19 17:41:55]

|pending_writes_| and |pending_write_callbacks_| look confusing. It is better to
have more comments.
To me, |pending_write_callbacks_| can be removed. (We probably only need put the
offset information in |callbacks_|, right?)

[michaeln, 2011/07/19 22:01:45]

Maybe...
pending_quota_checks_
pending_writes_

[kinuko, 2011/07/20 13:39:35]

Done.

+  std::queue<PendingWrite> pending_write_callbacks_;
+  int64_t pending_setlength_length_;
+
   DISALLOW_COPY_AND_ASSIGN(PPB_FileIO_Impl);
 };
 
 }  // namespace ppapi
 }  // namespace webkit
 
 #endif  // WEBKIT_PLUGINS_PPAPI_PPB_FILE_IO_IMPL_H_