Cache Storage: Move files to content/*/cache_storage, rename classes

content/browser/cache_storage/cache_storage_listener.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_listener.h"
+
+#include "base/bind.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/common/cache_storage/cache_storage_types.h"
+#include "storage/browser/blob/blob_data_handle.h"
+#include "third_party/WebKit/public/platform/WebServiceWorkerCacheError.h"
+
+namespace content {
+
+using blink::WebServiceWorkerCacheError;
+
+namespace {
+
+WebServiceWorkerCacheError ToWebServiceWorkerCacheError(
+    CacheStorage::CacheStorageError err) {
+  switch (err) {
+    case CacheStorage::CACHE_STORAGE_ERROR_NO_ERROR:
+      NOTREACHED();
+      return blink::WebServiceWorkerCacheErrorNotImplemented;
+    case CacheStorage::CACHE_STORAGE_ERROR_NOT_IMPLEMENTED:
+      return blink::WebServiceWorkerCacheErrorNotImplemented;
+    case CacheStorage::CACHE_STORAGE_ERROR_NOT_FOUND:
+      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.
+      return blink::WebServiceWorkerCacheErrorNotFound;
+  }
+  NOTREACHED();
+  return blink::WebServiceWorkerCacheErrorNotImplemented;
+}
+
+// TODO(jkarlin): CacheStorageCache and CacheStorage should share
+// an error enum type.
+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
+
+CacheStorageListener::CacheStorageListener(
+    CacheStorageDispatcherHost* dispatcher,
+    CacheStorageContextImpl* context)
+    : dispatcher_(dispatcher), context_(context), weak_factory_(this) {
+}
+
+CacheStorageListener::~CacheStorageListener() {
+}
+
+bool CacheStorageListener::OnMessageReceived(const IPC::Message& message) {
+  bool handled = true;
+  IPC_BEGIN_MESSAGE_MAP(CacheStorageListener, message)
+    IPC_MESSAGE_HANDLER(CacheStorageHostMsg_CacheStorageHas,
+                        OnCacheStorageHas)
+    IPC_MESSAGE_HANDLER(CacheStorageHostMsg_CacheStorageOpen,
+                        OnCacheStorageOpen)
+    IPC_MESSAGE_HANDLER(CacheStorageHostMsg_CacheStorageDelete,
+                        OnCacheStorageDelete)
+    IPC_MESSAGE_HANDLER(CacheStorageHostMsg_CacheStorageKeys,
+                        OnCacheStorageKeys)
+    IPC_MESSAGE_HANDLER(CacheStorageHostMsg_CacheStorageMatch,
+                        OnCacheStorageMatch)
+    IPC_MESSAGE_HANDLER(CacheStorageHostMsg_CacheMatch, OnCacheMatch)
+    IPC_MESSAGE_HANDLER(CacheStorageHostMsg_CacheMatchAll, OnCacheMatchAll)
+    IPC_MESSAGE_HANDLER(CacheStorageHostMsg_CacheKeys, OnCacheKeys)
+    IPC_MESSAGE_HANDLER(CacheStorageHostMsg_CacheBatch, OnCacheBatch)
+    IPC_MESSAGE_HANDLER(CacheStorageHostMsg_CacheClosed, OnCacheClosed)
+    IPC_MESSAGE_HANDLER(CacheStorageHostMsg_BlobDataHandled,
+                        OnBlobDataHandled)
+    IPC_MESSAGE_UNHANDLED(handled = false)
+  IPC_END_MESSAGE_MAP()
+
+  return handled;
+}
+
+void CacheStorageListener::OnCacheStorageHas(int thread_id,
+                                             int request_id,
+                                             const GURL& origin,
+                                             const base::string16& cache_name) {
+  TRACE_EVENT0("CacheStorage", "CacheStorageListener::OnCacheStorageHas");
+  context_->cache_manager()->HasCache(
+      origin, base::UTF16ToUTF8(cache_name),
+      base::Bind(&CacheStorageListener::OnCacheStorageHasCallback,
+                 weak_factory_.GetWeakPtr(), thread_id, request_id));
+}
+
+void CacheStorageListener::OnCacheStorageOpen(
+    int thread_id,
+    int request_id,
+    const GURL& origin,
+    const base::string16& cache_name) {
+  TRACE_EVENT0("CacheStorage", "CacheStorageListener::OnCacheStorageOpen");
+  context_->cache_manager()->OpenCache(
+      origin, base::UTF16ToUTF8(cache_name),
+      base::Bind(&CacheStorageListener::OnCacheStorageOpenCallback,
+                 weak_factory_.GetWeakPtr(), thread_id, request_id));
+}
+
+void CacheStorageListener::OnCacheStorageDelete(
+    int thread_id,
+    int request_id,
+    const GURL& origin,
+    const base::string16& cache_name) {
+  TRACE_EVENT0("CacheStorage", "CacheStorageListener::OnCacheStorageDelete");
+  context_->cache_manager()->DeleteCache(
+      origin, base::UTF16ToUTF8(cache_name),
+      base::Bind(&CacheStorageListener::OnCacheStorageDeleteCallback,
+                 weak_factory_.GetWeakPtr(), thread_id, request_id));
+}
+
+void CacheStorageListener::OnCacheStorageKeys(int thread_id,
+                                              int request_id,
+                                              const GURL& origin) {
+  TRACE_EVENT0("CacheStorage", "CacheStorageListener::OnCacheStorageKeys");
+  context_->cache_manager()->EnumerateCaches(
+      origin, base::Bind(&CacheStorageListener::OnCacheStorageKeysCallback,
+                         weak_factory_.GetWeakPtr(), thread_id, request_id));
+}
+
+void CacheStorageListener::OnCacheStorageMatch(
+    int thread_id,
+    int request_id,
+    const GURL& origin,
+    const ServiceWorkerFetchRequest& request,
+    const CacheStorageCacheQueryParams& match_params) {
+  TRACE_EVENT0("CacheStorage", "CacheStorageListener::OnCacheStorageMatch");
+
+  scoped_ptr<ServiceWorkerFetchRequest> scoped_request(
+      new ServiceWorkerFetchRequest(request.url, request.method,
+                                    request.headers, request.referrer,
+                                    request.is_reload));
+
+  if (match_params.cache_name.empty()) {
+    context_->cache_manager()->MatchAllCaches(
+        origin, scoped_request.Pass(),
+        base::Bind(&CacheStorageListener::OnCacheStorageMatchCallback,
+                   weak_factory_.GetWeakPtr(), thread_id, request_id));
+    return;
+  }
+  context_->cache_manager()->MatchCache(
+      origin, base::UTF16ToUTF8(match_params.cache_name), scoped_request.Pass(),
+      base::Bind(&CacheStorageListener::OnCacheStorageMatchCallback,
+                 weak_factory_.GetWeakPtr(), thread_id, request_id));
+}
+
+void CacheStorageListener::OnCacheMatch(
+    int thread_id,
+    int request_id,
+    int cache_id,
+    const ServiceWorkerFetchRequest& request,
+    const CacheStorageCacheQueryParams& match_params) {
+  IDToCacheMap::iterator it = id_to_cache_map_.find(cache_id);
+  if (it == id_to_cache_map_.end()) {
+    Send(new CacheStorageMsg_CacheMatchError(
+        thread_id, request_id, blink::WebServiceWorkerCacheErrorNotFound));
+    return;
+  }
+
+  scoped_refptr<CacheStorageCache> cache = it->second;
+  scoped_ptr<ServiceWorkerFetchRequest> scoped_request(
+      new ServiceWorkerFetchRequest(request.url, request.method,
+                                    request.headers, request.referrer,
+                                    request.is_reload));
+  cache->Match(
+      scoped_request.Pass(),
+      base::Bind(&CacheStorageListener::OnCacheMatchCallback,
+                 weak_factory_.GetWeakPtr(), thread_id, request_id, cache));
+}
+
+void CacheStorageListener::OnCacheMatchAll(
+    int thread_id,
+    int request_id,
+    int cache_id,
+    const ServiceWorkerFetchRequest& request,
+    const CacheStorageCacheQueryParams& match_params) {
+  // TODO(gavinp,jkarlin): Implement this method.
+  Send(new CacheStorageMsg_CacheMatchAllError(
+      thread_id, request_id, blink::WebServiceWorkerCacheErrorNotImplemented));
+}
+
+void CacheStorageListener::OnCacheKeys(
+    int thread_id,
+    int request_id,
+    int cache_id,
+    const ServiceWorkerFetchRequest& request,
+    const CacheStorageCacheQueryParams& match_params) {
+  IDToCacheMap::iterator it = id_to_cache_map_.find(cache_id);
+  if (it == id_to_cache_map_.end()) {
+    Send(new CacheStorageMsg_CacheKeysError(
+        thread_id, request_id, blink::WebServiceWorkerCacheErrorNotFound));
+    return;
+  }
+
+  scoped_refptr<CacheStorageCache> cache = it->second;
+
+  cache->Keys(base::Bind(&CacheStorageListener::OnCacheKeysCallback,
+                         weak_factory_.GetWeakPtr(), thread_id, request_id,
+                         cache));
+}
+
+void CacheStorageListener::OnCacheBatch(
+    int thread_id,
+    int request_id,
+    int cache_id,
+    const std::vector<CacheStorageBatchOperation>& operations) {
+  if (operations.size() != 1u) {
+    Send(new CacheStorageMsg_CacheBatchError(
+        thread_id, request_id,
+        blink::WebServiceWorkerCacheErrorNotImplemented));
+    return;
+  }
+
+  IDToCacheMap::iterator it = id_to_cache_map_.find(cache_id);
+  if (it == id_to_cache_map_.end()) {
+    Send(new CacheStorageMsg_CacheBatchError(
+        thread_id, request_id, blink::WebServiceWorkerCacheErrorNotFound));
+    return;
+  }
+
+  const CacheStorageBatchOperation& operation = operations[0];
+
+  scoped_refptr<CacheStorageCache> cache = it->second;
+  scoped_ptr<ServiceWorkerFetchRequest> scoped_request(
+      new ServiceWorkerFetchRequest(
+          operation.request.url, operation.request.method,
+          operation.request.headers, operation.request.referrer,
+          operation.request.is_reload));
+
+  if (operation.operation_type == CACHE_STORAGE_CACHE_OPERATION_TYPE_DELETE) {
+    cache->Delete(
+        scoped_request.Pass(),
+        base::Bind(&CacheStorageListener::OnCacheDeleteCallback,
+                   weak_factory_.GetWeakPtr(), thread_id, request_id, cache));
+    return;
+  }
+
+  if (operation.operation_type == CACHE_STORAGE_CACHE_OPERATION_TYPE_PUT) {
+    // We don't support streaming for cache.
+    DCHECK(operation.response.stream_url.is_empty());
+    scoped_ptr<ServiceWorkerResponse> scoped_response(new ServiceWorkerResponse(
+        operation.response.url, operation.response.status_code,
+        operation.response.status_text, operation.response.response_type,
+        operation.response.headers, operation.response.blob_uuid,
+        operation.response.blob_size, operation.response.stream_url));
+    cache->Put(
+        scoped_request.Pass(), scoped_response.Pass(),
+        base::Bind(&CacheStorageListener::OnCachePutCallback,
+                   weak_factory_.GetWeakPtr(), thread_id, request_id, cache));
+
+    return;
+  }
+
+  Send(new CacheStorageMsg_CacheBatchError(
+      thread_id, request_id, blink::WebServiceWorkerCacheErrorNotImplemented));
+}
+
+void CacheStorageListener::OnCacheClosed(int cache_id) {
+  DropCacheReference(cache_id);
+}
+
+void CacheStorageListener::OnBlobDataHandled(const std::string& uuid) {
+  DropBlobDataHandle(uuid);
+}
+
+void CacheStorageListener::Send(IPC::Message* message) {
+  dispatcher_->Send(message);
+}
+
+void CacheStorageListener::OnCacheStorageHasCallback(
+    int thread_id,
+    int request_id,
+    bool has_cache,
+    CacheStorage::CacheStorageError error) {
+  if (error != CacheStorage::CACHE_STORAGE_ERROR_NO_ERROR) {
+    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 CacheStorageListener::OnCacheStorageOpenCallback(
+    int thread_id,
+    int request_id,
+    const scoped_refptr<CacheStorageCache>& cache,
+    CacheStorage::CacheStorageError error) {
+  if (error != CacheStorage::CACHE_STORAGE_ERROR_NO_ERROR) {
+    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 CacheStorageListener::OnCacheStorageDeleteCallback(
+    int thread_id,
+    int request_id,
+    bool deleted,
+    CacheStorage::CacheStorageError error) {
+  if (!deleted || error != CacheStorage::CACHE_STORAGE_ERROR_NO_ERROR) {
+    Send(new CacheStorageMsg_CacheStorageDeleteError(
+        thread_id, request_id, ToWebServiceWorkerCacheError(error)));
+    return;
+  }
+  Send(new CacheStorageMsg_CacheStorageDeleteSuccess(thread_id, request_id));
+}
+
+void CacheStorageListener::OnCacheStorageKeysCallback(
+    int thread_id,
+    int request_id,
+    const std::vector<std::string>& strings,
+    CacheStorage::CacheStorageError error) {
+  if (error != CacheStorage::CACHE_STORAGE_ERROR_NO_ERROR) {
+    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 CacheStorageListener::OnCacheStorageMatchCallback(
+    int thread_id,
+    int request_id,
+    CacheStorageCache::ErrorType error,
+    scoped_ptr<ServiceWorkerResponse> response,
+    scoped_ptr<storage::BlobDataHandle> blob_data_handle) {
+  if (error != CacheStorageCache::ERROR_TYPE_OK) {
+    Send(new CacheStorageMsg_CacheStorageMatchError(
+        thread_id, request_id, CacheErrorToWebServiceWorkerCacheError(error)));
+    return;
+  }
+
+  if (blob_data_handle)
+    StoreBlobDataHandle(blob_data_handle.Pass());
+
+  Send(new CacheStorageMsg_CacheStorageMatchSuccess(thread_id, request_id,
+                                                    *response));
+}
+
+void CacheStorageListener::OnCacheMatchCallback(
+    int thread_id,
+    int request_id,
+    const scoped_refptr<CacheStorageCache>& cache,
+    CacheStorageCache::ErrorType error,
+    scoped_ptr<ServiceWorkerResponse> response,
+    scoped_ptr<storage::BlobDataHandle> blob_data_handle) {
+  if (error != CacheStorageCache::ERROR_TYPE_OK) {
+    Send(new CacheStorageMsg_CacheMatchError(
+        thread_id, request_id, CacheErrorToWebServiceWorkerCacheError(error)));
+    return;
+  }
+
+  if (blob_data_handle)
+    StoreBlobDataHandle(blob_data_handle.Pass());
+
+  Send(new CacheStorageMsg_CacheMatchSuccess(thread_id, request_id, *response));
+}
+
+void CacheStorageListener::OnCacheKeysCallback(
+    int thread_id,
+    int request_id,
+    const scoped_refptr<CacheStorageCache>& cache,
+    CacheStorageCache::ErrorType error,
+    scoped_ptr<CacheStorageCache::Requests> requests) {
+  if (error != CacheStorageCache::ERROR_TYPE_OK) {
+    Send(new CacheStorageMsg_CacheKeysError(
+        thread_id, request_id, CacheErrorToWebServiceWorkerCacheError(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 CacheStorageListener::OnCacheDeleteCallback(
+    int thread_id,
+    int request_id,
+    const scoped_refptr<CacheStorageCache>& cache,
+    CacheStorageCache::ErrorType error) {
+  if (error != CacheStorageCache::ERROR_TYPE_OK) {
+    Send(new CacheStorageMsg_CacheBatchError(
+        thread_id, request_id, CacheErrorToWebServiceWorkerCacheError(error)));
+    return;
+  }
+
+  Send(new CacheStorageMsg_CacheBatchSuccess(
+      thread_id, request_id, std::vector<ServiceWorkerResponse>()));
+}
+
+void CacheStorageListener::OnCachePutCallback(
+    int thread_id,
+    int request_id,
+    const scoped_refptr<CacheStorageCache>& cache,
+    CacheStorageCache::ErrorType error,
+    scoped_ptr<ServiceWorkerResponse> response,
+    scoped_ptr<storage::BlobDataHandle> blob_data_handle) {
+  if (error != CacheStorageCache::ERROR_TYPE_OK) {
+    Send(new CacheStorageMsg_CacheBatchError(
+        thread_id, request_id, CacheErrorToWebServiceWorkerCacheError(error)));
+    return;
+  }
+
+  if (blob_data_handle)
+    StoreBlobDataHandle(blob_data_handle.Pass());
+
+  std::vector<ServiceWorkerResponse> responses;
+  responses.push_back(*response);
+  Send(new CacheStorageMsg_CacheBatchSuccess(thread_id, request_id, responses));
+}
+
+CacheStorageListener::CacheID CacheStorageListener::StoreCacheReference(
+    const scoped_refptr<CacheStorageCache>& cache) {
+  int cache_id = next_cache_id_++;
+  id_to_cache_map_[cache_id] = cache;
+  return cache_id;
+}
+
+void CacheStorageListener::DropCacheReference(CacheID cache_id) {
+  id_to_cache_map_.erase(cache_id);
+}
+
+void CacheStorageListener::StoreBlobDataHandle(
+    scoped_ptr<storage::BlobDataHandle> blob_data_handle) {
+  DCHECK(blob_data_handle);
+  std::pair<UUIDToBlobDataHandleList::iterator, bool> rv =
+      blob_handle_store_.insert(std::make_pair(
+          blob_data_handle->uuid(), std::list<storage::BlobDataHandle>()));
+  rv.first->second.push_front(storage::BlobDataHandle(*blob_data_handle));
+}
+
+void CacheStorageListener::DropBlobDataHandle(std::string uuid) {
+  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