DevTools: add backend for discovering connected ADB devices.

chrome/browser/ui/webui/inspect_ui.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 "chrome/browser/ui/webui/inspect_ui.h"
 
 #include <set>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/json/json_writer.h"
 #include "base/memory/ref_counted_memory.h"
 #include "base/string_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/devtools/devtools_window.h"
+#include "chrome/browser/devtools/protocol_http_request.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/tab_contents/tab_contents_iterator.h"
 #include "chrome/common/url_constants.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/child_process_data.h"
 #include "content/public/browser/devtools_agent_host.h"
 #include "content/public/browser/devtools_client_host.h"
 #include "content/public/browser/devtools_manager.h"
 #include "content/public/browser/favicon_status.h"
@@ skipping 23 matching lines @@
 using content::DevToolsManager;
 using content::RenderProcessHost;
 using content::RenderViewHost;
 using content::RenderViewHostDelegate;
 using content::RenderWidgetHost;
 using content::WebContents;
 using content::WebUIMessageHandler;
 using content::WorkerService;
 using content::WorkerServiceObserver;
 
+namespace {
+
 static const char kDataFile[] = "targets-data.json";
+static const char kAdbQuery[] = "adb-query/";
+static const char kLocalXhr[] = "local-xhr/";
 
 static const char kExtensionTargetType[]  = "extension";
 static const char kPageTargetType[]  = "page";
 static const char kWorkerTargetType[]  = "worker";
 
 static const char kInspectCommand[]  = "inspect";
 static const char kTerminateCommand[]  = "terminate";
 
 static const char kTargetTypeField[]  = "type";
 static const char kAttachedField[]  = "attached";
 static const char kProcessIdField[]  = "processId";
 static const char kRouteIdField[]  = "routeId";
 static const char kUrlField[]  = "url";
 static const char kNameField[]  = "name";
 static const char kFaviconUrlField[] = "favicon_url";
 static const char kPidField[]  = "pid";
 
-namespace {
-
 DictionaryValue* BuildTargetDescriptor(
     const std::string& target_type,
     bool attached,
     const GURL& url,
     const std::string& name,
     const GURL& favicon_url,
     int process_id,
     int route_id,
     base::ProcessHandle handle = base::kNullProcessHandle) {
   DictionaryValue* target_data = new DictionaryValue();
@@ skipping 71 matching lines @@
         worker_info[i].route_id,
         worker_info[i].handle));
   }
 
   std::string json_string;
   base::JSONWriter::Write(rvh_list, &json_string);
 
   callback.Run(base::RefCountedString::TakeString(&json_string));
 }
 
-bool HandleRequestCallback(
+bool HandleDataRequestCallback(
     const std::string& path,
     const content::WebUIDataSource::GotDataCallback& callback) {
-  if (path != kDataFile)
-    return false;
-
   std::set<RenderViewHost*> tab_rvhs;
   for (TabContentsIterator it; !it.done(); it.Next())
     tab_rvhs.insert(it->GetRenderViewHost());
 
   scoped_ptr<ListValue> rvh_list(new ListValue());
 
   for (RenderProcessHost::iterator it(RenderProcessHost::AllHostsIterator());
        !it.IsAtEnd(); it.Advance()) {
     RenderProcessHost* render_process_host = it.GetCurrentValue();
     DCHECK(render_process_host);
@@ skipping 18 matching lines @@
     }
   }
 
   BrowserThread::PostTask(
       BrowserThread::IO,
       FROM_HERE,
       base::Bind(&SendDescriptors, base::Owned(rvh_list.release()), callback));
   return true;
 }
 
-content::WebUIDataSource* CreateInspectUIHTMLSource() {
-  content::WebUIDataSource* source =
-      content::WebUIDataSource::Create(chrome::kChromeUIInspectHost);
-  source->AddResourcePath("inspect.css", IDR_INSPECT_CSS);
-  source->AddResourcePath("inspect.js", IDR_INSPECT_JS);
-  source->SetDefaultResource(IDR_INSPECT_HTML);
-  source->SetRequestFilter(base::Bind(&HandleRequestCallback));
-  return source;
-}
-
 class InspectMessageHandler : public WebUIMessageHandler {
  public:
   InspectMessageHandler() {}
   virtual ~InspectMessageHandler() {}
 
  private:
   // WebUIMessageHandler implementation.
   virtual void RegisterMessages() OVERRIDE;
 
   // Callback for "openDevTools" message.
@@ skipping 115 matching lines @@
 
   void UnregisterObserver() {
     WorkerService::GetInstance()->RemoveObserver(this);
   }
 
   InspectUI* discovery_ui_;
 };
 
 InspectUI::InspectUI(content::WebUI* web_ui)
     : WebUIController(web_ui),
-      observer_(new WorkerCreationDestructionListener(this)) {
+      observer_(new WorkerCreationDestructionListener(this)),
+      ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)) {
   web_ui->AddMessageHandler(new InspectMessageHandler());
 
   Profile* profile = Profile::FromWebUI(web_ui);
+  adb_bridge_ = DevToolsAdbBridge::Start();
   content::WebUIDataSource::Add(profile, CreateInspectUIHTMLSource());
 
   registrar_.Add(this,
                  content::NOTIFICATION_WEB_CONTENTS_CONNECTED,
                  content::NotificationService::AllSources());
   registrar_.Add(this,
                  content::NOTIFICATION_WEB_CONTENTS_DISCONNECTED,
                  content::NotificationService::AllSources());
   registrar_.Add(this,
                  content::NOTIFICATION_WEB_CONTENTS_DESTROYED,
                  content::NotificationService::AllSources());
 }
 
 InspectUI::~InspectUI() {
   StopListeningNotifications();
 }
 
 void InspectUI::RefreshUI() {
   web_ui()->CallJavascriptFunction("populateLists");
 }
 
+// static
+bool InspectUI::WeakHandleRequestCallback(
+    const base::WeakPtr<InspectUI>& inspect_ui,
+    const std::string& path,
+    const content::WebUIDataSource::GotDataCallback& callback) {
+  if (!inspect_ui.get())
+    return false;
+  return inspect_ui->HandleRequestCallback(path, callback);
+}
+
 void InspectUI::Observe(int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   if (source != content::Source<WebContents>(web_ui()->GetWebContents()))
     RefreshUI();
   else if (type == content::NOTIFICATION_WEB_CONTENTS_DISCONNECTED)
     StopListeningNotifications();
 }
 
 void InspectUI::StopListeningNotifications()
 {
   if (!observer_)
     return;
+  if (adb_bridge_) {
+    adb_bridge_->Stop();
+    adb_bridge_ = NULL;
+  }
   observer_->InspectUIDestroyed();
   observer_ = NULL;
   registrar_.RemoveAll();
 }
+
+content::WebUIDataSource* InspectUI::CreateInspectUIHTMLSource() {
+  content::WebUIDataSource* source =
+      content::WebUIDataSource::Create(chrome::kChromeUIInspectHost);
+  source->AddResourcePath("inspect.css", IDR_INSPECT_CSS);
+  source->AddResourcePath("inspect.js", IDR_INSPECT_JS);
+  source->SetDefaultResource(IDR_INSPECT_HTML);
+  source->SetRequestFilter(base::Bind(&InspectUI::WeakHandleRequestCallback,
+                                      weak_factory_.GetWeakPtr()));
+  return source;
+}
+
+bool InspectUI::HandleRequestCallback(
+    const std::string& path,
+    const content::WebUIDataSource::GotDataCallback& callback) {
+  if (path == kDataFile)
+    return HandleDataRequestCallback(path, callback);
+  if (path.find(kAdbQuery) == 0)
+    return HandleAdbQueryCallback(path, callback);
+  if (path.find(kLocalXhr) == 0)
+    return HandleLocalXhrCallback(path, callback);
+  return false;
+}
+
+bool InspectUI::HandleAdbQueryCallback(
+    const std::string& path,
+    const content::WebUIDataSource::GotDataCallback& callback) {
+  std::string query = path.substr(strlen(kAdbQuery));
+  adb_bridge_->Query(query, base::Bind(&InspectUI::RespondOnUIThread,
+                                       weak_factory_.GetWeakPtr(), callback));
+  return true;
+}
+
+bool InspectUI::HandleLocalXhrCallback(
+    const std::string& path,
+    const content::WebUIDataSource::GotDataCallback& callback) {
+  std::string url = "http://localhost:" + path.substr(strlen(kLocalXhr));
+  new ProtocolHttpRequest(Profile::FromWebUI(web_ui()), url,
+      base::Bind(&InspectUI::RespondOnUIThread,
+                 weak_factory_.GetWeakPtr(), callback));
+  return true;
+}
+
+void InspectUI::RespondOnUIThread(
+    const content::WebUIDataSource::GotDataCallback& callback,
+    const std::string& error,
+    const std::string& data) {
+  ListValue result;
+  result.AppendString(error);
+  result.AppendString(data);
+  std::string json_string;
+  base::JSONWriter::Write(&result, &json_string);
+  callback.Run(base::RefCountedString::TakeString(&json_string));
+}