printing/backend/win_helper.h

   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 #ifndef PRINTING_BACKEND_WIN_HELPER_H_
   6 #define PRINTING_BACKEND_WIN_HELPER_H_
   7
   8 #include <objidl.h>
   9 #include <winspool.h>
  10 #include <prntvpt.h>
  11 #include <xpsprint.h>
  12
  13 #include <string>
  14
  15 #include "base/strings/string16.h"
  16 #include "base/win/scoped_handle.h"
  17 #include "printing/printing_export.h"
  18
  19 // These are helper functions for dealing with Windows Printing.
  20 namespace printing {
  21
  22 struct PRINTING_EXPORT PrinterBasicInfo;
  23
  24 class PrinterHandleTraits {
  25  public:
  26   typedef HANDLE Handle;
  27
  28   static bool CloseHandle(HANDLE handle) {
  29     return ::ClosePrinter(handle) != FALSE;
  30   }
  31
  32   static bool IsHandleValid(HANDLE handle) {
  33     return handle != NULL;
  34   }
  35
  36   static HANDLE NullHandle() {
  37     return NULL;
  38   }
  39
  40  private:
  41   DISALLOW_IMPLICIT_CONSTRUCTORS(PrinterHandleTraits);
  42 };
  43
  44 class ScopedPrinterHandle
  45     : public base::win::GenericScopedHandle<PrinterHandleTraits,
  46                                             base::win::VerifierTraits> {
  47  public:
  48   bool OpenPrinter(const wchar_t* printer) {
  49     HANDLE temp_handle;
  50     // ::OpenPrinter may return error but assign some value into handle.
  51     if (::OpenPrinter(const_cast<LPTSTR>(printer), &temp_handle, NULL)) {
  52       Set(temp_handle);
  53     }
  54     return IsValid();
  55   }
  56
  57  private:
  58   typedef base::win::GenericScopedHandle<PrinterHandleTraits,
  59                                          base::win::VerifierTraits> Base;
  60 };
  61
  62 class PrinterChangeHandleTraits {
  63  public:
  64   typedef HANDLE Handle;
  65
  66   static bool CloseHandle(HANDLE handle) {
  67     ::FindClosePrinterChangeNotification(handle);
  68     return true;
  69   }
  70
  71   static bool IsHandleValid(HANDLE handle) {
  72     return handle != NULL;
  73   }
  74
  75   static HANDLE NullHandle() {
  76     return NULL;
  77   }
  78
  79  private:
  80   DISALLOW_IMPLICIT_CONSTRUCTORS(PrinterChangeHandleTraits);
  81 };
  82
  83 typedef base::win::GenericScopedHandle<PrinterChangeHandleTraits,
  84                                        base::win::DummyVerifierTraits>
  85     ScopedPrinterChangeHandle;
  86
  87 // Wrapper class to wrap the XPS APIs (PTxxx APIs). This is needed because these
  88 // APIs are not available by default on XP. We could delayload prntvpt.dll but
  89 // this would mean having to add that to every binary that links with
  90 // printing.lib (which is a LOT of binaries). So choosing the GetProcAddress
  91 // route instead).
  92 class PRINTING_EXPORT XPSModule {
  93  public:
  94   // All the other methods can ONLY be called after a successful call to Init.
  95   // Init can be called many times and by multiple threads.
  96   static bool Init();
  97   static HRESULT OpenProvider(const base::string16& printer_name,
  98                               DWORD version,
  99                               HPTPROVIDER* provider);
 100   static HRESULT GetPrintCapabilities(HPTPROVIDER provider,
 101                                       IStream* print_ticket,
 102                                       IStream* capabilities,
 103                                       BSTR* error_message);
 104   static HRESULT ConvertDevModeToPrintTicket(HPTPROVIDER provider,
 105                                              ULONG devmode_size_in_bytes,
 106                                              PDEVMODE devmode,
 107                                              EPrintTicketScope scope,
 108                                              IStream* print_ticket);
 109   static HRESULT ConvertPrintTicketToDevMode(
 110       HPTPROVIDER provider,
 111       IStream* print_ticket,
 112       EDefaultDevmodeType base_devmode_type,
 113       EPrintTicketScope scope,
 114       ULONG* devmode_byte_count,
 115       PDEVMODE* devmode,
 116       BSTR* error_message);
 117   static HRESULT MergeAndValidatePrintTicket(HPTPROVIDER provider,
 118                                              IStream* base_ticket,
 119                                              IStream* delta_ticket,
 120                                              EPrintTicketScope scope,
 121                                              IStream* result_ticket,
 122                                              BSTR* error_message);
 123   static HRESULT ReleaseMemory(PVOID buffer);
 124   static HRESULT CloseProvider(HPTPROVIDER provider);
 125
 126  private:
 127   XPSModule() { }
 128   static bool InitImpl();
 129 };
 130
 131 // See comments in cc file explaining why we need this.
 132 class PRINTING_EXPORT ScopedXPSInitializer {
 133  public:
 134   ScopedXPSInitializer();
 135   ~ScopedXPSInitializer();
 136
 137   bool initialized() const { return initialized_; }
 138
 139  private:
 140   bool initialized_;
 141 };
 142
 143 // Wrapper class to wrap the XPS Print APIs (these are different from the PTxxx
 144 // which deal with the XML Print Schema). This is needed because these
 145 // APIs are only available on Windows 7 and higher.
 146 class PRINTING_EXPORT XPSPrintModule {
 147  public:
 148   // All the other methods can ONLY be called after a successful call to Init.
 149   // Init can be called many times and by multiple threads.
 150   static bool Init();
 151   static HRESULT StartXpsPrintJob(
 152       const LPCWSTR printer_name,
 153       const LPCWSTR job_name,
 154       const LPCWSTR output_file_name,
 155       HANDLE progress_event,
 156       HANDLE completion_event,
 157       UINT8* printable_pages_on,
 158       UINT32 printable_pages_on_count,
 159       IXpsPrintJob **xps_print_job,
 160       IXpsPrintJobStream **document_stream,
 161       IXpsPrintJobStream **print_ticket_stream);
 162  private:
 163   XPSPrintModule() { }
 164   static bool InitImpl();
 165 };
 166
 167 PRINTING_EXPORT bool InitBasicPrinterInfo(HANDLE printer,
 168                                           PrinterBasicInfo* printer_info);
 169
 170 PRINTING_EXPORT std::string GetDriverInfo(HANDLE printer);
 171
 172 }  // namespace printing
 173
 174 #endif  // PRINTING_BACKEND_WIN_HELPER_H_