Printing: Convert PrintingContext into an interface implemented by the separate

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 "printing/printing_context_win.h"
 
 #include <winspool.h>
 
 #include "base/file_util.h"
 #include "base/i18n/file_util_icu.h"
 #include "base/i18n/time_formatting.h"
 #include "base/message_loop.h"
 #include "base/time.h"
 #include "base/utf_string_conversions.h"
 #include "printing/printed_document.h"
 #include "skia/ext/platform_device_win.h"
 
 using base::Time;
 
 namespace printing {
 
-class PrintingContext::CallbackHandler : public IPrintDialogCallback,
-                                         public IObjectWithSite {
+class PrintingContextWin::CallbackHandler : public IPrintDialogCallback,
+                                            public IObjectWithSite {
  public:
-  CallbackHandler(PrintingContext& owner, HWND owner_hwnd)
+  CallbackHandler(PrintingContextWin& owner, HWND owner_hwnd)
       : owner_(owner),
         owner_hwnd_(owner_hwnd),
         services_(NULL) {
   }
 
   ~CallbackHandler() {
     if (services_)
       services_->Release();
   }
 
@@ skipping 70 matching lines @@
       DCHECK(SUCCEEDED(hr));
     }
     return S_OK;
   }
 
   virtual HRESULT WINAPI GetSite(REFIID riid, void** site) {
     return E_NOTIMPL;
   }
 
  private:
-  PrintingContext& owner_;
+  PrintingContextWin& owner_;
   HWND owner_hwnd_;
   IPrintDialogServices* services_;
 
   DISALLOW_COPY_AND_ASSIGN(CallbackHandler);
 };
 
-PrintingContext::PrintingContext()
-    : context_(NULL),
+// static
+PrintingContext* PrintingContext::Create() {
+  return static_cast<PrintingContext*>(new PrintingContextWin);
+}
+
+PrintingContextWin::PrintingContextWin()
+    : PrintingContext(),
+      context_(NULL),
       dialog_box_(NULL),
-      dialog_box_dismissed_(false),
-      in_print_job_(false),
-      abort_printing_(false),
       print_dialog_func_(&PrintDlgEx) {
 }
 
-PrintingContext::~PrintingContext() {
-  ResetSettings();
+PrintingContextWin::~PrintingContextWin() {
+  ReleaseContext();
 }
 
-void PrintingContext::AskUserForSettings(HWND view,
-                                         int max_pages,
-                                         bool has_selection,
-                                         PrintSettingsCallback* callback) {
+void PrintingContextWin::AskUserForSettings(HWND view,
+                                            int max_pages,
+                                            bool has_selection,
+                                            PrintSettingsCallback* callback) {
   DCHECK(!in_print_job_);
   dialog_box_dismissed_ = false;
 
   HWND window;
   if (!view || !IsWindow(view)) {
     // TODO(maruel):  bug 1214347 Get the right browser window instead.
     window = GetDesktopWindow();
   } else {
     window = GetAncestor(view, GA_ROOTOWNER);
   }
@@ skipping 37 matching lines @@
   {
     if ((*print_dialog_func_)(&dialog_options) != S_OK) {
       ResetSettings();
       callback->Run(FAILED);
     }
   }
   // TODO(maruel):  Support PD_PRINTTOFILE.
   callback->Run(ParseDialogResultEx(dialog_options));
 }
 
-PrintingContext::Result PrintingContext::UseDefaultSettings() {
+PrintingContext::Result PrintingContextWin::UseDefaultSettings() {
   DCHECK(!in_print_job_);
 
   PRINTDLG dialog_options = { sizeof(PRINTDLG) };
   dialog_options.Flags = PD_RETURNDC | PD_RETURNDEFAULT;
   if (PrintDlg(&dialog_options) == 0) {
     ResetSettings();
     return FAILED;
   }
   return ParseDialogResult(dialog_options);
 }
 
-PrintingContext::Result PrintingContext::InitWithSettings(
+PrintingContext::Result PrintingContextWin::InitWithSettings(
     const PrintSettings& settings) {
   DCHECK(!in_print_job_);
   settings_ = settings;
   // TODO(maruel): settings_->ToDEVMODE()
   HANDLE printer;
   if (!OpenPrinter(const_cast<wchar_t*>(settings_.device_name().c_str()),
                    &printer,
                    NULL))
     return FAILED;
 
   Result status = OK;
 
   if (!GetPrinterSettings(printer, settings_.device_name()))
     status = FAILED;
 
   // Close the printer after retrieving the context.
   ClosePrinter(printer);
 
   if (status != OK)
     ResetSettings();
   return status;
 }
 
-void PrintingContext::ResetSettings() {
-  if (context_ != NULL) {
-    DeleteDC(context_);
-    context_ = NULL;
-  }
-  settings_.Clear();
-  in_print_job_ = false;
-}
-
-PrintingContext::Result PrintingContext::NewDocument(
+PrintingContext::Result PrintingContextWin::NewDocument(
     const string16& document_name) {
   DCHECK(!in_print_job_);
   if (!context_)
     return OnError();
 
   // Set the flag used by the AbortPrintJob dialog procedure.
   abort_printing_ = false;
 
   in_print_job_ = true;
 
@@ skipping 29 matching lines @@
 
   // 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(context_, &di) <= 0)
     return OnError();
 
   return OK;
 }
 
-PrintingContext::Result PrintingContext::NewPage() {
+PrintingContext::Result PrintingContextWin::NewPage() {
   if (abort_printing_)
     return CANCEL;
 
   DCHECK(context_);
   DCHECK(in_print_job_);
 
   // Inform the driver that the application is about to begin sending data.
   if (StartPage(context_) <= 0)
     return OnError();
 
   return OK;
 }
 
-PrintingContext::Result PrintingContext::PageDone() {
+PrintingContext::Result PrintingContextWin::PageDone() {
   if (abort_printing_)
     return CANCEL;
   DCHECK(in_print_job_);
 
   if (EndPage(context_) <= 0)
     return OnError();
   return OK;
 }
 
-PrintingContext::Result PrintingContext::DocumentDone() {
+PrintingContext::Result PrintingContextWin::DocumentDone() {
   if (abort_printing_)
     return CANCEL;
   DCHECK(in_print_job_);
   DCHECK(context_);
 
   // Inform the driver that document has ended.
   if (EndDoc(context_) <= 0)
     return OnError();
 
   ResetSettings();
   return OK;
 }
 
-void PrintingContext::Cancel() {
+void PrintingContextWin::Cancel() {
   abort_printing_ = true;
   in_print_job_ = false;
   if (context_)
     CancelDC(context_);
   DismissDialog();
 }
 
-void PrintingContext::DismissDialog() {
+void PrintingContextWin::DismissDialog() {
   if (dialog_box_) {
     DestroyWindow(dialog_box_);
     dialog_box_dismissed_ = true;
   }
 }
 
-PrintingContext::Result PrintingContext::OnError() {
-  // This will close context_ and clear settings_.
-  ResetSettings();
-  return abort_printing_ ? CANCEL : FAILED;
+void PrintingContextWin::ReleaseContext() {
+  if (context_) {
+    DeleteDC(context_);
+    context_ = NULL;
+  }
+}
+
+gfx::NativeDrawingContext PrintingContextWin::context() const {
+  return context_;
 }
 
 // static
-BOOL PrintingContext::AbortProc(HDC hdc, int nCode) {
+BOOL PrintingContextWin::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) {
+bool PrintingContextWin::InitializeSettings(const DEVMODE& dev_mode,
+                                            const std::wstring& new_device_name,
+                                            const PRINTPAGERANGE* ranges,
+                                            int number_ranges,
+                                            bool selection_only) {
   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(context_, RASTERCAPS) & RC_SCALING);
   // DCHECK(GetDeviceCaps(context_, SHADEBLENDCAPS) & SB_CONST_ALPHA);
   // DCHECK(GetDeviceCaps(context_, SHADEBLENDCAPS) & SB_PIXEL_ALPHA);
 
   // StretchDIBits() support is needed for printing.
@@ skipping 19 matching lines @@
     }
   }
   settings_.Init(context_,
                  dev_mode,
                  ranges_vector,
                  new_device_name,
                  selection_only);
   return true;
 }
 
-bool PrintingContext::GetPrinterSettings(HANDLE printer,
-                                         const std::wstring& device_name) {
+bool PrintingContextWin::GetPrinterSettings(HANDLE printer,
+                                            const std::wstring& device_name) {
   DCHECK(!in_print_job_);
   scoped_array<uint8> buffer;
 
   // A PRINTER_INFO_9 structure specifying the per-user default printer
   // settings.
   GetPrinterHelper(printer, 9, &buffer);
   if (buffer.get()) {
     PRINTER_INFO_9* info_9 = reinterpret_cast<PRINTER_INFO_9*>(buffer.get());
     if (info_9->pDevMode != NULL) {
       if (!AllocateContext(device_name, info_9->pDevMode, &context_)) {
@@ skipping 32 matching lines @@
       return InitializeSettings(*info_2->pDevMode, device_name, NULL, 0, false);
     }
     buffer.reset();
   }
   // Failed to retrieve the printer settings.
   ResetSettings();
   return false;
 }
 
 // static
-bool PrintingContext::AllocateContext(const std::wstring& printer_name,
-                                      const DEVMODE* dev_mode,
-                                      gfx::NativeDrawingContext* context) {
+bool PrintingContextWin::AllocateContext(const std::wstring& printer_name,
+                                         const DEVMODE* dev_mode,
+                                         gfx::NativeDrawingContext* context) {
   *context = CreateDC(L"WINSPOOL", printer_name.c_str(), NULL, dev_mode);
   DCHECK(*context);
   return *context != NULL;
 }
 
-PrintingContext::Result PrintingContext::ParseDialogResultEx(
+PrintingContext::Result PrintingContextWin::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;
     if (dialog_options.hDevMode) {
       dev_mode =
           reinterpret_cast<DEVMODE*>(GlobalLock(dialog_options.hDevMode));
@@ skipping 58 matching lines @@
       return context_ ? OK : FAILED;
     case PD_RESULT_APPLY:
       return context_ ? CANCEL : FAILED;
     case PD_RESULT_CANCEL:
       return CANCEL;
     default:
       return FAILED;
   }
 }
 
-PrintingContext::Result PrintingContext::ParseDialogResult(
+PrintingContext::Result PrintingContextWin::ParseDialogResult(
     const PRINTDLG& dialog_options) {
   // If the user clicked OK or Apply then Cancel, but not only Cancel.
   // Start fresh.
   ResetSettings();
 
   DEVMODE* dev_mode = NULL;
   if (dialog_options.hDevMode) {
     dev_mode =
         reinterpret_cast<DEVMODE*>(GlobalLock(dialog_options.hDevMode));
     DCHECK(dev_mode);
@@ skipping 30 matching lines @@
 
   if (dialog_options.hDevMode != NULL)
     GlobalFree(dialog_options.hDevMode);
   if (dialog_options.hDevNames != NULL)
     GlobalFree(dialog_options.hDevNames);
 
   return context_ ? OK : FAILED;
 }
 
 // static
-void PrintingContext::GetPrinterHelper(HANDLE printer, int level,
-                                       scoped_array<uint8>* buffer) {
+void PrintingContextWin::GetPrinterHelper(HANDLE printer, int level,
+                                          scoped_array<uint8>* buffer) {
   DWORD buf_size = 0;
   GetPrinter(printer, level, NULL, 0, &buf_size);
   if (buf_size) {
     buffer->reset(new uint8[buf_size]);
     memset(buffer->get(), 0, buf_size);
     if (!GetPrinter(printer, level, buffer->get(), buf_size, &buf_size)) {
       buffer->reset();
     }
   }
 }
 
 }  // namespace printing