DevTools: [remote debugging] terminate web socket connection upon renderer disconnect.

content/browser/debugger/devtools_http_handler_impl.cc

 // Copyright (c) 2012 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/debugger/devtools_http_handler_impl.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 10 matching lines @@
 #include "base/values.h"
 #include "content/browser/web_contents/web_contents_impl.h"
 #include "content/common/devtools_messages.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/devtools_agent_host_registry.h"
 #include "content/public/browser/devtools_client_host.h"
 #include "content/public/browser/devtools_http_handler_delegate.h"
 #include "content/public/browser/devtools_manager.h"
 #include "content/public/browser/favicon_status.h"
 #include "content/public/browser/navigation_entry.h"
+#include "content/public/browser/notification_service.h"
+#include "content/public/browser/notification_types.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/render_widget_host.h"
 #include "content/public/common/content_client.h"
 #include "googleurl/src/gurl.h"
 #include "grit/devtools_resources_map.h"
 #include "net/base/escape.h"
 #include "net/base/io_buffer.h"
 #include "net/base/ip_endpoint.h"
 #include "net/server/http_server_request_info.h"
@@ skipping 33 matching lines @@
     if (!base::StringToInt(identifier.substr(pos+1), &routing_id))
       return NULL;
 
     return RenderViewHost::FromID(process_id, routing_id);
   }
 };
 
 
 // An internal implementation of DevToolsClientHost that delegates
 // messages sent for DevToolsClient to a DebuggerShell instance.
-class DevToolsClientHostImpl : public DevToolsClientHost {
+class DevToolsClientHostImpl : public DevToolsClientHost,
+                               public NotificationObserver {
  public:
   DevToolsClientHostImpl(
       MessageLoop* message_loop,
       net::HttpServer* server,
-      int connection_id)
+      int connection_id,
+      RenderProcessHost* process_host)
       : message_loop_(message_loop),
         server_(server),
-        connection_id_(connection_id) {
+        connection_id_(connection_id),
+        is_closed_(false) {
+    registrar_.Add(this, NOTIFICATION_RENDERER_PROCESS_TERMINATED,
+                   Source<RenderProcessHost>(process_host));
+    registrar_.Add(this, NOTIFICATION_RENDERER_PROCESS_CLOSED,

[yurys, 2012/10/16 06:18:20]

We listen to the termination of the render process which will happen only when
the last render view in that process is gone. But there may be render views in
other processes, don't we want to be able to inspect them?

[pfeldman, 2012/10/16 08:35:28]

We maintain WebSocket connection (And DevToolsClientHostImpl) per RVH. When the
process dies, all RVHs belonging to that process will disconnect. That's exactly
what I am trying to achieve.

+                   Source<RenderProcessHost>(process_host));
   }
+
   ~DevToolsClientHostImpl() {}
 
   // DevToolsClientHost interface
   virtual void InspectedContentsClosing() {
+    if (is_closed_)
+      return;
+    is_closed_ = true;
     message_loop_->PostTask(
         FROM_HERE,
         base::Bind(&net::HttpServer::Close, server_, connection_id_));
   }
 
   virtual void DispatchOnInspectorFrontend(const std::string& data) {
     message_loop_->PostTask(
         FROM_HERE,
         base::Bind(&net::HttpServer::SendOverWebSocket,
                    server_,
                    connection_id_,
                    data));
   }
 
   virtual void ContentsReplaced(WebContents* new_contents) {
   }
 
  private:
+  virtual void Observe(int type,
+                       const NotificationSource& source,
+                       const NotificationDetails& details) {
+    InspectedContentsClosing();
+  }
+
   virtual void FrameNavigating(const std::string& url) {}
   MessageLoop* message_loop_;
   net::HttpServer* server_;
   int connection_id_;
+  bool is_closed_;
+  NotificationRegistrar registrar_;
 };
 
 }  // namespace
 
 // static
 int DevToolsHttpHandler::GetFrontendResourceId(const std::string& name) {
   for (size_t i = 0; i < kDevtoolsResourcesSize; ++i) {
     if (name == kDevtoolsResources[i].name)
       return kDevtoolsResources[i].value;
   }
@@ skipping 349 matching lines @@
       rvh);
   if (manager->GetDevToolsClientHostFor(agent)) {
     Send500(connection_id, "Target with given id is being inspected: " +
         page_id);
     return;
   }
 
   DevToolsClientHostImpl* client_host =
       new DevToolsClientHostImpl(thread_->message_loop(),
                                  server_,
-                                 connection_id);
+                                 connection_id,
+                                 rvh->GetProcess());

[yurys, 2012/10/16 06:18:20]

This will not work for clients attached to instances without RVH, e.g. for
workers. Can we provide a generic mechanism that would allow clients to listen
for the agent termiation?

[pfeldman, 2012/10/16 08:35:28]

Allowing workers will require a major rewrite of discovery code in this class
anyways.

   connection_to_client_host_ui_[connection_id] = client_host;
 
   manager->RegisterDevToolsClientHostFor(agent, client_host);
 
   AcceptWebSocket(connection_id, request);
 }
 
 void DevToolsHttpHandlerImpl::OnWebSocketMessageUI(
     int connection_id,
     const std::string& data) {
@@ skipping 145 matching lines @@
                                              page_info.id.c_str()));
     std::string devtools_frontend_url = GetFrontendURLInternal(
         page_info.id.c_str(),
         host);
     dictionary->SetString("devtoolsFrontendUrl", devtools_frontend_url);
   }
   return dictionary;
 }
 
 }  // namespace content