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 225 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 68 matching lines @@
     const printing::PrinterBasicInfo& printer) {
 #if defined(OS_MACOSX)
   // On Mac, |printer.printer_description| specifies the printer name and
   // |printer.printer_name| specifies the device name / printer queue name.
   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);
+#elif defined(OS_CHROMEOS)
+  // For Chrome OS |printer.printer_display_name| is the human readable name and

[Lei Zhang, 2016/11/03 07:39:50]

So is ChromeOS more in line with Mac then? Maybe don't add a ChromeOS-only
"printer_display_name" field to PrinterBasicInfo, and just create the info the
Mac way in ToBasicInfo() ?

Having 2 different ways to interpret PrinterBasicInfo is already a bit
confusing. Let's not expand it to 3 ways.

[skau, 2016/11/03 21:58:27]

Per discussion, I'm going to try to align all the platforms around
printer_display_name.  But the interest of time, ChromeOS will take the OS X
code path as well.

[Lei Zhang, 2016/11/03 22:06:12]

Agreed, I think that's a safer bet.

+  // |printer.printer_name| is the name used in CUPS.
+  return std::make_pair(printer.printer_display_name,
+                        printer.printer_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;
   }
+}
+
+void EnumeratePrinters(Profile* profile, base::ListValue* printers) {
+  DCHECK(BrowserThread::GetBlockingPool()->RunsTasksOnCurrentThread());
+
+  VLOG(1) << "Enumerate printers start";
+  printing::PrinterList printer_list =
+      printing::EnumeratePrintersOnBlockingPoolThread(profile);
+  PrintersToValues(printer_list, printers);
   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(
@@ skipping 239 matching lines @@
   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,
+      FROM_HERE, base::Bind(&EnumeratePrinters, Profile::FromWebUI(web_ui()),
                             base::Unretained(results)),
       base::Bind(&PrintPreviewHandler::SetupPrinterList,
                  weak_factory_.GetWeakPtr(), base::Owned(results)));
 }
 
 void PrintPreviewHandler::HandleGetPrivetPrinters(const base::ListValue* args) {
   if (!PrivetPrintingEnabled())
     return web_ui()->CallJavascriptFunctionUnsafe("onPrivetPrinterSearchDone");
 #if BUILDFLAG(ENABLE_SERVICE_DISCOVERY)
   using local_discovery::ServiceDiscoverySharedClient;
@@ skipping 515 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 527 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;
 }