CUPS: Add a regression test for duplex detection.

chrome/browser/printing/print_system_task_proxy.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/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 "chrome/browser/ui/webui/print_preview_handler.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
@@ skipping 277 matching lines @@
 
 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) {
 }
 
+#if defined(UNIT_TEST) && defined(USE_CUPS)
+// Only used for testing.
+PrintSystemTaskProxy::PrintSystemTaskProxy() {
+}
+#endif
+
 PrintSystemTaskProxy::~PrintSystemTaskProxy() {
 }
 
 void PrintSystemTaskProxy::GetDefaultPrinter() {
   VLOG(1) << "Get default printer start";
   std::string* default_printer = NULL;
   if (PrintPreviewHandler::last_used_printer_name_ == NULL) {
     default_printer = new std::string(print_backend_->GetDefaultPrinterName());
   } else {
     default_printer = new std::string(
@@ skipping 56 matching lines @@
       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)
+bool PrintSystemTaskProxy::GetPrinterCapabilitiesCUPS(
+    const printing::PrinterCapsAndDefaults& printer_info,
+    const std::string& printer_name,
+    bool* set_color_as_default,
+    int* printer_color_space_for_color,
+    int* printer_color_space_for_black,
+    bool* set_duplex_as_default,
+    int* default_duplex_setting_value) {
   FilePath ppd_file_path;
   if (!file_util::CreateTemporaryFile(&ppd_file_path))
-    return;
+    return false;
 
   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;
+    return false;
   }
 
   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;
+        *set_duplex_as_default = true;
+        *default_duplex_setting_value = printing::LONG_EDGE;
       } else {
-        default_duplex_setting_value = printing::SIMPLEX;
+        *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;
+    *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)) ||
+              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) ||
+              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) ||
+              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) ||
+              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))) {
+              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)
+  return true;
+}
+#endif  // defined(USE_CUPS)
+
+#if defined(OS_WIN)
+void PrintSystemTaskProxy::GetPrinterCapabilitiesWin(
+    const printing::PrinterCapsAndDefaults& printer_info,
+    bool* set_color_as_default,
+    int* printer_color_space_for_color,
+    int* printer_color_space_for_black,
+    bool* set_duplex_as_default,
+    int* default_duplex_setting_value) {
   // 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;
+    *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;
+    *printer_color_space_for_black = printing::GRAY;
   }
-  set_color_as_default =
+  *set_color_as_default =
       (printer_info.printer_defaults.find(kPskColor) != std::string::npos);
 
-  set_duplex_as_default =
+  *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;
+        *default_duplex_setting_value = printing::LONG_EDGE;
       } else {
-        default_duplex_setting_value = printing::SIMPLEX;
+        *default_duplex_setting_value = printing::SIMPLEX;
     }
   }
+}
+#endif  // defined(OS_WIN)
+
+void PrintSystemTaskProxy::GetPrinterCapabilities(
+    const std::string& printer_name) {
+  VLOG(1) << "Get printer capabilities start for " << printer_name;
+  printing::PrinterCapsAndDefaults printer_info;
+  if (!print_backend_->GetPrinterCapsAndDefaults(printer_name,
+                                                 &printer_info)) {
+    return;
+  }
+
+  bool set_color_as_default = false;
+  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 defined(USE_CUPS)
+  if (!GetPrinterCapabilitiesCUPS(printer_info,
+                                  printer_name,
+                                  &set_color_as_default,
+                                  &printer_color_space_for_color,
+                                  &printer_color_space_for_black,
+                                  &set_duplex_as_default,
+                                  &default_duplex_setting_value)) {
+    return;
+  }
+#elif defined(OS_WIN)
+  GetPrinterCapabilitiesWin(printer_info,
+                            &set_color_as_default,
+                            &printer_color_space_for_color,
+                            &printer_color_space_for_black,
+                            &set_duplex_as_default,
+                            &default_duplex_setting_value);
 #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);
+  bool 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 ||
@@ skipping 18 matching lines @@
       base::Bind(&PrintSystemTaskProxy::SendPrinterCapabilities, this,
                  settings_info.DeepCopy()));
 }
 
 void PrintSystemTaskProxy::SendPrinterCapabilities(
     DictionaryValue* settings_info) {
   if (handler_)
     handler_->SendPrinterCapabilities(*settings_info);
   delete settings_info;
 }