DevTools: untangle device discovery request from the devtools android bridge.

chrome/browser/devtools/device/devtools_android_bridge.h

 // 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.
 
 #ifndef CHROME_BROWSER_DEVTOOLS_DEVICE_DEVTOOLS_ANDROID_BRIDGE_H_
 #define CHROME_BROWSER_DEVTOOLS_DEVICE_DEVTOOLS_ANDROID_BRIDGE_H_
 
 #include <memory>
 #include <string>
 #include <vector>
@@ skipping 42 matching lines @@
 
     Factory();
     ~Factory() override;
 
     // BrowserContextKeyedServiceFactory overrides:
     KeyedService* BuildServiceInstanceFor(
         content::BrowserContext* context) const override;
     DISALLOW_COPY_AND_ASSIGN(Factory);
   };
 
-  using BrowserId = std::pair<std::string, std::string>;
-
   class RemotePage : public base::RefCounted<RemotePage> {
    public:
-    const std::string& serial() { return browser_id_.first; }
-    const std::string& socket() { return browser_id_.second; }
+    scoped_refptr<AndroidDeviceManager::Device> device() { return device_; }
+    const std::string& socket() { return browser_id_; }
     const std::string& frontend_url() { return frontend_url_; }
+    scoped_refptr<content::DevToolsAgentHost> CreateTarget();
 
    private:
     friend class base::RefCounted<RemotePage>;
     friend class DevToolsAndroidBridge;
 
-    RemotePage(const BrowserId& browser_id, const base::DictionaryValue& dict);
+    RemotePage(scoped_refptr<AndroidDeviceManager::Device> device,
+               const std::string& browser_id,
+               const base::DictionaryValue& dict);
 
     virtual ~RemotePage();
 
-    BrowserId browser_id_;
+    scoped_refptr<AndroidDeviceManager::Device> device_;

[dgozman, 2016/09/22 17:13:59]

Now everyone retains the device?

+    std::string browser_id_;
     std::string frontend_url_;
     std::unique_ptr<base::DictionaryValue> dict_;
 
     DISALLOW_COPY_AND_ASSIGN(RemotePage);
   };
 
   using RemotePages = std::vector<scoped_refptr<RemotePage> >;
   using JsonRequestCallback = base::Callback<void(int, const std::string&)>;
 
   class RemoteBrowser : public base::RefCounted<RemoteBrowser> {
    public:
-    const std::string& serial() { return browser_id_.first; }
-    const std::string& socket() { return browser_id_.second; }
+    const std::string& serial() { return serial_; }
+    const std::string& socket() { return browser_id_; }
     const std::string& display_name() { return display_name_; }
     const std::string& user() { return user_; }
     const std::string& version() { return version_; }
     const RemotePages& pages() { return pages_; }
 
     bool IsChrome();
     std::string GetId();
 
     using ParsedVersion = std::vector<int>;
     ParsedVersion GetParsedVersion();
 
    private:
     friend class base::RefCounted<RemoteBrowser>;
     friend class DevToolsAndroidBridge;
 
     RemoteBrowser(const std::string& serial,
                   const AndroidDeviceManager::BrowserInfo& browser_info);
 
     virtual ~RemoteBrowser();
 
-    BrowserId browser_id_;
+    std::string serial_;
+    std::string browser_id_;
     std::string display_name_;
     std::string user_;
     AndroidDeviceManager::BrowserInfo::Type type_;
     std::string version_;
     RemotePages pages_;
 
     DISALLOW_COPY_AND_ASSIGN(RemoteBrowser);
   };
 
   using RemoteBrowsers = std::vector<scoped_refptr<RemoteBrowser> >;
@@ skipping 69 matching lines @@
   void set_device_providers_for_test(
       const AndroidDeviceManager::DeviceProviders& device_providers) {
     device_manager_->SetDeviceProviders(device_providers);
   }
 
   void set_task_scheduler_for_test(
       base::Callback<void(const base::Closure&)> scheduler) {
     task_scheduler_ = scheduler;
   }
 
-  bool HasDevToolsWindow(const std::string& agent_id);
-
-  // Creates new target instance owned by caller.
-  scoped_refptr<content::DevToolsAgentHost>
-  CreatePageTarget(scoped_refptr<RemotePage> browser);
-
   using RemotePageCallback = base::Callback<void(scoped_refptr<RemotePage>)>;
   void OpenRemotePage(scoped_refptr<RemoteBrowser> browser,
                       const std::string& url);
 
   scoped_refptr<content::DevToolsAgentHost> GetBrowserAgentHost(
       scoped_refptr<RemoteBrowser> browser);
 
   void SendJsonRequest(const std::string& browser_id_str,
                        const std::string& url,
                        const JsonRequestCallback& callback);
@@ skipping 27 matching lines @@
 
   void StartDeviceCountPolling();
   void StopDeviceCountPolling();
   void RequestDeviceCount(const base::Callback<void(int)>& callback);
   void ReceivedDeviceCount(int count);
 
   static void ScheduleTaskDefault(const base::Closure& task);
 
   void CreateDeviceProviders();
 
-  void SendJsonRequest(const BrowserId& browser_id,
-                       const std::string& url,
-                       const JsonRequestCallback& callback);
-
-  void SendProtocolCommand(const BrowserId& browser_id,
-                           const std::string& target_path,
-                           const std::string& method,
-                           std::unique_ptr<base::DictionaryValue> params,
-                           const base::Closure callback);
-
-  AndroidDeviceManager::AndroidWebSocket* CreateWebSocket(
-      const BrowserId& browser_id,
-      const std::string& url,
-      AndroidDeviceManager::AndroidWebSocket::Delegate* delegate);
-
   base::WeakPtr<DevToolsAndroidBridge> AsWeakPtr() {
       return weak_factory_.GetWeakPtr();
   }
 
   Profile* const profile_;
   const std::unique_ptr<AndroidDeviceManager> device_manager_;
 
   using DeviceMap =
       std::map<std::string, scoped_refptr<AndroidDeviceManager::Device> >;
   DeviceMap device_map_;
 
-  using AgentHostDelegates = std::map<std::string, AgentHostDelegate*>;
-  AgentHostDelegates host_delegates_;
-
   using DeviceListListeners = std::vector<DeviceListListener*>;
   DeviceListListeners device_list_listeners_;
   base::CancelableCallback<void(const CompleteDevices&)> device_list_callback_;
 
   using DeviceCountListeners = std::vector<DeviceCountListener*>;
   DeviceCountListeners device_count_listeners_;
   base::CancelableCallback<void(int)> device_count_callback_;
   base::Callback<void(const base::Closure&)> task_scheduler_;
 
   using PortForwardingListeners = std::vector<PortForwardingListener*>;
   PortForwardingListeners port_forwarding_listeners_;
   std::unique_ptr<PortForwardingController> port_forwarding_controller_;
 
   PrefChangeRegistrar pref_change_registrar_;
 
   TCPProviderCallback tcp_provider_callback_;
 
   base::WeakPtrFactory<DevToolsAndroidBridge> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(DevToolsAndroidBridge);
 };
 
 #endif  // CHROME_BROWSER_DEVTOOLS_DEVICE_DEVTOOLS_ANDROID_BRIDGE_H_