Add content API for DevTools HTTP handler

BUG=104625
TEST=Existing tests

Review URL: http://codereview.chromium.org/8554008

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@112662 0039d316-1c4b-4281-b951-d872f2087c98

chrome/browser/debugger/browser_list_tabcontents_provider.cc

@@ -12,9 +12,11 @@
 #include "net/url_request/url_request_context_getter.h"
 #include "ui/base/resource/resource_bundle.h"
 
-DevToolsHttpProtocolHandler::InspectableTabs
+using content::DevToolsHttpHandlerDelegate;
+
+DevToolsHttpHandlerDelegate::InspectableTabs
 BrowserListTabContentsProvider::GetInspectableTabs() {
-  DevToolsHttpProtocolHandler::InspectableTabs tabs;
+  DevToolsHttpHandlerDelegate::InspectableTabs tabs;
   for (BrowserList::const_iterator it = BrowserList::begin(),
        end = BrowserList::end(); it != end; ++it) {
     TabStripModel* model = (*it)->tabstrip_model();

chrome/browser/debugger/browser_list_tabcontents_provider.h

@@ -6,19 +6,23 @@
 #define CHROME_BROWSER_DEBUGGER_BROWSER_LIST_TABCONTENTS_PROVIDER_H_
 
 #include <string>
-#include "content/browser/debugger/devtools_http_protocol_handler.h"
+
+#include "base/basictypes.h"
+#include "base/compiler_specific.h"
+#include "content/public/browser/devtools_http_handler_delegate.h"
 
 class BrowserListTabContentsProvider
-    : public DevToolsHttpProtocolHandler::Delegate {
+    : public content::DevToolsHttpHandlerDelegate {
  public:
   BrowserListTabContentsProvider() {}
   virtual ~BrowserListTabContentsProvider() {}
 
   // DevToolsHttpProtocolHandler::Delegate overrides.
-  virtual DevToolsHttpProtocolHandler::InspectableTabs
+  virtual DevToolsHttpHandlerDelegate::InspectableTabs
       GetInspectableTabs() OVERRIDE;
   virtual std::string GetDiscoveryPageHTML() OVERRIDE;
   virtual net::URLRequestContext* GetURLRequestContext() OVERRIDE;
+
  private:
   DISALLOW_COPY_AND_ASSIGN(BrowserListTabContentsProvider);
 };

chrome/browser/debugger/remote_debugging_server.cc

@@ -8,6 +8,7 @@
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/webui/chrome_url_data_manager.h"
 #include "chrome/browser/ui/webui/devtools_ui.h"
+#include "content/public/browser/devtools_http_handler.h"
 
 RemoteDebuggingServer::RemoteDebuggingServer(Profile* profile,
                                              const std::string& ip,
@@ -17,10 +18,10 @@ RemoteDebuggingServer::RemoteDebuggingServer(Profile* profile,
   DevToolsUI::RegisterDevToolsDataSource(profile);
 
   devtools_http_handler_ =
-      DevToolsHttpProtocolHandler::Start(ip,
-                                         port,
-                                         frontend_url,
-                                         new BrowserListTabContentsProvider());
+      content::DevToolsHttpHandler::Start(ip,
+                                          port,
+                                          frontend_url,
+                                          new BrowserListTabContentsProvider());
 }
 
 RemoteDebuggingServer::~RemoteDebuggingServer() {

chrome/browser/debugger/remote_debugging_server.h

@@ -9,23 +9,24 @@
 #include <string>
 
 #include "base/basictypes.h"
-#include "base/memory/ref_counted.h"
-#include "content/browser/debugger/devtools_http_protocol_handler.h"
 
-class DevToolsHttpProtocolHandler;
 class Profile;
 
+namespace content {
+class DevToolsHttpHandler;
+}
+
 class RemoteDebuggingServer {
  public:
   RemoteDebuggingServer(Profile* profile,
-                             const std::string& ip,
-                             int port,
-                             const std::string& frontend_url);
+                        const std::string& ip,
+                        int port,
+                        const std::string& frontend_url);
 
   virtual ~RemoteDebuggingServer();
 
  private:
-  scoped_refptr<DevToolsHttpProtocolHandler> devtools_http_handler_;
+  content::DevToolsHttpHandler* devtools_http_handler_;
   DISALLOW_COPY_AND_ASSIGN(RemoteDebuggingServer);
 };
 

content/browser/debugger/devtools_http_protocol_handler.cc → content/browser/debugger/devtools_http_handler_impl.cc

@@ -2,7 +2,7 @@
 // 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_protocol_handler.h"
+#include "content/browser/debugger/devtools_http_handler_impl.h"
 
 #include <utility>
 
@@ -23,6 +23,7 @@
 #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 "googleurl/src/gurl.h"
 #include "net/base/escape.h"
@@ -30,11 +31,7 @@
 #include "net/server/http_server_request_info.h"
 #include "net/url_request/url_request_context.h"
 
-using content::BrowserThread;
-using content::DevToolsAgentHost;
-using content::DevToolsAgentHostRegistry;
-using content::DevToolsClientHost;
-using content::DevToolsManager;
+namespace content {
 
 const int kBufferSize = 16 * 1024;
 
@@ -138,35 +135,36 @@ base::LazyInstance<
 }  // namespace
 
 // static
-scoped_refptr<DevToolsHttpProtocolHandler> DevToolsHttpProtocolHandler::Start(
+DevToolsHttpHandler* DevToolsHttpHandler::Start(
     const std::string& ip,
     int port,
     const std::string& frontend_url,
-    Delegate* delegate) {
-  scoped_refptr<DevToolsHttpProtocolHandler> http_handler =
-      new DevToolsHttpProtocolHandler(ip, port, frontend_url, delegate);
+    DevToolsHttpHandlerDelegate* delegate) {
+  DevToolsHttpHandlerImpl* http_handler =
+      new DevToolsHttpHandlerImpl(ip, port, frontend_url, delegate);
   http_handler->Start();
   return http_handler;
 }
 
-DevToolsHttpProtocolHandler::~DevToolsHttpProtocolHandler() {
+DevToolsHttpHandlerImpl::~DevToolsHttpHandlerImpl() {
   // Stop() must be called prior to this being called
   DCHECK(server_.get() == NULL);
 }
 
-void DevToolsHttpProtocolHandler::Start() {
+void DevToolsHttpHandlerImpl::Start() {
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
-      base::Bind(&DevToolsHttpProtocolHandler::Init, this));
+      base::Bind(&DevToolsHttpHandlerImpl::Init, this));
 }
 
-void DevToolsHttpProtocolHandler::Stop() {
+void DevToolsHttpHandlerImpl::Stop() {
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
-      base::Bind(&DevToolsHttpProtocolHandler::Teardown, this));
+      base::Bind(&DevToolsHttpHandlerImpl::Teardown, this));
+  protect_ptr_ = NULL;
 }
 
-void DevToolsHttpProtocolHandler::OnHttpRequest(
+void DevToolsHttpHandlerImpl::OnHttpRequest(
     int connection_id,
     const net::HttpServerRequestInfo& info) {
   if (info.path == "/json") {
@@ -174,7 +172,7 @@ void DevToolsHttpProtocolHandler::OnHttpRequest(
     BrowserThread::PostTask(
         BrowserThread::UI,
         FROM_HERE,
-        base::Bind(&DevToolsHttpProtocolHandler::OnJsonRequestUI,
+        base::Bind(&DevToolsHttpHandlerImpl::OnJsonRequestUI,
                    this,
                    connection_id,
                    info));
@@ -210,33 +208,33 @@ void DevToolsHttpProtocolHandler::OnHttpRequest(
   request->Start();
 }
 
-void DevToolsHttpProtocolHandler::OnWebSocketRequest(
+void DevToolsHttpHandlerImpl::OnWebSocketRequest(
     int connection_id,
     const net::HttpServerRequestInfo& request) {
   BrowserThread::PostTask(
       BrowserThread::UI,
       FROM_HERE,
       base::Bind(
-          &DevToolsHttpProtocolHandler::OnWebSocketRequestUI,
+          &DevToolsHttpHandlerImpl::OnWebSocketRequestUI,
           this,
           connection_id,
           request));
 }
 
-void DevToolsHttpProtocolHandler::OnWebSocketMessage(
+void DevToolsHttpHandlerImpl::OnWebSocketMessage(
     int connection_id,
     const std::string& data) {
   BrowserThread::PostTask(
       BrowserThread::UI,
       FROM_HERE,
       base::Bind(
-          &DevToolsHttpProtocolHandler::OnWebSocketMessageUI,
+          &DevToolsHttpHandlerImpl::OnWebSocketMessageUI,
           this,
           connection_id,
           data));
 }
 
-void DevToolsHttpProtocolHandler::OnClose(int connection_id) {
+void DevToolsHttpHandlerImpl::OnClose(int connection_id) {
   ConnectionToRequestsMap::iterator it =
       connection_to_requests_io_.find(connection_id);
   if (it != connection_to_requests_io_.end()) {
@@ -256,7 +254,7 @@ void DevToolsHttpProtocolHandler::OnClose(int connection_id) {
       BrowserThread::UI,
       FROM_HERE,
       base::Bind(
-          &DevToolsHttpProtocolHandler::OnCloseUI,
+          &DevToolsHttpHandlerImpl::OnCloseUI,
           this,
           connection_id));
 }
@@ -273,10 +271,10 @@ struct PageInfo
 typedef std::vector<PageInfo> PageList;
 
 static PageList GeneratePageList(
-    DevToolsHttpProtocolHandler::Delegate* delegate,
+    DevToolsHttpHandlerDelegate* delegate,
     int connection_id,
     const net::HttpServerRequestInfo& info) {
-  typedef DevToolsHttpProtocolHandler::InspectableTabs Tabs;
+  typedef DevToolsHttpHandlerDelegate::InspectableTabs Tabs;
   Tabs inspectable_tabs = delegate->GetInspectableTabs();
 
   PageList page_list;
@@ -306,7 +304,7 @@ static PageList GeneratePageList(
   return page_list;
 }
 
-void DevToolsHttpProtocolHandler::OnJsonRequestUI(
+void DevToolsHttpHandlerImpl::OnJsonRequestUI(
     int connection_id,
     const net::HttpServerRequestInfo& info) {
   PageList page_list = GeneratePageList(delegate_.get(),
@@ -340,7 +338,7 @@ void DevToolsHttpProtocolHandler::OnJsonRequestUI(
   Send200(connection_id, response, "application/json; charset=UTF-8");
 }
 
-void DevToolsHttpProtocolHandler::OnWebSocketRequestUI(
+void DevToolsHttpHandlerImpl::OnWebSocketRequestUI(
     int connection_id,
     const net::HttpServerRequestInfo& request) {
   std::string prefix = "/devtools/page/";
@@ -379,7 +377,7 @@ void DevToolsHttpProtocolHandler::OnWebSocketRequestUI(
   AcceptWebSocket(connection_id, request);
 }
 
-void DevToolsHttpProtocolHandler::OnWebSocketMessageUI(
+void DevToolsHttpHandlerImpl::OnWebSocketMessageUI(
     int connection_id,
     const std::string& data) {
   ConnectionToClientHostMap::iterator it =
@@ -391,7 +389,7 @@ void DevToolsHttpProtocolHandler::OnWebSocketMessageUI(
   manager->DispatchOnInspectorBackend(it->second, data);
 }
 
-void DevToolsHttpProtocolHandler::OnCloseUI(int connection_id) {
+void DevToolsHttpHandlerImpl::OnCloseUI(int connection_id) {
   ConnectionToClientHostMap::iterator it =
       connection_to_client_host_ui_.find(connection_id);
   if (it != connection_to_client_host_ui_.end()) {
@@ -403,7 +401,7 @@ void DevToolsHttpProtocolHandler::OnCloseUI(int connection_id) {
   }
 }
 
-void DevToolsHttpProtocolHandler::OnResponseStarted(net::URLRequest* request) {
+void DevToolsHttpHandlerImpl::OnResponseStarted(net::URLRequest* request) {
   RequestToSocketMap::iterator it = request_to_connection_io_.find(request);
   if (it == request_to_connection_io_.end())
     return;
@@ -435,7 +433,7 @@ void DevToolsHttpProtocolHandler::OnResponseStarted(net::URLRequest* request) {
   OnReadCompleted(request, bytes_read);
 }
 
-void DevToolsHttpProtocolHandler::OnReadCompleted(net::URLRequest* request,
+void DevToolsHttpHandlerImpl::OnReadCompleted(net::URLRequest* request,
                                                   int bytes_read) {
   RequestToSocketMap::iterator it = request_to_connection_io_.find(request);
   if (it == request_to_connection_io_.end())
@@ -461,29 +459,30 @@ void DevToolsHttpProtocolHandler::OnReadCompleted(net::URLRequest* request,
   }
 }
 
-DevToolsHttpProtocolHandler::DevToolsHttpProtocolHandler(
+DevToolsHttpHandlerImpl::DevToolsHttpHandlerImpl(
     const std::string& ip,
     int port,
     const std::string& frontend_host,
-    Delegate* delegate)
+    DevToolsHttpHandlerDelegate* delegate)
     : ip_(ip),
       port_(port),
       overridden_frontend_url_(frontend_host),
-      delegate_(delegate) {
+      delegate_(delegate),
+      ALLOW_THIS_IN_INITIALIZER_LIST(protect_ptr_(this)) {
   if (overridden_frontend_url_.empty())
       overridden_frontend_url_ = "/devtools/devtools.html";
 }
 
-void DevToolsHttpProtocolHandler::Init() {
+void DevToolsHttpHandlerImpl::Init() {
   server_ = new net::HttpServer(ip_, port_, this);
 }
 
 // Run on I/O thread
-void DevToolsHttpProtocolHandler::Teardown() {
+void DevToolsHttpHandlerImpl::Teardown() {
   server_ = NULL;
 }
 
-void DevToolsHttpProtocolHandler::Bind(net::URLRequest* request,
+void DevToolsHttpHandlerImpl::Bind(net::URLRequest* request,
                                        int connection_id) {
   request_to_connection_io_[request] = connection_id;
   ConnectionToRequestsMap::iterator it =
@@ -498,7 +497,7 @@ void DevToolsHttpProtocolHandler::Bind(net::URLRequest* request,
   request_to_buffer_io_[request] = new net::IOBuffer(kBufferSize);
 }
 
-void DevToolsHttpProtocolHandler::RequestCompleted(net::URLRequest* request) {
+void DevToolsHttpHandlerImpl::RequestCompleted(net::URLRequest* request) {
   RequestToSocketMap::iterator it = request_to_connection_io_.find(request);
   if (it == request_to_connection_io_.end())
     return;
@@ -512,7 +511,7 @@ void DevToolsHttpProtocolHandler::RequestCompleted(net::URLRequest* request) {
   delete request;
 }
 
-void DevToolsHttpProtocolHandler::Send200(int connection_id,
+void DevToolsHttpHandlerImpl::Send200(int connection_id,
                                           const std::string& data,
                                           const std::string& mime_type) {
   BrowserThread::PostTask(
@@ -524,13 +523,13 @@ void DevToolsHttpProtocolHandler::Send200(int connection_id,
                  mime_type));
 }
 
-void DevToolsHttpProtocolHandler::Send404(int connection_id) {
+void DevToolsHttpHandlerImpl::Send404(int connection_id) {
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&net::HttpServer::Send404, server_.get(), connection_id));
 }
 
-void DevToolsHttpProtocolHandler::Send500(int connection_id,
+void DevToolsHttpHandlerImpl::Send500(int connection_id,
                                           const std::string& message) {
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
@@ -538,7 +537,7 @@ void DevToolsHttpProtocolHandler::Send500(int connection_id,
                  message));
 }
 
-void DevToolsHttpProtocolHandler::AcceptWebSocket(
+void DevToolsHttpHandlerImpl::AcceptWebSocket(
     int connection_id,
     const net::HttpServerRequestInfo& request) {
   BrowserThread::PostTask(
@@ -546,3 +545,5 @@ void DevToolsHttpProtocolHandler::AcceptWebSocket(
       base::Bind(&net::HttpServer::AcceptWebSocket, server_.get(),
                  connection_id, request));
 }
+
+}  // namespace content

content/browser/debugger/devtools_http_protocol_handler.h → content/browser/debugger/devtools_http_handler_impl.h

@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef CONTENT_BROWSER_DEBUGGER_DEVTOOLS_HTTP_PROTOCOL_HANDLER_H_
-#define CONTENT_BROWSER_DEBUGGER_DEVTOOLS_HTTP_PROTOCOL_HANDLER_H_
+#ifndef CONTENT_BROWSER_DEBUGGER_DEVTOOLS_HTTP_HANDLER_IMPL_H_
+#define CONTENT_BROWSER_DEBUGGER_DEVTOOLS_HTTP_HANDLER_IMPL_H_
 #pragma once
 
 #include <map>
@@ -14,65 +14,38 @@
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "content/common/content_export.h"
+#include "content/public/browser/devtools_http_handler.h"
 #include "net/server/http_server.h"
 #include "net/url_request/url_request.h"
 
 class TabContents;
 
-namespace content {
-class DevToolsClientHost;
-}
-
 namespace net {
 class URLRequestContext;
 }
 
-class DevToolsHttpProtocolHandler
-    : public net::HttpServer::Delegate,
-      public net::URLRequest::Delegate,
-      public base::RefCountedThreadSafe<DevToolsHttpProtocolHandler> {
- public:
-  typedef std::vector<TabContents*> InspectableTabs;
-  class Delegate {
-   public:
-    Delegate() {}
-    virtual ~Delegate() {}
-
-    // Should return the list of inspectable tabs. Called on the UI thread.
-    virtual InspectableTabs GetInspectableTabs() = 0;
-
-    // Should return discovery page HTML that should list available tabs
-    // and provide attach links. Called on the IO thread.
-    virtual std::string GetDiscoveryPageHTML() = 0;
-
-    // Should return URL request context for issuing requests against devtools
-    // webui or NULL if no context is available. Called on the IO thread.
-    virtual net::URLRequestContext* GetURLRequestContext() = 0;
-   private:
-    DISALLOW_COPY_AND_ASSIGN(Delegate);
-  };
-
-  // Takes ownership over |delegate|.
-  CONTENT_EXPORT static scoped_refptr<DevToolsHttpProtocolHandler> Start(
-      const std::string& ip,
-      int port,
-      const std::string& frontend_url,
-      Delegate* delegate);
-
-  // Called from the main thread in order to stop protocol handler.
-  // Will schedule tear down task on IO thread.
-  CONTENT_EXPORT void Stop();
+namespace content {
+
+class DevToolsClientHost;
 
+class DevToolsHttpHandlerImpl
+    : public DevToolsHttpHandler,
+      public base::RefCountedThreadSafe<DevToolsHttpHandlerImpl>,
+      public net::HttpServer::Delegate,
+      public net::URLRequest::Delegate {
  private:
-  friend class base::RefCountedThreadSafe<DevToolsHttpProtocolHandler>;
-
-  DevToolsHttpProtocolHandler(const std::string& ip,
-                              int port,
-                              const std::string& frontend_url,
-                              Delegate* delegate);
-  virtual ~DevToolsHttpProtocolHandler();
+  friend class base::RefCountedThreadSafe<DevToolsHttpHandlerImpl>;
+  friend class DevToolsHttpHandler;
+  DevToolsHttpHandlerImpl(const std::string& ip,
+                          int port,
+                          const std::string& frontend_url,
+                          DevToolsHttpHandlerDelegate* delegate);
+  virtual ~DevToolsHttpHandlerImpl();
   void Start();
 
+  // DevToolsHttpHandler implementation.
+  virtual void Stop() OVERRIDE;
+
   // net::HttpServer::Delegate implementation.
   virtual void OnHttpRequest(int connection_id,
                              const net::HttpServerRequestInfo& info) OVERRIDE;
@@ -126,8 +99,11 @@ class DevToolsHttpProtocolHandler
   typedef std::map<int, content::DevToolsClientHost*>
       ConnectionToClientHostMap;
   ConnectionToClientHostMap connection_to_client_host_ui_;
-  scoped_ptr<Delegate> delegate_;
-  DISALLOW_COPY_AND_ASSIGN(DevToolsHttpProtocolHandler);
+  scoped_ptr<DevToolsHttpHandlerDelegate> delegate_;
+  scoped_refptr<DevToolsHttpHandlerImpl> protect_ptr_;
+  DISALLOW_COPY_AND_ASSIGN(DevToolsHttpHandlerImpl);
 };
 
-#endif  // CONTENT_BROWSER_DEBUGGER_DEVTOOLS_HTTP_PROTOCOL_HANDLER_H_
+}  // namespace content
+
+#endif  // CONTENT_BROWSER_DEBUGGER_DEVTOOLS_HTTP_HANDLER_IMPL_H_

content/content_browser.gypi

@@ -34,6 +34,8 @@
     'public/browser/devtools_agent_host_registry.h',
     'public/browser/devtools_client_host.h',
     'public/browser/devtools_frontend_window_delegate.h',
+    'public/browser/devtools_http_handler.h',
+    'public/browser/devtools_http_handler_delegate.h',
     'public/browser/devtools_manager.h',
     'public/browser/download_manager_delegate.h',
     'public/browser/intents_host.h',
@@ -113,8 +115,8 @@
     'browser/debugger/devtools_agent_host.h',
     'browser/debugger/devtools_frontend_host.cc',
     'browser/debugger/devtools_frontend_host.h',
-    'browser/debugger/devtools_http_protocol_handler.cc',
-    'browser/debugger/devtools_http_protocol_handler.h',
+    'browser/debugger/devtools_http_handler_impl.cc',
+    'browser/debugger/devtools_http_handler_impl.h',
     'browser/debugger/devtools_manager_impl.cc',
     'browser/debugger/devtools_manager_impl.h',
     'browser/debugger/devtools_netlog_observer.cc',

content/public/browser/devtools_http_handler.h

+// 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.
+
+#ifndef CONTENT_PUBLIC_BROWSER_DEVTOOLS_HTTP_HANDLER_H_
+#define CONTENT_PUBLIC_BROWSER_DEVTOOLS_HTTP_HANDLER_H_
+#pragma once
+
+#include <string>
+
+#include "content/common/content_export.h"
+
+namespace content {
+
+class DevToolsHttpHandlerDelegate;
+
+// This class is used for managing DevTools remote debugging server.
+// Clients can connect to the specified ip:port and start debugging
+// this browser.
+class DevToolsHttpHandler {
+ public:
+  // Takes ownership over |delegate|.
+  CONTENT_EXPORT static DevToolsHttpHandler* Start(
+      const std::string& ip,
+      int port,
+      const std::string& frontend_url,
+      DevToolsHttpHandlerDelegate* delegate);
+
+  // Called from the main thread in order to stop protocol handler.
+  virtual void Stop() = 0;
+
+ protected:
+  virtual ~DevToolsHttpHandler() {}
+};
+
+}  // namespace content
+
+#endif  // CONTENT_PUBLIC_BROWSER_DEVTOOLS_HTTP_HANDLER_H_

content/public/browser/devtools_http_handler_delegate.h

+// 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.
+
+#ifndef CONTENT_PUBLIC_BROWSER_DEVTOOLS_HTTP_HANDLER_DELEGATE_H_
+#define CONTENT_PUBLIC_BROWSER_DEVTOOLS_HTTP_HANDLER_DELEGATE_H_
+#pragma once
+
+#include <string>
+#include <vector>
+
+class TabContents;
+
+namespace net {
+class URLRequestContext;
+}
+
+namespace content {
+
+class DevToolsHttpHandlerDelegate {
+ public:
+  typedef std::vector<TabContents*> InspectableTabs;
+  virtual ~DevToolsHttpHandlerDelegate() {}
+
+  // Should return the list of inspectable tabs. Called on the UI thread.
+  virtual InspectableTabs GetInspectableTabs() = 0;
+
+  // Should return discovery page HTML that should list available tabs
+  // and provide attach links. Called on the IO thread.
+  virtual std::string GetDiscoveryPageHTML() = 0;
+
+  // Should return URL request context for issuing requests against devtools
+  // webui or NULL if no context is available. Called on the IO thread.
+  virtual net::URLRequestContext* GetURLRequestContext() = 0;
+};
+
+}  // namespace content
+
+#endif  // CONTENT_PUBLIC_BROWSER_DEVTOOLS_HTTP_HANDLER_DELEGATE_H_