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