DevTools: extract ADB command classes, change objects' lifetimes

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"
@@ skipping 24 matching lines @@
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_ui.h"
 #include "content/public/browser/web_ui_data_source.h"
 #include "content/public/browser/web_ui_message_handler.h"
 #include "content/public/browser/worker_service.h"
 #include "content/public/browser/worker_service_observer.h"
 #include "content/public/common/process_type.h"
 #include "grit/browser_resources.h"
 #include "grit/generated_resources.h"
 #include "net/base/escape.h"
+#include "net/base/net_errors.h"
 #include "ui/base/resource/resource_bundle.h"
 
 using content::BrowserThread;
 using content::ChildProcessData;
 using content::DevToolsAgentHost;
 using content::DevToolsClientHost;
 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 kAdbDevices[] = "adb-devices";
+static const char kAdbPages[] = "adb-pages";
 static const char kLocalXhr[] = "local-xhr/";
 
 static const char kExtensionTargetType[]  = "extension";
 static const char kPageTargetType[]  = "page";
 static const char kWorkerTargetType[]  = "worker";
+static const char kAdbTargetType[]  = "adb_page";
 
 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 kFaviconUrlField[] = "faviconUrl";
 static const char kPidField[]  = "pid";
+static const char kAdbSerialField[] = "adbSerial";
+static const char kAdbModelField[] = "adbModel";
+static const char kAdbPageIdField[] = "adbPageId";
+static const char kAdbDebugUrl[] = "adbDebugUrl";
 
 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) {
@@ skipping 69 matching lines @@
         worker_info[i].url,
         UTF16ToUTF8(worker_info[i].name),
         GURL(),
         worker_info[i].process_id,
         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 HandleDataRequestCallback(
     const std::string& path,
     const content::WebUIDataSource::GotDataCallback& callback) {
   std::set<RenderViewHost*> tab_rvhs;
   for (TabContentsIterator it; !it.done(); it.Next())
     tab_rvhs.insert(it->GetRenderViewHost());
 
@@ skipping 148 matching lines @@
   InspectUI* discovery_ui_;
 };
 
 InspectUI::InspectUI(content::WebUI* web_ui)
     : WebUIController(web_ui),
       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();
+  adb_bridge_.reset(new DevToolsAdbBridge(profile));
   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,
@@ skipping 24 matching lines @@
   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;
-  }
+  adb_bridge_.reset();
   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(kAdbDevices) == 0)
-    return HandleAdbDevicesCallback(path, callback);
+  if (path.find(kAdbPages) == 0)
+    return HandleAdbPagesCallback(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 = net::UnescapeURLComponent(
       path.substr(strlen(kAdbQuery)),
       net::UnescapeRule::NORMAL | net::UnescapeRule::SPACES |
           net::UnescapeRule::URL_SPECIAL_CHARS);
   adb_bridge_->Query(query, base::Bind(&InspectUI::RespondOnUIThread,
                                        weak_factory_.GetWeakPtr(), callback));
   return true;
 }
 
-bool InspectUI::HandleAdbDevicesCallback(
+bool InspectUI::HandleAdbPagesCallback(
     const std::string& path,
     const content::WebUIDataSource::GotDataCallback& callback) {
-  adb_bridge_->Devices();
-  std::string json_string = "";
-  callback.Run(base::RefCountedString::TakeString(&json_string));
+  adb_bridge_->Pages(base::Bind(&InspectUI::OnAdbPages,
+                                weak_factory_.GetWeakPtr(),
+                                callback));
   return true;
 }
 
+void InspectUI::OnAdbPages(
+    const content::WebUIDataSource::GotDataCallback& callback,
+    int result,
+    DevToolsAdbBridge::RemotePages* pages) {
+  if (result != net::OK)
+    return;
+  ListValue targets;
+  scoped_ptr<DevToolsAdbBridge::RemotePages> my_pages(pages);
+  for (DevToolsAdbBridge::RemotePages::iterator it = my_pages->begin();
+       it != my_pages->end(); ++it) {
+    DevToolsAdbBridge::RemotePage* page = it->get();
+    DictionaryValue* target_data = BuildTargetDescriptor(kAdbTargetType,
+        false, GURL(page->url()), page->title(), GURL(page->favicon_url()), 0,
+        0);
+    target_data->SetString(kAdbSerialField, page->serial());
+    target_data->SetString(kAdbModelField, page->model());
+    target_data->SetString(kAdbPageIdField, page->id());
+    target_data->SetString(kAdbDebugUrl, page->debug_url());
+    targets.Append(target_data);
+  }
+
+  std::string json_string = "";
+  base::JSONWriter::Write(&targets, &json_string);
+  callback.Run(base::RefCountedString::TakeString(&json_string));
+}
+
 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,
     int result_code,
     const std::string& response) {
   ListValue result;
   result.AppendInteger(result_code);
   result.AppendString(response);
   std::string json_string;
   base::JSONWriter::Write(&result, &json_string);
   callback.Run(base::RefCountedString::TakeString(&json_string));
 }