Convert QuotaManager::GetLRUOrigin into a QuotaEvictionPolicy.

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 <deque>
 #include <list>
 #include <map>
@@ skipping 182 matching lines @@
     return origins_in_use_.find(origin) != origins_in_use_.end();
   }
 
   void SetUsageCacheEnabled(QuotaClient::ID client_id,
                             const GURL& origin,
                             StorageType type,
                             bool enabled);
 
   // Set the eviction policy to use when choosing an origin to evict.
   void SetQuotaEvictionPolicy(StorageType type,
                               scoped_ptr<QuotaEvictionPolicy> policy);

[raymes, 2015/09/22 07:02:42]

(I should've noticed this in the other CL too) I think this isn't called from
anywhere yet. Should we remove the function for now? Would it be reasonable to
configure the policies from inside the constructor of this class?

[calamity, 2015/09/24 06:50:31]

I just sent out a CL that hooks it all up. Also, it's used for the site
engagement policy test.

 
   // DeleteOriginData and DeleteHostData (surprisingly enough) delete data of a
   // particular StorageType associated with either a specific origin or set of
   // origins. Each method additionally requires a |quota_client_mask| which
   // specifies the types of QuotaClients to delete from the origin. This is
   // specified by the caller as a bitmask built from QuotaClient::IDs. Setting
   // the mask to QuotaClient::kAllClientsMask will remove all clients from the
   // origin, regardless of type.
   virtual void DeleteOriginData(const GURL& origin,
                                 StorageType type,
@@ skipping 85 matching lines @@
 
   class GetUsageInfoTask;
 
   class OriginDataDeleter;
   class HostDataDeleter;
 
   class GetModifiedSinceHelper;
   class DumpQuotaTableHelper;
   class DumpOriginInfoTableHelper;
 
+  class LRUOriginEvictionPolicy;
+
   typedef QuotaDatabase::QuotaTableEntry QuotaTableEntry;
   typedef QuotaDatabase::OriginInfoTableEntry OriginInfoTableEntry;
   typedef std::vector<QuotaTableEntry> QuotaTableEntries;
   typedef std::vector<OriginInfoTableEntry> OriginInfoTableEntries;
 
   // Function pointer type used to store the function which returns the
   // available disk space for the disk containing the given FilePath.
   typedef int64 (*GetAvailableDiskSpaceFn)(const base::FilePath&);
 
   typedef base::Callback<void(const QuotaTableEntries&)>
@@ skipping 83 matching lines @@
   void DidGetPersistentHostQuota(const std::string& host,
                                  const int64* quota,
                                  bool success);
   void DidSetPersistentHostQuota(const std::string& host,
                                  const QuotaCallback& callback,
                                  const int64* new_quota,
                                  bool success);
   void DidInitialize(int64* temporary_quota_override,
                      int64* desired_available_space,
                      bool success);
-  void DidGetLRUOrigin(const GURL* origin,
-                       bool success);
   void DidGetInitialTemporaryGlobalQuota(QuotaStatusCode status,
                                          int64 quota_unused);
   void DidInitializeTemporaryOriginsInfo(bool success);
   void DidGetAvailableSpace(int64 space);
   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);
 
   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 scoped_ptr<QuotaDatabase> database_;
 
-  GetOriginCallback lru_origin_callback_;
   std::set<GURL> access_notified_origins_;
 
   QuotaClientList clients_;
 
   scoped_ptr<UsageTracker> temporary_usage_tracker_;
   scoped_ptr<UsageTracker> persistent_usage_tracker_;
   scoped_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.
 
@@ skipping 19 matching lines @@
   base::RepeatingTimer<QuotaManager> histogram_timer_;
 
   // Pointer to the function used to get the available disk space. This is
   // overwritten by QuotaManagerTest in order to attain a deterministic reported
   // value. The default value points to base::SysInfo::AmountOfFreeDiskSpace.
   GetAvailableDiskSpaceFn get_disk_space_fn_;
 
   scoped_ptr<StorageMonitor> storage_monitor_;
 
   base::ScopedPtrMap<StorageType, scoped_ptr<QuotaEvictionPolicy>>
       eviction_policy_map_;

[raymes, 2015/09/22 06:58:58]

(I should have picked this up in the other CL) Consider making this a
ScopedVector - since StorageType is just an enum it would make lookups faster.

[calamity, 2015/09/24 06:50:31]

Done.

 
   bool is_getting_eviction_origin_;
 
   base::WeakPtrFactory<QuotaManager> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(QuotaManager);
 };
 
 struct QuotaManagerDeleter {
   static void Destruct(const QuotaManager* manager) {
     manager->DeleteOnCorrectThread();
   }
 };
 
 }  // namespace storage
 
 #endif  // STORAGE_BROWSER_QUOTA_QUOTA_MANAGER_H_