Pepper quota support

webkit/plugins/ppapi/ppb_file_io_impl.cc

Index: webkit/plugins/ppapi/ppb_file_io_impl.cc
diff --git a/webkit/plugins/ppapi/ppb_file_io_impl.cc b/webkit/plugins/ppapi/ppb_file_io_impl.cc
index 309067cd1b5cbf51783770aa46f8c63a8acff00a..0cf9b2766d98927a01cd87b004c8439fa58f9019 100644
--- a/webkit/plugins/ppapi/ppb_file_io_impl.cc
+++ b/webkit/plugins/ppapi/ppb_file_io_impl.cc
@@ -23,6 +23,7 @@
 #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;
@@ -50,6 +51,7 @@ 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) {
 }
@@ -89,8 +91,9 @@ int32_t PPB_FileIO_Impl::Open(PP_Resource pp_file_ref,
       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;
@@ -168,11 +171,18 @@ int32_t PPB_FileIO_Impl::Write(int64_t offset,
   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;
@@ -184,11 +194,18 @@ int32_t PPB_FileIO_Impl::SetLength(int64_t length,
   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;
@@ -213,6 +230,7 @@ void PPB_FileIO_Impl::Close() {
     base::FileUtilProxy::Close(
         instance()->delegate()->GetFileThreadMessageLoopProxy(), file_, NULL);
     file_ = base::kInvalidPlatformFileValue;
+    quota_file_io_.reset();
   }
 }
 
@@ -229,14 +247,38 @@ int32_t PPB_FileIO_Impl::GetOSFileDescriptor() {
 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,
@@ -312,6 +354,15 @@ void PPB_FileIO_Impl::AsyncOpenFileCallback(
 
   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));
 }