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

content/browser/cache_storage/cache_storage_dispatcher_host.cc

 // Copyright 2015 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_dispatcher_host.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/strings/string16.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/trace_event/trace_event.h"
 #include "content/browser/cache_storage/cache_storage_cache.h"
 #include "content/browser/cache_storage/cache_storage_context_impl.h"
 #include "content/browser/cache_storage/cache_storage_manager.h"
 #include "content/common/cache_storage/cache_storage_messages.h"
 #include "content/public/browser/content_browser_client.h"
 #include "storage/browser/blob/blob_data_handle.h"
 #include "third_party/WebKit/public/platform/WebServiceWorkerCacheError.h"
 
 namespace content {
 
 namespace {
 
 const uint32 kFilteredMessageClasses[] = {CacheStorageMsgStart};
 
 blink::WebServiceWorkerCacheError ToWebServiceWorkerCacheError(
-    CacheStorage::CacheStorageError err) {
+    CacheStorageError err) {
   switch (err) {
-    case CacheStorage::CACHE_STORAGE_ERROR_NO_ERROR:
+    case CACHE_STORAGE_OK:
       NOTREACHED();
       return blink::WebServiceWorkerCacheErrorNotImplemented;
-    case CacheStorage::CACHE_STORAGE_ERROR_NOT_IMPLEMENTED:
-      return blink::WebServiceWorkerCacheErrorNotImplemented;
-    case CacheStorage::CACHE_STORAGE_ERROR_NOT_FOUND:
+    case CACHE_STORAGE_ERROR_EXISTS:
+      return blink::WebServiceWorkerCacheErrorExists;
+    case CACHE_STORAGE_ERROR_STORAGE:
+      // TODO(nhiroki): Add WebServiceWorkerCacheError equivalent to
+      // CACHE_STORAGE_ERROR_STORAGE.
       return blink::WebServiceWorkerCacheErrorNotFound;
-    case CacheStorage::CACHE_STORAGE_ERROR_EXISTS:
-      return blink::WebServiceWorkerCacheErrorExists;
-    case CacheStorage::CACHE_STORAGE_ERROR_STORAGE:
-      // TODO(jkarlin): Change this to CACHE_STORAGE_ERROR_STORAGE once that's
-      // added.
-      return blink::WebServiceWorkerCacheErrorNotFound;
-    case CacheStorage::CACHE_STORAGE_ERROR_CLOSING:
-      // TODO(jkarlin): Update this to CACHE_STORAGE_ERROR_CLOSING once that's
-      // added.
+    case CACHE_STORAGE_ERROR_NOT_FOUND:
       return blink::WebServiceWorkerCacheErrorNotFound;
   }
   NOTREACHED();
-  return blink::WebServiceWorkerCacheErrorNotImplemented;
-}
-
-// TODO(jkarlin): CacheStorageCache and CacheStorage should share
-// an error enum type.
-blink::WebServiceWorkerCacheError CacheErrorToWebServiceWorkerCacheError(
-    CacheStorageCache::ErrorType err) {
-  switch (err) {
-    case CacheStorageCache::ERROR_TYPE_OK:
-      NOTREACHED();
-      return blink::WebServiceWorkerCacheErrorNotImplemented;
-    case CacheStorageCache::ERROR_TYPE_EXISTS:
-      return blink::WebServiceWorkerCacheErrorExists;
-    case CacheStorageCache::ERROR_TYPE_STORAGE:
-      // TODO(jkarlin): Change this to CACHE_STORAGE_ERROR_STORAGE once that's
-      // added.
-      return blink::WebServiceWorkerCacheErrorNotFound;
-    case CacheStorageCache::ERROR_TYPE_NOT_FOUND:
-      return blink::WebServiceWorkerCacheErrorNotFound;
-  }
-  NOTREACHED();
   return blink::WebServiceWorkerCacheErrorNotImplemented;
 }
 
 }  // namespace
 
 CacheStorageDispatcherHost::CacheStorageDispatcherHost()
     : BrowserMessageFilter(kFilteredMessageClasses,
                            arraysize(kFilteredMessageClasses)) {
 }
 
@@ skipping 233 matching lines @@
 }
 
 void CacheStorageDispatcherHost::OnBlobDataHandled(const std::string& uuid) {
   DropBlobDataHandle(uuid);
 }
 
 void CacheStorageDispatcherHost::OnCacheStorageHasCallback(
     int thread_id,
     int request_id,
     bool has_cache,
-    CacheStorage::CacheStorageError error) {
-  if (error != CacheStorage::CACHE_STORAGE_ERROR_NO_ERROR) {
+    CacheStorageError error) {
+  if (error != CACHE_STORAGE_OK) {
     Send(new CacheStorageMsg_CacheStorageHasError(
         thread_id, request_id, ToWebServiceWorkerCacheError(error)));
     return;
   }
   if (!has_cache) {
     Send(new CacheStorageMsg_CacheStorageHasError(
         thread_id, request_id, blink::WebServiceWorkerCacheErrorNotFound));
     return;
   }
   Send(new CacheStorageMsg_CacheStorageHasSuccess(thread_id, request_id));
 }
 
 void CacheStorageDispatcherHost::OnCacheStorageOpenCallback(
     int thread_id,
     int request_id,
     const scoped_refptr<CacheStorageCache>& cache,
-    CacheStorage::CacheStorageError error) {
-  if (error != CacheStorage::CACHE_STORAGE_ERROR_NO_ERROR) {
+    CacheStorageError error) {
+  if (error != CACHE_STORAGE_OK) {
     Send(new CacheStorageMsg_CacheStorageOpenError(
         thread_id, request_id, ToWebServiceWorkerCacheError(error)));
     return;
   }
   CacheID cache_id = StoreCacheReference(cache);
   Send(new CacheStorageMsg_CacheStorageOpenSuccess(thread_id, request_id,
                                                    cache_id));
 }
 
 void CacheStorageDispatcherHost::OnCacheStorageDeleteCallback(
     int thread_id,
     int request_id,
     bool deleted,
-    CacheStorage::CacheStorageError error) {
-  if (!deleted || error != CacheStorage::CACHE_STORAGE_ERROR_NO_ERROR) {
+    CacheStorageError error) {
+  if (!deleted || error != CACHE_STORAGE_OK) {
     Send(new CacheStorageMsg_CacheStorageDeleteError(
         thread_id, request_id, ToWebServiceWorkerCacheError(error)));
     return;
   }
   Send(new CacheStorageMsg_CacheStorageDeleteSuccess(thread_id, request_id));
 }
 
 void CacheStorageDispatcherHost::OnCacheStorageKeysCallback(
     int thread_id,
     int request_id,
     const std::vector<std::string>& strings,
-    CacheStorage::CacheStorageError error) {
-  if (error != CacheStorage::CACHE_STORAGE_ERROR_NO_ERROR) {
+    CacheStorageError error) {
+  if (error != CACHE_STORAGE_OK) {
     Send(new CacheStorageMsg_CacheStorageKeysError(
         thread_id, request_id, ToWebServiceWorkerCacheError(error)));
     return;
   }
 
   std::vector<base::string16> string16s;
   for (size_t i = 0, max = strings.size(); i < max; ++i) {
     string16s.push_back(base::UTF8ToUTF16(strings[i]));
   }
   Send(new CacheStorageMsg_CacheStorageKeysSuccess(thread_id, request_id,
                                                    string16s));
 }
 
 void CacheStorageDispatcherHost::OnCacheStorageMatchCallback(
     int thread_id,
     int request_id,
-    CacheStorageCache::ErrorType error,
+    CacheStorageError error,
     scoped_ptr<ServiceWorkerResponse> response,
     scoped_ptr<storage::BlobDataHandle> blob_data_handle) {
-  if (error != CacheStorageCache::ERROR_TYPE_OK) {
+  if (error != CACHE_STORAGE_OK) {
     Send(new CacheStorageMsg_CacheStorageMatchError(
-        thread_id, request_id, CacheErrorToWebServiceWorkerCacheError(error)));
+        thread_id, request_id, ToWebServiceWorkerCacheError(error)));
     return;
   }
 
   if (blob_data_handle)
     StoreBlobDataHandle(blob_data_handle.Pass());
 
   Send(new CacheStorageMsg_CacheStorageMatchSuccess(thread_id, request_id,
                                                     *response));
 }
 
 void CacheStorageDispatcherHost::OnCacheMatchCallback(
     int thread_id,
     int request_id,
     const scoped_refptr<CacheStorageCache>& cache,
-    CacheStorageCache::ErrorType error,
+    CacheStorageError error,
     scoped_ptr<ServiceWorkerResponse> response,
     scoped_ptr<storage::BlobDataHandle> blob_data_handle) {
-  if (error != CacheStorageCache::ERROR_TYPE_OK) {
+  if (error != CACHE_STORAGE_OK) {
     Send(new CacheStorageMsg_CacheMatchError(
-        thread_id, request_id, CacheErrorToWebServiceWorkerCacheError(error)));
+        thread_id, request_id, ToWebServiceWorkerCacheError(error)));
     return;
   }
 
   if (blob_data_handle)
     StoreBlobDataHandle(blob_data_handle.Pass());
 
   Send(new CacheStorageMsg_CacheMatchSuccess(thread_id, request_id, *response));
 }
 
 void CacheStorageDispatcherHost::OnCacheKeysCallback(
     int thread_id,
     int request_id,
     const scoped_refptr<CacheStorageCache>& cache,
-    CacheStorageCache::ErrorType error,
+    CacheStorageError error,
     scoped_ptr<CacheStorageCache::Requests> requests) {
-  if (error != CacheStorageCache::ERROR_TYPE_OK) {
+  if (error != CACHE_STORAGE_OK) {
     Send(new CacheStorageMsg_CacheKeysError(
-        thread_id, request_id, CacheErrorToWebServiceWorkerCacheError(error)));
+        thread_id, request_id, ToWebServiceWorkerCacheError(error)));
     return;
   }
 
   CacheStorageCache::Requests out;
 
   for (CacheStorageCache::Requests::const_iterator it = requests->begin();
        it != requests->end(); ++it) {
     ServiceWorkerFetchRequest request(it->url, it->method, it->headers,
                                       it->referrer, it->is_reload);
     out.push_back(request);
   }
 
   Send(new CacheStorageMsg_CacheKeysSuccess(thread_id, request_id, out));
 }
 
 void CacheStorageDispatcherHost::OnCacheBatchCallback(
     int thread_id,
     int request_id,
     const scoped_refptr<CacheStorageCache>& cache,
-    CacheStorageCache::ErrorType error) {
-  if (error != CacheStorageCache::ERROR_TYPE_OK) {
+    CacheStorageError error) {
+  if (error != CACHE_STORAGE_OK) {
     Send(new CacheStorageMsg_CacheBatchError(
-        thread_id, request_id, CacheErrorToWebServiceWorkerCacheError(error)));
+        thread_id, request_id, ToWebServiceWorkerCacheError(error)));
     return;
   }
 
   Send(new CacheStorageMsg_CacheBatchSuccess(thread_id, request_id));
 }
 
 CacheStorageDispatcherHost::CacheID
 CacheStorageDispatcherHost::StoreCacheReference(
     const scoped_refptr<CacheStorageCache>& cache) {
   int cache_id = next_cache_id_++;
@@ skipping 18 matching lines @@
   UUIDToBlobDataHandleList::iterator it = blob_handle_store_.find(uuid);
   if (it == blob_handle_store_.end())
     return;
   DCHECK(!it->second.empty());
   it->second.pop_front();
   if (it->second.empty())
     blob_handle_store_.erase(it);
 }
 
 }  // namespace content