Enabling WebRTCDeviceProvider under enable-devtools-experiments flag

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 18 matching lines @@
 class Thread;
 }
 
 namespace content {
 class BrowserContext;
 }
 
 class DevToolsTargetImpl;
 class PortForwardingController;
 class Profile;
+class WebRTCDeviceProvider;
+class ProfileIdentityProvider;
+class SigninManagerBase;
+class ProfileOAuth2TokenService;
 
 class DevToolsAndroidBridge : public KeyedService {
  public:
   class Factory : public BrowserContextKeyedServiceFactory {
    public:
     // Returns singleton instance of DevToolsAndroidBridge.
     static Factory* GetInstance();
 
     // Returns DevToolsAndroidBridge associated with |profile|.
     static DevToolsAndroidBridge* GetForProfile(Profile* profile);
@@ skipping 102 matching lines @@
 
   typedef std::vector<scoped_refptr<RemoteDevice> > RemoteDevices;
 
   class DeviceListListener {
    public:
     virtual void DeviceListChanged(const RemoteDevices& devices) = 0;
    protected:
     virtual ~DeviceListListener() {}
   };
 
-  explicit DevToolsAndroidBridge(Profile* profile);
+  DevToolsAndroidBridge(Profile* profile,
+                        SigninManagerBase* signin_manager,
+                        ProfileOAuth2TokenService* token_service);
   void AddDeviceListListener(DeviceListListener* listener);
   void RemoveDeviceListListener(DeviceListListener* listener);
 
   class DeviceCountListener {
    public:
     virtual void DeviceCountChanged(int count) = 0;
    protected:
     virtual ~DeviceCountListener() {}
   };
 
@@ skipping 35 matching lines @@
   // Creates new target instance owned by caller.
   DevToolsTargetImpl* CreatePageTarget(scoped_refptr<RemotePage> browser);
 
   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);
+
  private:
   friend struct content::BrowserThread::DeleteOnThread<
       content::BrowserThread::UI>;
   friend class base::DeleteHelper<DevToolsAndroidBridge>;
 
   friend class PortForwardingController;
 
   class AgentHostDelegate;
   class DiscoveryRequest;
   class RemotePageTarget;
@@ skipping 49 matching lines @@
   void RespondToOpenOnUIThread(scoped_refptr<RemoteBrowser> browser,
                                const RemotePageCallback& callback,
                                int result,
                                const std::string& response);
 
   base::WeakPtr<DevToolsAndroidBridge> AsWeakPtr() {
       return weak_factory_.GetWeakPtr();
   }
 
   Profile* profile_;
+  scoped_ptr<ProfileIdentityProvider> identity_provider_;
   const scoped_ptr<AndroidDeviceManager> device_manager_;
 
   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;
@@ skipping 10 matching lines @@
   scoped_ptr<PortForwardingController> port_forwarding_controller_;
 
   PrefChangeRegistrar pref_change_registrar_;
 
   base::WeakPtrFactory<DevToolsAndroidBridge> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(DevToolsAndroidBridge);
 };
 
 #endif  // CHROME_BROWSER_DEVTOOLS_DEVICE_DEVTOOLS_ANDROID_BRIDGE_H_