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

content/browser/cache_storage/cache_storage.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.h"
 
 #include <string>
 
 #include "base/barrier_closure.h"
 #include "base/files/file_util.h"
@@ skipping 542 matching lines @@
   initializing_ = false;
   initialized_ = true;
 
   scheduler_->CompleteOperationAndRunNext();
 }
 
 void CacheStorage::OpenCacheImpl(const std::string& cache_name,
                                  const CacheAndErrorCallback& callback) {
   scoped_refptr<CacheStorageCache> cache = GetLoadedCache(cache_name);
   if (cache.get()) {
-    callback.Run(cache, CACHE_STORAGE_ERROR_NO_ERROR);
+    callback.Run(cache, CACHE_STORAGE_OK);
     return;
   }
 
   cache_loader_->CreateCache(
       cache_name, base::Bind(&CacheStorage::CreateCacheDidCreateCache,
                              weak_factory_.GetWeakPtr(), cache_name, callback));
 }
 
 void CacheStorage::CreateCacheDidCreateCache(
     const std::string& cache_name,
     const CacheAndErrorCallback& callback,
     const scoped_refptr<CacheStorageCache>& cache) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   if (!cache.get()) {
     callback.Run(scoped_refptr<CacheStorageCache>(),
-                 CACHE_STORAGE_ERROR_CLOSING);

[nhiroki, 2015/05/08 07:33:03]

Are we able to replace "CLOSING" with "STORAGE"? This error is used only here
and it's great if we can remove this.

[jkarlin, 2015/05/08 12:38:19]

Yes, I think that's fine. I see an error in the below histogram though, it's
supposed to be above this condition! Otherwise it always reports true. I'll fix
that in a separate CL.

[nhiroki, 2015/05/08 14:14:49]

I see, thanks!

+                 CACHE_STORAGE_ERROR_STORAGE);
     return;
   }
 
   UMA_HISTOGRAM_BOOLEAN("ServiceWorkerCache.CreateCacheStorageResult",
                         cache != nullptr);
 
   cache_map_.insert(std::make_pair(cache_name, cache->AsWeakPtr()));
   ordered_cache_names_.push_back(cache_name);
 
   cache_loader_->WriteIndex(
       ordered_cache_names_,
       base::Bind(&CacheStorage::CreateCacheDidWriteIndex,
                  weak_factory_.GetWeakPtr(), callback, cache));
 }
 
 void CacheStorage::CreateCacheDidWriteIndex(
     const CacheAndErrorCallback& callback,
     const scoped_refptr<CacheStorageCache>& cache,
     bool success) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(cache.get());
 
   // TODO(jkarlin): Handle !success.
 
-  callback.Run(cache, CACHE_STORAGE_ERROR_NO_ERROR);
+  callback.Run(cache, CACHE_STORAGE_OK);
 }
 
 void CacheStorage::HasCacheImpl(const std::string& cache_name,
                                 const BoolAndErrorCallback& callback) {
   bool has_cache = cache_map_.find(cache_name) != cache_map_.end();
 
-  callback.Run(has_cache, CACHE_STORAGE_ERROR_NO_ERROR);
+  callback.Run(has_cache, CACHE_STORAGE_OK);
 }
 
 void CacheStorage::DeleteCacheImpl(const std::string& cache_name,
                                    const BoolAndErrorCallback& callback) {
   CacheMap::iterator it = cache_map_.find(cache_name);
   if (it == cache_map_.end()) {
     callback.Run(false, CACHE_STORAGE_ERROR_NOT_FOUND);
     return;
   }
 
@@ skipping 38 matching lines @@
 
   cache_loader_->CleanUpDeletedCache(
       cache_name, base::Bind(&CacheStorage::DeleteCacheDidCleanUp,
                              weak_factory_.GetWeakPtr(), callback));
 }
 
 void CacheStorage::DeleteCacheDidCleanUp(const BoolAndErrorCallback& callback,
                                          bool success) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
-  callback.Run(true, CACHE_STORAGE_ERROR_NO_ERROR);
+  callback.Run(true, CACHE_STORAGE_OK);
 }
 
 void CacheStorage::EnumerateCachesImpl(
     const StringsAndErrorCallback& callback) {
-  callback.Run(ordered_cache_names_, CACHE_STORAGE_ERROR_NO_ERROR);
+  callback.Run(ordered_cache_names_, CACHE_STORAGE_OK);
 }
 
 void CacheStorage::MatchCacheImpl(
     const std::string& cache_name,
     scoped_ptr<ServiceWorkerFetchRequest> request,
     const CacheStorageCache::ResponseCallback& callback) {
   scoped_refptr<CacheStorageCache> cache = GetLoadedCache(cache_name);
 
   if (!cache.get()) {
-    callback.Run(CacheStorageCache::ERROR_TYPE_NOT_FOUND,
+    callback.Run(CACHE_STORAGE_ERROR_NOT_FOUND,
                  scoped_ptr<ServiceWorkerResponse>(),
                  scoped_ptr<storage::BlobDataHandle>());
     return;
   }
 
   // Pass the cache along to the callback to keep the cache open until match is
   // done.
   cache->Match(request.Pass(),
                base::Bind(&CacheStorage::MatchCacheDidMatch,
                           weak_factory_.GetWeakPtr(), cache, callback));
 }
 
 void CacheStorage::MatchCacheDidMatch(
     const scoped_refptr<CacheStorageCache>& cache,
     const CacheStorageCache::ResponseCallback& callback,
-    CacheStorageCache::ErrorType error,
+    CacheStorageError error,
     scoped_ptr<ServiceWorkerResponse> response,
     scoped_ptr<storage::BlobDataHandle> handle) {
   callback.Run(error, response.Pass(), handle.Pass());
 }
 
 void CacheStorage::MatchAllCachesImpl(
     scoped_ptr<ServiceWorkerFetchRequest> request,
     const CacheStorageCache::ResponseCallback& callback) {
   scoped_ptr<CacheStorageCache::ResponseCallback> callback_copy(
       new CacheStorageCache::ResponseCallback(callback));
@@ skipping 13 matching lines @@
                  base::Bind(&CacheStorage::MatchAllCachesDidMatch,
                             weak_factory_.GetWeakPtr(), cache, barrier_closure,
                             callback_ptr));
   }
 }
 
 void CacheStorage::MatchAllCachesDidMatch(
     scoped_refptr<CacheStorageCache> cache,
     const base::Closure& barrier_closure,
     CacheStorageCache::ResponseCallback* callback,
-    CacheStorageCache::ErrorType error,
+    CacheStorageError error,
     scoped_ptr<ServiceWorkerResponse> response,
     scoped_ptr<storage::BlobDataHandle> handle) {
-  if (callback->is_null() || error == CacheStorageCache::ERROR_TYPE_NOT_FOUND) {
+  if (callback->is_null() || error == CACHE_STORAGE_ERROR_NOT_FOUND) {
     barrier_closure.Run();
     return;
   }
   callback->Run(error, response.Pass(), handle.Pass());
   callback->Reset();  // Only call the callback once.
 
   barrier_closure.Run();
 }
 
 void CacheStorage::MatchAllCachesDidMatchAll(
     scoped_ptr<CacheStorageCache::ResponseCallback> callback) {
   if (!callback->is_null()) {
-    callback->Run(CacheStorageCache::ERROR_TYPE_NOT_FOUND,
+    callback->Run(CACHE_STORAGE_ERROR_NOT_FOUND,
                   scoped_ptr<ServiceWorkerResponse>(),
                   scoped_ptr<storage::BlobDataHandle>());
   }
 }
 
 scoped_refptr<CacheStorageCache> CacheStorage::GetLoadedCache(
     const std::string& cache_name) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(initialized_);
 
@@ skipping 77 matching lines @@
     CacheStorageError error) {
   base::WeakPtr<CacheStorage> cache_storage = weak_factory_.GetWeakPtr();
 
   callback.Run(strings, error);
   if (cache_storage)
     scheduler_->CompleteOperationAndRunNext();
 }
 
 void CacheStorage::PendingResponseCallback(
     const CacheStorageCache::ResponseCallback& callback,
-    CacheStorageCache::ErrorType error,
+    CacheStorageError error,
     scoped_ptr<ServiceWorkerResponse> response,
     scoped_ptr<storage::BlobDataHandle> blob_data_handle) {
   base::WeakPtr<CacheStorage> cache_storage = weak_factory_.GetWeakPtr();
 
   callback.Run(error, response.Pass(), blob_data_handle.Pass());
   if (cache_storage)
     scheduler_->CompleteOperationAndRunNext();
 }
 
 }  // namespace content