Home | History | Annotate | Download | only in printing 
      1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "printing/printing_context_win.h"
      6 
      7 #include <winspool.h>
      8 
      9 #include <algorithm>
     10 
     11 #include "base/message_loop/message_loop.h"
     12 #include "base/metrics/histogram.h"
     13 #include "base/strings/string_number_conversions.h"
     14 #include "base/strings/utf_string_conversions.h"
     15 #include "base/values.h"
     16 #include "printing/backend/print_backend.h"
     17 #include "printing/backend/printing_info_win.h"
     18 #include "printing/backend/win_helper.h"
     19 #include "printing/print_job_constants.h"
     20 #include "printing/print_settings_initializer_win.h"
     21 #include "printing/printed_document.h"
     22 #include "printing/printing_utils.h"
     23 #include "printing/units.h"
     24 #include "skia/ext/platform_device.h"
     25 
     26 #if defined(USE_AURA)
     27 #include "ui/aura/remote_window_tree_host_win.h"
     28 #include "ui/aura/window.h"
     29 #include "ui/aura/window_event_dispatcher.h"
     30 #endif
     31 
     32 namespace {
     33 
     34 HWND GetRootWindow(gfx::NativeView view) {
     35   HWND window = NULL;
     36 #if defined(USE_AURA)
     37   if (view)
     38     window = view->GetHost()->GetAcceleratedWidget();
     39 #else
     40   if (view && IsWindow(view)) {
     41     window = GetAncestor(view, GA_ROOTOWNER);
     42   }
     43 #endif
     44   if (!window) {
     45     // TODO(maruel):  bug 1214347 Get the right browser window instead.
     46     return GetDesktopWindow();
     47   }
     48   return window;
     49 }
     50 
     51 }  // anonymous namespace
     52 
     53 namespace printing {
     54 
     55 class PrintingContextWin::CallbackHandler : public IPrintDialogCallback,
     56                                             public IObjectWithSite {
     57  public:
     58   CallbackHandler(PrintingContextWin& owner, HWND owner_hwnd)
     59       : owner_(owner),
     60         owner_hwnd_(owner_hwnd),
     61         services_(NULL) {
     62   }
     63 
     64   ~CallbackHandler() {
     65     if (services_)
     66       services_->Release();
     67   }
     68 
     69   IUnknown* ToIUnknown() {
     70     return static_cast<IUnknown*>(static_cast<IPrintDialogCallback*>(this));
     71   }
     72 
     73   // IUnknown
     74   virtual HRESULT WINAPI QueryInterface(REFIID riid, void**object) {
     75     if (riid == IID_IUnknown) {
     76       *object = ToIUnknown();
     77     } else if (riid == IID_IPrintDialogCallback) {
     78       *object = static_cast<IPrintDialogCallback*>(this);
     79     } else if (riid == IID_IObjectWithSite) {
     80       *object = static_cast<IObjectWithSite*>(this);
     81     } else {
     82       return E_NOINTERFACE;
     83     }
     84     return S_OK;
     85   }
     86 
     87   // No real ref counting.
     88   virtual ULONG WINAPI AddRef() {
     89     return 1;
     90   }
     91   virtual ULONG WINAPI Release() {
     92     return 1;
     93   }
     94 
     95   // IPrintDialogCallback methods
     96   virtual HRESULT WINAPI InitDone() {
     97     return S_OK;
     98   }
     99 
    100   virtual HRESULT WINAPI SelectionChange() {
    101     if (services_) {
    102       // TODO(maruel): Get the devmode for the new printer with
    103       // services_->GetCurrentDevMode(&devmode, &size), send that information
    104       // back to our client and continue. The client needs to recalculate the
    105       // number of rendered pages and send back this information here.
    106     }
    107     return S_OK;
    108   }
    109 
    110   virtual HRESULT WINAPI HandleMessage(HWND dialog,
    111                                        UINT message,
    112                                        WPARAM wparam,
    113                                        LPARAM lparam,
    114                                        LRESULT* result) {
    115     // Cheap way to retrieve the window handle.
    116     if (!owner_.dialog_box_) {
    117       // The handle we receive is the one of the groupbox in the General tab. We
    118       // need to get the grand-father to get the dialog box handle.
    119       owner_.dialog_box_ = GetAncestor(dialog, GA_ROOT);
    120       // Trick to enable the owner window. This can cause issues with navigation
    121       // events so it may have to be disabled if we don't fix the side-effects.
    122       EnableWindow(owner_hwnd_, TRUE);
    123     }
    124     return S_FALSE;
    125   }
    126 
    127   virtual HRESULT WINAPI SetSite(IUnknown* site) {
    128     if (!site) {
    129       DCHECK(services_);
    130       services_->Release();
    131       services_ = NULL;
    132       // The dialog box is destroying, PrintJob::Worker don't need the handle
    133       // anymore.
    134       owner_.dialog_box_ = NULL;
    135     } else {
    136       DCHECK(services_ == NULL);
    137       HRESULT hr = site->QueryInterface(IID_IPrintDialogServices,
    138                                         reinterpret_cast<void**>(&services_));
    139       DCHECK(SUCCEEDED(hr));
    140     }
    141     return S_OK;
    142   }
    143 
    144   virtual HRESULT WINAPI GetSite(REFIID riid, void** site) {
    145     return E_NOTIMPL;
    146   }
    147 
    148  private:
    149   PrintingContextWin& owner_;
    150   HWND owner_hwnd_;
    151   IPrintDialogServices* services_;
    152 
    153   DISALLOW_COPY_AND_ASSIGN(CallbackHandler);
    154 };
    155 
    156 // static
    157 PrintingContext* PrintingContext::Create(const std::string& app_locale) {
    158   return static_cast<PrintingContext*>(new PrintingContextWin(app_locale));
    159 }
    160 
    161 PrintingContextWin::PrintingContextWin(const std::string& app_locale)
    162     : PrintingContext(app_locale), context_(NULL), dialog_box_(NULL) {}
    163 
    164 PrintingContextWin::~PrintingContextWin() {
    165   ReleaseContext();
    166 }
    167 
    168 void PrintingContextWin::AskUserForSettings(
    169     gfx::NativeView view, int max_pages, bool has_selection,
    170     const PrintSettingsCallback& callback) {
    171   DCHECK(!in_print_job_);
    172   dialog_box_dismissed_ = false;
    173 
    174   HWND window = GetRootWindow(view);
    175   DCHECK(window);
    176 
    177   // Show the OS-dependent dialog box.
    178   // If the user press
    179   // - OK, the settings are reset and reinitialized with the new settings. OK is
    180   //   returned.
    181   // - Apply then Cancel, the settings are reset and reinitialized with the new
    182   //   settings. CANCEL is returned.
    183   // - Cancel, the settings are not changed, the previous setting, if it was
    184   //   initialized before, are kept. CANCEL is returned.
    185   // On failure, the settings are reset and FAILED is returned.
    186   PRINTDLGEX dialog_options = { sizeof(PRINTDLGEX) };
    187   dialog_options.hwndOwner = window;
    188   // Disable options we don't support currently.
    189   // TODO(maruel):  Reuse the previously loaded settings!
    190   dialog_options.Flags = PD_RETURNDC | PD_USEDEVMODECOPIESANDCOLLATE  |
    191                          PD_NOCURRENTPAGE | PD_HIDEPRINTTOFILE;
    192   if (!has_selection)
    193     dialog_options.Flags |= PD_NOSELECTION;
    194 
    195   PRINTPAGERANGE ranges[32];
    196   dialog_options.nStartPage = START_PAGE_GENERAL;
    197   if (max_pages) {
    198     // Default initialize to print all the pages.
    199     memset(ranges, 0, sizeof(ranges));
    200     ranges[0].nFromPage = 1;
    201     ranges[0].nToPage = max_pages;
    202     dialog_options.nPageRanges = 1;
    203     dialog_options.nMaxPageRanges = arraysize(ranges);
    204     dialog_options.nMinPage = 1;
    205     dialog_options.nMaxPage = max_pages;
    206     dialog_options.lpPageRanges = ranges;
    207   } else {
    208     // No need to bother, we don't know how many pages are available.
    209     dialog_options.Flags |= PD_NOPAGENUMS;
    210   }
    211 
    212   if (ShowPrintDialog(&dialog_options) != S_OK) {
    213     ResetSettings();
    214     callback.Run(FAILED);
    215   }
    216 
    217   // TODO(maruel):  Support PD_PRINTTOFILE.
    218   callback.Run(ParseDialogResultEx(dialog_options));
    219 }
    220 
    221 PrintingContext::Result PrintingContextWin::UseDefaultSettings() {
    222   DCHECK(!in_print_job_);
    223 
    224   PRINTDLG dialog_options = { sizeof(PRINTDLG) };
    225   dialog_options.Flags = PD_RETURNDC | PD_RETURNDEFAULT;
    226   if (PrintDlg(&dialog_options))
    227     return ParseDialogResult(dialog_options);
    228 
    229   // No default printer configured, do we have any printers at all?
    230   DWORD bytes_needed = 0;
    231   DWORD count_returned = 0;
    232   (void)::EnumPrinters(PRINTER_ENUM_LOCAL|PRINTER_ENUM_CONNECTIONS,
    233                        NULL, 2, NULL, 0, &bytes_needed, &count_returned);
    234   if (bytes_needed) {
    235     DCHECK_GE(bytes_needed, count_returned * sizeof(PRINTER_INFO_2));
    236     scoped_ptr<BYTE[]> printer_info_buffer(new BYTE[bytes_needed]);
    237     BOOL ret = ::EnumPrinters(PRINTER_ENUM_LOCAL|PRINTER_ENUM_CONNECTIONS,
    238                               NULL, 2, printer_info_buffer.get(),
    239                               bytes_needed, &bytes_needed,
    240                               &count_returned);
    241     if (ret && count_returned) {  // have printers
    242       // Open the first successfully found printer.
    243       const PRINTER_INFO_2* info_2 =
    244           reinterpret_cast<PRINTER_INFO_2*>(printer_info_buffer.get());
    245       const PRINTER_INFO_2* info_2_end = info_2 + count_returned;
    246       for (; info_2 < info_2_end; ++info_2) {
    247         ScopedPrinterHandle printer;
    248         if (!printer.OpenPrinter(info_2->pPrinterName))
    249           continue;
    250         scoped_ptr<DEVMODE, base::FreeDeleter> dev_mode =
    251             CreateDevMode(printer, NULL);
    252         if (!dev_mode || !AllocateContext(info_2->pPrinterName, dev_mode.get(),
    253                                           &context_)) {
    254           continue;
    255         }
    256         if (InitializeSettings(*dev_mode.get(), info_2->pPrinterName, NULL, 0,
    257                                false)) {
    258           return OK;
    259         }
    260         ReleaseContext();
    261       }
    262       if (context_)
    263         return OK;
    264     }
    265   }
    266 
    267   ResetSettings();
    268   return FAILED;
    269 }
    270 
    271 gfx::Size PrintingContextWin::GetPdfPaperSizeDeviceUnits() {
    272   // Default fallback to Letter size.
    273   gfx::SizeF paper_size(kLetterWidthInch, kLetterHeightInch);
    274 
    275   // Get settings from locale. Paper type buffer length is at most 4.
    276   const int paper_type_buffer_len = 4;
    277   wchar_t paper_type_buffer[paper_type_buffer_len] = {0};
    278   GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_IPAPERSIZE, paper_type_buffer,
    279                 paper_type_buffer_len);
    280   if (wcslen(paper_type_buffer)) {  // The call succeeded.
    281     int paper_code = _wtoi(paper_type_buffer);
    282     switch (paper_code) {
    283       case DMPAPER_LEGAL:
    284         paper_size.SetSize(kLegalWidthInch, kLegalHeightInch);
    285         break;
    286       case DMPAPER_A4:
    287         paper_size.SetSize(kA4WidthInch, kA4HeightInch);
    288         break;
    289       case DMPAPER_A3:
    290         paper_size.SetSize(kA3WidthInch, kA3HeightInch);
    291         break;
    292       default:  // DMPAPER_LETTER is used for default fallback.
    293         break;
    294     }
    295   }
    296   return gfx::Size(
    297       paper_size.width() * settings_.device_units_per_inch(),
    298       paper_size.height() * settings_.device_units_per_inch());
    299 }
    300 
    301 PrintingContext::Result PrintingContextWin::UpdatePrinterSettings(
    302     bool external_preview) {
    303   DCHECK(!in_print_job_);
    304   DCHECK(!external_preview) << "Not implemented";
    305 
    306   ScopedPrinterHandle printer;
    307   if (!printer.OpenPrinter(settings_.device_name().c_str()))
    308     return OnError();
    309 
    310   // Make printer changes local to Chrome.
    311   // See MSDN documentation regarding DocumentProperties.
    312   scoped_ptr<DEVMODE, base::FreeDeleter> scoped_dev_mode =
    313       CreateDevModeWithColor(printer, settings_.device_name(),
    314                              settings_.color() != GRAY);
    315   if (!scoped_dev_mode)
    316     return OnError();
    317 
    318   {
    319     DEVMODE* dev_mode = scoped_dev_mode.get();
    320     dev_mode->dmCopies = std::max(settings_.copies(), 1);
    321     if (dev_mode->dmCopies > 1) {  // do not change unless multiple copies
    322       dev_mode->dmFields |= DM_COPIES;
    323       dev_mode->dmCollate = settings_.collate() ? DMCOLLATE_TRUE :
    324                                                   DMCOLLATE_FALSE;
    325     }
    326 
    327     switch (settings_.duplex_mode()) {
    328       case LONG_EDGE:
    329         dev_mode->dmFields |= DM_DUPLEX;
    330         dev_mode->dmDuplex = DMDUP_VERTICAL;
    331         break;
    332       case SHORT_EDGE:
    333         dev_mode->dmFields |= DM_DUPLEX;
    334         dev_mode->dmDuplex = DMDUP_HORIZONTAL;
    335         break;
    336       case SIMPLEX:
    337         dev_mode->dmFields |= DM_DUPLEX;
    338         dev_mode->dmDuplex = DMDUP_SIMPLEX;
    339         break;
    340       default:  // UNKNOWN_DUPLEX_MODE
    341         break;
    342     }
    343 
    344     dev_mode->dmFields |= DM_ORIENTATION;
    345     dev_mode->dmOrientation = settings_.landscape() ? DMORIENT_LANDSCAPE :
    346                                                       DMORIENT_PORTRAIT;
    347 
    348     const PrintSettings::RequestedMedia& requested_media =
    349         settings_.requested_media();
    350     static const int kFromUm = 100;  // Windows uses 0.1mm.
    351     int width = requested_media.size_microns.width() / kFromUm;
    352     int height = requested_media.size_microns.height() / kFromUm;
    353     unsigned id = 0;
    354     if (base::StringToUint(requested_media.vendor_id, &id) && id) {
    355       dev_mode->dmFields |= DM_PAPERSIZE;
    356       dev_mode->dmPaperSize = static_cast<short>(id);
    357     } else if (width > 0 && height > 0) {
    358       dev_mode->dmFields |= DM_PAPERWIDTH;
    359       dev_mode->dmPaperWidth = width;
    360       dev_mode->dmFields |= DM_PAPERLENGTH;
    361       dev_mode->dmPaperLength = height;
    362     }
    363   }
    364 
    365   // Update data using DocumentProperties.
    366   scoped_dev_mode = CreateDevMode(printer, scoped_dev_mode.get());
    367   if (!scoped_dev_mode)
    368     return OnError();
    369 
    370   // Set printer then refresh printer settings.
    371   if (!AllocateContext(settings_.device_name(), scoped_dev_mode.get(),
    372                        &context_)) {
    373     return OnError();
    374   }
    375   PrintSettingsInitializerWin::InitPrintSettings(context_,
    376                                                  *scoped_dev_mode.get(),
    377                                                  &settings_);
    378   return OK;
    379 }
    380 
    381 PrintingContext::Result PrintingContextWin::InitWithSettings(
    382     const PrintSettings& settings) {
    383   DCHECK(!in_print_job_);
    384 
    385   settings_ = settings;
    386 
    387   // TODO(maruel): settings_.ToDEVMODE()
    388   ScopedPrinterHandle printer;
    389   if (!printer.OpenPrinter(settings_.device_name().c_str())) {
    390     return FAILED;
    391   }
    392 
    393   Result status = OK;
    394 
    395   if (!GetPrinterSettings(printer, settings_.device_name()))
    396     status = FAILED;
    397 
    398   if (status != OK)
    399     ResetSettings();
    400   return status;
    401 }
    402 
    403 PrintingContext::Result PrintingContextWin::NewDocument(
    404     const base::string16& document_name) {
    405   DCHECK(!in_print_job_);
    406   if (!context_)
    407     return OnError();
    408 
    409   // Set the flag used by the AbortPrintJob dialog procedure.
    410   abort_printing_ = false;
    411 
    412   in_print_job_ = true;
    413 
    414   // Register the application's AbortProc function with GDI.
    415   if (SP_ERROR == SetAbortProc(context_, &AbortProc))
    416     return OnError();
    417 
    418   DCHECK(SimplifyDocumentTitle(document_name) == document_name);
    419   DOCINFO di = { sizeof(DOCINFO) };
    420   di.lpszDocName = document_name.c_str();
    421 
    422   // Is there a debug dump directory specified? If so, force to print to a file.
    423   base::string16 debug_dump_path =
    424       PrintedDocument::CreateDebugDumpPath(document_name,
    425                                            FILE_PATH_LITERAL(".prn")).value();
    426   if (!debug_dump_path.empty())
    427     di.lpszOutput = debug_dump_path.c_str();
    428 
    429   // No message loop running in unit tests.
    430   DCHECK(!base::MessageLoop::current() ||
    431          !base::MessageLoop::current()->NestableTasksAllowed());
    432 
    433   // Begin a print job by calling the StartDoc function.
    434   // NOTE: StartDoc() starts a message loop. That causes a lot of problems with
    435   // IPC. Make sure recursive task processing is disabled.
    436   if (StartDoc(context_, &di) <= 0)
    437     return OnError();
    438 
    439   return OK;
    440 }
    441 
    442 PrintingContext::Result PrintingContextWin::NewPage() {
    443   if (abort_printing_)
    444     return CANCEL;
    445   DCHECK(context_);
    446   DCHECK(in_print_job_);
    447 
    448   // Intentional No-op. NativeMetafile::SafePlayback takes care of calling
    449   // ::StartPage().
    450 
    451   return OK;
    452 }
    453 
    454 PrintingContext::Result PrintingContextWin::PageDone() {
    455   if (abort_printing_)
    456     return CANCEL;
    457   DCHECK(in_print_job_);
    458 
    459   // Intentional No-op. NativeMetafile::SafePlayback takes care of calling
    460   // ::EndPage().
    461 
    462   return OK;
    463 }
    464 
    465 PrintingContext::Result PrintingContextWin::DocumentDone() {
    466   if (abort_printing_)
    467     return CANCEL;
    468   DCHECK(in_print_job_);
    469   DCHECK(context_);
    470 
    471   // Inform the driver that document has ended.
    472   if (EndDoc(context_) <= 0)
    473     return OnError();
    474 
    475   ResetSettings();
    476   return OK;
    477 }
    478 
    479 void PrintingContextWin::Cancel() {
    480   abort_printing_ = true;
    481   in_print_job_ = false;
    482   if (context_)
    483     CancelDC(context_);
    484   if (dialog_box_) {
    485     DestroyWindow(dialog_box_);
    486     dialog_box_dismissed_ = true;
    487   }
    488 }
    489 
    490 void PrintingContextWin::ReleaseContext() {
    491   if (context_) {
    492     DeleteDC(context_);
    493     context_ = NULL;
    494   }
    495 }
    496 
    497 gfx::NativeDrawingContext PrintingContextWin::context() const {
    498   return context_;
    499 }
    500 
    501 // static
    502 BOOL PrintingContextWin::AbortProc(HDC hdc, int nCode) {
    503   if (nCode) {
    504     // TODO(maruel):  Need a way to find the right instance to set. Should
    505     // leverage PrintJobManager here?
    506     // abort_printing_ = true;
    507   }
    508   return true;
    509 }
    510 
    511 bool PrintingContextWin::InitializeSettings(const DEVMODE& dev_mode,
    512                                             const std::wstring& new_device_name,
    513                                             const PRINTPAGERANGE* ranges,
    514                                             int number_ranges,
    515                                             bool selection_only) {
    516   skia::InitializeDC(context_);
    517   DCHECK(GetDeviceCaps(context_, CLIPCAPS));
    518   DCHECK(GetDeviceCaps(context_, RASTERCAPS) & RC_STRETCHDIB);
    519   DCHECK(GetDeviceCaps(context_, RASTERCAPS) & RC_BITMAP64);
    520   // Some printers don't advertise these.
    521   // DCHECK(GetDeviceCaps(context_, RASTERCAPS) & RC_SCALING);
    522   // DCHECK(GetDeviceCaps(context_, SHADEBLENDCAPS) & SB_CONST_ALPHA);
    523   // DCHECK(GetDeviceCaps(context_, SHADEBLENDCAPS) & SB_PIXEL_ALPHA);
    524 
    525   // StretchDIBits() support is needed for printing.
    526   if (!(GetDeviceCaps(context_, RASTERCAPS) & RC_STRETCHDIB) ||
    527       !(GetDeviceCaps(context_, RASTERCAPS) & RC_BITMAP64)) {
    528     NOTREACHED();
    529     ResetSettings();
    530     return false;
    531   }
    532 
    533   DCHECK(!in_print_job_);
    534   DCHECK(context_);
    535   PageRanges ranges_vector;
    536   if (!selection_only) {
    537     // Convert the PRINTPAGERANGE array to a PrintSettings::PageRanges vector.
    538     ranges_vector.reserve(number_ranges);
    539     for (int i = 0; i < number_ranges; ++i) {
    540       PageRange range;
    541       // Transfer from 1-based to 0-based.
    542       range.from = ranges[i].nFromPage - 1;
    543       range.to = ranges[i].nToPage - 1;
    544       ranges_vector.push_back(range);
    545     }
    546   }
    547 
    548   settings_.set_ranges(ranges_vector);
    549   settings_.set_device_name(new_device_name);
    550   settings_.set_selection_only(selection_only);
    551   PrintSettingsInitializerWin::InitPrintSettings(context_, dev_mode,
    552                                                  &settings_);
    553 
    554   return true;
    555 }
    556 
    557 bool PrintingContextWin::GetPrinterSettings(HANDLE printer,
    558                                             const std::wstring& device_name) {
    559   DCHECK(!in_print_job_);
    560 
    561   scoped_ptr<DEVMODE, base::FreeDeleter> dev_mode =
    562       CreateDevMode(printer, NULL);
    563 
    564   if (!dev_mode || !AllocateContext(device_name, dev_mode.get(), &context_)) {
    565     ResetSettings();
    566     return false;
    567   }
    568 
    569   return InitializeSettings(*dev_mode.get(), device_name, NULL, 0, false);
    570 }
    571 
    572 // static
    573 bool PrintingContextWin::AllocateContext(const std::wstring& device_name,
    574                                          const DEVMODE* dev_mode,
    575                                          gfx::NativeDrawingContext* context) {
    576   *context = CreateDC(L"WINSPOOL", device_name.c_str(), NULL, dev_mode);
    577   DCHECK(*context);
    578   return *context != NULL;
    579 }
    580 
    581 PrintingContext::Result PrintingContextWin::ParseDialogResultEx(
    582     const PRINTDLGEX& dialog_options) {
    583   // If the user clicked OK or Apply then Cancel, but not only Cancel.
    584   if (dialog_options.dwResultAction != PD_RESULT_CANCEL) {
    585     // Start fresh.
    586     ResetSettings();
    587 
    588     DEVMODE* dev_mode = NULL;
    589     if (dialog_options.hDevMode) {
    590       dev_mode =
    591           reinterpret_cast<DEVMODE*>(GlobalLock(dialog_options.hDevMode));
    592       DCHECK(dev_mode);
    593     }
    594 
    595     std::wstring device_name;
    596     if (dialog_options.hDevNames) {
    597       DEVNAMES* dev_names =
    598           reinterpret_cast<DEVNAMES*>(GlobalLock(dialog_options.hDevNames));
    599       DCHECK(dev_names);
    600       if (dev_names) {
    601         device_name = reinterpret_cast<const wchar_t*>(dev_names) +
    602                       dev_names->wDeviceOffset;
    603         GlobalUnlock(dialog_options.hDevNames);
    604       }
    605     }
    606 
    607     bool success = false;
    608     if (dev_mode && !device_name.empty()) {
    609       context_ = dialog_options.hDC;
    610       PRINTPAGERANGE* page_ranges = NULL;
    611       DWORD num_page_ranges = 0;
    612       bool print_selection_only = false;
    613       if (dialog_options.Flags & PD_PAGENUMS) {
    614         page_ranges = dialog_options.lpPageRanges;
    615         num_page_ranges = dialog_options.nPageRanges;
    616       }
    617       if (dialog_options.Flags & PD_SELECTION) {
    618         print_selection_only = true;
    619       }
    620       success = InitializeSettings(*dev_mode,
    621                                    device_name,
    622                                    page_ranges,
    623                                    num_page_ranges,
    624                                    print_selection_only);
    625     }
    626 
    627     if (!success && dialog_options.hDC) {
    628       DeleteDC(dialog_options.hDC);
    629       context_ = NULL;
    630     }
    631 
    632     if (dev_mode) {
    633       GlobalUnlock(dialog_options.hDevMode);
    634     }
    635   } else {
    636     if (dialog_options.hDC) {
    637       DeleteDC(dialog_options.hDC);
    638     }
    639   }
    640 
    641   if (dialog_options.hDevMode != NULL)
    642     GlobalFree(dialog_options.hDevMode);
    643   if (dialog_options.hDevNames != NULL)
    644     GlobalFree(dialog_options.hDevNames);
    645 
    646   switch (dialog_options.dwResultAction) {
    647     case PD_RESULT_PRINT:
    648       return context_ ? OK : FAILED;
    649     case PD_RESULT_APPLY:
    650       return context_ ? CANCEL : FAILED;
    651     case PD_RESULT_CANCEL:
    652       return CANCEL;
    653     default:
    654       return FAILED;
    655   }
    656 }
    657 
    658 HRESULT PrintingContextWin::ShowPrintDialog(PRINTDLGEX* options) {
    659   // Note that this cannot use ui::BaseShellDialog as the print dialog is
    660   // system modal: opening it from a background thread can cause Windows to
    661   // get the wrong Z-order which will make the print dialog appear behind the
    662   // browser frame (but still being modal) so neither the browser frame nor
    663   // the print dialog will get any input. See http://crbug.com/342697
    664   // http://crbug.com/180997 for details.
    665   base::MessageLoop::ScopedNestableTaskAllower allow(
    666       base::MessageLoop::current());
    667 
    668   return PrintDlgEx(options);
    669 }
    670 
    671 PrintingContext::Result PrintingContextWin::ParseDialogResult(
    672     const PRINTDLG& dialog_options) {
    673   // If the user clicked OK or Apply then Cancel, but not only Cancel.
    674   // Start fresh.
    675   ResetSettings();
    676 
    677   DEVMODE* dev_mode = NULL;
    678   if (dialog_options.hDevMode) {
    679     dev_mode =
    680         reinterpret_cast<DEVMODE*>(GlobalLock(dialog_options.hDevMode));
    681     DCHECK(dev_mode);
    682   }
    683 
    684   std::wstring device_name;
    685   if (dialog_options.hDevNames) {
    686     DEVNAMES* dev_names =
    687         reinterpret_cast<DEVNAMES*>(GlobalLock(dialog_options.hDevNames));
    688     DCHECK(dev_names);
    689     if (dev_names) {
    690       device_name =
    691           reinterpret_cast<const wchar_t*>(
    692               reinterpret_cast<const wchar_t*>(dev_names) +
    693                   dev_names->wDeviceOffset);
    694       GlobalUnlock(dialog_options.hDevNames);
    695     }
    696   }
    697 
    698   bool success = false;
    699   if (dev_mode && !device_name.empty()) {
    700     context_ = dialog_options.hDC;
    701     success = InitializeSettings(*dev_mode, device_name, NULL, 0, false);
    702   }
    703 
    704   if (!success && dialog_options.hDC) {
    705     DeleteDC(dialog_options.hDC);
    706     context_ = NULL;
    707   }
    708 
    709   if (dev_mode) {
    710     GlobalUnlock(dialog_options.hDevMode);
    711   }
    712 
    713   if (dialog_options.hDevMode != NULL)
    714     GlobalFree(dialog_options.hDevMode);
    715   if (dialog_options.hDevNames != NULL)
    716     GlobalFree(dialog_options.hDevNames);
    717 
    718   return context_ ? OK : FAILED;
    719 }
    720 
    721 }  // namespace printing
    722