Implement the basic OS-level printing mechanics on Mac

printing/printing_context_win.cc

 // Copyright (c) 2009 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.h"
 
 #include <winspool.h>
 
 #include "base/file_util.h"
 #include "base/i18n/file_util_icu.h"
@@ skipping 120 matching lines @@
 
  private:
   PrintingContext& owner_;
   HWND owner_hwnd_;
   IPrintDialogServices* services_;
 
   DISALLOW_EVIL_CONSTRUCTORS(CallbackHandler);
 };
 
 PrintingContext::PrintingContext()
-    : hdc_(NULL),
+    : context_(NULL),
 #ifndef NDEBUG
       page_number_(-1),
 #endif
       dialog_box_(NULL),
       dialog_box_dismissed_(false),
       in_print_job_(false),
       abort_printing_(false) {
 }
 
 PrintingContext::~PrintingContext() {
@@ skipping 82 matching lines @@
 
   // Close the printer after retrieving the context.
   ClosePrinter(printer);
 
   if (status != OK)
     ResetSettings();
   return status;
 }
 
 void PrintingContext::ResetSettings() {
-  if (hdc_ != NULL) {
-    DeleteDC(hdc_);
-    hdc_ = NULL;
+  if (context_ != NULL) {
+    DeleteDC(context_);
+    context_ = NULL;
   }
   settings_.Clear();
   in_print_job_ = false;
 
 #ifndef NDEBUG
   page_number_ = -1;
 #endif
 }
 
 PrintingContext::Result PrintingContext::NewDocument(
     const std::wstring& document_name) {
   DCHECK(!in_print_job_);
-  if (!hdc_)
+  if (!context_)
     return OnError();
 
   // Set the flag used by the AbortPrintJob dialog procedure.
   abort_printing_ = false;
 
   in_print_job_ = true;
 
   // Register the application's AbortProc function with GDI.
-  if (SP_ERROR == SetAbortProc(hdc_, &AbortProc))
+  if (SP_ERROR == SetAbortProc(context_, &AbortProc))
     return OnError();
 
   DOCINFO di = { sizeof(DOCINFO) };
   di.lpszDocName = document_name.c_str();
 
   // Is there a debug dump directory specified? If so, force to print to a file.
   std::wstring debug_dump_path = PrintedDocument::debug_dump_path();
   if (!debug_dump_path.empty()) {
     // Create a filename.
     std::wstring filename;
@@ skipping 10 matching lines @@
     di.lpszOutput = debug_dump_path.c_str();
   }
 
   // No message loop running in unit tests.
   DCHECK(!MessageLoop::current() ? true :
       !MessageLoop::current()->NestableTasksAllowed());
 
   // Begin a print job by calling the StartDoc function.
   // NOTE: StartDoc() starts a message loop. That causes a lot of problems with
   // IPC. Make sure recursive task processing is disabled.
-  if (StartDoc(hdc_, &di) <= 0)
+  if (StartDoc(context_, &di) <= 0)
     return OnError();
 
 #ifndef NDEBUG
   page_number_ = 0;
 #endif
   return OK;
 }
 
 PrintingContext::Result PrintingContext::NewPage() {
   if (abort_printing_)
     return CANCEL;
   DCHECK(in_print_job_);
 
   // Inform the driver that the application is about to begin sending data.
-  if (StartPage(hdc_) <= 0)
+  if (StartPage(context_) <= 0)
     return OnError();
 
 #ifndef NDEBUG
   ++page_number_;
 #endif
 
   return OK;
 }
 
 PrintingContext::Result PrintingContext::PageDone() {
   if (abort_printing_)
     return CANCEL;
   DCHECK(in_print_job_);
 
-  if (EndPage(hdc_) <= 0)
+  if (EndPage(context_) <= 0)
     return OnError();
   return OK;
 }
 
 PrintingContext::Result PrintingContext::DocumentDone() {
   if (abort_printing_)
     return CANCEL;
   DCHECK(in_print_job_);
 
   // Inform the driver that document has ended.
-  if (EndDoc(hdc_) <= 0)
+  if (EndDoc(context_) <= 0)
     return OnError();
 
   ResetSettings();
   return OK;
 }
 
 void PrintingContext::Cancel() {
   abort_printing_ = true;
   in_print_job_ = false;
-  if (hdc_)
-    CancelDC(hdc_);
+  if (context_)
+    CancelDC(context_);
   DismissDialog();
 }
 
 void PrintingContext::DismissDialog() {
   if (dialog_box_) {
     DestroyWindow(dialog_box_);
     dialog_box_dismissed_ = true;
   }
 }
 
 PrintingContext::Result PrintingContext::OnError() {
-  // This will close hdc_ and clear settings_.
+  // This will close context_ and clear settings_.
   ResetSettings();
   return abort_printing_ ? CANCEL : FAILED;
 }
 
 // static
 BOOL PrintingContext::AbortProc(HDC hdc, int nCode) {
   if (nCode) {
     // TODO(maruel):  Need a way to find the right instance to set. Should
     // leverage PrintJobManager here?
     // abort_printing_ = true;
   }
   return true;
 }
 
 bool PrintingContext::InitializeSettings(const DEVMODE& dev_mode,
                                          const std::wstring& new_device_name,
                                          const PRINTPAGERANGE* ranges,
                                          int number_ranges,
                                          bool selection_only) {
-  skia::PlatformDevice::InitializeDC(hdc_);
-  DCHECK(GetDeviceCaps(hdc_, CLIPCAPS));
-  DCHECK(GetDeviceCaps(hdc_, RASTERCAPS) & RC_STRETCHDIB);
-  DCHECK(GetDeviceCaps(hdc_, RASTERCAPS) & RC_BITMAP64);
+  skia::PlatformDevice::InitializeDC(context_);
+  DCHECK(GetDeviceCaps(context_, CLIPCAPS));
+  DCHECK(GetDeviceCaps(context_, RASTERCAPS) & RC_STRETCHDIB);
+  DCHECK(GetDeviceCaps(context_, RASTERCAPS) & RC_BITMAP64);
   // Some printers don't advertise these.
-  // DCHECK(GetDeviceCaps(hdc_, RASTERCAPS) & RC_SCALING);
-  // DCHECK(GetDeviceCaps(hdc_, SHADEBLENDCAPS) & SB_CONST_ALPHA);
-  // DCHECK(GetDeviceCaps(hdc_, SHADEBLENDCAPS) & SB_PIXEL_ALPHA);
+  // DCHECK(GetDeviceCaps(context_, RASTERCAPS) & RC_SCALING);
+  // DCHECK(GetDeviceCaps(context_, SHADEBLENDCAPS) & SB_CONST_ALPHA);
+  // DCHECK(GetDeviceCaps(context_, SHADEBLENDCAPS) & SB_PIXEL_ALPHA);
 
   // StretchDIBits() support is needed for printing.
-  if (!(GetDeviceCaps(hdc_, RASTERCAPS) & RC_STRETCHDIB) ||
-      !(GetDeviceCaps(hdc_, RASTERCAPS) & RC_BITMAP64)) {
+  if (!(GetDeviceCaps(context_, RASTERCAPS) & RC_STRETCHDIB) ||
+      !(GetDeviceCaps(context_, RASTERCAPS) & RC_BITMAP64)) {
     NOTREACHED();
     ResetSettings();
     return false;
   }
 
   DCHECK(!in_print_job_);
-  DCHECK(hdc_);
+  DCHECK(context_);
   PageRanges ranges_vector;
   if (!selection_only) {
     // Convert the PRINTPAGERANGE array to a PrintSettings::PageRanges vector.
     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);
     }
   }
-  settings_.Init(hdc_,
+  settings_.Init(context_,
                  dev_mode,
                  ranges_vector,
                  new_device_name,
                  selection_only);
   return true;
 }
 
 bool PrintingContext::GetPrinterSettings(HANDLE printer,
                                          const std::wstring& device_name) {
   DCHECK(!in_print_job_);
@@ skipping 42 matching lines @@
     }
     buffer.reset();
   }
   // Failed to retrieve the printer settings.
   ResetSettings();
   return false;
 }
 
 bool PrintingContext::AllocateContext(const std::wstring& printer_name,
                                       const DEVMODE* dev_mode) {
-  hdc_ = CreateDC(L"WINSPOOL", printer_name.c_str(), NULL, dev_mode);
-  DCHECK(hdc_);
-  return hdc_ != NULL;
+  context_ = CreateDC(L"WINSPOOL", printer_name.c_str(), NULL, dev_mode);
+  DCHECK(context_);
+  return context_ != NULL;
 }
 
 PrintingContext::Result PrintingContext::ParseDialogResultEx(
     const PRINTDLGEX& dialog_options) {
   // If the user clicked OK or Apply then Cancel, but not only Cancel.
   if (dialog_options.dwResultAction != PD_RESULT_CANCEL) {
     // Start fresh.
     ResetSettings();
 
     DEVMODE* dev_mode = NULL;
@@ skipping 12 matching lines @@
         device_name =
             reinterpret_cast<const wchar_t*>(
                 reinterpret_cast<const wchar_t*>(dev_names) +
                     dev_names->wDeviceOffset);
         GlobalUnlock(dialog_options.hDevNames);
       }
     }
 
     bool success = false;
     if (dev_mode && !device_name.empty()) {
-      hdc_ = dialog_options.hDC;
+      context_ = dialog_options.hDC;
       PRINTPAGERANGE* page_ranges = NULL;
       DWORD num_page_ranges = 0;
       bool print_selection_only = false;
       if (dialog_options.Flags & PD_PAGENUMS) {
         page_ranges = dialog_options.lpPageRanges;
         num_page_ranges = dialog_options.nPageRanges;
       }
       if (dialog_options.Flags & PD_SELECTION) {
         print_selection_only = true;
       }
       success = InitializeSettings(*dev_mode,
                                    device_name,
                                    dialog_options.lpPageRanges,
                                    dialog_options.nPageRanges,
                                    print_selection_only);
     }
 
     if (!success && dialog_options.hDC) {
       DeleteDC(dialog_options.hDC);
-      hdc_ = NULL;
+      context_ = NULL;
     }
 
     if (dev_mode) {
       GlobalUnlock(dialog_options.hDevMode);
     }
   } else {
     if (dialog_options.hDC) {
       DeleteDC(dialog_options.hDC);
     }
   }
 
   if (dialog_options.hDevMode != NULL)
     GlobalFree(dialog_options.hDevMode);
   if (dialog_options.hDevNames != NULL)
     GlobalFree(dialog_options.hDevNames);
 
   switch (dialog_options.dwResultAction) {
     case PD_RESULT_PRINT:
-      return hdc_ ? OK : FAILED;
+      return context_ ? OK : FAILED;
     case PD_RESULT_APPLY:
-      return hdc_ ? CANCEL : FAILED;
+      return context_ ? CANCEL : FAILED;
     case PD_RESULT_CANCEL:
       return CANCEL;
     default:
       return FAILED;
   }
 }
 
 PrintingContext::Result PrintingContext::ParseDialogResult(
     const PRINTDLG& dialog_options) {
   // If the user clicked OK or Apply then Cancel, but not only Cancel.
@@ skipping 16 matching lines @@
       device_name =
           reinterpret_cast<const wchar_t*>(
               reinterpret_cast<const wchar_t*>(dev_names) +
                   dev_names->wDeviceOffset);
       GlobalUnlock(dialog_options.hDevNames);
     }
   }
 
   bool success = false;
   if (dev_mode && !device_name.empty()) {
-    hdc_ = dialog_options.hDC;
+    context_ = dialog_options.hDC;
     success = InitializeSettings(*dev_mode, device_name, NULL, 0, false);
   }
 
   if (!success && dialog_options.hDC) {
     DeleteDC(dialog_options.hDC);
-    hdc_ = NULL;
+    context_ = NULL;
   }
 
   if (dev_mode) {
     GlobalUnlock(dialog_options.hDevMode);
   }
 
   if (dialog_options.hDevMode != NULL)
     GlobalFree(dialog_options.hDevMode);
   if (dialog_options.hDevNames != NULL)
     GlobalFree(dialog_options.hDevNames);
 
-  return hdc_ ? OK : FAILED;
+  return context_ ? OK : FAILED;
 }
 
 }  // namespace printing