CacheStorage: Split manager into interface and impl classes.

This CL splits the CacheStorageManager into separate interface and
implementation classes.  This serves two purposes:

1. It allows us to support separate backend implementations as
   described in crbug.com/940449.
2. It will also allows us to provide a cross-sequence wrapper
   implementation for external clients accessing cache_storage from
   different threads.

This CL initially creates the Legacy implementation in the
cache_storage_manager.h and .cc files.  A follow-up CL will move the
LegacyCacheStorageManager to separate files in the legacy directory.

Bug: 940449,960012
Change-Id: I5e03ca7de5890d0984add581b6d6bf10d9338497
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1626503Reviewed-by: Daniel Murphy <dmurph@chromium.org>
Reviewed-by: Peter Beverloo <peter@chromium.org>
Commit-Queue: Ben Kelly <wanderview@chromium.org>
Cr-Commit-Position: refs/heads/master@{#664605}

content/browser/background_fetch/background_fetch_test_data_manager.cc

@@ -69,7 +69,7 @@ void BackgroundFetchTestDataManager::InitializeOnIOThread() {
   quota_manager_proxy_ =
       base::MakeRefCounted<MockBGFQuotaManagerProxy>(mock_quota_manager_.get());
 
-  cache_manager_ = CacheStorageManager::Create(
+  cache_manager_ = LegacyCacheStorageManager::Create(
       storage_partition_->GetPath(), base::ThreadTaskRunnerHandle::Get(),
       base::ThreadTaskRunnerHandle::Get(), quota_manager_proxy_,
       base::MakeRefCounted<CacheStorageContextImpl::ObserverList>());

content/browser/cache_storage/cache_storage_cache_unittest.cc

@@ -403,7 +403,7 @@ class MockLegacyCacheStorage : public LegacyCacheStorage {
       scoped_refptr<base::SequencedTaskRunner> scheduler_task_runner,
       scoped_refptr<storage::QuotaManagerProxy> quota_manager_proxy,
       base::WeakPtr<storage::BlobStorageContext> blob_context,
-      CacheStorageManager* cache_storage_manager,
+      LegacyCacheStorageManager* cache_storage_manager,
       const url::Origin& origin,
       CacheStorageOwner owner)
       : LegacyCacheStorage(origin_path,

content/browser/cache_storage/cache_storage_context_impl.cc

@@ -154,7 +154,7 @@ void CacheStorageContextImpl::CreateCacheStorageManager(
   DCHECK(task_runner_->RunsTasksInCurrentSequence());
 
   DCHECK(!cache_manager_);
-  cache_manager_ = CacheStorageManager::Create(
+  cache_manager_ = LegacyCacheStorageManager::Create(
       user_data_directory, std::move(cache_task_runner), task_runner_,
       std::move(quota_manager_proxy), observers_);
 }

content/browser/cache_storage/cache_storage_manager.cc

@@ -92,7 +92,7 @@ void ListOriginsAndLastModifiedOnTaskRunner(
     if (index.ParseFromString(protobuf)) {
       if (index.has_origin()) {
         if (path ==
-            CacheStorageManager::ConstructOriginPath(
+            LegacyCacheStorageManager::ConstructOriginPath(
                 root_path, url::Origin::Create(GURL(index.origin())), owner)) {
           if (base::GetFileInfo(path, &file_info)) {
             int64_t storage_size = CacheStorage::kSizeUnknown;
@@ -155,7 +155,7 @@ void OneOriginSizeReported(base::OnceClosure callback,
 }  // namespace
 
 // static
-scoped_refptr<CacheStorageManager> CacheStorageManager::Create(
+scoped_refptr<LegacyCacheStorageManager> LegacyCacheStorageManager::Create(
     const base::FilePath& path,
     scoped_refptr<base::SequencedTaskRunner> cache_task_runner,
     scoped_refptr<base::SequencedTaskRunner> scheduler_task_runner,
@@ -167,15 +167,17 @@ scoped_refptr<CacheStorageManager> CacheStorageManager::Create(
                     .AppendASCII("CacheStorage");
   }
 
-  return base::WrapRefCounted(new CacheStorageManager(
+  return base::WrapRefCounted(new LegacyCacheStorageManager(
       root_path, std::move(cache_task_runner), std::move(scheduler_task_runner),
       std::move(quota_manager_proxy), std::move(observers)));
 }
 
 // static
-scoped_refptr<CacheStorageManager> CacheStorageManager::CreateForTesting(
-    CacheStorageManager* old_manager) {
-  scoped_refptr<CacheStorageManager> manager(new CacheStorageManager(
+scoped_refptr<LegacyCacheStorageManager>
+LegacyCacheStorageManager::CreateForTesting(
+    LegacyCacheStorageManager* old_manager) {
+  scoped_refptr<LegacyCacheStorageManager> manager(
+      new LegacyCacheStorageManager(
           old_manager->root_path(), old_manager->cache_task_runner(),
           old_manager->scheduler_task_runner(),
           old_manager->quota_manager_proxy_.get(), old_manager->observers_));
@@ -183,9 +185,9 @@ scoped_refptr<CacheStorageManager> CacheStorageManager::CreateForTesting(
   return manager;
 }
 
-CacheStorageManager::~CacheStorageManager() = default;
+LegacyCacheStorageManager::~LegacyCacheStorageManager() = default;
 
-CacheStorageHandle CacheStorageManager::OpenCacheStorage(
+CacheStorageHandle LegacyCacheStorageManager::OpenCacheStorage(
     const url::Origin& origin,
     CacheStorageOwner owner) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
@@ -194,9 +196,9 @@ CacheStorageHandle CacheStorageManager::OpenCacheStorage(
   // object is needed.  This ensures we create the listener on the correct
   // thread.
   if (!memory_pressure_listener_) {
-    memory_pressure_listener_ =
-        std::make_unique<base::MemoryPressureListener>(base::BindRepeating(
-            &CacheStorageManager::OnMemoryPressure, base::Unretained(this)));
+    memory_pressure_listener_ = std::make_unique<base::MemoryPressureListener>(
+        base::BindRepeating(&LegacyCacheStorageManager::OnMemoryPressure,
+                            base::Unretained(this)));
   }
 
   CacheStorageMap::const_iterator it = cache_storage_map_.find({origin, owner});
@@ -211,7 +213,7 @@ CacheStorageHandle CacheStorageManager::OpenCacheStorage(
   return it->second.get()->CreateHandle();
 }
 
-void CacheStorageManager::SetBlobParametersForCache(
+void LegacyCacheStorageManager::SetBlobParametersForCache(
     base::WeakPtr<storage::BlobStorageContext> blob_storage_context) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(cache_storage_map_.empty());
@@ -219,20 +221,22 @@ void CacheStorageManager::SetBlobParametersForCache(
   blob_context_ = blob_storage_context;
 }
 
-void CacheStorageManager::NotifyCacheListChanged(const url::Origin& origin) {
+void LegacyCacheStorageManager::NotifyCacheListChanged(
+    const url::Origin& origin) {
   observers_->Notify(FROM_HERE,
                      &CacheStorageContextImpl::Observer::OnCacheListChanged,
                      origin);
 }
 
-void CacheStorageManager::NotifyCacheContentChanged(const url::Origin& origin,
+void LegacyCacheStorageManager::NotifyCacheContentChanged(
+    const url::Origin& origin,
     const std::string& name) {
   observers_->Notify(FROM_HERE,
                      &CacheStorageContextImpl::Observer::OnCacheContentChanged,
                      origin, name);
 }
 
-void CacheStorageManager::CacheStorageUnreferenced(
+void LegacyCacheStorageManager::CacheStorageUnreferenced(
     LegacyCacheStorage* cache_storage,
     const url::Origin& origin,
     CacheStorageOwner owner) {
@@ -254,7 +258,7 @@ bool CacheStorageManager::IsValidQuotaOrigin(const url::Origin& origin) {
   return !origin.opaque();
 }
 
-void CacheStorageManager::GetAllOriginsUsage(
+void LegacyCacheStorageManager::GetAllOriginsUsage(
     CacheStorageOwner owner,
     CacheStorageContext::GetUsageInfoCallback callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
@@ -278,12 +282,12 @@ void CacheStorageManager::GetAllOriginsUsage(
       FROM_HERE,
       base::BindOnce(&ListOriginsAndLastModifiedOnTaskRunner, usages_ptr,
                      root_path_, owner),
-      base::BindOnce(&CacheStorageManager::GetAllOriginsUsageGetSizes,
+      base::BindOnce(&LegacyCacheStorageManager::GetAllOriginsUsageGetSizes,
                      weak_ptr_factory_.GetWeakPtr(), std::move(usages),
                      std::move(callback)));
 }
 
-void CacheStorageManager::GetAllOriginsUsageGetSizes(
+void LegacyCacheStorageManager::GetAllOriginsUsageGetSizes(
     std::unique_ptr<std::vector<StorageUsageInfo>> usages,
     CacheStorageContext::GetUsageInfoCallback callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
@@ -317,7 +321,7 @@ void CacheStorageManager::GetAllOriginsUsageGetSizes(
   }
 }
 
-void CacheStorageManager::GetOriginUsage(
+void LegacyCacheStorageManager::GetOriginUsage(
     const url::Origin& origin,
     CacheStorageOwner owner,
     storage::QuotaClient::GetUsageCallback callback) {
@@ -327,7 +331,7 @@ void CacheStorageManager::GetOriginUsage(
   LegacyCacheStorage::From(cache_storage)->Size(std::move(callback));
 }
 
-void CacheStorageManager::GetOrigins(
+void LegacyCacheStorageManager::GetOrigins(
     CacheStorageOwner owner,
     storage::QuotaClient::GetOriginsCallback callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
@@ -349,7 +353,7 @@ void CacheStorageManager::GetOrigins(
       std::move(callback));
 }
 
-void CacheStorageManager::GetOriginsForHost(
+void LegacyCacheStorageManager::GetOriginsForHost(
     const std::string& host,
     CacheStorageOwner owner,
     storage::QuotaClient::GetOriginsCallback callback) {
@@ -375,7 +379,7 @@ void CacheStorageManager::GetOriginsForHost(
                      std::move(callback)));
 }
 
-void CacheStorageManager::DeleteOriginData(
+void LegacyCacheStorageManager::DeleteOriginData(
     const url::Origin& origin,
     CacheStorageOwner owner,
     storage::QuotaClient::DeletionCallback callback) {
@@ -391,18 +395,18 @@ void CacheStorageManager::DeleteOriginData(
   cache_storage->ResetManager();
   cache_storage_map_.erase({origin, owner});
   cache_storage->GetSizeThenCloseAllCaches(
-      base::BindOnce(&CacheStorageManager::DeleteOriginDidClose,
+      base::BindOnce(&LegacyCacheStorageManager::DeleteOriginDidClose,
                      weak_ptr_factory_.GetWeakPtr(), origin, owner,
                      std::move(callback), base::WrapUnique(cache_storage)));
 }
 
-void CacheStorageManager::DeleteOriginData(const url::Origin& origin,
+void LegacyCacheStorageManager::DeleteOriginData(const url::Origin& origin,
                                                  CacheStorageOwner owner) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DeleteOriginData(origin, owner, base::DoNothing());
 }
 
-void CacheStorageManager::DeleteOriginDidClose(
+void LegacyCacheStorageManager::DeleteOriginDidClose(
     const url::Origin& origin,
     CacheStorageOwner owner,
     storage::QuotaClient::DeletionCallback callback,
@@ -434,7 +438,7 @@ void CacheStorageManager::DeleteOriginDidClose(
       base::BindOnce(&DeleteOriginDidDeleteDir, std::move(callback)));
 }
 
-CacheStorageManager::CacheStorageManager(
+LegacyCacheStorageManager::LegacyCacheStorageManager(
     const base::FilePath& path,
     scoped_refptr<base::SequencedTaskRunner> cache_task_runner,
     scoped_refptr<base::SequencedTaskRunner> scheduler_task_runner,
@@ -455,7 +459,7 @@ CacheStorageManager::CacheStorageManager(
 }
 
 // static
-base::FilePath CacheStorageManager::ConstructOriginPath(
+base::FilePath LegacyCacheStorageManager::ConstructOriginPath(
     const base::FilePath& root_path,
     const url::Origin& origin,
     CacheStorageOwner owner) {
@@ -469,7 +473,7 @@ base::FilePath CacheStorageManager::ConstructOriginPath(
   return root_path.AppendASCII(origin_hash_hex);
 }
 
-void CacheStorageManager::OnMemoryPressure(
+void LegacyCacheStorageManager::OnMemoryPressure(
     base::MemoryPressureListener::MemoryPressureLevel level) {
   if (level != base::MemoryPressureListener::MEMORY_PRESSURE_LEVEL_CRITICAL)
     return;

content/browser/cache_storage/cache_storage_manager.h

@@ -35,8 +35,6 @@ class QuotaManagerProxy;
 
 namespace content {
 
-class CacheStorageQuotaClient;
-
 namespace cache_storage_manager_unittest {
 class CacheStorageManagerTest;
 }
@@ -61,7 +59,53 @@ class CONTENT_EXPORT CacheStorageManager
     : public base::RefCountedThreadSafe<CacheStorageManager,
                                         BrowserThread::DeleteOnIOThread> {
  public:
-  static scoped_refptr<CacheStorageManager> Create(
+  // Open the CacheStorage for the given origin and owner.  A reference counting
+  // handle is returned which can be stored and used similar to a weak pointer.
+  virtual CacheStorageHandle OpenCacheStorage(const url::Origin& origin,
+                                              CacheStorageOwner owner) = 0;
+
+  // QuotaClient and Browsing Data Deletion support.
+  virtual void GetAllOriginsUsage(
+      CacheStorageOwner owner,
+      CacheStorageContext::GetUsageInfoCallback callback) = 0;
+  virtual void GetOriginUsage(
+      const url::Origin& origin_url,
+      CacheStorageOwner owner,
+      storage::QuotaClient::GetUsageCallback callback) = 0;
+  virtual void GetOrigins(
+      CacheStorageOwner owner,
+      storage::QuotaClient::GetOriginsCallback callback) = 0;
+  virtual void GetOriginsForHost(
+      const std::string& host,
+      CacheStorageOwner owner,
+      storage::QuotaClient::GetOriginsCallback callback) = 0;
+  virtual void DeleteOriginData(
+      const url::Origin& origin,
+      CacheStorageOwner owner,
+      storage::QuotaClient::DeletionCallback callback) = 0;
+  virtual void DeleteOriginData(const url::Origin& origin,
+                                CacheStorageOwner owner) = 0;
+
+  // This must be called before any of the public Cache functions above.
+  virtual void SetBlobParametersForCache(
+      base::WeakPtr<storage::BlobStorageContext> blob_storage_context) = 0;
+
+  static bool IsValidQuotaOrigin(const url::Origin& origin);
+
+ protected:
+  friend class base::DeleteHelper<CacheStorageManager>;
+  friend class base::RefCountedThreadSafe<CacheStorageManager>;
+  friend struct BrowserThread::DeleteOnThread<BrowserThread::IO>;
+
+  virtual ~CacheStorageManager() = default;
+};
+
+// A concrete implementation of the CacheStorageManager interface using
+// the legacy disk_cache backend.
+// TODO(crbug.com/940449): Move this code into a separate file under /legacy.
+class CONTENT_EXPORT LegacyCacheStorageManager : public CacheStorageManager {
+ public:
+  static scoped_refptr<LegacyCacheStorageManager> Create(
       const base::FilePath& path,
       scoped_refptr<base::SequencedTaskRunner> cache_task_runner,
       scoped_refptr<base::SequencedTaskRunner> scheduler_task_runner,
@@ -71,8 +115,8 @@ class CONTENT_EXPORT CacheStorageManager
   // Create a new manager using the underlying configuration of the given
   // manager, but with its own list of storage objects.  This is only used
   // for testing.
-  static scoped_refptr<CacheStorageManager> CreateForTesting(
-      CacheStorageManager* old_manager);
+  static scoped_refptr<LegacyCacheStorageManager> CreateForTesting(
+      LegacyCacheStorageManager* old_manager);
 
   // Map a database identifier (computed from an origin) to the path.
   static base::FilePath ConstructOriginPath(const base::FilePath& root_path,
@@ -82,12 +126,29 @@ class CONTENT_EXPORT CacheStorageManager
   // Open the CacheStorage for the given origin and owner.  A reference counting
   // handle is returned which can be stored and used similar to a weak pointer.
   CacheStorageHandle OpenCacheStorage(const url::Origin& origin,
-                                      CacheStorageOwner owner);
+                                      CacheStorageOwner owner) override;
+
+  void GetAllOriginsUsage(
+      CacheStorageOwner owner,
+      CacheStorageContext::GetUsageInfoCallback callback) override;
+  void GetOriginUsage(const url::Origin& origin_url,
+                      CacheStorageOwner owner,
+                      storage::QuotaClient::GetUsageCallback callback) override;
+  void GetOrigins(CacheStorageOwner owner,
+                  storage::QuotaClient::GetOriginsCallback callback) override;
+  void GetOriginsForHost(
+      const std::string& host,
+      CacheStorageOwner owner,
+      storage::QuotaClient::GetOriginsCallback callback) override;
+  void DeleteOriginData(
+      const url::Origin& origin,
+      CacheStorageOwner owner,
+      storage::QuotaClient::DeletionCallback callback) override;
+  void DeleteOriginData(const url::Origin& origin,
+                        CacheStorageOwner owner) override;
 
-  // This must be called before creating any of the public *Cache functions
-  // above.
   void SetBlobParametersForCache(
-      base::WeakPtr<storage::BlobStorageContext> blob_storage_context);
+      base::WeakPtr<storage::BlobStorageContext> blob_storage_context) override;
 
   void NotifyCacheListChanged(const url::Origin& origin);
   void NotifyCacheContentChanged(const url::Origin& origin,
@@ -105,48 +166,27 @@ class CONTENT_EXPORT CacheStorageManager
                                 const url::Origin& origin,
                                 CacheStorageOwner owner);
 
-  static bool IsValidQuotaOrigin(const url::Origin& origin);
-
  private:
-  friend class base::DeleteHelper<CacheStorageManager>;
-  friend class base::RefCountedThreadSafe<CacheStorageManager>;
   friend class cache_storage_manager_unittest::CacheStorageManagerTest;
   friend class CacheStorageContextImpl;
-  friend class CacheStorageQuotaClient;
-  friend struct BrowserThread::DeleteOnThread<BrowserThread::IO>;
 
   typedef std::map<std::pair<url::Origin, CacheStorageOwner>,
                    std::unique_ptr<LegacyCacheStorage>>
       CacheStorageMap;
 
-  CacheStorageManager(
+  LegacyCacheStorageManager(
       const base::FilePath& path,
       scoped_refptr<base::SequencedTaskRunner> cache_task_runner,
       scoped_refptr<base::SequencedTaskRunner> scheduler_task_runner,
       scoped_refptr<storage::QuotaManagerProxy> quota_manager_proxy,
       scoped_refptr<CacheStorageContextImpl::ObserverList> observers);
 
-  virtual ~CacheStorageManager();
+  ~LegacyCacheStorageManager() override;
 
-  // QuotaClient and Browsing Data Deletion support
-  void GetAllOriginsUsage(CacheStorageOwner owner,
-                          CacheStorageContext::GetUsageInfoCallback callback);
   void GetAllOriginsUsageGetSizes(
       std::unique_ptr<std::vector<StorageUsageInfo>> usage_info,
       CacheStorageContext::GetUsageInfoCallback callback);
 
-  void GetOriginUsage(const url::Origin& origin_url,
-                      CacheStorageOwner owner,
-                      storage::QuotaClient::GetUsageCallback callback);
-  void GetOrigins(CacheStorageOwner owner,
-                  storage::QuotaClient::GetOriginsCallback callback);
-  void GetOriginsForHost(const std::string& host,
-                         CacheStorageOwner owner,
-                         storage::QuotaClient::GetOriginsCallback callback);
-  void DeleteOriginData(const url::Origin& origin,
-                        CacheStorageOwner owner,
-                        storage::QuotaClient::DeletionCallback callback);
-  void DeleteOriginData(const url::Origin& origin, CacheStorageOwner owner);
   void DeleteOriginDidClose(const url::Origin& origin,
                             CacheStorageOwner owner,
                             storage::QuotaClient::DeletionCallback callback,
@@ -187,8 +227,8 @@ class CONTENT_EXPORT CacheStorageManager
 
   std::unique_ptr<base::MemoryPressureListener> memory_pressure_listener_;
 
-  base::WeakPtrFactory<CacheStorageManager> weak_ptr_factory_;
-  DISALLOW_COPY_AND_ASSIGN(CacheStorageManager);
+  base::WeakPtrFactory<LegacyCacheStorageManager> weak_ptr_factory_;
+  DISALLOW_COPY_AND_ASSIGN(LegacyCacheStorageManager);
 };
 
 }  // namespace content

content/browser/cache_storage/cache_storage_manager_unittest.cc

@@ -337,7 +337,7 @@ class CacheStorageManagerTest : public testing::Test {
     quota_manager_proxy_ = new MockCacheStorageQuotaManagerProxy(
         mock_quota_manager_.get(), base::ThreadTaskRunnerHandle::Get().get());
 
-    cache_manager_ = CacheStorageManager::Create(
+    cache_manager_ = LegacyCacheStorageManager::Create(
         temp_dir_path, base::ThreadTaskRunnerHandle::Get(),
         base::ThreadTaskRunnerHandle::Get(), quota_manager_proxy_, observers_);
 
@@ -748,7 +748,7 @@ class CacheStorageManagerTest : public testing::Test {
   scoped_refptr<MockQuotaManager> mock_quota_manager_;
   scoped_refptr<MockCacheStorageQuotaManagerProxy> quota_manager_proxy_;
   scoped_refptr<CacheStorageContextImpl::ObserverList> observers_;
-  scoped_refptr<CacheStorageManager> cache_manager_;
+  scoped_refptr<LegacyCacheStorageManager> cache_manager_;
 
   CacheStorageCacheHandle callback_cache_handle_;
   int callback_bool_;
@@ -1085,7 +1085,8 @@ TEST_F(CacheStorageManagerTest, DataPersists) {
   EXPECT_TRUE(Open(origin2_, "raz"));
   EXPECT_TRUE(Delete(origin1_, "bar"));
   quota_manager_proxy_->SimulateQuotaManagerDestroyed();
-  cache_manager_ = CacheStorageManager::CreateForTesting(cache_manager_.get());
+  cache_manager_ =
+      LegacyCacheStorageManager::CreateForTesting(cache_manager_.get());
   EXPECT_EQ(2u, Keys(origin1_));
   std::vector<std::string> expected_keys;
   expected_keys.push_back("foo");
@@ -1097,7 +1098,8 @@ TEST_F(CacheStorageManagerMemoryOnlyTest, DataLostWhenMemoryOnly) {
   EXPECT_TRUE(Open(origin1_, "foo"));
   EXPECT_TRUE(Open(origin2_, "baz"));
   quota_manager_proxy_->SimulateQuotaManagerDestroyed();
-  cache_manager_ = CacheStorageManager::CreateForTesting(cache_manager_.get());
+  cache_manager_ =
+      LegacyCacheStorageManager::CreateForTesting(cache_manager_.get());
   EXPECT_EQ(0u, Keys(origin1_));
 }
 
@@ -1398,7 +1400,8 @@ TEST_F(CacheStorageManagerTest, CacheSizePaddedAfterReopen) {
   // Create a new CacheStorageManager that hasn't yet loaded the origin.
   CreateStorageManager();
   quota_manager_proxy_->SimulateQuotaManagerDestroyed();
-  cache_manager_ = CacheStorageManager::CreateForTesting(cache_manager_.get());
+  cache_manager_ =
+      LegacyCacheStorageManager::CreateForTesting(cache_manager_.get());
   EXPECT_TRUE(Open(origin1_, kCacheName));
 
   base::RunLoop().RunUntilIdle();
@@ -1470,7 +1473,8 @@ TEST_F(CacheStorageManagerTest, PersistedCacheKeyUsed) {
   // Create a new CacheStorageManager that hasn't yet loaded the origin.
   CreateStorageManager();
   quota_manager_proxy_->SimulateQuotaManagerDestroyed();
-  cache_manager_ = CacheStorageManager::CreateForTesting(cache_manager_.get());
+  cache_manager_ =
+      LegacyCacheStorageManager::CreateForTesting(cache_manager_.get());
 
   // Reopening the origin/cache creates a new CacheStorage instance with a new
   // random key.
@@ -1664,7 +1668,8 @@ TEST_F(CacheStorageManagerTest, MAYBE_GetAllOriginsUsageWithOldIndex) {
   // Create a new CacheStorageManager that hasn't yet loaded the origin.
   CreateStorageManager();
   quota_manager_proxy_->SimulateQuotaManagerDestroyed();
-  cache_manager_ = CacheStorageManager::CreateForTesting(cache_manager_.get());
+  cache_manager_ =
+      LegacyCacheStorageManager::CreateForTesting(cache_manager_.get());
 
   // Create a second value (V2) in the cache.
   EXPECT_TRUE(Open(origin1_, kCacheName));
@@ -1732,7 +1737,8 @@ TEST_F(CacheStorageManagerTest, MAYBE_GetOriginSizeWithOldIndex) {
   // Create a new CacheStorageManager that hasn't yet loaded the origin.
   CreateStorageManager();
   quota_manager_proxy_->SimulateQuotaManagerDestroyed();
-  cache_manager_ = CacheStorageManager::CreateForTesting(cache_manager_.get());
+  cache_manager_ =
+      LegacyCacheStorageManager::CreateForTesting(cache_manager_.get());
 
   // Reopen the cache and write a second value (V2).
   EXPECT_TRUE(Open(origin1_, kCacheName));
@@ -1825,7 +1831,7 @@ TEST_F(CacheStorageManagerTest, DeleteUnreferencedCacheDirectories) {
       CachePut(callback_cache_handle_.value(), GURL("http://example.com/foo")));
 
   // Create an unreferenced directory next to the referenced one.
-  base::FilePath origin_path = CacheStorageManager::ConstructOriginPath(
+  base::FilePath origin_path = LegacyCacheStorageManager::ConstructOriginPath(
       cache_manager_->root_path(), origin1_, CacheStorageOwner::kCacheAPI);
   base::FilePath unreferenced_path = origin_path.AppendASCII("bar");
   EXPECT_TRUE(CreateDirectory(unreferenced_path));
@@ -1834,7 +1840,8 @@ TEST_F(CacheStorageManagerTest, DeleteUnreferencedCacheDirectories) {
   // Create a new StorageManager so that the next time the cache is opened
   // the unreferenced directory can be deleted.
   quota_manager_proxy_->SimulateQuotaManagerDestroyed();
-  cache_manager_ = CacheStorageManager::CreateForTesting(cache_manager_.get());
+  cache_manager_ =
+      LegacyCacheStorageManager::CreateForTesting(cache_manager_.get());
 
   // Verify that the referenced cache still works.
   EXPECT_TRUE(Open(origin1_, "foo"));
@@ -2424,7 +2431,8 @@ TEST_F(CacheStorageQuotaClientDiskOnlyTest, QuotaDeleteUnloadedOriginData) {
 
   // Create a new CacheStorageManager that hasn't yet loaded the origin.
   quota_manager_proxy_->SimulateQuotaManagerDestroyed();
-  cache_manager_ = CacheStorageManager::CreateForTesting(cache_manager_.get());
+  cache_manager_ =
+      LegacyCacheStorageManager::CreateForTesting(cache_manager_.get());
   quota_client_.reset(new CacheStorageQuotaClient(
       cache_manager_->AsWeakPtr(), CacheStorageOwner::kCacheAPI));
 

content/browser/cache_storage/legacy/legacy_cache_storage.cc

@@ -559,7 +559,7 @@ LegacyCacheStorage::LegacyCacheStorage(
     scoped_refptr<base::SequencedTaskRunner> scheduler_task_runner,
     scoped_refptr<storage::QuotaManagerProxy> quota_manager_proxy,
     base::WeakPtr<storage::BlobStorageContext> blob_context,
-    CacheStorageManager* cache_storage_manager,
+    LegacyCacheStorageManager* cache_storage_manager,
     const url::Origin& origin,
     CacheStorageOwner owner)
     : CacheStorage(origin),

content/browser/cache_storage/legacy/legacy_cache_storage.h

@@ -29,9 +29,9 @@ class BlobStorageContext;
 
 namespace content {
 class CacheStorageIndex;
-class CacheStorageManager;
 class CacheStorageScheduler;
 enum class CacheStorageOwner;
+class LegacyCacheStorageManager;
 
 namespace cache_storage_manager_unittest {
 class CacheStorageManagerTest;
@@ -57,7 +57,7 @@ class CONTENT_EXPORT LegacyCacheStorage : public CacheStorage,
       scoped_refptr<base::SequencedTaskRunner> scheduler_task_runner,
       scoped_refptr<storage::QuotaManagerProxy> quota_manager_proxy,
       base::WeakPtr<storage::BlobStorageContext> blob_context,
-      CacheStorageManager* cache_storage_manager,
+      LegacyCacheStorageManager* cache_storage_manager,
       const url::Origin& origin,
       CacheStorageOwner owner);
 
@@ -297,7 +297,7 @@ class CONTENT_EXPORT LegacyCacheStorage : public CacheStorage,
 
   // The manager that owns this cache storage. Only set to null by
   // RemoveManager() when this cache storage is being deleted.
-  CacheStorageManager* cache_storage_manager_;
+  LegacyCacheStorageManager* cache_storage_manager_;
 
   base::CancelableOnceClosure index_write_task_;
   size_t handle_ref_count_ = 0;