Home | History | Annotate | Download | only in device 
      1 // Copyright 2014 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #ifndef CHROME_BROWSER_DEVTOOLS_DEVICE_DEVTOOLS_ANDROID_BRIDGE_H_
      6 #define CHROME_BROWSER_DEVTOOLS_DEVICE_DEVTOOLS_ANDROID_BRIDGE_H_
      7 
      8 #include <string>
      9 #include <vector>
     10 
     11 #include "base/callback.h"
     12 #include "base/cancelable_callback.h"
     13 #include "base/memory/ref_counted.h"
     14 #include "base/memory/scoped_ptr.h"
     15 #include "base/prefs/pref_change_registrar.h"
     16 #include "chrome/browser/devtools/device/android_device_manager.h"
     17 #include "components/keyed_service/content/browser_context_keyed_service_factory.h"
     18 #include "components/keyed_service/core/keyed_service.h"
     19 #include "content/public/browser/devtools_agent_host.h"
     20 #include "ui/gfx/size.h"
     21 
     22 template<typename T> struct DefaultSingletonTraits;
     23 
     24 namespace base {
     25 class MessageLoop;
     26 class DictionaryValue;
     27 class ListValue;
     28 class Thread;
     29 }
     30 
     31 namespace content {
     32 class BrowserContext;
     33 }
     34 
     35 class DevToolsTargetImpl;
     36 class Profile;
     37 
     38 class DevToolsAndroidBridge
     39     : public base::RefCountedThreadSafe<
     40           DevToolsAndroidBridge,
     41           content::BrowserThread::DeleteOnUIThread> {
     42  public:
     43   typedef base::Callback<void(int result,
     44                               const std::string& response)> Callback;
     45 
     46   class Wrapper : public KeyedService {
     47    public:
     48     explicit Wrapper(content::BrowserContext* context);
     49     virtual ~Wrapper();
     50 
     51     DevToolsAndroidBridge* Get();
     52    private:
     53     scoped_refptr<DevToolsAndroidBridge> bridge_;
     54   };
     55 
     56   class Factory : public BrowserContextKeyedServiceFactory {
     57    public:
     58     // Returns singleton instance of DevToolsAndroidBridge.
     59     static Factory* GetInstance();
     60 
     61     // Returns DevToolsAndroidBridge associated with |profile|.
     62     static DevToolsAndroidBridge* GetForProfile(Profile* profile);
     63 
     64    private:
     65     friend struct DefaultSingletonTraits<Factory>;
     66 
     67     Factory();
     68     virtual ~Factory();
     69 
     70     // BrowserContextKeyedServiceFactory overrides:
     71     virtual KeyedService* BuildServiceInstanceFor(
     72         content::BrowserContext* context) const OVERRIDE;
     73     DISALLOW_COPY_AND_ASSIGN(Factory);
     74   };
     75 
     76   class RemotePage {
     77    public:
     78     virtual ~RemotePage() {}
     79     virtual DevToolsTargetImpl* GetTarget() = 0;
     80     virtual std::string GetFrontendURL() = 0;
     81   };
     82 
     83   typedef base::Callback<void(RemotePage*)> RemotePageCallback;
     84   typedef base::Callback<void(int, const std::string&)> JsonRequestCallback;
     85   typedef AndroidDeviceManager::Device Device;
     86   typedef AndroidDeviceManager::AndroidWebSocket AndroidWebSocket;
     87 
     88   class RemoteBrowser : public base::RefCounted<RemoteBrowser> {
     89    public:
     90     RemoteBrowser(scoped_refptr<Device> device,
     91                   const AndroidDeviceManager::BrowserInfo& browser_info);
     92 
     93     std::string serial() { return device_->serial(); }
     94     std::string socket() { return socket_; }
     95 
     96     std::string display_name() { return display_name_; }
     97     void set_display_name(const std::string& name) { display_name_ = name; }
     98 
     99     std::string version() { return version_; }
    100     void set_version(const std::string& version) { version_ = version; }
    101 
    102     bool IsChrome() const;
    103     bool IsWebView() const;
    104 
    105     typedef std::vector<int> ParsedVersion;
    106     ParsedVersion GetParsedVersion() const;
    107 
    108     std::vector<RemotePage*> CreatePages();
    109     void SetPageDescriptors(const base::ListValue&);
    110 
    111     void SendJsonRequest(const std::string& request,
    112                          const JsonRequestCallback& callback);
    113 
    114     void SendProtocolCommand(const std::string& debug_url,
    115                              const std::string& method,
    116                              base::DictionaryValue* params,
    117                              const base::Closure callback);
    118 
    119     void Open(const std::string& url,
    120               const RemotePageCallback& callback);
    121 
    122     scoped_refptr<content::DevToolsAgentHost> GetAgentHost();
    123 
    124     scoped_refptr<AndroidWebSocket> CreateWebSocket(
    125         const std::string& url,
    126         DevToolsAndroidBridge::AndroidWebSocket::Delegate* delegate);
    127 
    128    private:
    129     friend class base::RefCounted<RemoteBrowser>;
    130     virtual ~RemoteBrowser();
    131 
    132     void InnerOpen(const std::string& url,
    133                    const JsonRequestCallback& callback);
    134 
    135     void PageCreatedOnUIThread(
    136         const JsonRequestCallback& callback,
    137         const std::string& url, int result, const std::string& response);
    138 
    139     void NavigatePageOnUIThread(const JsonRequestCallback& callback,
    140         int result,
    141         const std::string& response,
    142         const std::string& url);
    143 
    144     void RespondToOpenOnUIThread(
    145         const DevToolsAndroidBridge::RemotePageCallback& callback,
    146         int result,
    147         const std::string& response);
    148 
    149     scoped_refptr<Device> device_;
    150     const std::string socket_;
    151     std::string display_name_;
    152     const AndroidDeviceManager::BrowserInfo::Type type_;
    153     std::string version_;
    154     scoped_ptr<base::ListValue> page_descriptors_;
    155 
    156     DISALLOW_COPY_AND_ASSIGN(RemoteBrowser);
    157   };
    158 
    159   typedef std::vector<scoped_refptr<RemoteBrowser> > RemoteBrowsers;
    160 
    161   class RemoteDevice : public base::RefCounted<RemoteDevice> {
    162    public:
    163     RemoteDevice(scoped_refptr<Device> device,
    164                  const AndroidDeviceManager::DeviceInfo& device_info);
    165 
    166     std::string serial() { return device_->serial(); }
    167     std::string model() { return model_; }
    168     bool is_connected() { return connected_; }
    169     RemoteBrowsers& browsers() { return browsers_; }
    170     gfx::Size screen_size() { return screen_size_; }
    171 
    172     void OpenSocket(const std::string& socket_name,
    173                     const AndroidDeviceManager::SocketCallback& callback);
    174 
    175    private:
    176     friend class base::RefCounted<RemoteDevice>;
    177     virtual ~RemoteDevice();
    178 
    179     scoped_refptr<Device> device_;
    180     std::string model_;
    181     bool connected_;
    182     RemoteBrowsers browsers_;
    183     gfx::Size screen_size_;
    184 
    185     DISALLOW_COPY_AND_ASSIGN(RemoteDevice);
    186   };
    187 
    188   typedef std::vector<scoped_refptr<RemoteDevice> > RemoteDevices;
    189 
    190   class DeviceListListener {
    191    public:
    192     virtual void DeviceListChanged(const RemoteDevices& devices) = 0;
    193    protected:
    194     virtual ~DeviceListListener() {}
    195   };
    196 
    197   explicit DevToolsAndroidBridge(Profile* profile);
    198   void AddDeviceListListener(DeviceListListener* listener);
    199   void RemoveDeviceListListener(DeviceListListener* listener);
    200 
    201   class DeviceCountListener {
    202    public:
    203     virtual void DeviceCountChanged(int count) = 0;
    204    protected:
    205     virtual ~DeviceCountListener() {}
    206   };
    207 
    208   void AddDeviceCountListener(DeviceCountListener* listener);
    209   void RemoveDeviceCountListener(DeviceCountListener* listener);
    210 
    211   void set_device_providers_for_test(
    212       const AndroidDeviceManager::DeviceProviders& device_providers) {
    213     device_manager_->SetDeviceProviders(device_providers);
    214   }
    215 
    216   void set_task_scheduler_for_test(
    217       base::Callback<void(const base::Closure&)> scheduler) {
    218     task_scheduler_ = scheduler;
    219   }
    220 
    221   static bool HasDevToolsWindow(const std::string& agent_id);
    222 
    223  private:
    224   friend struct content::BrowserThread::DeleteOnThread<
    225       content::BrowserThread::UI>;
    226   friend class base::DeleteHelper<DevToolsAndroidBridge>;
    227 
    228   virtual ~DevToolsAndroidBridge();
    229 
    230   void StartDeviceListPolling();
    231   void StopDeviceListPolling();
    232   void RequestDeviceList(
    233       const base::Callback<void(const RemoteDevices&)>& callback);
    234   void ReceivedDeviceList(const RemoteDevices& devices);
    235   void StartDeviceCountPolling();
    236   void StopDeviceCountPolling();
    237   void RequestDeviceCount(const base::Callback<void(int)>& callback);
    238   void ReceivedDeviceCount(int count);
    239 
    240   static void ScheduleTaskDefault(const base::Closure& task);
    241 
    242   void CreateDeviceProviders();
    243 
    244   Profile* profile_;
    245   scoped_refptr<AndroidDeviceManager> device_manager_;
    246   RemoteDevices devices_;
    247 
    248   typedef std::vector<DeviceListListener*> DeviceListListeners;
    249   DeviceListListeners device_list_listeners_;
    250   base::CancelableCallback<void(const RemoteDevices&)> device_list_callback_;
    251 
    252   typedef std::vector<DeviceCountListener*> DeviceCountListeners;
    253   DeviceCountListeners device_count_listeners_;
    254   base::CancelableCallback<void(int)> device_count_callback_;
    255   base::Callback<void(const base::Closure&)> task_scheduler_;
    256 
    257   PrefChangeRegistrar pref_change_registrar_;
    258   DISALLOW_COPY_AND_ASSIGN(DevToolsAndroidBridge);
    259 };
    260 
    261 #endif  // CHROME_BROWSER_DEVTOOLS_DEVICE_DEVTOOLS_ANDROID_BRIDGE_H_
    262