Revert 105087 - PrintPreview: Fix printer color settings issues based on printer ppd/schema infor...

chrome/browser/ui/webui/print_preview_handler.cc

 // Copyright (c) 2011 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_handler.h"
 
 #include <ctype.h>
 
 #include <string>
 #include <vector>
 
 #include "base/base64.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/i18n/file_util_icu.h"
 #include "base/json/json_reader.h"
 #include "base/memory/ref_counted.h"
 #include "base/metrics/histogram.h"
 #include "base/path_service.h"
+#include "base/string_split.h"
+#include "base/string_util.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/platform_util.h"
 #include "chrome/browser/printing/background_printing_manager.h"
 #include "chrome/browser/printing/cloud_print/cloud_print_url.h"
 #include "chrome/browser/printing/print_dialog_cloud.h"
 #include "chrome/browser/printing/print_job_manager.h"
 #include "chrome/browser/printing/print_preview_tab_controller.h"
-#include "chrome/browser/printing/print_system_task_proxy.h"
 #include "chrome/browser/printing/print_view_manager.h"
 #include "chrome/browser/printing/printer_manager_dialog.h"
 #include "chrome/browser/sessions/restore_tab_helper.h"
 #include "chrome/browser/tabs/tab_strip_model.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/browser/ui/tab_contents/tab_contents_wrapper.h"
 #include "chrome/browser/ui/webui/cloud_print_signin_dialog.h"
 #include "chrome/browser/ui/webui/print_preview_ui.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/print_messages.h"
 #include "content/browser/browser_thread.h"
 #include "content/browser/renderer_host/render_view_host.h"
 #include "content/browser/tab_contents/tab_contents.h"
 #include "printing/backend/print_backend.h"
 #include "printing/metafile.h"
 #include "printing/metafile_impl.h"
 #include "printing/page_range.h"
-#include "printing/print_settings.h"
+#include "printing/print_job_constants.h"
+
+#if defined(USE_CUPS)
+#include <cups/cups.h>
+#include <cups/ppd.h>
+
+#include "base/file_util.h"
+#endif
 
 #if !defined(OS_CHROMEOS)
 #include "base/command_line.h"
 #include "chrome/common/chrome_switches.h"
 #endif
 
+#if defined(USE_CUPS) && !defined(OS_MACOSX)
+namespace printing_internal {
+
+void parse_lpoptions(const FilePath& filepath, const std::string& printer_name,
+                     int* num_options, cups_option_t** options) {
+  std::string content;
+  if (!file_util::ReadFileToString(filepath, &content))
+    return;
+
+  const char kDest[] = "dest";
+  const char kDefault[] = "default";
+  size_t kDestLen = sizeof(kDest) - 1;
+  size_t kDefaultLen = sizeof(kDefault) - 1;
+  std::vector <std::string> lines;
+  base::SplitString(content, '\n', &lines);
+
+  for (size_t i = 0; i < lines.size(); ++i) {
+    std::string line = lines[i];
+    if (line.empty())
+      continue;
+
+    if (base::strncasecmp (line.c_str(), kDefault, kDefaultLen) == 0 &&
+        isspace(line[kDefaultLen])) {
+      line = line.substr(kDefaultLen);
+    } else if (base::strncasecmp (line.c_str(), kDest, kDestLen) == 0 &&
+               isspace(line[kDestLen])) {
+      line = line.substr(kDestLen);
+    } else {
+      continue;
+    }
+
+    TrimWhitespaceASCII(line, TRIM_ALL, &line);
+    if (line.empty())
+      continue;
+
+    size_t space_found = line.find(' ');
+    if (space_found == std::string::npos)
+      continue;
+
+    std::string name = line.substr(0, space_found);
+    if (name.empty())
+      continue;
+
+    if (base::strncasecmp(printer_name.c_str(), name.c_str(),
+                          name.length()) != 0) {
+      continue;  // This is not the required printer.
+    }
+
+    line = line.substr(space_found + 1);
+    TrimWhitespaceASCII(line, TRIM_ALL, &line);  // Remove extra spaces.
+    if (line.empty())
+      continue;
+    // Parse the selected printer custom options.
+    *num_options = cupsParseOptions(line.c_str(), 0, options);
+  }
+}
+
+void mark_lpoptions(const std::string& printer_name, ppd_file_t** ppd) {
+  cups_option_t* options = NULL;
+  int num_options = 0;
+  ppdMarkDefaults(*ppd);
+
+  const char kSystemLpOptionPath[] = "/etc/cups/lpoptions";
+  const char kUserLpOptionPath[] = ".cups/lpoptions";
+
+  std::vector<FilePath> file_locations;
+  file_locations.push_back(FilePath(kSystemLpOptionPath));
+  file_locations.push_back(file_util::GetHomeDir().Append(kUserLpOptionPath));
+
+  for (std::vector<FilePath>::const_iterator it = file_locations.begin();
+       it != file_locations.end(); ++it) {
+    num_options = 0;
+    options = NULL;
+    parse_lpoptions(*it, printer_name, &num_options, &options);
+    if (num_options > 0 && options) {
+      cupsMarkOptions(*ppd, num_options, options);
+      cupsFreeOptions(num_options, options);
+    }
+  }
+}
+
+}  // printing_internal namespace
+#endif
+
 namespace {
 
+const char kDisableColorOption[] = "disableColorOption";
+const char kSetColorAsDefault[] = "setColorAsDefault";
+const char kSetDuplexAsDefault[] = "setDuplexAsDefault";
+const char kPrinterColorModelForColor[] = "printerColorModelForColor";
+const char kPrinterDefaultDuplexValue[] = "printerDefaultDuplexValue";
+
+#if defined(USE_CUPS)
+const char kColorDevice[] = "ColorDevice";
+const char kColorModel[] = "ColorModel";
+const char kColorModelForColor[] = "Color";
+const char kCMYK[] = "CMYK";
+const char kDuplex[] = "Duplex";
+const char kDuplexNone[] = "None";
+#elif defined(OS_WIN)
+const char kPskColor[] = "psk:Color";
+const char kPskDuplexFeature[] = "psk:JobDuplexAllDocumentsContiguously";
+const char kPskTwoSided[] = "psk:TwoSided";
+#endif
+
 enum UserActionBuckets {
   PRINT_TO_PRINTER,
   PRINT_TO_PDF,
   CANCEL,
   FALLBACK_TO_ADVANCED_SETTINGS_DIALOG,
   PREVIEW_FAILED,
   PREVIEW_STARTED,
   INITIATOR_TAB_CRASHED,
   INITIATOR_TAB_CLOSED,
   PRINT_WITH_CLOUD_PRINT,
@@ skipping 77 matching lines @@
   bool collate;
   if (settings.GetBoolean(printing::kSettingCollate, &collate) && collate)
     ReportPrintSettingHistogram(COLLATE);
 
   int duplex_mode;
   if (settings.GetInteger(printing::kSettingDuplexMode, &duplex_mode))
     ReportPrintSettingHistogram(duplex_mode ? DUPLEX : SIMPLEX);
 
   int color_mode;
   if (settings.GetInteger(printing::kSettingColor, &color_mode)) {
-    ReportPrintSettingHistogram(
-        printing::isColorModelSelected(color_mode) ? COLOR : BLACK_AND_WHITE);
+    ReportPrintSettingHistogram(color_mode == printing::GRAY ? BLACK_AND_WHITE :
+                                                               COLOR);
   }
 }
 
 printing::BackgroundPrintingManager* GetBackgroundPrintingManager() {
   return g_browser_process->background_printing_manager();
 }
 
 }  // namespace
 
+class PrintSystemTaskProxy
+    : public base::RefCountedThreadSafe<PrintSystemTaskProxy,
+                                        BrowserThread::DeleteOnUIThread> {
+ public:
+  PrintSystemTaskProxy(const base::WeakPtr<PrintPreviewHandler>& handler,
+                       printing::PrintBackend* print_backend,
+                       bool has_logged_printers_count)
+      : handler_(handler),
+        print_backend_(print_backend),
+        has_logged_printers_count_(has_logged_printers_count) {
+  }
+
+  void GetDefaultPrinter() {
+    VLOG(1) << "Get default printer start";
+    StringValue* default_printer = NULL;
+    if (PrintPreviewHandler::last_used_printer_name_ == NULL) {
+      default_printer = new StringValue(
+          print_backend_->GetDefaultPrinterName());
+    } else {
+      default_printer = new StringValue(
+          *PrintPreviewHandler::last_used_printer_name_);
+    }
+    std::string default_printer_string;
+    default_printer->GetAsString(&default_printer_string);
+    VLOG(1) << "Get default printer finished, found: "
+            << default_printer_string;
+
+    StringValue* cloud_print_data = NULL;
+    if (PrintPreviewHandler::last_used_printer_cloud_print_data_ != NULL) {
+      cloud_print_data = new StringValue(
+          *PrintPreviewHandler::last_used_printer_cloud_print_data_);
+    } else {
+      cloud_print_data = new StringValue("");
+    }
+
+    BrowserThread::PostTask(
+        BrowserThread::UI, FROM_HERE,
+        base::Bind(&PrintSystemTaskProxy::SendDefaultPrinter, this,
+                   default_printer, cloud_print_data));
+  }
+
+  void SendDefaultPrinter(const StringValue* default_printer,
+                          const StringValue* cloud_print_data) {
+    if (handler_)
+      handler_->SendDefaultPrinter(*default_printer, *cloud_print_data);
+    delete default_printer;
+  }
+
+  void EnumeratePrinters() {
+    VLOG(1) << "Enumerate printers start";
+    ListValue* printers = new ListValue;
+
+    printing::PrinterList printer_list;
+    print_backend_->EnumeratePrinters(&printer_list);
+
+    if (!has_logged_printers_count_) {
+      // Record the total number of printers.
+      UMA_HISTOGRAM_COUNTS("PrintPreview.NumberOfPrinters",
+                           printer_list.size());
+    }
+
+    int i = 0;
+    for (printing::PrinterList::iterator iter = printer_list.begin();
+         iter != printer_list.end(); ++iter, ++i) {
+      DictionaryValue* printer_info = new DictionaryValue;
+      std::string printerName;
+  #if defined(OS_MACOSX)
+      // On Mac, |iter->printer_description| specifies the printer name and
+      // |iter->printer_name| specifies the device name / printer queue name.
+      printerName = iter->printer_description;
+  #else
+      printerName = iter->printer_name;
+  #endif
+      printer_info->SetString(printing::kSettingPrinterName, printerName);
+      printer_info->SetString(printing::kSettingDeviceName, iter->printer_name);
+      printers->Append(printer_info);
+    }
+    VLOG(1) << "Enumerate printers finished, found " << i << " printers";
+
+    BrowserThread::PostTask(
+        BrowserThread::UI, FROM_HERE,
+        base::Bind(&PrintSystemTaskProxy::SetupPrinterList, this, printers));
+  }
+
+  void SetupPrinterList(ListValue* printers) {
+    if (handler_) {
+      handler_->SetupPrinterList(*printers);
+    }
+    delete printers;
+  }
+
+  void GetPrinterCapabilities(const std::string& printer_name) {
+    VLOG(1) << "Get printer capabilities start for " << printer_name;
+    printing::PrinterCapsAndDefaults printer_info;
+    bool supports_color = true;
+    bool set_duplex_as_default = false;
+    int printer_color_space = printing::GRAY;
+    int default_duplex_setting_value = printing::UNKNOWN_DUPLEX_MODE;
+    if (!print_backend_->GetPrinterCapsAndDefaults(printer_name,
+                                                   &printer_info)) {
+      return;
+    }
+
+#if defined(USE_CUPS)
+    FilePath ppd_file_path;
+    if (!file_util::CreateTemporaryFile(&ppd_file_path))
+      return;
+
+    int data_size = printer_info.printer_capabilities.length();
+    if (data_size != file_util::WriteFile(
+                         ppd_file_path,
+                         printer_info.printer_capabilities.data(),
+                         data_size)) {
+      file_util::Delete(ppd_file_path, false);
+      return;
+    }
+
+    ppd_file_t* ppd = ppdOpenFile(ppd_file_path.value().c_str());
+    if (ppd) {
+#if !defined(OS_MACOSX)
+      printing_internal::mark_lpoptions(printer_name, &ppd);
+#endif
+      ppd_attr_t* attr = ppdFindAttr(ppd, kColorDevice, NULL);
+      if (attr && attr->value)
+        supports_color = ppd->color_device;
+
+      ppd_choice_t* duplex_choice = ppdFindMarkedChoice(ppd, kDuplex);
+      if (duplex_choice) {
+        ppd_option_t* option = ppdFindOption(ppd, kDuplex);
+        if (option)
+          duplex_choice = ppdFindChoice(option, option->defchoice);
+      }
+
+      if (duplex_choice) {
+        if (base::strcasecmp(duplex_choice->choice, kDuplexNone) != 0) {
+          set_duplex_as_default = true;
+          default_duplex_setting_value = printing::LONG_EDGE;
+        } else {
+          default_duplex_setting_value = printing::SIMPLEX;
+        }
+      }
+
+      if (supports_color) {
+        // Identify the color space (COLOR/CMYK) for this printer.
+        ppd_option_t* color_model = ppdFindOption(ppd, kColorModel);
+        if (color_model) {
+          if (ppdFindChoice(color_model, kColorModelForColor))
+            printer_color_space = printing::COLOR;
+          else if (ppdFindChoice(color_model, kCMYK))
+            printer_color_space = printing::CMYK;
+        }
+      }
+      ppdClose(ppd);
+    }
+    file_util::Delete(ppd_file_path, false);
+#elif defined(OS_WIN)
+    // According to XPS 1.0 spec, only color printers have psk:Color.
+    // Therefore we don't need to parse the whole XML file, we just need to
+    // search the string.  The spec can be found at:
+    // http://msdn.microsoft.com/en-us/windows/hardware/gg463431.
+    supports_color = (printer_info.printer_capabilities.find(kPskColor) !=
+                      std::string::npos);
+    if (supports_color)
+      printer_color_space = printing::COLOR;
+
+    set_duplex_as_default =
+        (printer_info.printer_defaults.find(kPskDuplexFeature) !=
+            std::string::npos) &&
+        (printer_info.printer_defaults.find(kPskTwoSided) !=
+            std::string::npos);
+
+    if (printer_info.printer_defaults.find(kPskDuplexFeature) !=
+            std::string::npos) {
+        if (printer_info.printer_defaults.find(kPskTwoSided) !=
+                std::string::npos) {
+          default_duplex_setting_value = printing::LONG_EDGE;
+        } else {
+          default_duplex_setting_value = printing::SIMPLEX;
+        }
+    }
+#else
+  NOTIMPLEMENTED();
+#endif
+
+    DictionaryValue settings_info;
+    settings_info.SetBoolean(kDisableColorOption, !supports_color);
+    if (!supports_color) {
+      settings_info.SetBoolean(kSetColorAsDefault, false);
+    } else {
+       settings_info.SetBoolean(kSetColorAsDefault,
+                                PrintPreviewHandler::last_used_color_setting_);
+    }
+    settings_info.SetBoolean(kSetDuplexAsDefault, set_duplex_as_default);
+    settings_info.SetInteger(kPrinterColorModelForColor, printer_color_space);
+    settings_info.SetInteger(kPrinterDefaultDuplexValue,
+                             default_duplex_setting_value);
+    BrowserThread::PostTask(
+        BrowserThread::UI, FROM_HERE,
+        base::Bind(&PrintSystemTaskProxy::SendPrinterCapabilities, this,
+                   settings_info.DeepCopy()));
+  }
+
+  void SendPrinterCapabilities(DictionaryValue* settings_info) {
+    if (handler_)
+      handler_->SendPrinterCapabilities(*settings_info);
+    delete settings_info;
+  }
+
+ private:
+  friend struct BrowserThread::DeleteOnThread<BrowserThread::UI>;
+  friend class DeleteTask<PrintSystemTaskProxy>;
+
+  ~PrintSystemTaskProxy() {}
+
+  base::WeakPtr<PrintPreviewHandler> handler_;
+
+  scoped_refptr<printing::PrintBackend> print_backend_;
+
+  bool has_logged_printers_count_;
+
+  DISALLOW_COPY_AND_ASSIGN(PrintSystemTaskProxy);
+};
+
 // A Task implementation that stores a PDF file on disk.
 class PrintToPdfTask : public Task {
  public:
   // Takes ownership of |metafile|.
   PrintToPdfTask(printing::Metafile* metafile, const FilePath& path)
       : metafile_(metafile), path_(path) {
     DCHECK(metafile);
   }
 
   ~PrintToPdfTask() {
@@ skipping 12 matching lines @@
   scoped_ptr<printing::Metafile> metafile_;
 
   // The absolute path where the file will be saved.
   FilePath path_;
 };
 
 // static
 FilePath* PrintPreviewHandler::last_saved_path_ = NULL;
 std::string* PrintPreviewHandler::last_used_printer_cloud_print_data_ = NULL;
 std::string* PrintPreviewHandler::last_used_printer_name_ = NULL;
-printing::ColorModels PrintPreviewHandler::last_used_color_model_ =
-    printing::UNKNOWN_COLOR_MODEL;
+bool PrintPreviewHandler::last_used_color_setting_ = false;
 
 PrintPreviewHandler::PrintPreviewHandler()
     : print_backend_(printing::PrintBackend::CreateInstance(NULL)),
       regenerate_preview_request_count_(0),
       manage_printers_dialog_request_count_(0),
       reported_failed_preview_(false),
       has_logged_printers_count_(false) {
   ReportUserActionHistogram(PREVIEW_STARTED);
 }
 
@@ skipping 160 matching lines @@
   TabContentsWrapper* initiator_tab = GetInitiatorTab();
   if (initiator_tab) {
     RenderViewHost* rvh = initiator_tab->render_view_host();
     rvh->Send(new PrintMsg_ResetScriptedPrintCount(rvh->routing_id()));
   }
 
   scoped_ptr<DictionaryValue> settings(GetSettingsDictionary(args));
   if (!settings.get())
     return;
 
-  // Storing last used color model.
-  int color_model;
-  if (!settings->GetInteger(printing::kSettingColor, &color_model))
-    color_model = printing::GRAY;
-  last_used_color_model_ = static_cast<printing::ColorModels>(color_model);
+  // Storing last used color setting.
+  int color_mode;
+  if (!settings->GetInteger(printing::kSettingColor, &color_mode))
+    color_mode = printing::GRAY;
+  last_used_color_setting_ = (color_mode != printing::GRAY);
 
   bool print_to_pdf = false;
   settings->GetBoolean(printing::kSettingPrintToPDF, &print_to_pdf);
 
   settings->SetBoolean(printing::kSettingHeaderFooterEnabled, false);
 
   bool is_cloud_printer = settings->HasKey(printing::kSettingCloudPrintId);
   bool is_cloud_dialog = false;
   settings->GetBoolean(printing::kSettingCloudPrintDialog, &is_cloud_dialog);
   if (is_cloud_printer) {
@@ skipping 434 matching lines @@
     return;
 
   // We no longer require the initiator tab details. Remove those details
   // associated with the preview tab to allow the initiator tab to create
   // another preview tab.
   printing::PrintPreviewTabController* tab_controller =
       printing::PrintPreviewTabController::GetInstance();
   if (tab_controller)
     tab_controller->EraseInitiatorTabInfo(preview_tab_wrapper());
 }