DevTools: Split RemotePage and RemotePageTarget

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 53 matching lines @@
 
     Factory();
     virtual ~Factory();
 
     // BrowserContextKeyedServiceFactory overrides:
     virtual KeyedService* BuildServiceInstanceFor(
         content::BrowserContext* context) const override;
     DISALLOW_COPY_AND_ASSIGN(Factory);
   };
 
-  class RemotePage {
+  typedef std::pair<std::string, std::string> BrowserId;
+
+  class RemotePage : public base::RefCounted<RemotePage> {
    public:
-    virtual ~RemotePage() {}
-    virtual DevToolsTargetImpl* GetTarget() = 0;
-    virtual std::string GetFrontendURL() = 0;
+    const std::string& serial() { return browser_id_.first; }
+    const std::string& socket() { return browser_id_.second; }
+    const std::string& frontend_url() { return frontend_url_; }
+    const base::DictionaryValue& dict();

[dgozman, 2014/10/15 14:53:12]

I think we should move this to private.

[vkuzkokov, 2014/10/15 15:24:19]

Removed.

+    bool is_web_view() { return is_web_view_; }
+
+   private:
+    friend class base::RefCounted<RemotePage>;
+    friend class DevToolsAndroidBridge;
+
+    RemotePage(const BrowserId& browser_id,
+               const base::DictionaryValue& dict,
+               bool is_web_view);
+
+    virtual ~RemotePage();
+
+    BrowserId browser_id_;
+    std::string frontend_url_;
+    bool is_web_view_;
+    scoped_ptr<base::DictionaryValue> dict_;
+
+    DISALLOW_COPY_AND_ASSIGN(RemotePage);
   };
 
+  typedef std::vector<scoped_refptr<RemotePage> > RemotePages;
   typedef base::Callback<void(int, const std::string&)> JsonRequestCallback;
 
   class RemoteBrowser : public base::RefCounted<RemoteBrowser> {
    public:
-    const std::string& serial() { return serial_; }
-    const std::string& socket() { return socket_; }
+    const std::string& serial() { return browser_id_.first; }
+    const std::string& socket() { return browser_id_.second; }
     const std::string& display_name() { return display_name_; }
     const std::string& version() { return version_; }
+    const RemotePages& pages() { return pages_; }
 
     bool IsChrome();
     bool IsWebView();
 
     typedef std::vector<int> ParsedVersion;
     ParsedVersion GetParsedVersion();
 
-    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();
 
-    std::string serial_;
-    const std::string socket_;
+    BrowserId browser_id_;
     std::string display_name_;
-    const AndroidDeviceManager::BrowserInfo::Type type_;
+    AndroidDeviceManager::BrowserInfo::Type type_;
     std::string version_;
-    scoped_ptr<base::ListValue> page_descriptors_;
+    RemotePages pages_;
 
     DISALLOW_COPY_AND_ASSIGN(RemoteBrowser);
   };
 
   typedef std::vector<scoped_refptr<RemoteBrowser> > RemoteBrowsers;
 
   class RemoteDevice : public base::RefCounted<RemoteDevice> {
    public:
     std::string serial() { return serial_; }
     std::string model() { return model_; }
@@ skipping 67 matching lines @@
     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);
 
-  std::vector<RemotePage*> CreatePages(scoped_refptr<RemoteBrowser> browser);
+  // Creates new target instance owned by caller.
+  DevToolsTargetImpl* CreatePageTarget(scoped_refptr<RemotePage> browser);
 
-  typedef base::Callback<void(RemotePage*)> RemotePageCallback;
+  typedef base::Callback<void(scoped_refptr<RemotePage>)> RemotePageCallback;
   void OpenRemotePage(scoped_refptr<RemoteBrowser> browser,
                       const std::string& url,
                       const RemotePageCallback& callback);
 
   scoped_refptr<content::DevToolsAgentHost> GetBrowserAgentHost(
       scoped_refptr<RemoteBrowser> browser);
 
   typedef std::pair<scoped_refptr<AndroidDeviceManager::Device>,
                     scoped_refptr<RemoteDevice>> CompleteDevice;
   typedef std::vector<CompleteDevice> CompleteDevices;
@@ skipping 20 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(scoped_refptr<RemoteBrowser> browser,
+  void SendJsonRequest(const BrowserId& browser_id,
                        const std::string& url,
                        const JsonRequestCallback& callback);
 
-  void SendProtocolCommand(scoped_refptr<RemoteBrowser> browser,
+  void SendProtocolCommand(const BrowserId& browser_id,
                            const std::string& debug_url,
                            const std::string& method,
                            base::DictionaryValue* params,
                            const base::Closure callback);
 
   AndroidDeviceManager::AndroidWebSocket* CreateWebSocket(
-      scoped_refptr<RemoteBrowser> browser,
+      const BrowserId& browser_id,
       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,
@@ skipping 28 matching lines @@
 
   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_