CacheStorage: Remove duplicate member from CacheStorageManagerTest for cleanup

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 11 matching lines @@
 #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_(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 41 matching lines @@
 
   void StringsAndErrorCallback(base::RunLoop* run_loop,
                                const std::vector<std::string>& strings,
                                CacheStorageError error) {
     callback_strings_ = strings;
     callback_error_ = error;
     run_loop->Quit();
   }
 
   void CachePutCallback(base::RunLoop* run_loop, CacheStorageError error) {
-    callback_cache_error_ = error;
+    callback_error_ = error;
     run_loop->Quit();
   }
 
   void CacheMatchCallback(
       base::RunLoop* run_loop,
       CacheStorageError error,
       scoped_ptr<ServiceWorkerResponse> response,
       scoped_ptr<storage::BlobDataHandle> blob_data_handle) {
-    callback_cache_error_ = error;
+    callback_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,
@@ skipping 31 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_ != CACHE_STORAGE_OK;
-    return !error;
+    return callback_error_ == CACHE_STORAGE_OK;
   }
 
   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_ != CACHE_STORAGE_OK;
-    return !error;
+    return callback_error_ == CACHE_STORAGE_OK;
   }
 
   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_ != CACHE_STORAGE_OK;
-    return !error;
+    return callback_error_ == CACHE_STORAGE_OK;
   }
 
   bool CachePut(const scoped_refptr<CacheStorageCache>& cache,
                 const GURL& url) {
     ServiceWorkerFetchRequest request;
     ServiceWorkerResponse response;
     request.url = url;
     response.url = url;
 
     CacheStorageBatchOperation operation;
     operation.operation_type = CACHE_STORAGE_CACHE_OPERATION_TYPE_PUT;
     operation.request = request;
     operation.response = response;
 
     scoped_ptr<base::RunLoop> loop(new base::RunLoop());
     cache->BatchOperation(
         std::vector<CacheStorageBatchOperation>(1, operation),
         base::Bind(&CacheStorageManagerTest::CachePutCallback,
                    base::Unretained(this), base::Unretained(loop.get())));
     loop->Run();
 
-    bool error = callback_cache_error_ != CACHE_STORAGE_OK;
-    return !error;
+    return callback_error_ == CACHE_STORAGE_OK;
   }
 
   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_ != CACHE_STORAGE_OK;
-    return !error;
+    return callback_error_ == CACHE_STORAGE_OK;
   }
 
   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_;
   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 96 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(CACHE_STORAGE_ERROR_NOT_FOUND, callback_cache_error_);
+  EXPECT_EQ(CACHE_STORAGE_ERROR_NOT_FOUND, callback_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(CACHE_STORAGE_ERROR_NOT_FOUND, callback_cache_error_);
+  EXPECT_EQ(CACHE_STORAGE_ERROR_NOT_FOUND, callback_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(CACHE_STORAGE_ERROR_NOT_FOUND, callback_cache_error_);
+  EXPECT_EQ(CACHE_STORAGE_ERROR_NOT_FOUND, callback_error_);
 }
 
 TEST_P(CacheStorageManagerTestP, StorageMatchAllNoCaches) {
   EXPECT_FALSE(StorageMatchAll(origin1_, GURL("http://example.com/foo")));
-  EXPECT_EQ(CACHE_STORAGE_ERROR_NOT_FOUND, callback_cache_error_);
+  EXPECT_EQ(CACHE_STORAGE_ERROR_NOT_FOUND, callback_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