Introduce worker_devtools_agent_route_id for EmbeddedWorker.

content/browser/service_worker/embedded_worker_instance.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_instance.h"
 
 #include "content/browser/service_worker/embedded_worker_registry.h"
 #include "content/common/service_worker/embedded_worker_messages.h"
 #include "ipc/ipc_message.h"
 #include "url/gurl.h"
@@ skipping 10 matching lines @@
     const GURL& script_url) {
   DCHECK(status_ == STOPPED);
   if (!ChooseProcess())
     return SERVICE_WORKER_ERROR_PROCESS_NOT_FOUND;
   status_ = STARTING;
   ServiceWorkerStatusCode status =
       registry_->StartWorker(process_id_,
                              embedded_worker_id_,
                              service_worker_version_id,
                              scope,
-                             script_url);
+                             script_url,
+                             &worker_route_id_);
   if (status != SERVICE_WORKER_OK) {
     status_ = STOPPED;
     process_id_ = -1;
+    worker_route_id_ = MSG_ROUTING_NONE;
   }
   return status;
 }
 
 ServiceWorkerStatusCode EmbeddedWorkerInstance::Stop() {
   DCHECK(status_ == STARTING || status_ == RUNNING);
   ServiceWorkerStatusCode status =
       registry_->StopWorker(process_id_, embedded_worker_id_);
   if (status == SERVICE_WORKER_OK)
     status_ = STOPPING;
@@ skipping 18 matching lines @@
 void EmbeddedWorkerInstance::ReleaseProcessReference(int process_id) {
   ProcessRefMap::iterator found = process_refs_.find(process_id);
   if (found == process_refs_.end()) {
     NOTREACHED() << "Releasing unknown process ref " << process_id;
     return;
   }
   if (--found->second == 0)
     process_refs_.erase(found);
 }
 
-EmbeddedWorkerInstance::EmbeddedWorkerInstance(
-    EmbeddedWorkerRegistry* registry,
-    int embedded_worker_id)
+EmbeddedWorkerInstance::EmbeddedWorkerInstance(EmbeddedWorkerRegistry* registry,
+                                               int embedded_worker_id)
     : registry_(registry),
       embedded_worker_id_(embedded_worker_id),
       status_(STOPPED),
       process_id_(-1),
-      thread_id_(-1) {
+      thread_id_(-1),
+      worker_route_id_(MSG_ROUTING_NONE) {
 }
 
 void EmbeddedWorkerInstance::OnStarted(int thread_id) {
   // Stop is requested before OnStarted is sent back from the worker.
   if (status_ == STOPPING)
     return;
   DCHECK(status_ == STARTING);
   status_ = RUNNING;
   thread_id_ = thread_id;
   FOR_EACH_OBSERVER(Listener, listener_list_, OnStarted());
 }
 
 void EmbeddedWorkerInstance::OnStopped() {
   status_ = STOPPED;
   process_id_ = -1;
   thread_id_ = -1;
+  worker_route_id_ = MSG_ROUTING_NONE;
   FOR_EACH_OBSERVER(Listener, listener_list_, OnStopped());
 }
 
 bool EmbeddedWorkerInstance::OnMessageReceived(const IPC::Message& message) {
   ListenerList::Iterator it(listener_list_);
   while (Listener* listener = it.GetNext()) {
     if (listener->OnMessageReceived(message))
       return true;
   }
   return false;
@@ skipping 42 matching lines @@
         max_ref_iter->second < iter->second)
       max_ref_iter = iter;
   }
   if (max_ref_iter == process_refs_.end())
     return false;
   process_id_ = max_ref_iter->first;
   return true;
 }
 
 }  // namespace content