DevTools: prepare workers for DevToolsManager::Attach(Detach)ClientHost removal.

content/browser/devtools/worker_devtools_manager.cc

 // Copyright (c) 2011 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/devtools/worker_devtools_manager.h"
 
 #include <list>
 #include <map>
 
 #include "base/bind.h"
 #include "base/lazy_instance.h"
 #include "content/browser/devtools/devtools_agent_host.h"
 #include "content/browser/devtools/devtools_manager_impl.h"
 #include "content/browser/devtools/worker_devtools_message_filter.h"
 #include "content/browser/worker_host/worker_service_impl.h"
 #include "content/common/devtools_messages.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/child_process_data.h"
 #include "content/public/browser/devtools_agent_host_registry.h"
 #include "content/public/common/process_type.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebDevToolsAgent.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebCString.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebString.h"
 
+using WebKit::WebDevToolsAgent;
+
 namespace content {
 
 // Called on the UI thread.
 // static
 DevToolsAgentHost* DevToolsAgentHostRegistry::GetDevToolsAgentHostForWorker(
     int worker_process_id,
     int worker_route_id) {
   return WorkerDevToolsManager::GetDevToolsAgentHostForWorker(
       worker_process_id,
       worker_route_id);
 }
 
 namespace {
 
+static WorkerDevToolsManager::WorkerId g_null_id = std::make_pair(-1, -1);
+
 typedef std::map<WorkerDevToolsManager::WorkerId,
                  WorkerDevToolsManager::WorkerDevToolsAgentHost*> AgentHosts;
-typedef std::map<WorkerDevToolsManager::WorkerId,
-                 int> OrphanHosts;
 base::LazyInstance<AgentHosts>::Leaky g_agent_map = LAZY_INSTANCE_INITIALIZER;
-base::LazyInstance<OrphanHosts>::Leaky g_orphan_map = LAZY_INSTANCE_INITIALIZER;
+base::LazyInstance<AgentHosts>::Leaky g_orphan_map = LAZY_INSTANCE_INITIALIZER;
 
 }  // namespace
 
 struct WorkerDevToolsManager::TerminatedInspectedWorker {
   TerminatedInspectedWorker(WorkerId id, const GURL& url, const string16& name)
       : old_worker_id(id),
         worker_url(url),
         worker_name(name) {}
   WorkerId old_worker_id;
   GURL worker_url;
   string16 worker_name;
 };
 
 
 class WorkerDevToolsManager::WorkerDevToolsAgentHost
     : public DevToolsAgentHost {
  public:
-  explicit WorkerDevToolsAgentHost(WorkerId worker_id)
-      : worker_id_(worker_id) {
+  explicit WorkerDevToolsAgentHost(WorkerId worker_id) {
+    SetWorkerId(worker_id, false);
+  }
+
+  void SetWorkerId(WorkerId worker_id, bool reattach) {
+    worker_id_ = worker_id;
     g_agent_map.Get()[worker_id_] = this;
+
     BrowserThread::PostTask(
         BrowserThread::IO,
         FROM_HERE,
         base::Bind(
-            &RegisterAgent,
+            &ConnectToWorker,
             worker_id.first,
             worker_id.second));
+
+    if (reattach)
+      Reattach(state_);
   }
 
-  void WorkerDestroyed() {
-    NotifyCloseListener();
+  void ResetWorkerId() {
+    g_agent_map.Get().erase(worker_id_);
+    worker_id_ = g_null_id;
+  }
+
+  virtual void Detach() {
+    DevToolsAgentHost::Detach();
+    SelfDestruct();
+  }
+
+  void SaveAgentRuntimeState(const std::string& state) {
+    state_ = state;
+  }
+
+  void ConnectionFailed() {
+    // Depending on whether we are connected or not, we should disconnect and
+    // self-destruct.
+    if (NotifyCloseListener())
+      return;  // Detach will delete this instance.
+    SelfDestruct();
+  }
+
+  void SelfDestruct() {
     delete this;
   }
 
  private:
   virtual ~WorkerDevToolsAgentHost() {
     g_agent_map.Get().erase(worker_id_);
   }
 
-  static void RegisterAgent(
+  static void ConnectToWorker(
       int worker_process_id,
       int worker_route_id) {
-    WorkerDevToolsManager::GetInstance()->RegisterDevToolsAgentHostForWorker(
+    WorkerDevToolsManager::GetInstance()->ConnectDevToolsAgentHostToWorker(
         worker_process_id, worker_route_id);
   }
 
   static void ForwardToWorkerDevToolsAgent(
       int worker_process_id,
       int worker_route_id,
       IPC::Message* message) {
     WorkerDevToolsManager::GetInstance()->ForwardToWorkerDevToolsAgent(
         worker_process_id, worker_route_id, *message);
   }
 
   // DevToolsAgentHost implementation.
   virtual void SendMessageToAgent(IPC::Message* message) OVERRIDE {
+    if (worker_id_ == g_null_id) {
+      delete message;
+      return;
+    }
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
         base::Bind(
             &WorkerDevToolsAgentHost::ForwardToWorkerDevToolsAgent,
             worker_id_.first,
             worker_id_.second,
             base::Owned(message)));
   }
+
   virtual void NotifyClientAttaching() OVERRIDE {}
   virtual void NotifyClientDetaching() OVERRIDE {}
   virtual int GetRenderProcessId() OVERRIDE { return -1; }
 
   WorkerId worker_id_;
+  std::string state_;
 
   DISALLOW_COPY_AND_ASSIGN(WorkerDevToolsAgentHost);
 };
 
 
 class WorkerDevToolsManager::DetachedClientHosts {
  public:
   static void WorkerReloaded(WorkerId old_id, WorkerId new_id) {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-    if (ReattachClient(old_id, new_id))
+    AgentHosts::iterator it = g_orphan_map.Get().find(old_id);
+    if (it != g_orphan_map.Get().end()) {
+      g_orphan_map.Get().erase(old_id);
+      it->second->SetWorkerId(new_id, true);
       return;
+    }
     RemovePendingWorkerData(old_id);
   }
 
   static void WorkerDestroyed(WorkerId id) {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
     AgentHosts::iterator it = g_agent_map.Get().find(id);
     if (it == g_agent_map.Get().end()) {
       RemovePendingWorkerData(id);
       return;
     }
+
     WorkerDevToolsAgentHost* agent = it->second;
-    DevToolsManagerImpl::GetInstance()->DispatchOnInspectorFrontend(
-        agent,
-        WebKit::WebDevToolsAgent::workerDisconnectedFromWorkerEvent().utf8());
-    int cookie = DevToolsManagerImpl::GetInstance()->DetachClientHost(agent);
-    agent->WorkerDestroyed();
-    if (cookie == -1) {
-      RemovePendingWorkerData(id);
+    DevToolsManagerImpl* devtools_manager = DevToolsManagerImpl::GetInstance();
+    DevToolsClientHost* client_host =
+        devtools_manager->GetDevToolsClientHostFor(agent);
+
+    if (!client_host) {
+      // Agent has no client hosts -> delete it.
+      agent->SelfDestruct();

[yurys, 2012/12/21 13:48:02]

RemovePendingWorkerData is missing

       return;
     }
-    g_orphan_map.Get()[id] = cookie;
+
+    // Client host is debugging this worker agent host.
+    devtools_manager->DispatchOnInspectorFrontend(
+        agent,
+        WebDevToolsAgent::workerDisconnectedFromWorkerEvent().utf8());
+    g_orphan_map.Get()[id] = agent;
+    agent->ResetWorkerId();
   }
 
  private:
-  DetachedClientHosts() {}
-  ~DetachedClientHosts() {}
-
-  static bool ReattachClient(WorkerId old_id, WorkerId new_id) {
-    OrphanHosts::iterator it = g_orphan_map.Get().find(old_id);
-    if (it == g_orphan_map.Get().end())
-      return false;
-    DevToolsAgentHost* agent =
-        WorkerDevToolsManager::GetDevToolsAgentHostForWorker(
-            new_id.first,
-            new_id.second);
-    DevToolsManagerImpl::GetInstance()->AttachClientHost(
-        it->second,
-        agent);
-    g_orphan_map.Get().erase(it);
-    return true;
-  }
+  DetachedClientHosts() { }
+  ~DetachedClientHosts() { }
 
   static void RemovePendingWorkerData(WorkerId id) {
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
         base::Bind(&RemoveInspectedWorkerDataOnIOThread, id));
   }
 
   static void RemoveInspectedWorkerDataOnIOThread(WorkerId id) {
     WorkerDevToolsManager::GetInstance()->RemoveInspectedWorkerData(id);
   }
@@ skipping 122 matching lines @@
 }
 
 static WorkerProcessHost* FindWorkerProcess(int worker_process_id) {
   for (WorkerProcessHostIterator iter; !iter.Done(); ++iter) {
     if (iter.GetData().id == worker_process_id)
       return *iter;
   }
   return NULL;
 }
 
-void WorkerDevToolsManager::RegisterDevToolsAgentHostForWorker(
+void WorkerDevToolsManager::ConnectDevToolsAgentHostToWorker(
     int worker_process_id,
     int worker_route_id) {
   if (WorkerProcessHost* process = FindWorkerProcess(worker_process_id)) {
     const WorkerProcessHost::Instances& instances = process->instances();
     for (WorkerProcessHost::Instances::const_iterator i = instances.begin();
          i != instances.end(); ++i) {
       if (i->worker_route_id() == worker_route_id) {
         DCHECK(FindInspectedWorker(worker_process_id, worker_route_id) ==
                inspected_workers_.end());
         inspected_workers_.push_back(
             InspectedWorker(process, worker_route_id, i->url(), i->name()));
         return;
       }
     }
   }
-  NotifyWorkerDestroyedOnIOThread(worker_process_id, worker_route_id);
+  NotifyConnectionFailedOnIOThread(worker_process_id, worker_route_id);
 }
 
 void WorkerDevToolsManager::ForwardToDevToolsClient(
     int worker_process_id,
     int worker_route_id,
     const std::string& message) {
   if (FindInspectedWorker(worker_process_id, worker_route_id) ==
           inspected_workers_.end()) {
       NOTREACHED();
       return;
@@ skipping 48 matching lines @@
 
 // static
 void WorkerDevToolsManager::SaveAgentRuntimeStateOnUIThread(
     int worker_process_id,
     int worker_route_id,
     const std::string& state) {
   AgentHosts::iterator it = g_agent_map.Get().find(WorkerId(worker_process_id,
                                                             worker_route_id));
   if (it == g_agent_map.Get().end())
     return;
-  DevToolsManagerImpl::GetInstance()->SaveAgentRuntimeState(it->second, state);
+  it->second->SaveAgentRuntimeState(state);
 }
 
 // static
-void WorkerDevToolsManager::NotifyWorkerDestroyedOnIOThread(
+void WorkerDevToolsManager::NotifyConnectionFailedOnIOThread(
     int worker_process_id,
     int worker_route_id) {
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(
-          &WorkerDevToolsManager::NotifyWorkerDestroyedOnUIThread,
+          &WorkerDevToolsManager::NotifyConnectionFailedOnUIThread,
           worker_process_id,
           worker_route_id));
 }
 
 // static
-void WorkerDevToolsManager::NotifyWorkerDestroyedOnUIThread(
+void WorkerDevToolsManager::NotifyConnectionFailedOnUIThread(
     int worker_process_id,
     int worker_route_id) {
   AgentHosts::iterator it = g_agent_map.Get().find(WorkerId(worker_process_id,
                                                             worker_route_id));
   if (it != g_agent_map.Get().end())
-    it->second->WorkerDestroyed();
+    it->second->ConnectionFailed();
 }
 
 // static
 void WorkerDevToolsManager::SendResumeToWorker(const WorkerId& id) {
   if (WorkerProcessHost* process = FindWorkerProcess(id.first))
     process->Send(new DevToolsAgentMsg_ResumeWorkerContext(id.second));
 }
 
 }  // namespace content