Revert 275646 "Generalize printer color model handling, get rid ..."

trunk/src/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"
 #include "base/memory/linked_ptr.h"
 #include "base/memory/ref_counted_memory.h"
 #include "base/metrics/histogram.h"
 #include "base/path_service.h"
 #include "base/prefs/pref_service.h"
-#include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/platform_util.h"
 #include "chrome/browser/printing/print_dialog_cloud.h"
 #include "chrome/browser/printing/print_error_dialog.h"
 #include "chrome/browser/printing/print_job_manager.h"
 #include "chrome/browser/printing/print_preview_dialog_controller.h"
@@ skipping 148 matching lines @@
 #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";
+#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.
 base::DictionaryValue* GetSettingsDictionary(const base::ListValue* args) {
   std::string json_str;
   if (!args->GetString(0, &json_str)) {
     NOTREACHED() << "Could not read JSON argument";
     return NULL;
   }
   if (json_str.empty()) {
@@ skipping 103 matching lines @@
   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 standard_color(STANDARD_COLOR);
-    standard_color.vendor_id = base::IntToString(printing::COLOR);
-    color.AddDefaultOption(standard_color, true);
-  }
+  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();
@@ skipping 38 matching lines @@
     return scoped_ptr<base::DictionaryValue>();
   }
 
   scoped_ptr<base::DictionaryValue> description(
       cloud_print::PrinterSemanticCapsAndDefaultsToCdd(info));
   if (!description) {
     LOG(WARNING) << "Failed to convert capabilities for " << printer_name;
     return scoped_ptr<base::DictionaryValue>();
   }
 
+#if defined(USE_CUPS)
+  // TODO(alekseys): Use CUSTOM_COLOR/MONOCHROME instead.
+  description->SetInteger(kCUPSsColorModel, info.color_model);
+  description->SetInteger(kCUPSsBWModel, info.bw_model);
+#endif
   return description.Pass();
 }
 
 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";
@@ skipping 72 matching lines @@
 
 base::LazyInstance<printing::StickySettings> g_sticky_settings =
     LAZY_INSTANCE_INITIALIZER;
 
 printing::StickySettings* GetStickySettings() {
   return g_sticky_settings.Pointer();
 }
 
 }  // namespace
 
+#if defined(USE_CUPS)
+struct PrintPreviewHandler::CUPSPrinterColorModels {
+  std::string printer_name;
+  printing::ColorModel color_model;
+  printing::ColorModel bw_model;
+};
+#endif
+
 class PrintPreviewHandler::AccessTokenService
     : public OAuth2TokenService::Consumer {
  public:
   explicit AccessTokenService(PrintPreviewHandler* handler)
       : OAuth2TokenService::Consumer("print_preview"),
         handler_(handler) {
   }
 
   void RequestToken(const std::string& type) {
     if (requests_.find(type) != requests_.end())
@@ skipping 379 matching lines @@
     // Do this so the initiator can open a new print preview dialog, while the
     // current print preview dialog is still handling its print job.
     ClearInitiatorDetails();
 
     // The PDF being printed contains only the pages that the user selected,
     // so ignore the page range and print all pages.
     settings->Remove(printing::kSettingPageRange, NULL);
     // Reset selection only flag for the same reason.
     settings->SetBoolean(printing::kSettingShouldPrintSelectionOnly, false);
 
+#if defined(USE_CUPS)
+    if (!open_pdf_in_preview)  // We can get here even for cloud printers.
+      ConvertColorSettingToCUPSColorModel(settings.get());
+#endif
+
     // Set ID to know whether printing is for preview.
     settings->SetInteger(printing::kPreviewUIID,
                          print_preview_ui->GetIDForPrintPreviewUI());
     RenderViewHost* rvh = preview_web_contents()->GetRenderViewHost();
     rvh->Send(new PrintMsg_PrintForPrintPreview(rvh->GetRoutingID(),
                                                 *settings));
 
     // For all other cases above, the preview dialog will stay open until the
     // printing has finished. Then the dialog closes and PrintPreviewDone() gets
     // called. In the case below, since the preview dialog will be hidden and
@@ skipping 324 matching lines @@
                                           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) {
   VLOG(1) << "Get printer capabilities finished";
+
+#if defined(USE_CUPS)
+  SaveCUPSColorSetting(settings_info);
+#endif
+
   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);
@@ skipping 156 matching lines @@
     // Nothing to print, no preview available.
     return false;
   }
   DCHECK(tmp_data->size() && tmp_data->front());
 
   *data = tmp_data;
   *title = print_preview_ui->initiator_title();
   return true;
 }
 
+#if defined(USE_CUPS)
+void PrintPreviewHandler::SaveCUPSColorSetting(
+    const base::DictionaryValue* settings) {
+  cups_printer_color_models_.reset(new CUPSPrinterColorModels);
+  settings->GetString(kPrinterId, &cups_printer_color_models_->printer_name);
+  const base::DictionaryValue* capabilities = NULL;
+  if (!settings->GetDictionary(kPrinterCapabilities, &capabilities) ||
+      !capabilities) {
+    NOTREACHED();
+    return;
+  }
+  capabilities->GetInteger(
+      kCUPSsColorModel,
+      reinterpret_cast<int*>(&cups_printer_color_models_->color_model));
+  capabilities->GetInteger(
+      kCUPSsBWModel,
+      reinterpret_cast<int*>(&cups_printer_color_models_->bw_model));
+}
+
+void PrintPreviewHandler::ConvertColorSettingToCUPSColorModel(
+    base::DictionaryValue* settings) const {
+  if (!cups_printer_color_models_)
+    return;
+
+  // Sanity check the printer name.
+  std::string printer_name;
+  if (!settings->GetString(printing::kSettingDeviceName, &printer_name) ||
+      printer_name != cups_printer_color_models_->printer_name) {
+    NOTREACHED();
+    return;
+  }
+
+  int color;
+  if (!settings->GetInteger(printing::kSettingColor, &color)) {
+    NOTREACHED();
+    return;
+  }
+
+  if (color == printing::GRAY) {
+    if (cups_printer_color_models_->bw_model != printing::UNKNOWN_COLOR_MODEL) {
+      settings->SetInteger(printing::kSettingColor,
+                           cups_printer_color_models_->bw_model);
+    }
+    return;
+  }
+
+  printing::ColorModel color_model = cups_printer_color_models_->color_model;
+  if (color_model != printing::UNKNOWN_COLOR_MODEL)
+    settings->SetInteger(printing::kSettingColor, color_model);
+}
+
+#endif  // defined(USE_CUPS)
+
 #if defined(ENABLE_SERVICE_DISCOVERY)
 void PrintPreviewHandler::LocalPrinterChanged(
     bool added,
     const std::string& name,
     bool has_local_printing,
     const local_discovery::DeviceDescription& description) {
   base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
   if (has_local_printing ||
       command_line->HasSwitch(switches::kEnablePrintPreviewRegisterPromos)) {
     base::DictionaryValue info;
@@ skipping 180 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  // defined(ENABLE_SERVICE_DISCOVERY)