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 "content/public/common/url_constants.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"
@@ skipping 45 matching lines @@
 // An internal implementation of DevToolsClientHost that delegates
 // messages sent for DevToolsClient to a DebuggerShell instance.
 class DevToolsClientHostImpl : public DevToolsClientHost {
  public:
   DevToolsClientHostImpl(
       MessageLoop* message_loop,
       net::HttpServer* server,
       int connection_id)
       : message_loop_(message_loop),
         server_(server),
-        connection_id_(connection_id) {
+        connection_id_(connection_id),
+        is_closed_(false) {
   }
+
   ~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 FrameNavigating(const std::string& url) {}
   MessageLoop* message_loop_;
   net::HttpServer* server_;
   int connection_id_;
+  bool is_closed_;
 };
 
 }  // 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 78 matching lines @@
     return "application/javascript";
   } else if (EndsWith(filename, ".png", false)) {
     return "image/png";
   } else if (EndsWith(filename, ".gif", false)) {
     return "image/gif";
   }
   NOTREACHED();
   return "text/plain";
 }
 
+void DevToolsHttpHandlerImpl::Observe(int type,
+                                      const NotificationSource& source,
+                                      const NotificationDetails& details) {
+  RenderProcessHost* process = Source<RenderProcessHost>(source).ptr();
+  DevToolsManager* manager = DevToolsManager::GetInstance();
+  for (ConnectionToClientHostMap::iterator it =
+       connection_to_client_host_ui_.begin();
+       it != connection_to_client_host_ui_.end(); ++it) {
+    DevToolsAgentHost* agent = manager->GetDevToolsAgentHostFor(it->second);
+    if (!agent)
+      continue;
+    RenderViewHost* rvh = DevToolsAgentHostRegistry::GetRenderViewHost(agent);
+    if (rvh && rvh->GetProcess() == process)
+      it->second->InspectedContentsClosing();
+  }
+}
+
 void DevToolsHttpHandlerImpl::OnHttpRequest(
     int connection_id,
     const net::HttpServerRequestInfo& info) {
   if (info.path.find("/json/version") == 0) {
     // New page request.
     BrowserThread::PostTask(
         BrowserThread::UI,
         FROM_HERE,
         base::Bind(&DevToolsHttpHandlerImpl::OnVersionRequestUI,
                    this,
@@ skipping 321 matching lines @@
     DevToolsHttpHandlerDelegate* delegate)
     : overridden_frontend_url_(frontend_url),
       socket_factory_(socket_factory),
       delegate_(delegate) {
   if (overridden_frontend_url_.empty())
       overridden_frontend_url_ = "/devtools/devtools.html";
 
   default_binding_.reset(new DevToolsDefaultBindingHandler);
   binding_ = default_binding_.get();
 
+  registrar_.Add(this, NOTIFICATION_RENDERER_PROCESS_TERMINATED,
+                 content::NotificationService::AllBrowserContextsAndSources());
+  registrar_.Add(this, NOTIFICATION_RENDERER_PROCESS_CLOSED,
+                 content::NotificationService::AllBrowserContextsAndSources());
   AddRef();
 }
 
 void DevToolsHttpHandlerImpl::Init() {
   server_ = new net::HttpServer(*socket_factory_.get(), this);
 }
 
 // Run on the handler thread
 void DevToolsHttpHandlerImpl::TeardownAndRelease() {
   server_ = NULL;
@@ skipping 101 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