De-duplicate job_settings parsing code.

printing/printing_context_win.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/printing_context_win.h"
 
 #include <winspool.h>
 
 #include <algorithm>
 
@@ skipping 290 matching lines @@
       if (context_)
         return OK;
     }
   }
 
   ResetSettings();
   return FAILED;
 }
 
 PrintingContext::Result PrintingContextWin::UpdatePrinterSettings(
-    const DictionaryValue& job_settings,
-    const PageRanges& ranges) {
+    bool target_is_pdf,
+    bool external_preview) {
   DCHECK(!in_print_job_);
+  DCHECK(!external_preview) << "Not implemented";
 
-  bool collate;
-  int color;
-  bool landscape;
-  bool print_to_pdf;
-  bool is_cloud_dialog;
-  int copies;
-  int duplex_mode;
-  base::string16 device_name;
-
-  if (!job_settings.GetBoolean(kSettingLandscape, &landscape) ||
-      !job_settings.GetBoolean(kSettingCollate, &collate) ||
-      !job_settings.GetInteger(kSettingColor, &color) ||
-      !job_settings.GetBoolean(kSettingPrintToPDF, &print_to_pdf) ||
-      !job_settings.GetInteger(kSettingDuplexMode, &duplex_mode) ||
-      !job_settings.GetInteger(kSettingCopies, &copies) ||
-      !job_settings.GetString(kSettingDeviceName, &device_name) ||
-      !job_settings.GetBoolean(kSettingCloudPrintDialog, &is_cloud_dialog)) {
-    return OnError();
-  }
-
-  bool print_to_cloud = job_settings.HasKey(kSettingCloudPrintId);
-
-  if (print_to_pdf || print_to_cloud || is_cloud_dialog) {
+  if (target_is_pdf) {
     // Default fallback to Letter size.
     gfx::Size paper_size;
     gfx::Rect paper_rect;
     paper_size.SetSize(kPDFLetterWidth, kPDFLetterHeight);
 
     // Get settings from locale. Paper type buffer length is at most 4.
     const int paper_type_buffer_len = 4;
     wchar_t paper_type_buffer[paper_type_buffer_len] = {0};
     GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_IPAPERSIZE, paper_type_buffer,
                   paper_type_buffer_len);
     if (wcslen(paper_type_buffer)) {  // The call succeeded.
       int paper_code = _wtoi(paper_type_buffer);
       switch (paper_code) {
         case DMPAPER_LEGAL:
           paper_size.SetSize(kPDFLegalWidth, kPDFLegalHeight);
           break;
         case DMPAPER_A4:
           paper_size.SetSize(kPDFA4Width, kPDFA4Height);
           break;
         case DMPAPER_A3:
           paper_size.SetSize(kPDFA3Width, kPDFA3Height);
           break;
         default:  // DMPAPER_LETTER is used for default fallback.
           break;
       }
     }
     paper_rect.SetRect(0, 0, paper_size.width(), paper_size.height());
-    settings_.SetPrinterPrintableArea(paper_size, paper_rect, kPDFDpi);
+    settings_.SetPrinterPrintableArea(paper_size, paper_rect, kPDFDpi, true);
     settings_.set_dpi(kPDFDpi);
-    settings_.SetOrientation(landscape);
-    settings_.ranges = ranges;
     return OK;
   }
 
   ScopedPrinterHandle printer;
-  LPWSTR device_name_wide = const_cast<wchar_t*>(device_name.c_str());
+  LPWSTR device_name_wide =
+      const_cast<wchar_t*>(settings_.device_name().c_str());
   if (!printer.OpenPrinter(device_name_wide))
     return OnError();
 
   // Make printer changes local to Chrome.
   // See MSDN documentation regarding DocumentProperties.
   scoped_ptr<uint8[]> buffer;
   DEVMODE* dev_mode = NULL;
   LONG buffer_size = DocumentProperties(NULL, printer, device_name_wide,
                                         NULL, NULL, 0);
   if (buffer_size > 0) {
     buffer.reset(new uint8[buffer_size]);
     memset(buffer.get(), 0, buffer_size);
     if (DocumentProperties(NULL, printer, device_name_wide,
                            reinterpret_cast<PDEVMODE>(buffer.get()), NULL,
                            DM_OUT_BUFFER) == IDOK) {
       dev_mode = reinterpret_cast<PDEVMODE>(buffer.get());
     }
   }
   if (dev_mode == NULL) {
     buffer.reset();
     return OnError();
   }
 
-  if (color == GRAY)
+  if (settings_.color() == GRAY)
     dev_mode->dmColor = DMCOLOR_MONOCHROME;
   else
     dev_mode->dmColor = DMCOLOR_COLOR;
 
-  dev_mode->dmCopies = std::max(copies, 1);
-  if (dev_mode->dmCopies > 1)  // do not change collate unless multiple copies
-    dev_mode->dmCollate = collate ? DMCOLLATE_TRUE : DMCOLLATE_FALSE;
-  switch (duplex_mode) {
+  dev_mode->dmCopies = std::max(settings_.copies(), 1);
+  if (dev_mode->dmCopies > 1) { // do not change collate unless multiple copies
+    dev_mode->dmCollate = settings_.collate() ? DMCOLLATE_TRUE :
+                                                DMCOLLATE_FALSE;
+  }
+  switch (settings_.duplex_mode()) {
     case LONG_EDGE:
       dev_mode->dmDuplex = DMDUP_VERTICAL;
       break;
     case SHORT_EDGE:
       dev_mode->dmDuplex = DMDUP_HORIZONTAL;
       break;
     case SIMPLEX:
       dev_mode->dmDuplex = DMDUP_SIMPLEX;
       break;
     default:  // UNKNOWN_DUPLEX_MODE
       break;
   }
-  dev_mode->dmOrientation = landscape ? DMORIENT_LANDSCAPE : DMORIENT_PORTRAIT;
+  dev_mode->dmOrientation = settings_.landscape() ? DMORIENT_LANDSCAPE :
+                                                    DMORIENT_PORTRAIT;
 
   // Update data using DocumentProperties.
   if (DocumentProperties(NULL, printer, device_name_wide, dev_mode, dev_mode,
                          DM_IN_BUFFER | DM_OUT_BUFFER) != IDOK) {
     return OnError();
   }
 
   // Set printer then refresh printer settings.
-  if (!AllocateContext(device_name, dev_mode, &context_)) {
+  if (!AllocateContext(settings_.device_name(), dev_mode, &context_)) {
     return OnError();
   }
   PrintSettingsInitializerWin::InitPrintSettings(context_, *dev_mode,
-                                                 ranges, device_name,
-                                                 false, &settings_);
+                                                 &settings_);
   return OK;
 }
 
 PrintingContext::Result PrintingContextWin::InitWithSettings(
     const PrintSettings& settings) {
   DCHECK(!in_print_job_);
 
   settings_ = settings;
 
   // TODO(maruel): settings_.ToDEVMODE()
@@ skipping 176 matching lines @@
     ranges_vector.reserve(number_ranges);
     for (int i = 0; i < number_ranges; ++i) {
       PageRange range;
       // Transfer from 1-based to 0-based.
       range.from = ranges[i].nFromPage - 1;
       range.to = ranges[i].nToPage - 1;
       ranges_vector.push_back(range);
     }
   }
 
-  PrintSettingsInitializerWin::InitPrintSettings(context_,
-                                                 dev_mode,
-                                                 ranges_vector,
-                                                 new_device_name,
-                                                 selection_only,
+  settings_.set_ranges(ranges_vector);
+  settings_.set_device_name(new_device_name);
+  settings_.set_selection_only(selection_only);
+  PrintSettingsInitializerWin::InitPrintSettings(context_, dev_mode,
                                                  &settings_);
 
   return true;
 }
 
 bool PrintingContextWin::GetPrinterSettings(HANDLE printer,
                                             const std::wstring& device_name) {
   DCHECK(!in_print_job_);
 
   UserDefaultDevMode user_settings;
@@ skipping 139 matching lines @@
 
   if (dialog_options.hDevMode != NULL)
     GlobalFree(dialog_options.hDevMode);
   if (dialog_options.hDevNames != NULL)
     GlobalFree(dialog_options.hDevNames);
 
   return context_ ? OK : FAILED;
 }
 
 }  // namespace printing