Print Preview: Get printer info with capabilities.

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 291 matching lines @@
                   base::File::FLAG_CREATE_ALWAYS | base::File::FLAG_WRITE);
   metafile.SaveTo(&file);
   if (!pdf_file_saved_closure.is_null())
     pdf_file_saved_closure.Run();
 }
 
 std::string GetDefaultPrinterOnFileThread() {
   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
 
   scoped_refptr<printing::PrintBackend> print_backend(
-      printing::PrintBackend::CreateInstance(NULL));
+      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; }
@@ skipping 11 matching lines @@
     return gfx::Size();
   }
   gfx::Size pdf_media_size = printing_context->GetPdfPaperSizeDeviceUnits();
   float deviceMicronsPerDeviceUnit =
       (printing::kHundrethsMMPerInch * 10.0f) /
       printing_context->settings().device_units_per_inch();
   return gfx::Size(pdf_media_size.width() * deviceMicronsPerDeviceUnit,
                    pdf_media_size.height() * deviceMicronsPerDeviceUnit);
 }
 
-typedef base::Callback<void(const base::DictionaryValue*)>
-    GetPdfCapabilitiesCallback;
-
-std::unique_ptr<base::DictionaryValue> GetPdfCapabilitiesOnFileThread(
+std::unique_ptr<base::DictionaryValue> GetPdfCapabilities(
     const std::string& locale) {
-  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   cloud_devices::CloudDeviceDescription description;
   using namespace cloud_devices::printer;
 
   OrientationCapability orientation;
   orientation.AddOption(cloud_devices::printer::PORTRAIT);
   orientation.AddOption(cloud_devices::printer::LANDSCAPE);
   orientation.AddDefaultOption(AUTO_ORIENTATION, true);
   orientation.SaveTo(&description);
 
@@ skipping 29 matching lines @@
   for (size_t i = 0; i < arraysize(kPdfMedia); ++i) {
     Media media_option(kPdfMedia[i]);
     media.AddDefaultOption(media_option,
                            default_media.type == media_option.type);
   }
   media.SaveTo(&description);
 
   return std::unique_ptr<base::DictionaryValue>(description.root().DeepCopy());
 }
 
-std::unique_ptr<base::DictionaryValue> GetLocalPrinterCapabilitiesOnFileThread(
-    const std::string& printer_name) {
-  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
-
-  scoped_refptr<printing::PrintBackend> print_backend(
-      printing::PrintBackend::CreateInstance(NULL));
-
-  VLOG(1) << "Get printer capabilities start for " << printer_name;
-  crash_keys::ScopedPrinterInfo crash_key(
-      print_backend->GetPrinterDriverInfo(printer_name));
-
-  if (!print_backend->IsValidPrinter(printer_name)) {
-    LOG(WARNING) << "Invalid printer " << printer_name;
-    return std::unique_ptr<base::DictionaryValue>();
-  }
-
-  printing::PrinterSemanticCapsAndDefaults info;
-  if (!print_backend->GetPrinterSemanticCapsAndDefaults(printer_name, &info)) {
-    LOG(WARNING) << "Failed to get capabilities for " << printer_name;
-    return std::unique_ptr<base::DictionaryValue>();
-  }
-
-  std::unique_ptr<base::DictionaryValue> description(
-      cloud_print::PrinterSemanticCapsAndDefaultsToCdd(info));
-  if (!description) {
-    LOG(WARNING) << "Failed to convert capabilities for " << printer_name;
-    return std::unique_ptr<base::DictionaryValue>();
-  }
-
-  return description;
+std::pair<std::string, std::string> GetPrinterNameAndDescription(
+    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);
+#else
+  return std::make_pair(printer.printer_name, printer.printer_description);
+#endif
 }
 
 void EnumeratePrintersOnFileThread(base::ListValue* printers) {
   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
 
   scoped_refptr<printing::PrintBackend> print_backend(
-      printing::PrintBackend::CreateInstance(NULL));
+      printing::PrintBackend::CreateInstance(nullptr));
 
   VLOG(1) << "Enumerate printers start";
   printing::PrinterList printer_list;
   print_backend->EnumeratePrinters(&printer_list);
 
-  for (printing::PrinterList::iterator it = printer_list.begin();
-       it != printer_list.end(); ++it) {
+  for (const printing::PrinterBasicInfo& printer : printer_list) {
     base::DictionaryValue* printer_info = new base::DictionaryValue;
     printers->Append(printer_info);
-    std::string printer_name;
-    std::string printer_description;
-#if defined(OS_MACOSX)
-    // On Mac, |it->printer_description| specifies the printer name and
-    // |it->printer_name| specifies the device name / printer queue name.
-    printer_name = it->printer_description;
-    if (!it->options[kDriverNameTagName].empty())
-      printer_description = it->options[kDriverNameTagName];
-#else
-    printer_name = it->printer_name;
-    printer_description = it->printer_description;
-#endif
-    printer_info->SetString(printing::kSettingDeviceName, it->printer_name);
+
+    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);
-    printer_info->SetString(printing::kSettingPrinterName, printer_name);
-    VLOG(1) << "Found printer " << printer_name
-            << " with device name " << it->printer_name;
 
     base::DictionaryValue* options = new base::DictionaryValue;
     printer_info->Set(printing::kSettingPrinterOptions, options);
-    for (std::map<std::string, std::string>::iterator opt = it->options.begin();
-         opt != it->options.end();
-         ++opt) {
-      options->SetString(opt->first, opt->second);
-    }
+    for (const auto opt_it : printer.options)
+      options->SetString(opt_it.first, opt_it.second);
 
     VLOG(1) << "Found printer " << printer_name << " with device name "
-            << it->printer_name;
+            << printer.printer_name;
   }
   VLOG(1) << "Enumerate printers finished, found " << printers->GetSize()
           << " printers";
 }
 
-typedef base::Callback<void(const base::DictionaryValue*)>
-    GetPrinterCapabilitiesSuccessCallback;
-typedef base::Callback<void(const std::string&)>
-    GetPrinterCapabilitiesFailureCallback;
+std::unique_ptr<base::DictionaryValue> GetPrinterCapabilitiesOnFileThread(
+    const std::string& device_name) {
+  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
+  DCHECK(!device_name.empty());
 
-void GetPrinterCapabilitiesOnFileThread(
-    const std::string& printer_name,
-    const std::string& locale,
-    const GetPrinterCapabilitiesSuccessCallback& success_cb,
-    const GetPrinterCapabilitiesFailureCallback& failure_cb) {
-  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
-  DCHECK(!printer_name.empty());
+  scoped_refptr<printing::PrintBackend> print_backend(
+      printing::PrintBackend::CreateInstance(nullptr));
 
-  std::unique_ptr<base::DictionaryValue> printer_capabilities(
-      printer_name == kLocalPdfPrinterId
-          ? GetPdfCapabilitiesOnFileThread(locale)
-          : GetLocalPrinterCapabilitiesOnFileThread(printer_name));
-  if (!printer_capabilities) {
-    BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
-                            base::Bind(failure_cb, printer_name));
-    return;
+  VLOG(1) << "Get printer capabilities start for " << device_name;
+  crash_keys::ScopedPrinterInfo crash_key(
+      print_backend->GetPrinterDriverInfo(device_name));
+
+  std::unique_ptr<base::DictionaryValue> printer_info;
+  if (!print_backend->IsValidPrinter(device_name)) {
+    LOG(WARNING) << "Invalid printer " << device_name;
+    return printer_info;
   }
 
-  std::unique_ptr<base::DictionaryValue> printer_info(
-      new base::DictionaryValue);
-  printer_info->SetString(kPrinterId, printer_name);
+  printing::PrinterSemanticCapsAndDefaults info;
+  if (!print_backend->GetPrinterSemanticCapsAndDefaults(device_name, &info)) {
+    LOG(WARNING) << "Failed to get capabilities for " << device_name;
+    return printer_info;
+  }
+
+  std::unique_ptr<base::DictionaryValue> printer_capabilities =
+      cloud_print::PrinterSemanticCapsAndDefaultsToCdd(info);
+  if (!printer_capabilities) {
+    LOG(WARNING) << "Failed to convert capabilities for " << device_name;
+    return printer_info;
+  }
+
+  printing::PrinterBasicInfo basic_info;
+  if (!print_backend->GetPrinterBasicInfo(device_name, &basic_info))
+    return printer_info;
+
+  const auto printer_name_description =
+      GetPrinterNameAndDescription(basic_info);
+  const std::string& printer_name = printer_name_description.first;
+  const std::string& printer_description = printer_name_description.second;
+
+  printer_info.reset(new base::DictionaryValue);
+  printer_info->SetString(kPrinterId, device_name);
+  printer_info->SetString(printing::kSettingPrinterName, printer_name);
+  printer_info->SetString(printing::kSettingPrinterDescription,
+                          printer_description);
   printer_info->Set(kPrinterCapabilities, printer_capabilities.release());
-
-  BrowserThread::PostTask(
-      BrowserThread::UI, FROM_HERE,
-      base::Bind(success_cb, base::Owned(printer_info.release())));
+  return printer_info;
 }
 
 base::LazyInstance<printing::StickySettings> g_sticky_settings =
     LAZY_INSTANCE_INITIALIZER;
 
 printing::StickySettings* GetStickySettings() {
   return g_sticky_settings.Pointer();
 }
 
 // Returns a unique path for |path|, just like with downloads.
@@ skipping 593 matching lines @@
       preview_web_contents()->GetBrowserContext())->GetPrefs());
 }
 
 void PrintPreviewHandler::HandleGetPrinterCapabilities(
     const base::ListValue* args) {
   std::string printer_name;
   bool ret = args->GetString(0, &printer_name);
   if (!ret || printer_name.empty())
     return;
 
-  GetPrinterCapabilitiesSuccessCallback success_cb =
+  if (printer_name == kLocalPdfPrinterId) {
+    std::unique_ptr<base::DictionaryValue> printer_info(
+        new base::DictionaryValue);
+    printer_info->SetString(kPrinterId, printer_name);
+    printer_info->Set(
+        kPrinterCapabilities,
+        GetPdfCapabilities(g_browser_process->GetApplicationLocale()));
+    SendPrinterCapabilities(printer_name, std::move(printer_info));
+    return;
+  }
+
+  BrowserThread::PostTaskAndReplyWithResult(
+      BrowserThread::FILE, FROM_HERE,
+      base::Bind(&GetPrinterCapabilitiesOnFileThread, printer_name),
       base::Bind(&PrintPreviewHandler::SendPrinterCapabilities,
-                 weak_factory_.GetWeakPtr());
-  GetPrinterCapabilitiesFailureCallback failure_cb =
-      base::Bind(&PrintPreviewHandler::SendFailedToGetPrinterCapabilities,
-                 weak_factory_.GetWeakPtr());
-  BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE,
-                          base::Bind(&GetPrinterCapabilitiesOnFileThread,
-                                     printer_name,
-                                     g_browser_process->GetApplicationLocale(),
-                                     success_cb, failure_cb));
+                 weak_factory_.GetWeakPtr(), printer_name));
 }
 
 void PrintPreviewHandler::OnSigninComplete() {
   if (print_preview_ui())
     print_preview_ui()->OnReloadPrintersList();
 }
 
 void PrintPreviewHandler::HandleSignin(const base::ListValue* args) {
   bool add_account = false;
   bool success = args->GetBoolean(0, &add_account);
@@ skipping 94 matching lines @@
     system = UMS_SI;
 
   // Getting the number formatting based on the locale and writing to
   // dictionary.
   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.
+  // Send before SendInitialSettings() to allow cloud printer auto select.
   SendCloudPrintEnabled();
   BrowserThread::PostTaskAndReplyWithResult(
       BrowserThread::FILE, FROM_HERE,
       base::Bind(&GetDefaultPrinterOnFileThread),
       base::Bind(&PrintPreviewHandler::SendInitialSettings,
                  weak_factory_.GetWeakPtr()));
 }
 
 void PrintPreviewHandler::HandleForceOpenNewTab(const base::ListValue* args) {
   std::string url;
@@ skipping 58 matching lines @@
 
 void PrintPreviewHandler::SendAccessToken(const std::string& type,
                                           const std::string& access_token) {
   VLOG(1) << "Get getAccessToken finished";
   web_ui()->CallJavascriptFunction("onDidGetAccessToken",
                                    base::StringValue(type),
                                    base::StringValue(access_token));
 }
 
 void PrintPreviewHandler::SendPrinterCapabilities(
-    const base::DictionaryValue* settings_info) {
+    const std::string& printer_name,
+    std::unique_ptr<base::DictionaryValue> settings_info) {
+  if (!settings_info) {
+    VLOG(1) << "Get printer capabilities failed";
+    web_ui()->CallJavascriptFunction("failedToGetPrinterCapabilities",
+                                     base::StringValue(printer_name));
+    return;
+  }
   VLOG(1) << "Get printer capabilities finished";
   web_ui()->CallJavascriptFunction("updateWithPrinterCapabilities",
                                    *settings_info);
 }
 
-void PrintPreviewHandler::SendFailedToGetPrinterCapabilities(
-    const std::string& printer_name) {
-  VLOG(1) << "Get printer capabilities failed";
-  base::StringValue printer_name_value(printer_name);
-  web_ui()->CallJavascriptFunction("failedToGetPrinterCapabilities",
-                                   printer_name_value);
-}
-
 void PrintPreviewHandler::SetupPrinterList(const base::ListValue* printers) {
   if (!has_logged_printers_count_) {
     UMA_HISTOGRAM_COUNTS("PrintPreview.NumberOfPrinters", printers->GetSize());
     has_logged_printers_count_ = true;
   }
 
   web_ui()->CallJavascriptFunction("setPrinters", *printers);
 }
 
 void PrintPreviewHandler::SendCloudPrintEnabled() {
@@ skipping 454 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;
 }