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

storage/browser/quota/quota_manager.h

 // 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.
 
 #ifndef STORAGE_BROWSER_QUOTA_QUOTA_MANAGER_H_
 #define STORAGE_BROWSER_QUOTA_QUOTA_MANAGER_H_
 
 #include <stdint.h>
 
 #include <deque>
@@ skipping 42 matching lines @@
 namespace storage {
 
 class QuotaDatabase;
 class QuotaManagerProxy;
 class QuotaTemporaryStorageEvictor;
 class StorageMonitor;
 class UsageTracker;
 
 struct QuotaManagerDeleter;
 
-struct STORAGE_EXPORT UsageAndQuota {
+struct STORAGE_EXPORT XUsageAndQuota {
   int64_t usage;
   int64_t global_limited_usage;
   int64_t quota;
   int64_t available_disk_space;
 
-  UsageAndQuota();
-  UsageAndQuota(int64_t usage,
+  XUsageAndQuota();
+  XUsageAndQuota(int64_t usage,
                 int64_t global_limited_usage,
                 int64_t quota,
                 int64_t available_disk_space);
 };
 
 // TODO(calamity): Use this in the temporary storage eviction path.
 // An interface for deciding which origin's storage should be evicted when the
 // quota is exceeded.
 class STORAGE_EXPORT QuotaEvictionPolicy {
  public:
   virtual ~QuotaEvictionPolicy() {}
 
   // Returns the next origin to evict.  It might return an empty GURL when there
   // are no evictable origins.
   virtual void GetEvictionOrigin(
       const scoped_refptr<SpecialStoragePolicy>& special_storage_policy,
       const std::set<GURL>& exceptions,
       const std::map<GURL, int64_t>& usage_map,
       int64_t global_quota,
       const GetOriginCallback& callback) = 0;
 };
 
 // An interface called by QuotaTemporaryStorageEvictor.
 class STORAGE_EXPORT QuotaEvictionHandler {
  public:
   using EvictOriginDataCallback = StatusCallback;
-  using UsageAndQuotaCallback = base::Callback<
-      void(QuotaStatusCode status, const UsageAndQuota& usage_and_quota)>;
+  using XUsageAndQuotaCallback = base::Callback<
+      void(QuotaStatusCode status, const XUsageAndQuota& usage_and_quota)>;
   using VolumeInfoCallback = base::Callback<
       void(bool success, uint64_t available_space, uint64_t total_space)>;
 
   // Returns next origin to evict.  It might return an empty GURL when there are
   // no evictable origins.
   virtual void GetEvictionOrigin(StorageType type,
                                  const std::set<GURL>& extra_exceptions,
                                  int64_t global_quota,
                                  const GetOriginCallback& callback) = 0;
 
   virtual void EvictOriginData(
       const GURL& origin,
       StorageType type,
       const EvictOriginDataCallback& callback) = 0;
 
   virtual void AsyncGetVolumeInfo(const VolumeInfoCallback& callback) = 0;
   virtual void GetUsageAndQuotaForEviction(
-      const UsageAndQuotaCallback& callback) = 0;
+      const XUsageAndQuotaCallback& callback) = 0;
 
  protected:
   virtual ~QuotaEvictionHandler() {}
 };
 
 struct UsageInfo {
   UsageInfo(const std::string& host, StorageType type, int64_t usage)
       : host(host), type(type), usage(usage) {}
   std::string host;
   StorageType type;
   int64_t usage;
 };
 
+// todo: new file temporary_pool_config
+// Configuration parameters the storage lib embedder must provide
+// to the QuotaManager.
+struct TemporaryStorageConfiguration {

[michaeln, 2016/07/27 19:57:47]

wdyt about the set of config params?

+  TemporaryStorageConfiguration() {}
+
+  // The target size of the shared pool of disk space the quota system allows

[jsbell, 2016/07/27 20:18:30]

Possibly extend this comment with a concrete example, such as: "for example, the
embedder may use 50% of the total volume size"

[michaeln, 2016/07/28 02:06:28]

Done.

+  // for use by by websites using HTML5 storage apis. This is not a hard limit,
+  // it serves as the basis for computing the quota of an individual site.
+  int64_t pool_size = 0;

[jsbell, 2016/07/27 20:18:30]

nit: document units

Some of these are bytes, some of these are divisors

[michaeln, 2016/07/28 02:06:28]

Done.

+
+  // The amount of space that must remain available on the storage
+  // volume. As the volume approaches this limit, the quota system gets
+  // more aggressive about evicting data and disallowing new data.
+  int64_t must_remain_available = 0;
+
+  // The target number of sites that will be sharing the larger pool.
+  // Nominally, an individual site is allowed to use up to
+  // pool_size / per_host_portion.
+  int per_host_portion = 5;

[jsbell, 2016/07/27 20:18:30]

Given that we use this as a divisor, should probably comment not to use 0 and/or
give 0 special meaning.

Alternately, we could make this bytes (to be consistent) and let the embedder do
the dividing.

[michaeln, 2016/07/28 02:06:27]

switched to a number of bytes value

+
+  // The quota system querries the embedder for the TemporaryPoolConfiguration,
+  // but will rate limit the frequency of the querries to no more than once
+  // per refresh interval.
+  base::TimeDelta refresh_interval = base::TimeDelta::Max();
+};
+
+// Function type used to return the temp storage config in response to a
+// GetTemporaryStorageConfigurationFunc invocation.
+using TemporaryStorageConfigurationCallback =
+    base::Callback<void(const TemporaryStorageConfiguration&)>;
+
+// Function type used to query the embedder about the temporary pool .
+// configuration. This function is invoked on the UI thread.
+using GetTemporaryStorageConfigurationFunc = base::Callback<
+    void(const base::FilePath& profile_path, bool is_incognito,
+         TemporaryStorageConfigurationCallback callback)>;
+
 // The quota manager class.  This class is instantiated per profile and
 // held by the profile.  With the exception of the constructor and the
 // proxy() method, all methods should only be called on the IO thread.
 class STORAGE_EXPORT QuotaManager
     : public QuotaTaskObserver,
       public QuotaEvictionHandler,
       public base::RefCountedThreadSafe<QuotaManager, QuotaManagerDeleter> {
  public:
   typedef base::Callback<void(QuotaStatusCode,
                               int64_t /* usage */,
                               int64_t /* quota */)> GetUsageAndQuotaCallback;
 
   static const int64_t kIncognitoDefaultQuotaLimit;
   static const int64_t kNoLimit;
 
   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_storage_config_function);
+
+  const TemporaryStorageConfiguration& storage_config() {
+    return storage_config_;
+  }
+  void SetTemporaryStorageConfiguration(
+      const TemporaryStorageConfiguration& storage_config);
 
   // Returns a proxy object that can be used on any thread.
   QuotaManagerProxy* proxy() { return proxy_.get(); }
 
   // Called by clients or webapps. Returns usage per host.
   void GetUsageInfo(const GetUsageInfoCallback& callback);
 
   // Called by Web Apps.
   // This method is declared as virtual to allow test code to override it.
   virtual void GetUsageAndQuotaForWebApps(
@@ skipping 55 matching lines @@
   virtual void DeleteOriginData(const GURL& origin,
                                 StorageType type,
                                 int quota_client_mask,
                                 const StatusCallback& callback);
   void DeleteHostData(const std::string& host,
                       StorageType type,
                       int quota_client_mask,
                       const StatusCallback& callback);
 
   // Called by UI and internal modules.
-  void GetAvailableSpace(const AvailableSpaceCallback& callback);
+  void xGetAvailableSpace(const AvailableSpaceCallback& callback);
   void GetTemporaryGlobalQuota(const QuotaCallback& callback);
 
-  // Ok to call with NULL callback.
-  void SetTemporaryGlobalOverrideQuota(int64_t new_quota,
-                                       const QuotaCallback& callback);
-
   void GetPersistentHostQuota(const std::string& host,
                               const QuotaCallback& callback);
   void SetPersistentHostQuota(const std::string& host,
                               int64_t new_quota,
                               const QuotaCallback& callback);
   void GetGlobalUsage(StorageType type, const GlobalUsageCallback& callback);
   void GetHostUsage(const std::string& host, StorageType type,
                     const UsageCallback& callback);
   void GetHostUsage(const std::string& host, StorageType type,
                     QuotaClient::ID client_id,
                     const UsageCallback& callback);
 
   bool IsTrackingHostUsage(StorageType type, QuotaClient::ID client_id) const;
 
   void GetStatistics(std::map<std::string, std::string>* statistics);
 
   bool IsStorageUnlimited(const GURL& origin, StorageType type) const;
 
   bool CanQueryDiskSize(const GURL& origin) const {
+    // TODO: not currently used?
     return special_storage_policy_.get() &&
            special_storage_policy_->CanQueryDiskSize(origin);
   }
 
   virtual void GetOriginsModifiedSince(StorageType type,
                                        base::Time modified_since,
                                        const GetOriginsCallback& callback);
 
   bool ResetUsageTracker(StorageType type);
 
   // Used to register/deregister observers that wish to monitor storage events.
   void AddStorageObserver(StorageObserver* observer,
                           const StorageObserver::MonitorParams& params);
   void RemoveStorageObserver(StorageObserver* observer);
   void RemoveStorageObserverForFilter(StorageObserver* observer,
                                       const StorageObserver::Filter& filter);
 
+  static bool GetVolumeInfo(const base::FilePath& path,
+                            uint64_t* available_space,
+                            uint64_t* total_size);
+
   // Determines the portion of the temp pool that can be
   // utilized by a single host (ie. 5 for 20%).
   static const int kPerHostTemporaryPortion;
 
   static const int64_t kPerHostPersistentQuotaLimit;
 
   static const char kDatabaseName[];
 
   static const int kThresholdOfErrorsToBeBlacklisted;
 
@@ skipping 47 matching lines @@
   typedef base::Callback<void(const QuotaTableEntries&)>
       DumpQuotaTableCallback;
   typedef base::Callback<void(const OriginInfoTableEntries&)>
       DumpOriginInfoTableCallback;
 
   typedef CallbackQueue<base::Closure> ClosureQueue;
   typedef CallbackQueue<AvailableSpaceCallback, QuotaStatusCode, int64_t>
       AvailableSpaceCallbackQueue;
   typedef CallbackQueueMap<QuotaCallback, std::string, QuotaStatusCode, int64_t>
       HostQuotaCallbackMap;
-
+  using TemporaryConfigCallbackQueue =
+      CallbackQueue<TemporaryStorageConfigurationCallback,
+                    const TemporaryStorageConfiguration&>;
   struct EvictionContext {
     EvictionContext();
     virtual ~EvictionContext();
     GURL evicted_origin;
     StorageType evicted_type;
 
     EvictOriginDataCallback evict_origin_data_callback;
   };
 
-  typedef QuotaEvictionHandler::UsageAndQuotaCallback
-      UsageAndQuotaDispatcherCallback;
-
   // This initialization method is lazily called on the IO thread
   // when the first quota manager API is called.
   // Initialize must be called after all quota clients are added to the
   // manager by RegisterStorage.
   void LazyInitialize();
 
   // Called by clients via proxy.
   // Registers a quota client to the manager.
   // The client must remain valid until OnQuotaManagerDestored is called.
   void RegisterClient(QuotaClient* client);
@@ skipping 48 matching lines @@
 
   // QuotaEvictionHandler.
   void GetEvictionOrigin(StorageType type,
                          const std::set<GURL>& extra_exceptions,
                          int64_t global_quota,
                          const GetOriginCallback& callback) override;
   void EvictOriginData(const GURL& origin,
                        StorageType type,
                        const EvictOriginDataCallback& callback) override;
   void GetUsageAndQuotaForEviction(
-      const UsageAndQuotaCallback& callback) override;
+      const XUsageAndQuotaCallback& callback) override;
   void AsyncGetVolumeInfo(const VolumeInfoCallback& callback) override;
 
   void DidGetVolumeInfo(
       const VolumeInfoCallback& callback,
       uint64_t* available_space, uint64_t* total_space, bool success);
 
   void GetLRUOrigin(StorageType type, const GetOriginCallback& callback);
 
-  void DidSetTemporaryGlobalOverrideQuota(const QuotaCallback& callback,
-                                          const int64_t* new_quota,
-                                          bool success);
   void DidGetPersistentHostQuota(const std::string& host,
                                  const int64_t* quota,
                                  bool success);
   void DidSetPersistentHostQuota(const std::string& host,
                                  const QuotaCallback& callback,
                                  const int64_t* new_quota,
                                  bool success);
-  void DidInitialize(int64_t* temporary_quota_override,
-                     int64_t* desired_available_space,
-                     bool success);
   void DidGetLRUOrigin(const GURL* origin,
                        bool success);
   void DidGetInitialTemporaryGlobalQuota(base::TimeTicks start_ticks,
                                          QuotaStatusCode status,
                                          int64_t quota_unused);
   void DidInitializeTemporaryOriginsInfo(bool success);
   void DidGetAvailableSpace(int64_t space);
+  void GetTemporaryStorageConfig(
+      const TemporaryStorageConfigurationCallback& callback);
+  void DidGetTemporaryStorageConfig(
+      const TemporaryStorageConfiguration& storage_config);
+
   void DidDatabaseWork(bool success);
 
   void DeleteOnCorrectThread() const;
 
   void PostTaskAndReplyWithResultForDBThread(
       const tracked_objects::Location& from_here,
       const base::Callback<bool(QuotaDatabase*)>& task,
       const base::Callback<void(bool)>& reply);
 
   static int64_t CallGetAmountOfFreeDiskSpace(
       GetVolumeInfoFn get_vol_info_fn,
       const base::FilePath& profile_path);
-  static bool GetVolumeInfo(const base::FilePath& path,
-                            uint64_t* available_space,
-                            uint64_t* total_size);
 
   const bool is_incognito_;
   const base::FilePath profile_path_;
 
   scoped_refptr<QuotaManagerProxy> proxy_;
   bool db_disabled_;
   bool eviction_disabled_;
   scoped_refptr<base::SingleThreadTaskRunner> io_thread_;
   scoped_refptr<base::SequencedTaskRunner> db_thread_;
   mutable std::unique_ptr<QuotaDatabase> database_;
 
+  GetTemporaryStorageConfigurationFunc get_config_function_;
+  scoped_refptr<base::TaskRunner> get_config_task_runner_;
+  TemporaryStorageConfiguration storage_config_;
+  base::TimeTicks storage_config_timestamp_;
+  TemporaryConfigCallbackQueue storage_config_callbacks_;
+
   GetOriginCallback lru_origin_callback_;
   std::set<GURL> access_notified_origins_;
 
   QuotaClientList clients_;
 
   std::unique_ptr<UsageTracker> temporary_usage_tracker_;
   std::unique_ptr<UsageTracker> persistent_usage_tracker_;
   std::unique_ptr<UsageTracker> syncable_usage_tracker_;
   // TODO(michaeln): Need a way to clear the cache, drop and
   // reinstantiate the trackers when they're not handling requests.
 
   std::unique_ptr<QuotaTemporaryStorageEvictor> temporary_storage_evictor_;
   EvictionContext eviction_context_;
   std::unique_ptr<QuotaEvictionPolicy> temporary_storage_eviction_policy_;
   bool is_getting_eviction_origin_;
 
-  ClosureQueue db_initialization_callbacks_;
   AvailableSpaceCallbackQueue available_space_callbacks_;
   HostQuotaCallbackMap persistent_host_quota_callbacks_;
 
-  bool temporary_quota_initialized_;
-  int64_t temporary_quota_override_;
-  int64_t desired_available_space_;
-
   // Map from origin to count.
   std::map<GURL, int> origins_in_use_;
   // Map from origin to error count.
   std::map<GURL, int> origins_in_error_;
 
   scoped_refptr<SpecialStoragePolicy> special_storage_policy_;
 
   base::RepeatingTimer histogram_timer_;
 
   // Pointer to the function used to get volume information. This is
@@ skipping 10 matching lines @@
 
 struct QuotaManagerDeleter {
   static void Destruct(const QuotaManager* manager) {
     manager->DeleteOnCorrectThread();
   }
 };
 
 }  // namespace storage
 
 #endif  // STORAGE_BROWSER_QUOTA_QUOTA_MANAGER_H_