src/content/browser/service_worker/embedded_worker_instance.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_instance.h"
   6
   7 #include "content/browser/service_worker/embedded_worker_registry.h"
   8 #include "content/common/service_worker/embedded_worker_messages.h"
   9 #include "ipc/ipc_message.h"
  10 #include "url/gurl.h"
  11
  12 namespace content {
  13
  14 EmbeddedWorkerInstance::~EmbeddedWorkerInstance() {
  15   registry_->RemoveWorker(process_id_, embedded_worker_id_);
  16 }
  17
  18 ServiceWorkerStatusCode EmbeddedWorkerInstance::Start(
  19     int64 service_worker_version_id,
  20     const GURL& script_url) {
  21   DCHECK(status_ == STOPPED);
  22   if (!ChooseProcess())
  23     return SERVICE_WORKER_ERROR_PROCESS_NOT_FOUND;
  24   status_ = STARTING;
  25   ServiceWorkerStatusCode status = registry_->StartWorker(
  26       process_id_,
  27       embedded_worker_id_,
  28       service_worker_version_id,
  29       script_url);
  30   if (status != SERVICE_WORKER_OK) {
  31     status_ = STOPPED;
  32     process_id_ = -1;
  33   }
  34   return status;
  35 }
  36
  37 ServiceWorkerStatusCode EmbeddedWorkerInstance::Stop() {
  38   DCHECK(status_ == STARTING || status_ == RUNNING);
  39   ServiceWorkerStatusCode status =
  40       registry_->StopWorker(process_id_, embedded_worker_id_);
  41   if (status == SERVICE_WORKER_OK)
  42     status_ = STOPPING;
  43   return status;
  44 }
  45
  46 ServiceWorkerStatusCode EmbeddedWorkerInstance::SendMessage(
  47     int request_id,
  48     const IPC::Message& message) {
  49   DCHECK(status_ == RUNNING);
  50   return registry_->Send(process_id_,
  51                          new EmbeddedWorkerContextMsg_SendMessageToWorker(
  52                              thread_id_, embedded_worker_id_,
  53                              request_id, message));
  54 }
  55
  56 void EmbeddedWorkerInstance::AddProcessReference(int process_id) {
  57   ProcessRefMap::iterator found = process_refs_.find(process_id);
  58   if (found == process_refs_.end())
  59     found = process_refs_.insert(std::make_pair(process_id, 0)).first;
  60   ++found->second;
  61 }
  62
  63 void EmbeddedWorkerInstance::ReleaseProcessReference(int process_id) {
  64   ProcessRefMap::iterator found = process_refs_.find(process_id);
  65   if (found == process_refs_.end()) {
  66     NOTREACHED() << "Releasing unknown process ref " << process_id;
  67     return;
  68   }
  69   if (--found->second == 0)
  70     process_refs_.erase(found);
  71 }
  72
  73 EmbeddedWorkerInstance::EmbeddedWorkerInstance(
  74     EmbeddedWorkerRegistry* registry,
  75     int embedded_worker_id)
  76     : registry_(registry),
  77       embedded_worker_id_(embedded_worker_id),
  78       status_(STOPPED),
  79       process_id_(-1),
  80       thread_id_(-1) {
  81 }
  82
  83 void EmbeddedWorkerInstance::OnStarted(int thread_id) {
  84   // Stop is requested before OnStarted is sent back from the worker.
  85   if (status_ == STOPPING)
  86     return;
  87   DCHECK(status_ == STARTING);
  88   status_ = RUNNING;
  89   thread_id_ = thread_id;
  90   FOR_EACH_OBSERVER(Observer, observer_list_, OnStarted());
  91 }
  92
  93 void EmbeddedWorkerInstance::OnStopped() {
  94   status_ = STOPPED;
  95   process_id_ = -1;
  96   thread_id_ = -1;
  97   FOR_EACH_OBSERVER(Observer, observer_list_, OnStopped());
  98 }
  99
 100 void EmbeddedWorkerInstance::OnMessageReceived(int request_id,
 101                                                const IPC::Message& message) {
 102   FOR_EACH_OBSERVER(Observer, observer_list_,
 103                     OnMessageReceived(request_id, message));
 104 }
 105
 106 void EmbeddedWorkerInstance::AddObserver(Observer* observer) {
 107   observer_list_.AddObserver(observer);
 108 }
 109
 110 void EmbeddedWorkerInstance::RemoveObserver(Observer* observer) {
 111   observer_list_.RemoveObserver(observer);
 112 }
 113
 114 bool EmbeddedWorkerInstance::ChooseProcess() {
 115   DCHECK_EQ(-1, process_id_);
 116   // Naive implementation; chooses a process which has the biggest number of
 117   // associated providers (so that hopefully likely live longer).
 118   ProcessRefMap::iterator max_ref_iter = process_refs_.end();
 119   for (ProcessRefMap::iterator iter = process_refs_.begin();
 120        iter != process_refs_.end(); ++iter) {
 121     if (max_ref_iter == process_refs_.end() ||
 122         max_ref_iter->second < iter->second)
 123       max_ref_iter = iter;
 124   }
 125   if (max_ref_iter == process_refs_.end())
 126     return false;
 127   process_id_ = max_ref_iter->first;
 128   return true;
 129 }
 130
 131 }  // namespace content