Convert QuotaManager::GetLRUOrigin into a QuotaEvictionPolicy.

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 <algorithm>
 #include <functional>
 
 #include "base/bind.h"
@@ skipping 774 matching lines @@
 
  private:
   bool AppendEntry(const OriginInfoTableEntry& entry) {
     entries_.push_back(entry);
     return true;
   }
 
   OriginInfoTableEntries entries_;
 };
 
+class QuotaManager::LRUOriginEvictionPolicy : public QuotaEvictionPolicy {
+ public:
+  LRUOriginEvictionPolicy(QuotaManager* manager, StorageType type)
+      : manager_(manager), type_(type), weak_factory_(this) {}
+
+  ~LRUOriginEvictionPolicy() override {}
+
+  // Overridden from storage::QuotaEvictionPolicy:
+  void GetEvictionOrigin(const scoped_refptr<storage::SpecialStoragePolicy>&
+                             special_storage_policy,
+                         const std::set<GURL>& exceptions,
+                         const storage::GetOriginCallback& callback) override {
+    if (manager_->db_disabled_) {
+      callback.Run(GURL());
+      return;
+    }
+
+    GURL* url = new GURL;
+    manager_->PostTaskAndReplyWithResultForDBThread(
+        FROM_HERE,
+        base::Bind(&GetLRUOriginOnDBThread, type_, exceptions,
+                   manager_->special_storage_policy_, base::Unretained(url)),
+        base::Bind(&LRUOriginEvictionPolicy::DidGetLRUOrigin,
+                   weak_factory_.GetWeakPtr(), callback, base::Owned(url)));
+  }
+
+  void DidGetLRUOrigin(const storage::GetOriginCallback& callback,
+                       const GURL* origin,
+                       bool success) {
+    manager_->DidDatabaseWork(success);
+    callback.Run(*origin);
+  }
+
+ private:
+  QuotaManager* manager_;
+  StorageType type_;
+  base::WeakPtrFactory<LRUOriginEvictionPolicy> weak_factory_;
+
+  DISALLOW_COPY_AND_ASSIGN(LRUOriginEvictionPolicy);
+};
+
 // 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)
     : is_incognito_(is_incognito),
       profile_path_(profile_path),
@@ skipping 482 matching lines @@
   DCHECK(GetUsageTracker(type));
   GetUsageTracker(type)->GetCachedOrigins(origins);
 }
 
 void QuotaManager::NotifyStorageAccessedInternal(
     QuotaClient::ID client_id,
     const GURL& origin, StorageType type,
     base::Time accessed_time) {
   LazyInitialize();
   if (type == kStorageTypeTemporary && is_getting_eviction_origin_) {
-    // Record the accessed origins while GetLRUOrigin task is runing
-    // to filter out them from eviction.
+    // Record the accessed origins while an eviction origin task is running
+    // to filter them from eviction.
     access_notified_origins_.insert(origin);
   }
 
   if (db_disabled_)
     return;
   PostTaskAndReplyWithResultForDBThread(
       FROM_HERE,
       base::Bind(&UpdateAccessTimeOnDBThread, origin, type, accessed_time),
       base::Bind(&QuotaManager::DidDatabaseWork,
                  weak_factory_.GetWeakPtr()));
@@ skipping 130 matching lines @@
                   &unlimited_origins);
 
   UMA_HISTOGRAM_COUNTS("Quota.NumberOfPersistentStorageOrigins",
                        num_origins);
   UMA_HISTOGRAM_COUNTS("Quota.NumberOfProtectedPersistentStorageOrigins",
                        protected_origins);
   UMA_HISTOGRAM_COUNTS("Quota.NumberOfUnlimitedPersistentStorageOrigins",
                        unlimited_origins);
 }
 
-void QuotaManager::GetEvictionOrigin(StorageType type,
-                                     const GetOriginCallback& callback) {
-  LazyInitialize();
-  is_getting_eviction_origin_ = true;
-
-  GetOriginCallback did_get_origin_callback =
-      base::Bind(&QuotaManager::DidGetEvictionOrigin,
-                 weak_factory_.GetWeakPtr(), callback);
-
-  auto eviction_policy = eviction_policy_map_.find(type);
-  if (eviction_policy != eviction_policy_map_.end()) {
-    eviction_policy->second->GetEvictionOrigin(special_storage_policy_,
-                                               GetEvictionOriginExceptions(),
-                                               did_get_origin_callback);
-  }
-
-  // TODO(calamity): convert LRU origin retrieval into a QuotaEvictionPolicy.
-  GetLRUOrigin(type, did_get_origin_callback);
-}
-
 std::set<GURL> QuotaManager::GetEvictionOriginExceptions() {
   std::set<GURL> exceptions;
   for (const auto& p : origins_in_use_) {
     if (p.second > 0)
       exceptions.insert(p.first);
   }
 
   for (const auto& p : origins_in_error_) {
     if (p.second > QuotaManager::kThresholdOfErrorsToBeBlacklisted)
       exceptions.insert(p.first);
   }
 
   return exceptions;
 }
 
+void QuotaManager::GetEvictionOrigin(StorageType type,
+                                     const GetOriginCallback& callback) {
+  LazyInitialize();
+  is_getting_eviction_origin_ = true;
+
+  if (eviction_policy_map_.find(type) == eviction_policy_map_.end()) {
+    eviction_policy_map_.set(
+        type, make_scoped_ptr(new LRUOriginEvictionPolicy(this, type)));

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

How about setting the LRU policy to the default policy for all StorageTypes in
the constructor (by iterating through them - there isn't many)? Then they could
be overriden.

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

There are several storage types and I believe only temporary storage is ever
evicted. Perhaps we should DCHECK here that the storage type is temporary
storage.

In fact, I'm not sure why there is a storage type here? Is this system supposed
to be generic for all the storage types? Can any of the storage people shed some
light on this?

+  }
+
+  eviction_policy_map_.find(type)->second->GetEvictionOrigin(

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

We can avoid the additional map lookup here

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

Done.

+      special_storage_policy_, GetEvictionOriginExceptions(),
+      base::Bind(&QuotaManager::DidGetEvictionOrigin,
+                 weak_factory_.GetWeakPtr(), callback));
+}
+
 void QuotaManager::DidGetEvictionOrigin(const GetOriginCallback& callback,
                                         const GURL& origin) {
   // Make sure the returned origin is (still) not in the origin_in_use_ set
   // and has not been accessed since we posted the task.
   if (origins_in_use_.find(origin) != origins_in_use_.end() ||
       access_notified_origins_.find(origin) != access_notified_origins_.end()) {
     callback.Run(GURL());
   } else {
     callback.Run(origin);
   }
@@ skipping 24 matching lines @@
 
   UsageAndQuotaCallbackDispatcher* dispatcher =
       new UsageAndQuotaCallbackDispatcher(this);
   GetUsageTracker(kStorageTypeTemporary)
       ->GetGlobalLimitedUsage(dispatcher->GetGlobalLimitedUsageCallback());
   GetTemporaryGlobalQuota(dispatcher->GetQuotaCallback());
   GetAvailableSpace(dispatcher->GetAvailableSpaceCallback());
   dispatcher->WaitForResults(callback);
 }
 
-void QuotaManager::GetLRUOrigin(StorageType type,

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

nit: This function still exists in the header

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

Done.

-                                const GetOriginCallback& callback) {
-  LazyInitialize();
-  // This must not be called while there's an in-flight task.
-  DCHECK(lru_origin_callback_.is_null());
-  lru_origin_callback_ = callback;
-  if (db_disabled_) {
-    lru_origin_callback_.Run(GURL());
-    lru_origin_callback_.Reset();
-    return;
-  }
-
-  GURL* url = new GURL;
-  PostTaskAndReplyWithResultForDBThread(
-      FROM_HERE,
-      base::Bind(&GetLRUOriginOnDBThread, type, GetEvictionOriginExceptions(),
-                 special_storage_policy_, base::Unretained(url)),
-      base::Bind(&QuotaManager::DidGetLRUOrigin, weak_factory_.GetWeakPtr(),
-                 base::Owned(url)));
-}
-
 void QuotaManager::DidSetTemporaryGlobalOverrideQuota(
     const QuotaCallback& callback,
     const int64* new_quota,
     bool success) {
   QuotaStatusCode status = kQuotaErrorInvalidAccess;
   DidDatabaseWork(success);
   if (success) {
     temporary_quota_override_ = *new_quota;
     status = kQuotaStatusOk;
   }
@@ skipping 31 matching lines @@
                          base::TimeDelta::FromMilliseconds(
                              kReportHistogramInterval),
                          this, &QuotaManager::ReportHistogram);
 
   db_initialization_callbacks_.Run();
   GetTemporaryGlobalQuota(
       base::Bind(&QuotaManager::DidGetInitialTemporaryGlobalQuota,
                  weak_factory_.GetWeakPtr()));
 }
 
-void QuotaManager::DidGetLRUOrigin(const GURL* origin,
-                                   bool success) {
-  DidDatabaseWork(success);
-
-  lru_origin_callback_.Run(*origin);
-  lru_origin_callback_.Reset();
-}
-
 void QuotaManager::DidGetInitialTemporaryGlobalQuota(
     QuotaStatusCode status, int64 quota_unused) {
   if (eviction_disabled_)
     return;
 
   std::set<GURL>* origins = new std::set<GURL>;
   temporary_usage_tracker_->GetCachedOrigins(origins);
   // This will call the StartEviction() when initial origin registration
   // is completed.
   PostTaskAndReplyWithResultForDBThread(
@@ skipping 34 matching lines @@
   // |database_|, therefore we can be sure that database_ is alive when this
   // task runs.
   base::PostTaskAndReplyWithResult(
       db_thread_.get(),
       from_here,
       base::Bind(task, base::Unretained(database_.get())),
       reply);
 }
 
 }  // namespace storage