Pepper quota support

webkit/fileapi/file_system_operation.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/fileapi/file_system_operation.h"
 
 #include "base/time.h"
 #include "base/utf_string_conversions.h"
 #include "net/base/escape.h"
 #include "net/url_request/url_request_context.h"
 #include "webkit/fileapi/file_system_callback_dispatcher.h"
 #include "webkit/fileapi/file_system_context.h"
 #include "webkit/fileapi/file_system_file_util_proxy.h"
 #include "webkit/fileapi/file_system_operation_context.h"
 #include "webkit/fileapi/file_system_path_manager.h"
 #include "webkit/fileapi/file_system_quota_util.h"
 #include "webkit/fileapi/file_system_types.h"
 #include "webkit/fileapi/file_system_util.h"
 #include "webkit/fileapi/file_writer_delegate.h"
 #include "webkit/fileapi/local_file_system_file_util.h"
 #include "webkit/fileapi/quota_file_util.h"
 #include "webkit/quota/quota_types.h"
 
 namespace fileapi {
 
+namespace {
+
+void SetQuotaForOperation(FileSystemOperationContext* op_context,
+                          const GURL& origin_url,
+                          quota::QuotaStatusCode status,
+                          int64 usage, int64 quota) {
+  if (op_context->file_system_context()->IsStorageUnlimited(origin_url) ||
+      quota == QuotaFileUtil::kNoLimit) {
+    op_context->set_allowed_bytes_growth(QuotaFileUtil::kNoLimit);
+  } else {
+    int64 avail = quota - usage;
+    if (status != quota::kQuotaStatusOk || avail < 0)
+      avail = 0;
+    op_context->set_allowed_bytes_growth(avail);
+  }
+}
+
+}  // namespace
+
 FileSystemOperation::FileSystemOperation(
     FileSystemCallbackDispatcher* dispatcher,
     scoped_refptr<base::MessageLoopProxy> proxy,
     FileSystemContext* file_system_context,
     FileSystemFileUtil* file_system_file_util)
     : proxy_(proxy),
       dispatcher_(dispatcher),
       file_system_operation_context_(
           file_system_context, file_system_file_util),
-      callback_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
+      callback_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
+      is_write_operation_(false) {
+  DCHECK(file_system_context);
   DCHECK(dispatcher);
 #ifndef NDEBUG
   pending_operation_ = kOperationNone;
 #endif
 }
 
 FileSystemOperation::~FileSystemOperation() {
   if (file_writer_delegate_.get())
     FileSystemFileUtilProxy::Close(
         file_system_operation_context_,
@@ skipping 108 matching lines @@
   file_system_operation_context_.set_dest_type(dest_type);
   file_system_operation_context_.set_src_virtual_path(virtual_path_0);
   file_system_operation_context_.set_dest_virtual_path(virtual_path_1);
   if (!file_system_operation_context_.src_file_system_file_util())
     file_system_operation_context_.set_src_file_system_file_util(
         src_file_system_file_util);
   if (!file_system_operation_context_.dest_file_system_file_util())
     file_system_operation_context_.set_dest_file_system_file_util(
         dest_file_system_file_util);
 
-  GetUsageAndQuotaThenCallback(dest_origin_url, callback_factory_.NewCallback(
-      &FileSystemOperation::DelayedCopyForQuota));
+  GetUsageAndQuotaThenCallback(dest_origin_url, dest_type,
+      callback_factory_.NewCallback(&FileSystemOperation::DelayedCopyForQuota));
 }
 
 void FileSystemOperation::DelayedCopyForQuota(quota::QuotaStatusCode status,
                                               int64 usage, int64 quota) {
-  if (file_system_context()->IsStorageUnlimited(
-          file_system_operation_context()->dest_origin_url()) ||
-      quota == QuotaFileUtil::kNoLimit) {
-    file_system_operation_context_.set_allowed_bytes_growth(
-        QuotaFileUtil::kNoLimit);
-  } else {
-    file_system_operation_context_.set_allowed_bytes_growth(quota - usage);
-  }
+  SetQuotaForOperation(&file_system_operation_context_,
+                       file_system_operation_context_.dest_origin_url(),
+                       status, usage, quota);
   FileSystemFileUtilProxy::Copy(
       file_system_operation_context_,
       proxy_,
       file_system_operation_context_.src_virtual_path(),
       file_system_operation_context_.dest_virtual_path(),
       callback_factory_.NewCallback(
         &FileSystemOperation::DidFinishFileOperation));
 }
 
 void FileSystemOperation::Move(const GURL& src_path,
@@ skipping 25 matching lines @@
   file_system_operation_context_.set_dest_type(dest_type);
   file_system_operation_context_.set_src_virtual_path(virtual_path_0);
   file_system_operation_context_.set_dest_virtual_path(virtual_path_1);
   if (!file_system_operation_context_.src_file_system_file_util())
     file_system_operation_context_.set_src_file_system_file_util(
         src_file_system_file_util);
   if (!file_system_operation_context_.dest_file_system_file_util())
     file_system_operation_context_.set_dest_file_system_file_util(
         dest_file_system_file_util);
 
-  GetUsageAndQuotaThenCallback(dest_origin_url, callback_factory_.NewCallback(
-      &FileSystemOperation::DelayedMoveForQuota));
+  GetUsageAndQuotaThenCallback(dest_origin_url, dest_type,
+      callback_factory_.NewCallback(&FileSystemOperation::DelayedMoveForQuota));
 }
 
 void FileSystemOperation::DelayedMoveForQuota(quota::QuotaStatusCode status,
                                               int64 usage, int64 quota) {
-  if (file_system_context()->IsStorageUnlimited(
-          file_system_operation_context()->dest_origin_url()) ||
-      quota == QuotaFileUtil::kNoLimit) {
-    file_system_operation_context_.set_allowed_bytes_growth(
-        QuotaFileUtil::kNoLimit);
-  } else {
-    file_system_operation_context_.set_allowed_bytes_growth(quota - usage);
-  }
+  SetQuotaForOperation(&file_system_operation_context_,
+                       file_system_operation_context_.dest_origin_url(),
+                       status, usage, quota);
   FileSystemFileUtilProxy::Move(
       file_system_operation_context_,
       proxy_,
       file_system_operation_context_.src_virtual_path(),
       file_system_operation_context_.dest_virtual_path(),
       callback_factory_.NewCallback(
         &FileSystemOperation::DidFinishFileOperation));
 }
 
 void FileSystemOperation::DirectoryExists(const GURL& path) {
@@ skipping 149 matching lines @@
   file_system_operation_context_.set_src_virtual_path(virtual_path);
   if (!file_system_operation_context_.src_file_system_file_util())
     file_system_operation_context_.set_src_file_system_file_util(
         file_system_file_util);
   DCHECK(blob_url.is_valid());
   file_writer_delegate_.reset(new FileWriterDelegate(this, offset, proxy_));
   blob_request_.reset(
       new net::URLRequest(blob_url, file_writer_delegate_.get()));
   blob_request_->set_context(url_request_context);
 
-  GetUsageAndQuotaThenCallback(origin_url, callback_factory_.NewCallback(
+  GetUsageAndQuotaThenCallback(origin_url, type, callback_factory_.NewCallback(
       &FileSystemOperation::DelayedWriteForQuota));
 }
 
 void FileSystemOperation::DelayedWriteForQuota(quota::QuotaStatusCode status,
                                                int64 usage, int64 quota) {
-  if (file_system_context()->IsStorageUnlimited(
-          file_system_operation_context()->dest_origin_url()) ||
-      quota == QuotaFileUtil::kNoLimit) {
-    file_system_operation_context_.set_allowed_bytes_growth(
-        QuotaFileUtil::kNoLimit);
-  } else {
-    file_system_operation_context_.set_allowed_bytes_growth(quota - usage);
-  }
-  FileSystemFileUtilProxy::CreateOrOpen(
+  SetQuotaForOperation(&file_system_operation_context_,
+                       file_system_operation_context_.src_origin_url(),
+                       status, usage, quota);
+  FileSystemFileUtilProxy::CreateOrOpenAndQuerySize(
       file_system_operation_context_,
       proxy_,
       file_system_operation_context_.src_virtual_path(),
       base::PLATFORM_FILE_OPEN | base::PLATFORM_FILE_WRITE |
           base::PLATFORM_FILE_ASYNC,
       callback_factory_.NewCallback(
           &FileSystemOperation::OnFileOpenedForWrite));
 }
 
 void FileSystemOperation::Truncate(const GURL& path, int64 length) {
@@ skipping 11 matching lines @@
     return;
   }
   file_system_operation_context_.set_src_origin_url(origin_url);
   file_system_operation_context_.set_src_type(type);
   file_system_operation_context_.set_src_virtual_path(virtual_path);
   if (!file_system_operation_context_.src_file_system_file_util())
     file_system_operation_context_.set_src_file_system_file_util(
         file_system_file_util);
   length_ = length;
 
-  GetUsageAndQuotaThenCallback(origin_url, callback_factory_.NewCallback(
+  GetUsageAndQuotaThenCallback(origin_url, type, callback_factory_.NewCallback(
       &FileSystemOperation::DelayedTruncateForQuota));
 }
 
 void FileSystemOperation::DelayedTruncateForQuota(quota::QuotaStatusCode status,
                                                   int64 usage, int64 quota) {
-  if (file_system_context()->IsStorageUnlimited(
-          file_system_operation_context()->dest_origin_url()) ||
-      quota == QuotaFileUtil::kNoLimit) {
-    file_system_operation_context_.set_allowed_bytes_growth(
-        QuotaFileUtil::kNoLimit);
-  } else {
-    file_system_operation_context_.set_allowed_bytes_growth(quota - usage);
-  }
+  SetQuotaForOperation(&file_system_operation_context_,
+                       file_system_operation_context_.src_origin_url(),
+                       status, usage, quota);
   FileSystemFileUtilProxy::Truncate(
       file_system_operation_context_,
       proxy_,
       file_system_operation_context_.src_virtual_path(),
       length_, callback_factory_.NewCallback(
           &FileSystemOperation::DidFinishFileOperation));
 }
 
 void FileSystemOperation::TouchFile(const GURL& path,
                                     const base::Time& last_access_time,
@@ skipping 32 matching lines @@
 #endif
 
   peer_handle_ = peer_handle;
   FilePath virtual_path;
   GURL origin_url;
   FileSystemType type;
   FileSystemFileUtil* file_system_file_util;
   if (file_flags & (
       (base::PLATFORM_FILE_ENUMERATE | base::PLATFORM_FILE_TEMPORARY |
        base::PLATFORM_FILE_HIDDEN))) {
+    dispatcher_->DidFail(base::PLATFORM_FILE_ERROR_INVALID_OPERATION);
     delete this;
     return;
   }
   if (file_flags &
       (base::PLATFORM_FILE_CREATE | base::PLATFORM_FILE_OPEN_ALWAYS |
        base::PLATFORM_FILE_CREATE_ALWAYS | base::PLATFORM_FILE_OPEN_TRUNCATED |
        base::PLATFORM_FILE_WRITE | base::PLATFORM_FILE_EXCLUSIVE_WRITE |
        base::PLATFORM_FILE_DELETE_ON_CLOSE |
        base::PLATFORM_FILE_WRITE_ATTRIBUTES)) {
     if (!VerifyFileSystemPathForWrite(path, true /* create */, &origin_url,
         &type, &virtual_path, &file_system_file_util)) {
       delete this;
       return;
     }
   } else {
     if (!VerifyFileSystemPathForRead(path, &origin_url, &type, &virtual_path,
         &file_system_file_util)) {
       delete this;
       return;
     }
   }
   file_system_operation_context_.set_src_origin_url(origin_url);
   file_system_operation_context_.set_src_type(type);
   if (!file_system_operation_context_.src_file_system_file_util())
     file_system_operation_context_.set_src_file_system_file_util(
         file_system_file_util);
-  FileSystemFileUtilProxy::CreateOrOpen(
+  FileSystemFileUtilProxy::CreateOrOpenAndQuerySize(
       file_system_operation_context_,
       proxy_,
       virtual_path,
       file_flags,
       callback_factory_.NewCallback(
           &FileSystemOperation::DidOpenFile));
 }
 
 // We can only get here on a write or truncate that's not yet completed.
 // We don't support cancelling any other operation at this time.
@@ skipping 24 matching lines @@
     // cancel_operation so that when the truncate returns, it can see that it's
     // been cancelled, report it, and report that the cancel has succeeded.
     DCHECK(!cancel_operation_.get());
     cancel_operation_.swap(cancel_operation);
   }
 }
 
 // TODO(ericu): Obfuscation integration.
 bool FileSystemOperation::GetUsageAndQuotaThenCallback(
     const GURL& origin_url,
+    FileSystemType type,
     quota::QuotaManager::GetUsageAndQuotaCallback* callback) {
   quota::QuotaManagerProxy* quota_manager_proxy =
       file_system_context()->quota_manager_proxy();
   if (quota_manager_proxy && quota_manager_proxy->quota_manager() &&
       file_system_operation_context_.src_type() != kFileSystemTypeExternal) {
     quota_manager_proxy->quota_manager()->GetUsageAndQuota(
-        file_system_operation_context_.src_origin_url(),
-        FileSystemTypeToQuotaStorageType(
-            file_system_operation_context_.src_type()),
+        origin_url,
+        FileSystemTypeToQuotaStorageType(type),
         callback);
   } else {
     if (file_system_context()->IsStorageUnlimited(origin_url)) {
       callback->Run(quota::kQuotaStatusOk, 0, QuotaFileUtil::kNoLimit);
       delete callback;
     } else {
       dispatcher_->DidFail(base::PLATFORM_FILE_ERROR_NO_SPACE);
       delete callback;
       return false;
     }
@@ skipping 117 matching lines @@
   if (rv == base::PLATFORM_FILE_OK)
     dispatcher_->DidSucceed();
   else
     dispatcher_->DidFail(rv);
   delete this;
 }
 
 void FileSystemOperation::DidOpenFile(
     base::PlatformFileError rv,
     base::PassPlatformFile file,
-    bool unused) {
+    bool unused,
+    int64 file_size) {
   if (rv == base::PLATFORM_FILE_OK)
-    dispatcher_->DidOpenFile(file.ReleaseValue(), peer_handle_);
+    dispatcher_->DidOpenFile(file.ReleaseValue(), peer_handle_, file_size);
   else
     dispatcher_->DidFail(rv);
   delete this;
 }
 
 void FileSystemOperation::OnFileOpenedForWrite(
     base::PlatformFileError rv,
     base::PassPlatformFile file,
-    bool created) {
+    bool created,
+    int64 file_size) {
   if (base::PLATFORM_FILE_OK != rv) {
     dispatcher_->DidFail(rv);
     delete this;
     return;
   }
-  file_writer_delegate_->Start(file.ReleaseValue(), blob_request_.get());
+  file_writer_delegate_->Start(file.ReleaseValue(), file_size,
+                               blob_request_.get());
 }
 
 bool FileSystemOperation::VerifyFileSystemPathForRead(
     const GURL& path, GURL* origin_url, FileSystemType* type,
     FilePath* virtual_path, FileSystemFileUtil** file_system_file_util) {
-
-  // If we have no context, we just allow any operations, for testing.
-  // TODO(ericu): Revisit this hack for security.
-  if (!file_system_context()) {
-#ifdef OS_WIN
-    // On Windows, the path will look like /C:/foo/bar; we need to remove the
-    // leading slash to make it valid.  But if it's empty, we shouldn't do
-    // anything.
-    std::string temp = UnescapeURLComponent(path.path(),
-        UnescapeRule::SPACES | UnescapeRule::URL_SPECIAL_CHARS);
-    if (temp.size())
-      temp = temp.substr(1);
-    *virtual_path = FilePath(UTF8ToWide(temp)).NormalizeWindowsPathSeparators();
-#else
-    *virtual_path = FilePath(path.path());
-#endif
-    *type = file_system_operation_context_.src_type();
-    *origin_url = file_system_operation_context_.src_origin_url();
-    *file_system_file_util = NULL;
-    return true;
-  }
+  DCHECK(file_system_context());
 
   // We may want do more checks, but for now it just checks if the given
   // URL is valid.
   if (!CrackFileSystemURL(path, origin_url, type, virtual_path)) {
     dispatcher_->DidFail(base::PLATFORM_FILE_ERROR_INVALID_URL);
     return false;
   }
   if (!file_system_context()->path_manager()->IsAccessAllowed(
       *origin_url, *type, *virtual_path)) {
     dispatcher_->DidFail(base::PLATFORM_FILE_ERROR_SECURITY);
@@ skipping 62 matching lines @@
   if (create && file_system_context()->path_manager()->IsRestrictedFileName(
           *type, virtual_path->BaseName())) {
     dispatcher_->DidFail(base::PLATFORM_FILE_ERROR_SECURITY);
     return false;
   }
   DCHECK(file_system_file_util);
   *file_system_file_util =
       file_system_context()->path_manager()->GetFileSystemFileUtil(*type);
   DCHECK(*file_system_file_util);
 
+  is_write_operation_ = true;

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

Seems like an odd place to be setting this flag, also i don't see where this
flag is used?

   return true;
 }
 
 }  // namespace fileapi