PrintPreview: Fix printer color settings issues based on printer ppd/schema information.

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>
@@ skipping 133 matching lines @@
 }
 
 }  // 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(USE_CUPS)
 const char kColorDevice[] = "ColorDevice";
 const char kColorModel[] = "ColorModel";
-const char kColorModelForColor[] = "Color";
-const char kCMYK[] = "CMYK";
+const char kColorMode[] = "ColorMode";
+const char kProcessColorModel[] = "ProcessColorModel";
+
 const char kDuplex[] = "Duplex";
 const char kDuplexNone[] = "None";
+
+// Foomatic ppd attributes and values.
+const char kFoomaticId[] = "FoomaticIDs";
+const char kPrintoutMode[] = "PrintoutMode";
+const char kDraftGray[] = "Draft.Gray";
+const char kHighGray[] = "High.Gray";
 #elif 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";
 #endif
 
 enum UserActionBuckets {
   PRINT_TO_PRINTER,
   PRINT_TO_PDF,
   CANCEL,
   FALLBACK_TO_ADVANCED_SETTINGS_DIALOG,
   PREVIEW_FAILED,
@@ skipping 65 matching lines @@
       if (!dict->GetInteger(printing::kSettingPageRangeFrom, &range.from) ||
           !dict->GetInteger(printing::kSettingPageRangeTo, &range.to)) {
         continue;
       }
       count += (range.to - range.from) + 1;
     }
   }
   return count;
 }
 
+// Returns true if |color_mode| is a valid color model.
+bool isColorModeSelected(int color_mode) {
+  return (color_mode != printing::GRAY &&
+          color_mode != printing::BLACK &&
+          color_mode != printing::PRINTOUTMODE_NORMAL_GRAY &&
+          color_mode != printing::COLORMODE_MONOCHROME &&
+          color_mode != printing::PROCESSCOLORMODEL_GREYSCALE);
+}
+
 // Track the popularity of print settings and report the stats.
 void ReportPrintSettingsStats(const DictionaryValue& settings) {
   bool landscape;
   if (settings.GetBoolean(printing::kSettingLandscape, &landscape))
     ReportPrintSettingHistogram(landscape ? LANDSCAPE : PORTRAIT);
 
   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(color_mode == printing::GRAY ? BLACK_AND_WHITE :
-                                                               COLOR);
+    ReportPrintSettingHistogram(
+        isColorModeSelected(color_mode) ? COLOR : BLACK_AND_WHITE);
   }
 }
 
 printing::BackgroundPrintingManager* GetBackgroundPrintingManager() {
   return g_browser_process->background_printing_manager();
 }
 
 }  // namespace
 
 class PrintSystemTaskProxy

[vandebo (ex-Chrome), 2011/10/07 18:23:30]

Maybe this class should get moved out of webui?

[kmadhusu, 2011/10/10 23:34:26]

Done.

     : 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) {
   }
@@ skipping 77 matching lines @@
   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_color_as_default = false;
+    bool disable_color_options = false;
     bool set_duplex_as_default = false;
-    int printer_color_space = printing::GRAY;
+    int printer_color_space_for_color = printing::COLOR;

[vandebo (ex-Chrome), 2011/10/07 18:23:30]

Move both of these down to line 448 - just before you set them.

[kmadhusu, 2011/10/10 23:34:26]

This is also used by windows code. 

+    int printer_color_space_for_black = 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
+      bool is_color_device = false;
       ppd_attr_t* attr = ppdFindAttr(ppd, kColorDevice, NULL);
       if (attr && attr->value)
-        supports_color = ppd->color_device;
+        is_color_device = ppd->color_device;
+      disable_color_options = !is_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) {
+      set_color_as_default = is_color_device;
+      if (is_color_device) {
         // Identify the color space (COLOR/CMYK) for this printer.
         ppd_option_t* color_model = ppdFindOption(ppd, kColorModel);
         if (color_model) {

[vandebo (ex-Chrome), 2011/10/07 18:23:30]

I would pull each of these blocks into a method...
bool getBasicColorModelSettings(int* color_model_for_black, int*
color_model_for_color, bool* color_is_default);
bool getFoomaticColorModelSetting(int* color_model_for_black, int*
color_model_for_color, bool* color_is_default);
etc...
Maybe you need a constant for invalid color model too?

[kmadhusu, 2011/10/10 23:34:26]

Done.

-          if (ppdFindChoice(color_model, kColorModelForColor))
-            printer_color_space = printing::COLOR;
-          else if (ppdFindChoice(color_model, kCMYK))
-            printer_color_space = printing::CMYK;
+          if (ppdFindChoice(color_model, printing::kBlack))

[vandebo (ex-Chrome), 2011/10/07 18:23:30]

Does this need to happen even if it's not a color model?

[kmadhusu, 2011/10/10 23:34:26]

No. I have seen Black and Gray only as ColorModel attribute values. 

+            printer_color_space_for_black = printing::BLACK;
+          else if (!ppdFindChoice(color_model, printing::kGray)) {
+            disable_color_options = true;
+          }
+
+          if (ppdFindChoice(color_model, printing::kColor))
+            printer_color_space_for_color = printing::COLOR;
+          else if (ppdFindChoice(color_model, printing::kCMYK))
+            printer_color_space_for_color = printing::CMYK;
+          else if (ppdFindChoice(color_model, printing::kRGB))
+            printer_color_space_for_color = printing::RGB;
+          else if (ppdFindChoice(color_model, printing::kRGBA))
+            printer_color_space_for_color = printing::RGBA;
+          else if (ppdFindChoice(color_model, printing::kRGB16))
+            printer_color_space_for_color = printing::RGB16;
+          else if (ppdFindChoice(color_model, printing::kCMY))
+            printer_color_space_for_color = printing::CMY;
+          else if (ppdFindChoice(color_model, printing::kKCMY))
+            printer_color_space_for_color = printing::KCMY;
+          else if (ppdFindChoice(color_model, printing::kCMY_K))
+             printer_color_space_for_color = printing::CMY_K;
+          } else {
+            disable_color_options = true;
+        }
+      }
+
+      // If this is a foomatic ppd, color values are present in
+      // PrintoutMode attribute.
+      ppd_attr_t* foomatic_id_attr = ppdFindAttr(ppd, kFoomaticId, NULL);
+      if (foomatic_id_attr && foomatic_id_attr->value) {
+        ppd_option_t* printout_mode = ppdFindOption(ppd, kPrintoutMode);
+        if (printout_mode) {
+          disable_color_options = false;
+          printer_color_space_for_color = printing::PRINTOUTMODE_NORMAL;
+          printer_color_space_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))
+            printer_color_space_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)) {
+              printer_color_space_for_black =
+                  printing::PRINTOUTMODE_NORMAL_GRAY;
+              set_color_as_default = false;
+            }
+          }
+          disable_color_options = printer_color_space_for_black ==
+                                  printing::PRINTOUTMODE_NORMAL;
+        }
+      }
+
+      // Samsung printers use "ColorMode" attribute in their ppds.
+      ppd_option_t* color_mode_option = ppdFindOption(ppd, kColorMode);
+      if (color_mode_option) {
+        disable_color_options = false;
+        printer_color_space_for_color = printing::COLORMODE_COLOR;
+        printer_color_space_for_black = printing::COLORMODE_MONOCHROME;
+        if (!(ppdFindChoice(color_mode_option, printing::kColor) &&
+            ppdFindChoice(color_mode_option, printing::kMonochrome))) {
+          disable_color_options = true;
+        }
+
+        ppd_choice_t* mode_choice = ppdFindMarkedChoice(ppd, kColorMode);
+        if (!mode_choice) {
+          mode_choice = ppdFindChoice(color_mode_option,
+                                      color_mode_option->defchoice);
+        }
+
+        if (mode_choice) {
+          set_color_as_default =
+              (base::strcasecmp(mode_choice->choice, printing::kColor) == 0);
+        }
+      }
+
+      // HP printers use "Color/Color Model" attribute in their ppds.
+      color_mode_option = ppdFindOption(ppd, printing::kColor);
+      if (color_mode_option) {
+        disable_color_options = false;
+        printer_color_space_for_color = printing::HP_COLOR_COLOR;
+        printer_color_space_for_black = printing::HP_COLOR_BLACK;
+        if (!(ppdFindChoice(color_mode_option, printing::kColor) &&
+            ppdFindChoice(color_mode_option, printing::kBlack))) {
+          disable_color_options = true;
+        }
+
+        ppd_choice_t* mode_choice = ppdFindMarkedChoice(ppd, kColorMode);
+        if (!mode_choice) {
+          mode_choice = ppdFindChoice(color_mode_option,
+                                      color_mode_option->defchoice);
+        }
+
+        if (mode_choice) {
+          set_color_as_default =
+              (base::strcasecmp(mode_choice->choice, printing::kColor) == 0);
+        }
+      }
+
+      // Canon printers use "ProcessColorModel" attribute in their ppds.
+      color_mode_option =  ppdFindOption(ppd, kProcessColorModel);
+      if (color_mode_option) {
+        disable_color_options = false;
+        if (ppdFindChoice(color_mode_option, printing::kRGB))
+          printer_color_space_for_color = printing::PROCESSCOLORMODEL_RGB;
+        else if (ppdFindChoice(color_mode_option, printing::kCMYK))
+          printer_color_space_for_color = printing::PROCESSCOLORMODEL_CMYK;
+        else
+          disable_color_options = true;
+
+        if (ppdFindChoice(color_mode_option, printing::kGreyscale))
+          printer_color_space_for_black = printing::PROCESSCOLORMODEL_GREYSCALE;
+        else
+          disable_color_options = true;
+
+        ppd_choice_t* mode_choice = ppdFindMarkedChoice(ppd,
+                                                        kProcessColorModel);
+        if (!mode_choice) {
+          mode_choice = ppdFindChoice(color_mode_option,
+                                      color_mode_option->defchoice);
+        }
+
+        if (mode_choice) {
+          set_color_as_default =
+              (base::strcasecmp(mode_choice->choice,
+                                printing::kGreyscale) != 0);
         }
       }
       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.
+    bool supports_color = false;
+    bool supports_grayscale = true;
     supports_color = (printer_info.printer_capabilities.find(kPskColor) !=
                       std::string::npos);
-    if (supports_color)
-      printer_color_space = printing::COLOR;
+
+    supports_grayscale =
+        (printer_info.printer_capabilities.find(kPskGray) !=
+            std::string::npos) ||
+        (printer_info.printer_capabilities.find(kPskMonochrome) !=
+            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;
         }
     }
+    disable_color_options = !supports_color || !supports_grayscale;

[vandebo (ex-Chrome), 2011/10/07 18:23:30]

Can you use this logic above?

[kmadhusu, 2011/10/10 23:34:26]

Done.

+    set_color_as_default = supports_color;
 #else
   NOTIMPLEMENTED();
 #endif
-
     DictionaryValue settings_info;
-    settings_info.SetBoolean(kDisableColorOption, !supports_color);
-    if (!supports_color) {
-      settings_info.SetBoolean(kSetColorAsDefault, false);
+    settings_info.SetBoolean(kDisableColorOption, disable_color_options);
+    if (disable_color_options) {
+      settings_info.SetBoolean(kSetColorAsDefault, set_color_as_default);
     } else {
-       settings_info.SetBoolean(kSetColorAsDefault,
-                                PrintPreviewHandler::last_used_color_setting_);
+      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(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,
         NewRunnableMethod(this,
                           &PrintSystemTaskProxy::SendPrinterCapabilities,
                           settings_info.DeepCopy()));
   }
 
   void SendPrinterCapabilities(DictionaryValue* settings_info) {
@@ skipping 229 matching lines @@
   }
 
   scoped_ptr<DictionaryValue> settings(GetSettingsDictionary(args));
   if (!settings.get())
     return;
 
   // 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);
+  last_used_color_setting_ = isColorModeSelected(color_mode);
 
   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 437 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());
 }