Pepper quota support

webkit/plugins/ppapi/ppb_file_io_impl.cc

 // 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.
 
 #include "webkit/plugins/ppapi/ppb_file_io_impl.h"
 
 #include "base/callback.h"
 #include "base/file_util.h"
 #include "base/file_util_proxy.h"
 #include "base/message_loop_proxy.h"
 #include "base/platform_file.h"
 #include "base/logging.h"
 #include "base/time.h"
 #include "ppapi/c/ppb_file_io.h"
 #include "ppapi/c/trusted/ppb_file_io_trusted.h"
 #include "ppapi/c/pp_completion_callback.h"
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/shared_impl/time_conversion.h"
 #include "ppapi/thunk/enter.h"
 #include "ppapi/thunk/ppb_file_ref_api.h"
 #include "webkit/plugins/ppapi/common.h"
 #include "webkit/plugins/ppapi/file_type_conversions.h"
 #include "webkit/plugins/ppapi/plugin_module.h"
 #include "webkit/plugins/ppapi/ppapi_plugin_instance.h"
 #include "webkit/plugins/ppapi/ppb_file_ref_impl.h"
+#include "webkit/plugins/ppapi/quota_file_io.h"
 #include "webkit/plugins/ppapi/resource_tracker.h"
 
 using ppapi::PPTimeToTime;
 using ppapi::TimeToPPTime;
 using ppapi::thunk::EnterResourceNoLock;
 using ppapi::thunk::PPB_FileIO_API;
 using ppapi::thunk::PPB_FileRef_API;
 
 namespace webkit {
 namespace ppapi {
 
 PPB_FileIO_Impl::CallbackEntry::CallbackEntry()
     : read_buffer(NULL) {
 }
 
 PPB_FileIO_Impl::CallbackEntry::CallbackEntry(const CallbackEntry& entry)
     : callback(entry.callback),
       read_buffer(entry.read_buffer) {
 }
 
 PPB_FileIO_Impl::CallbackEntry::~CallbackEntry() {
 }
 
 PPB_FileIO_Impl::PPB_FileIO_Impl(PluginInstance* instance)
     : Resource(instance),
       ALLOW_THIS_IN_INITIALIZER_LIST(callback_factory_(this)),
       file_(base::kInvalidPlatformFileValue),
+      file_system_type_(PP_FILESYSTEMTYPE_INVALID),
       pending_op_(OPERATION_NONE),
       info_(NULL) {
 }
 
 PPB_FileIO_Impl::~PPB_FileIO_Impl() {
   Close();
 }
 
 PPB_FileIO_API* PPB_FileIO_Impl::AsPPB_FileIO_API() {
   return this;
@@ skipping 19 matching lines @@
   switch (file_system_type_) {
     case PP_FILESYSTEMTYPE_EXTERNAL:
       if (!instance()->delegate()->AsyncOpenFile(
               file_ref->GetSystemPath(), flags,
               callback_factory_.NewCallback(
                   &PPB_FileIO_Impl::AsyncOpenFileCallback)))
         return PP_ERROR_FAILED;
       break;
     case PP_FILESYSTEMTYPE_LOCALPERSISTENT:
     case PP_FILESYSTEMTYPE_LOCALTEMPORARY:
+      file_system_url_ = file_ref->GetFileSystemURL();
       if (!instance()->delegate()->AsyncOpenFileSystemURL(
-              file_ref->GetFileSystemURL(), flags,
+              file_system_url_, flags,
               callback_factory_.NewCallback(
                   &PPB_FileIO_Impl::AsyncOpenFileCallback)))
         return PP_ERROR_FAILED;
       break;
     default:
       return PP_ERROR_FAILED;
   }
 
   RegisterCallback(OPERATION_EXCLUSIVE, callback, NULL);
   return PP_OK_COMPLETIONPENDING;
@@ skipping 57 matching lines @@
 }
 
 int32_t PPB_FileIO_Impl::Write(int64_t offset,
                                const char* buffer,
                                int32_t bytes_to_write,
                                PP_CompletionCallback callback) {
   int32_t rv = CommonCallValidation(true, OPERATION_WRITE, callback);
   if (rv != PP_OK)
     return rv;
 
-  if (!base::FileUtilProxy::Write(
-          instance()->delegate()->GetFileThreadMessageLoopProxy(),
-          file_, offset, buffer, bytes_to_write,
-          callback_factory_.NewCallback(&PPB_FileIO_Impl::WriteCallback)))
-    return PP_ERROR_FAILED;
+  if (quota_file_io_.get()) {
+    if (!quota_file_io_->Write(
+            offset, buffer, bytes_to_write,
+            callback_factory_.NewCallback(&PPB_FileIO_Impl::WriteCallback)))
+      return PP_ERROR_FAILED;
+  } else {
+    if (!base::FileUtilProxy::Write(
+            instance()->delegate()->GetFileThreadMessageLoopProxy(),
+            file_, offset, buffer, bytes_to_write,
+            callback_factory_.NewCallback(&PPB_FileIO_Impl::WriteCallback)))
+      return PP_ERROR_FAILED;
+  }
 
   RegisterCallback(OPERATION_WRITE, callback, NULL);
   return PP_OK_COMPLETIONPENDING;
 }
 
 int32_t PPB_FileIO_Impl::SetLength(int64_t length,
                                    PP_CompletionCallback callback) {
   int32_t rv = CommonCallValidation(true, OPERATION_EXCLUSIVE, callback);
   if (rv != PP_OK)
     return rv;
 
-  if (!base::FileUtilProxy::Truncate(
-          instance()->delegate()->GetFileThreadMessageLoopProxy(),
-          file_, length,
-          callback_factory_.NewCallback(&PPB_FileIO_Impl::StatusCallback)))
-    return PP_ERROR_FAILED;
+  if (quota_file_io_.get()) {
+    if (!quota_file_io_->SetLength(
+            length,
+            callback_factory_.NewCallback(&PPB_FileIO_Impl::StatusCallback)))
+      return PP_ERROR_FAILED;
+  } else {
+    if (!base::FileUtilProxy::Truncate(
+            instance()->delegate()->GetFileThreadMessageLoopProxy(),
+            file_, length,
+            callback_factory_.NewCallback(&PPB_FileIO_Impl::StatusCallback)))
+      return PP_ERROR_FAILED;
+  }
 
   RegisterCallback(OPERATION_EXCLUSIVE, callback, NULL);
   return PP_OK_COMPLETIONPENDING;
 }
 
 int32_t PPB_FileIO_Impl::Flush(PP_CompletionCallback callback) {
   int32_t rv = CommonCallValidation(true, OPERATION_EXCLUSIVE, callback);
   if (rv != PP_OK)
     return rv;
 
   if (!base::FileUtilProxy::Flush(
           instance()->delegate()->GetFileThreadMessageLoopProxy(), file_,
           callback_factory_.NewCallback(&PPB_FileIO_Impl::StatusCallback)))
     return PP_ERROR_FAILED;
 
   RegisterCallback(OPERATION_EXCLUSIVE, callback, NULL);
   return PP_OK_COMPLETIONPENDING;
 }
 
 void PPB_FileIO_Impl::Close() {
   if (file_ != base::kInvalidPlatformFileValue) {
     base::FileUtilProxy::Close(
         instance()->delegate()->GetFileThreadMessageLoopProxy(), file_, NULL);
     file_ = base::kInvalidPlatformFileValue;
+    quota_file_io_.reset();
   }
 }
 
 int32_t PPB_FileIO_Impl::GetOSFileDescriptor() {
 #if defined(OS_POSIX)
   return file_;
 #elif defined(OS_WIN)
   return reinterpret_cast<uintptr_t>(file_);
 #else
 #error "Platform not supported."
 #endif
 }
 
 int32_t PPB_FileIO_Impl::WillWrite(int64_t offset,
                                    int32_t bytes_to_write,
                                    PP_CompletionCallback callback) {
-  // TODO(dumi): implement me
-  return PP_OK;
+  int32_t rv = CommonCallValidation(true, OPERATION_WRITE, callback);

[yzshen1, 2011/07/26 19:26:44]

Using OPERATION_WRITE means it can be queued up in |callbacks_| along with
PPB_FileIO_Impl::Write.
That requires all WillWrite / Write operations to be completed in the same order
as they are pushed into |callbacks_|. Otherwise, we will call the wrong
callbacks!

However, after reading the implementation of quota_file_io, it seems that cannot
be guaranteed.

One possible, simple solution is to make WillWrite OPERATION_EXCLUSIVE. I don't
think we explicitly say that WillWrite can be queued up in the API definition.
What do you think?

[kinuko, 2011/07/27 09:33:14]

Guessing how the API is supposed to be used, making this OPERATION_EXCLUSIVE
sounds right to me.

+  if (rv != PP_OK)
+    return rv;
+
+  if (!quota_file_io_.get())
+    return PP_OK;
+
+  if (!quota_file_io_->WillWrite(
+          offset, bytes_to_write,
+          callback_factory_.NewCallback(&PPB_FileIO_Impl::WriteCallback)))
+    return PP_ERROR_FAILED;
+
+  RegisterCallback(OPERATION_WRITE, callback, NULL);

[yzshen1, 2011/07/26 19:26:44]

Please see comments on line 250.

[kinuko, 2011/07/27 09:33:14]

Done.

+  return PP_OK_COMPLETIONPENDING;
 }
 
 int32_t PPB_FileIO_Impl::WillSetLength(int64_t length,
                                        PP_CompletionCallback callback) {
-  // TODO(dumi): implement me
-  return PP_OK;
+  int32_t rv = CommonCallValidation(true, OPERATION_EXCLUSIVE, callback);
+  if (rv != PP_OK)
+    return rv;
+
+  if (!quota_file_io_.get())
+    return PP_OK;
+
+  if (!quota_file_io_->WillSetLength(
+          length,
+          callback_factory_.NewCallback(&PPB_FileIO_Impl::StatusCallback)))
+    return PP_ERROR_FAILED;
+
+  RegisterCallback(OPERATION_EXCLUSIVE, callback, NULL);
+  return PP_OK_COMPLETIONPENDING;
 }
 
 int32_t PPB_FileIO_Impl::CommonCallValidation(bool should_be_open,
                                               OperationType new_op,
                                               PP_CompletionCallback callback) {
   // Only asynchronous operation is supported.
   if (!callback.func) {
     NOTIMPLEMENTED();
     return PP_ERROR_BADARGUMENT;
   }
@@ skipping 55 matching lines @@
 void PPB_FileIO_Impl::AsyncOpenFileCallback(
     base::PlatformFileError error_code,
     base::PassPlatformFile file) {
   if (pending_op_ != OPERATION_EXCLUSIVE || callbacks_.empty()) {
     NOTREACHED();
     return;
   }
 
   DCHECK(file_ == base::kInvalidPlatformFileValue);
   file_ = file.ReleaseValue();
+
+  DCHECK(!quota_file_io_.get());
+  if (file_ != base::kInvalidPlatformFileValue &&
+      (file_system_type_ == PP_FILESYSTEMTYPE_LOCALTEMPORARY ||
+       file_system_type_ == PP_FILESYSTEMTYPE_LOCALPERSISTENT)) {
+    quota_file_io_.reset(new QuotaFileIO(
+        instance(), file_, file_system_url_, file_system_type_));
+  }
+
   RunAndRemoveFirstPendingCallback(PlatformFileErrorToPepperError(error_code));
 }
 
 void PPB_FileIO_Impl::QueryInfoCallback(
     base::PlatformFileError error_code,
     const base::PlatformFileInfo& file_info) {
   if (pending_op_ != OPERATION_EXCLUSIVE || callbacks_.empty()) {
     NOTREACHED();
     return;
   }
@@ skipping 47 matching lines @@
   if (error_code != base::PLATFORM_FILE_OK) {
     RunAndRemoveFirstPendingCallback(
         PlatformFileErrorToPepperError(error_code));
   } else {
     RunAndRemoveFirstPendingCallback(bytes_written);
   }
 }
 
 }  // namespace ppapi
 }  // namespace webkit