[Quota][FileAPI] Add quota policy to FileSystemOperationContext

webkit/fileapi/sandbox_mount_point_provider.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/sandbox_mount_point_provider.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 123 matching lines @@
 bool SandboxMountPointProvider::IsSandboxType(FileSystemType type) {
   return type == kFileSystemTypeTemporary ||
          type == kFileSystemTypePersistent ||
          type == kFileSystemTypeSyncable;
 }
 
 SandboxMountPointProvider::SandboxMountPointProvider(
     quota::QuotaManagerProxy* quota_manager_proxy,
     base::SequencedTaskRunner* file_task_runner,
     const base::FilePath& profile_path,
-    const FileSystemOptions& file_system_options)
+    const FileSystemOptions& file_system_options,
+    quota::SpecialStoragePolicy* special_storage_policy)
     : file_task_runner_(file_task_runner),
       profile_path_(profile_path),
       file_system_options_(file_system_options),
       enable_temporary_file_system_in_incognito_(false),
       sandbox_file_util_(
           new AsyncFileUtilAdapter(
               new ObfuscatedFileUtil(
                   profile_path.Append(kFileSystemDirectory)))),
       file_system_usage_cache_(new FileSystemUsageCache(file_task_runner)),
       quota_observer_(new SandboxQuotaObserver(
                       quota_manager_proxy,
                       file_task_runner,
                       sandbox_sync_file_util(),
                       file_system_usage_cache_.get())),
       enable_usage_tracking_(
           !CommandLine::ForCurrentProcess()->HasSwitch(
               kDisableUsageTracking)),
+      special_storage_policy_(special_storage_policy),
       weak_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
   // Set quota observers.
   UpdateObserverList::Source update_observers_src;
   AccessObserverList::Source access_observers_src;
 
   if (enable_usage_tracking_) {
     update_observers_src.AddObserver(quota_observer_.get(), file_task_runner_);
     access_observers_src.AddObserver(quota_observer_.get(), NULL);
   }
 
@@ skipping 153 matching lines @@
     operation_context->set_update_observers(syncable_update_observers_);
     operation_context->set_change_observers(syncable_change_observers_);
     operation_context->set_access_observers(access_observers_);
     return new sync_file_system::SyncableFileSystemOperation(
         context, operation_context.Pass());
   }
 
   // For regular sandboxed types.
   operation_context->set_update_observers(update_observers_);
   operation_context->set_access_observers(access_observers_);
+
+  if (special_storage_policy_ &&

[kinuko, 2013/04/26 07:27:37]

nit: I think you can also check this without passing special_storage_policy

context->quota_manager_proxy() &&
context->quota_manager_proxy()->IsStorageUnlimited(url.origin());

[tzik, 2013/04/26 07:36:27]

Done.

+      special_storage_policy_->IsStorageUnlimited(url.origin())) {
+    operation_context->set_quota_limit_type(quota::kQuotaLimitTypeUnlimited);
+  } else {
+    operation_context->set_quota_limit_type(quota::kQuotaLimitTypeLimited);
+  }
+
   return new LocalFileSystemOperation(context, operation_context.Pass());
 }
 
 scoped_ptr<webkit_blob::FileStreamReader>
 SandboxMountPointProvider::CreateFileStreamReader(
     const FileSystemURL& url,
     int64 offset,
     const base::Time& expected_modification_time,
     FileSystemContext* context) const {
   return scoped_ptr<webkit_blob::FileStreamReader>(
@@ skipping 302 matching lines @@
     FileSystemType type,
     FileSystemUsageCache* usage_cache) {
   base::PlatformFileError error = base::PLATFORM_FILE_OK;
   base::FilePath usage_cache_path = GetUsageCachePathForOriginAndType(
       file_util, origin, type, &error);
   if (error == base::PLATFORM_FILE_OK)
     usage_cache->IncrementDirty(usage_cache_path);
 }
 
 }  // namespace fileapi