Better detect options for Brother 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>
@@ skipping 18 matching lines @@
 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";
 
-const char kDuplex[] = "Duplex";
-const char kDuplexNone[] = "None";
-const char kPageSize[] = "PageSize";
+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";
+constexpr char kFullColor[] = "FullColor";
+constexpr char kMono[] = "Mono";
 
 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 62 matching lines @@
     num_options = 0;
     options = nullptr;
     ParseLpOptions(location, printer_name, &num_options, &options);
     if (num_options > 0 && options) {
       cupsMarkOptions(*ppd, num_options, options);
       cupsFreeOptions(num_options, options);
     }
   }
 }
 
+void GetDuplexSettings(ppd_file_t* ppd,
+                       bool* duplex_capable,
+                       DuplexMode* duplex_default) {
+  ppd_choice_t* duplex_choice = ppdFindMarkedChoice(ppd, kDuplex);
+  if (!duplex_choice) {
+    ppd_option_t* option = ppdFindOption(ppd, kDuplex);
+    if (!option)
+      option = ppdFindOption(ppd, kBrotherDuplex);
+    if (!option)
+      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)) {
+    *duplex_default = SIMPLEX;
+  } else if (base::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) {
   ppd_option_t* color_model = ppdFindOption(ppd, kColorModel);
   if (!color_model)
     return false;
 
   if (ppdFindChoice(color_model, kBlack))
     *color_model_for_black = BLACK;
@@ skipping 68 matching lines @@
       *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.
+  // 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))
     *color_model_for_color = COLORMODE_COLOR;
 
   if (ppdFindChoice(color_mode_option, kMonochrome))
     *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);
   }
   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.
+  ppd_option_t* color_mode_option = ppdFindOption(ppd, kBrotherMonoColor);
+  if (!color_mode_option)
+    color_mode_option = ppdFindOption(ppd, kBrotherPrintQuality);
+  if (!color_mode_option)
+    return false;
+
+  if (ppdFindChoice(color_mode_option, kFullColor) ||
+      ppdFindChoice(color_mode_option, kColor)) {
+    *color_model_for_color = BROTHER_COLOR_COLOR;
+  }
+  if (ppdFindChoice(color_mode_option, kBlack) ||
+      ppdFindChoice(color_mode_option, kMono)) {
+    *color_model_for_black = BROTHER_COLOR_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);
+  }
+  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.
+  // 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);
   }
   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.
+  // 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))
@@ skipping 17 matching lines @@
                            ColorModel* cm_color,
                            bool* is_color) {
   bool is_color_device = false;
   ppd_attr_t* attr = ppdFindAttr(ppd, kColorDevice, nullptr);
   if (attr && attr->value)
     is_color_device = ppd->color_device;
 
   *is_color = is_color_device;
   return (is_color_device &&
           GetBasicColorModelSettings(ppd, cm_black, cm_color, is_color)) ||
-      GetPrintOutModeColorSettings(ppd, cm_black, cm_color, is_color) ||
-      GetColorModeSettings(ppd, cm_black, cm_color, is_color) ||
-      GetHPColorSettings(ppd, cm_black, cm_color, is_color) ||
-      GetProcessColorModelSettings(ppd, cm_black, cm_color, is_color);
+         GetPrintOutModeColorSettings(ppd, cm_black, cm_color, is_color) ||
+         GetColorModeSettings(ppd, cm_black, cm_color, is_color) ||
+         GetHPColorSettings(ppd, cm_black, cm_color, is_color) ||
+         GetBrotherColorSettings(ppd, cm_black, cm_color, is_color) ||
+         GetProcessColorModelSettings(ppd, cm_black, cm_color, is_color);
 }
 
 // Default port for IPP print servers.
 const int kDefaultIPPServerPort = 631;
 
 }  // namespace
 
 // Helper wrapper around http_t structure, with connection and cleanup
 // functionality.
 HttpConnectionCUPS::HttpConnectionCUPS(const GURL& print_server_url,
@@ skipping 52 matching lines @@
     return false;
   }
   ppdMarkDefaults(ppd);
   MarkLpOptions(printer_name, &ppd);
 
   PrinterSemanticCapsAndDefaults caps;
   caps.collate_capable = true;
   caps.collate_default = true;
   caps.copies_capable = true;
 
-  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) {
-    caps.duplex_capable = true;
-    if (!base::EqualsCaseInsensitiveASCII(duplex_choice->choice, kDuplexNone))
-      caps.duplex_default = LONG_EDGE;
-    else
-      caps.duplex_default = SIMPLEX;
-  }
+  GetDuplexSettings(ppd, &caps.duplex_capable, &caps.duplex_default);
 
   bool is_color = false;
   ColorModel cm_color = UNKNOWN_COLOR_MODEL, cm_black = UNKNOWN_COLOR_MODEL;
   if (!GetColorModelSettings(ppd, &cm_black, &cm_color, &is_color)) {
     VLOG(1) << "Unknown printer color model";
   }
 
   caps.color_changeable = ((cm_color != UNKNOWN_COLOR_MODEL) &&
                            (cm_black != UNKNOWN_COLOR_MODEL) &&
                            (cm_color != cm_black));
@@ skipping 30 matching lines @@
   }
 
   ppdClose(ppd);
   base::DeleteFile(ppd_file_path, false);
 
   *printer_info = caps;
   return true;
 }
 
 }  // namespace printing