Support for browser aliases in DevTools.

chrome/browser/devtools/device/devtools_android_bridge.cc

 // Copyright 2014 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/devtools/device/devtools_android_bridge.h"
 
 #include <map>
 #include <vector>
 
 #include "base/base64.h"
@@ skipping 39 matching lines @@
 const char kBrowserTargetSocket[] = "/devtools/browser";
 const int kAdbPollingIntervalMs = 1000;
 
 const char kUrlParam[] = "url";
 const char kPageReloadCommand[] = "Page.reload";
 const char kPageNavigateCommand[] = "Page.navigate";
 
 const int kMinVersionNewWithURL = 32;
 const int kNewPageNavigateDelayMs = 500;
 
+static int last_remote_browser_id_ = 1;
+
 // DiscoveryRequest -----------------------------------------------------
 
 class DiscoveryRequest : public base::RefCountedThreadSafe<
     DiscoveryRequest,
     BrowserThread::DeleteOnUIThread> {
  public:
   typedef AndroidDeviceManager::Device Device;
   typedef AndroidDeviceManager::Devices Devices;
   typedef AndroidDeviceManager::DeviceInfo DeviceInfo;
   typedef DevToolsAndroidBridge::RemoteDevice RemoteDevice;
@@ skipping 332 matching lines @@
   virtual std::string GetId() const OVERRIDE;
   virtual bool IsAttached() const OVERRIDE;
   virtual bool Activate() const OVERRIDE;
   virtual bool Close() const OVERRIDE;
   virtual void Inspect(Profile* profile) const OVERRIDE;
   virtual void Reload() const OVERRIDE;
 
   void Navigate(const std::string& url, base::Closure callback) const;
 
  private:
-  scoped_refptr<DevToolsAndroidBridge::RemoteBrowser> browser_;
-  std::string debug_url_;
+  const scoped_refptr<DevToolsAndroidBridge::RemoteBrowser> browser_;
+  const std::string debug_url_;
   std::string frontend_url_;
-  std::string remote_id_;
-  std::string remote_type_;
+  const std::string remote_id_;
+  const std::string local_id_;
+  const std::string remote_type_;
   DISALLOW_COPY_AND_ASSIGN(RemotePageTarget);
 };
 
 static std::string GetStringProperty(const base::DictionaryValue& value,
                                      const std::string& name) {
   std::string result;
   value.GetString(name, &result);
   return result;
 }
 
@@ skipping 14 matching lines @@
   return debug_url;
 }
 
 RemotePageTarget::RemotePageTarget(
     scoped_refptr<DevToolsAndroidBridge::RemoteBrowser> browser,
     const base::DictionaryValue& value)
     : DevToolsTargetImpl(AgentHostDelegate::GetOrCreateAgentHost(
                              BuildUniqueTargetId(browser.get(), value),
                              browser, GetDebugURL(value))),
       browser_(browser),
       debug_url_(GetDebugURL(value)),

[SeRya, 2014/08/29 07:04:41]

Initialized twice.

       remote_id_(GetStringProperty(value, "id")),
+      local_id_(base::IntToString(browser->GetId()) + ":" + remote_id_),
       remote_type_(GetStringProperty(value, "type")) {
   set_type("adb_page");
   set_url(GURL(GetStringProperty(value, "url")));
   set_title(base::UTF16ToUTF8(net::UnescapeForHTML(base::UTF8ToUTF16(
       GetStringProperty(value, "title")))));
   set_description(GetStringProperty(value, "description"));
   set_favicon_url(GURL(GetStringProperty(value, "faviconUrl")));
-  debug_url_ = GetDebugURL(value);
   frontend_url_ = GetStringProperty(value, "devtoolsFrontendUrl");
 
   size_t ws_param = frontend_url_.find("?ws");
   if (ws_param != std::string::npos)
     frontend_url_ = frontend_url_.substr(0, ws_param);
   if (frontend_url_.find("http:") == 0)
     frontend_url_ = "https:" + frontend_url_.substr(5);
 }
 
 RemotePageTarget::~RemotePageTarget() {
 }
 
 DevToolsTargetImpl* RemotePageTarget::GetTarget() {
   return this;
 }
 
 std::string RemotePageTarget::GetFrontendURL() {
   return frontend_url_;
 }
 
 std::string RemotePageTarget::GetId() const {
-  return remote_id_;
+  return local_id_;
 }
 
 bool RemotePageTarget::IsAttached() const {
   return debug_url_.empty();
 }
 
 static void NoOp(int, const std::string&) {}
 
 void RemotePageTarget::Inspect(Profile* profile) const {
   Activate();
@@ skipping 28 matching lines @@
   params.SetString(kUrlParam, url);
   browser_->SendProtocolCommand(debug_url_, kPageNavigateCommand, &params,
                                 callback);
 }
 
 // DevToolsAndroidBridge::RemoteBrowser ---------------------------------------
 
 DevToolsAndroidBridge::RemoteBrowser::RemoteBrowser(
     scoped_refptr<Device> device,
     const AndroidDeviceManager::BrowserInfo& browser_info)
-    : device_(device),
+    : id_(last_remote_browser_id_++),
+      device_(device),
       socket_(browser_info.socket_name),
       display_name_(browser_info.display_name),
       type_(browser_info.type),
       page_descriptors_(new base::ListValue()) {
 }
 
 bool DevToolsAndroidBridge::RemoteBrowser::IsChrome() const {
   return type_ == AndroidDeviceManager::BrowserInfo::kTypeChrome;
 }
 
@@ skipping 352 matching lines @@
   bool enabled;
   if (pref_value->GetAsBoolean(&enabled) && enabled) {
     device_providers.push_back(new UsbDeviceProvider(profile_));
   }
   device_manager_->SetDeviceProviders(device_providers);
   if (!device_list_listeners_.empty()) {
     StopDeviceListPolling();
     StartDeviceListPolling();
   }
 }