DevTools: RemoteDevice and RemoteBrowser are now value types

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 <string>
 #include <vector>
 
@@ skipping 23 matching lines @@
 
 class DevToolsTargetImpl;
 class PortForwardingController;
 class Profile;
 
 class DevToolsAndroidBridge
     : public base::RefCountedThreadSafe<
           DevToolsAndroidBridge,
           content::BrowserThread::DeleteOnUIThread> {
  public:
-  typedef base::Callback<void(int result,
-                              const std::string& response)> Callback;
-
   class Wrapper : public KeyedService {
    public:
     explicit Wrapper(content::BrowserContext* context);
     virtual ~Wrapper();
 
     DevToolsAndroidBridge* Get();
    private:
     scoped_refptr<DevToolsAndroidBridge> bridge_;
   };
 
@@ skipping 17 matching lines @@
     DISALLOW_COPY_AND_ASSIGN(Factory);
   };
 
   class RemotePage {
    public:
     virtual ~RemotePage() {}
     virtual DevToolsTargetImpl* GetTarget() = 0;
     virtual std::string GetFrontendURL() = 0;
   };
 
-  typedef base::Callback<void(RemotePage*)> RemotePageCallback;
   typedef base::Callback<void(int, const std::string&)> JsonRequestCallback;
-  typedef AndroidDeviceManager::Device Device;
-  typedef AndroidDeviceManager::AndroidWebSocket AndroidWebSocket;
 
   class RemoteBrowser : public base::RefCounted<RemoteBrowser> {
    public:
-    RemoteBrowser(scoped_refptr<Device> device,
-                  const AndroidDeviceManager::BrowserInfo& browser_info);
+    const std::string& serial() { return serial_; }
+    const std::string& socket() { return socket_; }
+    const std::string& display_name() { return display_name_; }
+    const std::string& version() { return version_; }
 
-    std::string serial() { return device_->serial(); }
-    std::string socket() { return socket_; }
-
-    std::string display_name() { return display_name_; }
-    void set_display_name(const std::string& name) { display_name_ = name; }
-
-    std::string version() { return version_; }
-    void set_version(const std::string& version) { version_ = version; }
-
-    bool IsChrome() const;
-    bool IsWebView() const;
+    bool IsChrome();
+    bool IsWebView();
 
     typedef std::vector<int> ParsedVersion;
-    ParsedVersion GetParsedVersion() const;
+    ParsedVersion GetParsedVersion();
 
-    std::vector<RemotePage*> CreatePages();
-    void SetPageDescriptors(const base::ListValue&);
-
-    void SendJsonRequest(const std::string& request,
-                         const JsonRequestCallback& callback);
-
-    void SendProtocolCommand(const std::string& debug_url,
-                             const std::string& method,
-                             base::DictionaryValue* params,
-                             const base::Closure callback);
-
-    void Open(const std::string& url,
-              const RemotePageCallback& callback);
-
-    scoped_refptr<content::DevToolsAgentHost> GetAgentHost();
-
-    AndroidWebSocket* CreateWebSocket(
-        const std::string& url,
-        DevToolsAndroidBridge::AndroidWebSocket::Delegate* delegate);
+    const base::ListValue& page_descriptors();
 
    private:
     friend class base::RefCounted<RemoteBrowser>;
+    friend class DevToolsAndroidBridge;
+
+    RemoteBrowser(const std::string& serial,
+                  const AndroidDeviceManager::BrowserInfo& browser_info);
+
     virtual ~RemoteBrowser();
 
-    void InnerOpen(const std::string& url,
-                   const JsonRequestCallback& callback);
-
-    void PageCreatedOnUIThread(
-        const JsonRequestCallback& callback,
-        const std::string& url, int result, const std::string& response);
-
-    void NavigatePageOnUIThread(const JsonRequestCallback& callback,
-        int result,
-        const std::string& response,
-        const std::string& url);
-
-    void RespondToOpenOnUIThread(
-        const DevToolsAndroidBridge::RemotePageCallback& callback,
-        int result,
-        const std::string& response);
-
-    scoped_refptr<Device> device_;
+    std::string serial_;
     const std::string socket_;
     std::string display_name_;
     const AndroidDeviceManager::BrowserInfo::Type type_;
     std::string version_;
     scoped_ptr<base::ListValue> page_descriptors_;
 
     DISALLOW_COPY_AND_ASSIGN(RemoteBrowser);
   };
 
   typedef std::vector<scoped_refptr<RemoteBrowser> > RemoteBrowsers;
 
   class RemoteDevice : public base::RefCounted<RemoteDevice> {
    public:
-    RemoteDevice(scoped_refptr<Device> device,
-                 const AndroidDeviceManager::DeviceInfo& device_info);
-
-    std::string serial() { return device_->serial(); }
+    std::string serial() { return serial_; }
     std::string model() { return model_; }
     bool is_connected() { return connected_; }
     RemoteBrowsers& browsers() { return browsers_; }
     gfx::Size screen_size() { return screen_size_; }
 
-    void OpenSocket(const std::string& socket_name,
-                    const AndroidDeviceManager::SocketCallback& callback);
-
    private:
     friend class base::RefCounted<RemoteDevice>;
+    friend class DevToolsAndroidBridge;
+
+    RemoteDevice(const std::string& serial,
+                 const AndroidDeviceManager::DeviceInfo& device_info);
+
     virtual ~RemoteDevice();
 
-    scoped_refptr<Device> device_;
+    std::string serial_;
     std::string model_;
     bool connected_;
     RemoteBrowsers browsers_;
     gfx::Size screen_size_;
 
     DISALLOW_COPY_AND_ASSIGN(RemoteDevice);
   };
 
   typedef std::vector<scoped_refptr<RemoteDevice> > RemoteDevices;
 
@@ skipping 38 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;
   }
 
-  static bool HasDevToolsWindow(const std::string& agent_id);
+  bool HasDevToolsWindow(const std::string& agent_id);
+
+  std::vector<RemotePage*> CreatePages(scoped_refptr<RemoteBrowser> browser);
+
+  typedef base::Callback<void(RemotePage*)> RemotePageCallback;
+  void Open(scoped_refptr<RemoteBrowser> browser,
+            const std::string& url,
+            const RemotePageCallback& callback);
+
+  scoped_refptr<content::DevToolsAgentHost> GetBrowserAgentHost(
+      scoped_refptr<RemoteBrowser> browser);
 
  private:
   friend struct content::BrowserThread::DeleteOnThread<
       content::BrowserThread::UI>;
   friend class base::DeleteHelper<DevToolsAndroidBridge>;
+  friend class PortForwardingController;

[dgozman, 2014/10/01 14:27:28]

Why we need this friend?

[vkuzkokov, 2014/10/02 11:35:01]

It uses CreateWebSocket which we now encapsulate within
chrome/browser/devtools/device.

+
+  class AgentHostDelegate;
+  class DiscoveryRequest;
+  class RemotePageTarget;
 
   virtual ~DevToolsAndroidBridge();
 
   void StartDeviceListPolling();
   void StopDeviceListPolling();
   bool NeedsDeviceListPolling();
-  void RequestDeviceList(
-      const base::Callback<void(const RemoteDevices&)>& callback);
-  void ReceivedDeviceList(const RemoteDevices& devices);
+
+  typedef base::Callback<void(const AndroidDeviceManager::Devices&,

[dgozman, 2014/10/01 14:27:28]

All the places which need both ADM::Device and RemoteDevice should use
std::pair<>.

[vkuzkokov, 2014/10/02 11:35:01]

Done.

+                              const RemoteDevices&)> DeviceListCallback;
+  void RequestDeviceList(const DeviceListCallback& callback);
+
+  void ReceivedDeviceList(const AndroidDeviceManager::Devices& devices,
+                          const RemoteDevices& remote_devices);
+
   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(scoped_refptr<RemoteBrowser> browser,
+                       const std::string& url,
+                       const JsonRequestCallback& callback);
+
+  void SendProtocolCommand(scoped_refptr<RemoteBrowser> browser,
+                           const std::string& debug_url,
+                           const std::string& method,
+                           base::DictionaryValue* params,
+                           const base::Closure callback);
+
+  AndroidDeviceManager::AndroidWebSocket* CreateWebSocket(
+      scoped_refptr<RemoteBrowser> browser,
+      const std::string& url,
+      AndroidDeviceManager::AndroidWebSocket::Delegate* delegate);
+
+  void PageCreatedOnUIThread(scoped_refptr<RemoteBrowser> browser,
+                             const RemotePageCallback& callback,
+                             const std::string& url,
+                             int result,
+                             const std::string& response);
+
+  void NavigatePageOnUIThread(scoped_refptr<RemoteBrowser> browser,
+                              const RemotePageCallback& callback,
+                              int result,
+                              const std::string& response,
+                              const std::string& url);
+
+  void RespondToOpenOnUIThread(scoped_refptr<RemoteBrowser> browser,
+                               const RemotePageCallback& callback,
+                               int result,
+                               const std::string& response);
+
   Profile* profile_;
   scoped_refptr<AndroidDeviceManager> device_manager_;
-  RemoteDevices devices_;
+
+  typedef std::map<std::string, scoped_refptr<AndroidDeviceManager::Device>>
+      DeviceMap;
+  DeviceMap device_map_;
+
+  typedef std::map<std::string, AgentHostDelegate*> AgentHostDelegates;
+  AgentHostDelegates host_delegates_;
 
   typedef std::vector<DeviceListListener*> DeviceListListeners;
   DeviceListListeners device_list_listeners_;
-  base::CancelableCallback<void(const RemoteDevices&)> device_list_callback_;
+  base::CancelableCallback<void(const AndroidDeviceManager::Devices&,
+                                const RemoteDevices&)> device_list_callback_;
 
   typedef std::vector<DeviceCountListener*> DeviceCountListeners;
   DeviceCountListeners device_count_listeners_;
   base::CancelableCallback<void(int)> device_count_callback_;
   base::Callback<void(const base::Closure&)> task_scheduler_;
 
   typedef std::vector<PortForwardingListener*> PortForwardingListeners;
   PortForwardingListeners port_forwarding_listeners_;
   scoped_ptr<PortForwardingController> port_forwarding_controller_;
 
   PrefChangeRegistrar pref_change_registrar_;
   DISALLOW_COPY_AND_ASSIGN(DevToolsAndroidBridge);
 };
 
 #endif  // CHROME_BROWSER_DEVTOOLS_DEVICE_DEVTOOLS_ANDROID_BRIDGE_H_