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"

[michaeln, 2011/07/20 21:28:33]

Are any plugins using the file descriptor base APIs yet?


On 2011/07/20 17:54:52, michaeln wrote:
Looks like the pepper glueware has a URLLoader capability defined in
url_loader.h and implemented in ppb_url_loader_impl.h which invokes
WebURLLoader.

[kinuko, 2011/07/21 14:34:08]

I guessed you meant this but also wished there might be an easier path :)
Sounds good-- but could we make it a TODO while we're targeting M14?  Also even
if we move the major code to the browser don't we still need to do some tricky
stuff for trusted apps?

 
-#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/fileapi/file_system_util.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/resource_tracker.h"
+#include "webkit/quota/quota_client.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 {
 
+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()
+    : type(UNKNOWN), offset(0), buffer(NULL), bytes_to_write(0) {}
+
 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_size_(-1),
+      cached_available_space_(0),
       pending_op_(OPERATION_NONE),
-      info_(NULL) {
+      info_(NULL),
+      pending_setlength_length_(-1) {
 }
 
 PPB_FileIO_Impl::~PPB_FileIO_Impl() {
   Close();
 }
 
 PPB_FileIO_API* PPB_FileIO_Impl::AsPPB_FileIO_API() {
   return this;
 }
 
@@ skipping 16 matching lines @@
   file_system_type_ = file_ref->GetFileSystemType();
   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:
+    case PP_FILESYSTEMTYPE_LOCALTEMPORARY: {
+      GURL root_url = file_ref->GetFileSystemURL();
       if (!instance()->delegate()->AsyncOpenFileSystemURL(
-              file_ref->GetFileSystemURL(), flags,
+              root_url, flags,
               callback_factory_.NewCallback(
                   &PPB_FileIO_Impl::AsyncOpenFileCallback)))
         return PP_ERROR_FAILED;
+      origin_url_ = GURL(root_url.path()).GetOrigin();
       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)))
-    return PP_ERROR_FAILED;
+  int64_t expected_growth = offset + bytes_to_write - file_size_;
 
-  RegisterCallback(OPERATION_WRITE, callback, NULL);
+  if (!DoesRequireQuotaCheck() ||
+      expected_growth <= cached_available_space_) {
+    // we're ok to go.
+    if (!base::FileUtilProxy::Write(
+            instance()->delegate()->GetFileThreadMessageLoopProxy(),
+            file_, offset, buffer, bytes_to_write,
+            callback_factory_.NewCallback(&PPB_FileIO_Impl::WriteCallback))) {
+      return PP_ERROR_FAILED;
+    }
+    pending_write_offset_.push(offset);
+    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;
+  QueryAvailableSpace(op);
+
+  RegisterCallback(&pending_quota_check_callbacks_,

[yzshen1, 2011/07/20 20:50:36]

The problem is that write operations may be executed in wrong order.
Consider the following example:
Current file length: 5
Write_1: offset: 3; bytes_to_write: 10
Write_2: offset: 0; bytes_to_write: 5

Write_1 requires QueryAvailableSpace, while Write_2 doesn't.
If Write_1 and Write_2 comes in quick succession, it is possible that Write_2 is
executed before Write_1, which will result in unexpected file contents.

[kinuko, 2011/07/21 14:34:08]

I changed the code to either always or never queue the operations.

+                   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;
+  DCHECK_EQ(-1, pending_setlength_length_);
+  int64_t expected_growth = length - file_size_;
 
-  RegisterCallback(OPERATION_EXCLUSIVE, callback, NULL);
+  if (!DoesRequireQuotaCheck() ||
+      expected_growth <= cached_available_space_) {
+    if (!base::FileUtilProxy::Truncate(
+            instance()->delegate()->GetFileThreadMessageLoopProxy(),
+            file_, length,
+            callback_factory_.NewCallback(
+                &PPB_FileIO_Impl::SetLengthCallback))) {
+      return PP_ERROR_FAILED;
+    }
+    pending_setlength_length_ = length;
+    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;
+  QueryAvailableSpace(op);
+
+  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
+  // Request quota.

[michaeln, 2011/07/20 21:28:33]

Given the shape of the trusted APIs (there's a WillDoSomething() but no
DidDoSomething()), should this method (and the one below) check space available
and also notify storage modified.

[kinuko, 2011/07/21 14:34:08]

Hmm the successive write or truncate may fail, so this model may not work really
well.
I made a tentative change that performs something like that.

   return PP_OK;
 }
 
 int32_t PPB_FileIO_Impl::WillSetLength(int64_t length,
                                        PP_CompletionCallback callback) {
   // TODO(dumi): implement me
+  // Request quota.
   return PP_OK;
 }
 
 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())
     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) {
+    base::PassPlatformFile file,
+    int64_t file_size) {
   if (pending_op_ != OPERATION_EXCLUSIVE || callbacks_.empty()) {
     NOTREACHED();
     return;
   }
 
   DCHECK(file_ == base::kInvalidPlatformFileValue);
   file_ = file.ReleaseValue();
-  RunAndRemoveFirstPendingCallback(PlatformFileErrorToPepperError(error_code));
+  file_size_ = file_size;
+  DCHECK(!DoesRequireQuotaCheck() ||
+         error_code != base::PLATFORM_FILE_OK ||
+         file_size_ >= 0);
+  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;
   }
 
+  DCHECK(!pending_write_offset_.empty());
+  int64_t offset = pending_write_offset_.front();
+  pending_write_offset_.pop();
+
   if (error_code != base::PLATFORM_FILE_OK) {
     RunAndRemoveFirstPendingCallback(
-        PlatformFileErrorToPepperError(error_code));
+        &callbacks_, PlatformFileErrorToPepperError(error_code));
   } else {
-    RunAndRemoveFirstPendingCallback(bytes_written);
+    int64_t growth = offset + bytes_written - file_size_;
+    if (growth >= 0) {
+      if (DoesRequireQuotaCheck()) {
+        instance()->delegate()->NotifyStorageModified(
+            quota::QuotaClient::kFileSystem,
+            origin_url_,
+            PPFileSystemTypeToQuotaStorageType(file_system_type_),
+            growth);
+      }
+      file_size_ += growth;
+    }
+    RunAndRemoveFirstPendingCallback(&callbacks_, bytes_written);
+  }
+
+  // Reset the available space.
+  if (HasNoPendingWrites())
+    cached_available_space_ = 0;
+}
+
+void PPB_FileIO_Impl::SetLengthCallback(
+    base::PlatformFileError error_code) {
+  if (callbacks_.empty()) {
+    NOTREACHED();
+    return;
+  }
+
+  DCHECK_NE(-1, pending_setlength_length_);
+
+  if (base::PLATFORM_FILE_OK == error_code) {
+    if (DoesRequireQuotaCheck()) {
+      int64_t delta = pending_setlength_length_ - file_size_;
+      instance()->delegate()->NotifyStorageModified(
+          quota::QuotaClient::kFileSystem,
+          origin_url_,
+          PPFileSystemTypeToQuotaStorageType(file_system_type_),
+          delta);
+    }
+    file_size_ = pending_setlength_length_;
+  }
+
+  RunAndRemoveFirstPendingCallback(
+      &callbacks_, PlatformFileErrorToPepperError(error_code));
+
+  pending_setlength_length_ = -1;

[michaeln, 2011/07/20 21:28:33]

If the caller's callback has invoked FileIO.SetLength(), i think this line will
squash the value provided to that call.

[kinuko, 2011/07/21 14:34:08]

Good catch, fixed.

+  cached_available_space_ = 0;
+}
+
+bool PPB_FileIO_Impl::DoesRequireQuotaCheck() const {
+  return (file_system_type_ == PP_FILESYSTEMTYPE_LOCALTEMPORARY ||
+          file_system_type_ == PP_FILESYSTEMTYPE_LOCALPERSISTENT);
+}
+
+bool PPB_FileIO_Impl::HasNoPendingWrites() const {
+  return pending_quota_checks_.empty() &&
+         pending_write_offset_.empty() &&
+         pending_setlength_length_ == -1;
+}
+
+void PPB_FileIO_Impl::QueryAvailableSpace(const PendingOperation& op) {
+  pending_quota_checks_.push(op);
+  if (pending_quota_checks_.size() == 1) {
+    // This is the first one.
+    instance()->delegate()->QueryAvailableSpace(
+        origin_url_,
+        PPFileSystemTypeToQuotaStorageType(file_system_type_),
+        callback_factory_.NewCallback(
+            &PPB_FileIO_Impl::DidQueryAvailableSpace));
   }
 }
 
+void PPB_FileIO_Impl::DidQueryAvailableSpace(int64_t avail_space) {
+  cached_available_space_ = avail_space;
+  DCHECK(!pending_quota_checks_.empty());
+
+  while (!pending_quota_checks_.empty()) {
+    DCHECK(!pending_quota_check_callbacks_.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 - file_size_;
+        if (growth > cached_available_space_) {
+          RunAndRemoveFirstPendingCallback(
+              &pending_quota_check_callbacks_,
+              PP_ERROR_NOQUOTA);
+          return;

[michaeln, 2011/07/20 21:28:33]

What about other pending checks in the queue? Is it ok to return here or should
the others be processed too so the FileIO doesn't hang.

[kinuko, 2011/07/21 14:34:08]

Done.

+        }
+        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);
+        }
+        pending_write_offset_.push(op.offset);
+        break;
+      }
+
+      case PendingOperation::SETLENGTH: {
+        int64_t growth = op.length - file_size_;
+        if (growth > cached_available_space_) {
+          RunAndRemoveFirstPendingCallback(
+              &pending_quota_check_callbacks_,
+              PP_ERROR_NOQUOTA);
+          return;
+        }
+        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);
+        }
+        DCHECK_EQ(-1, pending_setlength_length_);
+        pending_setlength_length_ = op.length;
+        break;
+      }
+
+      default:
+        NOTREACHED();
+        return;
+    }
+
+    CallbackEntry entry = pending_quota_check_callbacks_.front();
+    pending_quota_check_callbacks_.pop();
+    callbacks_.push(entry);
+  }
+}
+
 }  // namespace ppapi
 }  // namespace webkit