DevTools: [remote debugging] emit Inspector.detached protocol message upon connectin termination.

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 78 matching lines @@
 // 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),
-        is_closed_(false) {
+        is_closed_(false),
+        detach_reason_("target_closed") {
   }
 
   ~DevToolsClientHostImpl() {}
 
   // DevToolsClientHost interface
   virtual void InspectedContentsClosing() {
     if (is_closed_)
       return;
     is_closed_ = true;
+
+    std::string response;
+    DictionaryValue message;
+    message.SetString("method", "Inspector.detached");
+    DictionaryValue* params = new DictionaryValue();
+    message.Set("params", params);
+    params->SetString("reason", detach_reason_);
+    base::JSONWriter::WriteWithOptions(&message,

[yurys, 2012/11/01 15:37:11]

Can you provide a method in WebKit API that would create the message to make the
dependency clear? I don't like the idea of sending protocol message from the
remote debugger server which is expected to provide a transport for the
inspector protocol. Ideally there should be a notification from the embedder
that it is going to shut down and the inspector agent should listen to it and
send the message over the protocol. WDYT?

[pfeldman, 2012/11/01 16:24:49]

We can't delegate it to the dying renderer, but I share your concern. I'll
either add the message to the WebKit API or introduce a new domain.

[pfeldman, 2012/11/01 16:54:32]

Done.

+                                       base::JSONWriter::OPTIONS_PRETTY_PRINT,
+                                       &response);
+    message_loop_->PostTask(
+        FROM_HERE,
+        base::Bind(&net::HttpServer::SendOverWebSocket,
+                   server_,
+                   connection_id_,
+                   response));
+
     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) {
   }
 
+  virtual void ReplacedWithAnotherClient() {
+    detach_reason_ = "replaced_with_devtools";
+  }
+
  private:
   virtual void FrameNavigating(const std::string& url) {}
   MessageLoop* message_loop_;
   net::HttpServer* server_;
   int connection_id_;
   bool is_closed_;
+  std::string detach_reason_;
 };
 
 }  // 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 570 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