content/renderer/service_worker/service_worker_script_context.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "content/renderer/service_worker/service_worker_script_context.h"
   6
   7 #include <map>
   8
   9 #include "base/logging.h"
  10 #include "content/child/thread_safe_sender.h"
  11 #include "content/child/webmessageportchannel_impl.h"
  12 #include "content/common/service_worker/service_worker_messages.h"
  13 #include "content/renderer/service_worker/embedded_worker_context_client.h"
  14 #include "ipc/ipc_message.h"
  15 #include "third_party/WebKit/public/platform/WebReferrerPolicy.h"
  16 #include "third_party/WebKit/public/platform/WebServiceWorkerRequest.h"
  17 #include "third_party/WebKit/public/platform/WebString.h"
  18 #include "third_party/WebKit/public/platform/WebURL.h"
  19 #include "third_party/WebKit/public/web/WebServiceWorkerContextClient.h"
  20 #include "third_party/WebKit/public/web/WebServiceWorkerContextProxy.h"
  21
  22 namespace content {
  23
  24 namespace {
  25
  26 void SendPostMessageToDocumentOnMainThread(
  27     ThreadSafeSender* sender,
  28     int routing_id,
  29     int client_id,
  30     const base::string16& message,
  31     scoped_ptr<blink::WebMessagePortChannelArray> channels) {
  32   sender->Send(new ServiceWorkerHostMsg_PostMessageToDocument(
  33       routing_id, client_id, message,
  34       WebMessagePortChannelImpl::ExtractMessagePortIDs(channels.release())));
  35 }
  36
  37 }  // namespace
  38
  39 ServiceWorkerScriptContext::ServiceWorkerScriptContext(
  40     EmbeddedWorkerContextClient* embedded_context,
  41     blink::WebServiceWorkerContextProxy* proxy)
  42     : cache_storage_dispatcher_(new ServiceWorkerCacheStorageDispatcher(this)),
  43       embedded_context_(embedded_context),
  44       proxy_(proxy) {
  45 }
  46
  47 ServiceWorkerScriptContext::~ServiceWorkerScriptContext() {}
  48
  49 void ServiceWorkerScriptContext::OnMessageReceived(
  50     const IPC::Message& message) {
  51   bool handled = true;
  52   IPC_BEGIN_MESSAGE_MAP(ServiceWorkerScriptContext, message)
  53     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_ActivateEvent, OnActivateEvent)
  54     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_FetchEvent, OnFetchEvent)
  55     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_InstallEvent, OnInstallEvent)
  56     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_SyncEvent, OnSyncEvent)
  57     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_PushEvent, OnPushEvent)
  58     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_MessageToWorker, OnPostMessage)
  59     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_DidGetClientDocuments,
  60                         OnDidGetClientDocuments)
  61     IPC_MESSAGE_UNHANDLED(handled = false)
  62   IPC_END_MESSAGE_MAP()
  63
  64   // TODO(gavinp): Would it be preferable to put an AddListener() method to
  65   // EmbeddedWorkerContextClient?
  66   if (!handled)
  67     handled = cache_storage_dispatcher_->OnMessageReceived(message);
  68
  69   DCHECK(handled);
  70 }
  71
  72 void ServiceWorkerScriptContext::DidHandleActivateEvent(
  73     int request_id,
  74     blink::WebServiceWorkerEventResult result) {
  75   Send(new ServiceWorkerHostMsg_ActivateEventFinished(
  76       GetRoutingID(), request_id, result));
  77 }
  78
  79 void ServiceWorkerScriptContext::DidHandleInstallEvent(
  80     int request_id,
  81     blink::WebServiceWorkerEventResult result) {
  82   Send(new ServiceWorkerHostMsg_InstallEventFinished(
  83       GetRoutingID(), request_id, result));
  84 }
  85
  86 void ServiceWorkerScriptContext::DidHandleFetchEvent(
  87     int request_id,
  88     ServiceWorkerFetchEventResult result,
  89     const ServiceWorkerResponse& response) {
  90   Send(new ServiceWorkerHostMsg_FetchEventFinished(
  91       GetRoutingID(), request_id, result, response));
  92 }
  93
  94 void ServiceWorkerScriptContext::DidHandleSyncEvent(int request_id) {
  95   Send(new ServiceWorkerHostMsg_SyncEventFinished(
  96       GetRoutingID(), request_id));
  97 }
  98
  99 void ServiceWorkerScriptContext::GetClientDocuments(
 100     blink::WebServiceWorkerClientsCallbacks* callbacks) {
 101   DCHECK(callbacks);
 102   int request_id = pending_clients_callbacks_.Add(callbacks);
 103   Send(new ServiceWorkerHostMsg_GetClientDocuments(
 104       GetRoutingID(), request_id));
 105 }
 106
 107 void ServiceWorkerScriptContext::PostMessageToDocument(
 108     int client_id,
 109     const base::string16& message,
 110     scoped_ptr<blink::WebMessagePortChannelArray> channels) {
 111   // This may send channels for MessagePorts, and all internal book-keeping
 112   // messages for MessagePort (e.g. QueueMessages) are sent from main thread
 113   // (with thread hopping), so we need to do the same thread hopping here not
 114   // to overtake those messages.
 115   embedded_context_->main_thread_proxy()->PostTask(
 116       FROM_HERE,
 117       base::Bind(&SendPostMessageToDocumentOnMainThread,
 118                  make_scoped_refptr(embedded_context_->thread_safe_sender()),
 119                  GetRoutingID(), client_id, message, base::Passed(&channels)));
 120 }
 121
 122 void ServiceWorkerScriptContext::Send(IPC::Message* message) {
 123   embedded_context_->Send(message);
 124 }
 125
 126 int ServiceWorkerScriptContext::GetRoutingID() const {
 127   return embedded_context_->embedded_worker_id();
 128 }
 129
 130 void ServiceWorkerScriptContext::OnActivateEvent(int request_id) {
 131   proxy_->dispatchActivateEvent(request_id);
 132 }
 133
 134 void ServiceWorkerScriptContext::OnInstallEvent(int request_id,
 135                                                 int active_version_id) {
 136   proxy_->dispatchInstallEvent(request_id);
 137 }
 138
 139 void ServiceWorkerScriptContext::OnFetchEvent(
 140     int request_id,
 141     const ServiceWorkerFetchRequest& request) {
 142   blink::WebServiceWorkerRequest webRequest;
 143   webRequest.setURL(blink::WebURL(request.url));
 144   webRequest.setMethod(blink::WebString::fromUTF8(request.method));
 145   for (std::map<std::string, std::string>::const_iterator it =
 146            request.headers.begin();
 147        it != request.headers.end();
 148        ++it) {
 149     webRequest.setHeader(blink::WebString::fromUTF8(it->first),
 150                          blink::WebString::fromUTF8(it->second));
 151   }
 152   if (!request.blob_uuid.empty()) {
 153     webRequest.setBlob(blink::WebString::fromUTF8(request.blob_uuid),
 154                        request.blob_size);
 155   }
 156   webRequest.setReferrer(blink::WebString::fromUTF8(request.referrer.spec()),
 157                          blink::WebReferrerPolicyDefault);
 158   webRequest.setIsReload(request.is_reload);
 159   proxy_->dispatchFetchEvent(request_id, webRequest);
 160 }
 161
 162 void ServiceWorkerScriptContext::OnSyncEvent(int request_id) {
 163   proxy_->dispatchSyncEvent(request_id);
 164 }
 165
 166 void ServiceWorkerScriptContext::OnPushEvent(int request_id,
 167                                              const std::string& data) {
 168   proxy_->dispatchPushEvent(request_id, blink::WebString::fromUTF8(data));
 169   Send(new ServiceWorkerHostMsg_PushEventFinished(
 170       GetRoutingID(), request_id));
 171 }
 172
 173 void ServiceWorkerScriptContext::OnPostMessage(
 174     const base::string16& message,
 175     const std::vector<int>& sent_message_port_ids,
 176     const std::vector<int>& new_routing_ids) {
 177   std::vector<WebMessagePortChannelImpl*> ports;
 178   if (!sent_message_port_ids.empty()) {
 179     base::MessageLoopProxy* loop_proxy = embedded_context_->main_thread_proxy();
 180     ports.resize(sent_message_port_ids.size());
 181     for (size_t i = 0; i < sent_message_port_ids.size(); ++i) {
 182       ports[i] = new WebMessagePortChannelImpl(
 183           new_routing_ids[i], sent_message_port_ids[i], loop_proxy);
 184     }
 185   }
 186
 187   proxy_->dispatchMessageEvent(message, ports);
 188 }
 189
 190 void ServiceWorkerScriptContext::OnDidGetClientDocuments(
 191     int request_id, const std::vector<int>& client_ids) {
 192   blink::WebServiceWorkerClientsCallbacks* callbacks =
 193       pending_clients_callbacks_.Lookup(request_id);
 194   if (!callbacks) {
 195     NOTREACHED() << "Got stray response: " << request_id;
 196     return;
 197   }
 198   scoped_ptr<blink::WebServiceWorkerClientsInfo> info(
 199       new blink::WebServiceWorkerClientsInfo);
 200   info->clientIDs = client_ids;
 201   callbacks->onSuccess(info.release());
 202   pending_clients_callbacks_.Remove(request_id);
 203 }
 204
 205 }  // namespace content