DevTools: Partially redesigned DevToolsAndroidBridge and AndroidDeviceManager

chrome/browser/devtools/device/android_device_manager.h

Index: chrome/browser/devtools/device/android_device_manager.h
diff --git a/chrome/browser/devtools/device/android_device_manager.h b/chrome/browser/devtools/device/android_device_manager.h
index 27d1be809fa069e1330fe6e33d15bb07e2ef3fd4..a57a60993ad2d35121f238c440f033ea1d382c42 100644
--- a/chrome/browser/devtools/device/android_device_manager.h
+++ b/chrome/browser/devtools/device/android_device_manager.h
@@ -23,6 +23,7 @@ class AndroidDeviceManager
  public:
   typedef base::Callback<void(int, const std::string&)> CommandCallback;
   typedef base::Callback<void(int result, net::StreamSocket*)> SocketCallback;
+  typedef base::Callback<void(const std::vector<std::string>&)> SerialsCallback;
 
   struct BrowserInfo {
     BrowserInfo();
@@ -43,117 +44,147 @@ class AndroidDeviceManager
     ~DeviceInfo();
 
     std::string model;
+    bool connected;
     gfx::Size screen_size;
     std::vector<BrowserInfo> browser_info;
   };
 
   typedef base::Callback<void(const DeviceInfo&)> DeviceInfoCallback;
 
-  class Device : public base::RefCounted<Device>,
-                 public base::NonThreadSafe {
-   protected:
-    friend class AndroidDeviceManager;
-
-    typedef AndroidDeviceManager::CommandCallback CommandCallback;
-    typedef AndroidDeviceManager::SocketCallback SocketCallback;
+  class DeviceProvider : public base::RefCountedThreadSafe<DeviceProvider> {
+   public:
+    typedef AndroidDeviceManager::SerialsCallback SerialsCallback;
     typedef AndroidDeviceManager::DeviceInfoCallback DeviceInfoCallback;
+    typedef AndroidDeviceManager::SocketCallback SocketCallback;
+    typedef AndroidDeviceManager::CommandCallback CommandCallback;
 
-    Device(const std::string& serial, bool is_connected);
+    virtual void QueryDevices(const SerialsCallback& callback) = 0;
 
-    virtual void QueryDeviceInfo(const DeviceInfoCallback& callback) = 0;
+    virtual void QueryDeviceInfo(const std::string& serial,
+                                 const DeviceInfoCallback& callback) = 0;
 
-    virtual void OpenSocket(const std::string& socket_name,
+    virtual void OpenSocket(const std::string& serial,
+                            const std::string& socket_name,
                             const SocketCallback& callback) = 0;
 
-    virtual void HttpQuery(const std::string& socket_name,
-                           const std::string& request,
-                           const CommandCallback& callback);
+    virtual void SendJsonRequest(const std::string& serial,
+                                 const std::string& socket_name,
+                                 const std::string& request,
+                                 const CommandCallback& callback);
 
-    std::string serial() { return serial_; }
-    bool is_connected() { return is_connected_; }
+    virtual void HttpUpgrade(const std::string& serial,
+                             const std::string& socket_name,
+                             const std::string& url,
+                             const SocketCallback& callback);
 
-    friend class base::RefCounted<Device>;
-    virtual ~Device();
+    virtual void ReleaseDevice(const std::string& serial);
 
-   private:
-    const std::string serial_;
-    const bool is_connected_;
-
-    DISALLOW_COPY_AND_ASSIGN(Device);
+   protected:
+    friend class base::RefCountedThreadSafe<DeviceProvider>;
+    DeviceProvider();
+    virtual ~DeviceProvider();
   };
 
-  typedef std::vector<scoped_refptr<Device> > Devices;
+  typedef std::vector<scoped_refptr<DeviceProvider> > DeviceProviders;
 
-  class DeviceProvider
-      : public base::RefCountedThreadSafe<
-            DeviceProvider,
-            content::BrowserThread::DeleteOnUIThread> {
-   protected:
-    friend class AndroidDeviceManager;
+  class AndroidWebSocket : public base::RefCountedThreadSafe<AndroidWebSocket> {
+   public:
+    class Delegate {
+     public:
+      virtual void OnSocketOpened() = 0;
+      virtual void OnFrameRead(const std::string& message) = 0;
+      virtual void OnSocketClosed(bool closed_by_device) = 0;
 
-    typedef base::Callback<void(const Devices&)> QueryDevicesCallback;
+     protected:
+      virtual ~Delegate() {}
+    };
 
-    virtual void QueryDevices(const QueryDevicesCallback& callback) = 0;
+    AndroidWebSocket() {}
+
+    virtual void Connect() = 0;
+    virtual void Disconnect() = 0;
+    virtual void SendFrame(const std::string& message) = 0;
 
    protected:
-    friend struct
-        content::BrowserThread::DeleteOnThread<content::BrowserThread::UI>;
-    friend class base::DeleteHelper<DeviceProvider>;
+    virtual ~AndroidWebSocket() {}
 
-    DeviceProvider();
-    virtual ~DeviceProvider();
+   private:
+    friend class base::RefCountedThreadSafe<AndroidWebSocket>;
+
+    DISALLOW_COPY_AND_ASSIGN(AndroidWebSocket);
   };
 
- public:
-  static scoped_refptr<AndroidDeviceManager> Create();
+  class Device : public base::RefCountedThreadSafe<Device>,

[pfeldman, 2014/05/26 09:57:14]

Lets swap them back for better diff.

[vkuzkokov, 2014/05/26 10:54:03]

Done.

+                 public base::NonThreadSafe {
+   public:
+    typedef AndroidDeviceManager::DeviceInfoCallback DeviceInfoCallback;
+    typedef AndroidDeviceManager::CommandCallback CommandCallback;
+    typedef AndroidDeviceManager::SocketCallback SocketCallback;
 
-  typedef std::vector<scoped_refptr<DeviceProvider> > DeviceProviders;
-  typedef base::Callback<void (const std::vector<std::string>&)>
-      QueryDevicesCallback;
+    void QueryDeviceInfo(const DeviceInfoCallback& callback);
 
-  void QueryDevices(const DeviceProviders& providers,
-                    const QueryDevicesCallback& callback);
+    void OpenSocket(const std::string& socket_name,
+                    const SocketCallback& callback);
 
-  void Stop();
+    void SendJsonRequest(const std::string& socket_name,
+                         const std::string& request,
+                         const CommandCallback& callback);
 
-  bool IsConnected(const std::string& serial);
+    void HttpUpgrade(const std::string& socket_name,
+                     const std::string& url,
+                     const SocketCallback& callback);
 
-  void QueryDeviceInfo(const std::string& serial,
-                       const DeviceInfoCallback& callback);
+    scoped_refptr<AndroidWebSocket> CreateWebSocket(
+        const std::string& socket_name,
+        const std::string& url,
+        AndroidWebSocket::Delegate* delegate);
 
-  void OpenSocket(const std::string& serial,
-                  const std::string& socket_name,
-                  const SocketCallback& callback);
+    std::string serial() { return serial_; }
 
-  void HttpQuery(const std::string& serial,
-                 const std::string& socket_name,
-                 const std::string& request,
-                 const CommandCallback& callback);
+   private:
+    friend class AndroidDeviceManager;
+    Device(scoped_refptr<base::MessageLoopProxy> device_message_loop,
+           const scoped_refptr<DeviceProvider>& provider,
+           const std::string& serial);
 
-  void HttpUpgrade(const std::string& serial,
-                   const std::string& socket_name,
-                   const std::string& url,
-                   const SocketCallback& callback);
+    friend class base::RefCountedThreadSafe<Device>;
+    virtual ~Device();
 
- private:
-  AndroidDeviceManager();
+    scoped_refptr<base::MessageLoopProxy> device_message_loop_;
+    scoped_refptr<DeviceProvider> provider_;

[pfeldman, 2014/05/26 09:57:14]

On what thread will this be released?

[vkuzkokov, 2014/05/26 10:54:03]

UI. Same way as in DevToolsAndroidBridge. It does seem dodgy though.

+    std::string serial_;
+    base::WeakPtrFactory<Device> weak_factory_;
 
-  friend class base::RefCountedThreadSafe<AndroidDeviceManager>;
+    DISALLOW_COPY_AND_ASSIGN(Device);
+  };
 
-  virtual ~AndroidDeviceManager();
+  typedef std::vector<scoped_refptr<Device> > Devices;
+  typedef base::Callback<void(const Devices&)> DevicesCallback;
 
-  void QueryNextProvider(
-      const QueryDevicesCallback& callback,
-      const DeviceProviders& providers,
-      const Devices& total_devices,
-      const Devices& new_devices);
+  static scoped_refptr<AndroidDeviceManager> Create();
+
+  void QueryDevices(scoped_refptr<base::MessageLoopProxy> device_message_loop,
+                    const DeviceProviders& providers,
+                    const DevicesCallback& callback);
 
-  Device* FindDevice(const std::string& serial);
+  struct DeviceDescriptor {
+    scoped_refptr<DeviceProvider> provider;
+    std::string serial;
+  };
+
+  typedef std::vector<DeviceDescriptor> DeviceDescriptors;
+
+ private:
+  friend class base::RefCountedThreadSafe<AndroidDeviceManager>;
+  AndroidDeviceManager();
+  virtual ~AndroidDeviceManager();
 
-  typedef std::map<std::string, scoped_refptr<Device> > DeviceMap;
-  DeviceMap devices_;
+  void UpdateDevices(scoped_refptr<base::MessageLoopProxy> device_message_loop,
+                     const DevicesCallback& callback,
+                     const DeviceDescriptors& descriptors);
 
-  bool stopped_;
+  typedef std::map<std::string, base::WeakPtr<Device> > DeviceWeakMap;
+  DeviceWeakMap devices_;
 };
 
 #endif  // CHROME_BROWSER_DEVTOOLS_DEVICE_ANDROID_DEVICE_MANAGER_H_