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"
@@ skipping 16 matching lines @@
 
 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 {
 
+namespace {
+quota::StorageType PPFileSystemTypeToQuotaStorageType(PP_FileSystemType type) {
+  switch (type) {
+    case PP_FILESYSTEMTYPE_LOCALPERSISTENT:
+      return quota::kStorageTypePersistent;
+    case PP_FILESYSTEMTYPE_LOCALTEMPORARY:
+      return quota::kStorageTypeTemporary;
+    default:
+      return quota::kStorageTypeUnknown;
+  }
+  NOTREACHED();
+}
+}  // namespace
+
+PPB_FileIO_Impl::PendingOperation::PendingOperation()

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

Please use the same order as they are declared in the .h file.

This method should come after CallbackEntry::*.

+    : type(UNKNOWN), offset(0), buffer(NULL), bytes_to_write(0) {}

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

You miss |length|.

+
 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),
       pending_op_(OPERATION_NONE),
-      info_(NULL) {
+      info_(NULL),
+      cached_available_space_(0),

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

You miss quite a few members. Please initialize all those which don't have a
constructor.

+      did_notify_will_update_(false),
+      pending_setlength_length_(-1) {
 }
 
 PPB_FileIO_Impl::~PPB_FileIO_Impl() {
   Close();
 }
 
 PPB_FileIO_API* PPB_FileIO_Impl::AsPPB_FileIO_API() {
   return this;
 }
 
@@ skipping 17 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:
+      path_url_ = file_ref->GetFileSystemURL();
       if (!instance()->delegate()->AsyncOpenFileSystemURL(
-              file_ref->GetFileSystemURL(), flags,
+              path_url_, flags,
               callback_factory_.NewCallback(
                   &PPB_FileIO_Impl::AsyncOpenFileCallback)))
         return PP_ERROR_FAILED;
       break;
     default:
       return PP_ERROR_FAILED;
   }
 
-  RegisterCallback(OPERATION_EXCLUSIVE, callback, NULL);
+  RegisterCallback(&callbacks_, OPERATION_EXCLUSIVE, callback, NULL);
   return PP_OK_COMPLETIONPENDING;
 }
 
 int32_t PPB_FileIO_Impl::Query(PP_FileInfo* info,
                                PP_CompletionCallback callback) {
   int32_t rv = CommonCallValidation(true, OPERATION_EXCLUSIVE, callback);
   if (rv != PP_OK)
     return rv;
 
   if (!info)
     return PP_ERROR_BADARGUMENT;
 
   DCHECK(!info_);  // If |info_|, a callback should be pending (caught above).
   info_ = info;
 
   if (!base::FileUtilProxy::GetFileInfoFromPlatformFile(
           instance()->delegate()->GetFileThreadMessageLoopProxy(), file_,
           callback_factory_.NewCallback(&PPB_FileIO_Impl::QueryInfoCallback)))
     return PP_ERROR_FAILED;
 
-  RegisterCallback(OPERATION_EXCLUSIVE, callback, NULL);
+  RegisterCallback(&callbacks_, OPERATION_EXCLUSIVE, callback, NULL);
   return PP_OK_COMPLETIONPENDING;
 }
 
 int32_t PPB_FileIO_Impl::Touch(PP_Time last_access_time,
                                PP_Time last_modified_time,
                                PP_CompletionCallback callback) {
   int32_t rv = CommonCallValidation(true, OPERATION_EXCLUSIVE, callback);
   if (rv != PP_OK)
     return rv;
 
   if (!base::FileUtilProxy::Touch(
           instance()->delegate()->GetFileThreadMessageLoopProxy(),
           file_, PPTimeToTime(last_access_time),
           PPTimeToTime(last_modified_time),
           callback_factory_.NewCallback(&PPB_FileIO_Impl::StatusCallback)))
     return PP_ERROR_FAILED;
 
-  RegisterCallback(OPERATION_EXCLUSIVE, callback, NULL);
+  RegisterCallback(&callbacks_, OPERATION_EXCLUSIVE, callback, NULL);
   return PP_OK_COMPLETIONPENDING;
 }
 
 int32_t PPB_FileIO_Impl::Read(int64_t offset,
                               char* buffer,
                               int32_t bytes_to_read,
                               PP_CompletionCallback callback) {
   int32_t rv = CommonCallValidation(true, OPERATION_READ, callback);
   if (rv != PP_OK)
     return rv;
 
   if (!base::FileUtilProxy::Read(
           instance()->delegate()->GetFileThreadMessageLoopProxy(),
           file_, offset, bytes_to_read,
           callback_factory_.NewCallback(&PPB_FileIO_Impl::ReadCallback)))
     return PP_ERROR_FAILED;
 
-  RegisterCallback(OPERATION_READ, callback, buffer);
+  RegisterCallback(&callbacks_, OPERATION_READ, callback, buffer);
   return PP_OK_COMPLETIONPENDING;
 }
 
 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)))
+  if (!DoesRequireQuotaCheck()) {
+    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(&callbacks_, OPERATION_WRITE, callback, NULL);
+    return PP_OK_COMPLETIONPENDING;
+  }
+
+  // Enqueue this request and query the quota.
+  PendingOperation op;
+  op.type = PendingOperation::WRITE;
+  op.offset = offset;
+  op.buffer = buffer;
+  op.bytes_to_write = bytes_to_write;
+  if (!QueryFileSizeAndQuota(op))
     return PP_ERROR_FAILED;
 
-  RegisterCallback(OPERATION_WRITE, callback, NULL);
+  RegisterCallback(&pending_quota_check_callbacks_,
+                   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)))
+  if (!DoesRequireQuotaCheck()) {
+    if (!base::FileUtilProxy::Truncate(
+            instance()->delegate()->GetFileThreadMessageLoopProxy(),
+            file_, length,
+            callback_factory_.NewCallback(
+                &PPB_FileIO_Impl::SetLengthCallback))) {
+      return PP_ERROR_FAILED;
+    }
+    RegisterCallback(&callbacks_, OPERATION_EXCLUSIVE, callback, NULL);
+    return PP_OK_COMPLETIONPENDING;
+  }
+
+  // Enqueue this request and query the quota.
+  PendingOperation op;
+  op.type = PendingOperation::SETLENGTH;
+  op.length = length;
+  if (!QueryFileSizeAndQuota(op))
     return PP_ERROR_FAILED;
 
-  RegisterCallback(OPERATION_EXCLUSIVE, callback, NULL);
+  RegisterCallback(&pending_quota_check_callbacks_,
+                   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);
+  RegisterCallback(&callbacks_, 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;
   }
 }
 
 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);
+  if (rv != PP_OK)
+    return rv;
+
+  if (!DoesRequireQuotaCheck()) {
+    PP_RunCompletionCallback(&callback, PP_OK);
+    return PP_OK;
+  }
+
+  PendingOperation op;
+  op.type = PendingOperation::WILL_WRITE;
+  op.offset = offset;
+  op.bytes_to_write = bytes_to_write;
+  if (!QueryFileSizeAndQuota(op))
+    return PP_ERROR_FAILED;
+
+  RegisterCallback(&pending_quota_check_callbacks_,
+                   OPERATION_WRITE, callback, NULL);
+  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 (!DoesRequireQuotaCheck()) {
+    PP_RunCompletionCallback(&callback, PP_OK);
+    return PP_OK;
+  }
+
+  PendingOperation op;
+  op.type = PendingOperation::WILL_SETLENGTH;
+  op.length = length;
+  if (!QueryFileSizeAndQuota(op))
+    return PP_ERROR_FAILED;
+
+  RegisterCallback(&pending_quota_check_callbacks_,
+                   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;
   }
 
   if (should_be_open) {
     if (file_ == base::kInvalidPlatformFileValue)
       return PP_ERROR_FAILED;
   } else {
     if (file_ != base::kInvalidPlatformFileValue)
       return PP_ERROR_FAILED;
   }
 
   if (pending_op_ != OPERATION_NONE &&
       (pending_op_ != new_op || pending_op_ == OPERATION_EXCLUSIVE)) {
     return PP_ERROR_INPROGRESS;
   }
 
   return PP_OK;
 }
 
-void PPB_FileIO_Impl::RegisterCallback(OperationType op,
+void PPB_FileIO_Impl::RegisterCallback(std::queue<CallbackEntry>* callbacks,
+                                       OperationType op,
                                        PP_CompletionCallback callback,
                                        char* read_buffer) {
   DCHECK(callback.func);
   DCHECK(pending_op_ == OPERATION_NONE ||
          (pending_op_ != OPERATION_EXCLUSIVE && pending_op_ == op));
 
   CallbackEntry entry;
   PP_Resource resource_id = GetReferenceNoAddRef();
   CHECK(resource_id);
   entry.callback = new TrackedCompletionCallback(
       instance()->module()->GetCallbackTracker(), resource_id, callback);
   entry.read_buffer = read_buffer;
 
-  callbacks_.push(entry);
+  callbacks->push(entry);
   pending_op_ = op;
 }
 
-void PPB_FileIO_Impl::RunAndRemoveFirstPendingCallback(int32_t result) {
-  DCHECK(!callbacks_.empty());
+void PPB_FileIO_Impl::RunAndRemoveFirstPendingCallback(
+    std::queue<CallbackEntry>* callbacks, int32_t result) {
+  DCHECK(!callbacks->empty());
 
-  CallbackEntry front = callbacks_.front();
-  callbacks_.pop();
-  if (callbacks_.empty())
+  CallbackEntry front = callbacks->front();
+  callbacks->pop();
+  if (callbacks->empty())

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

pending_op_ can be set incorrectly.
Consider the following example: there are two writes in the callbacks_ queue,
while the third in pending_quota_check_callbacks_. And now we call
RunAndRemoveFirstPendingCallback() with the pending_quota_check_callbacks_
queue. pending_op_ will be set to NONE.

     pending_op_ = OPERATION_NONE;
 
   front.callback->Run(result);  // Will complete abortively if necessary.
 }
 
 void PPB_FileIO_Impl::StatusCallback(base::PlatformFileError error_code) {
   if (pending_op_ != OPERATION_EXCLUSIVE || callbacks_.empty()) {
     NOTREACHED();
     return;
   }
 
-  RunAndRemoveFirstPendingCallback(PlatformFileErrorToPepperError(error_code));
+  RunAndRemoveFirstPendingCallback(
+      &callbacks_, PlatformFileErrorToPepperError(error_code));
 }
 
 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();
-  RunAndRemoveFirstPendingCallback(PlatformFileErrorToPepperError(error_code));
+  RunAndRemoveFirstPendingCallback(
+      &callbacks_, 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;
   }
 
   DCHECK(info_);
   if (error_code == base::PLATFORM_FILE_OK) {
     info_->size = file_info.size;
     info_->creation_time = TimeToPPTime(file_info.creation_time);
     info_->last_access_time = TimeToPPTime(file_info.last_accessed);
     info_->last_modified_time = TimeToPPTime(file_info.last_modified);
     info_->system_type = file_system_type_;
     if (file_info.is_directory)
       info_->type = PP_FILETYPE_DIRECTORY;
     else
       info_->type = PP_FILETYPE_REGULAR;
   }
   info_ = NULL;
-  RunAndRemoveFirstPendingCallback(PlatformFileErrorToPepperError(error_code));
+  RunAndRemoveFirstPendingCallback(
+      &callbacks_, PlatformFileErrorToPepperError(error_code));
 }
 
 void PPB_FileIO_Impl::ReadCallback(base::PlatformFileError error_code,
                                    const char* data, int bytes_read) {
   if (pending_op_ != OPERATION_READ || callbacks_.empty()) {
     NOTREACHED();
     return;
   }
 
   char* read_buffer = callbacks_.front().read_buffer;
   DCHECK(data);
   DCHECK(read_buffer);
 
   int rv;
   if (error_code == base::PLATFORM_FILE_OK) {
     rv = bytes_read;
     if (file_ != base::kInvalidPlatformFileValue)
       memcpy(read_buffer, data, bytes_read);
   } else {
     rv = PlatformFileErrorToPepperError(error_code);
   }
 
-  RunAndRemoveFirstPendingCallback(rv);
+  RunAndRemoveFirstPendingCallback(&callbacks_, rv);
 }
 
 void PPB_FileIO_Impl::WriteCallback(base::PlatformFileError error_code,
                                     int bytes_written) {
   if (pending_op_ != OPERATION_WRITE || callbacks_.empty()) {
     NOTREACHED();
     return;
   }
 
+  if (DoesRequireQuotaCheck()) {
+    DCHECK(did_notify_will_update_);
+    DCHECK(!pending_write_offset_.empty());
+
+    // Update possible max file offset.
+    int64_t offset = pending_write_offset_.front();
+    pending_write_offset_.pop();
+    if (error_code == base::PLATFORM_FILE_OK)
+      max_written_offset_ = std::max(max_written_offset_,
+                                     offset + bytes_written);
+
+    // If we have no more pending writes, notify the browser that we did
+    // update the file.
+    if (pending_quota_checks_.empty() &&
+        pending_write_offset_.empty()) {
+      int64_t growth = max_written_offset_ - cached_file_size_;
+      if (growth > 0)
+        instance()->delegate()->DidUpdateFile(path_url_, growth);
+      did_notify_will_update_ = false;
+    }
+  }
+
   if (error_code != base::PLATFORM_FILE_OK) {
     RunAndRemoveFirstPendingCallback(
-        PlatformFileErrorToPepperError(error_code));
+        &callbacks_, PlatformFileErrorToPepperError(error_code));
   } else {
-    RunAndRemoveFirstPendingCallback(bytes_written);
-  }
+    RunAndRemoveFirstPendingCallback(&callbacks_, bytes_written);
+  }
+}
+
+void PPB_FileIO_Impl::SetLengthCallback(
+    base::PlatformFileError error_code) {
+  if (callbacks_.empty()) {
+    NOTREACHED();
+    return;
+  }
+
+  if (DoesRequireQuotaCheck()) {
+    DCHECK_NE(-1, pending_setlength_length_);
+    DCHECK(did_notify_will_update_);
+    if (base::PLATFORM_FILE_OK == error_code) {
+      instance()->delegate()->DidUpdateFile(
+          path_url_, pending_setlength_length_ - cached_file_size_);
+    }
+    pending_setlength_length_ = -1;
+    did_notify_will_update_ = false;
+  }
+
+  RunAndRemoveFirstPendingCallback(
+      &callbacks_, PlatformFileErrorToPepperError(error_code));
+}
+
+bool PPB_FileIO_Impl::DoesRequireQuotaCheck() const {
+  return (file_system_type_ == PP_FILESYSTEMTYPE_LOCALTEMPORARY ||
+          file_system_type_ == PP_FILESYSTEMTYPE_LOCALPERSISTENT);
+}
+
+bool PPB_FileIO_Impl::QueryFileSizeAndQuota(const PendingOperation& op) {
+  pending_quota_checks_.push(op);
+  if (pending_quota_checks_.size() == 1) {
+    // This is the first call.
+    DCHECK(!did_notify_will_update_);
+    outstanding_quota_queries_ = 0;
+    outstanding_errors_ = 0;
+
+    // Query the file size.
+    ++outstanding_quota_queries_;
+    if (!base::FileUtilProxy::GetFileInfoFromPlatformFile(
+            instance()->delegate()->GetFileThreadMessageLoopProxy(), file_,
+            callback_factory_.NewCallback(
+                &PPB_FileIO_Impl::DidQueryInfoForQuota))) {
+      pending_quota_checks_.pop();

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

Maybe you could push at the end of the method, so that you don't need to
remember to pop on every error handling path.

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

Done (in quota_file_io.cc)

+      return false;
+    }
+
+    // Query the current available space.
+    ++outstanding_quota_queries_;
+    instance()->delegate()->QueryAvailableSpace(
+        GURL(path_url_.path()).GetOrigin(),
+        PPFileSystemTypeToQuotaStorageType(file_system_type_),
+        callback_factory_.NewCallback(
+            &PPB_FileIO_Impl::DidQueryAvailableSpace));
+  }
+  return true;
+}
+
+void PPB_FileIO_Impl::DidQueryInfoForQuota(
+    base::PlatformFileError error_code,
+    const base::PlatformFileInfo& file_info) {
+  if (error_code != base::PLATFORM_FILE_OK)
+    ++outstanding_errors_;
+  cached_file_size_ = max_written_offset_ = file_info.size;
+  DCHECK_GT(outstanding_quota_queries_, 0);
+  if (--outstanding_quota_queries_ == 0)
+    DidQueryFileSizeAndQuota();
+}
+
+void PPB_FileIO_Impl::DidQueryAvailableSpace(int64_t avail_space) {
+  cached_available_space_ = avail_space;
+  DCHECK_GT(outstanding_quota_queries_, 0);
+  if (--outstanding_quota_queries_ == 0)
+    DidQueryFileSizeAndQuota();
+}
+
+void PPB_FileIO_Impl::DidQueryFileSizeAndQuota() {
+  DCHECK(!pending_quota_checks_.empty());
+  while (!pending_quota_checks_.empty()) {
+    PendingOperation op = pending_quota_checks_.front();
+    pending_quota_checks_.pop();
+
+    switch (op.type) {
+      case PendingOperation::WRITE: {
+        int64_t growth = op.offset + op.bytes_to_write - cached_file_size_;
+        if (!CommonQuotaCheck(growth))
+          continue;
+        if (!base::FileUtilProxy::Write(
+                instance()->delegate()->GetFileThreadMessageLoopProxy(),
+                file_, op.offset, op.buffer, op.bytes_to_write,
+                callback_factory_.NewCallback(
+                    &PPB_FileIO_Impl::WriteCallback))) {
+          RunAndRemoveFirstPendingCallback(
+              &pending_quota_check_callbacks_, PP_ERROR_FAILED);
+          continue;
+        }
+        pending_write_offset_.push(op.offset);
+        break;
+      }
+
+      case PendingOperation::SETLENGTH: {
+        int64_t growth = op.length - cached_file_size_;
+        if (!CommonQuotaCheck(growth))
+          continue;
+        if (!base::FileUtilProxy::Truncate(
+                instance()->delegate()->GetFileThreadMessageLoopProxy(),
+                file_, op.length,
+                callback_factory_.NewCallback(
+                    &PPB_FileIO_Impl::SetLengthCallback))) {
+          RunAndRemoveFirstPendingCallback(
+              &pending_quota_check_callbacks_, PP_ERROR_FAILED);
+          continue;
+        }
+        DCHECK_EQ(-1, pending_setlength_length_);
+        pending_setlength_length_ = op.length;
+        break;
+      }
+
+      case PendingOperation::WILL_WRITE: {
+        int64_t growth = op.offset + op.bytes_to_write - cached_file_size_;
+        if (!CommonQuotaCheck(growth))
+          continue;
+        // TODO(kinuko) we should have a way to handle failure cases;
+        // currently we always update the usage upfront even if the actual
+        // write (which will be called after we run the callback) may fail.
+        pending_write_offset_.push(op.offset);
+        WriteCallback(base::PLATFORM_FILE_OK, op.bytes_to_write);

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

You shouldn't call WriteCallback before moving the callback from
|pending_quota_check_callbacks_| into |callbacks_|.

+        break;
+      }
+
+      case PendingOperation::WILL_SETLENGTH: {
+        int64_t growth = op.length - cached_file_size_;
+        if (!CommonQuotaCheck(growth))
+          continue;
+        // TODO(kinuko) we should have a way to handle failure cases;
+        // currently we always update the usage upfront even if the actual
+        // truncate (which will be called after we run the callback) may fail.
+        pending_setlength_length_ = op.length;
+        SetLengthCallback(base::PLATFORM_FILE_OK);

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

You shouldn't call SetLengthCallback before moving the callback from
|pending_quota_check_callbacks_| into |callbacks_|.

Please do tests to ensure that the CL works properly.

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

Added tests that call WillWrite/WillSetLength in ppapi/tests/test_file_io.cc and
verified it works (on my local env).

As for quota related operations I've also added new unittest as
quota_file_io_unittest.

+        break;
+      }
+
+      default:
+        NOTREACHED();
+        continue;
+    }
+
+    DCHECK(did_notify_will_update_);
+    CallbackEntry entry = pending_quota_check_callbacks_.front();
+    pending_quota_check_callbacks_.pop();
+    callbacks_.push(entry);
+  }
+}
+
+bool PPB_FileIO_Impl::CommonQuotaCheck(int64_t growth) {
+  DCHECK(!pending_quota_check_callbacks_.empty());
+  if (outstanding_errors_ || growth > cached_available_space_) {
+    RunAndRemoveFirstPendingCallback(
+        &pending_quota_check_callbacks_,
+        PP_ERROR_NOQUOTA);
+    return false;
+  }
+  if (!did_notify_will_update_) {
+    instance()->delegate()->WillUpdateFile(path_url_);
+    did_notify_will_update_ = true;
+  }
+  return true;
 }
 
 }  // namespace ppapi
 }  // namespace webkit