Add media size capability to PDF printer.

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 <map>
 #include <string>
 
 #include "base/base64.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/i18n/file_util_icu.h"
 #include "base/i18n/number_formatting.h"
 #include "base/json/json_reader.h"
 #include "base/lazy_instance.h"
@@ skipping 22 matching lines @@
 #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/sticky_settings.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/cloud_print/cloud_print_constants.h"
 #include "chrome/common/crash_keys.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/print_messages.h"
+#include "components/cloud_devices/common/cloud_device_description.h"
 #include "components/cloud_devices/common/cloud_devices_urls.h"
+#include "components/cloud_devices/common/printer_description.h"
 #include "components/signin/core/browser/profile_oauth2_token_service.h"
 #include "components/signin/core/browser/signin_manager.h"
 #include "components/signin/core/browser/signin_manager_base.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/navigation_controller.h"
 #include "content/public/browser/navigation_entry.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_ui.h"
 #include "google_apis/gaia/oauth2_token_service.h"
 #include "printing/backend/print_backend.h"
 #include "printing/backend/print_backend_consts.h"
 #include "printing/metafile.h"
 #include "printing/metafile_impl.h"
 #include "printing/pdf_render_settings.h"
 #include "printing/print_settings.h"
+#include "printing/printing_context.h"
 #include "printing/units.h"
 #include "third_party/icu/source/i18n/unicode/ulocdata.h"
 
 #if defined(OS_CHROMEOS)
 #include "chrome/browser/chromeos/settings/device_oauth2_token_service.h"
 #include "chrome/browser/chromeos/settings/device_oauth2_token_service_factory.h"
 #endif
 
 #if defined(ENABLE_SERVICE_DISCOVERY)
 #include "chrome/browser/local_discovery/privet_constants.h"
@@ skipping 93 matching lines @@
 const char kNumberFormat[] = "numberFormat";
 // Name of a dictionary field specifying whether to print automatically in
 // kiosk mode. See http://crbug.com/31395.
 const char kPrintAutomaticallyInKioskMode[] = "printAutomaticallyInKioskMode";
 #if defined(OS_WIN)
 const char kHidePrintWithSystemDialogLink[] = "hidePrintWithSystemDialogLink";
 #endif
 // Name of a dictionary field holding the state of selection for document.
 const char kDocumentHasSelection[] = "documentHasSelection";
 
+// Id of the predefined PDF printer.
+const char kLocalPdfPrinterId[] = "Save as PDF";
+
 // Additional printer capability setting keys.
 const char kPrinterId[] = "printerId";
+const char kPrinterCapabilities[] = "capabilities";
 const char kDisableColorOption[] = "disableColorOption";
 const char kSetDuplexAsDefault[] = "setDuplexAsDefault";
 const char kPrinterDefaultDuplexValue[] = "printerDefaultDuplexValue";
 #if defined(USE_CUPS)
 const char kCUPSsColorModel[] = "cupsColorModel";
 const char kCUPSsBWModel[] = "cupsBWModel";
 #endif
 
 // Get the print job settings dictionary from |args|. The caller takes
 // ownership of the returned DictionaryValue. Returns NULL on failure.
@@ skipping 66 matching lines @@
 
 // Callback that stores a PDF file on disk.
 void PrintToPdfCallback(printing::Metafile* metafile,
                         const base::FilePath& path) {
   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
   metafile->SaveTo(path);
   // |metafile| must be deleted on the UI thread.
   BrowserThread::DeleteSoon(BrowserThread::UI, FROM_HERE, metafile);
 }
 
-std::string GetDefaultPrinterOnFileThread(
-    scoped_refptr<printing::PrintBackend> print_backend) {
+std::string GetDefaultPrinterOnFileThread() {
   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
 
+  scoped_refptr<printing::PrintBackend> print_backend(
+      printing::PrintBackend::CreateInstance(NULL));
+
   std::string default_printer = print_backend->GetDefaultPrinterName();
   VLOG(1) << "Default Printer: " << default_printer;
   return default_printer;
 }
 
-void EnumeratePrintersOnFileThread(
-    scoped_refptr<printing::PrintBackend> print_backend,
-    base::ListValue* printers) {
+gfx::Size GetDefaultPdfMediaSizeMicrons() {
+  scoped_ptr<printing::PrintingContext> printing_context(
+      printing::PrintingContext::Create(
+          g_browser_process->GetApplicationLocale()));
+  if (printing::PrintingContext::OK != printing_context->UsePdfSettings() ||
+      printing_context->settings().device_units_per_inch() <= 0) {
+    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;
+
+scoped_ptr<base::DictionaryValue> GetPdfCapabilitiesOnFileThread(
+    const std::string& locale) {
   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
 
+  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);
+
+  ColorCapability color;
+  color.AddDefaultOption(Color(STANDARD_COLOR), true);
+  color.SaveTo(&description);
+
+  static const cloud_devices::printer::MediaType kPdfMedia[] = {
+    ISO_A4,
+    ISO_A3,
+    NA_LETTER,
+    NA_LEGAL,
+    NA_LEDGER
+  };
+  const gfx::Size default_media_size = GetDefaultPdfMediaSizeMicrons();
+  Media default_media(
+      "", default_media_size.width(), default_media_size.height());
+  if (!default_media.MatchBySize() ||
+      std::find(kPdfMedia,
+                kPdfMedia + arraysize(kPdfMedia),
+                default_media.type) == kPdfMedia + arraysize(kPdfMedia)) {
+    default_media = Media(locale == "en-US" ? NA_LETTER : ISO_A4);
+  }
+  MediaCapability media;
+  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 scoped_ptr<base::DictionaryValue>(description.root().DeepCopy());
+}
+
+void EnumeratePrintersOnFileThread(base::ListValue* printers) {
+  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
+
+  scoped_refptr<printing::PrintBackend> print_backend(
+      printing::PrintBackend::CreateInstance(NULL));
+
   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) {
     base::DictionaryValue* printer_info = new base::DictionaryValue;
     printers->Append(printer_info);
     std::string printer_name;
     std::string printer_description;
@@ skipping 28 matching lines @@
   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;
 
 void GetPrinterCapabilitiesOnFileThread(
-    scoped_refptr<printing::PrintBackend> print_backend,
     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());
 
+  // Special case for PDF printer.
+  if (printer_name == kLocalPdfPrinterId) {
+    scoped_ptr<base::DictionaryValue> printer_info(new base::DictionaryValue);
+    printer_info->SetString(kPrinterId, printer_name);
+    printer_info->Set(kPrinterCapabilities,
+                      GetPdfCapabilitiesOnFileThread(locale).release());
+    BrowserThread::PostTask(
+        BrowserThread::UI, FROM_HERE,
+        base::Bind(success_cb, base::Owned(printer_info.release())));
+    return;
+  }
+
+  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)) {
     // TODO(gene): Notify explicitly if printer is not valid, instead of
     // failed to get capabilities.
     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
                             base::Bind(failure_cb, printer_name));
     return;
@@ skipping 11 matching lines @@
   settings_info->SetString(kPrinterId, printer_name);
   settings_info->SetBoolean(kDisableColorOption, !info.color_changeable);
   settings_info->SetBoolean(printing::kSettingSetColorAsDefault,
                             info.color_default);
 #if defined(USE_CUPS)
   settings_info->SetInteger(kCUPSsColorModel, info.color_model);
   settings_info->SetInteger(kCUPSsBWModel, info.bw_model);
 #endif
 
   // TODO(gene): Make new capabilities format for Print Preview
-  // that will suit semantic capabiltities better.
+  // that will suit semantic capabilities better.
   // Refactor pld API code below
   bool default_duplex = info.duplex_capable ?
       (info.duplex_default != printing::SIMPLEX) : false;
   int duplex_value = info.duplex_capable ?
       printing::LONG_EDGE : printing::UNKNOWN_DUPLEX_MODE;
   settings_info->SetBoolean(kSetDuplexAsDefault, default_duplex);
   settings_info->SetInteger(kPrinterDefaultDuplexValue, duplex_value);
 
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
@@ skipping 87 matching lines @@
 
   typedef std::map<std::string,
                    linked_ptr<OAuth2TokenService::Request> > Requests;
   Requests requests_;
   PrintPreviewHandler* handler_;
 
   DISALLOW_COPY_AND_ASSIGN(AccessTokenService);
 };
 
 PrintPreviewHandler::PrintPreviewHandler()
-    : print_backend_(printing::PrintBackend::CreateInstance(NULL)),
-      regenerate_preview_request_count_(0),
+    : regenerate_preview_request_count_(0),
       manage_printers_dialog_request_count_(0),
       manage_cloud_printers_dialog_request_count_(0),
       reported_failed_preview_(false),
       has_logged_printers_count_(false),
       weak_factory_(this) {
   ReportUserActionHistogram(PREVIEW_STARTED);
 }
 
 PrintPreviewHandler::~PrintPreviewHandler() {
   if (select_file_dialog_.get())
@@ skipping 73 matching lines @@
 }
 
 WebContents* PrintPreviewHandler::preview_web_contents() const {
   return web_ui()->GetWebContents();
 }
 
 void PrintPreviewHandler::HandleGetPrinters(const base::ListValue* /*args*/) {
   base::ListValue* results = new base::ListValue;
   BrowserThread::PostTaskAndReply(
       BrowserThread::FILE, FROM_HERE,
-      base::Bind(&EnumeratePrintersOnFileThread, print_backend_,
+      base::Bind(&EnumeratePrintersOnFileThread,
                  base::Unretained(results)),
       base::Bind(&PrintPreviewHandler::SetupPrinterList,
                  weak_factory_.GetWeakPtr(),
                  base::Owned(results)));
 }
 
 void PrintPreviewHandler::HandleGetPrivetPrinters(const base::ListValue* args) {
 #if defined(ENABLE_SERVICE_DISCOVERY)
   if (PrivetPrintingEnabled()) {
     Profile* profile = Profile::FromWebUI(web_ui());
@@ skipping 295 matching lines @@
   bool ret = args->GetString(0, &printer_name);
   if (!ret || printer_name.empty())
     return;
 
   GetPrinterCapabilitiesSuccessCallback success_cb =
       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,
-                 print_backend_, printer_name, success_cb, failure_cb));
+  BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE,
+                          base::Bind(&GetPrinterCapabilitiesOnFileThread,
+                                     printer_name,
+                                     g_browser_process->GetApplicationLocale(),
+                                     success_cb, failure_cb));
 }
 
 void PrintPreviewHandler::OnSigninComplete() {
   PrintPreviewUI* print_preview_ui =
       static_cast<PrintPreviewUI*>(web_ui()->GetController());
   if (print_preview_ui)
     print_preview_ui->OnReloadPrintersList();
 }
 
 void PrintPreviewHandler::HandleSignin(const base::ListValue* args) {
@@ skipping 131 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();
   BrowserThread::PostTaskAndReplyWithResult(
       BrowserThread::FILE, FROM_HERE,
-      base::Bind(&GetDefaultPrinterOnFileThread, print_backend_),
+      base::Bind(&GetDefaultPrinterOnFileThread),
       base::Bind(&PrintPreviewHandler::SendInitialSettings,
                  weak_factory_.GetWeakPtr()));
 }
 
 void PrintPreviewHandler::HandleReportUiEvent(const base::ListValue* args) {
   int event_group, event_number;
   if (!args->GetInteger(0, &event_group) || !args->GetInteger(1, &event_number))
     return;
 
   enum UiBucketGroups ui_bucket_group =
@@ skipping 511 matching lines @@
   printer_value->SetString("name", description.name);
   printer_value->SetBoolean("hasLocalPrinting", has_local_printing);
   printer_value->SetBoolean(
       "isUnregistered",
       description.id.empty() &&
       command_line->HasSwitch(switches::kEnablePrintPreviewRegisterPromos));
   printer_value->SetString("cloudID", description.id);
 }
 
 #endif