printing/printing_context_win.cc

   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