Present the printer list from preferences for Chrome OS.

chrome/browser/ui/webui/print_preview/print_preview_handler.cc

 // Copyright (c) 2012 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/print_preview/print_preview_handler.h"
 
 #include <ctype.h>
 #include <stddef.h>
 
 #include <map>
@@ skipping 31 matching lines @@
 #include "chrome/browser/printing/printer_manager_dialog.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/signin/gaia_cookie_manager_service_factory.h"
 #include "chrome/browser/signin/profile_oauth2_token_service_factory.h"
 #include "chrome/browser/signin/signin_manager_factory.h"
 #include "chrome/browser/ui/browser_finder.h"
 #include "chrome/browser/ui/browser_tabstrip.h"
 #include "chrome/browser/ui/chrome_select_file_policy.h"
 #include "chrome/browser/ui/scoped_tabbed_browser_displayer.h"
 #include "chrome/browser/ui/webui/print_preview/print_preview_ui.h"
+#include "chrome/browser/ui/webui/print_preview/printer_backend_proxy.h"
 #include "chrome/browser/ui/webui/print_preview/printer_handler.h"
 #include "chrome/browser/ui/webui/print_preview/sticky_settings.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/cloud_print/cloud_print_cdd_conversion.h"
 #include "chrome/common/cloud_print/cloud_print_constants.h"
 #include "chrome/common/crash_keys.h"
 #include "chrome/common/features.h"
 #include "chrome/common/pref_names.h"
 #include "components/cloud_devices/common/cloud_device_description.h"
 #include "components/cloud_devices/common/cloud_devices_urls.h"
@@ skipping 226 matching lines @@
                         const base::Closure& pdf_file_saved_closure) {
   DCHECK(BrowserThread::GetBlockingPool()->RunsTasksOnCurrentThread());
   base::File file(path,
                   base::File::FLAG_CREATE_ALWAYS | base::File::FLAG_WRITE);
   file.WriteAtCurrentPos(reinterpret_cast<const char*>(data->front()),
                          base::checked_cast<int>(data->size()));
   if (!pdf_file_saved_closure.is_null())
     pdf_file_saved_closure.Run();
 }
 
-std::string GetDefaultPrinterOnBlockingPoolThread() {
-  DCHECK(BrowserThread::GetBlockingPool()->RunsTasksOnCurrentThread());
-
-  scoped_refptr<printing::PrintBackend> print_backend(
-      printing::PrintBackend::CreateInstance(nullptr));
-
-  std::string default_printer = print_backend->GetDefaultPrinterName();
-  VLOG(1) << "Default Printer: " << default_printer;
-  return default_printer;
-}
-
 class PrintingContextDelegate : public printing::PrintingContext::Delegate {
  public:
   // PrintingContext::Delegate methods.
   gfx::NativeView GetParentView() override { return NULL; }
   std::string GetAppLocale() override {
     return g_browser_process->GetApplicationLocale();
   }
 };
 
 gfx::Size GetDefaultPdfMediaSizeMicrons() {
@@ skipping 59 matching lines @@
     media.AddDefaultOption(media_option,
                            default_media.type == media_option.type);
   }
   media.SaveTo(&description);
 
   return std::unique_ptr<base::DictionaryValue>(description.root().DeepCopy());
 }
 
 std::pair<std::string, std::string> GetPrinterNameAndDescription(
     const printing::PrinterBasicInfo& printer) {
-#if defined(OS_MACOSX)
+#if defined(OS_MACOSX) || defined(OS_CHROMEOS)
   // On Mac, |printer.printer_description| specifies the printer name and
   // |printer.printer_name| specifies the device name / printer queue name.
+  // Chrome OS emulates the Mac behavior.
   const std::string& real_name = printer.printer_description;
   std::string real_description;
   const auto it = printer.options.find(kDriverNameTagName);
   if (it != printer.options.end())
     real_description = it->second;
   return std::make_pair(real_name, real_description);
 #else
   return std::make_pair(printer.printer_name, printer.printer_description);
 #endif
 }
 
-void EnumeratePrintersOnBlockingPoolThread(base::ListValue* printers) {
-  DCHECK(BrowserThread::GetBlockingPool()->RunsTasksOnCurrentThread());
-
-  scoped_refptr<printing::PrintBackend> print_backend(
-      printing::PrintBackend::CreateInstance(nullptr));
-
-  VLOG(1) << "Enumerate printers start";
-  printing::PrinterList printer_list;
-  print_backend->EnumeratePrinters(&printer_list);
-
+void PrintersToValues(const printing::PrinterList& printer_list,
+                      base::ListValue* printers) {
   for (const printing::PrinterBasicInfo& printer : printer_list) {
     std::unique_ptr<base::DictionaryValue> printer_info(
         new base::DictionaryValue);
     const auto printer_name_description = GetPrinterNameAndDescription(printer);
     const std::string& printer_name = printer_name_description.first;
     const std::string& printer_description = printer_name_description.second;
     printer_info->SetString(printing::kSettingDeviceName, printer.printer_name);
     printer_info->SetString(printing::kSettingPrinterName, printer_name);
     printer_info->SetString(printing::kSettingPrinterDescription,
                             printer_description);
 
     base::DictionaryValue* options = new base::DictionaryValue;
     printer_info->Set(printing::kSettingPrinterOptions, options);
     for (const auto opt_it : printer.options)
       options->SetString(opt_it.first, opt_it.second);
 
     printers->Append(std::move(printer_info));
 
     VLOG(1) << "Found printer " << printer_name << " with device name "
             << printer.printer_name;
   }
-  VLOG(1) << "Enumerate printers finished, found " << printers->GetSize()
-          << " printers";
 }
 
 std::unique_ptr<base::DictionaryValue>
 GetPrinterCapabilitiesOnBlockingPoolThread(const std::string& device_name) {
   DCHECK(BrowserThread::GetBlockingPool()->RunsTasksOnCurrentThread());
   DCHECK(!device_name.empty());
 
   scoped_refptr<printing::PrintBackend> print_backend(
       printing::PrintBackend::CreateInstance(nullptr));
 
@@ skipping 235 matching lines @@
 
 WebContents* PrintPreviewHandler::preview_web_contents() const {
   return web_ui()->GetWebContents();
 }
 
 PrintPreviewUI* PrintPreviewHandler::print_preview_ui() const {
   return static_cast<PrintPreviewUI*>(web_ui()->GetController());
 }
 
 void PrintPreviewHandler::HandleGetPrinters(const base::ListValue* /*args*/) {
-  base::ListValue* results = new base::ListValue;
-  BrowserThread::PostBlockingPoolTaskAndReply(
-      FROM_HERE, base::Bind(&EnumeratePrintersOnBlockingPoolThread,
-                            base::Unretained(results)),
-      base::Bind(&PrintPreviewHandler::SetupPrinterList,
-                 weak_factory_.GetWeakPtr(), base::Owned(results)));
+  VLOG(1) << "Enumerate printers start";
+  printing::EnumeratePrinters(Profile::FromWebUI(web_ui()),
+                              base::Bind(&PrintPreviewHandler::SetupPrinterList,
+                                         weak_factory_.GetWeakPtr()));
 }
 
 void PrintPreviewHandler::HandleGetPrivetPrinters(const base::ListValue* args) {
   if (!PrivetPrintingEnabled())
     return web_ui()->CallJavascriptFunctionUnsafe("onPrivetPrinterSearchDone");
 #if BUILDFLAG(ENABLE_SERVICE_DISCOVERY)
   using local_discovery::ServiceDiscoverySharedClient;
   scoped_refptr<ServiceDiscoverySharedClient> service_discovery =
       ServiceDiscoverySharedClient::GetInstance();
   StartPrivetLister(service_discovery);
@@ skipping 512 matching lines @@
   settings->SetString(kNumberFormat, base::FormatDouble(123456.78, 2));
   settings->SetInteger(kMeasurementSystem, system);
 }
 
 void PrintPreviewHandler::HandleGetInitialSettings(
     const base::ListValue* /*args*/) {
   // Send before SendInitialSettings() to allow cloud printer auto select.
   SendCloudPrintEnabled();
   base::PostTaskAndReplyWithResult(
       BrowserThread::GetBlockingPool(), FROM_HERE,
-      base::Bind(&GetDefaultPrinterOnBlockingPoolThread),
+      base::Bind(&printing::GetDefaultPrinterOnBlockingPoolThread),
       base::Bind(&PrintPreviewHandler::SendInitialSettings,
                  weak_factory_.GetWeakPtr()));
 }
 
 void PrintPreviewHandler::HandleForceOpenNewTab(const base::ListValue* args) {
   std::string url;
   if (!args->GetString(0, &url))
     return;
   Browser* browser = chrome::FindBrowserWithWebContents(GetInitiator());
   if (!browser)
@@ skipping 61 matching lines @@
     VLOG(1) << "Get printer capabilities failed";
     web_ui()->CallJavascriptFunctionUnsafe("failedToGetPrinterCapabilities",
                                            base::StringValue(printer_name));
     return;
   }
   VLOG(1) << "Get printer capabilities finished";
   web_ui()->CallJavascriptFunctionUnsafe("updateWithPrinterCapabilities",
                                          *settings_info);
 }
 
-void PrintPreviewHandler::SetupPrinterList(const base::ListValue* printers) {
+void PrintPreviewHandler::SetupPrinterList(
+    const printing::PrinterList& printer_list) {
+  base::ListValue printers;
+  PrintersToValues(printer_list, &printers);
+
+  VLOG(1) << "Enumerate printers finished, found " << printers.GetSize()
+          << " printers";
+
   if (!has_logged_printers_count_) {
-    UMA_HISTOGRAM_COUNTS("PrintPreview.NumberOfPrinters", printers->GetSize());
+    UMA_HISTOGRAM_COUNTS("PrintPreview.NumberOfPrinters", printers.GetSize());
     has_logged_printers_count_ = true;
   }
 
-  web_ui()->CallJavascriptFunctionUnsafe("setPrinters", *printers);
+  web_ui()->CallJavascriptFunctionUnsafe("setPrinters", printers);
 }
 
 void PrintPreviewHandler::SendCloudPrintEnabled() {
   Profile* profile = Profile::FromBrowserContext(
       preview_web_contents()->GetBrowserContext());
   PrefService* prefs = profile->GetPrefs();
   if (prefs->GetBoolean(prefs::kCloudPrintSubmitEnabled)) {
     base::DictionaryValue settings;
     settings.SetString(kCloudPrintUrl,
                        GURL(cloud_devices::GetCloudPrintURL()).spec());
@@ skipping 439 matching lines @@
 
 void PrintPreviewHandler::UnregisterForGaiaCookieChanges() {
   if (gaia_cookie_manager_service_)
     gaia_cookie_manager_service_->RemoveObserver(this);
 }
 
 void PrintPreviewHandler::SetPdfSavedClosureForTesting(
     const base::Closure& closure) {
   pdf_file_saved_closure_ = closure;
 }