List cloud devices in chrome://devices page.

chrome/browser/ui/webui/local_discovery/local_discovery_ui_handler.cc

 // Copyright 2013 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.
 
 #include "chrome/browser/ui/webui/local_discovery/local_discovery_ui_handler.h"
 
 #include <set>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 80 matching lines @@
       base::Unretained(this)));
   web_ui()->RegisterMessageCallback("isVisible", base::Bind(
       &LocalDiscoveryUIHandler::HandleIsVisible,
       base::Unretained(this)));
   web_ui()->RegisterMessageCallback("registerDevice", base::Bind(
       &LocalDiscoveryUIHandler::HandleRegisterDevice,
       base::Unretained(this)));
   web_ui()->RegisterMessageCallback("cancelRegistration", base::Bind(
       &LocalDiscoveryUIHandler::HandleCancelRegistration,
       base::Unretained(this)));
-  web_ui()->RegisterMessageCallback("requestPrinterList", base::Bind(
-      &LocalDiscoveryUIHandler::HandleRequestPrinterList,
-      base::Unretained(this)));
+  web_ui()->RegisterMessageCallback(
+      "requestDeviceList",
+      base::Bind(&LocalDiscoveryUIHandler::HandleRequestDeviceList,
+                 base::Unretained(this)));
   web_ui()->RegisterMessageCallback("openCloudPrintURL", base::Bind(
       &LocalDiscoveryUIHandler::HandleOpenCloudPrintURL,
       base::Unretained(this)));
   web_ui()->RegisterMessageCallback("showSyncUI", base::Bind(
       &LocalDiscoveryUIHandler::HandleShowSyncUI,
       base::Unretained(this)));
 
   // Cloud print connector related messages
 #if defined(CLOUD_PRINT_CONNECTOR_UI_AVAILABLE)
   if (cloud_print_connector_ui_enabled_) {
@@ skipping 58 matching lines @@
       base::Bind(&LocalDiscoveryUIHandler::StartRegisterHTTP,
                  base::Unretained(this)));
   privet_resolution_->Start();
 }
 
 void LocalDiscoveryUIHandler::HandleCancelRegistration(
     const base::ListValue* args) {
   ResetCurrentRegistration();
 }
 
-void LocalDiscoveryUIHandler::HandleRequestPrinterList(
+void LocalDiscoveryUIHandler::HandleRequestDeviceList(
     const base::ListValue* args) {
   Profile* profile = Profile::FromWebUI(web_ui());
   ProfileOAuth2TokenService* token_service =
       ProfileOAuth2TokenServiceFactory::GetForProfile(profile);
 
   SigninManagerBase* signin_manager =
       SigninManagerFactory::GetInstance()->GetForProfile(profile);
 
+  devices_list_.reset();
+
   cloud_print_printer_list_.reset(
       new CloudPrintPrinterList(profile->GetRequestContext(),
                                 token_service,
                                 signin_manager->GetAuthenticatedAccountId(),
                                 this));
+
+  cloud_device_list_.reset(

[Noam Samuel, 2014/05/16 21:13:26]

IMPORTANT: Please hide behind flag for now.

[Vitaly Buka (NO REVIEWS), 2014/05/17 17:15:37]

Done.

+      new CloudDeviceList(profile->GetRequestContext(),
+                          token_service,
+                          signin_manager->GetAuthenticatedAccountId(),
+                          this));
+
   cloud_print_printer_list_->Start();
+  cloud_device_list_->Start();
 }
 
 void LocalDiscoveryUIHandler::HandleOpenCloudPrintURL(
     const base::ListValue* args) {
   std::string id;
   bool rv = args->GetString(0, &id);
   DCHECK(rv);
 
   Browser* browser = chrome::FindBrowserWithWebContents(
       web_ui()->GetWebContents());
@@ skipping 169 matching lines @@
   web_ui()->CallJavascriptFunction("local_discovery.onUnregisteredDeviceUpdate",
                                    name_value, *null_value);
 }
 
 void LocalDiscoveryUIHandler::DeviceCacheFlushed() {
   web_ui()->CallJavascriptFunction("local_discovery.onDeviceCacheFlushed");
   privet_lister_->DiscoverNewDevices(false);
 }
 
 void LocalDiscoveryUIHandler::OnCloudPrintPrinterListReady() {
-  base::ListValue printer_object_list;
+  if (!devices_list_)
+    devices_list_.reset(new base::ListValue());
   std::set<std::string> local_ids;
 
   for (DeviceDescriptionMap::iterator i = device_descriptions_.begin();
-       i != device_descriptions_.end();
-       i++) {
+       i != device_descriptions_.end(); i++) {
     std::string device_id = i->second.id;
     if (!device_id.empty()) {
       const CloudPrintPrinterList::PrinterDetails* details =
           cloud_print_printer_list_->GetDetailsFor(device_id);
 
       if (details) {
         local_ids.insert(device_id);
-        printer_object_list.Append(CreatePrinterInfo(*details).release());
+        devices_list_->Append(CreatePrinterInfo(*details).release());
       }
     }
   }
 
   for (CloudPrintPrinterList::iterator i = cloud_print_printer_list_->begin();
        i != cloud_print_printer_list_->end(); i++) {
     if (local_ids.count(i->id) == 0) {
-      printer_object_list.Append(CreatePrinterInfo(*i).release());
+      devices_list_->Append(CreatePrinterInfo(*i).release());
     }
   }
 
-  web_ui()->CallJavascriptFunction(
-      "local_discovery.onCloudDeviceListAvailable", printer_object_list);
+  cloud_print_printer_list_.reset();
+  CheckListingDone();
 }
 
 void LocalDiscoveryUIHandler::OnCloudPrintPrinterListUnavailable() {
-  web_ui()->CallJavascriptFunction(
-      "local_discovery.onCloudDeviceListUnavailable");
+  cloud_print_printer_list_.reset();
+  CheckListingDone();
+}
+
+void LocalDiscoveryUIHandler::OnCloudDeviceListReady() {
+  if (!devices_list_)
+    devices_list_.reset(new base::ListValue());
+  std::set<std::string> local_ids;
+
+  for (DeviceDescriptionMap::iterator i = device_descriptions_.begin();
+       i != device_descriptions_.end(); i++) {
+    std::string device_id = i->second.id;
+    if (!device_id.empty()) {
+      const CloudDeviceList::DeviceDetails* details =
+          cloud_device_list_->GetDetailsFor(device_id);
+
+      if (details) {
+        local_ids.insert(device_id);
+        devices_list_->Append(CreateDeviceInfo(*details).release());
+      }
+    }
+  }
+
+  for (CloudDeviceList::iterator i = cloud_device_list_->begin();
+       i != cloud_device_list_->end(); i++) {
+    if (local_ids.count(i->id) == 0) {
+      devices_list_->Append(CreateDeviceInfo(*i).release());
+    }
+  }
+
+  cloud_device_list_.reset();
+  CheckListingDone();
+}
+
+void LocalDiscoveryUIHandler::OnCloudDeviceListUnavailable() {
+  cloud_device_list_.reset();
+  CheckListingDone();
 }
 
 void LocalDiscoveryUIHandler::GoogleSigninSucceeded(
     const std::string& username,
     const std::string& password) {
   CheckUserLoggedIn();
 }
 
 void LocalDiscoveryUIHandler::GoogleSignedOut(const std::string& username) {
   CheckUserLoggedIn();
@@ skipping 41 matching lines @@
     current_register_operation_->Cancel();
     current_register_operation_.reset();
   }
 
   confirm_api_call_flow_.reset();
   privet_resolution_.reset();
   current_http_client_.reset();
 }
 
 scoped_ptr<base::DictionaryValue> LocalDiscoveryUIHandler::CreatePrinterInfo(
     const CloudPrintPrinterList::PrinterDetails& description) {

[Noam Samuel, 2014/05/16 21:13:26]

Maybe it makes sense to just migrate CloudPrintPrinterList to DeviceDetails, and
use a "type" of kDeviceTypePrinter.

[Vitaly Buka (NO REVIEWS), 2014/05/17 17:15:37]

Done.

   scoped_ptr<base::DictionaryValue> return_value(new base::DictionaryValue);
 
   return_value->SetString("id", description.id);
   return_value->SetString("display_name", description.display_name);
   return_value->SetString("description", description.description);
-  return_value->SetString("type", "printer");
+  return_value->SetString("type", kDeviceTypePrinter);
 
   return return_value.Pass();
 }
+
+scoped_ptr<base::DictionaryValue> LocalDiscoveryUIHandler::CreateDeviceInfo(
+    const CloudDeviceList::DeviceDetails& description) {
+  scoped_ptr<base::DictionaryValue> return_value(new base::DictionaryValue);
+
+  return_value->SetString("id", description.id);
+  return_value->SetString("display_name", description.display_name);
+  return_value->SetString("description", description.description);
+  return_value->SetString("type", description.type);
+
+  return return_value.Pass();
+}
 
 void LocalDiscoveryUIHandler::CheckUserLoggedIn() {
   base::FundamentalValue logged_in_value(!GetSyncAccount().empty());
   web_ui()->CallJavascriptFunction("local_discovery.setUserLoggedIn",
                                    logged_in_value);
 }
 
+void LocalDiscoveryUIHandler::CheckListingDone() {
+  if (cloud_print_printer_list_ || cloud_device_list_)
+    return;
+  if (devices_list_) {
+    web_ui()->CallJavascriptFunction(
+        "local_discovery.onCloudDeviceListAvailable", *devices_list_);
+    devices_list_.reset();
+  } else {
+    web_ui()->CallJavascriptFunction(
+        "local_discovery.onCloudDeviceListUnavailable");
+  }
+}
+
 #if defined(CLOUD_PRINT_CONNECTOR_UI_AVAILABLE)
 void LocalDiscoveryUIHandler::StartCloudPrintConnector() {
   Profile* profile = Profile::FromWebUI(web_ui());
 
   base::Closure cloud_print_callback = base::Bind(
       &LocalDiscoveryUIHandler::OnCloudPrintPrefsChanged,
           base::Unretained(this));
 
   if (cloud_print_connector_email_.GetPrefName().empty()) {
     cloud_print_connector_email_.Init(
@@ skipping 88 matching lines @@
 }
 
 void LocalDiscoveryUIHandler::RefreshCloudPrintStatusFromService() {
   if (cloud_print_connector_ui_enabled_)
     CloudPrintProxyServiceFactory::GetForProfile(Profile::FromWebUI(web_ui()))->
         RefreshStatusFromService();
 }
 #endif // cloud print connector option stuff
 
 }  // namespace local_discovery