DevTools: Split RemotePage and RemotePageTarget

chrome/browser/devtools/device/devtools_android_bridge.cc

Index: chrome/browser/devtools/device/devtools_android_bridge.cc
diff --git a/chrome/browser/devtools/device/devtools_android_bridge.cc b/chrome/browser/devtools/device/devtools_android_bridge.cc
index 919561ecd28df57bdcde10b50e49915d23442abd..fc440bf988779d1f5b2aaafb10a21204c6271869 100644
--- a/chrome/browser/devtools/device/devtools_android_bridge.cc
+++ b/chrome/browser/devtools/device/devtools_android_bridge.cc
@@ -174,8 +174,16 @@ void DevToolsAndroidBridge::DiscoveryRequest::ReceivedPages(
     return;
   scoped_ptr<base::Value> value(base::JSONReader::Read(response));
   base::ListValue* list_value;
-  if (value && value->GetAsList(&list_value))
-    browser->page_descriptors_.reset(list_value->DeepCopy());
+  if (value && value->GetAsList(&list_value)) {
+    for (base::ListValue::iterator it = list_value->begin();
+        it != list_value->end(); ++it) {
+      base::DictionaryValue* dict;
+      if ((*it)->GetAsDictionary(&dict)) {
+        browser->pages_.push_back(
+            new RemotePage(browser->browser_id_, *dict, browser->IsWebView()));

[dgozman, 2014/09/30 09:23:48]

dict->DeepCopy()

[vkuzkokov, 2014/10/01 09:05:17]

DeepCopy is already called from RemotePage::RemotePage.

+      }
+    }
+  }
 }
 
 // ProtocolCommand ------------------------------------------------------------
@@ -281,15 +289,17 @@ class DevToolsAndroidBridge::AgentHostDelegate
   static scoped_refptr<content::DevToolsAgentHost> GetOrCreateAgentHost(
       scoped_refptr<DevToolsAndroidBridge> bridge,
       const std::string& id,
-      scoped_refptr<RemoteBrowser> browser,
-      const std::string& debug_url);
+      const BrowserId& browser_id,
+      const std::string& debug_url,
+      bool is_web_view);
 
  private:
   AgentHostDelegate(
       scoped_refptr<DevToolsAndroidBridge> bridge,
       const std::string& id,
-      scoped_refptr<RemoteBrowser> browser,
-      const std::string& debug_url);
+      const BrowserId& browser_id,
+      const std::string& debug_url,
+      bool is_web_view);
   virtual ~AgentHostDelegate();
   virtual void Attach(content::DevToolsExternalAgentProxy* proxy) OVERRIDE;
   virtual void Detach() OVERRIDE;
@@ -301,7 +311,7 @@ class DevToolsAndroidBridge::AgentHostDelegate
 
   std::string id_;
   scoped_refptr<DevToolsAndroidBridge> bridge_;
-  scoped_refptr<RemoteBrowser> browser_;
+  BrowserId browser_id_;
   std::string debug_url_;
   bool socket_opened_;
   bool is_web_view_;
@@ -317,15 +327,16 @@ scoped_refptr<content::DevToolsAgentHost>
 DevToolsAndroidBridge::AgentHostDelegate::GetOrCreateAgentHost(
     scoped_refptr<DevToolsAndroidBridge> bridge,
     const std::string& id,
-    scoped_refptr<RemoteBrowser> browser,
-    const std::string& debug_url) {
+    const BrowserId& browser_id,
+    const std::string& debug_url,
+    bool is_web_view) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   AgentHostDelegates::iterator it = bridge->host_delegates_.find(id);
   if (it != bridge->host_delegates_.end())
     return it->second->agent_host_;
 
   AgentHostDelegate* delegate =
-      new AgentHostDelegate(bridge, id, browser, debug_url);
+      new AgentHostDelegate(bridge, id, browser_id, debug_url, is_web_view);
   scoped_refptr<content::DevToolsAgentHost> result =
       content::DevToolsAgentHost::Create(delegate);
   delegate->agent_host_ = result.get();
@@ -335,14 +346,15 @@ DevToolsAndroidBridge::AgentHostDelegate::GetOrCreateAgentHost(
 DevToolsAndroidBridge::AgentHostDelegate::AgentHostDelegate(
     scoped_refptr<DevToolsAndroidBridge> bridge,
     const std::string& id,
-    scoped_refptr<RemoteBrowser> browser,
-    const std::string& debug_url)
+    const BrowserId& browser_id,
+    const std::string& debug_url,
+    bool is_web_view)
     : id_(id),
       bridge_(bridge),
-      browser_(browser),
+      browser_id_(browser_id),
       debug_url_(debug_url),
       socket_opened_(false),
-      is_web_view_(browser->IsWebView()),
+      is_web_view_(is_web_view),
       agent_host_(NULL),
       proxy_(NULL) {
   bridge_->host_delegates_[id] = this;
@@ -358,7 +370,7 @@ void DevToolsAndroidBridge::AgentHostDelegate::Attach(
   content::RecordAction(base::UserMetricsAction(is_web_view_ ?
       "DevTools_InspectAndroidWebView" : "DevTools_InspectAndroidPage"));
   web_socket_.reset(
-      bridge_->CreateWebSocket(browser_, debug_url_, this));
+      bridge_->CreateWebSocket(browser_id_, debug_url_, this));
 }
 
 void DevToolsAndroidBridge::AgentHostDelegate::Detach() {
@@ -395,19 +407,14 @@ void DevToolsAndroidBridge::AgentHostDelegate::OnSocketClosed() {
 
 //// RemotePageTarget ----------------------------------------------
 
-class DevToolsAndroidBridge::RemotePageTarget
-    : public DevToolsTargetImpl,
-      public DevToolsAndroidBridge::RemotePage {
+class DevToolsAndroidBridge::RemotePageTarget : public DevToolsTargetImpl {
  public:
   RemotePageTarget(scoped_refptr<DevToolsAndroidBridge> bridge,
-                   scoped_refptr<RemoteBrowser> browser,
-                   const base::DictionaryValue& value);
+                   const BrowserId& browser_id,
+                   const base::DictionaryValue& value,
+                   bool is_web_view_);
   virtual ~RemotePageTarget();
 
-  // DevToolsAndroidBridge::RemotePage implementation.
-  virtual DevToolsTargetImpl* GetTarget() OVERRIDE;
-  virtual std::string GetFrontendURL() OVERRIDE;
-
   // DevToolsTargetImpl overrides.
   virtual std::string GetId() const OVERRIDE;
   virtual bool IsAttached() const OVERRIDE;
@@ -420,7 +427,7 @@ class DevToolsAndroidBridge::RemotePageTarget
 
  private:
   scoped_refptr<DevToolsAndroidBridge> bridge_;
-  scoped_refptr<RemoteBrowser> browser_;
+  BrowserId browser_id_;
   std::string debug_url_;
   std::string frontend_url_;
   std::string remote_id_;
@@ -437,10 +444,20 @@ static std::string GetStringProperty(const base::DictionaryValue& value,
 }
 
 static std::string BuildUniqueTargetId(
-    DevToolsAndroidBridge::RemoteBrowser* browser,
+    const DevToolsAndroidBridge::BrowserId& browser_id,
     const base::DictionaryValue& value) {
-  return base::StringPrintf("%s:%s:%s", browser->serial().c_str(),
-      browser->socket().c_str(), GetStringProperty(value, "id").c_str());
+  return base::StringPrintf("%s:%s:%s", browser_id.first.c_str(),
+      browser_id.second.c_str(), GetStringProperty(value, "id").c_str());
+}
+
+static std::string GetFrontendURL(const base::DictionaryValue& value) {
+  std::string 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);
+  return frontend_url;
 }
 
 static std::string GetDebugURL(const base::DictionaryValue& value) {
@@ -455,19 +472,22 @@ static std::string GetDebugURL(const base::DictionaryValue& value) {
 
 DevToolsAndroidBridge::RemotePageTarget::RemotePageTarget(
     scoped_refptr<DevToolsAndroidBridge> bridge,
-    scoped_refptr<RemoteBrowser> browser,
-    const base::DictionaryValue& value)
+    const BrowserId& browser_id,
+    const base::DictionaryValue& value,
+    bool is_web_view)
     : DevToolsTargetImpl(AgentHostDelegate::GetOrCreateAgentHost(
                              bridge,
-                             BuildUniqueTargetId(browser.get(), value),
-                             browser,
-                             GetDebugURL(value))),
+                             BuildUniqueTargetId(browser_id, value),
+                             browser_id,
+                             GetDebugURL(value),
+                             is_web_view)),
       bridge_(bridge),
-      browser_(browser),
+      browser_id_(browser_id),
       debug_url_(GetDebugURL(value)),
+      frontend_url_(GetFrontendURL(value)),
       remote_id_(GetStringProperty(value, "id")),
       remote_type_(GetStringProperty(value, "type")),
-      local_id_(BuildUniqueTargetId(browser.get(), value)) {
+      local_id_(BuildUniqueTargetId(browser_id, value)) {
   set_type("adb_page");
   set_url(GURL(GetStringProperty(value, "url")));
   set_title(base::UTF16ToUTF8(net::UnescapeForHTML(base::UTF8ToUTF16(
@@ -475,26 +495,11 @@ DevToolsAndroidBridge::RemotePageTarget::RemotePageTarget(
   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);
 }
 
 DevToolsAndroidBridge::RemotePageTarget::~RemotePageTarget() {
 }
 
-DevToolsTargetImpl* DevToolsAndroidBridge::RemotePageTarget::GetTarget() {
-  return this;
-}
-
-std::string DevToolsAndroidBridge::RemotePageTarget::GetFrontendURL() {
-  return frontend_url_;
-}
-
 std::string DevToolsAndroidBridge::RemotePageTarget::GetId() const {
   return local_id_;
 }
@@ -516,19 +521,19 @@ void DevToolsAndroidBridge::RemotePageTarget::Inspect(Profile* profile) const {
 bool DevToolsAndroidBridge::RemotePageTarget::Activate() const {
   std::string request = base::StringPrintf(kActivatePageRequest,
                                            remote_id_.c_str());
-  bridge_->SendJsonRequest(browser_, request, base::Bind(&NoOp));
+  bridge_->SendJsonRequest(browser_id_, request, base::Bind(&NoOp));
   return true;
 }
 
 bool DevToolsAndroidBridge::RemotePageTarget::Close() const {
   std::string request = base::StringPrintf(kClosePageRequest,
                                            remote_id_.c_str());
-  bridge_->SendJsonRequest(browser_, request, base::Bind(&NoOp));
+  bridge_->SendJsonRequest(browser_id_, request, base::Bind(&NoOp));
   return true;
 }
 
 void DevToolsAndroidBridge::RemotePageTarget::Reload() const {
-  bridge_->SendProtocolCommand(browser_, debug_url_, kPageReloadCommand,
+  bridge_->SendProtocolCommand(browser_id_, debug_url_, kPageReloadCommand,
                                NULL, base::Closure());
 }
 
@@ -537,20 +542,37 @@ void DevToolsAndroidBridge::RemotePageTarget::Navigate(
     base::Closure callback) const {
   base::DictionaryValue params;
   params.SetString(kUrlParam, url);
-  bridge_->SendProtocolCommand(browser_, debug_url_, kPageNavigateCommand,
+  bridge_->SendProtocolCommand(browser_id_, debug_url_, kPageNavigateCommand,
                                &params, callback);
 }
 
+// DevToolsAndroidBridge::RemotePage ------------------------------------------
+
+const base::DictionaryValue& DevToolsAndroidBridge::RemotePage::dict() {
+  return *dict_;
+}
+
+DevToolsAndroidBridge::RemotePage::RemotePage(
+    const BrowserId& browser_id,
+    const base::DictionaryValue& dict,
+    bool is_web_view)
+    : browser_id_(browser_id),
+      frontend_url_(GetFrontendURL(dict)),
+      is_web_view_(is_web_view),
+      dict_(dict.DeepCopy()) {
+}
+
+DevToolsAndroidBridge::RemotePage::~RemotePage() {
+}
+
 // DevToolsAndroidBridge::RemoteBrowser ---------------------------------------
 
 DevToolsAndroidBridge::RemoteBrowser::RemoteBrowser(
     const std::string& serial,
     const AndroidDeviceManager::BrowserInfo& browser_info)
-    : serial_(serial),
-      socket_(browser_info.socket_name),
+    : browser_id_(std::make_pair(serial,browser_info.socket_name)),

[dgozman, 2014/09/30 09:23:48]

nit: space after comma

[vkuzkokov, 2014/10/01 09:05:17]

Done.

       display_name_(browser_info.display_name),
-      type_(browser_info.type),
-      page_descriptors_(new base::ListValue()) {
+      type_(browser_info.type) {
 }
 
 bool DevToolsAndroidBridge::RemoteBrowser::IsChrome() {
@@ -574,37 +596,26 @@ DevToolsAndroidBridge::RemoteBrowser::GetParsedVersion() {
   return result;
 }
 
-std::vector<DevToolsAndroidBridge::RemotePage*>
-DevToolsAndroidBridge::CreatePages(scoped_refptr<RemoteBrowser> browser) {
-  std::vector<RemotePage*> result;
-  for (base::ListValue::const_iterator it = browser->page_descriptors().begin();
-      it != browser->page_descriptors().end(); ++it) {
-    base::DictionaryValue* dict;
-    if (*it && (*it)->GetAsDictionary(&dict))
-      result.push_back(new RemotePageTarget(this, browser, *dict));
-  }
-  return result;
-}
-
-const base::ListValue&
-DevToolsAndroidBridge::RemoteBrowser::page_descriptors() {
-  return *page_descriptors_;
+DevToolsTargetImpl*
+DevToolsAndroidBridge::CreatePageTarget(scoped_refptr<RemotePage> page) {
+  return new RemotePageTarget(this, page->browser_id_, page->dict(),
+                              page->is_web_view_);
 }
 
 void DevToolsAndroidBridge::SendJsonRequest(
-    scoped_refptr<RemoteBrowser> browser,
+    const BrowserId& browser_id,
     const std::string& request,
     const JsonRequestCallback& callback) {
-  DeviceMap::iterator it = device_map_.find(browser->serial());
+  DeviceMap::iterator it = device_map_.find(browser_id.first);
   if (it == device_map_.end()) {
     callback.Run(net::ERR_FAILED, std::string());
     return;
   }
-  it->second->SendJsonRequest(browser->socket(), request, callback);
+  it->second->SendJsonRequest(browser_id.second, request, callback);
 }
 
 void DevToolsAndroidBridge::SendProtocolCommand(
-    scoped_refptr<RemoteBrowser> browser,
+    const BrowserId& browser_id,
     const std::string& debug_url,
     const std::string& method,
     base::DictionaryValue* params,
@@ -612,13 +623,13 @@ void DevToolsAndroidBridge::SendProtocolCommand(
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (debug_url.empty())
     return;
-  DeviceMap::iterator it = device_map_.find(browser->serial());
+  DeviceMap::iterator it = device_map_.find(browser_id.first);
   if (it == device_map_.end()) {
     callback.Run();
     return;
   }
   DevToolsProtocol::Command command(1, method, params);
-  new ProtocolCommand(it->second, browser->socket(), debug_url,
+  new ProtocolCommand(it->second, browser_id.second, debug_url,
                       command.Serialize(), callback);
 }
 
@@ -628,20 +639,21 @@ DevToolsAndroidBridge::GetBrowserAgentHost(
   return AgentHostDelegate::GetOrCreateAgentHost(
       this,
       "adb:" + browser->serial() + ":" + browser->socket(),
-      browser,
-      kBrowserTargetSocket);
+      browser->browser_id_,
+      kBrowserTargetSocket,
+      browser->IsWebView());
 }
 
 AndroidDeviceManager::AndroidWebSocket*
 DevToolsAndroidBridge::CreateWebSocket(
-    scoped_refptr<RemoteBrowser> browser,
+    const BrowserId& browser_id,
     const std::string& url,
     AndroidDeviceManager::AndroidWebSocket::Delegate* delegate) {
-  DeviceMap::iterator it = device_map_.find(browser->serial());
+  DeviceMap::iterator it = device_map_.find(browser_id.first);
   if (it == device_map_.end())
     return NULL;
 
-  return it->second->CreateWebSocket(browser->socket(), url, delegate);
+  return it->second->CreateWebSocket(browser_id.second, url, delegate);
 }
 
 void DevToolsAndroidBridge::RespondToOpenOnUIThread(
@@ -657,7 +669,8 @@ void DevToolsAndroidBridge::RespondToOpenOnUIThread(
   scoped_ptr<base::Value> value(base::JSONReader::Read(response));
   base::DictionaryValue* dict;
   if (value && value->GetAsDictionary(&dict)) {
-    RemotePageTarget* new_page = new RemotePageTarget(this, browser, *dict);
+    RemotePage* new_page =
+        new RemotePage(browser->browser_id_, *dict, browser->IsWebView());
     callback.Run(new_page);
   }
 }
@@ -682,11 +695,11 @@ void DevToolsAndroidBridge::Open(
     std::string query = net::EscapeQueryParamValue(url, false /* use_plus */);
     std::string request =
         base::StringPrintf(kNewPageRequestWithURL, query.c_str());
-    SendJsonRequest(browser, request,
+    SendJsonRequest(browser->browser_id_, request,
                     base::Bind(&DevToolsAndroidBridge::RespondToOpenOnUIThread,
                                this, browser, callback));
   } else {
-    SendJsonRequest(browser, kNewPageRequest,
+    SendJsonRequest(browser->browser_id_, kNewPageRequest,
                     base::Bind(&DevToolsAndroidBridge::PageCreatedOnUIThread,
                                this, browser, callback, url));
   }
@@ -722,7 +735,8 @@ void DevToolsAndroidBridge::NavigatePageOnUIThread(
   base::DictionaryValue* dict;
 
   if (value && value->GetAsDictionary(&dict)) {
-    RemotePageTarget new_page(this, browser, *dict);
+    RemotePageTarget new_page(this, browser->browser_id_, *dict,
+                              browser->IsWebView());
     new_page.Navigate(url,
         base::Bind(&DevToolsAndroidBridge::RespondToOpenOnUIThread,
                    this, browser, callback, result, response));