CacheStorage: Merge CacheStorage::CacheStorageError and CacheStorageCache::ErrorType

content/browser/cache_storage/cache_storage_manager_unittest.cc

 // Copyright 2014 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 "content/browser/cache_storage/cache_storage_manager.h"
 
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/message_loop/message_loop_proxy.h"
@@ skipping 10 matching lines @@
 #include "storage/browser/quota/quota_manager_proxy.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace content {
 
 class CacheStorageManagerTest : public testing::Test {
  public:
   CacheStorageManagerTest()
       : browser_thread_bundle_(TestBrowserThreadBundle::IO_MAINLOOP),
         callback_bool_(false),
-        callback_error_(CacheStorage::CACHE_STORAGE_ERROR_NO_ERROR),
-        callback_cache_error_(CacheStorageCache::ERROR_TYPE_OK),
+        callback_error_(CACHE_STORAGE_OK),
+        callback_cache_error_(CACHE_STORAGE_OK),
         origin1_("http://example1.com"),
         origin2_("http://example2.com") {}
 
   void SetUp() override {
     ChromeBlobStorageContext* blob_storage_context(
         ChromeBlobStorageContext::GetFor(&browser_context_));
     // Wait for ChromeBlobStorageContext to finish initializing.
     base::RunLoop().RunUntilIdle();
 
     quota_manager_proxy_ = new MockQuotaManagerProxy(
@@ skipping 18 matching lines @@
 
   void TearDown() override {
     quota_manager_proxy_->SimulateQuotaManagerDestroyed();
     base::RunLoop().RunUntilIdle();
   }
 
   virtual bool MemoryOnly() { return false; }
 
   void BoolAndErrorCallback(base::RunLoop* run_loop,
                             bool value,
-                            CacheStorage::CacheStorageError error) {
+                            CacheStorageError error) {
     callback_bool_ = value;
     callback_error_ = error;
     run_loop->Quit();
   }
 
   void CacheAndErrorCallback(base::RunLoop* run_loop,
                              const scoped_refptr<CacheStorageCache>& cache,
-                             CacheStorage::CacheStorageError error) {
+                             CacheStorageError error) {
     callback_cache_ = cache;
     callback_error_ = error;
     run_loop->Quit();
   }
 
   void StringsAndErrorCallback(base::RunLoop* run_loop,
                                const std::vector<std::string>& strings,
-                               CacheStorage::CacheStorageError error) {
+                               CacheStorageError error) {
     callback_strings_ = strings;
     callback_error_ = error;
     run_loop->Quit();
   }
 
-  void CachePutCallback(base::RunLoop* run_loop,
-                        CacheStorageCache::ErrorType error) {
+  void CachePutCallback(base::RunLoop* run_loop, CacheStorageError error) {
     callback_cache_error_ = error;
     run_loop->Quit();
   }
 
   void CacheMatchCallback(
       base::RunLoop* run_loop,
-      CacheStorageCache::ErrorType error,
+      CacheStorageError error,
       scoped_ptr<ServiceWorkerResponse> response,
       scoped_ptr<storage::BlobDataHandle> blob_data_handle) {
     callback_cache_error_ = error;
     callback_cache_response_ = response.Pass();
     // Deliberately drop the data handle as only the url is being tested.
     run_loop->Quit();
   }
 
   bool Open(const GURL& origin, const std::string& cache_name) {
     scoped_ptr<base::RunLoop> loop(new base::RunLoop());
     cache_manager_->OpenCache(
         origin, cache_name,
         base::Bind(&CacheStorageManagerTest::CacheAndErrorCallback,
                    base::Unretained(this), base::Unretained(loop.get())));
     loop->Run();
 
-    bool error = callback_error_ != CacheStorage::CACHE_STORAGE_ERROR_NO_ERROR;
+    bool error = callback_error_ != CACHE_STORAGE_OK;
     if (error)
       EXPECT_TRUE(!callback_cache_.get());
     else
       EXPECT_TRUE(callback_cache_.get());
     return !error;
   }
 
   bool Has(const GURL& origin, const std::string& cache_name) {
     scoped_ptr<base::RunLoop> loop(new base::RunLoop());
     cache_manager_->HasCache(
@@ skipping 17 matching lines @@
   }
 
   bool Keys(const GURL& origin) {
     scoped_ptr<base::RunLoop> loop(new base::RunLoop());
     cache_manager_->EnumerateCaches(
         origin,
         base::Bind(&CacheStorageManagerTest::StringsAndErrorCallback,
                    base::Unretained(this), base::Unretained(loop.get())));
     loop->Run();
 
-    bool error = callback_error_ != CacheStorage::CACHE_STORAGE_ERROR_NO_ERROR;
+    bool error = callback_error_ != CACHE_STORAGE_OK;
     return !error;
   }
 
   bool StorageMatch(const GURL& origin,
                     const std::string& cache_name,
                     const GURL& url) {
     scoped_ptr<ServiceWorkerFetchRequest> request(
         new ServiceWorkerFetchRequest());
     request->url = url;
     scoped_ptr<base::RunLoop> loop(new base::RunLoop());
     cache_manager_->MatchCache(
         origin, cache_name, request.Pass(),
         base::Bind(&CacheStorageManagerTest::CacheMatchCallback,
                    base::Unretained(this), base::Unretained(loop.get())));
     loop->Run();
 
-    bool error = callback_cache_error_ != CacheStorageCache::ERROR_TYPE_OK;
+    bool error = callback_cache_error_ != CACHE_STORAGE_OK;
     return !error;
   }
 
   bool StorageMatchAll(const GURL& origin, const GURL& url) {
     scoped_ptr<ServiceWorkerFetchRequest> request(
         new ServiceWorkerFetchRequest());
     request->url = url;
     scoped_ptr<base::RunLoop> loop(new base::RunLoop());
     cache_manager_->MatchAllCaches(
         origin, request.Pass(),
         base::Bind(&CacheStorageManagerTest::CacheMatchCallback,
                    base::Unretained(this), base::Unretained(loop.get())));
     loop->Run();
 
-    bool error = callback_cache_error_ != CacheStorageCache::ERROR_TYPE_OK;
+    bool error = callback_cache_error_ != CACHE_STORAGE_OK;
     return !error;
   }
 
   bool CachePut(const scoped_refptr<CacheStorageCache>& cache,
                 const GURL& url) {
     scoped_ptr<ServiceWorkerFetchRequest> request(
         new ServiceWorkerFetchRequest());
     scoped_ptr<ServiceWorkerResponse> response(new ServiceWorkerResponse());
     request->url = url;
     response->url = url;
     scoped_ptr<base::RunLoop> loop(new base::RunLoop());
     cache->Put(
         request.Pass(), response.Pass(),
         base::Bind(&CacheStorageManagerTest::CachePutCallback,
                    base::Unretained(this), base::Unretained(loop.get())));
     loop->Run();
 
-    bool error = callback_cache_error_ != CacheStorageCache::ERROR_TYPE_OK;
+    bool error = callback_cache_error_ != CACHE_STORAGE_OK;
     return !error;
   }
 
   bool CacheMatch(const scoped_refptr<CacheStorageCache>& cache,
                   const GURL& url) {
     scoped_ptr<ServiceWorkerFetchRequest> request(
         new ServiceWorkerFetchRequest());
     request->url = url;
     scoped_ptr<base::RunLoop> loop(new base::RunLoop());
     cache->Match(
         request.Pass(),
         base::Bind(&CacheStorageManagerTest::CacheMatchCallback,
                    base::Unretained(this), base::Unretained(loop.get())));
     loop->Run();
 
-    bool error = callback_cache_error_ != CacheStorageCache::ERROR_TYPE_OK;
+    bool error = callback_cache_error_ != CACHE_STORAGE_OK;
     return !error;
   }
 
   CacheStorage* CacheStorageForOrigin(const GURL& origin) {
     return cache_manager_->FindOrCreateCacheStorage(origin);
   }
 
  protected:
   TestBrowserContext browser_context_;
   TestBrowserThreadBundle browser_thread_bundle_;
 
   base::ScopedTempDir temp_dir_;
   scoped_refptr<MockQuotaManagerProxy> quota_manager_proxy_;
   scoped_ptr<CacheStorageManager> cache_manager_;
 
   scoped_refptr<CacheStorageCache> callback_cache_;
   int callback_bool_;
-  CacheStorage::CacheStorageError callback_error_;
-  CacheStorageCache::ErrorType callback_cache_error_;
+  CacheStorageError callback_error_;
+  CacheStorageError callback_cache_error_;
   scoped_ptr<ServiceWorkerResponse> callback_cache_response_;
   std::vector<std::string> callback_strings_;
 
   const GURL origin1_;
   const GURL origin2_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(CacheStorageManagerTest);
 };
 
@@ skipping 53 matching lines @@
 TEST_P(CacheStorageManagerTestP, DeleteCache) {
   EXPECT_TRUE(Open(origin1_, "foo"));
   EXPECT_TRUE(Delete(origin1_, "foo"));
   EXPECT_FALSE(Has(origin1_, "foo"));
 }
 
 TEST_P(CacheStorageManagerTestP, DeleteTwice) {
   EXPECT_TRUE(Open(origin1_, "foo"));
   EXPECT_TRUE(Delete(origin1_, "foo"));
   EXPECT_FALSE(Delete(origin1_, "foo"));
-  EXPECT_EQ(CacheStorage::CACHE_STORAGE_ERROR_NOT_FOUND, callback_error_);
+  EXPECT_EQ(CACHE_STORAGE_ERROR_NOT_FOUND, callback_error_);
 }
 
 TEST_P(CacheStorageManagerTestP, EmptyKeys) {
   EXPECT_TRUE(Keys(origin1_));
   EXPECT_TRUE(callback_strings_.empty());
 }
 
 TEST_P(CacheStorageManagerTestP, SomeKeys) {
   EXPECT_TRUE(Open(origin1_, "foo"));
   EXPECT_TRUE(Open(origin1_, "bar"));
@@ skipping 22 matching lines @@
 TEST_P(CacheStorageManagerTestP, StorageMatchEntryExists) {
   EXPECT_TRUE(Open(origin1_, "foo"));
   EXPECT_TRUE(CachePut(callback_cache_, GURL("http://example.com/foo")));
   EXPECT_TRUE(StorageMatch(origin1_, "foo", GURL("http://example.com/foo")));
 }
 
 TEST_P(CacheStorageManagerTestP, StorageMatchNoEntry) {
   EXPECT_TRUE(Open(origin1_, "foo"));
   EXPECT_TRUE(CachePut(callback_cache_, GURL("http://example.com/foo")));
   EXPECT_FALSE(StorageMatch(origin1_, "foo", GURL("http://example.com/bar")));
-  EXPECT_EQ(CacheStorageCache::ERROR_TYPE_NOT_FOUND, callback_cache_error_);
+  EXPECT_EQ(CACHE_STORAGE_ERROR_NOT_FOUND, callback_cache_error_);
 }
 
 TEST_P(CacheStorageManagerTestP, StorageMatchNoCache) {
   EXPECT_TRUE(Open(origin1_, "foo"));
   EXPECT_TRUE(CachePut(callback_cache_, GURL("http://example.com/foo")));
   EXPECT_FALSE(StorageMatch(origin1_, "bar", GURL("http://example.com/foo")));
-  EXPECT_EQ(CacheStorageCache::ERROR_TYPE_NOT_FOUND, callback_cache_error_);
+  EXPECT_EQ(CACHE_STORAGE_ERROR_NOT_FOUND, callback_cache_error_);
 }
 
 TEST_P(CacheStorageManagerTestP, StorageMatchAllEntryExists) {
   EXPECT_TRUE(Open(origin1_, "foo"));
   EXPECT_TRUE(CachePut(callback_cache_, GURL("http://example.com/foo")));
   EXPECT_TRUE(StorageMatchAll(origin1_, GURL("http://example.com/foo")));
 }
 
 TEST_P(CacheStorageManagerTestP, StorageMatchAllNoEntry) {
   EXPECT_TRUE(Open(origin1_, "foo"));
   EXPECT_TRUE(CachePut(callback_cache_, GURL("http://example.com/foo")));
   EXPECT_FALSE(StorageMatchAll(origin1_, GURL("http://example.com/bar")));
-  EXPECT_EQ(CacheStorageCache::ERROR_TYPE_NOT_FOUND, callback_cache_error_);
+  EXPECT_EQ(CACHE_STORAGE_ERROR_NOT_FOUND, callback_cache_error_);
 }
 
 TEST_P(CacheStorageManagerTestP, StorageMatchAllNoCaches) {
   EXPECT_FALSE(StorageMatchAll(origin1_, GURL("http://example.com/foo")));
-  EXPECT_EQ(CacheStorageCache::ERROR_TYPE_NOT_FOUND, callback_cache_error_);
+  EXPECT_EQ(CACHE_STORAGE_ERROR_NOT_FOUND, callback_cache_error_);
 }
 
 TEST_P(CacheStorageManagerTestP, StorageMatchAllEntryExistsTwice) {
   EXPECT_TRUE(Open(origin1_, "foo"));
   EXPECT_TRUE(CachePut(callback_cache_, GURL("http://example.com/foo")));
   EXPECT_TRUE(Open(origin1_, "bar"));
   EXPECT_TRUE(CachePut(callback_cache_, GURL("http://example.com/foo")));
 
   EXPECT_TRUE(StorageMatchAll(origin1_, GURL("http://example.com/foo")));
 }
@@ skipping 400 matching lines @@
 
 INSTANTIATE_TEST_CASE_P(CacheStorageManagerTests,
                         CacheStorageManagerTestP,
                         ::testing::Values(false, true));
 
 INSTANTIATE_TEST_CASE_P(CacheStorageQuotaClientTests,
                         CacheStorageQuotaClientTestP,
                         ::testing::Values(false, true));
 
 }  // namespace content