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"
@@ skipping 75 matching lines @@
     // 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,
     // There is no pending operation right now.
     OPERATION_NONE,
   };
 
+  struct PendingOperation {

[yzshen1, 2011/07/21 22:23:34]

It seems we have two kinds of "pending" now.
- called base::FileUtilProxy::* but haven't got replies.
  (That is what pending means in OperationType.)
- started quota check but haven't called base::FileUtilProxy::*.
  (That is what pending means here.)

Please think up better names and/or add comments to clarify.

Otherwise, OperationType and PendingOperation/PendingOperation::Type seem very
confusing.

[kinuko, 2011/07/26 16:27:46]

I've moved all the quota-related 'pending' bookkeeping info to the new class
QuotaFileIO, therefore in FileIOImpl we only have single type of 'pending'
operations as ever.

(QuotaFileIO keeps its own 'pending' operations but it has the almost same
meaning as the PPB_FileIOImpl's 'pending', i.e. operations that are being
dispatched or waiting for quota checks are referred as 'pending'.)

+    enum Type { UNKNOWN, WRITE, SETLENGTH, WILL_WRITE, WILL_SETLENGTH };
+    PendingOperation();
+    Type type;
+
+    // For WRITE.
+    int64_t offset;
+    const char* buffer;
+    int32_t bytes_to_write;
+
+    // For SETLENGTH.
+    int64_t length;
+  };
+
   // Verifies:
   //  - that |callback| is valid (only nonblocking operation supported);
   //  - that the file is already open or not, depending on |should_be_open|; and
   //  - that no callback is already pending, or it is a read(write) request
   //    and currently the pending operations are reads(writes).
   // Returns |PP_OK| to indicate that everything is valid or |PP_ERROR_...| if
   // the call should be aborted and that code returned to the plugin.
   int32_t CommonCallValidation(bool should_be_open,
                                OperationType new_op,
                                PP_CompletionCallback callback);
 
   // Sets up a pending callback. This should only be called once it is certain
   // that |PP_OK_COMPLETIONPENDING| will be returned.
   // |read_buffer| is only used by read operations.
-  void RegisterCallback(OperationType op,
+  void RegisterCallback(std::queue<CallbackEntry>* callbacks,
+                        OperationType op,
                         PP_CompletionCallback callback,
                         char* rend_buffer);
-
-  void RunAndRemoveFirstPendingCallback(int32_t result);
+  void RunAndRemoveFirstPendingCallback(std::queue<CallbackEntry>* callbacks,
+                                        int32_t result);
 
   void StatusCallback(base::PlatformFileError error_code);
   void AsyncOpenFileCallback(base::PlatformFileError error_code,
                              base::PassPlatformFile file);
   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);
+
+  // Quota related methods.
+  bool DoesRequireQuotaCheck() const;
+  bool QueryFileSizeAndQuota(const PendingOperation& op);
+  void DidQueryInfoForQuota(base::PlatformFileError error_code,
+                            const base::PlatformFileInfo& file_info);
+  void DidQueryAvailableSpace(int64_t avail_space);
+  void DidQueryFileSizeAndQuota();
+  bool CommonQuotaCheck(int64_t growth);
 
   base::ScopedCallbackFactory<PPB_FileIO_Impl> callback_factory_;
 
   base::PlatformFile file_;
   PP_FileSystemType file_system_type_;
 
+  // Valid only for PP_FILESYSTEMTYPE_LOCAL{PERSISTENT,TEMPORARY}.
+  GURL path_url_;
+
   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_;
 
+  // Valid only while there're pending write requests.

[yzshen1, 2011/07/21 22:23:34]

I think SetLength/Will* also use this, right?

(PS: As I mentioned above, we need to clarify what pending means here.)

[kinuko, 2011/07/26 16:27:46]

Fixed the comment (in quota_file_io.h)

+  int64_t cached_file_size_;
+  int64_t cached_available_space_;
+
+  // For async quota query bookkeeping.
+  int outstanding_quota_queries_;
+  int outstanding_errors_;
+  std::queue<PendingOperation> pending_quota_checks_;
+  std::queue<CallbackEntry> pending_quota_check_callbacks_;

[yzshen1, 2011/07/21 22:23:34]

I would suggest that you don't keep another CallbackEntry queue. Instead, you
keep a  scoped_refptr<TrackedCompletionCallback> in PendingOperation.
When DidQueryFileSizeAndQuota is called, you move this callback into callbacks_
(or run it directly on error).

In that way, you don't need two CallbackEntry queues, which is confusing.

And you need to be careful about setting |pending_op_| correctly. (The current
CL does it incorrectly. Please see my comment in CommonCallValidation.)

[kinuko, 2011/07/26 16:27:46]

In the new QuotaFileIO class I organized the code/callbacks like that; now we
have single queue of pending operations and each operation keeps/maintains its
associated callback(s)/parameters encapsulated in it.

+  bool did_notify_will_update_;
+
+  std::queue<int64_t> pending_write_offset_;

[yzshen1, 2011/07/21 22:23:34]

I think this should be part of CallbackEntry, right? The original code doesn't
keep a separate queue for |read_buffer|.

If you concern about putting too many members (which are only used by one kind
of operations) into CallbackEntry, we could probably find another way to do it.
But at least we should be consistent.

[kinuko, 2011/07/26 16:27:46]

Similarly they now belong to each (QuotaFileIO's) pending operation instance.

+  int64_t pending_setlength_length_;
+  int64_t max_written_offset_;
+
   DISALLOW_COPY_AND_ASSIGN(PPB_FileIO_Impl);
 };
 
 }  // namespace ppapi
 }  // namespace webkit
 
 #endif  // WEBKIT_PLUGINS_PPAPI_PPB_FILE_IO_IMPL_H_