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

content/browser/cache_storage/cache_storage_cache.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_cache.h"
 
 #include <string>
 
 #include "base/files/file_path.h"
 #include "base/guid.h"
@@ skipping 390 matching lines @@
   return weak_ptr_factory_.GetWeakPtr();
 }
 
 void CacheStorageCache::Put(scoped_ptr<ServiceWorkerFetchRequest> request,
                             scoped_ptr<ServiceWorkerResponse> response,
                             const ErrorCallback& callback) {
   scoped_ptr<storage::BlobDataHandle> blob_data_handle;
 
   if (!response->blob_uuid.empty()) {
     if (!blob_storage_context_) {
-      callback.Run(ERROR_TYPE_STORAGE);
+      callback.Run(CACHE_STORAGE_ERROR_STORAGE);
       return;
     }
     blob_data_handle =
         blob_storage_context_->GetBlobDataFromUUID(response->blob_uuid);
     if (!blob_data_handle) {
-      callback.Run(ERROR_TYPE_STORAGE);
+      callback.Run(CACHE_STORAGE_ERROR_STORAGE);
       return;
     }
   }
 
   ErrorCallback pending_callback =
       base::Bind(&CacheStorageCache::PendingErrorCallback,
                  weak_ptr_factory_.GetWeakPtr(), callback);
 
   scoped_ptr<PutContext> put_context(new PutContext(
       origin_, request.Pass(), response.Pass(), blob_data_handle.Pass(),
       pending_callback, request_context_, quota_manager_proxy_));
 
   if (backend_state_ == BACKEND_UNINITIALIZED)
     InitBackend();
 
   scheduler_->ScheduleOperation(base::Bind(&CacheStorageCache::PutImpl,
                                            weak_ptr_factory_.GetWeakPtr(),
                                            base::Passed(put_context.Pass())));
 }
 
 void CacheStorageCache::Match(scoped_ptr<ServiceWorkerFetchRequest> request,
                               const ResponseCallback& callback) {
   switch (backend_state_) {
     case BACKEND_UNINITIALIZED:
       InitBackend();
       break;
     case BACKEND_CLOSED:
-      callback.Run(ERROR_TYPE_STORAGE, scoped_ptr<ServiceWorkerResponse>(),
+      callback.Run(CACHE_STORAGE_ERROR_STORAGE,
+                   scoped_ptr<ServiceWorkerResponse>(),
                    scoped_ptr<storage::BlobDataHandle>());
       return;
     case BACKEND_OPEN:
       DCHECK(backend_);
       break;
   }
 
   ResponseCallback pending_callback =
       base::Bind(&CacheStorageCache::PendingResponseCallback,
                  weak_ptr_factory_.GetWeakPtr(), callback);
   scheduler_->ScheduleOperation(
       base::Bind(&CacheStorageCache::MatchImpl, weak_ptr_factory_.GetWeakPtr(),
                  base::Passed(request.Pass()), pending_callback));
 }
 
 void CacheStorageCache::Delete(scoped_ptr<ServiceWorkerFetchRequest> request,
                                const ErrorCallback& callback) {
   switch (backend_state_) {
     case BACKEND_UNINITIALIZED:
       InitBackend();
       break;
     case BACKEND_CLOSED:
-      callback.Run(ERROR_TYPE_STORAGE);
+      callback.Run(CACHE_STORAGE_ERROR_STORAGE);
       return;
     case BACKEND_OPEN:
       DCHECK(backend_);
       break;
   }
   ErrorCallback pending_callback =
       base::Bind(&CacheStorageCache::PendingErrorCallback,
                  weak_ptr_factory_.GetWeakPtr(), callback);
   scheduler_->ScheduleOperation(
       base::Bind(&CacheStorageCache::DeleteImpl, weak_ptr_factory_.GetWeakPtr(),
                  base::Passed(request.Pass()), pending_callback));
 }
 
 void CacheStorageCache::Keys(const RequestsCallback& callback) {
   switch (backend_state_) {
     case BACKEND_UNINITIALIZED:
       InitBackend();
       break;
     case BACKEND_CLOSED:
-      callback.Run(ERROR_TYPE_STORAGE, scoped_ptr<Requests>());
+      callback.Run(CACHE_STORAGE_ERROR_STORAGE, scoped_ptr<Requests>());
       return;
     case BACKEND_OPEN:
       DCHECK(backend_);
       break;
   }
 
   RequestsCallback pending_callback =
       base::Bind(&CacheStorageCache::PendingRequestsCallback,
                  weak_ptr_factory_.GetWeakPtr(), callback);
   scheduler_->ScheduleOperation(base::Bind(&CacheStorageCache::KeysImpl,
@@ skipping 57 matching lines @@
       scheduler_(new CacheStorageScheduler()),
       initializing_(false),
       memory_only_(path.empty()),
       weak_ptr_factory_(this) {
 }
 
 void CacheStorageCache::MatchImpl(scoped_ptr<ServiceWorkerFetchRequest> request,
                                   const ResponseCallback& callback) {
   DCHECK(backend_state_ != BACKEND_UNINITIALIZED);
   if (backend_state_ != BACKEND_OPEN) {
-    callback.Run(ERROR_TYPE_STORAGE, scoped_ptr<ServiceWorkerResponse>(),
+    callback.Run(CACHE_STORAGE_ERROR_STORAGE,
+                 scoped_ptr<ServiceWorkerResponse>(),
                  scoped_ptr<storage::BlobDataHandle>());
     return;
   }
 
   scoped_ptr<MatchContext> match_context(
       new MatchContext(request.Pass(), callback, blob_storage_context_));
 
   disk_cache::Entry** entry_ptr = &match_context->entry;
   ServiceWorkerFetchRequest* request_ptr = match_context->request.get();
 
   net::CompletionCallback open_entry_callback = base::Bind(
       &CacheStorageCache::MatchDidOpenEntry, weak_ptr_factory_.GetWeakPtr(),
       base::Passed(match_context.Pass()));
 
   int rv = backend_->OpenEntry(request_ptr->url.spec(), entry_ptr,
                                open_entry_callback);
   if (rv != net::ERR_IO_PENDING)
     open_entry_callback.Run(rv);
 }
 
 void CacheStorageCache::MatchDidOpenEntry(
     scoped_ptr<MatchContext> match_context,
     int rv) {
   if (rv != net::OK) {
-    match_context->original_callback.Run(
-        CacheStorageCache::ERROR_TYPE_NOT_FOUND,
-        scoped_ptr<ServiceWorkerResponse>(),
-        scoped_ptr<storage::BlobDataHandle>());
+    match_context->original_callback.Run(CACHE_STORAGE_ERROR_NOT_FOUND,
+                                         scoped_ptr<ServiceWorkerResponse>(),
+                                         scoped_ptr<storage::BlobDataHandle>());
     return;
   }
 
   // Copy the entry pointer before passing it in base::Bind.
   disk_cache::Entry* tmp_entry_ptr = match_context->entry;
   DCHECK(tmp_entry_ptr);
 
   MetadataCallback headers_callback = base::Bind(
       &CacheStorageCache::MatchDidReadMetadata, weak_ptr_factory_.GetWeakPtr(),
       base::Passed(match_context.Pass()));
 
   ReadMetadata(tmp_entry_ptr, headers_callback);
 }
 
 void CacheStorageCache::MatchDidReadMetadata(
     scoped_ptr<MatchContext> match_context,
     scoped_ptr<CacheMetadata> metadata) {
   if (!metadata) {
-    match_context->original_callback.Run(CacheStorageCache::ERROR_TYPE_STORAGE,
+    match_context->original_callback.Run(CACHE_STORAGE_ERROR_STORAGE,
                                          scoped_ptr<ServiceWorkerResponse>(),
                                          scoped_ptr<storage::BlobDataHandle>());
     return;
   }
 
   match_context->response.reset(new ServiceWorkerResponse(
       match_context->request->url, metadata->response().status_code(),
       metadata->response().status_text(),
       ProtoResponseTypeToWebResponseType(metadata->response().response_type()),
       ServiceWorkerHeaderMap(), "", 0, GURL()));
@@ skipping 13 matching lines @@
   ServiceWorkerHeaderMap cached_request_headers;
   for (int i = 0; i < metadata->request().headers_size(); ++i) {
     const CacheHeaderMap header = metadata->request().headers(i);
     DCHECK(header.name().find('\0') == std::string::npos);
     DCHECK(header.value().find('\0') == std::string::npos);
     cached_request_headers[header.name()] = header.value();
   }
 
   if (!VaryMatches(match_context->request->headers, cached_request_headers,
                    response->headers)) {
-    match_context->original_callback.Run(
-        CacheStorageCache::ERROR_TYPE_NOT_FOUND,
-        scoped_ptr<ServiceWorkerResponse>(),
-        scoped_ptr<storage::BlobDataHandle>());
+    match_context->original_callback.Run(CACHE_STORAGE_ERROR_NOT_FOUND,
+                                         scoped_ptr<ServiceWorkerResponse>(),
+                                         scoped_ptr<storage::BlobDataHandle>());
     return;
   }
 
   if (match_context->entry->GetDataSize(INDEX_RESPONSE_BODY) == 0) {
-    match_context->original_callback.Run(CacheStorageCache::ERROR_TYPE_OK,
+    match_context->original_callback.Run(CACHE_STORAGE_OK,
                                          match_context->response.Pass(),
                                          scoped_ptr<storage::BlobDataHandle>());
     return;
   }
 
   // Stream the response body into a blob.
   if (!match_context->blob_storage_context) {
-    match_context->original_callback.Run(CacheStorageCache::ERROR_TYPE_STORAGE,
+    match_context->original_callback.Run(CACHE_STORAGE_ERROR_STORAGE,
                                          scoped_ptr<ServiceWorkerResponse>(),
                                          scoped_ptr<storage::BlobDataHandle>());
     return;
   }
 
   response->blob_uuid = base::GenerateGUID();
 
   match_context->blob_data.reset(
       new storage::BlobDataBuilder(response->blob_uuid));
   match_context->response_body_buffer = new net::IOBufferWithSize(kBufferSize);
@@ skipping 11 matching lines @@
                               response_body_buffer->size(), read_callback);
 
   if (read_rv != net::ERR_IO_PENDING)
     read_callback.Run(read_rv);
 }
 
 void CacheStorageCache::MatchDidReadResponseBodyData(
     scoped_ptr<MatchContext> match_context,
     int rv) {
   if (rv < 0) {
-    match_context->original_callback.Run(CacheStorageCache::ERROR_TYPE_STORAGE,
+    match_context->original_callback.Run(CACHE_STORAGE_ERROR_STORAGE,
                                          scoped_ptr<ServiceWorkerResponse>(),
                                          scoped_ptr<storage::BlobDataHandle>());
     return;
   }
 
   if (rv == 0) {
     match_context->response->blob_uuid = match_context->blob_data->uuid();
     match_context->response->blob_size = match_context->total_bytes_read;
     MatchDoneWithBody(match_context.Pass());
     return;
@@ skipping 18 matching lines @@
   int read_rv = tmp_entry_ptr->ReadData(INDEX_RESPONSE_BODY, total_bytes_read,
                                         buffer, buffer->size(), read_callback);
 
   if (read_rv != net::ERR_IO_PENDING)
     read_callback.Run(read_rv);
 }
 
 void CacheStorageCache::MatchDoneWithBody(
     scoped_ptr<MatchContext> match_context) {
   if (!match_context->blob_storage_context) {
-    match_context->original_callback.Run(CacheStorageCache::ERROR_TYPE_STORAGE,
+    match_context->original_callback.Run(CACHE_STORAGE_ERROR_STORAGE,
                                          scoped_ptr<ServiceWorkerResponse>(),
                                          scoped_ptr<storage::BlobDataHandle>());
     return;
   }
 
   scoped_ptr<storage::BlobDataHandle> blob_data_handle(
       match_context->blob_storage_context->AddFinishedBlob(
           match_context->blob_data.get()));
 
-  match_context->original_callback.Run(CacheStorageCache::ERROR_TYPE_OK,
+  match_context->original_callback.Run(CACHE_STORAGE_OK,
                                        match_context->response.Pass(),
                                        blob_data_handle.Pass());
 }
 
 void CacheStorageCache::PutImpl(scoped_ptr<PutContext> put_context) {
   DCHECK(backend_state_ != BACKEND_UNINITIALIZED);
   if (backend_state_ != BACKEND_OPEN) {
-    put_context->callback.Run(ERROR_TYPE_STORAGE);
+    put_context->callback.Run(CACHE_STORAGE_ERROR_STORAGE);
     return;
   }
 
   scoped_ptr<ServiceWorkerFetchRequest> request_copy(
       new ServiceWorkerFetchRequest(*put_context->request));
 
   DeleteImpl(request_copy.Pass(), base::Bind(&CacheStorageCache::PutDidDelete,
                                              weak_ptr_factory_.GetWeakPtr(),
                                              base::Passed(put_context.Pass())));
 }
 
 void CacheStorageCache::PutDidDelete(scoped_ptr<PutContext> put_context,
-                                     ErrorType delete_error) {
+                                     CacheStorageError delete_error) {
   if (backend_state_ != BACKEND_OPEN) {
-    put_context->callback.Run(ERROR_TYPE_STORAGE);
+    put_context->callback.Run(CACHE_STORAGE_ERROR_STORAGE);
     return;
   }
 
   disk_cache::Entry** entry_ptr = &put_context->cache_entry;
   ServiceWorkerFetchRequest* request_ptr = put_context->request.get();
   disk_cache::Backend* backend_ptr = backend_.get();
 
   net::CompletionCallback create_entry_callback = base::Bind(
       &CacheStorageCache::PutDidCreateEntry, weak_ptr_factory_.GetWeakPtr(),
       base::Passed(put_context.Pass()));
 
   int create_rv = backend_ptr->CreateEntry(request_ptr->url.spec(), entry_ptr,
                                            create_entry_callback);
 
   if (create_rv != net::ERR_IO_PENDING)
     create_entry_callback.Run(create_rv);
 }
 
 void CacheStorageCache::PutDidCreateEntry(scoped_ptr<PutContext> put_context,
                                           int rv) {
   if (rv != net::OK) {
-    put_context->callback.Run(CacheStorageCache::ERROR_TYPE_EXISTS);
+    put_context->callback.Run(CACHE_STORAGE_ERROR_EXISTS);
     return;
   }
 
   DCHECK(put_context->cache_entry);
 
   CacheMetadata metadata;
   CacheRequest* request_metadata = metadata.mutable_request();
   request_metadata->set_method(put_context->request->method);
   for (ServiceWorkerHeaderMap::const_iterator it =
            put_context->request->headers.begin();
@@ skipping 16 matching lines @@
        it != put_context->response->headers.end(); ++it) {
     DCHECK(it->first.find('\0') == std::string::npos);
     DCHECK(it->second.find('\0') == std::string::npos);
     CacheHeaderMap* header_map = response_metadata->add_headers();
     header_map->set_name(it->first);
     header_map->set_value(it->second);
   }
 
   scoped_ptr<std::string> serialized(new std::string());
   if (!metadata.SerializeToString(serialized.get())) {
-    put_context->callback.Run(CacheStorageCache::ERROR_TYPE_STORAGE);
+    put_context->callback.Run(CACHE_STORAGE_ERROR_STORAGE);
     return;
   }
 
   scoped_refptr<net::StringIOBuffer> buffer(
       new net::StringIOBuffer(serialized.Pass()));
 
   // Get a temporary copy of the entry pointer before passing it in base::Bind.
   disk_cache::Entry* tmp_entry_ptr = put_context->cache_entry;
 
   net::CompletionCallback write_headers_callback = base::Bind(
       &CacheStorageCache::PutDidWriteHeaders, weak_ptr_factory_.GetWeakPtr(),
       base::Passed(put_context.Pass()), buffer->size());
 
   rv = tmp_entry_ptr->WriteData(INDEX_HEADERS, 0 /* offset */, buffer.get(),
                                 buffer->size(), write_headers_callback,
                                 true /* truncate */);
 
   if (rv != net::ERR_IO_PENDING)
     write_headers_callback.Run(rv);
 }
 
 void CacheStorageCache::PutDidWriteHeaders(scoped_ptr<PutContext> put_context,
                                            int expected_bytes,
                                            int rv) {
   if (rv != expected_bytes) {
     put_context->cache_entry->Doom();
-    put_context->callback.Run(CacheStorageCache::ERROR_TYPE_STORAGE);
+    put_context->callback.Run(CACHE_STORAGE_ERROR_STORAGE);
     return;
   }
 
   // The metadata is written, now for the response content. The data is streamed
   // from the blob into the cache entry.
 
   if (put_context->response->blob_uuid.empty()) {
     if (put_context->quota_manager_proxy.get()) {
       put_context->quota_manager_proxy->NotifyStorageModified(
           storage::QuotaClient::kServiceWorkerCache, put_context->origin,
           storage::kStorageTypeTemporary,
           put_context->cache_entry->GetDataSize(INDEX_HEADERS));
     }
 
-    put_context->callback.Run(CacheStorageCache::ERROR_TYPE_OK);
+    put_context->callback.Run(CACHE_STORAGE_OK);
     return;
   }
 
   DCHECK(put_context->blob_data_handle);
 
   disk_cache::ScopedEntryPtr entry(put_context->cache_entry);
   put_context->cache_entry = NULL;
   scoped_ptr<BlobReader> reader(new BlobReader());
   BlobReader* reader_ptr = reader.get();
 
@@ skipping 13 matching lines @@
 void CacheStorageCache::PutDidWriteBlobToCache(
     scoped_ptr<PutContext> put_context,
     scoped_ptr<BlobReader> blob_reader,
     disk_cache::ScopedEntryPtr entry,
     bool success) {
   DCHECK(entry);
   put_context->cache_entry = entry.release();
 
   if (!success) {
     put_context->cache_entry->Doom();
-    put_context->callback.Run(CacheStorageCache::ERROR_TYPE_STORAGE);
+    put_context->callback.Run(CACHE_STORAGE_ERROR_STORAGE);
     return;
   }
 
   if (put_context->quota_manager_proxy.get()) {
     put_context->quota_manager_proxy->NotifyStorageModified(
         storage::QuotaClient::kServiceWorkerCache, put_context->origin,
         storage::kStorageTypeTemporary,
         put_context->cache_entry->GetDataSize(INDEX_HEADERS) +
             put_context->cache_entry->GetDataSize(INDEX_RESPONSE_BODY));
   }
 
-  put_context->callback.Run(CacheStorageCache::ERROR_TYPE_OK);
+  put_context->callback.Run(CACHE_STORAGE_OK);
 }
 
 void CacheStorageCache::DeleteImpl(
     scoped_ptr<ServiceWorkerFetchRequest> request,
     const ErrorCallback& callback) {
   DCHECK(backend_state_ != BACKEND_UNINITIALIZED);
   if (backend_state_ != BACKEND_OPEN) {
-    callback.Run(ERROR_TYPE_STORAGE);
+    callback.Run(CACHE_STORAGE_ERROR_STORAGE);
     return;
   }
   scoped_ptr<disk_cache::Entry*> entry(new disk_cache::Entry*);
 
   disk_cache::Entry** entry_ptr = entry.get();
 
   ServiceWorkerFetchRequest* request_ptr = request.get();
 
   net::CompletionCallback open_entry_callback = base::Bind(
       &CacheStorageCache::DeleteDidOpenEntry, weak_ptr_factory_.GetWeakPtr(),
       origin_, base::Passed(request.Pass()), callback,
       base::Passed(entry.Pass()), quota_manager_proxy_);
 
   int rv = backend_->OpenEntry(request_ptr->url.spec(), entry_ptr,
                                open_entry_callback);
   if (rv != net::ERR_IO_PENDING)
     open_entry_callback.Run(rv);
 }
 
 void CacheStorageCache::DeleteDidOpenEntry(
     const GURL& origin,
     scoped_ptr<ServiceWorkerFetchRequest> request,
     const CacheStorageCache::ErrorCallback& callback,
     scoped_ptr<disk_cache::Entry*> entry_ptr,
     const scoped_refptr<storage::QuotaManagerProxy>& quota_manager_proxy,
     int rv) {
   if (rv != net::OK) {
-    callback.Run(CacheStorageCache::ERROR_TYPE_NOT_FOUND);
+    callback.Run(CACHE_STORAGE_ERROR_NOT_FOUND);
     return;
   }
 
   DCHECK(entry_ptr);
   disk_cache::ScopedEntryPtr entry(*entry_ptr);
 
   if (quota_manager_proxy.get()) {
     quota_manager_proxy->NotifyStorageModified(
         storage::QuotaClient::kServiceWorkerCache, origin,
         storage::kStorageTypeTemporary,
         -1 * (entry->GetDataSize(INDEX_HEADERS) +
               entry->GetDataSize(INDEX_RESPONSE_BODY)));
   }
 
   entry->Doom();
-  callback.Run(CacheStorageCache::ERROR_TYPE_OK);
+  callback.Run(CACHE_STORAGE_OK);
 }
 
 void CacheStorageCache::KeysImpl(const RequestsCallback& callback) {
   DCHECK(backend_state_ != BACKEND_UNINITIALIZED);
   if (backend_state_ != BACKEND_OPEN) {
-    callback.Run(ERROR_TYPE_STORAGE, scoped_ptr<Requests>());
+    callback.Run(CACHE_STORAGE_ERROR_STORAGE, scoped_ptr<Requests>());
     return;
   }
 
   // 1. Iterate through all of the entries, open them, and add them to a vector.
   // 2. For each open entry:
   //  2.1. Read the headers into a protobuf.
   //  2.2. Copy the protobuf into a ServiceWorkerFetchRequest (a "key").
   //  2.3. Push the response into a vector of requests to be returned.
   // 3. Return the vector of requests (keys).
 
@@ skipping 21 matching lines @@
     int rv) {
   if (rv == net::ERR_FAILED) {
     DCHECK(!keys_context->enumerated_entry);
     // Enumeration is complete, extract the requests from the entries.
     Entries::iterator iter = keys_context->entries.begin();
     KeysProcessNextEntry(keys_context.Pass(), iter);
     return;
   }
 
   if (rv < 0) {
-    keys_context->original_callback.Run(ERROR_TYPE_STORAGE,
+    keys_context->original_callback.Run(CACHE_STORAGE_ERROR_STORAGE,
                                         scoped_ptr<Requests>());
     return;
   }
 
   if (backend_state_ != BACKEND_OPEN) {
-    keys_context->original_callback.Run(ERROR_TYPE_NOT_FOUND,
+    keys_context->original_callback.Run(CACHE_STORAGE_ERROR_NOT_FOUND,
                                         scoped_ptr<Requests>());
     return;
   }
 
   // Store the entry.
   keys_context->entries.push_back(keys_context->enumerated_entry);
   keys_context->enumerated_entry = NULL;
 
   // Enumerate the next entry.
   disk_cache::Backend::Iterator& iterator = *keys_context->backend_iterator;
   disk_cache::Entry** enumerated_entry = &keys_context->enumerated_entry;
   net::CompletionCallback open_entry_callback = base::Bind(
       &CacheStorageCache::KeysDidOpenNextEntry, weak_ptr_factory_.GetWeakPtr(),
       base::Passed(keys_context.Pass()));
 
   rv = iterator.OpenNextEntry(enumerated_entry, open_entry_callback);
 
   if (rv != net::ERR_IO_PENDING)
     open_entry_callback.Run(rv);
 }
 
 void CacheStorageCache::KeysProcessNextEntry(
     scoped_ptr<KeysContext> keys_context,
     const Entries::iterator& iter) {
   if (iter == keys_context->entries.end()) {
     // All done. Return all of the keys.
-    keys_context->original_callback.Run(ERROR_TYPE_OK,
+    keys_context->original_callback.Run(CACHE_STORAGE_OK,
                                         keys_context->out_keys.Pass());
     return;
   }
 
   ReadMetadata(*iter, base::Bind(&CacheStorageCache::KeysDidReadMetadata,
                                  weak_ptr_factory_.GetWeakPtr(),
                                  base::Passed(keys_context.Pass()), iter));
 }
 
 void CacheStorageCache::KeysDidReadMetadata(
@@ skipping 56 matching lines @@
       NULL, backend, create_cache_callback);
   if (rv != net::ERR_IO_PENDING)
     create_cache_callback.Run(rv);
 }
 
 void CacheStorageCache::CreateBackendDidCreate(
     const CacheStorageCache::ErrorCallback& callback,
     scoped_ptr<ScopedBackendPtr> backend_ptr,
     int rv) {
   if (rv != net::OK) {
-    callback.Run(CacheStorageCache::ERROR_TYPE_STORAGE);
+    callback.Run(CACHE_STORAGE_ERROR_STORAGE);
     return;
   }
 
   backend_ = backend_ptr->Pass();
-  callback.Run(CacheStorageCache::ERROR_TYPE_OK);
+  callback.Run(CACHE_STORAGE_OK);
 }
 
 void CacheStorageCache::InitBackend() {
   DCHECK(backend_state_ == BACKEND_UNINITIALIZED);
 
   if (initializing_)
     return;
 
   DCHECK(!scheduler_->ScheduledOperations());
   initializing_ = true;
 
   scheduler_->ScheduleOperation(base::Bind(
       &CacheStorageCache::CreateBackend, weak_ptr_factory_.GetWeakPtr(),
       base::Bind(&CacheStorageCache::InitDone,
                  weak_ptr_factory_.GetWeakPtr())));
 }
 
-void CacheStorageCache::InitDone(ErrorType error) {
+void CacheStorageCache::InitDone(CacheStorageError error) {
   initializing_ = false;
-  backend_state_ = (error == ERROR_TYPE_OK && backend_ &&
+  backend_state_ = (error == CACHE_STORAGE_OK && backend_ &&
                     backend_state_ == BACKEND_UNINITIALIZED)
                        ? BACKEND_OPEN
                        : BACKEND_CLOSED;
 
   UMA_HISTOGRAM_ENUMERATION("ServiceWorkerCache.InitBackendResult", error,
-                            ErrorType::ERROR_TYPE_LAST + 1);
+                            CACHE_STORAGE_ERROR_LAST + 1);
 
   scheduler_->CompleteOperationAndRunNext();
 }
 
 void CacheStorageCache::PendingClosure(const base::Closure& callback) {
   base::WeakPtr<CacheStorageCache> cache = weak_ptr_factory_.GetWeakPtr();
 
   callback.Run();
   if (cache)
     scheduler_->CompleteOperationAndRunNext();
 }
 
 void CacheStorageCache::PendingErrorCallback(const ErrorCallback& callback,
-                                             ErrorType error) {
+                                             CacheStorageError error) {
   base::WeakPtr<CacheStorageCache> cache = weak_ptr_factory_.GetWeakPtr();
 
   callback.Run(error);
   if (cache)
     scheduler_->CompleteOperationAndRunNext();
 }
 
 void CacheStorageCache::PendingResponseCallback(
     const ResponseCallback& callback,
-    ErrorType error,
+    CacheStorageError error,
     scoped_ptr<ServiceWorkerResponse> response,
     scoped_ptr<storage::BlobDataHandle> blob_data_handle) {
   base::WeakPtr<CacheStorageCache> cache = weak_ptr_factory_.GetWeakPtr();
 
   callback.Run(error, response.Pass(), blob_data_handle.Pass());
   if (cache)
     scheduler_->CompleteOperationAndRunNext();
 }
 
 void CacheStorageCache::PendingRequestsCallback(
     const RequestsCallback& callback,
-    ErrorType error,
+    CacheStorageError error,
     scoped_ptr<Requests> requests) {
   base::WeakPtr<CacheStorageCache> cache = weak_ptr_factory_.GetWeakPtr();
 
   callback.Run(error, requests.Pass());
   if (cache)
     scheduler_->CompleteOperationAndRunNext();
 }
 
 }  // namespace content