Change how the quota system computes the total poolsize for temporary storage

storage/browser/quota/quota_manager.cc

 // Copyright 2013 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 "storage/browser/quota/quota_manager.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
 #include <functional>
 #include <limits>
 #include <memory>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/files/file_util.h"
 #include "base/macros.h"
 #include "base/metrics/histogram.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/profiler/scoped_tracker.h"
 #include "base/sequenced_task_runner.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/sys_info.h"
 #include "base/task_runner_util.h"
+#include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "base/trace_event/trace_event.h"
 #include "net/base/url_util.h"
 #include "storage/browser/quota/client_usage_tracker.h"
 #include "storage/browser/quota/quota_manager_proxy.h"
 #include "storage/browser/quota/quota_temporary_storage_evictor.h"
 #include "storage/browser/quota/storage_monitor.h"
 #include "storage/browser/quota/usage_tracker.h"
 #include "storage/common/quota/quota_types.h"
 
 #define UMA_HISTOGRAM_MBYTES(name, sample)          \
   UMA_HISTOGRAM_CUSTOM_COUNTS(                      \
       (name), static_cast<int>((sample) / kMBytes), \
       1, 10 * 1024 * 1024 /* 10TB */, 100)
 
 namespace storage {
 
 namespace {
 
 const int64_t kMBytes = 1024 * 1024;
 const int kMinutesInMilliSeconds = 60 * 1000;
-
 const int64_t kReportHistogramInterval = 60 * 60 * 1000;  // 1 hour
-const double kTemporaryQuotaRatioToAvail = 1.0 / 3.0;  // 33%
 
 }  // namespace
 
-// Arbitrary for now, but must be reasonably small so that
-// in-memory databases can fit.
-// TODO(kinuko): Refer SysInfo::AmountOfPhysicalMemory() to determine this.
-const int64_t QuotaManager::kIncognitoDefaultQuotaLimit = 100 * kMBytes;
-
 const int64_t QuotaManager::kNoLimit = INT64_MAX;
 
+// TODO(michaeln): REMOVE
 const int QuotaManager::kPerHostTemporaryPortion = 5;  // 20%
 
 // Cap size for per-host persistent quota determined by the histogram.
 // This is a bit lax value because the histogram says nothing about per-host
 // persistent storage usage and we determined by global persistent storage
 // usage that is less than 10GB for almost all users.
 const int64_t QuotaManager::kPerHostPersistentQuotaLimit = 10 * 1024 * kMBytes;
 
+// TODO(michaeln): REMOVE
+int64_t QuotaManager::kMinimumPreserveForSystem = 1024 * kMBytes;
+
 const char QuotaManager::kDatabaseName[] = "QuotaManager";
 
 const int QuotaManager::kThresholdOfErrorsToBeBlacklisted = 3;
-
-// Preserve kMinimumPreserveForSystem disk space for system book-keeping
-// when returning the quota to unlimited apps/extensions.
-// TODO(kinuko): This should be like 10% of the actual disk space.
-// For now we simply use a constant as getting the disk size needs
-// platform-dependent code. (http://crbug.com/178976)
-int64_t QuotaManager::kMinimumPreserveForSystem = 1024 * kMBytes;
-
 const int QuotaManager::kEvictionIntervalInMilliSeconds =
     30 * kMinutesInMilliSeconds;
 
 const char QuotaManager::kTimeBetweenRepeatedOriginEvictionsHistogram[] =
     "Quota.TimeBetweenRepeatedOriginEvictions";
 const char QuotaManager::kEvictedOriginAccessedCountHistogram[] =
     "Quota.EvictedOriginAccessCount";
 const char QuotaManager::kEvictedOriginTimeSinceAccessHistogram[] =
     "Quota.EvictedOriginTimeSinceAccess";
 
@@ skipping 135 matching lines @@
 }
 
 bool UpdateModifiedTimeOnDBThread(const GURL& origin,
                                   StorageType type,
                                   base::Time modified_time,
                                   QuotaDatabase* database) {
   DCHECK(database);
   return database->SetOriginLastModifiedTime(origin, type, modified_time);
 }
 
-int64_t CalculateTemporaryGlobalQuota(int64_t global_limited_usage,
-                                      int64_t available_space) {
-  DCHECK_GE(global_limited_usage, 0);
-  int64_t avail_space = available_space;
-  if (avail_space <
-      std::numeric_limits<int64_t>::max() - global_limited_usage) {
-    // We basically calculate the temporary quota by
-    // [available_space + space_used_for_temp] * kTempQuotaRatio,
-    // but make sure we'll have no overflow.
-    avail_space += global_limited_usage;
-  }
-  int64_t pool_size = avail_space * kTemporaryQuotaRatioToAvail;
-  UMA_HISTOGRAM_MBYTES("Quota.GlobalTemporaryPoolSize", pool_size);
-  return pool_size;
-}
-
-void DispatchTemporaryGlobalQuotaCallback(
-    const QuotaCallback& callback,
-    QuotaStatusCode status,
-    const UsageAndQuota& usage_and_quota) {
-  if (status != kQuotaStatusOk) {
-    callback.Run(status, 0);
-    return;
-  }
-
-  callback.Run(status, CalculateTemporaryGlobalQuota(
-      usage_and_quota.global_limited_usage,
-      usage_and_quota.available_disk_space));
-}
-
-int64_t CalculateQuotaWithDiskSpace(int64_t available_disk_space,
-                                    int64_t usage,
-                                    int64_t quota) {
-  if (available_disk_space < QuotaManager::kMinimumPreserveForSystem) {
-    LOG(WARNING)
-        << "Running out of disk space for profile."
-        << " QuotaManager starts forbidding further quota consumption.";
-    return usage;
-  }
-
-  if (quota < usage) {
-    // No more space; cap the quota to the current usage.
-    return usage;
-  }
-
-  available_disk_space -= QuotaManager::kMinimumPreserveForSystem;
-  if (available_disk_space < quota - usage)
-    return available_disk_space + usage;
-
-  return quota;
-}
-
-int64_t CalculateTemporaryHostQuota(int64_t host_usage,
-                                    int64_t global_quota,
-                                    int64_t global_limited_usage) {
-  DCHECK_GE(global_limited_usage, 0);
-  int64_t host_quota = global_quota / QuotaManager::kPerHostTemporaryPortion;
-  if (global_limited_usage > global_quota)
-    host_quota = std::min(host_quota, host_usage);
-  return host_quota;
-}
-
+// TODO: cleanup??
 void DispatchUsageAndQuotaForWebApps(
     StorageType type,
     bool is_incognito,
     bool is_unlimited,
-    bool can_query_disk_size,
+    int64_t cached_usage_for_incognito,
     const QuotaManager::GetUsageAndQuotaCallback& callback,
     QuotaStatusCode status,
-    const UsageAndQuota& usage_and_quota) {
+    const XUsageAndQuota& usage_and_quota) {
+  DCHECK(type == kStorageTypeTemporary ||  type == kStorageTypePersistent ||
+         type == kStorageTypeSyncable);
   if (status != kQuotaStatusOk) {
     callback.Run(status, 0, 0);
     return;
   }
 
-  int64_t usage = usage_and_quota.usage;
-  int64_t quota = usage_and_quota.quota;
-
-  if (type == kStorageTypeTemporary && !is_unlimited) {
-    quota = CalculateTemporaryHostQuota(
-        usage, quota, usage_and_quota.global_limited_usage);
+  //int64_t available = usage_and_quota.available_disk_space;
+  if (is_incognito) {
+    //int64_t incognito_space_avalable = pool_size -
+    //    cached_usage_for_incognito;
+    //available = std::max(INT64_C(0), incognito_space_avalable);
   }
 
-  if (is_incognito) {
-    quota = std::min(quota, QuotaManager::kIncognitoDefaultQuotaLimit);
-    callback.Run(status, usage, quota);
-    return;
-  }
+  // For persistent and syncable, usage_and_quota.quota contains a
+  // per-host value. For the temporary type, usage_and_quota.quota
+  // contains the shared poolsize. Hoever, if the origin is unlimited,
+  // it will contain kNoLimit which is INT64_MAX.
+  int64_t desired_host_quota = usage_and_quota.quota;
+  if (type == kStorageTypeTemporary)
+    desired_host_quota /= QuotaManager::kPerHostTemporaryPortion;
 
-  // For apps with unlimited permission or can_query_disk_size is true (and not
-  // in incognito mode).
-  // We assume we can expose the actual disk size for them and cap the quota by
-  // the available disk space.
-  if (is_unlimited || can_query_disk_size) {
-    quota = CalculateQuotaWithDiskSpace(
-        usage_and_quota.available_disk_space,
-        usage, quota);
-  }
+  int min_preserve = !is_unlimited && (type == kStorageTypeTemporary) ?
+      desired_host_quota : QuotaManager::kMinimumPreserveForSystem;
 
-  callback.Run(status, usage, quota);
+  // Constrain the desired |host_quota| to something that fits.
+  // If available space is too low, cap usage at current levels.
+  // If it's close to being too low, cap growth to avoid it getting too low.
+  // We define "too low" as not enough room for another hosts
+  // nominal desired amount of data.
+  // Note: for incognito, available space is a number based on
+  // system memory.
+  int64_t host_quota = std::min(
+      desired_host_quota,
+      usage_and_quota.usage +
+          std::max(INT64_C(0),
+                   usage_and_quota.available_disk_space - min_preserve));
 
-  if (type == kStorageTypeTemporary && !is_unlimited)
-    UMA_HISTOGRAM_MBYTES("Quota.QuotaForOrigin", quota);
+  callback.Run(status, usage_and_quota.usage, host_quota);
+  if (type == kStorageTypeTemporary && !is_incognito && !is_unlimited)
+    UMA_HISTOGRAM_MBYTES("Quota.QuotaForOrigin", host_quota);
 }
 
 }  // namespace
 
-UsageAndQuota::UsageAndQuota()
+XUsageAndQuota::XUsageAndQuota()
     : usage(0),
       global_limited_usage(0),
       quota(0),
       available_disk_space(0) {
 }
 
-UsageAndQuota::UsageAndQuota(int64_t usage,
+XUsageAndQuota::XUsageAndQuota(int64_t usage,
                              int64_t global_limited_usage,
                              int64_t quota,
                              int64_t available_disk_space)
     : usage(usage),
       global_limited_usage(global_limited_usage),
       quota(quota),
       available_disk_space(available_disk_space) {}
 
+// TODO: cleanup???
 class UsageAndQuotaCallbackDispatcher
     : public QuotaTask,
       public base::SupportsWeakPtr<UsageAndQuotaCallbackDispatcher> {
  public:
   explicit UsageAndQuotaCallbackDispatcher(QuotaManager* manager)
       : QuotaTask(manager),
         has_usage_(false),
         has_global_limited_usage_(false),
         has_quota_(false),
         has_available_disk_space_(false),
         status_(kQuotaStatusUnknown),
         usage_and_quota_(-1, -1, -1, -1),
         waiting_callbacks_(1) {}
 
   ~UsageAndQuotaCallbackDispatcher() override {}
 
-  void WaitForResults(const QuotaManager::UsageAndQuotaCallback& callback) {
+  void WaitForResults(const QuotaManager::XUsageAndQuotaCallback& callback) {
     callback_ = callback;
     Start();
   }
 
   void set_usage(int64_t usage) {
     usage_and_quota_.usage = usage;
     has_usage_ = true;
   }
 
   void set_global_limited_usage(int64_t global_limited_usage) {
@@ skipping 33 matching lines @@
                       AsWeakPtr());
   }
 
   QuotaCallback GetAvailableSpaceCallback() {
     ++waiting_callbacks_;
     has_available_disk_space_ = true;
     return base::Bind(&UsageAndQuotaCallbackDispatcher::DidGetAvailableSpace,
                       AsWeakPtr());
   }
 
+  TemporaryStorageConfigurationCallback GetTempStorageConfigCallback() {
+    ++waiting_callbacks_;
+    return base::Bind(&UsageAndQuotaCallbackDispatcher::DidGetTempStorageConfig,
+                      AsWeakPtr());
+  }
+
  private:
   void DidGetHostUsage(int64_t usage) {
     if (status_ == kQuotaStatusUnknown)
       status_ = kQuotaStatusOk;
     usage_and_quota_.usage = usage;
     CheckCompleted();
   }
 
   void DidGetGlobalLimitedUsage(int64_t limited_usage) {
     if (status_ == kQuotaStatusUnknown)
@@ skipping 14 matching lines @@
     TRACE_EVENT0(
         "io", "UsageAndQuotaCallbackDispatcher::DidGetAvailableSpace");
 
     DCHECK_GE(space, 0);
     if (status_ == kQuotaStatusUnknown || status_ == kQuotaStatusOk)
       status_ = status;
     usage_and_quota_.available_disk_space = space;
     CheckCompleted();
   }
 
+  void DidGetTempStorageConfig(const TemporaryStorageConfiguration& config) {
+    storage_config_ = config;
+    CheckCompleted();
+  }
+
   void Run() override {
     // We initialize waiting_callbacks to 1 so that we won't run
     // the completion callback until here even some of the callbacks
     // are dispatched synchronously.
     CheckCompleted();
   }
 
   void Aborted() override {
-    callback_.Run(kQuotaErrorAbort, UsageAndQuota());
+    callback_.Run(kQuotaErrorAbort, XUsageAndQuota());
     DeleteSoon();
   }
 
   void Completed() override {
     // crbug.com/349708
     TRACE_EVENT0("io", "UsageAndQuotaCallbackDispatcher::Completed");
 
     DCHECK(!has_usage_ || usage_and_quota_.usage >= 0);
     DCHECK(!has_global_limited_usage_ ||
            usage_and_quota_.global_limited_usage >= 0);
@@ skipping 10 matching lines @@
       CallCompleted();
   }
 
   // For sanity checks, they're checked only when DCHECK is on.
   bool has_usage_;
   bool has_global_limited_usage_;
   bool has_quota_;
   bool has_available_disk_space_;
 
   QuotaStatusCode status_;
-  UsageAndQuota usage_and_quota_;
-  QuotaManager::UsageAndQuotaCallback callback_;
+  XUsageAndQuota usage_and_quota_;
+  TemporaryStorageConfiguration storage_config_;
+  QuotaManager::XUsageAndQuotaCallback callback_;
   int waiting_callbacks_;
 
   DISALLOW_COPY_AND_ASSIGN(UsageAndQuotaCallbackDispatcher);
 };
 
 class QuotaManager::GetUsageInfoTask : public QuotaTask {
  public:
   GetUsageInfoTask(
       QuotaManager* manager,
       const GetUsageInfoCallback& callback)
@@ skipping 344 matching lines @@
   OriginInfoTableEntries entries_;
 };
 
 // QuotaManager ---------------------------------------------------------------
 
 QuotaManager::QuotaManager(
     bool is_incognito,
     const base::FilePath& profile_path,
     const scoped_refptr<base::SingleThreadTaskRunner>& io_thread,
     const scoped_refptr<base::SequencedTaskRunner>& db_thread,
-    const scoped_refptr<SpecialStoragePolicy>& special_storage_policy)
+    const scoped_refptr<SpecialStoragePolicy>& special_storage_policy,
+    GetTemporaryStorageConfigurationFunc get_config_function)
     : is_incognito_(is_incognito),
       profile_path_(profile_path),
       proxy_(new QuotaManagerProxy(this, io_thread)),
       db_disabled_(false),
       eviction_disabled_(false),
+      get_config_function_(get_config_function),
+      get_config_task_runner_(base::ThreadTaskRunnerHandle::Get()),
       io_thread_(io_thread),
       db_thread_(db_thread),
       is_getting_eviction_origin_(false),
-      temporary_quota_initialized_(false),
-      temporary_quota_override_(-1),
       special_storage_policy_(special_storage_policy),
       get_volume_info_fn_(&QuotaManager::GetVolumeInfo),
       storage_monitor_(new StorageMonitor(this)),
-      weak_factory_(this) {}
+      weak_factory_(this) {
+  // Reset to ensure we refresh the config the first times it's accessed.
+  storage_config_.refresh_interval = base::TimeDelta();
+}
+
+void QuotaManager::SetTemporaryStorageConfiguration(
+    const TemporaryStorageConfiguration& config) {
+  storage_config_ = config;
+  storage_config_timestamp_ = base::TimeTicks::Now();
+}
 
 void QuotaManager::GetUsageInfo(const GetUsageInfoCallback& callback) {
   LazyInitialize();
   GetUsageInfoTask* get_usage_info = new GetUsageInfoTask(this, callback);
   get_usage_info->Start();
 }
 
 void QuotaManager::GetUsageAndQuotaForWebApps(
     const GURL& origin,
     StorageType type,
     const GetUsageAndQuotaCallback& callback) {
   // TODO(pkasting): Remove ScopedTracker below once crbug.com/477117 is fixed.
   tracked_objects::ScopedTracker tracking_profile(
       FROM_HERE_WITH_EXPLICIT_FUNCTION(
           "477117 QuotaManager::GetUsageAndQuotaForWebApps"));
   if (type != kStorageTypeTemporary &&
       type != kStorageTypePersistent &&
       type != kStorageTypeSyncable) {
     callback.Run(kQuotaErrorNotSupported, 0, 0);
     return;
   }
+  if (is_incognito_ && type != kStorageTypeTemporary) {
+    callback.Run(kQuotaErrorNotSupported, 0, 0);
+    return;
+  }
 
   DCHECK(origin == origin.GetOrigin());
   LazyInitialize();
 
-  bool unlimited = IsStorageUnlimited(origin, type);
-  bool can_query_disk_size = CanQueryDiskSize(origin);
+  bool is_unlimited = IsStorageUnlimited(origin, type);
 
   UsageAndQuotaCallbackDispatcher* dispatcher =
       new UsageAndQuotaCallbackDispatcher(this);
 
-  if (unlimited) {
+  if (is_unlimited) {
     dispatcher->set_quota(kNoLimit);
   } else {
     if (type == kStorageTypeTemporary) {
-      GetUsageTracker(type)->GetGlobalLimitedUsage(
-          dispatcher->GetGlobalLimitedUsageCallback());
       GetTemporaryGlobalQuota(dispatcher->GetQuotaCallback());
     } else if (type == kStorageTypePersistent) {
       GetPersistentHostQuota(net::GetHostOrSpecFromURL(origin),
                              dispatcher->GetQuotaCallback());
     } else {
       dispatcher->set_quota(kSyncableStorageDefaultHostQuota);
     }
   }
 
-  DCHECK(GetUsageTracker(type));
   GetUsageTracker(type)->GetHostUsage(net::GetHostOrSpecFromURL(origin),
                                       dispatcher->GetHostUsageCallback());
 
-  if (!is_incognito_ && (unlimited || can_query_disk_size))
-    GetAvailableSpace(dispatcher->GetAvailableSpaceCallback());
+  int64_t cached_usage_for_incognito = 0;
+  if (!is_incognito_) {
+    xGetAvailableSpace(dispatcher->GetAvailableSpaceCallback());
+  } else {
+    cached_usage_for_incognito = GetUsageTracker(type)->GetCachedUsage();
+  }
 
   dispatcher->WaitForResults(base::Bind(
       &DispatchUsageAndQuotaForWebApps,
-      type, is_incognito_, unlimited, can_query_disk_size,
-      callback));
+      type, is_incognito_, is_unlimited,
+      cached_usage_for_incognito, callback));
 }
 
 void QuotaManager::GetUsageAndQuota(
     const GURL& origin, StorageType type,
     const GetUsageAndQuotaCallback& callback) {
   DCHECK(origin == origin.GetOrigin());
 
   if (IsStorageUnlimited(origin, type)) {
     callback.Run(kQuotaStatusOk, 0, kNoLimit);
     return;
@@ skipping 61 matching lines @@
   if (host.empty() || clients_.empty()) {
     callback.Run(kQuotaStatusOk);
     return;
   }
 
   HostDataDeleter* deleter =
       new HostDataDeleter(this, host, type, quota_client_mask, callback);
   deleter->Start();
 }
 
-void QuotaManager::GetAvailableSpace(const AvailableSpaceCallback& callback) {
+void QuotaManager::xGetAvailableSpace(const AvailableSpaceCallback& callback) {
   if (!available_space_callbacks_.Add(callback))
     return;
   // crbug.com/349708
   TRACE_EVENT0("io", "QuotaManager::GetAvailableSpace");
 
-  PostTaskAndReplyWithResult(
+  // TODO: if (incognito) return poolsize - globalusage;
+  base::PostTaskAndReplyWithResult(
       db_thread_.get(),
       FROM_HERE,
       base::Bind(&QuotaManager::CallGetAmountOfFreeDiskSpace,
                  get_volume_info_fn_, profile_path_),
       base::Bind(&QuotaManager::DidGetAvailableSpace,
                  weak_factory_.GetWeakPtr()));
 }
 
+namespace {
+void ContinueGetTemporaryQuota(
+    const QuotaCallback& callback,
+    const TemporaryStorageConfiguration& pool_config) {
+  callback.Run(kQuotaStatusOk, pool_config.pool_size);
+}
+}
+
 void QuotaManager::GetTemporaryGlobalQuota(const QuotaCallback& callback) {
   LazyInitialize();
-  if (!temporary_quota_initialized_) {
-    db_initialization_callbacks_.Add(base::Bind(
-        &QuotaManager::GetTemporaryGlobalQuota,
-        weak_factory_.GetWeakPtr(), callback));
-    return;
-  }
-
-  if (temporary_quota_override_ > 0) {
-    callback.Run(kQuotaStatusOk, temporary_quota_override_);
-    return;
-  }
-
-  UsageAndQuotaCallbackDispatcher* dispatcher =
-      new UsageAndQuotaCallbackDispatcher(this);
-  GetUsageTracker(kStorageTypeTemporary)->
-      GetGlobalLimitedUsage(dispatcher->GetGlobalLimitedUsageCallback());
-  GetAvailableSpace(dispatcher->GetAvailableSpaceCallback());
-  dispatcher->WaitForResults(
-      base::Bind(&DispatchTemporaryGlobalQuotaCallback, callback));
-}
-
-void QuotaManager::SetTemporaryGlobalOverrideQuota(
-    int64_t new_quota,
-    const QuotaCallback& callback) {
-  LazyInitialize();
-
-  if (new_quota < 0) {
-    if (!callback.is_null())
-      callback.Run(kQuotaErrorInvalidModification, -1);
-    return;
-  }
-
-  if (db_disabled_) {
-    if (!callback.is_null())
-      callback.Run(kQuotaErrorInvalidAccess, -1);
-    return;
-  }
-
-  int64_t* new_quota_ptr = new int64_t(new_quota);
-  PostTaskAndReplyWithResultForDBThread(
-      FROM_HERE,
-      base::Bind(&SetTemporaryGlobalOverrideQuotaOnDBThread,
-                 base::Unretained(new_quota_ptr)),
-      base::Bind(&QuotaManager::DidSetTemporaryGlobalOverrideQuota,
-                 weak_factory_.GetWeakPtr(),
-                 callback,
-                 base::Owned(new_quota_ptr)));
+  GetTemporaryStorageConfig(
+          base::Bind(&ContinueGetTemporaryQuota, callback));
 }
 
 void QuotaManager::GetPersistentHostQuota(const std::string& host,
                                           const QuotaCallback& callback) {
   LazyInitialize();
   if (host.empty()) {
     // This could happen if we are called on file:///.
     // TODO(kinuko) We may want to respect --allow-file-access-from-files
     // command line switch.
     callback.Run(kQuotaStatusOk, 0);
@@ skipping 23 matching lines @@
     // This could happen if we are called on file:///.
     callback.Run(kQuotaErrorNotSupported, 0);
     return;
   }
 
   if (new_quota < 0) {
     callback.Run(kQuotaErrorInvalidModification, -1);
     return;
   }
 
-  if (kPerHostPersistentQuotaLimit < new_quota) {
-    // Cap the requested size at the per-host quota limit.
-    new_quota = kPerHostPersistentQuotaLimit;
-  }
+  // Cap the requested size at the per-host quota limit.
+  new_quota = std::min(new_quota, kPerHostPersistentQuotaLimit);
 
   if (db_disabled_) {
     callback.Run(kQuotaErrorInvalidAccess, -1);
     return;
   }
 
   int64_t* new_quota_ptr = new int64_t(new_quota);
   PostTaskAndReplyWithResultForDBThread(
       FROM_HERE,
       base::Bind(&SetPersistentHostQuotaOnDBThread,
@@ skipping 139 matching lines @@
 QuotaManager::EvictionContext::EvictionContext()
     : evicted_type(kStorageTypeUnknown) {
 }
 
 QuotaManager::EvictionContext::~EvictionContext() {
 }
 
 void QuotaManager::LazyInitialize() {
   DCHECK(io_thread_->BelongsToCurrentThread());
   if (database_) {
-    // Initialization seems to be done already.
+    // Already initialized.
     return;
   }
 
   // Use an empty path to open an in-memory only databse for incognito.
   database_.reset(new QuotaDatabase(is_incognito_ ? base::FilePath() :
       profile_path_.AppendASCII(kDatabaseName)));
 
   temporary_usage_tracker_.reset(new UsageTracker(
       clients_, kStorageTypeTemporary, special_storage_policy_.get(),
       storage_monitor_.get()));
   persistent_usage_tracker_.reset(new UsageTracker(
       clients_, kStorageTypePersistent, special_storage_policy_.get(),
       storage_monitor_.get()));
   syncable_usage_tracker_.reset(new UsageTracker(
       clients_, kStorageTypeSyncable, special_storage_policy_.get(),
       storage_monitor_.get()));
 
-  int64_t* temporary_quota_override = new int64_t(-1);
-  int64_t* desired_available_space = new int64_t(-1);
-  PostTaskAndReplyWithResultForDBThread(
-      FROM_HERE,
-      base::Bind(&InitializeOnDBThread,
-                 base::Unretained(temporary_quota_override),
-                 base::Unretained(desired_available_space)),
-      base::Bind(&QuotaManager::DidInitialize,
-                 weak_factory_.GetWeakPtr(),
-                 base::Owned(temporary_quota_override),
-                 base::Owned(desired_available_space)));
+  if (!is_incognito_) {
+    histogram_timer_.Start(FROM_HERE,
+                           base::TimeDelta::FromMilliseconds(
+                               kReportHistogramInterval),
+                           this, &QuotaManager::ReportHistogram);
+  }
+
+  GetTemporaryGlobalQuota(
+      base::Bind(&QuotaManager::DidGetInitialTemporaryGlobalQuota,
+                 weak_factory_.GetWeakPtr(), base::TimeTicks::Now()));
 }
 
 void QuotaManager::RegisterClient(QuotaClient* client) {
   DCHECK(!database_.get());
   clients_.push_back(client);
 }
 
 UsageTracker* QuotaManager::GetUsageTracker(StorageType type) const {
   switch (type) {
     case kStorageTypeTemporary:
@@ skipping 76 matching lines @@
       base::Bind(&DumpOriginInfoTableHelper::DidDumpOriginInfoTable,
                  base::Owned(helper),
                  weak_factory_.GetWeakPtr(),
                  callback));
 }
 
 void QuotaManager::StartEviction() {
   DCHECK(!temporary_storage_evictor_.get());
   temporary_storage_evictor_.reset(new QuotaTemporaryStorageEvictor(
       this, kEvictionIntervalInMilliSeconds));
-  if (desired_available_space_ >= 0)
-    temporary_storage_evictor_->set_min_available_disk_space_to_start_eviction(
-        desired_available_space_);
   temporary_storage_evictor_->Start();
 }
 
 void QuotaManager::DeleteOriginFromDatabase(const GURL& origin,
                                             StorageType type,
                                             bool is_eviction) {
   LazyInitialize();
   if (db_disabled_)
     return;
 
@@ skipping 198 matching lines @@
   eviction_context_.evicted_origin = origin;
   eviction_context_.evicted_type = type;
   eviction_context_.evict_origin_data_callback = callback;
 
   DeleteOriginDataInternal(origin, type, QuotaClient::kAllClientsMask, true,
                            base::Bind(&QuotaManager::DidOriginDataEvicted,
                                       weak_factory_.GetWeakPtr()));
 }
 
 void QuotaManager::GetUsageAndQuotaForEviction(
-    const UsageAndQuotaCallback& callback) {
+    const XUsageAndQuotaCallback& callback) {
   // crbug.com/349708
   TRACE_EVENT0("io", "QuotaManager::GetUsageAndQuotaForEviction");
 
   DCHECK(io_thread_->BelongsToCurrentThread());
   LazyInitialize();
 
   UsageAndQuotaCallbackDispatcher* dispatcher =
       new UsageAndQuotaCallbackDispatcher(this);
   GetUsageTracker(kStorageTypeTemporary)
       ->GetGlobalLimitedUsage(dispatcher->GetGlobalLimitedUsageCallback());
   GetTemporaryGlobalQuota(dispatcher->GetQuotaCallback());
-  GetAvailableSpace(dispatcher->GetAvailableSpaceCallback());
+  xGetAvailableSpace(dispatcher->GetAvailableSpaceCallback());
   dispatcher->WaitForResults(callback);
 }
 
 void QuotaManager::AsyncGetVolumeInfo(
     const VolumeInfoCallback& callback) {
   DCHECK(io_thread_->BelongsToCurrentThread());
   uint64_t* available_space = new uint64_t(0);
   uint64_t* total_space = new uint64_t(0);
-  PostTaskAndReplyWithResult(
+  base::PostTaskAndReplyWithResult(
       db_thread_.get(),
       FROM_HERE,
       base::Bind(get_volume_info_fn_,
                  profile_path_,
                  base::Unretained(available_space),
                  base::Unretained(total_space)),
       base::Bind(&QuotaManager::DidGetVolumeInfo,
                  weak_factory_.GetWeakPtr(),
                  callback,
                  base::Owned(available_space),
@@ skipping 22 matching lines @@
   GURL* url = new GURL;
   PostTaskAndReplyWithResultForDBThread(
       FROM_HERE, base::Bind(&GetLRUOriginOnDBThread, type,
                             GetEvictionOriginExceptions(std::set<GURL>()),
                             base::RetainedRef(special_storage_policy_),
                             base::Unretained(url)),
       base::Bind(&QuotaManager::DidGetLRUOrigin, weak_factory_.GetWeakPtr(),
                  base::Owned(url)));
 }
 
-void QuotaManager::DidSetTemporaryGlobalOverrideQuota(
-    const QuotaCallback& callback,
-    const int64_t* new_quota,
-    bool success) {
-  QuotaStatusCode status = kQuotaErrorInvalidAccess;
-  DidDatabaseWork(success);
-  if (success) {
-    temporary_quota_override_ = *new_quota;
-    status = kQuotaStatusOk;
-  }
-
-  if (callback.is_null())
-    return;
-
-  callback.Run(status, *new_quota);
-}
-
 void QuotaManager::DidGetPersistentHostQuota(const std::string& host,
                                              const int64_t* quota,
                                              bool success) {
   DidDatabaseWork(success);
-  persistent_host_quota_callbacks_.Run(host, kQuotaStatusOk, *quota);
+  persistent_host_quota_callbacks_.Run(
+      host, kQuotaStatusOk,
+      std::min(*quota, kPerHostPersistentQuotaLimit));
 }
 
 void QuotaManager::DidSetPersistentHostQuota(const std::string& host,
                                              const QuotaCallback& callback,
                                              const int64_t* new_quota,
                                              bool success) {
   DidDatabaseWork(success);
   callback.Run(success ? kQuotaStatusOk : kQuotaErrorInvalidAccess, *new_quota);
 }
 
-void QuotaManager::DidInitialize(int64_t* temporary_quota_override,
-                                 int64_t* desired_available_space,
-                                 bool success) {
-  temporary_quota_override_ = *temporary_quota_override;
-  desired_available_space_ = *desired_available_space;
-  temporary_quota_initialized_ = true;
-  DidDatabaseWork(success);
-
-  if (!is_incognito_) {
-    histogram_timer_.Start(FROM_HERE,
-                           base::TimeDelta::FromMilliseconds(
-                               kReportHistogramInterval),
-                           this, &QuotaManager::ReportHistogram);
-  }
-
-  db_initialization_callbacks_.Run();
-  GetTemporaryGlobalQuota(
-      base::Bind(&QuotaManager::DidGetInitialTemporaryGlobalQuota,
-                 weak_factory_.GetWeakPtr(), base::TimeTicks::Now()));
-}
-
 void QuotaManager::DidGetLRUOrigin(const GURL* origin,
                                    bool success) {
   DidDatabaseWork(success);
 
   lru_origin_callback_.Run(*origin);
   lru_origin_callback_.Reset();
 }
 
 void QuotaManager::DidGetInitialTemporaryGlobalQuota(
     base::TimeTicks start_ticks,
@@ skipping 25 matching lines @@
 }
 
 void QuotaManager::DidGetAvailableSpace(int64_t space) {
   // crbug.com/349708
   TRACE_EVENT1("io", "QuotaManager::DidGetAvailableSpace",
                "n_callbacks", available_space_callbacks_.size());
 
   available_space_callbacks_.Run(kQuotaStatusOk, space);
 }
 
+namespace {
+void DidGetTempStorageConfigThreadAdapter(
+    base::TaskRunner* task_runner,
+    const TemporaryStorageConfigurationCallback& callback,
+    const TemporaryStorageConfiguration& storage_config) {
+  task_runner->PostTask(FROM_HERE, base::Bind(callback, storage_config));
+}
+}  // namespace
+
+void QuotaManager::GetTemporaryStorageConfig(
+    const TemporaryStorageConfigurationCallback& callback) {
+  if (base::TimeTicks::Now() - storage_config_timestamp_ <
+      storage_config_.refresh_interval) {
+    callback.Run(storage_config_);
+    return;
+   }
+
+   if (!storage_config_callbacks_.Add(callback))
+     return;
+
+  // We invoke our clients GetTemporaryPoolConfigurationFunc on the
+  // UI thread and plumb the resulting value back to this thread.

[kinuko, 2016/07/27 14:23:25]

Could you help me understand why it needs to be called from the UI thread?

+  get_config_task_runner_->PostTask(
+      FROM_HERE,
+      base::Bind(
+          get_config_function_,
+          profile_path_, is_incognito_,
+          base::Bind(
+              &DidGetTempStorageConfigThreadAdapter,
+              base::RetainedRef(base::ThreadTaskRunnerHandle::Get()),
+              base::Bind(
+                  &QuotaManager::DidGetTemporaryStorageConfig,
+                  weak_factory_.GetWeakPtr()))));
+}
+
+void QuotaManager::DidGetTemporaryStorageConfig(
+    const TemporaryStorageConfiguration& config) {
+  SetTemporaryStorageConfiguration(config);
+  storage_config_callbacks_.Run(config);
+}
+
+
 void QuotaManager::DidDatabaseWork(bool success) {
   db_disabled_ = !success;
 }
 
 void QuotaManager::DeleteOnCorrectThread() const {
   if (!io_thread_->BelongsToCurrentThread() &&
       io_thread_->DeleteSoon(FROM_HERE, this)) {
     return;
   }
   delete this;
@@ skipping 45 matching lines @@
   int64_t total = base::SysInfo::AmountOfTotalDiskSpace(path);
   if (total < 0)
     return false;
 
   *available_space = static_cast<uint64_t>(available);
   *total_size = static_cast<uint64_t>(total);
   return true;
 }
 
 }  // namespace storage