Manage ServiceWorkerDispatcherHost in ServiceWorkerContextCore

content/browser/service_worker/embedded_worker_registry.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/browser/service_worker/embedded_worker_registry.h"
 
 #include "base/bind_helpers.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/stl_util.h"
 #include "content/browser/renderer_host/render_widget_helper.h"
 #include "content/browser/service_worker/embedded_worker_instance.h"
 #include "content/browser/service_worker/service_worker_context_core.h"
 #include "content/browser/service_worker/service_worker_context_wrapper.h"
+#include "content/browser/service_worker/service_worker_dispatcher_host.h"
 #include "content/common/service_worker/embedded_worker_messages.h"
 #include "content/public/browser/browser_thread.h"
 #include "ipc/ipc_message.h"
 #include "ipc/ipc_sender.h"
 
 namespace content {
 
 // static
 scoped_refptr<EmbeddedWorkerRegistry> EmbeddedWorkerRegistry::Create(
     const base::WeakPtr<ServiceWorkerContextCore>& context) {
   return make_scoped_refptr(new EmbeddedWorkerRegistry(context, 0));
 }
 
 // static
 scoped_refptr<EmbeddedWorkerRegistry> EmbeddedWorkerRegistry::Create(
     const base::WeakPtr<ServiceWorkerContextCore>& context,
     EmbeddedWorkerRegistry* old_registry) {
   scoped_refptr<EmbeddedWorkerRegistry> registry =
       new EmbeddedWorkerRegistry(
           context,
           old_registry->next_embedded_worker_id_);
-  registry->process_sender_map_.swap(old_registry->process_sender_map_);
   return registry;
 }
 
 std::unique_ptr<EmbeddedWorkerInstance> EmbeddedWorkerRegistry::CreateWorker() {
   std::unique_ptr<EmbeddedWorkerInstance> worker(
       new EmbeddedWorkerInstance(context_, next_embedded_worker_id_));
   worker_map_[next_embedded_worker_id_++] = worker.get();
   return worker;
 }
 
@@ skipping 126 matching lines @@
     const base::string16& message,
     int line_number,
     const GURL& source_url) {
   EmbeddedWorkerInstance* worker = GetWorker(embedded_worker_id);
   if (!worker)
     return;
   worker->OnReportConsoleMessage(source_identifier, message_level, message,
                                  line_number, source_url);
 }
 
-void EmbeddedWorkerRegistry::AddChildProcessSender(
-    int process_id,
-    IPC::Sender* sender,
-    MessagePortMessageFilter* message_port_message_filter) {
-  process_sender_map_[process_id] = sender;
-  process_message_port_message_filter_map_[process_id] =
-      message_port_message_filter;
-  DCHECK(!base::ContainsKey(worker_process_map_, process_id));
-}
-
-void EmbeddedWorkerRegistry::RemoveChildProcessSender(int process_id) {
-  process_sender_map_.erase(process_id);
-  process_message_port_message_filter_map_.erase(process_id);
+void EmbeddedWorkerRegistry::RemoveProcess(int process_id) {
   std::map<int, std::set<int> >::iterator found =
       worker_process_map_.find(process_id);
   if (found != worker_process_map_.end()) {
     const std::set<int>& worker_set = worker_process_map_[process_id];
     for (std::set<int>::const_iterator it = worker_set.begin();
          it != worker_set.end();
          ++it) {
       int embedded_worker_id = *it;
       DCHECK(base::ContainsKey(worker_map_, embedded_worker_id));
-      // Somehow the worker thread has lost contact with the browser process.
-      // The renderer may have been killed.  Set the worker's status to STOPPED
-      // so a new thread can be created for this version. Use OnDetached rather
-      // than OnStopped so UMA doesn't record it as a normal stoppage.
+      // |worker_map_| doesn't have workers when it's stopped normally, and
+      // this is for resetting the workers which has lost contact with the
+      // browser process somehow.

[falken, 2017/02/13 05:59:24]

I like how the existing comment explains why OnDetached is used. My previous
confusion is nothing mentioned that RemoveProcess should be called after the
workers have stopped.

I'd keep the previous comment and just add to the beginning that "RemoveProcess
is typically called after the running workers on the process have been stopped,
so if there is a running worker at this point somehow the worker thread has lost
contact with the browser process."

[shimazu, 2017/02/13 08:20:19]

Done.

       worker_map_[embedded_worker_id]->OnDetached();
     }
     worker_process_map_.erase(found);
   }
 }
 
 EmbeddedWorkerInstance* EmbeddedWorkerRegistry::GetWorker(
     int embedded_worker_id) {
   WorkerInstanceMap::iterator found = worker_map_.find(embedded_worker_id);
   if (found == worker_map_.end())
     return nullptr;
   return found->second;
 }
 
 bool EmbeddedWorkerRegistry::CanHandle(int embedded_worker_id) const {
   if (embedded_worker_id < initial_embedded_worker_id_ ||
       next_embedded_worker_id_ <= embedded_worker_id) {
     return false;
   }
   return true;
 }
 
 MessagePortMessageFilter*
 EmbeddedWorkerRegistry::MessagePortMessageFilterForProcess(int process_id) {
-  return process_message_port_message_filter_map_[process_id];
+  ServiceWorkerDispatcherHost* dispatcher_host =
+      context_->GetDispatcherHost(process_id);
+  DCHECK(dispatcher_host);
+  return dispatcher_host->message_port_message_filter();
 }
 
 EmbeddedWorkerRegistry::EmbeddedWorkerRegistry(
     const base::WeakPtr<ServiceWorkerContextCore>& context,
     int initial_embedded_worker_id)
     : context_(context),
       next_embedded_worker_id_(initial_embedded_worker_id),
       initial_embedded_worker_id_(initial_embedded_worker_id) {
 }
 
 EmbeddedWorkerRegistry::~EmbeddedWorkerRegistry() {
   Shutdown();
 }
 
 void EmbeddedWorkerRegistry::BindWorkerToProcess(int process_id,
                                                  int embedded_worker_id) {
-  // The ServiceWorkerDispatcherHost is supposed to be created when the process
-  // is created, and keep an entry in process_sender_map_ for its whole
-  // lifetime.
-  DCHECK(base::ContainsKey(process_sender_map_, process_id));
   DCHECK(GetWorker(embedded_worker_id));
   DCHECK_EQ(GetWorker(embedded_worker_id)->process_id(), process_id);
   DCHECK(
       !base::ContainsKey(worker_process_map_, process_id) ||
       !base::ContainsKey(worker_process_map_[process_id], embedded_worker_id));
 
   worker_process_map_[process_id].insert(embedded_worker_id);
 }
 
 ServiceWorkerStatusCode EmbeddedWorkerRegistry::Send(
     int process_id, IPC::Message* message_ptr) {
   std::unique_ptr<IPC::Message> message(message_ptr);
   if (!context_)
     return SERVICE_WORKER_ERROR_ABORT;
-  ProcessToSenderMap::iterator found = process_sender_map_.find(process_id);
-  if (found == process_sender_map_.end())
+  IPC::Sender* sender = context_->GetDispatcherHost(process_id);
+  if (!sender)
     return SERVICE_WORKER_ERROR_PROCESS_NOT_FOUND;
-  if (!found->second->Send(message.release()))
+  if (!sender->Send(message.release()))
     return SERVICE_WORKER_ERROR_IPC_FAILED;
   return SERVICE_WORKER_OK;
 }
 
 void EmbeddedWorkerRegistry::RemoveWorker(int process_id,
                                           int embedded_worker_id) {
   DCHECK(base::ContainsKey(worker_map_, embedded_worker_id));
   DetachWorker(process_id, embedded_worker_id);
   worker_map_.erase(embedded_worker_id);
 }
@@ skipping 14 matching lines @@
   EmbeddedWorkerInstance* worker = GetWorker(embedded_worker_id);
   if (!worker || worker->process_id() != process_id) {
     UMA_HISTOGRAM_BOOLEAN("ServiceWorker.WorkerForMessageFound", false);
     return nullptr;
   }
   UMA_HISTOGRAM_BOOLEAN("ServiceWorker.WorkerForMessageFound", true);
   return worker;
 }
 
 }  // namespace content