src/content/browser/service_worker/embedded_worker_registry.cc

   1 // Copyright 2013 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/service_worker/embedded_worker_registry.h"
   6
   7 #include "base/stl_util.h"
   8 #include "content/browser/service_worker/embedded_worker_instance.h"
   9 #include "content/browser/service_worker/service_worker_context_core.h"
  10 #include "content/common/service_worker/embedded_worker_messages.h"
  11 #include "ipc/ipc_message.h"
  12 #include "ipc/ipc_sender.h"
  13
  14 namespace content {
  15
  16 EmbeddedWorkerRegistry::EmbeddedWorkerRegistry(
  17     base::WeakPtr<ServiceWorkerContextCore> context)
  18     : context_(context),
  19       next_embedded_worker_id_(0) {}
  20
  21 scoped_ptr<EmbeddedWorkerInstance> EmbeddedWorkerRegistry::CreateWorker() {
  22   scoped_ptr<EmbeddedWorkerInstance> worker(
  23       new EmbeddedWorkerInstance(this, next_embedded_worker_id_));
  24   worker_map_[next_embedded_worker_id_++] = worker.get();
  25   return worker.Pass();
  26 }
  27
  28 bool EmbeddedWorkerRegistry::StartWorker(
  29     int process_id,
  30     int embedded_worker_id,
  31     int64 service_worker_version_id,
  32     const GURL& script_url) {
  33   return Send(process_id,
  34               new EmbeddedWorkerMsg_StartWorker(embedded_worker_id,
  35                                                service_worker_version_id,
  36                                                script_url));
  37 }
  38
  39 bool EmbeddedWorkerRegistry::StopWorker(int process_id,
  40                                         int embedded_worker_id) {
  41   return Send(process_id,
  42               new EmbeddedWorkerMsg_StopWorker(embedded_worker_id));
  43 }
  44
  45 void EmbeddedWorkerRegistry::OnWorkerStarted(
  46     int process_id, int thread_id, int embedded_worker_id) {
  47   DCHECK(!ContainsKey(worker_process_map_, process_id));
  48   WorkerInstanceMap::iterator found = worker_map_.find(embedded_worker_id);
  49   if (found == worker_map_.end()) {
  50     LOG(ERROR) << "Worker " << embedded_worker_id << " not registered";
  51     return;
  52   }
  53   worker_process_map_[process_id] = embedded_worker_id;
  54   DCHECK_EQ(found->second->process_id(), process_id);
  55   found->second->OnStarted(thread_id);
  56 }
  57
  58 void EmbeddedWorkerRegistry::OnWorkerStopped(
  59     int process_id, int embedded_worker_id) {
  60   WorkerInstanceMap::iterator found = worker_map_.find(embedded_worker_id);
  61   if (found == worker_map_.end()) {
  62     LOG(ERROR) << "Worker " << embedded_worker_id << " not registered";
  63     return;
  64   }
  65   DCHECK_EQ(found->second->process_id(), process_id);
  66   worker_process_map_.erase(process_id);
  67   found->second->OnStopped();
  68 }
  69
  70 void EmbeddedWorkerRegistry::OnSendMessageToBrowser(
  71     int embedded_worker_id, const IPC::Message& message) {
  72   WorkerInstanceMap::iterator found = worker_map_.find(embedded_worker_id);
  73   if (found == worker_map_.end()) {
  74     LOG(ERROR) << "Worker " << embedded_worker_id << " not registered";
  75     return;
  76   }
  77   // TODO(kinuko): Filter out unexpected messages here and uncomment below
  78   // when we actually define messages that are to be sent from child process
  79   // to the browser via this channel. (We don't have any yet)
  80   // found->second->OnMessageReceived(message);
  81 }
  82
  83 void EmbeddedWorkerRegistry::AddChildProcessSender(
  84     int process_id, IPC::Sender* sender) {
  85   process_sender_map_[process_id] = sender;
  86   DCHECK(!ContainsKey(worker_process_map_, process_id));
  87 }
  88
  89 void EmbeddedWorkerRegistry::RemoveChildProcessSender(int process_id) {
  90   process_sender_map_.erase(process_id);
  91   std::map<int, int>::iterator found = worker_process_map_.find(process_id);
  92   if (found != worker_process_map_.end()) {
  93     int embedded_worker_id = found->second;
  94     DCHECK(ContainsKey(worker_map_, embedded_worker_id));
  95     worker_map_[embedded_worker_id]->OnStopped();
  96     worker_process_map_.erase(found);
  97   }
  98 }
  99
 100 EmbeddedWorkerInstance* EmbeddedWorkerRegistry::GetWorker(
 101     int embedded_worker_id) {
 102   WorkerInstanceMap::iterator found = worker_map_.find(embedded_worker_id);
 103   if (found == worker_map_.end())
 104     return NULL;
 105   return found->second;
 106 }
 107
 108 EmbeddedWorkerRegistry::~EmbeddedWorkerRegistry() {}
 109
 110 bool EmbeddedWorkerRegistry::Send(int process_id, IPC::Message* message) {
 111   if (!context_)
 112     return false;
 113   ProcessToSenderMap::iterator found = process_sender_map_.find(process_id);
 114   if (found == process_sender_map_.end())
 115     return false;
 116   return found->second->Send(message);
 117 }
 118
 119 void EmbeddedWorkerRegistry::RemoveWorker(int process_id,
 120                                           int embedded_worker_id) {
 121   DCHECK(ContainsKey(worker_map_, embedded_worker_id));
 122   worker_map_.erase(embedded_worker_id);
 123   worker_process_map_.erase(process_id);
 124 }
 125
 126 }  // namespace content