content::WebServiceWorkerCache implementation.

content/renderer/service_worker/service_worker_cache_storage_dispatcher.cc

Index: content/renderer/service_worker/service_worker_cache_storage_dispatcher.cc
diff --git a/content/renderer/service_worker/service_worker_cache_storage_dispatcher.cc b/content/renderer/service_worker/service_worker_cache_storage_dispatcher.cc
index b5b44b2c449a9af236bd83ae65918900db4c2394..575e2a224afe625c1af82351eb9ce2bcab952bb7 100644
--- a/content/renderer/service_worker/service_worker_cache_storage_dispatcher.cc
+++ b/content/renderer/service_worker/service_worker_cache_storage_dispatcher.cc
@@ -4,15 +4,152 @@
 
 #include "content/renderer/service_worker/service_worker_cache_storage_dispatcher.h"
 
+#include <map>
+#include <string>
+#include <utility>
+
 #include "base/logging.h"
+#include "base/strings/utf_string_conversions.h"
 #include "content/common/service_worker/service_worker_messages.h"
 #include "content/public/renderer/render_thread.h"
 #include "content/renderer/service_worker/service_worker_script_context.h"
+#include "third_party/WebKit/public/platform/WebHTTPHeaderVisitor.h"
+#include "third_party/WebKit/public/platform/WebServiceWorkerCache.h"
+#include "third_party/WebKit/public/platform/WebServiceWorkerRequest.h"
+#include "third_party/WebKit/public/platform/WebServiceWorkerResponse.h"
 
 namespace content {
 
+using blink::WebServiceWorkerCacheError;
+using blink::WebServiceWorkerRequest;
+
 namespace {
 
+class HeaderVisitor : public blink::WebHTTPHeaderVisitor {
+ public:
+  HeaderVisitor(ServiceWorkerHeaderMap* headers) : headers_(headers) {}
+  virtual ~HeaderVisitor() {}
+
+  virtual void visitHeader(const blink::WebString& name,
+                           const blink::WebString& value) {
+    headers_->insert(ServiceWorkerHeaderMap::value_type(
+        base::UTF16ToASCII(name), base::UTF16ToASCII(value)));
+  }
+
+ private:
+  ServiceWorkerHeaderMap* headers_;
+};
+
+scoped_ptr<HeaderVisitor> MakeHeaderVisitor(ServiceWorkerHeaderMap* headers) {
+  return scoped_ptr<HeaderVisitor>(new HeaderVisitor(headers)).Pass();
+}
+
+ServiceWorkerFetchRequest FetchRequestFromWebRequest(
+    const blink::WebServiceWorkerRequest& web_request) {
+  ServiceWorkerHeaderMap headers;
+  web_request.visitHTTPHeaderFields(MakeHeaderVisitor(&headers).get());
+
+  return ServiceWorkerFetchRequest(web_request.url(),
+                                   base::UTF16ToASCII(web_request.method()),
+                                   headers, web_request.referrerUrl(),
+                                   web_request.isReload());
+}
+
+void PopulateWebRequestFromFetchRequest(
+    const ServiceWorkerFetchRequest& request,
+    blink::WebServiceWorkerRequest* web_request) {
+  web_request->setURL(request.url);
+  web_request->setMethod(base::ASCIIToUTF16(request.method));
+  for (ServiceWorkerHeaderMap::const_iterator i = request.headers.begin(),
+                                            end = request.headers.end();
+       i != end; ++i) {
+    web_request->setHeader(base::ASCIIToUTF16(i->first),
+                           base::ASCIIToUTF16(i->second));
+  }
+  web_request->setReferrer(base::ASCIIToUTF16(request.referrer.spec()),
+                           blink::WebReferrerPolicy::WebReferrerPolicyNever);

[jochen (gone - plz use gerrit), 2015/01/21 13:55:14]

this is not correct. You can't set a referrer and the "never" policy.

[jochen (gone - plz use gerrit), 2015/01/21 13:58:27]

The fact that referrer is a URL is also a bug :-/

+  web_request->setIsReload(request.is_reload);
+}
+
+blink::WebVector<blink::WebServiceWorkerRequest> WebRequestsFromRequests(
+    const std::vector<ServiceWorkerFetchRequest>& requests) {
+  blink::WebVector<blink::WebServiceWorkerRequest>
+      web_requests(requests.size());
+  for (size_t i = 0; i < requests.size(); ++i)
+    PopulateWebRequestFromFetchRequest(requests[i], &(web_requests[i]));
+  return web_requests;
+}
+
+ServiceWorkerResponse ResponseFromWebResponse(
+    const blink::WebServiceWorkerResponse& web_response) {
+  ServiceWorkerHeaderMap headers;
+  web_response.visitHTTPHeaderFields(MakeHeaderVisitor(&headers).get());
+
+  return ServiceWorkerResponse(
+      web_response.url(), web_response.status(),
+      base::UTF16ToASCII(web_response.statusText()), headers,
+      base::UTF16ToASCII(web_response.blobUUID()));
+}
+
+void PopulateWebResponseFromResponse(
+    const ServiceWorkerResponse& response,
+    blink::WebServiceWorkerResponse* web_response) {
+  web_response->setURL(response.url);
+  web_response->setStatus(response.status_code);
+  web_response->setStatusText(base::ASCIIToUTF16(response.status_text));
+  for (ServiceWorkerHeaderMap::const_iterator i = response.headers.begin(),
+                                            end = response.headers.end();
+       i != end; ++i) {
+    web_response->setHeader(base::ASCIIToUTF16(i->first),
+                            base::ASCIIToUTF16(i->second));
+  }
+  // TODO(gavinp): set blob here.
+}
+
+blink::WebVector<blink::WebServiceWorkerResponse> WebResponsesFromResponses(
+    const std::vector<ServiceWorkerResponse>& responses) {
+  blink::WebVector<blink::WebServiceWorkerResponse>
+      web_responses(responses.size());
+  for (size_t i = 0; i < responses.size(); ++i)
+    PopulateWebResponseFromResponse(responses[i], &(web_responses[i]));
+  return web_responses;
+}
+
+ServiceWorkerCacheQueryParams QueryParamsFromWebQueryParams(
+    const blink::WebServiceWorkerCache::QueryParams& web_query_params) {
+  ServiceWorkerCacheQueryParams query_params;
+  query_params.ignore_search = web_query_params.ignoreSearch;
+  query_params.ignore_method = web_query_params.ignoreMethod;
+  query_params.ignore_vary = web_query_params.ignoreVary;
+  query_params.prefix_match = web_query_params.prefixMatch;
+
+  return query_params;
+}
+
+ServiceWorkerCacheOperationType CacheOperationTypeFromWebCacheOperationType(
+    blink::WebServiceWorkerCache::OperationType operation_type) {
+  switch (operation_type) {
+    case blink::WebServiceWorkerCache::OperationTypePut:
+      return SERVICE_WORKER_CACHE_OPERATION_TYPE_PUT;
+    case blink::WebServiceWorkerCache::OperationTypeDelete:
+      return SERVICE_WORKER_CACHE_OPERATION_TYPE_DELETE;
+    default:
+      return SERVICE_WORKER_CACHE_OPERATION_TYPE_UNDEFINED;
+  }
+}
+
+ServiceWorkerBatchOperation BatchOperationFromWebBatchOperation(
+    const blink::WebServiceWorkerCache::BatchOperation& web_operation) {
+  ServiceWorkerBatchOperation operation;
+  operation.operation_type =
+      CacheOperationTypeFromWebCacheOperationType(web_operation.operationType);
+  operation.request = FetchRequestFromWebRequest(web_operation.request);
+  operation.response = ResponseFromWebResponse(web_operation.response);
+  operation.match_params =
+      QueryParamsFromWebQueryParams(web_operation.matchParams);
+  return operation;
+}
+
 template<typename T>
 void ClearCallbacksMapWithErrors(T* callbacks_map) {
   typename T::iterator iter(callbacks_map);
@@ -27,9 +164,65 @@ void ClearCallbacksMapWithErrors(T* callbacks_map) {
 
 }  // namespace
 
+// The WebCache object is the Chromium side implementation of the Blink
+// WebServiceWorkerCache API. Most of its methods delegate directly to the
+// ServiceWorkerStorage object, which is able to assign unique IDs as well
+// as have a lifetime longer than the requests.
+class ServiceWorkerCacheStorageDispatcher::WebCache
+    : public blink::WebServiceWorkerCache {
+ public:
+  WebCache(base::WeakPtr<ServiceWorkerCacheStorageDispatcher> dispatcher,
+           int cache_id)
+      : dispatcher_(dispatcher),
+        cache_id_(cache_id) {}
+
+  virtual ~WebCache() {
+    if (dispatcher_)
+      dispatcher_->OnWebCacheDestruction(cache_id_);
+  }
+
+  // From blink::WebServiceWorkerCache:
+  virtual void dispatchMatch(CacheMatchCallbacks* callbacks,
+                             const blink::WebServiceWorkerRequest& request,
+                             const QueryParams& query_params) {
+    if (!dispatcher_)
+      return;
+    dispatcher_->dispatchMatchForCache(cache_id_, callbacks, request,
+                                       query_params);
+  }
+  virtual void dispatchMatchAll(CacheWithResponsesCallbacks* callbacks,
+                                const blink::WebServiceWorkerRequest& request,
+                                const QueryParams& query_params) {
+    if (!dispatcher_)
+      return;
+    dispatcher_->dispatchMatchAllForCache(cache_id_, callbacks, request,
+                                          query_params);
+  }
+  virtual void dispatchKeys(CacheWithRequestsCallbacks* callbacks,
+                            const blink::WebServiceWorkerRequest* request,
+                            const QueryParams& query_params) {
+    if (!dispatcher_)
+      return;
+    dispatcher_->dispatchKeysForCache(cache_id_, callbacks, request,
+                                      query_params);
+  }
+  virtual void dispatchBatch(
+      CacheWithResponsesCallbacks* callbacks,
+      const blink::WebVector<BatchOperation>& batch_operations) {
+    if (!dispatcher_)
+      return;
+    dispatcher_->dispatchBatchForCache(cache_id_, callbacks, batch_operations);
+  }
+
+ private:
+  const base::WeakPtr<ServiceWorkerCacheStorageDispatcher> dispatcher_;
+  const int cache_id_;
+};
+
 ServiceWorkerCacheStorageDispatcher::ServiceWorkerCacheStorageDispatcher(
     ServiceWorkerScriptContext* script_context)
-  : script_context_(script_context) {}
+    : script_context_(script_context),
+      weak_factory_(this) {}
 
 ServiceWorkerCacheStorageDispatcher::~ServiceWorkerCacheStorageDispatcher() {
   ClearCallbacksMapWithErrors(&get_callbacks_);
@@ -37,32 +230,53 @@ ServiceWorkerCacheStorageDispatcher::~ServiceWorkerCacheStorageDispatcher() {
   ClearCallbacksMapWithErrors(&create_callbacks_);
   ClearCallbacksMapWithErrors(&delete_callbacks_);
   ClearCallbacksMapWithErrors(&keys_callbacks_);
+
+  ClearCallbacksMapWithErrors(&cache_match_callbacks_);
+  ClearCallbacksMapWithErrors(&cache_match_all_callbacks_);
+  ClearCallbacksMapWithErrors(&cache_keys_callbacks_);
+  ClearCallbacksMapWithErrors(&cache_batch_callbacks_);
 }
 
 bool ServiceWorkerCacheStorageDispatcher::OnMessageReceived(
     const IPC::Message& message)  {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(ServiceWorkerCacheStorageDispatcher, message)
-     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_CacheStorageGetSuccess,
-                         OnCacheStorageGetSuccess)
-     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_CacheStorageHasSuccess,
-                         OnCacheStorageHasSuccess)
-     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_CacheStorageCreateSuccess,
-                         OnCacheStorageCreateSuccess)
-     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_CacheStorageDeleteSuccess,
-                         OnCacheStorageDeleteSuccess)
-     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_CacheStorageKeysSuccess,
-                         OnCacheStorageKeysSuccess)
-     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_CacheStorageGetError,
-                         OnCacheStorageGetError)
-     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_CacheStorageHasError,
-                         OnCacheStorageHasError)
-     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_CacheStorageCreateError,
-                         OnCacheStorageCreateError)
-     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_CacheStorageDeleteError,
-                         OnCacheStorageDeleteError)
-     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_CacheStorageKeysError,
-                         OnCacheStorageKeysError)
+      IPC_MESSAGE_HANDLER(ServiceWorkerMsg_CacheStorageGetSuccess,
+                          OnCacheStorageGetSuccess)
+      IPC_MESSAGE_HANDLER(ServiceWorkerMsg_CacheStorageHasSuccess,
+                          OnCacheStorageHasSuccess)
+      IPC_MESSAGE_HANDLER(ServiceWorkerMsg_CacheStorageCreateSuccess,
+                          OnCacheStorageCreateSuccess)
+      IPC_MESSAGE_HANDLER(ServiceWorkerMsg_CacheStorageDeleteSuccess,
+                          OnCacheStorageDeleteSuccess)
+      IPC_MESSAGE_HANDLER(ServiceWorkerMsg_CacheStorageKeysSuccess,
+                          OnCacheStorageKeysSuccess)
+      IPC_MESSAGE_HANDLER(ServiceWorkerMsg_CacheStorageGetError,
+                          OnCacheStorageGetError)
+      IPC_MESSAGE_HANDLER(ServiceWorkerMsg_CacheStorageHasError,
+                          OnCacheStorageHasError)
+      IPC_MESSAGE_HANDLER(ServiceWorkerMsg_CacheStorageCreateError,
+                          OnCacheStorageCreateError)
+      IPC_MESSAGE_HANDLER(ServiceWorkerMsg_CacheStorageDeleteError,
+                          OnCacheStorageDeleteError)
+      IPC_MESSAGE_HANDLER(ServiceWorkerMsg_CacheStorageKeysError,
+                          OnCacheStorageKeysError)
+      IPC_MESSAGE_HANDLER(ServiceWorkerMsg_CacheMatchSuccess,
+                          OnCacheMatchSuccess)
+      IPC_MESSAGE_HANDLER(ServiceWorkerMsg_CacheMatchAllSuccess,
+                          OnCacheMatchAllSuccess)
+      IPC_MESSAGE_HANDLER(ServiceWorkerMsg_CacheKeysSuccess,
+                          OnCacheKeysSuccess)
+      IPC_MESSAGE_HANDLER(ServiceWorkerMsg_CacheBatchSuccess,
+                          OnCacheBatchSuccess)
+      IPC_MESSAGE_HANDLER(ServiceWorkerMsg_CacheMatchError,
+                          OnCacheMatchError)
+      IPC_MESSAGE_HANDLER(ServiceWorkerMsg_CacheMatchAllError,
+                          OnCacheMatchAllError)
+      IPC_MESSAGE_HANDLER(ServiceWorkerMsg_CacheKeysError,
+                          OnCacheKeysError)
+      IPC_MESSAGE_HANDLER(ServiceWorkerMsg_CacheBatchError,
+                          OnCacheBatchError)
      IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
 
@@ -72,9 +286,10 @@ bool ServiceWorkerCacheStorageDispatcher::OnMessageReceived(
 void ServiceWorkerCacheStorageDispatcher::OnCacheStorageGetSuccess(
     int request_id,
     int cache_id) {
-  CacheStorageWithCacheCallbacks* callbacks =
-      get_callbacks_.Lookup(request_id);
-  callbacks->onSuccess(NULL);
+  WebCache* web_cache = new WebCache(weak_factory_.GetWeakPtr(), cache_id);
+  web_caches_.AddWithID(web_cache, cache_id);
+  CacheStorageWithCacheCallbacks* callbacks = get_callbacks_.Lookup(request_id);
+  callbacks->onSuccess(web_cache);
   get_callbacks_.Remove(request_id);
 }
 
@@ -88,9 +303,11 @@ void ServiceWorkerCacheStorageDispatcher::OnCacheStorageHasSuccess(
 void ServiceWorkerCacheStorageDispatcher::OnCacheStorageCreateSuccess(
     int request_id,
     int cache_id) {
+  WebCache* web_cache = new WebCache(weak_factory_.GetWeakPtr(), cache_id);
+  web_caches_.AddWithID(web_cache, cache_id);
   CacheStorageWithCacheCallbacks* callbacks =
       create_callbacks_.Lookup(request_id);
-  callbacks->onSuccess(NULL);
+  callbacks->onSuccess(web_cache);
   create_callbacks_.Remove(request_id);
 }
 
@@ -155,6 +372,91 @@ void ServiceWorkerCacheStorageDispatcher::OnCacheStorageKeysError(
   keys_callbacks_.Remove(request_id);
 }
 
+void ServiceWorkerCacheStorageDispatcher::OnCacheMatchSuccess(
+    int request_id,
+    const ServiceWorkerResponse& response) {
+  blink::WebServiceWorkerCache::CacheMatchCallbacks* callbacks =
+      cache_match_callbacks_.Lookup(request_id);
+
+  blink::WebServiceWorkerResponse web_response;
+  PopulateWebResponseFromResponse(response, &web_response);
+  callbacks->onSuccess(&web_response);
+  cache_match_callbacks_.Remove(request_id);
+}
+
+void ServiceWorkerCacheStorageDispatcher::OnCacheMatchAllSuccess(
+    int request_id,
+    const std::vector<ServiceWorkerResponse>& responses) {
+  blink::WebServiceWorkerCache::CacheWithResponsesCallbacks* callbacks =
+      cache_match_all_callbacks_.Lookup(request_id);
+
+  blink::WebVector<blink::WebServiceWorkerResponse>
+      web_responses = WebResponsesFromResponses(responses);
+  callbacks->onSuccess(&web_responses);
+  cache_match_all_callbacks_.Remove(request_id);
+}
+
+void ServiceWorkerCacheStorageDispatcher::OnCacheKeysSuccess(
+
+    int request_id,
+    const std::vector<ServiceWorkerFetchRequest>& requests) {
+  blink::WebServiceWorkerCache::CacheWithRequestsCallbacks* callbacks =
+      cache_keys_callbacks_.Lookup(request_id);
+
+  blink::WebVector<blink::WebServiceWorkerRequest>
+      web_requests = WebRequestsFromRequests(requests);
+  callbacks->onSuccess(&web_requests);
+  cache_keys_callbacks_.Remove(request_id);
+}
+
+void ServiceWorkerCacheStorageDispatcher::OnCacheBatchSuccess(
+    int request_id,
+    const std::vector<ServiceWorkerResponse>& responses) {
+  blink::WebServiceWorkerCache::CacheWithResponsesCallbacks* callbacks =
+      cache_batch_callbacks_.Lookup(request_id);
+
+  blink::WebVector<blink::WebServiceWorkerResponse>
+      web_responses = WebResponsesFromResponses(responses);
+  callbacks->onSuccess(&web_responses);
+  cache_batch_callbacks_.Remove(request_id);
+}
+
+void ServiceWorkerCacheStorageDispatcher::OnCacheMatchError(
+    int request_id,
+    blink::WebServiceWorkerCacheError reason) {
+  blink::WebServiceWorkerCache::CacheMatchCallbacks* callbacks =
+      cache_match_callbacks_.Lookup(request_id);
+  callbacks->onError(&reason);
+  cache_match_callbacks_.Remove(request_id);
+}
+
+void ServiceWorkerCacheStorageDispatcher::OnCacheMatchAllError(
+    int request_id,
+    blink::WebServiceWorkerCacheError reason) {
+  blink::WebServiceWorkerCache::CacheWithResponsesCallbacks* callbacks =
+      cache_match_all_callbacks_.Lookup(request_id);
+  callbacks->onError(&reason);
+  cache_match_all_callbacks_.Remove(request_id);
+}
+
+void ServiceWorkerCacheStorageDispatcher::OnCacheKeysError(
+    int request_id,
+    blink::WebServiceWorkerCacheError reason) {
+  blink::WebServiceWorkerCache::CacheWithRequestsCallbacks* callbacks =
+      cache_keys_callbacks_.Lookup(request_id);
+  callbacks->onError(&reason);
+  cache_keys_callbacks_.Remove(request_id);
+}
+
+void ServiceWorkerCacheStorageDispatcher::OnCacheBatchError(
+    int request_id,
+    blink::WebServiceWorkerCacheError reason) {
+  blink::WebServiceWorkerCache::CacheWithResponsesCallbacks* callbacks =
+      cache_batch_callbacks_.Lookup(request_id);
+  callbacks->onError(&reason);
+  cache_batch_callbacks_.Remove(request_id);
+}
+
 void ServiceWorkerCacheStorageDispatcher::dispatchGet(
     CacheStorageWithCacheCallbacks* callbacks,
     const blink::WebString& cacheName) {
@@ -194,4 +496,68 @@ void ServiceWorkerCacheStorageDispatcher::dispatchKeys(
       script_context_->GetRoutingID(), request_id));
 }
 
+void ServiceWorkerCacheStorageDispatcher::dispatchMatchForCache(
+    int cache_id,
+    blink::WebServiceWorkerCache::CacheMatchCallbacks* callbacks,
+    const blink::WebServiceWorkerRequest& request,
+    const blink::WebServiceWorkerCache::QueryParams& query_params) {
+  int request_id = cache_match_callbacks_.Add(callbacks);
+
+  script_context_->Send(new ServiceWorkerHostMsg_CacheMatch(
+      script_context_->GetRoutingID(), request_id, cache_id,
+      FetchRequestFromWebRequest(request),
+      QueryParamsFromWebQueryParams(query_params)));
+}
+
+void ServiceWorkerCacheStorageDispatcher::dispatchMatchAllForCache(
+    int cache_id,
+    blink::WebServiceWorkerCache::CacheWithResponsesCallbacks* callbacks,
+    const blink::WebServiceWorkerRequest& request,
+    const blink::WebServiceWorkerCache::QueryParams& query_params) {
+  int request_id = cache_match_all_callbacks_.Add(callbacks);
+
+  script_context_->Send(new ServiceWorkerHostMsg_CacheMatchAll(
+      script_context_->GetRoutingID(), request_id, cache_id,
+      FetchRequestFromWebRequest(request),
+      QueryParamsFromWebQueryParams(query_params)));
+}
+
+void ServiceWorkerCacheStorageDispatcher::dispatchKeysForCache(
+    int cache_id,
+    blink::WebServiceWorkerCache::CacheWithRequestsCallbacks* callbacks,
+    const blink::WebServiceWorkerRequest* request,
+    const blink::WebServiceWorkerCache::QueryParams& query_params) {
+  int request_id = cache_keys_callbacks_.Add(callbacks);
+
+  script_context_->Send(new ServiceWorkerHostMsg_CacheKeys(
+      script_context_->GetRoutingID(), request_id, cache_id,
+      request ? FetchRequestFromWebRequest(*request)
+              : ServiceWorkerFetchRequest(),
+      QueryParamsFromWebQueryParams(query_params)));
+}
+
+void ServiceWorkerCacheStorageDispatcher::dispatchBatchForCache(
+    int cache_id,
+    blink::WebServiceWorkerCache::CacheWithResponsesCallbacks* callbacks,
+    const blink::WebVector<
+        blink::WebServiceWorkerCache::BatchOperation>& web_operations) {
+  int request_id = cache_batch_callbacks_.Add(callbacks);
+
+  std::vector<ServiceWorkerBatchOperation> operations;
+  operations.reserve(web_operations.size());
+  for (size_t i = 0; i < web_operations.size(); ++i) {
+    operations.push_back(
+        BatchOperationFromWebBatchOperation(web_operations[i]));
+  }
+
+  script_context_->Send(new ServiceWorkerHostMsg_CacheBatch(
+      script_context_->GetRoutingID(), request_id, cache_id, operations));
+}
+
+void ServiceWorkerCacheStorageDispatcher::OnWebCacheDestruction(int cache_id) {
+  web_caches_.Remove(cache_id);
+  script_context_->Send(new ServiceWorkerHostMsg_CacheClosed(
+      script_context_->GetRoutingID(), cache_id));
+}
+
 }  // namespace content