Better detect color options for Samsung CUPS printers.

printing/backend/cups_helper.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 "printing/backend/cups_helper.h"
 
 #include <cups/ppd.h>
 #include <stddef.h>
 
 #include <string>
 #include <vector>
 
 #include "base/base_paths.h"
 #include "base/files/file_util.h"
 #include "base/logging.h"
 #include "base/path_service.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/values.h"
 #include "printing/backend/print_backend.h"
 #include "printing/backend/print_backend_consts.h"
 #include "printing/units.h"
 #include "url/gurl.h"
 
+using base::EqualsCaseInsensitiveASCII;
+
 namespace printing {
 
 // This section contains helper code for PPD parsing for semantic capabilities.
 namespace {
 
 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";
 
 constexpr char kDuplex[] = "Duplex";
 constexpr char kDuplexNone[] = "None";
 constexpr char kDuplexTumble[] = "DuplexTumble";
 constexpr char kPageSize[] = "PageSize";
 
 // Brother printer specific options.
 constexpr char kBrotherDuplex[] = "BRDuplex";
 constexpr char kBrotherMonoColor[] = "BRMonoColor";
 constexpr char kBrotherPrintQuality[] = "BRPrintQuality";
 
+// Samsung printer specific options.
+constexpr char kSamsungColorTrue[] = "True";
+constexpr char kSamsungColorFalse[] = "False";
+
 const double kMicronsPerPoint = 10.0f * kHundrethsMMPerInch / kPointsPerInch;
 
 void ParseLpOptions(const base::FilePath& filepath,
                     base::StringPiece printer_name,
                     int* num_options,
                     cups_option_t** options) {
   std::string content;
   if (!base::ReadFileToString(filepath, &content))
     return;
 
@@ skipping 22 matching lines @@
       continue;
 
     size_t space_found = line.find(' ');
     if (space_found == base::StringPiece::npos)
       continue;
 
     base::StringPiece name = line.substr(0, space_found);
     if (name.empty())
       continue;
 
-    if (!base::EqualsCaseInsensitiveASCII(printer_name, name))
+    if (!EqualsCaseInsensitiveASCII(printer_name, name))
       continue;  // This is not the required printer.
 
     line = line.substr(space_found + 1);
     // Remove extra spaces.
     line = base::TrimWhitespaceASCII(line, base::TRIM_ALL);
     if (line.empty())
       continue;
 
     // Parse the selected printer custom options. Need to pass a
     // null-terminated string.
@@ skipping 37 matching lines @@
       return;
 
     duplex_choice = ppdFindChoice(option, option->defchoice);
   }
 
   if (!duplex_choice)
     return;
 
   *duplex_capable = true;
   const char* choice = duplex_choice->choice;
-  if (base::EqualsCaseInsensitiveASCII(choice, kDuplexNone)) {
+  if (EqualsCaseInsensitiveASCII(choice, kDuplexNone)) {
     *duplex_default = SIMPLEX;
-  } else if (base::EqualsCaseInsensitiveASCII(choice, kDuplexTumble)) {
+  } else if (EqualsCaseInsensitiveASCII(choice, kDuplexTumble)) {
     *duplex_default = SHORT_EDGE;
   } else {
     *duplex_default = LONG_EDGE;
   }
 }
 
 bool GetBasicColorModelSettings(ppd_file_t* ppd,
                                 ColorModel* color_model_for_black,
                                 ColorModel* color_model_for_color,
                                 bool* color_is_default) {
@@ skipping 24 matching lines @@
     *color_model_for_color = KCMY;
   else if (ppdFindChoice(color_model, kCMY_K))
     *color_model_for_color = 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::EqualsCaseInsensitiveASCII(marked_choice->choice, kBlack) &&
-        !base::EqualsCaseInsensitiveASCII(marked_choice->choice, kGray) &&
-        !base::EqualsCaseInsensitiveASCII(marked_choice->choice, kGrayscale);
+        !EqualsCaseInsensitiveASCII(marked_choice->choice, kBlack) &&
+        !EqualsCaseInsensitiveASCII(marked_choice->choice, kGray) &&
+        !EqualsCaseInsensitiveASCII(marked_choice->choice, kGrayscale);
   }
   return true;
 }
 
 bool GetPrintOutModeColorSettings(ppd_file_t* ppd,
                                   ColorModel* color_model_for_black,
                                   ColorModel* color_model_for_color,
                                   bool* color_is_default) {
   ppd_option_t* printout_mode = ppdFindOption(ppd, kPrintoutMode);
   if (!printout_mode)
@@ skipping 10 matching lines @@
     *color_model_for_black = 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::EqualsCaseInsensitiveASCII(printout_mode_choice->choice,
-                                         kNormalGray) ||
-        base::EqualsCaseInsensitiveASCII(printout_mode_choice->choice,
-                                         kHighGray) ||
-        base::EqualsCaseInsensitiveASCII(printout_mode_choice->choice,
-                                         kDraftGray)) {
+    if (EqualsCaseInsensitiveASCII(printout_mode_choice->choice, kNormalGray) ||
+        EqualsCaseInsensitiveASCII(printout_mode_choice->choice, kHighGray) ||
+        EqualsCaseInsensitiveASCII(printout_mode_choice->choice, kDraftGray)) {
       *color_model_for_black = PRINTOUTMODE_NORMAL_GRAY;
       *color_is_default = false;
     }
   }
   return true;
 }
 
 bool GetColorModeSettings(ppd_file_t* ppd,
                           ColorModel* color_model_for_black,
                           ColorModel* 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, kColor))
+  if (ppdFindChoice(color_mode_option, kColor) ||
+      ppdFindChoice(color_mode_option, kSamsungColorTrue)) {
     *color_model_for_color = COLORMODE_COLOR;
+  }
 
-  if (ppdFindChoice(color_mode_option, kMonochrome))
+  if (ppdFindChoice(color_mode_option, kMonochrome) ||
+      ppdFindChoice(color_mode_option, kSamsungColorFalse)) {
     *color_model_for_black = 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::EqualsCaseInsensitiveASCII(mode_choice->choice, kColor);
+        EqualsCaseInsensitiveASCII(mode_choice->choice, kColor) ||
+        EqualsCaseInsensitiveASCII(mode_choice->choice, kSamsungColorTrue);
   }
   return true;
 }
 
 bool GetBrotherColorSettings(ppd_file_t* ppd,
                              ColorModel* color_model_for_black,
                              ColorModel* color_model_for_color,
                              bool* color_is_default) {
   // Some Brother printers use "BRMonoColor" attribute in their PPDs.
   // Some Brother printers use "BRPrintQuality" attribute in their PPDs.
@@ skipping 13 matching lines @@
   else if (ppdFindChoice(color_mode_option, kBlack))
     *color_model_for_black = BROTHER_BRSCRIPT3_BLACK;
 
   ppd_choice_t* marked_choice = ppdFindMarkedChoice(ppd, kColorMode);
   if (!marked_choice) {
     marked_choice =
         ppdFindChoice(color_mode_option, color_mode_option->defchoice);
   }
   if (marked_choice) {
     *color_is_default =
-        !base::EqualsCaseInsensitiveASCII(marked_choice->choice, kBlack) &&
-        !base::EqualsCaseInsensitiveASCII(marked_choice->choice, kMono);
+        !EqualsCaseInsensitiveASCII(marked_choice->choice, kBlack) &&
+        !EqualsCaseInsensitiveASCII(marked_choice->choice, kMono);
   }
   return true;
 }
 
 bool GetHPColorSettings(ppd_file_t* ppd,
                         ColorModel* color_model_for_black,
                         ColorModel* 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, kColor);
   if (!color_mode_option)
     return false;
 
   if (ppdFindChoice(color_mode_option, kColor))
     *color_model_for_color = HP_COLOR_COLOR;
   if (ppdFindChoice(color_mode_option, kBlack))
     *color_model_for_black = 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::EqualsCaseInsensitiveASCII(mode_choice->choice, kColor);
+    *color_is_default = EqualsCaseInsensitiveASCII(mode_choice->choice, kColor);
   }
   return true;
 }
 
 bool GetProcessColorModelSettings(ppd_file_t* ppd,
                                   ColorModel* color_model_for_black,
                                   ColorModel* 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, kRGB))
     *color_model_for_color = PROCESSCOLORMODEL_RGB;
   else if (ppdFindChoice(color_mode_option, kCMYK))
     *color_model_for_color = PROCESSCOLORMODEL_CMYK;
 
   if (ppdFindChoice(color_mode_option, kGreyscale))
     *color_model_for_black = 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::EqualsCaseInsensitiveASCII(mode_choice->choice, kGreyscale);
+        !EqualsCaseInsensitiveASCII(mode_choice->choice, kGreyscale);
   }
   return true;
 }
 
 bool GetColorModelSettings(ppd_file_t* ppd,
                            ColorModel* cm_black,
                            ColorModel* cm_color,
                            bool* is_color) {
   bool is_color_device = false;
   ppd_attr_t* attr = ppdFindAttr(ppd, kColorDevice, nullptr);
@@ skipping 124 matching lines @@
   }
 
   ppdClose(ppd);
   base::DeleteFile(ppd_file_path, false);
 
   *printer_info = caps;
   return true;
 }
 
 }  // namespace printing