content/renderer/shared_worker/embedded_shared_worker_stub.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/shared_worker/embedded_shared_worker_stub.h"
   6
   7 #include "base/message_loop/message_loop_proxy.h"
   8 #include "content/child/appcache/appcache_dispatcher.h"
   9 #include "content/child/appcache/web_application_cache_host_impl.h"
  10 #include "content/child/scoped_child_process_reference.h"
  11 #include "content/child/shared_worker_devtools_agent.h"
  12 #include "content/child/webmessageportchannel_impl.h"
  13 #include "content/common/worker_messages.h"
  14 #include "content/renderer/render_thread_impl.h"
  15 #include "content/renderer/shared_worker/embedded_shared_worker_permission_client_proxy.h"
  16 #include "ipc/ipc_message_macros.h"
  17 #include "third_party/WebKit/public/web/WebSecurityOrigin.h"
  18 #include "third_party/WebKit/public/web/WebSharedWorker.h"
  19 #include "third_party/WebKit/public/web/WebSharedWorkerClient.h"
  20
  21 namespace content {
  22
  23 namespace {
  24
  25 class SharedWorkerWebApplicationCacheHostImpl
  26     : public WebApplicationCacheHostImpl {
  27  public:
  28   SharedWorkerWebApplicationCacheHostImpl(
  29       blink::WebApplicationCacheHostClient* client)
  30       : WebApplicationCacheHostImpl(client,
  31                                     RenderThreadImpl::current()
  32                                         ->appcache_dispatcher()
  33                                         ->backend_proxy()) {}
  34
  35   // Main resource loading is different for workers. The main resource is
  36   // loaded by the worker using WorkerScriptLoader.
  37   // These overrides are stubbed out.
  38   virtual void willStartMainResourceRequest(
  39       blink::WebURLRequest&,
  40       const blink::WebApplicationCacheHost*) {}
  41   virtual void didReceiveResponseForMainResource(const blink::WebURLResponse&) {
  42   }
  43   virtual void didReceiveDataForMainResource(const char* data, int len) {}
  44   virtual void didFinishLoadingMainResource(bool success) {}
  45
  46   // Cache selection is also different for workers. We know at construction
  47   // time what cache to select and do so then.
  48   // These overrides are stubbed out.
  49   virtual void selectCacheWithoutManifest() {}
  50   virtual bool selectCacheWithManifest(const blink::WebURL& manifestURL) {
  51     return true;
  52   }
  53 };
  54 }
  55
  56 EmbeddedSharedWorkerStub::EmbeddedSharedWorkerStub(
  57     const GURL& url,
  58     const base::string16& name,
  59     const base::string16& content_security_policy,
  60     blink::WebContentSecurityPolicyType security_policy_type,
  61     bool pause_on_start,
  62     int route_id)
  63     : route_id_(route_id), name_(name), runing_(false), url_(url) {
  64   RenderThreadImpl::current()->AddEmbeddedWorkerRoute(route_id_, this);
  65   impl_ = blink::WebSharedWorker::create(this);
  66   if (pause_on_start) {
  67     // Pause worker context when it starts and wait until either DevTools client
  68     // is attached or explicit resume notification is received.
  69     impl_->pauseWorkerContextOnStart();
  70   }
  71   worker_devtools_agent_.reset(
  72       new SharedWorkerDevToolsAgent(route_id, impl_));
  73   impl_->startWorkerContext(url, name_,
  74                             content_security_policy, security_policy_type);
  75 }
  76
  77 EmbeddedSharedWorkerStub::~EmbeddedSharedWorkerStub() {
  78   RenderThreadImpl::current()->RemoveEmbeddedWorkerRoute(route_id_);
  79 }
  80
  81 bool EmbeddedSharedWorkerStub::OnMessageReceived(
  82     const IPC::Message& message) {
  83   if (worker_devtools_agent_->OnMessageReceived(message))
  84     return true;
  85   bool handled = true;
  86   IPC_BEGIN_MESSAGE_MAP(EmbeddedSharedWorkerStub, message)
  87     IPC_MESSAGE_HANDLER(WorkerMsg_TerminateWorkerContext,
  88                         OnTerminateWorkerContext)
  89     IPC_MESSAGE_HANDLER(WorkerMsg_Connect, OnConnect)
  90     IPC_MESSAGE_UNHANDLED(handled = false)
  91   IPC_END_MESSAGE_MAP()
  92   return handled;
  93 }
  94
  95 void EmbeddedSharedWorkerStub::OnChannelError() {
  96   OnTerminateWorkerContext();
  97 }
  98
  99 void EmbeddedSharedWorkerStub::workerReadyForInspection() {
 100   Send(new WorkerHostMsg_WorkerReadyForInspection(route_id_));
 101 }
 102
 103 void EmbeddedSharedWorkerStub::workerScriptLoaded() {
 104   Send(new WorkerHostMsg_WorkerScriptLoaded(route_id_));
 105   runing_ = true;
 106   // Process any pending connections.
 107   for (PendingChannelList::const_iterator iter = pending_channels_.begin();
 108        iter != pending_channels_.end();
 109        ++iter) {
 110     ConnectToChannel(*iter);
 111   }
 112   pending_channels_.clear();
 113 }
 114
 115 void EmbeddedSharedWorkerStub::workerScriptLoadFailed() {
 116   Send(new WorkerHostMsg_WorkerScriptLoadFailed(route_id_));
 117   for (PendingChannelList::const_iterator iter = pending_channels_.begin();
 118        iter != pending_channels_.end();
 119        ++iter) {
 120     blink::WebMessagePortChannel* channel = *iter;
 121     channel->destroy();
 122   }
 123   pending_channels_.clear();
 124   Shutdown();
 125 }
 126
 127 void EmbeddedSharedWorkerStub::workerContextClosed() {
 128   Send(new WorkerHostMsg_WorkerContextClosed(route_id_));
 129 }
 130
 131 void EmbeddedSharedWorkerStub::workerContextDestroyed() {
 132   Send(new WorkerHostMsg_WorkerContextDestroyed(route_id_));
 133   Shutdown();
 134 }
 135
 136 void EmbeddedSharedWorkerStub::selectAppCacheID(long long app_cache_id) {
 137   if (app_cache_host_) {
 138     // app_cache_host_ could become stale as it's owned by blink's
 139     // DocumentLoader. This method is assumed to be called while it's valid.
 140     app_cache_host_->backend()->SelectCacheForSharedWorker(
 141         app_cache_host_->host_id(), app_cache_id);
 142   }
 143 }
 144
 145 blink::WebNotificationPresenter*
 146 EmbeddedSharedWorkerStub::notificationPresenter() {
 147   // TODO(horo): delete this method if we have no plan to implement this.
 148   NOTREACHED();
 149   return NULL;
 150 }
 151
 152 blink::WebApplicationCacheHost*
 153 EmbeddedSharedWorkerStub::createApplicationCacheHost(
 154     blink::WebApplicationCacheHostClient* client) {
 155   app_cache_host_ = new SharedWorkerWebApplicationCacheHostImpl(client);
 156   return app_cache_host_;
 157 }
 158
 159 blink::WebWorkerPermissionClientProxy*
 160     EmbeddedSharedWorkerStub::createWorkerPermissionClientProxy(
 161     const blink::WebSecurityOrigin& origin) {
 162   return new EmbeddedSharedWorkerPermissionClientProxy(
 163       GURL(origin.toString()),
 164       origin.isUnique(),
 165       route_id_,
 166       ChildThread::current()->thread_safe_sender());
 167 }
 168
 169 void EmbeddedSharedWorkerStub::dispatchDevToolsMessage(
 170       const blink::WebString& message) {
 171   worker_devtools_agent_->SendDevToolsMessage(message);
 172 }
 173
 174 void EmbeddedSharedWorkerStub::saveDevToolsAgentState(
 175       const blink::WebString& state) {
 176   worker_devtools_agent_->SaveDevToolsAgentState(state);
 177 }
 178
 179 void EmbeddedSharedWorkerStub::Shutdown() {
 180   delete this;
 181 }
 182
 183 bool EmbeddedSharedWorkerStub::Send(IPC::Message* message) {
 184   return RenderThreadImpl::current()->Send(message);
 185 }
 186
 187 void EmbeddedSharedWorkerStub::ConnectToChannel(
 188     WebMessagePortChannelImpl* channel) {
 189   impl_->connect(channel);
 190   Send(
 191       new WorkerHostMsg_WorkerConnected(channel->message_port_id(), route_id_));
 192 }
 193
 194 void EmbeddedSharedWorkerStub::OnConnect(int sent_message_port_id,
 195                                          int routing_id) {
 196   WebMessagePortChannelImpl* channel =
 197       new WebMessagePortChannelImpl(routing_id,
 198                                     sent_message_port_id,
 199                                     base::MessageLoopProxy::current().get());
 200   if (runing_) {
 201     ConnectToChannel(channel);
 202   } else {
 203     // If two documents try to load a SharedWorker at the same time, the
 204     // WorkerMsg_Connect for one of the documents can come in before the
 205     // worker is started. Just queue up the connect and deliver it once the
 206     // worker starts.
 207     pending_channels_.push_back(channel);
 208   }
 209 }
 210
 211 void EmbeddedSharedWorkerStub::OnTerminateWorkerContext() {
 212   runing_ = false;
 213   impl_->terminateWorkerContext();
 214 }
 215
 216 }  // namespace content