content/browser/shared_worker/shared_worker_host.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/browser/shared_worker/shared_worker_host.h"
   6
   7 #include "base/metrics/histogram.h"
   8 #include "content/browser/devtools/embedded_worker_devtools_manager.h"
   9 #include "content/browser/frame_host/render_frame_host_delegate.h"
  10 #include "content/browser/frame_host/render_frame_host_impl.h"
  11 #include "content/browser/message_port_service.h"
  12 #include "content/browser/shared_worker/shared_worker_instance.h"
  13 #include "content/browser/shared_worker/shared_worker_message_filter.h"
  14 #include "content/browser/shared_worker/shared_worker_service_impl.h"
  15 #include "content/browser/shared_worker/worker_document_set.h"
  16 #include "content/common/view_messages.h"
  17 #include "content/common/worker_messages.h"
  18 #include "content/public/browser/browser_thread.h"
  19 #include "content/public/browser/content_browser_client.h"
  20 #include "content/public/browser/render_process_host.h"
  21 #include "content/public/common/content_client.h"
  22
  23 namespace content {
  24 namespace {
  25
  26 // Notifies RenderViewHost that one or more worker objects crashed.
  27 void WorkerCrashCallback(int render_process_unique_id, int render_frame_id) {
  28   RenderFrameHostImpl* host =
  29       RenderFrameHostImpl::FromID(render_process_unique_id, render_frame_id);
  30   if (host)
  31     host->delegate()->WorkerCrashed(host);
  32 }
  33
  34 void NotifyWorkerReadyForInspection(int worker_process_id,
  35                                     int worker_route_id) {
  36   if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
  37     BrowserThread::PostTask(BrowserThread::UI,
  38                             FROM_HERE,
  39                             base::Bind(NotifyWorkerReadyForInspection,
  40                                        worker_process_id,
  41                                        worker_route_id));
  42     return;
  43   }
  44   EmbeddedWorkerDevToolsManager::GetInstance()->WorkerReadyForInspection(
  45       worker_process_id, worker_route_id);
  46 }
  47
  48 void NotifyWorkerContextStarted(int worker_process_id, int worker_route_id) {
  49   if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
  50     BrowserThread::PostTask(
  51         BrowserThread::UI,
  52         FROM_HERE,
  53         base::Bind(
  54             NotifyWorkerContextStarted, worker_process_id, worker_route_id));
  55     return;
  56   }
  57   EmbeddedWorkerDevToolsManager::GetInstance()->WorkerContextStarted(
  58       worker_process_id, worker_route_id);
  59 }
  60
  61 void NotifyWorkerDestroyed(int worker_process_id, int worker_route_id) {
  62   if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
  63     BrowserThread::PostTask(
  64         BrowserThread::UI,
  65         FROM_HERE,
  66         base::Bind(NotifyWorkerDestroyed, worker_process_id, worker_route_id));
  67     return;
  68   }
  69   EmbeddedWorkerDevToolsManager::GetInstance()->WorkerDestroyed(
  70       worker_process_id, worker_route_id);
  71 }
  72
  73 }  // namespace
  74
  75 SharedWorkerHost::SharedWorkerHost(SharedWorkerInstance* instance,
  76                                    SharedWorkerMessageFilter* filter,
  77                                    int worker_route_id)
  78     : instance_(instance),
  79       worker_document_set_(new WorkerDocumentSet()),
  80       weak_factory_(this),
  81       container_render_filter_(filter),
  82       worker_process_id_(filter->render_process_id()),
  83       worker_route_id_(worker_route_id),
  84       load_failed_(false),
  85       closed_(false),
  86       creation_time_(base::TimeTicks::Now()) {
  87   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
  88 }
  89
  90 SharedWorkerHost::~SharedWorkerHost() {
  91   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
  92   UMA_HISTOGRAM_LONG_TIMES("SharedWorker.TimeToDeleted",
  93                            base::TimeTicks::Now() - creation_time_);
  94   // If we crashed, tell the RenderViewHosts.
  95   if (instance_ && !load_failed_) {
  96     const WorkerDocumentSet::DocumentInfoSet& parents =
  97         worker_document_set_->documents();
  98     for (WorkerDocumentSet::DocumentInfoSet::const_iterator parent_iter =
  99              parents.begin();
 100          parent_iter != parents.end();
 101          ++parent_iter) {
 102       BrowserThread::PostTask(BrowserThread::UI,
 103                               FROM_HERE,
 104                               base::Bind(&WorkerCrashCallback,
 105                                          parent_iter->render_process_id(),
 106                                          parent_iter->render_frame_id()));
 107     }
 108   }
 109   if (!closed_)
 110     NotifyWorkerDestroyed(worker_process_id_, worker_route_id_);
 111   SharedWorkerServiceImpl::GetInstance()->NotifyWorkerDestroyed(
 112       worker_process_id_, worker_route_id_);
 113 }
 114
 115 bool SharedWorkerHost::Send(IPC::Message* message) {
 116   if (!container_render_filter_) {
 117     delete message;
 118     return false;
 119   }
 120   return container_render_filter_->Send(message);
 121 }
 122
 123 void SharedWorkerHost::Start(bool pause_on_start) {
 124   WorkerProcessMsg_CreateWorker_Params params;
 125   params.url = instance_->url();
 126   params.name = instance_->name();
 127   params.content_security_policy = instance_->content_security_policy();
 128   params.security_policy_type = instance_->security_policy_type();
 129   params.pause_on_start = pause_on_start;
 130   params.route_id = worker_route_id_;
 131   Send(new WorkerProcessMsg_CreateWorker(params));
 132
 133   for (FilterList::const_iterator i = filters_.begin(); i != filters_.end();
 134        ++i) {
 135     i->filter()->Send(new ViewMsg_WorkerCreated(i->route_id()));
 136   }
 137 }
 138
 139 bool SharedWorkerHost::FilterMessage(const IPC::Message& message,
 140                                      SharedWorkerMessageFilter* filter) {
 141   if (!instance_)
 142     return false;
 143
 144   if (!closed_ && HasFilter(filter, message.routing_id())) {
 145     RelayMessage(message, filter);
 146     return true;
 147   }
 148
 149   return false;
 150 }
 151
 152 void SharedWorkerHost::FilterShutdown(SharedWorkerMessageFilter* filter) {
 153   if (!instance_)
 154     return;
 155   RemoveFilters(filter);
 156   worker_document_set_->RemoveAll(filter);
 157   if (worker_document_set_->IsEmpty()) {
 158     // This worker has no more associated documents - shut it down.
 159     Send(new WorkerMsg_TerminateWorkerContext(worker_route_id_));
 160   }
 161 }
 162
 163 void SharedWorkerHost::DocumentDetached(SharedWorkerMessageFilter* filter,
 164                                         unsigned long long document_id) {
 165   if (!instance_)
 166     return;
 167   // Walk all instances and remove the document from their document set.
 168   worker_document_set_->Remove(filter, document_id);
 169   if (worker_document_set_->IsEmpty()) {
 170     // This worker has no more associated documents - shut it down.
 171     Send(new WorkerMsg_TerminateWorkerContext(worker_route_id_));
 172   }
 173 }
 174
 175 void SharedWorkerHost::WorkerContextClosed() {
 176   if (!instance_)
 177     return;
 178   // Set the closed flag - this will stop any further messages from
 179   // being sent to the worker (messages can still be sent from the worker,
 180   // for exception reporting, etc).
 181   closed_ = true;
 182   NotifyWorkerDestroyed(worker_process_id_, worker_route_id_);
 183 }
 184
 185 void SharedWorkerHost::WorkerContextDestroyed() {
 186   if (!instance_)
 187     return;
 188   instance_.reset();
 189   worker_document_set_ = NULL;
 190 }
 191
 192 void SharedWorkerHost::WorkerReadyForInspection() {
 193   NotifyWorkerReadyForInspection(worker_process_id_, worker_route_id_);
 194 }
 195
 196 void SharedWorkerHost::WorkerScriptLoaded() {
 197   UMA_HISTOGRAM_TIMES("SharedWorker.TimeToScriptLoaded",
 198                       base::TimeTicks::Now() - creation_time_);
 199   NotifyWorkerContextStarted(worker_process_id_, worker_route_id_);
 200 }
 201
 202 void SharedWorkerHost::WorkerScriptLoadFailed() {
 203   UMA_HISTOGRAM_TIMES("SharedWorker.TimeToScriptLoadFailed",
 204                       base::TimeTicks::Now() - creation_time_);
 205   if (!instance_)
 206     return;
 207   load_failed_ = true;
 208   for (FilterList::const_iterator i = filters_.begin(); i != filters_.end();
 209        ++i) {
 210     i->filter()->Send(new ViewMsg_WorkerScriptLoadFailed(i->route_id()));
 211   }
 212 }
 213
 214 void SharedWorkerHost::WorkerConnected(int message_port_id) {
 215   if (!instance_)
 216     return;
 217   for (FilterList::const_iterator i = filters_.begin(); i != filters_.end();
 218        ++i) {
 219     if (i->message_port_id() != message_port_id)
 220       continue;
 221     i->filter()->Send(new ViewMsg_WorkerConnected(i->route_id()));
 222     return;
 223   }
 224 }
 225
 226 void SharedWorkerHost::AllowDatabase(const GURL& url,
 227                                      const base::string16& name,
 228                                      const base::string16& display_name,
 229                                      unsigned long estimated_size,
 230                                      bool* result) {
 231   if (!instance_)
 232     return;
 233   *result = GetContentClient()->browser()->AllowWorkerDatabase(
 234       url,
 235       name,
 236       display_name,
 237       estimated_size,
 238       instance_->resource_context(),
 239       GetRenderFrameIDsForWorker());
 240 }
 241
 242 void SharedWorkerHost::AllowFileSystem(const GURL& url,
 243                                        scoped_ptr<IPC::Message> reply_msg) {
 244   if (!instance_)
 245     return;
 246   GetContentClient()->browser()->AllowWorkerFileSystem(
 247       url,
 248       instance_->resource_context(),
 249       GetRenderFrameIDsForWorker(),
 250       base::Bind(&SharedWorkerHost::AllowFileSystemResponse,
 251                  weak_factory_.GetWeakPtr(),
 252                  base::Passed(&reply_msg)));
 253 }
 254
 255 void SharedWorkerHost::AllowFileSystemResponse(
 256     scoped_ptr<IPC::Message> reply_msg,
 257     bool allowed) {
 258   WorkerProcessHostMsg_RequestFileSystemAccessSync::WriteReplyParams(
 259       reply_msg.get(),
 260       allowed);
 261   Send(reply_msg.release());
 262 }
 263
 264 void SharedWorkerHost::AllowIndexedDB(const GURL& url,
 265                                       const base::string16& name,
 266                                       bool* result) {
 267   if (!instance_)
 268     return;
 269   *result = GetContentClient()->browser()->AllowWorkerIndexedDB(
 270       url, name, instance_->resource_context(), GetRenderFrameIDsForWorker());
 271 }
 272
 273 void SharedWorkerHost::RelayMessage(
 274     const IPC::Message& message,
 275     SharedWorkerMessageFilter* incoming_filter) {
 276   if (!instance_)
 277     return;
 278   if (message.type() == WorkerMsg_Connect::ID) {
 279     // Crack the SharedWorker Connect message to setup routing for the port.
 280     WorkerMsg_Connect::Param param;
 281     if (!WorkerMsg_Connect::Read(&message, &param))
 282       return;
 283     int sent_message_port_id = param.a;
 284     int new_routing_id = param.b;
 285
 286     DCHECK(container_render_filter_);
 287     new_routing_id = container_render_filter_->GetNextRoutingID();
 288     MessagePortService::GetInstance()->UpdateMessagePort(
 289         sent_message_port_id,
 290         container_render_filter_->message_port_message_filter(),
 291         new_routing_id);
 292     SetMessagePortID(
 293         incoming_filter, message.routing_id(), sent_message_port_id);
 294     // Resend the message with the new routing id.
 295     Send(new WorkerMsg_Connect(
 296         worker_route_id_, sent_message_port_id, new_routing_id));
 297
 298     // Send any queued messages for the sent port.
 299     MessagePortService::GetInstance()->SendQueuedMessagesIfPossible(
 300         sent_message_port_id);
 301   } else {
 302     IPC::Message* new_message = new IPC::Message(message);
 303     new_message->set_routing_id(worker_route_id_);
 304     Send(new_message);
 305     return;
 306   }
 307 }
 308
 309 void SharedWorkerHost::TerminateWorker() {
 310   Send(new WorkerMsg_TerminateWorkerContext(worker_route_id_));
 311 }
 312
 313 std::vector<std::pair<int, int> >
 314 SharedWorkerHost::GetRenderFrameIDsForWorker() {
 315   std::vector<std::pair<int, int> > result;
 316   if (!instance_)
 317     return result;
 318   const WorkerDocumentSet::DocumentInfoSet& documents =
 319       worker_document_set_->documents();
 320   for (WorkerDocumentSet::DocumentInfoSet::const_iterator doc =
 321            documents.begin();
 322        doc != documents.end();
 323        ++doc) {
 324     result.push_back(
 325         std::make_pair(doc->render_process_id(), doc->render_frame_id()));
 326   }
 327   return result;
 328 }
 329
 330 void SharedWorkerHost::AddFilter(SharedWorkerMessageFilter* filter,
 331                                  int route_id) {
 332   CHECK(filter);
 333   if (!HasFilter(filter, route_id)) {
 334     FilterInfo info(filter, route_id);
 335     filters_.push_back(info);
 336   }
 337 }
 338
 339 void SharedWorkerHost::RemoveFilters(SharedWorkerMessageFilter* filter) {
 340   for (FilterList::iterator i = filters_.begin(); i != filters_.end();) {
 341     if (i->filter() == filter)
 342       i = filters_.erase(i);
 343     else
 344       ++i;
 345   }
 346 }
 347
 348 bool SharedWorkerHost::HasFilter(SharedWorkerMessageFilter* filter,
 349                                  int route_id) const {
 350   for (FilterList::const_iterator i = filters_.begin(); i != filters_.end();
 351        ++i) {
 352     if (i->filter() == filter && i->route_id() == route_id)
 353       return true;
 354   }
 355   return false;
 356 }
 357
 358 void SharedWorkerHost::SetMessagePortID(SharedWorkerMessageFilter* filter,
 359                                         int route_id,
 360                                         int message_port_id) {
 361   for (FilterList::iterator i = filters_.begin(); i != filters_.end(); ++i) {
 362     if (i->filter() == filter && i->route_id() == route_id) {
 363       i->set_message_port_id(message_port_id);
 364       return;
 365     }
 366   }
 367 }
 368
 369 }  // namespace content