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 38 matching lines @@
 #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/page_range.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 190 matching lines @@
 
 std::string GetDefaultPrinterOnFileThread(
     scoped_refptr<printing::PrintBackend> print_backend) {
   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
 
   std::string default_printer = print_backend->GetDefaultPrinterName();
   VLOG(1) << "Default Printer: " << default_printer;
   return default_printer;
 }
 
+gfx::Size GetDefaultPdfMediaSizeMicrons() {
+  scoped_ptr<printing::PrintingContext> printing_context(
+        printing::PrintingContext::Create(
+            g_browser_process->GetApplicationLocale()));
+  scoped_ptr<base::DictionaryValue> pdf_settings(new base::DictionaryValue);
+  pdf_settings->SetBoolean(printing::kSettingHeaderFooterEnabled, false);
+  pdf_settings->SetBoolean(printing::kSettingShouldPrintBackgrounds, false);
+  pdf_settings->SetBoolean(printing::kSettingShouldPrintSelectionOnly, false);
+  pdf_settings->SetInteger(printing::kSettingMarginsType, printing::NO_MARGINS);
+  pdf_settings->SetBoolean(printing::kSettingCollate, true);
+  pdf_settings->SetInteger(printing::kSettingCopies, 1);
+  pdf_settings->SetInteger(printing::kSettingColor, printing::COLOR);
+  pdf_settings->SetInteger(printing::kSettingDuplexMode, printing::SIMPLEX);
+  pdf_settings->SetBoolean(printing::kSettingLandscape, false);

[Vitaly Buka (NO REVIEWS), 2014/05/20 23:53:02]

move to context

[Aleksey Shlyapnikov, 2014/05/22 00:08:14]

Done.

+  pdf_settings->SetString(printing::kSettingDeviceName, "");
+  pdf_settings->SetBoolean(printing::kSettingPrintToPDF, true);
+  pdf_settings->SetBoolean(printing::kSettingCloudPrintDialog, false);
+  pdf_settings->SetBoolean(printing::kSettingPrintWithPrivet, false);
+
+  printing::PrintingContext::Result result =
+      printing_context->UpdatePrintSettings(*pdf_settings,
+                                            printing::PageRanges());
+  if (printing::PrintingContext::OK != result ||
+      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;
+
+const struct {
+  int width_microns;
+  int height_microns;
+  const char* name;
+} PDF_MEDIA_SIZE[] = {
+  {
+      209900, /*x*/ 297000,
+      "ISO_A4"
+  },
+  {
+      297000, /*x*/ 420000,
+      "ISO_A3"
+  },
+  {
+      215900, /*x*/ 279400,
+      "NA_LETTER"
+  },
+  {
+      215900, /*x*/ 355600,
+      "NA_LEGAL"
+  },
+  {
+      279400, /*x*/ 431800,
+      "NA_LEDGER"
+  }
+};
+
+void GetPdfCapabilitiesOnFileThread(
+    scoped_refptr<printing::PrintBackend> print_backend,
+    const GetPdfCapabilitiesCallback& capabilities_cb) {
+  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
+
+  gfx::Size default_media_size = GetDefaultPdfMediaSizeMicrons();
+
+  // Create a list of media.
+  scoped_ptr<base::ListValue> media_size_option(new base::ListValue);
+
+  base::DictionaryValue* default_media_item = 0;
+  int max_diff = default_media_size.width() + default_media_size.height();
+  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(PDF_MEDIA_SIZE); ++i) {
+    scoped_ptr<base::DictionaryValue> media_item(new base::DictionaryValue);
+    media_item->SetInteger("width_microns", PDF_MEDIA_SIZE[i].width_microns);
+    media_item->SetInteger("height_microns", PDF_MEDIA_SIZE[i].height_microns);
+    media_item->SetString("name", PDF_MEDIA_SIZE[i].name);
+    int diff =
+        abs(default_media_size.width() - PDF_MEDIA_SIZE[i].width_microns) +
+        abs(default_media_size.height() - PDF_MEDIA_SIZE[i].height_microns);
+    if (max_diff >= diff) {

[Vitaly Buka (NO REVIEWS), 2014/05/20 23:53:02]

TEST(PrinterDescriptionTest, CddSetAll)

[Aleksey Shlyapnikov, 2014/05/22 00:08:14]

Done.

+      max_diff = diff;
+      default_media_item = media_item.get();
+    }
+    media_size_option->Append(media_item.release());
+  }
+  if (!default_media_item) {
+    media_size_option->GetDictionary(0, &default_media_item);
+  }
+  default_media_item->SetBoolean("is_default", true);
+
+  scoped_ptr<base::DictionaryValue> media_size(new base::DictionaryValue);
+  media_size->Set("option", media_size_option.release());
+
+  scoped_ptr<base::DictionaryValue> printer(new base::DictionaryValue);
+  printer->Set("media_size", media_size.release());
+
+  scoped_ptr<base::DictionaryValue> capabilities(new base::DictionaryValue);
+  capabilities->Set("printer", printer.release());
+
+  BrowserThread::PostTask(
+      BrowserThread::UI, FROM_HERE,
+      base::Bind(capabilities_cb, base::Owned(capabilities.release())));
+}
+
 void EnumeratePrintersOnFileThread(
     scoped_refptr<printing::PrintBackend> print_backend,
     base::ListValue* printers) {
   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
 
   VLOG(1) << "Enumerate printers start";
   printing::PrinterList printer_list;
   print_backend->EnumeratePrinters(&printer_list);
 
   for (printing::PrinterList::iterator it = printer_list.begin();
@@ skipping 37 matching lines @@
 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 GetPrinterCapabilitiesSuccessCallback& success_cb,
     const GetPrinterCapabilitiesFailureCallback& failure_cb) {
   DCHECK_CURRENTLY_ON(BrowserThread::FILE);

[Vitaly Buka (NO REVIEWS), 2014/05/20 23:53:02]

calculate here?

[Aleksey Shlyapnikov, 2014/05/22 00:08:14]

Done.

   DCHECK(!printer_name.empty());
 
   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,
@@ skipping 179 matching lines @@
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback("cancelPendingPrintRequest",
       base::Bind(&PrintPreviewHandler::HandleCancelPendingPrintRequest,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback("saveAppState",
       base::Bind(&PrintPreviewHandler::HandleSaveAppState,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback("getInitialSettings",
       base::Bind(&PrintPreviewHandler::HandleGetInitialSettings,
                  base::Unretained(this)));
+  web_ui()->RegisterMessageCallback("getPdfCapabilities",
+      base::Bind(&PrintPreviewHandler::HandleGetPdfCapabilities,
+                 base::Unretained(this)));
   web_ui()->RegisterMessageCallback("reportUiEvent",
       base::Bind(&PrintPreviewHandler::HandleReportUiEvent,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback("printWithCloudPrintDialog",
       base::Bind(&PrintPreviewHandler::HandlePrintWithCloudPrintDialog,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback("forceOpenNewTab",
       base::Bind(&PrintPreviewHandler::HandleForceOpenNewTab,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback("getPrivetPrinters",
@@ skipping 493 matching lines @@
     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(&PrintPreviewHandler::SendInitialSettings,
                  weak_factory_.GetWeakPtr()));
 }
 
+void PrintPreviewHandler::HandleGetPdfCapabilities(
+    const base::ListValue* /*args*/) {
+  GetPdfCapabilitiesCallback capabilities_cb =
+      base::Bind(&PrintPreviewHandler::SendPdfCapabilities,
+                 weak_factory_.GetWeakPtr());
+  BrowserThread::PostTask(
+      BrowserThread::FILE, FROM_HERE,
+      base::Bind(&GetPdfCapabilitiesOnFileThread,
+                 print_backend_, capabilities_cb));
+}
+
 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 =
       static_cast<enum UiBucketGroups>(event_group);
   if (ui_bucket_group >= UI_BUCKET_GROUP_BOUNDARY)
     return;
 
@@ skipping 62 matching lines @@
   // metro.
   bool is_ash = (chrome::GetActiveDesktop() == chrome::HOST_DESKTOP_TYPE_ASH);
   initial_settings.SetBoolean(kHidePrintWithSystemDialogLink, is_ash);
 #endif
 
   if (print_preview_ui->source_is_modifiable())
     GetNumberFormatAndMeasurementSystem(&initial_settings);
   web_ui()->CallJavascriptFunction("setInitialSettings", initial_settings);
 }
 
+void PrintPreviewHandler::SendPdfCapabilities(
+    const base::DictionaryValue* capabilities) {
+  web_ui()->CallJavascriptFunction("setPdfCapabilities", *capabilities);
+}
+
 void PrintPreviewHandler::ClosePreviewDialog() {
   PrintPreviewUI* print_preview_ui =
       static_cast<PrintPreviewUI*>(web_ui()->GetController());
   print_preview_ui->OnClosePrintPreviewDialog();
 }
 
 void PrintPreviewHandler::SendAccessToken(const std::string& type,
                                           const std::string& access_token) {
   VLOG(1) << "Get getAccessToken finished";
   web_ui()->CallJavascriptFunction("onDidGetAccessToken",
@@ skipping 425 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