[Quota][FileAPI] Add quota policy to FileSystemOperationContext

webkit/fileapi/local_file_system_operation.cc

 // Copyright (c) 2012 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/local_file_system_operation.h"
 
 #include "base/bind.h"
 #include "base/single_thread_task_runner.h"
 #include "base/time.h"
 #include "base/utf_string_conversions.h"
@@ skipping 313 matching lines @@
                                         const OpenFileCallback& callback) {
   DCHECK(SetPendingOperationType(kOperationOpenFile));
   scoped_ptr<LocalFileSystemOperation> deleter(this);
 
   peer_handle_ = peer_handle;
 
   if (file_flags & (
       (base::PLATFORM_FILE_ENUMERATE | base::PLATFORM_FILE_TEMPORARY |
        base::PLATFORM_FILE_HIDDEN))) {
     callback.Run(base::PLATFORM_FILE_ERROR_FAILED,
-                 base::PlatformFile(), base::ProcessHandle());
+                 base::kInvalidPlatformFileValue,
+                 base::kNullProcessHandle,
+                 quota::kQuotaLimitTypeLimited);
     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)) {
     base::PlatformFileError result = SetUp(url, OPERATION_MODE_WRITE);
     if (result != base::PLATFORM_FILE_OK) {
-      callback.Run(result, base::PlatformFile(), base::ProcessHandle());
+      callback.Run(result,
+                   base::kInvalidPlatformFileValue,
+                   base::kNullProcessHandle,
+                   quota::kQuotaLimitTypeLimited);
       return;
     }
   } else {
     base::PlatformFileError result = SetUp(url, OPERATION_MODE_READ);
     if (result != base::PLATFORM_FILE_OK) {
-      callback.Run(result, base::PlatformFile(), base::ProcessHandle());
+      callback.Run(result,
+                   base::kInvalidPlatformFileValue,
+                   base::kNullProcessHandle,
+                   quota::kQuotaLimitTypeLimited);
       return;
     }
   }
   GetUsageAndQuotaThenRunTask(
       url,
       base::Bind(&LocalFileSystemOperation::DoOpenFile,
                  base::Unretained(deleter.release()),
                  url, callback, file_flags),
       base::Bind(callback, base::PLATFORM_FILE_ERROR_FAILED,
                  base::kInvalidPlatformFileValue,
-                 base::kNullProcessHandle));
+                 base::kNullProcessHandle,
+                 quota::kQuotaLimitTypeLimited));
 }
 
 void LocalFileSystemOperation::NotifyCloseFile(const FileSystemURL& url) {
   // No particular task to do. This method is for remote file systems that
   // need synchronization with remote server.
   delete this;
 }
 
 // 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 182 matching lines @@
     const FileSystemURL& url,
     const base::Closure& task,
     const base::Closure& error_callback) {
   quota::QuotaManagerProxy* quota_manager_proxy =
       file_system_context()->quota_manager_proxy();
   if (!quota_manager_proxy ||
       !file_system_context()->GetQuotaUtil(url.type())) {
     // If we don't have the quota manager or the requested filesystem type
     // does not support quota, we should be able to let it go.
     operation_context()->set_allowed_bytes_growth(kint64max);
+    operation_context()->set_quota_limit_type(quota::kQuotaLimitTypeUnlimited);

[kinuko, 2013/04/26 06:44:21]

Looks like this is the primary change you want to make?

Can we check this in OpenFile() and bind the value to DidOpenFile() in
FileAPIMessageFilter, so that FS modules (which may not know anything about
quota policy) don't need to change DidOpenFile callback?

[tzik, 2013/04/26 06:55:11]

Done.

     task.Run();
     return;
   }
 
   DCHECK(quota_manager_proxy);
   DCHECK(quota_manager_proxy->quota_manager());
+  if (quota_manager_proxy->quota_manager()->IsStorageUnlimited(
+          url.origin(),
+          FileSystemTypeToQuotaStorageType(url.type()))) {
+    operation_context()->set_quota_limit_type(quota::kQuotaLimitTypeUnlimited);
+  } else {
+    operation_context()->set_quota_limit_type(quota::kQuotaLimitTypeLimited);
+  }
+
   quota_manager_proxy->quota_manager()->GetUsageAndQuota(
       url.origin(),
       FileSystemTypeToQuotaStorageType(url.type()),
       base::Bind(&LocalFileSystemOperation::DidGetUsageAndQuotaAndRunTask,
                  weak_factory_.GetWeakPtr(), task, error_callback));
 }
 
 void LocalFileSystemOperation::DidGetUsageAndQuotaAndRunTask(
     const base::Closure& task,
     const base::Closure& error_callback,
@@ skipping 231 matching lines @@
   callback.Run(rv);
 }
 
 void LocalFileSystemOperation::DidOpenFile(
     const OpenFileCallback& callback,
     base::PlatformFileError rv,
     base::PassPlatformFile file,
     bool unused) {
   if (rv == base::PLATFORM_FILE_OK)
     CHECK_NE(base::kNullProcessHandle, peer_handle_);
-  callback.Run(rv, file.ReleaseValue(), peer_handle_);
+  callback.Run(rv, file.ReleaseValue(),
+               peer_handle_,
+               operation_context()->quota_limit_type());
 }
 
 void LocalFileSystemOperation::DidCreateSnapshotFile(
     const SnapshotFileCallback& callback,
     base::PlatformFileError result,
     const base::PlatformFileInfo& file_info,
     const base::FilePath& platform_path,
     SnapshotFilePolicy snapshot_policy) {
   scoped_refptr<ShareableFileReference> file_ref;
   if (result == base::PLATFORM_FILE_OK &&
@@ skipping 36 matching lines @@
 }
 
 bool LocalFileSystemOperation::SetPendingOperationType(OperationType type) {
   if (pending_operation_ != kOperationNone)
     return false;
   pending_operation_ = type;
   return true;
 }
 
 }  // namespace fileapi