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

content/browser/cache_storage/cache_storage.h

 // 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.
 
 #ifndef CONTENT_BROWSER_CACHE_STORAGE_CACHE_STORAGE_H_
 #define CONTENT_BROWSER_CACHE_STORAGE_CACHE_STORAGE_H_
 
 #include <map>
 #include <string>
 
@@ skipping 17 matching lines @@
 namespace content {
 class CacheStorageScheduler;
 
 // TODO(jkarlin): Constrain the total bytes used per origin.
 
 // CacheStorage holds the set of caches for a given origin. It is
 // owned by the CacheStorageManager. This class expects to be run
 // on the IO thread. The asynchronous methods are executed serially.
 class CONTENT_EXPORT CacheStorage {
  public:
-  enum CacheStorageError {
-    CACHE_STORAGE_ERROR_NO_ERROR,
-    CACHE_STORAGE_ERROR_NOT_IMPLEMENTED,
-    CACHE_STORAGE_ERROR_NOT_FOUND,
-    CACHE_STORAGE_ERROR_EXISTS,
-    CACHE_STORAGE_ERROR_STORAGE,
-    CACHE_STORAGE_ERROR_CLOSING
-  };
   typedef std::vector<std::string> StringVector;
   typedef base::Callback<void(bool, CacheStorageError)> BoolAndErrorCallback;
   typedef base::Callback<void(const scoped_refptr<CacheStorageCache>&,
                               CacheStorageError)> CacheAndErrorCallback;
   typedef base::Callback<void(const StringVector&, CacheStorageError)>
       StringsAndErrorCallback;
 
   static const char kIndexFileName[];
 
   CacheStorage(
@@ skipping 28 matching lines @@
 
   // Calls match on the cache with the given |cache_name|.
   void MatchCache(const std::string& cache_name,
                   scoped_ptr<ServiceWorkerFetchRequest> request,
                   const CacheStorageCache::ResponseCallback& callback);
 
   // Calls match on all of the caches in parallel, calling |callback| with the
   // first response found. Note that if multiple caches have the same
   // request/response then it is not defined which cache's response will be
   // returned. If no response is found then |callback| is called with
-  // CacheStorageCache::ErrorTypeNotFound.
+  // CACHE_STORAGE_ERROR_NOT_FOUND.
   void MatchAllCaches(scoped_ptr<ServiceWorkerFetchRequest> request,
                       const CacheStorageCache::ResponseCallback& callback);
 
   // Calls close on each cache and runs the callback after all of them have
   // closed.
   void CloseAllCaches(const base::Closure& callback);
 
   // The size of all of the origin's contents in memory. Returns 0 if the cache
   // backend is not a memory backend. Runs synchronously.
   int64 MemoryBackedSize() const;
@@ skipping 51 matching lines @@
 
   // The EnumerateCache callbacks are below.
   void EnumerateCachesImpl(const StringsAndErrorCallback& callback);
 
   // The MatchCache callbacks are below.
   void MatchCacheImpl(const std::string& cache_name,
                       scoped_ptr<ServiceWorkerFetchRequest> request,
                       const CacheStorageCache::ResponseCallback& callback);
   void MatchCacheDidMatch(const scoped_refptr<CacheStorageCache>& cache,
                           const CacheStorageCache::ResponseCallback& callback,
-                          CacheStorageCache::ErrorType error,
+                          CacheStorageError error,
                           scoped_ptr<ServiceWorkerResponse> response,
                           scoped_ptr<storage::BlobDataHandle> handle);
 
   // The MatchAllCaches callbacks are below.
   void MatchAllCachesImpl(scoped_ptr<ServiceWorkerFetchRequest> request,
                           const CacheStorageCache::ResponseCallback& callback);
   void 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);
   void MatchAllCachesDidMatchAll(
       scoped_ptr<CacheStorageCache::ResponseCallback> callback);
 
   // The CloseAllCaches callbacks are below.
   void CloseAllCachesImpl(const base::Closure& callback);
 
   void PendingClosure(const base::Closure& callback);
   void PendingBoolAndErrorCallback(const BoolAndErrorCallback& callback,
                                    bool found,
                                    CacheStorageError error);
   void PendingCacheAndErrorCallback(
       const CacheAndErrorCallback& callback,
       const scoped_refptr<CacheStorageCache>& cache,
       CacheStorageError error);
   void PendingStringsAndErrorCallback(const StringsAndErrorCallback& callback,
                                       const StringVector& strings,
                                       CacheStorageError error);
   void PendingResponseCallback(
       const CacheStorageCache::ResponseCallback& callback,
-      CacheStorageCache::ErrorType error,
+      CacheStorageError error,
       scoped_ptr<ServiceWorkerResponse> response,
       scoped_ptr<storage::BlobDataHandle> blob_data_handle);
 
   // Whether or not we've loaded the list of cache names into memory.
   bool initialized_;
   bool initializing_;
 
   // The pending operation scheduler.
   scoped_ptr<CacheStorageScheduler> scheduler_;
 
@@ skipping 16 matching lines @@
   scoped_ptr<CacheLoader> cache_loader_;
 
   base::WeakPtrFactory<CacheStorage> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(CacheStorage);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_CACHE_STORAGE_CACHE_STORAGE_H_