chrome://inspect: Add "open", "close" and "reload" actions to Devices tab

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/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
+#include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/devtools/devtools_window.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/browser/ui/webui/theme_source.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
 #include "content/public/browser/browser_thread.h"
@@ skipping 42 matching lines @@
 
 static const char kAppTargetType[] = "app";
 static const char kExtensionTargetType[]  = "extension";
 static const char kPageTargetType[]  = "page";
 static const char kWorkerTargetType[]  = "worker";
 static const char kAdbTargetType[]  = "adb_page";
 
 static const char kInitUICommand[]  = "init-ui";
 static const char kInspectCommand[]  = "inspect";
 static const char kTerminateCommand[]  = "terminate";
+static const char kReloadCommand[]  = "reload";
+static const char kOpenCommand[]  = "open";
+
 static const char kPortForwardingEnabledCommand[] =
     "set-port-forwarding-enabled";
 static const char kPortForwardingConfigCommand[] = "set-port-forwarding-config";
 
 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[] = "faviconUrl";
 static const char kPidField[]  = "pid";
 static const char kAdbSerialField[] = "adbSerial";
 static const char kAdbModelField[] = "adbModel";
 static const char kAdbBrowserNameField[] = "adbBrowserName";
-static const char kAdbPageIdField[] = "adbPageId";
+static const char kAdbGlobalIdField[] = "adbGlobalId";
 static const char kAdbBrowsersField[] = "browsers";
 static const char kAdbPagesField[] = "pages";
 
 DictionaryValue* BuildTargetDescriptor(
     const std::string& target_type,
     bool attached,
     const GURL& url,
     const std::string& name,
     const GURL& favicon_url,
     int process_id,
@@ skipping 68 matching lines @@
       : inspect_ui_(inspect_ui) {}
   virtual ~InspectMessageHandler() {}
 
  private:
   // WebUIMessageHandler implementation.
   virtual void RegisterMessages() OVERRIDE;
 
   void HandleInitUICommand(const ListValue* args);
   void HandleInspectCommand(const ListValue* args);
   void HandleTerminateCommand(const ListValue* args);
+  void HandleReloadCommand(const ListValue* args);
+  void HandleOpenCommand(const ListValue* args);
   void HandlePortForwardingEnabledCommand(const ListValue* args);
   void HandlePortForwardingConfigCommand(const ListValue* args);
 
-  bool GetProcessAndRouteId(const ListValue* args,
-                            int* process_id,
-                            int* route_id);
+  static bool GetProcessAndRouteId(const ListValue* args,
+                                   int* process_id,
+                                   int* route_id);
+
+  static bool GetRemotePageId(const ListValue* args, std::string* page_id);
 
   InspectUI* inspect_ui_;
 
   DISALLOW_COPY_AND_ASSIGN(InspectMessageHandler);
 };
 
 void InspectMessageHandler::RegisterMessages() {
   web_ui()->RegisterMessageCallback(kInitUICommand,
       base::Bind(&InspectMessageHandler::HandleInitUICommand,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback(kInspectCommand,
       base::Bind(&InspectMessageHandler::HandleInspectCommand,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback(kTerminateCommand,
       base::Bind(&InspectMessageHandler::HandleTerminateCommand,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback(kPortForwardingEnabledCommand,
       base::Bind(&InspectMessageHandler::HandlePortForwardingEnabledCommand,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback(kPortForwardingConfigCommand,
       base::Bind(&InspectMessageHandler::HandlePortForwardingConfigCommand,
                  base::Unretained(this)));
+  web_ui()->RegisterMessageCallback(kReloadCommand,
+      base::Bind(&InspectMessageHandler::HandleReloadCommand,
+                 base::Unretained(this)));
+  web_ui()->RegisterMessageCallback(kOpenCommand,
+      base::Bind(&InspectMessageHandler::HandleOpenCommand,
+                 base::Unretained(this)));
 }
 
 void InspectMessageHandler::HandleInitUICommand(const ListValue*) {
   inspect_ui_->InitUI();
 }
 
 void InspectMessageHandler::HandleInspectCommand(const ListValue* args) {
   Profile* profile = Profile::FromWebUI(web_ui());
   if (!profile)
     return;
 
+  std::string page_id;
+  if (GetRemotePageId(args, &page_id)) {
+    inspect_ui_->InspectRemotePage(page_id);
+    return;
+  }
+
   int process_id;
   int route_id;
   if (!GetProcessAndRouteId(args, &process_id, &route_id) || process_id == 0
       || route_id == 0) {
-    // Check for ADB page id
-    const DictionaryValue* data;
-    std::string page_id;
-    if (args->GetSize() == 1 && args->GetDictionary(0, &data) &&
-        data->GetString(kAdbPageIdField, &page_id)) {
-      inspect_ui_->InspectRemotePage(page_id);
-    }
     return;
   }
 
   RenderViewHost* rvh = RenderViewHost::FromID(process_id, route_id);
   if (rvh) {
     DevToolsWindow::OpenDevToolsWindow(rvh);
     return;
   }
 
   scoped_refptr<DevToolsAgentHost> agent_host(
       DevToolsAgentHost::GetForWorker(process_id, route_id));
   if (!agent_host.get())
     return;
 
   DevToolsWindow::OpenDevToolsWindowForWorker(profile, agent_host.get());
 }
 
 static void TerminateWorker(int process_id, int route_id) {
   WorkerService::GetInstance()->TerminateWorker(process_id, route_id);
 }
 
 void InspectMessageHandler::HandleTerminateCommand(const ListValue* args) {
+  std::string page_id;
+  if (GetRemotePageId(args, &page_id)) {
+    inspect_ui_->CloseRemotePage(page_id);
+    return;
+  }
+
   int process_id;
   int route_id;
   if (!GetProcessAndRouteId(args, &process_id, &route_id))
     return;
 
   BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
       base::Bind(&TerminateWorker, process_id, route_id));
 }
 
+void InspectMessageHandler::HandleReloadCommand(const ListValue* args) {
+  std::string page_id;
+  if (GetRemotePageId(args, &page_id))
+    inspect_ui_->ReloadRemotePage(page_id);
+}
+
+void InspectMessageHandler::HandleOpenCommand(const ListValue* args) {
+  std::string browser_id;
+  std::string url;
+  if (args->GetSize() == 2 &&
+      args->GetString(0, &browser_id) &&
+      args->GetString(1, &url)) {
+    inspect_ui_->OpenRemotePage(browser_id, url);
+  }
+}
+
 bool InspectMessageHandler::GetProcessAndRouteId(const ListValue* args,
                                                  int* process_id,
                                                  int* route_id) {
   const DictionaryValue* data;
   if (args->GetSize() == 1 && args->GetDictionary(0, &data) &&
       data->GetInteger(kProcessIdField, process_id) &&
       data->GetInteger(kRouteIdField, route_id)) {
     return true;
   }
   return false;
@@ skipping 16 matching lines @@
     const ListValue* args) {
   Profile* profile = Profile::FromWebUI(web_ui());
   if (!profile)
     return;
 
   const DictionaryValue* dict_src;
   if (args->GetSize() == 1 && args->GetDictionary(0, &dict_src))
     profile->GetPrefs()->Set(prefs::kDevToolsPortForwardingConfig, *dict_src);
 }
 
+bool InspectMessageHandler::GetRemotePageId(const ListValue* args,
+                                            std::string* page_id) {
+  const DictionaryValue* data;
+  if (args->GetSize() == 1 && args->GetDictionary(0, &data) &&
+      data->GetString(kAdbGlobalIdField, page_id)) {
+    return true;
+  }
+  return false;
+}
+
 }  // namespace
 
 class InspectUI::WorkerCreationDestructionListener
     : public WorkerServiceObserver,
       public base::RefCountedThreadSafe<WorkerCreationDestructionListener> {
  public:
   WorkerCreationDestructionListener()
       : discovery_ui_(NULL) {}
 
   void Init(InspectUI* workers_ui) {
@@ skipping 104 matching lines @@
 }
 
 void InspectUI::InspectRemotePage(const std::string& id) {
   RemotePages::iterator it = remote_pages_.find(id);
   if (it != remote_pages_.end()) {
     Profile* profile = Profile::FromWebUI(web_ui());
     it->second->Inspect(profile);
   }
 }
 
+void InspectUI::ReloadRemotePage(const std::string& id) {
+  RemotePages::iterator it = remote_pages_.find(id);
+  if (it != remote_pages_.end())
+    it->second->Reload();
+}
+
+void InspectUI::CloseRemotePage(const std::string& id) {
+  RemotePages::iterator it = remote_pages_.find(id);
+  if (it != remote_pages_.end())
+    it->second->Close();
+}
+
+void InspectUI::OpenRemotePage(const std::string& browser_id,
+                               const std::string& url) {
+  GURL gurl(url);
+  if (!gurl.is_valid()) {
+    gurl = GURL("http://" + url);
+    if (!gurl.is_valid())
+      return;
+  }
+  RemoteBrowsers::iterator it = remote_browsers_.find(browser_id);
+  if (it != remote_browsers_.end())
+    it->second->Open(gurl.spec());
+}
+
 void InspectUI::PopulateLists() {
   std::set<RenderViewHost*> tab_rvhs;
   for (TabContentsIterator it; !it.done(); it.Next())
     tab_rvhs.insert(it->GetRenderViewHost());
 
   scoped_ptr<ListValue> target_list(new ListValue());
 
   std::vector<RenderViewHost*> rvh_vector =
       DevToolsAgentHost::GetValidRenderViewHosts();
 
@@ skipping 65 matching lines @@
   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);
   return source;
 }
 
 void InspectUI::RemoteDevicesChanged(
     DevToolsAdbBridge::RemoteDevices* devices) {
+  remote_browsers_.clear();
   remote_pages_.clear();
   ListValue device_list;
   for (DevToolsAdbBridge::RemoteDevices::iterator dit = devices->begin();
        dit != devices->end(); ++dit) {
-    DevToolsAdbBridge::RemoteDevice& device = *(dit->get());
+    DevToolsAdbBridge::RemoteDevice* device = dit->get();
     DictionaryValue* device_data = new DictionaryValue();
-    device_data->SetString(kAdbModelField, device.model());
-    device_data->SetString(kAdbSerialField, device.serial());
+    device_data->SetString(kAdbModelField, device->model());
+    device_data->SetString(kAdbSerialField, device->serial());
+    std::string device_id = base::StringPrintf(
+        "device:%s",
+        device->serial().c_str());
+    device_data->SetString(kAdbGlobalIdField, device_id);
     ListValue* browser_list = new ListValue();
     device_data->Set(kAdbBrowsersField, browser_list);
 
-    DevToolsAdbBridge::RemoteBrowsers& browsers = device.browsers();
+    DevToolsAdbBridge::RemoteBrowsers& browsers = device->browsers();
     for (DevToolsAdbBridge::RemoteBrowsers::iterator bit =
         browsers.begin(); bit != browsers.end(); ++bit) {
-      DevToolsAdbBridge::RemoteBrowser& browser = *(bit->get());
+      DevToolsAdbBridge::RemoteBrowser* browser = bit->get();
       DictionaryValue* browser_data = new DictionaryValue();
-      browser_data->SetString(kAdbBrowserNameField, browser.name());
+      browser_data->SetString(kAdbBrowserNameField, browser->name());
+      std::string browser_id = base::StringPrintf(
+          "browser:%s:%s:%s",
+          device->serial().c_str(),
+          browser->socket().c_str(),
+          browser->name().c_str());
+      browser_data->SetString(kAdbGlobalIdField, browser_id);
+      remote_browsers_[browser_id] = browser;
       ListValue* page_list = new ListValue();
       browser_data->Set(kAdbPagesField, page_list);
 
-      DevToolsAdbBridge::RemotePages& pages = browser.pages();
+      DevToolsAdbBridge::RemotePages& pages = browser->pages();
       for (DevToolsAdbBridge::RemotePages::iterator it =
           pages.begin(); it != pages.end(); ++it) {
         DevToolsAdbBridge::RemotePage* page =  it->get();
-        DictionaryValue* page_data = BuildTargetDescriptor(kAdbTargetType,
-            false, GURL(page->url()), page->title(), GURL(page->favicon_url()),
+        DictionaryValue* page_data = BuildTargetDescriptor(
+            kAdbTargetType, page->attached(),
+            GURL(page->url()), page->title(), GURL(page->favicon_url()),
             0, 0);
-        page_data->SetString(kAdbPageIdField, page->global_id());
+        std::string page_id = base::StringPrintf("page:%s:%s:%s",
+            device->serial().c_str(),
+            browser->socket().c_str(),
+            page->id().c_str());
+        page_data->SetString(kAdbGlobalIdField, page_id);
+        remote_pages_[page_id] = page;
         page_list->Append(page_data);
-        remote_pages_[page->global_id()] = page;
       }
       browser_list->Append(browser_data);
     }
     device_list.Append(device_data);
   }
   web_ui()->CallJavascriptFunction("populateDeviceLists", device_list);
 }
 
 void InspectUI::UpdatePortForwardingEnabled() {
   Profile* profile = Profile::FromWebUI(web_ui());
   const base::Value* value = profile->GetPrefs()->FindPreference(
       prefs::kDevToolsPortForwardingEnabled)->GetValue();
   web_ui()->CallJavascriptFunction("updatePortForwardingEnabled", *value);
 
 }
 
 void InspectUI::UpdatePortForwardingConfig() {
   Profile* profile = Profile::FromWebUI(web_ui());
   const base::Value* value = profile->GetPrefs()->FindPreference(
       prefs::kDevToolsPortForwardingConfig)->GetValue();
   web_ui()->CallJavascriptFunction("updatePortForwardingConfig", *value);
 }