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

chrome/browser/printing/print_system_task_proxy.cc

Index: chrome/browser/printing/print_system_task_proxy.cc
===================================================================
--- chrome/browser/printing/print_system_task_proxy.cc	(revision 105094)
+++ chrome/browser/printing/print_system_task_proxy.cc	(working copy)
@@ -1,543 +0,0 @@
-// 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/printing/print_system_task_proxy.h"
-
-#include <ctype.h>
-
-#include <string>
-#include <vector>
-
-#include "base/bind.h"
-#include "base/metrics/histogram.h"
-#include "base/string_split.h"
-#include "base/string_util.h"
-#include "base/values.h"
-#include "printing/backend/print_backend.h"
-#include "printing/print_job_constants.h"
-#include "printing/print_settings.h"
-
-#if defined(USE_CUPS)
-#include <cups/cups.h>
-#include <cups/ppd.h>
-
-#include "base/file_util.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(FilePath(
-      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 kPrinterColorModelForBlack[] = "printerColorModelForBlack";
-const char kPrinterColorModelForColor[] = "printerColorModelForColor";
-const char kPrinterDefaultDuplexValue[] = "printerDefaultDuplexValue";
-
-#if defined(OS_WIN)
-const char kPskColor[] = "psk:Color";
-const char kPskGray[] = "psk:Grayscale";
-const char kPskMonochrome[] = "psk:Monochrome";
-const char kPskDuplexFeature[] = "psk:JobDuplexAllDocumentsContiguously";
-const char kPskTwoSided[] = "psk:TwoSided";
-#elif defined(USE_CUPS)
-const char kColorDevice[] = "ColorDevice";
-const char kColorModel[] = "ColorModel";
-const char kColorMode[] = "ColorMode";
-const char kProcessColorModel[] = "ProcessColorModel";
-const char kPrintoutMode[] = "PrintoutMode";
-const char kDraftGray[] = "Draft.Gray";
-const char kHighGray[] = "High.Gray";
-
-const char kDuplex[] = "Duplex";
-const char kDuplexNone[] = "None";
-
-bool getBasicColorModelSettings(
-    ppd_file_t* ppd, int* color_model_for_black, int* color_model_for_color,
-    bool* color_is_default) {
-  ppd_option_t* color_model = ppdFindOption(ppd, kColorModel);
-  if (!color_model)
-    return false;
-
-  if (ppdFindChoice(color_model, printing::kBlack))
-    *color_model_for_black = printing::BLACK;
-  else if (ppdFindChoice(color_model, printing::kGray))
-    *color_model_for_black = printing::GRAY;
-
-  if (ppdFindChoice(color_model, printing::kColor))
-    *color_model_for_color = printing::COLOR;
-  else if (ppdFindChoice(color_model, printing::kCMYK))
-    *color_model_for_color = printing::CMYK;
-  else if (ppdFindChoice(color_model, printing::kRGB))
-    *color_model_for_color = printing::RGB;
-  else if (ppdFindChoice(color_model, printing::kRGBA))
-    *color_model_for_color = printing::RGBA;
-  else if (ppdFindChoice(color_model, printing::kRGB16))
-    *color_model_for_color = printing::RGB16;
-  else if (ppdFindChoice(color_model, printing::kCMY))
-    *color_model_for_color = printing::CMY;
-  else if (ppdFindChoice(color_model, printing::kKCMY))
-    *color_model_for_color = printing::KCMY;
-  else if (ppdFindChoice(color_model, printing::kCMY_K))
-    *color_model_for_color = printing::CMY_K;
-
-  ppd_choice_t* marked_choice = ppdFindMarkedChoice(ppd, kColorModel);
-  if (!marked_choice)
-    marked_choice = ppdFindChoice(color_model, color_model->defchoice);
-
-  if (marked_choice) {
-    *color_is_default =
-        (base::strcasecmp(marked_choice->choice, printing::kBlack) != 0) &&
-        (base::strcasecmp(marked_choice->choice, printing::kGray) != 0);
-  }
-  return true;
-}
-
-bool getPrintOutModeColorSettings(
-    ppd_file_t* ppd, int* color_model_for_black, int* color_model_for_color,
-    bool* color_is_default) {
-  ppd_option_t* printout_mode = ppdFindOption(ppd, kPrintoutMode);
-  if (!printout_mode)
-    return false;
-
-  *color_model_for_color = printing::PRINTOUTMODE_NORMAL;
-  *color_model_for_black = printing::PRINTOUTMODE_NORMAL;
-
-  // Check to see if NORMAL_GRAY value is supported by PrintoutMode.
-  // If NORMAL_GRAY is not supported, NORMAL value is used to
-  // represent grayscale. If NORMAL_GRAY is supported, NORMAL is used to
-  // represent color.
-  if (ppdFindChoice(printout_mode, printing::kNormalGray))
-    *color_model_for_black = printing::PRINTOUTMODE_NORMAL_GRAY;
-
-  // Get the default marked choice to identify the default color setting
-  // value.
-  ppd_choice_t* printout_mode_choice = ppdFindMarkedChoice(ppd, kPrintoutMode);
-  if (!printout_mode_choice) {
-      printout_mode_choice = ppdFindChoice(printout_mode,
-                                           printout_mode->defchoice);
-  }
-  if (printout_mode_choice) {
-    if ((base::strcasecmp(printout_mode_choice->choice,
-                          printing::kNormalGray) == 0) ||
-        (base::strcasecmp(printout_mode_choice->choice, kHighGray) == 0) ||
-        (base::strcasecmp(printout_mode_choice->choice, kDraftGray) == 0)) {
-      *color_model_for_black = printing::PRINTOUTMODE_NORMAL_GRAY;
-      *color_is_default = false;
-    }
-  }
-  return true;
-}
-
-bool getColorModeSettings(
-    ppd_file_t* ppd, int* color_model_for_black, int* color_model_for_color,
-    bool* color_is_default) {
-  // Samsung printers use "ColorMode" attribute in their ppds.
-  ppd_option_t* color_mode_option = ppdFindOption(ppd, kColorMode);
-  if (!color_mode_option)
-    return false;
-
-  if (ppdFindChoice(color_mode_option, printing::kColor))
-    *color_model_for_color = printing::COLORMODE_COLOR;
-
-  if (ppdFindChoice(color_mode_option, printing::kMonochrome))
-    *color_model_for_black = printing::COLORMODE_MONOCHROME;
-
-  ppd_choice_t* mode_choice = ppdFindMarkedChoice(ppd, kColorMode);
-  if (!mode_choice) {
-    mode_choice = ppdFindChoice(color_mode_option,
-                                color_mode_option->defchoice);
-  }
-
-  if (mode_choice) {
-    *color_is_default =
-        (base::strcasecmp(mode_choice->choice, printing::kColor) == 0);
-  }
-  return true;
-}
-
-bool getHPColorSettings(
-    ppd_file_t* ppd, int* color_model_for_black, int* color_model_for_color,
-    bool* color_is_default) {
-  // HP printers use "Color/Color Model" attribute in their ppds.
-  ppd_option_t* color_mode_option = ppdFindOption(ppd, printing::kColor);
-  if (!color_mode_option)
-    return false;
-
-  if (ppdFindChoice(color_mode_option, printing::kColor))
-    *color_model_for_color = printing::HP_COLOR_COLOR;
-  if (ppdFindChoice(color_mode_option, printing::kBlack))
-    *color_model_for_black = printing::HP_COLOR_BLACK;
-
-  ppd_choice_t* mode_choice = ppdFindMarkedChoice(ppd, kColorMode);
-  if (!mode_choice) {
-    mode_choice = ppdFindChoice(color_mode_option,
-                                color_mode_option->defchoice);
-  }
-  if (mode_choice) {
-    *color_is_default =
-        (base::strcasecmp(mode_choice->choice, printing::kColor) == 0);
-  }
-  return true;
-}
-
-bool getProcessColorModelSettings(
-    ppd_file_t* ppd, int* color_model_for_black, int* color_model_for_color,
-    bool* color_is_default) {
-  // Canon printers use "ProcessColorModel" attribute in their ppds.
-  ppd_option_t* color_mode_option =  ppdFindOption(ppd, kProcessColorModel);
-  if (!color_mode_option)
-    return false;
-
-  if (ppdFindChoice(color_mode_option, printing::kRGB))
-    *color_model_for_color = printing::PROCESSCOLORMODEL_RGB;
-  else if (ppdFindChoice(color_mode_option, printing::kCMYK))
-    *color_model_for_color = printing::PROCESSCOLORMODEL_CMYK;
-
-  if (ppdFindChoice(color_mode_option, printing::kGreyscale))
-    *color_model_for_black = printing::PROCESSCOLORMODEL_GREYSCALE;
-
-  ppd_choice_t* mode_choice = ppdFindMarkedChoice(ppd, kProcessColorModel);
-  if (!mode_choice) {
-    mode_choice = ppdFindChoice(color_mode_option,
-                                color_mode_option->defchoice);
-  }
-
-  if (mode_choice) {
-    *color_is_default =
-        (base::strcasecmp(mode_choice->choice, printing::kGreyscale) != 0);
-  }
-  return true;
-}
-#endif
-
-}  // namespace
-
-PrintSystemTaskProxy::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) {
-}
-
-PrintSystemTaskProxy::~PrintSystemTaskProxy() {
-}
-
-void PrintSystemTaskProxy::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 PrintSystemTaskProxy::SendDefaultPrinter(
-    const StringValue* default_printer, const StringValue* cloud_print_data) {
-  if (handler_)
-    handler_->SendDefaultPrinter(*default_printer, *cloud_print_data);
-  delete default_printer;
-}
-
-void PrintSystemTaskProxy::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 PrintSystemTaskProxy::SetupPrinterList(ListValue* printers) {
-  if (handler_)
-    handler_->SetupPrinterList(*printers);
-  delete printers;
-}
-
-void PrintSystemTaskProxy::GetPrinterCapabilities(
-    const std::string& printer_name) {
-  VLOG(1) << "Get printer capabilities start for " << printer_name;
-  printing::PrinterCapsAndDefaults printer_info;
-
-  bool set_color_as_default = false;
-  bool disable_color_options = true;
-  bool set_duplex_as_default = false;
-  int printer_color_space_for_color = printing::UNKNOWN_COLOR_MODEL;
-  int printer_color_space_for_black = printing::UNKNOWN_COLOR_MODEL;
-  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_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;
-      }
-    }
-
-    bool is_color_device = false;
-    ppd_attr_t* attr = ppdFindAttr(ppd, kColorDevice, NULL);
-    if (attr && attr->value)
-      is_color_device = ppd->color_device;
-    disable_color_options = !is_color_device;
-    set_color_as_default = is_color_device;
-
-    if (!((is_color_device && getBasicColorModelSettings(
-              ppd, &printer_color_space_for_black,
-              &printer_color_space_for_color, &set_color_as_default)) ||
-          getPrintOutModeColorSettings(
-              ppd, &printer_color_space_for_black,
-              &printer_color_space_for_color, &set_color_as_default) ||
-          getColorModeSettings(
-              ppd, &printer_color_space_for_black,
-              &printer_color_space_for_color, &set_color_as_default) ||
-          getHPColorSettings(
-              ppd, &printer_color_space_for_black,
-              &printer_color_space_for_color, &set_color_as_default) ||
-          getProcessColorModelSettings(
-              ppd, &printer_color_space_for_black,
-              &printer_color_space_for_color, &set_color_as_default))) {
-      VLOG(1) << "Unknown printer color model";
-    }
-    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.
-  if (printer_info.printer_capabilities.find(kPskColor) != std::string::npos)
-    printer_color_space_for_color = printing::COLOR;
-
-  if ((printer_info.printer_capabilities.find(kPskGray) !=
-          std::string::npos) ||
-      (printer_info.printer_capabilities.find(kPskMonochrome) !=
-          std::string::npos)) {
-    printer_color_space_for_black = printing::GRAY;
-  }
-  set_color_as_default =
-      (printer_info.printer_defaults.find(kPskColor) != std::string::npos);
-
-  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
-  disable_color_options = !printer_color_space_for_color ||
-                          !printer_color_space_for_black ||
-                          (printer_color_space_for_color ==
-                           printer_color_space_for_black);
-
-  DictionaryValue settings_info;
-  settings_info.SetBoolean(kDisableColorOption, disable_color_options);
-  if (printer_color_space_for_color == printing::UNKNOWN_COLOR_MODEL)
-    printer_color_space_for_color = printing::COLOR;
-
-  if (printer_color_space_for_black == printing::UNKNOWN_COLOR_MODEL)
-    printer_color_space_for_black = printing::GRAY;
-
-  if (disable_color_options ||
-      PrintPreviewHandler::last_used_color_model_ ==
-          printing::UNKNOWN_COLOR_MODEL) {
-    settings_info.SetBoolean(kSetColorAsDefault, set_color_as_default);
-  } else {
-    settings_info.SetBoolean(kSetColorAsDefault,
-                             printing::isColorModelSelected(
-                                 PrintPreviewHandler::last_used_color_model_));
-  }
-
-  settings_info.SetBoolean(kSetDuplexAsDefault, set_duplex_as_default);
-  settings_info.SetInteger(kPrinterColorModelForColor,
-                           printer_color_space_for_color);
-  settings_info.SetInteger(kPrinterColorModelForBlack,
-                           printer_color_space_for_black);
-  settings_info.SetInteger(kPrinterDefaultDuplexValue,
-                           default_duplex_setting_value);
-  BrowserThread::PostTask(
-      BrowserThread::UI, FROM_HERE,
-      base::Bind(&PrintSystemTaskProxy::SendPrinterCapabilities, this,
-                 settings_info.DeepCopy()));
-}
-
-void PrintSystemTaskProxy::SendPrinterCapabilities(
-    DictionaryValue* settings_info) {
-  if (handler_)
-    handler_->SendPrinterCapabilities(*settings_info);
-  delete settings_info;
-}