Allow customization of remote debugger URL targets.

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"
 #include "base/compiler_specific.h"
 #include "base/json/json_writer.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/message_loop_proxy.h"
 #include "base/string_number_conversions.h"
 #include "base/stringprintf.h"
@@ skipping 20 matching lines @@
 #include "net/server/http_server_request_info.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_context_getter.h"
 
 namespace content {
 
 const int kBufferSize = 16 * 1024;
 
 namespace {
 
+class DevToolsDefaultBindingHandler
+    : public DevToolsHttpHandlerDelegate::BindingHandler {
+ public:
+  DevToolsDefaultBindingHandler() {
+  }
+
+  virtual std::string GetRenderViewHostIdentifier(
+      RenderViewHost* rvh) OVERRIDE {
+    Target target = std::make_pair(rvh->GetProcess()->GetID(),
+                                   rvh->GetRoutingID());
+    targets_.push_back(target);
+    size_t index = targets_.size() - 1;
+    return base::StringPrintf("%lu", index);

[pfeldman, 2012/04/25 05:45:15]

Nit: it might be a good time to migrate to the "<process_id>_<routing_id>" id
scheme. That would eliminate the need for ResetRenderViewHostBinding and would
make ids persistent across debugging sessions.

[Marshall, 2012/04/25 15:14:57]

Done.

+  }
+
+  virtual RenderViewHost* GetRenderViewHostBinding(
+      const std::string& identifier) OVERRIDE {
+    size_t index;
+    if (!base::StringToSizeT(identifier, &index))
+      return NULL;
+    if (index >= targets_.size())
+      return NULL;
+
+    return RenderViewHost::FromID(targets_[index].first,
+                                  targets_[index].second);
+  }
+
+  virtual void ResetRenderViewHostBinding() OVERRIDE {
+    targets_.clear();
+  }
+
+ private:
+  typedef std::pair<int, int> Target;
+  std::vector<Target> targets_;
+};
+
+
 // An internal implementation of DevToolsClientHost that delegates
 // messages sent for DevToolsClient to a DebuggerShell instance.
 class DevToolsClientHostImpl : public DevToolsClientHost {
  public:
   DevToolsClientHostImpl(
       net::HttpServer* server,
       int connection_id)
       : server_(server),
         connection_id_(connection_id) {
   }
@@ skipping 198 matching lines @@
 
   BrowserThread::PostTask(
       BrowserThread::UI,
       FROM_HERE,
       base::Bind(
           &DevToolsHttpHandlerImpl::OnCloseUI,
           this,
           connection_id));
 }
 
-struct DevToolsHttpHandlerImpl::PageInfo
-{
+struct DevToolsHttpHandlerImpl::PageInfo {
   PageInfo()
-      : id(0),
-        attached(false) {
+      : attached(false) {
   }
 
-  int id;
+  std::string id;
   std::string url;
   bool attached;
   std::string title;
   std::string thumbnail_url;
   std::string favicon_url;
   base::TimeTicks last_selected_time;
 };
 
 // static
 bool DevToolsHttpHandlerImpl::SortPageListByTime(const PageInfo& info1,
                                                  const PageInfo& info2) {
   return info1.last_selected_time > info2.last_selected_time;
 }
 
 DevToolsHttpHandlerImpl::PageList DevToolsHttpHandlerImpl::GeneratePageList() {
-  ResetRenderViewHostBinding();
+  binding_handler_->ResetRenderViewHostBinding();
   PageList page_list;
   for (RenderProcessHost::iterator it(RenderProcessHost::AllHostsIterator());
        !it.IsAtEnd(); it.Advance()) {
     RenderProcessHost* render_process_host = it.GetCurrentValue();
     DCHECK(render_process_host);
 
     // Ignore processes that don't have a connection, such as crashed contents.
     if (!render_process_host->HasConnection())
       continue;
 
     RenderProcessHost::RenderWidgetHostsIterator rwit(
         render_process_host->GetRenderWidgetHostsIterator());
     for (; !rwit.IsAtEnd(); rwit.Advance()) {
       const RenderWidgetHost* widget = rwit.GetCurrentValue();
       DCHECK(widget);
       if (!widget || !widget->IsRenderView())
         continue;
 
       RenderViewHost* host =
           RenderViewHost::From(const_cast<RenderWidgetHost*>(widget));
       content::RenderViewHostDelegate* host_delegate = host->GetDelegate();
 
       DevToolsAgentHost* agent =
           DevToolsAgentHostRegistry::GetDevToolsAgentHost(host);
       DevToolsClientHost* client_host = DevToolsManager::GetInstance()->
           GetDevToolsClientHostFor(agent);
       PageInfo page_info;
-      page_info.id = BindRenderViewHost(host);
+      page_info.id = binding_handler_->GetRenderViewHostIdentifier(host);
       page_info.attached = client_host != NULL;
       page_info.url = host_delegate->GetURL().spec();
 
       WebContents* web_contents = host_delegate->GetAsWebContents();
       if (web_contents) {
         page_info.title = UTF16ToUTF8(
             net::EscapeForHTML(web_contents->GetTitle()));
         page_info.last_selected_time = web_contents->GetLastSelectedTime();
 
         NavigationController& controller = web_contents->GetController();
@@ skipping 11 matching lines @@
 }
 
 void DevToolsHttpHandlerImpl::OnJsonRequestUI(
     int connection_id,
     const net::HttpServerRequestInfo& info) {
   PageList page_list = GeneratePageList();
   ListValue json_pages_list;
   std::string host = info.headers["Host"];
   for (PageList::iterator i = page_list.begin();
        i != page_list.end(); ++i) {
-
     DictionaryValue* page_info = new DictionaryValue;
     json_pages_list.Append(page_info);
     page_info->SetString("title", i->title);
     page_info->SetString("url", i->url);
     page_info->SetString("thumbnailUrl", i->thumbnail_url);
     page_info->SetString("faviconUrl", i->favicon_url);
     if (!i->attached) {
       page_info->SetString("webSocketDebuggerUrl",
-                           base::StringPrintf("ws://%s/devtools/page/%d",
+                           base::StringPrintf("ws://%s/devtools/page/%s",
                                               host.c_str(),
-                                              i->id));
+                                              i->id.c_str()));
       std::string devtools_frontend_url = base::StringPrintf(
-          "%s%sws=%s/devtools/page/%d",
+          "%s%sws=%s/devtools/page/%s",
           overridden_frontend_url_.c_str(),
           overridden_frontend_url_.find("?") == std::string::npos ? "?" : "&",
           host.c_str(),
-          i->id);
+          i->id.c_str());
       page_info->SetString("devtoolsFrontendUrl", devtools_frontend_url);
     }
   }
 
   std::string response;
   base::JSONWriter::WriteWithOptions(&json_pages_list,
                                      base::JSONWriter::OPTIONS_PRETTY_PRINT,
                                      &response);
   Send200(connection_id, response, "application/json; charset=UTF-8");
 }
 
 void DevToolsHttpHandlerImpl::OnWebSocketRequestUI(
     int connection_id,
     const net::HttpServerRequestInfo& request) {
   std::string prefix = "/devtools/page/";
   size_t pos = request.path.find(prefix);
   if (pos != 0) {
     Send404(connection_id);
     return;
   }
+
   std::string page_id = request.path.substr(prefix.length());
-  int id = 0;
-  if (!base::StringToInt(page_id, &id)) {
-    Send500(connection_id, "Invalid page id: " + page_id);
-    return;
-  }
-
-  RenderViewHost* rvh = GetBoundRenderViewHost(id);
+  RenderViewHost* rvh = binding_handler_->GetRenderViewHostBinding(page_id);
   if (!rvh) {
     Send500(connection_id, "No such target id: " + page_id);
     return;
   }
 
   DevToolsManager* manager = DevToolsManager::GetInstance();
   DevToolsAgentHost* agent = DevToolsAgentHostRegistry::GetDevToolsAgentHost(
       rvh);
   if (manager->GetDevToolsClientHostFor(agent)) {
     Send500(connection_id, "Target with given id is being inspected: " +
@@ skipping 99 matching lines @@
     net::URLRequestContextGetter* request_context_getter,
     DevToolsHttpHandlerDelegate* delegate)
     : ip_(ip),
       port_(port),
       overridden_frontend_url_(frontend_url),
       request_context_getter_(request_context_getter),
       delegate_(delegate) {
   if (overridden_frontend_url_.empty())
       overridden_frontend_url_ = "/devtools/devtools.html";
 
+  binding_handler_.reset(delegate_->GetBindingHandler());
+  if (!binding_handler_.get())
+    binding_handler_.reset(new DevToolsDefaultBindingHandler);
+
   AddRef();
 }
 
 void DevToolsHttpHandlerImpl::Init() {
   server_ = new net::HttpServer(ip_, port_, this);
 }
 
 // Run on I/O thread
 void DevToolsHttpHandlerImpl::TeardownAndRelease() {
   server_ = NULL;
@@ skipping 59 matching lines @@
 
 void DevToolsHttpHandlerImpl::AcceptWebSocket(
     int connection_id,
     const net::HttpServerRequestInfo& request) {
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&net::HttpServer::AcceptWebSocket, server_.get(),
                  connection_id, request));
 }
 
-size_t DevToolsHttpHandlerImpl::BindRenderViewHost(RenderViewHost* rvh) {
-  Target target = std::make_pair(rvh->GetProcess()->GetID(),
-                                 rvh->GetRoutingID());
-  targets_.push_back(target);
-  return targets_.size() - 1;
-}
-
-RenderViewHost* DevToolsHttpHandlerImpl::GetBoundRenderViewHost(size_t id) {
-  return RenderViewHost::FromID(targets_[id].first,
-                                targets_[id].second);
-}
-
-void DevToolsHttpHandlerImpl::ResetRenderViewHostBinding() {
-  targets_.clear();
-}
-
 }  // namespace content