Populating browser list in WebRTCDeviceProvider.

chrome/browser/devtools/device/webrtc/webrtc_device_provider.cc

Index: chrome/browser/devtools/device/webrtc/webrtc_device_provider.cc
diff --git a/chrome/browser/devtools/device/webrtc/webrtc_device_provider.cc b/chrome/browser/devtools/device/webrtc/webrtc_device_provider.cc
index c6f6935cf52cc0adcfc99a58d4d4951f4ed5136c..f05feeec393c3a59063b24c6241ae16036f4ae4c 100644
--- a/chrome/browser/devtools/device/webrtc/webrtc_device_provider.cc
+++ b/chrome/browser/devtools/device/webrtc/webrtc_device_provider.cc
@@ -5,6 +5,9 @@
 #include "chrome/browser/devtools/device/webrtc/webrtc_device_provider.h"
 
 #include "chrome/browser/chrome_notification_types.h"
+#include "chrome/browser/local_discovery/cloud_device_list.h"
+#include "chrome/browser/local_discovery/cloud_device_list_delegate.h"
+#include "chrome/browser/local_discovery/gcd_api_flow.h"
 #include "chrome/browser/signin/profile_identity_provider.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/common/url_constants.h"
@@ -19,6 +22,10 @@
 #include "net/socket/stream_socket.h"
 #include "ui/base/page_transition_types.h"
 
+using BrowserInfo = AndroidDeviceManager::BrowserInfo;
+using BrowserInfoList = std::vector<BrowserInfo>;
+using DeviceInfo = AndroidDeviceManager::DeviceInfo;
+using SerialList = std::vector<std::string>;
 using content::BrowserThread;
 using content::NotificationDetails;
 using content::NotificationObserver;
@@ -27,18 +34,24 @@ using content::NotificationSource;
 using content::WebContents;
 using content::WebUIDataSource;
 using content::WebUIMessageHandler;
+using local_discovery::CloudDeviceList;
+using local_discovery::CloudDeviceListDelegate;
+using local_discovery::GCDApiFlow;
 
 namespace {
 
 const char kBackgroundWorkerURL[] =
     "chrome://webrtc-device-provider/background_worker.html";
+const char kSerial[] = "clouddevices";
+const char kPseudoDeviceName[] = "Remote browsers";
 
 }  // namespace
 
 // Lives on the UI thread.
 class WebRTCDeviceProvider::DevToolsBridgeClient :
     private NotificationObserver,
-    private IdentityProvider::Observer {
+    private IdentityProvider::Observer,
+    private CloudDeviceListDelegate {
  public:
   static base::WeakPtr<DevToolsBridgeClient> Create(
       Profile* profile,
@@ -47,6 +60,10 @@ class WebRTCDeviceProvider::DevToolsBridgeClient :
 
   void DeleteSelf();
 
+  static SerialList GetDevices(base::WeakPtr<DevToolsBridgeClient> weak_ptr);
+  static DeviceInfo GetDeviceInfo(base::WeakPtr<DevToolsBridgeClient> weak_ptr,
+                                  const std::string& serial);
+
  private:
   DevToolsBridgeClient(Profile* profile,
                        SigninManagerBase* signin_manager,
@@ -55,6 +72,7 @@ class WebRTCDeviceProvider::DevToolsBridgeClient :
   ~DevToolsBridgeClient();
 
   void CreateBackgroundWorker();
+  void UpdateBrowserList();
 
   // Implementation of IdentityProvider::Observer.
   void OnActiveAccountLogin() override;
@@ -65,10 +83,18 @@ class WebRTCDeviceProvider::DevToolsBridgeClient :
                const NotificationSource& source,
                const NotificationDetails& details) override;
 
+  // CloudDeviceListDelegate implementation.
+  void OnDeviceListReady(
+      const CloudDeviceListDelegate::DeviceList& devices) override;
+  void OnDeviceListUnavailable() override;
+
   Profile* const profile_;
   ProfileIdentityProvider identity_provider_;
   NotificationRegistrar registrar_;
   scoped_ptr<WebContents> background_worker_;
+  scoped_ptr<GCDApiFlow> browser_list_request_;
+  BrowserInfoList browsers_;
+  bool browser_list_updating_;
   base::WeakPtrFactory<DevToolsBridgeClient> weak_factory_;
 };
 
@@ -129,6 +155,7 @@ WebRTCDeviceProvider::DevToolsBridgeClient::DevToolsBridgeClient(
     ProfileOAuth2TokenService* token_service)
     : profile_(profile),
       identity_provider_(signin_manager, token_service, nullptr),
+      browser_list_updating_(false),
       weak_factory_(this) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
@@ -151,6 +178,40 @@ void WebRTCDeviceProvider::DevToolsBridgeClient::DeleteSelf() {
   delete this;
 }
 
+void WebRTCDeviceProvider::DevToolsBridgeClient::UpdateBrowserList() {
+  if (browser_list_updating_ || !browser_list_request_.get())
+    return;
+  browser_list_updating_ = true;
+
+  browser_list_request_->Start(make_scoped_ptr(new CloudDeviceList(this)));
+}
+
+// static
+SerialList WebRTCDeviceProvider::DevToolsBridgeClient::GetDevices(
+    base::WeakPtr<DevToolsBridgeClient> weak_ptr) {
+  SerialList result;
+  if (auto* ptr = weak_ptr.get()) {
+    if (ptr->background_worker_.get())
+      result.push_back(kSerial);
+
+    ptr->UpdateBrowserList();
+  }
+  return result;
+}
+
+// static
+DeviceInfo WebRTCDeviceProvider::DevToolsBridgeClient::GetDeviceInfo(
+    base::WeakPtr<DevToolsBridgeClient> weak_ptr,
+    const std::string& serial) {
+  DeviceInfo result;
+  if (auto* ptr = weak_ptr.get()) {

[dgozman, 2014/12/08 16:08:16]

What about renaming to |self| and |weak_self|? |ptr| is too ambiguous.

[SeRya, 2014/12/08 17:33:39]

Done.

+    result.connected = ptr->background_worker_.get();
+    result.model = kPseudoDeviceName;
+    result.browser_info = ptr->browsers_;
+  }
+  return result;
+}
+
 void WebRTCDeviceProvider::DevToolsBridgeClient::CreateBackgroundWorker() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
@@ -168,6 +229,11 @@ void WebRTCDeviceProvider::DevToolsBridgeClient::CreateBackgroundWorker() {
 
   background_worker_->GetWebUI()->AddMessageHandler(
       new MessageHandler(this));
+
+  browser_list_request_ =
+      GCDApiFlow::Create(profile_->GetRequestContext(),
+                         identity_provider_.GetTokenService(),
+                         identity_provider_.GetActiveAccountId());
 }
 
 void WebRTCDeviceProvider::DevToolsBridgeClient::Observe(
@@ -188,6 +254,31 @@ void WebRTCDeviceProvider::DevToolsBridgeClient::OnActiveAccountLogin() {
 void WebRTCDeviceProvider::DevToolsBridgeClient::OnActiveAccountLogout() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   background_worker_.reset();
+  browser_list_request_.reset();
+  BrowserInfoList().swap(browsers_);
+}
+
+void WebRTCDeviceProvider::DevToolsBridgeClient::OnDeviceListReady(
+    const CloudDeviceListDelegate::DeviceList& devices) {
+  browser_list_updating_ = false;
+
+  // TODO(serya): Not all devices are browsers. Filter them out.
+  BrowserInfoList browsers;
+  browsers.reserve(devices.size());
+  for (const auto& device : devices) {
+    BrowserInfo browser;
+    browser.type = BrowserInfo::kTypeChrome;
+    browser.display_name = device.display_name;
+    browsers.push_back(browser);
+  }
+
+  browsers_.swap(browsers);
+}
+
+void WebRTCDeviceProvider::DevToolsBridgeClient::OnDeviceListUnavailable() {
+  browser_list_updating_ = false;
+
+  BrowserInfoList().swap(browsers_);
 }
 
 // WebRTCDeviceProvider::MessageHandler ----------------------------------------
@@ -227,16 +318,20 @@ WebRTCDeviceProvider::~WebRTCDeviceProvider() {
 }
 
 void WebRTCDeviceProvider::QueryDevices(const SerialsCallback& callback) {
-  // TODO(serya): Implement
-  base::MessageLoop::current()->PostTask(
-      FROM_HERE, base::Bind(callback, std::vector<std::string>()));
+  BrowserThread::PostTaskAndReplyWithResult(
+      BrowserThread::UI,
+      FROM_HERE,
+      base::Bind(&DevToolsBridgeClient::GetDevices, client_),
+      callback);
 }
 
 void WebRTCDeviceProvider::QueryDeviceInfo(const std::string& serial,
-                                          const DeviceInfoCallback& callback) {
-  // TODO(serya): Implement
-  base::MessageLoop::current()->PostTask(
-      FROM_HERE, base::Bind(callback, AndroidDeviceManager::DeviceInfo()));
+                                           const DeviceInfoCallback& callback) {
+  BrowserThread::PostTaskAndReplyWithResult(
+      BrowserThread::UI,
+      FROM_HERE,
+      base::Bind(&DevToolsBridgeClient::GetDeviceInfo, client_, serial),
+      callback);
 }
 
 void WebRTCDeviceProvider::OpenSocket(const std::string& serial,