Take PPD and CUPS defaults into account on Mac.

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 "base/base_paths.h"
 #include "base/files/file_util.h"
@@ skipping 20 matching lines @@
 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";
 
 const double kMicronsPerPoint = 10.0f * kHundrethsMMPerInch / kPointsPerInch;
 
-#if !defined(OS_MACOSX)
 void ParseLpOptions(const base::FilePath& filepath,
                     const std::string& printer_name,
                     int* num_options, cups_option_t** options) {
   std::string content;
   if (!base::ReadFileToString(filepath, &content))
     return;
 
   const char kDest[] = "dest";
   const char kDefault[] = "default";
   const size_t kDestLen = sizeof(kDest) - 1;
@@ skipping 39 matching lines @@
     if (line.empty())
       continue;
     // Parse the selected printer custom options.
     *num_options = cupsParseOptions(line.c_str(), 0, options);
   }
 }
 
 void MarkLpOptions(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<base::FilePath> file_locations;
   file_locations.push_back(base::FilePath(kSystemLpOptionPath));
   base::FilePath homedir;
   PathService::Get(base::DIR_HOME, &homedir);
   file_locations.push_back(base::FilePath(homedir.Append(kUserLpOptionPath)));
 
   for (std::vector<base::FilePath>::const_iterator it = file_locations.begin();
        it != file_locations.end(); ++it) {
     num_options = 0;
     options = NULL;
     ParseLpOptions(*it, printer_name, &num_options, &options);
     if (num_options > 0 && options) {
       cupsMarkOptions(*ppd, num_options, options);
       cupsFreeOptions(num_options, options);
     }
   }
 }
-#endif  // !defined(OS_MACOSX)
 
 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, printing::kBlack))
@@ skipping 228 matching lines @@
   }
 
   ppd_file_t* ppd = ppdOpenFile(ppd_file_path.value().c_str());
   if (!ppd) {
     int line = 0;
     ppd_status_t ppd_status = ppdLastError(&line);
     LOG(ERROR) << "Failed to open PDD file: error " << ppd_status << " at line "
                << line << ", " << ppdErrorString(ppd_status);
     return false;
   }
+  ppdMarkDefaults(ppd);
+  MarkLpOptions(printer_name, &ppd);
 
   printing::PrinterSemanticCapsAndDefaults caps;
-#if !defined(OS_MACOSX)
-  MarkLpOptions(printer_name, &ppd);
-#endif
   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);
   }
@@ skipping 48 matching lines @@
   }
 
   ppdClose(ppd);
   base::DeleteFile(ppd_file_path, false);
 
   *printer_info = caps;
   return true;
 }
 
 }  // namespace printing