Rename ServiceWorkerFetchStore/FetchStores/FetchStoresManager

content/browser/service_worker/service_worker_cache_storage_manager_unittest.cc

Index: content/browser/service_worker/service_worker_cache_storage_manager_unittest.cc
diff --git a/content/browser/service_worker/service_worker_fetch_stores_manager_unittest.cc b/content/browser/service_worker/service_worker_cache_storage_manager_unittest.cc
similarity index 49%
rename from content/browser/service_worker/service_worker_fetch_stores_manager_unittest.cc
rename to content/browser/service_worker/service_worker_cache_storage_manager_unittest.cc
index 3c25be448be589594d4482b7f6e089d55333a34c..0ec9c2e80f65b63802e2ed7c9695b4511968a3be 100644
--- a/content/browser/service_worker/service_worker_fetch_stores_manager_unittest.cc
+++ b/content/browser/service_worker/service_worker_cache_storage_manager_unittest.cc
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "content/browser/service_worker/service_worker_fetch_stores_manager.h"
+#include "content/browser/service_worker/service_worker_cache_storage_manager.h"
 
 #include "base/files/file_path.h"
 #include "base/files/scoped_temp_dir.h"
@@ -14,41 +14,44 @@
 
 namespace content {
 
-class ServiceWorkerFetchStoresManagerTest : public testing::Test {
+class ServiceWorkerCacheStorageManagerTest : public testing::Test {
  protected:
-  ServiceWorkerFetchStoresManagerTest()
+  ServiceWorkerCacheStorageManagerTest()
       : browser_thread_bundle_(TestBrowserThreadBundle::IO_MAINLOOP),
         callback_bool_(false),
-        callback_store_(0),
-        callback_error_(ServiceWorkerFetchStores::FETCH_STORES_ERROR_NO_ERROR),
+        callback_cache_id_(0),
+        callback_error_(
+            ServiceWorkerCacheStorage::CACHE_STORAGE_ERROR_NO_ERROR),
         origin1_("http://example1.com"),
         origin2_("http://example2.com") {}
 
   virtual void SetUp() OVERRIDE {
     if (MemoryOnly()) {
-      stores_ = ServiceWorkerFetchStoresManager::Create(
+      cache_manager_ = ServiceWorkerCacheStorageManager::Create(
           base::FilePath(), base::MessageLoopProxy::current());
     } else {
       ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
-      stores_ = ServiceWorkerFetchStoresManager::Create(
+      cache_manager_ = ServiceWorkerCacheStorageManager::Create(
           temp_dir_.path(), base::MessageLoopProxy::current());
     }
   }
 
   virtual bool MemoryOnly() { return false; }
 
-  void BoolAndErrorCallback(base::RunLoop* run_loop,
-                            bool value,
-                            ServiceWorkerFetchStores::FetchStoresError error) {
+  void BoolAndErrorCallback(
+      base::RunLoop* run_loop,
+      bool value,
+      ServiceWorkerCacheStorage::CacheStorageError error) {
     callback_bool_ = value;
     callback_error_ = error;
     run_loop->Quit();
   }
 
-  void StoreAndErrorCallback(base::RunLoop* run_loop,
-                             int store,
-                             ServiceWorkerFetchStores::FetchStoresError error) {
-    callback_store_ = store;
+  void CacheAndErrorCallback(
+      base::RunLoop* run_loop,
+      int cache_id,
+      ServiceWorkerCacheStorage::CacheStorageError error) {
+    callback_cache_id_ = cache_id;
     callback_error_ = error;
     run_loop->Quit();
   }
@@ -56,56 +59,56 @@ class ServiceWorkerFetchStoresManagerTest : public testing::Test {
   void StringsAndErrorCallback(
       base::RunLoop* run_loop,
       const std::vector<std::string>& strings,
-      ServiceWorkerFetchStores::FetchStoresError error) {
+      ServiceWorkerCacheStorage::CacheStorageError error) {
     callback_strings_ = strings;
     callback_error_ = error;
     run_loop->Quit();
   }
 
-  bool CreateStore(const GURL& origin, std::string key) {
+  bool CreateCache(const GURL& origin, const std::string& cache_name) {
     scoped_ptr<base::RunLoop> loop(new base::RunLoop());
-    stores_->CreateStore(
+    cache_manager_->CreateCache(
         origin,
-        key,
-        base::Bind(&ServiceWorkerFetchStoresManagerTest::StoreAndErrorCallback,
+        cache_name,
+        base::Bind(&ServiceWorkerCacheStorageManagerTest::CacheAndErrorCallback,
                    base::Unretained(this),
                    base::Unretained(loop.get())));
     loop->Run();
 
     bool error = callback_error_ !=
-                 ServiceWorkerFetchStores::FETCH_STORES_ERROR_NO_ERROR;
+                 ServiceWorkerCacheStorage::CACHE_STORAGE_ERROR_NO_ERROR;
     if (error)
-      EXPECT_EQ(0, callback_store_);
+      EXPECT_EQ(0, callback_cache_id_);
     else
-      EXPECT_LT(0, callback_store_);
+      EXPECT_LT(0, callback_cache_id_);
     return !error;
   }
 
-  bool Get(const GURL& origin, std::string key) {
+  bool Get(const GURL& origin, const std::string& cache_name) {
     scoped_ptr<base::RunLoop> loop(new base::RunLoop());
-    stores_->GetStore(
+    cache_manager_->GetCache(
         origin,
-        key,
-        base::Bind(&ServiceWorkerFetchStoresManagerTest::StoreAndErrorCallback,
+        cache_name,
+        base::Bind(&ServiceWorkerCacheStorageManagerTest::CacheAndErrorCallback,
                    base::Unretained(this),
                    base::Unretained(loop.get())));
     loop->Run();
 
     bool error = callback_error_ !=
-                 ServiceWorkerFetchStores::FETCH_STORES_ERROR_NO_ERROR;
+                 ServiceWorkerCacheStorage::CACHE_STORAGE_ERROR_NO_ERROR;
     if (error)
-      EXPECT_EQ(0, callback_store_);
+      EXPECT_EQ(0, callback_cache_id_);
     else
-      EXPECT_LT(0, callback_store_);
+      EXPECT_LT(0, callback_cache_id_);
     return !error;
   }
 
-  bool Has(const GURL& origin, std::string key) {
+  bool Has(const GURL& origin, const std::string& cache_name) {
     scoped_ptr<base::RunLoop> loop(new base::RunLoop());
-    stores_->HasStore(
+    cache_manager_->HasCache(
         origin,
-        key,
-        base::Bind(&ServiceWorkerFetchStoresManagerTest::BoolAndErrorCallback,
+        cache_name,
+        base::Bind(&ServiceWorkerCacheStorageManagerTest::BoolAndErrorCallback,
                    base::Unretained(this),
                    base::Unretained(loop.get())));
     loop->Run();
@@ -113,12 +116,12 @@ class ServiceWorkerFetchStoresManagerTest : public testing::Test {
     return callback_bool_;
   }
 
-  bool Delete(const GURL& origin, std::string key) {
+  bool Delete(const GURL& origin, const std::string& cache_name) {
     scoped_ptr<base::RunLoop> loop(new base::RunLoop());
-    stores_->DeleteStore(
+    cache_manager_->DeleteCache(
         origin,
-        key,
-        base::Bind(&ServiceWorkerFetchStoresManagerTest::BoolAndErrorCallback,
+        cache_name,
+        base::Bind(&ServiceWorkerCacheStorageManagerTest::BoolAndErrorCallback,
                    base::Unretained(this),
                    base::Unretained(loop.get())));
     loop->Run();
@@ -128,16 +131,16 @@ class ServiceWorkerFetchStoresManagerTest : public testing::Test {
 
   bool Keys(const GURL& origin) {
     scoped_ptr<base::RunLoop> loop(new base::RunLoop());
-    stores_->EnumerateStores(
+    cache_manager_->EnumerateCaches(
         origin,
         base::Bind(
-            &ServiceWorkerFetchStoresManagerTest::StringsAndErrorCallback,
+            &ServiceWorkerCacheStorageManagerTest::StringsAndErrorCallback,
             base::Unretained(this),
             base::Unretained(loop.get())));
     loop->Run();
 
     bool error = callback_error_ !=
-                 ServiceWorkerFetchStores::FETCH_STORES_ERROR_NO_ERROR;
+                 ServiceWorkerCacheStorage::CACHE_STORAGE_ERROR_NO_ERROR;
     return !error;
   }
 
@@ -160,104 +163,104 @@ class ServiceWorkerFetchStoresManagerTest : public testing::Test {
   TestBrowserThreadBundle browser_thread_bundle_;
 
   base::ScopedTempDir temp_dir_;
-  scoped_ptr<ServiceWorkerFetchStoresManager> stores_;
+  scoped_ptr<ServiceWorkerCacheStorageManager> cache_manager_;
 
   int callback_bool_;
-  int callback_store_;
-  ServiceWorkerFetchStores::FetchStoresError callback_error_;
+  int callback_cache_id_;
+  ServiceWorkerCacheStorage::CacheStorageError callback_error_;
   std::vector<std::string> callback_strings_;
 
   const GURL origin1_;
   const GURL origin2_;
 
  private:
-  DISALLOW_COPY_AND_ASSIGN(ServiceWorkerFetchStoresManagerTest);
+  DISALLOW_COPY_AND_ASSIGN(ServiceWorkerCacheStorageManagerTest);
 };
 
-class ServiceWorkerFetchStoresManagerMemoryOnlyTest
-    : public ServiceWorkerFetchStoresManagerTest {
+class ServiceWorkerCacheStorageManagerMemoryOnlyTest
+    : public ServiceWorkerCacheStorageManagerTest {
   virtual bool MemoryOnly() OVERRIDE { return true; }
 };
 
-class ServiceWorkerFetchStoresManagerTestP
-    : public ServiceWorkerFetchStoresManagerTest,
+class ServiceWorkerCacheStorageManagerTestP
+    : public ServiceWorkerCacheStorageManagerTest,
       public testing::WithParamInterface<bool> {
   virtual bool MemoryOnly() OVERRIDE { return !GetParam(); }
 };
 
-TEST_F(ServiceWorkerFetchStoresManagerTest, TestsRunOnIOThread) {
+TEST_F(ServiceWorkerCacheStorageManagerTest, TestsRunOnIOThread) {
   EXPECT_TRUE(BrowserThread::CurrentlyOn(BrowserThread::IO));
 }
 
-TEST_P(ServiceWorkerFetchStoresManagerTestP, CreateStore) {
-  EXPECT_TRUE(CreateStore(origin1_, "foo"));
+TEST_P(ServiceWorkerCacheStorageManagerTestP, CreateCache) {
+  EXPECT_TRUE(CreateCache(origin1_, "foo"));
 }
 
-TEST_P(ServiceWorkerFetchStoresManagerTestP, CreateDuplicateStore) {
-  EXPECT_TRUE(CreateStore(origin1_, "foo"));
-  EXPECT_FALSE(CreateStore(origin1_, "foo"));
-  EXPECT_EQ(ServiceWorkerFetchStores::FETCH_STORES_ERROR_EXISTS,
+TEST_P(ServiceWorkerCacheStorageManagerTestP, CreateDuplicateCache) {
+  EXPECT_TRUE(CreateCache(origin1_, "foo"));
+  EXPECT_FALSE(CreateCache(origin1_, "foo"));
+  EXPECT_EQ(ServiceWorkerCacheStorage::CACHE_STORAGE_ERROR_EXISTS,
             callback_error_);
 }
 
-TEST_P(ServiceWorkerFetchStoresManagerTestP, Create2Stores) {
-  EXPECT_TRUE(CreateStore(origin1_, "foo"));
-  EXPECT_TRUE(CreateStore(origin1_, "bar"));
+TEST_P(ServiceWorkerCacheStorageManagerTestP, CreateTwoCaches) {
+  EXPECT_TRUE(CreateCache(origin1_, "foo"));
+  EXPECT_TRUE(CreateCache(origin1_, "bar"));
 }
 
-TEST_P(ServiceWorkerFetchStoresManagerTestP, Create2StoresSameNameDiffSWs) {
-  EXPECT_TRUE(CreateStore(origin1_, "foo"));
-  EXPECT_TRUE(CreateStore(origin2_, "foo"));
+TEST_P(ServiceWorkerCacheStorageManagerTestP, Create2CachesSameNameDiffSWs) {
+  EXPECT_TRUE(CreateCache(origin1_, "foo"));
+  EXPECT_TRUE(CreateCache(origin2_, "foo"));
 }
 
-TEST_P(ServiceWorkerFetchStoresManagerTestP, GetStore) {
-  EXPECT_TRUE(CreateStore(origin1_, "foo"));
-  int store = callback_store_;
+TEST_P(ServiceWorkerCacheStorageManagerTestP, GetCache) {
+  EXPECT_TRUE(CreateCache(origin1_, "foo"));
+  int cache_id = callback_cache_id_;
   EXPECT_TRUE(Get(origin1_, "foo"));
-  EXPECT_EQ(store, callback_store_);
+  EXPECT_EQ(cache_id, callback_cache_id_);
 }
 
-TEST_P(ServiceWorkerFetchStoresManagerTestP, GetNonExistent) {
+TEST_P(ServiceWorkerCacheStorageManagerTestP, GetNonExistent) {
   EXPECT_FALSE(Get(origin1_, "foo"));
-  EXPECT_EQ(ServiceWorkerFetchStores::FETCH_STORES_ERROR_NOT_FOUND,
+  EXPECT_EQ(ServiceWorkerCacheStorage::CACHE_STORAGE_ERROR_NOT_FOUND,
             callback_error_);
 }
 
-TEST_P(ServiceWorkerFetchStoresManagerTestP, HasStore) {
-  EXPECT_TRUE(CreateStore(origin1_, "foo"));
+TEST_P(ServiceWorkerCacheStorageManagerTestP, HasCache) {
+  EXPECT_TRUE(CreateCache(origin1_, "foo"));
   EXPECT_TRUE(Has(origin1_, "foo"));
   EXPECT_TRUE(callback_bool_);
 }
 
-TEST_P(ServiceWorkerFetchStoresManagerTestP, HasNonExistent) {
+TEST_P(ServiceWorkerCacheStorageManagerTestP, HasNonExistent) {
   EXPECT_FALSE(Has(origin1_, "foo"));
 }
 
-TEST_P(ServiceWorkerFetchStoresManagerTestP, DeleteStore) {
-  EXPECT_TRUE(CreateStore(origin1_, "foo"));
+TEST_P(ServiceWorkerCacheStorageManagerTestP, DeleteCache) {
+  EXPECT_TRUE(CreateCache(origin1_, "foo"));
   EXPECT_TRUE(Delete(origin1_, "foo"));
   EXPECT_FALSE(Get(origin1_, "foo"));
-  EXPECT_EQ(ServiceWorkerFetchStores::FETCH_STORES_ERROR_NOT_FOUND,
+  EXPECT_EQ(ServiceWorkerCacheStorage::CACHE_STORAGE_ERROR_NOT_FOUND,
             callback_error_);
 }
 
-TEST_P(ServiceWorkerFetchStoresManagerTestP, DeleteTwice) {
-  EXPECT_TRUE(CreateStore(origin1_, "foo"));
+TEST_P(ServiceWorkerCacheStorageManagerTestP, DeleteTwice) {
+  EXPECT_TRUE(CreateCache(origin1_, "foo"));
   EXPECT_TRUE(Delete(origin1_, "foo"));
   EXPECT_FALSE(Delete(origin1_, "foo"));
-  EXPECT_EQ(ServiceWorkerFetchStores::FETCH_STORES_ERROR_NOT_FOUND,
+  EXPECT_EQ(ServiceWorkerCacheStorage::CACHE_STORAGE_ERROR_NOT_FOUND,
             callback_error_);
 }
 
-TEST_P(ServiceWorkerFetchStoresManagerTestP, EmptyKeys) {
+TEST_P(ServiceWorkerCacheStorageManagerTestP, EmptyKeys) {
   EXPECT_TRUE(Keys(origin1_));
   EXPECT_TRUE(callback_strings_.empty());
 }
 
-TEST_P(ServiceWorkerFetchStoresManagerTestP, SomeKeys) {
-  EXPECT_TRUE(CreateStore(origin1_, "foo"));
-  EXPECT_TRUE(CreateStore(origin1_, "bar"));
-  EXPECT_TRUE(CreateStore(origin2_, "baz"));
+TEST_P(ServiceWorkerCacheStorageManagerTestP, SomeKeys) {
+  EXPECT_TRUE(CreateCache(origin1_, "foo"));
+  EXPECT_TRUE(CreateCache(origin1_, "bar"));
+  EXPECT_TRUE(CreateCache(origin2_, "baz"));
   EXPECT_TRUE(Keys(origin1_));
   EXPECT_EQ(2u, callback_strings_.size());
   std::vector<std::string> expected_keys;
@@ -269,51 +272,52 @@ TEST_P(ServiceWorkerFetchStoresManagerTestP, SomeKeys) {
   EXPECT_STREQ("baz", callback_strings_[0].c_str());
 }
 
-TEST_P(ServiceWorkerFetchStoresManagerTestP, DeletedKeysGone) {
-  EXPECT_TRUE(CreateStore(origin1_, "foo"));
-  EXPECT_TRUE(CreateStore(origin1_, "bar"));
-  EXPECT_TRUE(CreateStore(origin2_, "baz"));
+TEST_P(ServiceWorkerCacheStorageManagerTestP, DeletedKeysGone) {
+  EXPECT_TRUE(CreateCache(origin1_, "foo"));
+  EXPECT_TRUE(CreateCache(origin1_, "bar"));
+  EXPECT_TRUE(CreateCache(origin2_, "baz"));
   EXPECT_TRUE(Delete(origin1_, "bar"));
   EXPECT_TRUE(Keys(origin1_));
   EXPECT_EQ(1u, callback_strings_.size());
   EXPECT_STREQ("foo", callback_strings_[0].c_str());
 }
 
-TEST_P(ServiceWorkerFetchStoresManagerTestP, Chinese) {
-  EXPECT_TRUE(CreateStore(origin1_, "你好"));
-  int store = callback_store_;
+TEST_P(ServiceWorkerCacheStorageManagerTestP, Chinese) {
+  EXPECT_TRUE(CreateCache(origin1_, "你好"));
+  int cache_id = callback_cache_id_;
   EXPECT_TRUE(Get(origin1_, "你好"));
-  EXPECT_EQ(store, callback_store_);
+  EXPECT_EQ(cache_id, callback_cache_id_);
   EXPECT_TRUE(Keys(origin1_));
   EXPECT_EQ(1u, callback_strings_.size());
   EXPECT_TRUE("你好" == callback_strings_[0]);
 }
 
-TEST_F(ServiceWorkerFetchStoresManagerTest, EmptyKey) {
-  EXPECT_FALSE(CreateStore(origin1_, ""));
-  EXPECT_EQ(ServiceWorkerFetchStores::FETCH_STORES_ERROR_EMPTY_KEY,
+TEST_F(ServiceWorkerCacheStorageManagerTest, EmptyKey) {
+  EXPECT_FALSE(CreateCache(origin1_, ""));
+  EXPECT_EQ(ServiceWorkerCacheStorage::CACHE_STORAGE_ERROR_EMPTY_KEY,
             callback_error_);
 
   EXPECT_FALSE(Get(origin1_, ""));
-  EXPECT_EQ(ServiceWorkerFetchStores::FETCH_STORES_ERROR_EMPTY_KEY,
+  EXPECT_EQ(ServiceWorkerCacheStorage::CACHE_STORAGE_ERROR_EMPTY_KEY,
             callback_error_);
 
   EXPECT_FALSE(Has(origin1_, ""));
-  EXPECT_EQ(ServiceWorkerFetchStores::FETCH_STORES_ERROR_EMPTY_KEY,
+  EXPECT_EQ(ServiceWorkerCacheStorage::CACHE_STORAGE_ERROR_EMPTY_KEY,
             callback_error_);
 
   EXPECT_FALSE(Delete(origin1_, ""));
-  EXPECT_EQ(ServiceWorkerFetchStores::FETCH_STORES_ERROR_EMPTY_KEY,
+  EXPECT_EQ(ServiceWorkerCacheStorage::CACHE_STORAGE_ERROR_EMPTY_KEY,
             callback_error_);
 }
 
-TEST_F(ServiceWorkerFetchStoresManagerTest, DataPersists) {
-  EXPECT_TRUE(CreateStore(origin1_, "foo"));
-  EXPECT_TRUE(CreateStore(origin1_, "bar"));
-  EXPECT_TRUE(CreateStore(origin1_, "baz"));
-  EXPECT_TRUE(CreateStore(origin2_, "raz"));
+TEST_F(ServiceWorkerCacheStorageManagerTest, DataPersists) {
+  EXPECT_TRUE(CreateCache(origin1_, "foo"));
+  EXPECT_TRUE(CreateCache(origin1_, "bar"));
+  EXPECT_TRUE(CreateCache(origin1_, "baz"));
+  EXPECT_TRUE(CreateCache(origin2_, "raz"));
   EXPECT_TRUE(Delete(origin1_, "bar"));
-  stores_ = ServiceWorkerFetchStoresManager::Create(stores_.get());
+  cache_manager_ =
+      ServiceWorkerCacheStorageManager::Create(cache_manager_.get());
   EXPECT_TRUE(Keys(origin1_));
   EXPECT_EQ(2u, callback_strings_.size());
   std::vector<std::string> expected_keys;
@@ -322,36 +326,37 @@ TEST_F(ServiceWorkerFetchStoresManagerTest, DataPersists) {
   EXPECT_TRUE(VerifyKeys(expected_keys));
 }
 
-TEST_F(ServiceWorkerFetchStoresManagerMemoryOnlyTest, DataLostWhenMemoryOnly) {
-  EXPECT_TRUE(CreateStore(origin1_, "foo"));
-  EXPECT_TRUE(CreateStore(origin2_, "baz"));
-  stores_ = ServiceWorkerFetchStoresManager::Create(stores_.get());
+TEST_F(ServiceWorkerCacheStorageManagerMemoryOnlyTest, DataLostWhenMemoryOnly) {
+  EXPECT_TRUE(CreateCache(origin1_, "foo"));
+  EXPECT_TRUE(CreateCache(origin2_, "baz"));
+  cache_manager_ =
+      ServiceWorkerCacheStorageManager::Create(cache_manager_.get());
   EXPECT_TRUE(Keys(origin1_));
   EXPECT_EQ(0u, callback_strings_.size());
 }
 
-TEST_F(ServiceWorkerFetchStoresManagerTest, BadStoreName) {
-  // Since the implementation writes store names to disk, ensure that we don't
+TEST_F(ServiceWorkerCacheStorageManagerTest, BadCacheName) {
+  // Since the implementation writes cache names to disk, ensure that we don't
   // escape the directory.
   const std::string bad_name = "../../../../../../../../../../../../../../foo";
-  EXPECT_TRUE(CreateStore(origin1_, bad_name));
+  EXPECT_TRUE(CreateCache(origin1_, bad_name));
   EXPECT_TRUE(Keys(origin1_));
   EXPECT_EQ(1u, callback_strings_.size());
   EXPECT_STREQ(bad_name.c_str(), callback_strings_[0].c_str());
 }
 
-TEST_F(ServiceWorkerFetchStoresManagerTest, BadOriginName) {
+TEST_F(ServiceWorkerCacheStorageManagerTest, BadOriginName) {
   // Since the implementation writes origin names to disk, ensure that we don't
   // escape the directory.
   GURL bad_origin("../../../../../../../../../../../../../../foo");
-  EXPECT_TRUE(CreateStore(bad_origin, "foo"));
+  EXPECT_TRUE(CreateCache(bad_origin, "foo"));
   EXPECT_TRUE(Keys(bad_origin));
   EXPECT_EQ(1u, callback_strings_.size());
   EXPECT_STREQ("foo", callback_strings_[0].c_str());
 }
 
-INSTANTIATE_TEST_CASE_P(ServiceWorkerFetchStoresManagerTests,
-                        ServiceWorkerFetchStoresManagerTestP,
+INSTANTIATE_TEST_CASE_P(ServiceWorkerCacheStorageManagerTests,
+                        ServiceWorkerCacheStorageManagerTestP,
                         ::testing::Values(false, true));
 
 }  // namespace content