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 11 matching lines @@
 #include "chrome/browser/printing/cloud_print/cloud_print_proxy_service.h"
 #include "chrome/browser/printing/cloud_print/cloud_print_proxy_service_factory.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/signin/profile_oauth2_token_service_factory.h"
 #include "chrome/browser/signin/signin_manager_factory.h"
 #include "chrome/browser/signin/signin_promo.h"
 #include "chrome/browser/ui/browser_finder.h"
 #include "chrome/browser/ui/browser_tabstrip.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
+#include "components/cloud_devices/common/cloud_devices_switches.h"
 #include "components/cloud_devices/common/cloud_devices_urls.h"
 #include "components/signin/core/browser/profile_oauth2_token_service.h"
 #include "components/signin/core/browser/signin_manager_base.h"
 #include "content/public/browser/user_metrics.h"
 #include "content/public/browser/web_ui.h"
 #include "content/public/common/page_transition_types.h"
 #include "grit/generated_resources.h"
 #include "net/base/host_port_pair.h"
 #include "net/base/net_util.h"
 #include "net/base/url_util.h"
 #include "net/http/http_status_code.h"
 #include "ui/base/l10n/l10n_util.h"
 
 #if defined(ENABLE_FULL_PRINTING) && !defined(OS_CHROMEOS)
 #define CLOUD_PRINT_CONNECTOR_UI_AVAILABLE
 #endif
 
 namespace local_discovery {
 
 namespace {
-const char kDeviceTypePrinter[] = "printer";
+
 int g_num_visible = 0;
+
+scoped_ptr<base::DictionaryValue> CreateDeviceInfo(
+    const CloudDeviceListDelegate::Device& 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 ReadDevicesList(
+    const std::vector<CloudDeviceListDelegate::Device>& devices,
+    const std::set<std::string>& local_ids,
+    base::ListValue* devices_list) {
+  for (CloudDeviceList::iterator i = devices.begin(); i != devices.end(); i++) {
+    if (local_ids.count(i->id) > 0) {
+      devices_list->Append(CreateDeviceInfo(*i).release());
+    }
+  }
+
+  for (CloudDeviceList::iterator i = devices.begin(); i != devices.end(); i++) {
+    if (local_ids.count(i->id) == 0) {
+      devices_list->Append(CreateDeviceInfo(*i).release());
+    }
+  }
+}
+
 }  // namespace
 
-LocalDiscoveryUIHandler::LocalDiscoveryUIHandler() : is_visible_(false) {
+LocalDiscoveryUIHandler::LocalDiscoveryUIHandler()
+    : is_visible_(false),
+      failed_list_count_(0),
+      succeded_list_count_(0) {
 #if defined(CLOUD_PRINT_CONNECTOR_UI_AVAILABLE)
 #if !defined(GOOGLE_CHROME_BUILD) && defined(OS_WIN)
   // On Windows, we need the PDF plugin which is only guaranteed to exist on
   // Google Chrome builds. Use a command-line switch for Windows non-Google
   //  Chrome builds.
   cloud_print_connector_ui_enabled_ =
       CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kEnableCloudPrintProxy);
 #else
   // Always enabled for Linux and Google Chrome Windows builds.
@@ skipping 24 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);
 
+  failed_list_count_ = 0;
+  succeded_list_count_ = 0;
+
   cloud_print_printer_list_.reset(
       new CloudPrintPrinterList(profile->GetRequestContext(),
                                 token_service,
                                 signin_manager->GetAuthenticatedAccountId(),
                                 this));
+  if (CommandLine::ForCurrentProcess()->HasSwitch(
+      switches::kEnableCloudDevices)) {
+    cloud_device_list_.reset(
+        new CloudDeviceList(profile->GetRequestContext(),
+                            token_service,
+                            signin_manager->GetAuthenticatedAccountId(),
+                            this));
+  }
+
   cloud_print_printer_list_->Start();
+  if (cloud_device_list_)
+    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 168 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;
-  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 CloudPrintPrinterList::PrinterDetails* details =
-          cloud_print_printer_list_->GetDetailsFor(device_id);
-
-      if (details) {
-        local_ids.insert(device_id);
-        printer_object_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());
-    }
-  }
-
-  web_ui()->CallJavascriptFunction(
-      "local_discovery.onCloudDeviceListAvailable", printer_object_list);
+void LocalDiscoveryUIHandler::OnDeviceListReady() {
+  ++succeded_list_count_;
+  CheckListingDone();
 }
 
-void LocalDiscoveryUIHandler::OnCloudPrintPrinterListUnavailable() {
-  web_ui()->CallJavascriptFunction(
-      "local_discovery.onCloudDeviceListUnavailable");
+void LocalDiscoveryUIHandler::OnDeviceListUnavailable() {
+  ++failed_list_count_;
+  CheckListingDone();
 }
 
 void LocalDiscoveryUIHandler::GoogleSigninSucceeded(
     const std::string& username,
     const std::string& password) {
   CheckUserLoggedIn();
 }
 
 void LocalDiscoveryUIHandler::GoogleSignedOut(const std::string& username) {
   CheckUserLoggedIn();
@@ skipping 40 matching lines @@
   if (current_register_operation_.get()) {
     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) {
-  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 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() {
+  int started = 0;
+  if (cloud_print_printer_list_)
+    ++started;
+  if (cloud_device_list_)
+    ++started;
+
+  if (started > failed_list_count_ + succeded_list_count_)
+    return;
+
+  if (succeded_list_count_ <= 0) {
+    web_ui()->CallJavascriptFunction(
+        "local_discovery.onCloudDeviceListUnavailable");
+    return;
+  }
+
+  base::ListValue devices_list;
+  std::set<std::string> local_ids;
+
+  for (DeviceDescriptionMap::iterator i = device_descriptions_.begin();
+       i != device_descriptions_.end(); i++) {
+    local_ids.insert(i->second.id);
+  }
+
+  if (cloud_print_printer_list_) {
+    ReadDevicesList(cloud_print_printer_list_->printer_list(), local_ids,
+                    &devices_list);
+  }
+  if (cloud_device_list_) {
+    ReadDevicesList(cloud_device_list_->device_list(), local_ids,
+                    &devices_list);
+  }
+
+  web_ui()->CallJavascriptFunction(
+      "local_discovery.onCloudDeviceListAvailable", devices_list);
+  cloud_print_printer_list_.reset();
+  cloud_device_list_.reset();
+}
+
 #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