[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);
     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);
       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);
       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,
@@ skipping 193 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);
     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);
+  }

[kinuko, 2013/04/26 07:00:25]

Can we do this in SandboxMountPointProvider::CreateFileSystemOperation() and
make FSOC::set_quota_limit_type() private (if the value wouldn't/shouldn't be
changed after its creation)?

[tzik, 2013/04/26 07:17:59]

Done.

+
   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 288 matching lines @@
 }
 
 bool LocalFileSystemOperation::SetPendingOperationType(OperationType type) {
   if (pending_operation_ != kOperationNone)
     return false;
   pending_operation_ = type;
   return true;
 }
 
 }  // namespace fileapi