printing/printing_context_win_unittest.cc

   1 // Copyright 2011 The Chromium Authors
   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 <stddef.h>
   8 #include <stdint.h>
   9
  10 #include <utility>
  11
  12 #include "base/bind.h"
  13 #include "base/strings/utf_string_conversions.h"
  14 #include "base/test/task_environment.h"
  15 #include "base/win/scoped_handle.h"
  16 #include "base/win/scoped_hdc.h"
  17 #include "printing/backend/printing_info_win.h"
  18 #include "printing/backend/win_helper.h"
  19 #include "printing/mojom/print.mojom.h"
  20 #include "printing/print_settings.h"
  21 #include "printing/printing_context_system_dialog_win.h"
  22 #include "printing/printing_test.h"
  23 #include "testing/gtest/include/gtest/gtest.h"
  24
  25 namespace printing {
  26
  27 // This test is automatically disabled if no printer is available.
  28 class PrintingContextTest : public PrintingTest<testing::Test>,
  29                             public PrintingContext::Delegate {
  30  public:
  31   void PrintSettingsCallback(mojom::ResultCode result) { result_ = result; }
  32
  33   // PrintingContext::Delegate methods.
  34   gfx::NativeView GetParentView() override { return nullptr; }
  35   std::string GetAppLocale() override { return std::string(); }
  36
  37  protected:
  38   mojom::ResultCode result() const { return result_; }
  39
  40  private:
  41   mojom::ResultCode result_;
  42 };
  43
  44 namespace {
  45
  46 struct FreeHandleTraits {
  47   typedef HANDLE Handle;
  48   static void CloseHandle(HANDLE handle) { GlobalFree(handle); }
  49   static bool IsHandleValid(HANDLE handle) { return handle != nullptr; }
  50   static HANDLE NullHandle() { return nullptr; }
  51 };
  52
  53 using ScopedGlobalAlloc =
  54     base::win::GenericScopedHandle<FreeHandleTraits,
  55                                    base::win::DummyVerifierTraits>;
  56
  57 }  // namespace
  58
  59 class MockPrintingContextWin : public PrintingContextSystemDialogWin {
  60  public:
  61   explicit MockPrintingContextWin(Delegate* delegate)
  62       : PrintingContextSystemDialogWin(delegate) {}
  63
  64  protected:
  65   // This is a fake PrintDlgEx implementation that sets the right fields in
  66   // `lppd` to trigger a bug in older revisions of PrintingContext.
  67   HRESULT ShowPrintDialog(PRINTDLGEX* lppd) override {
  68     // The interesting bits:
  69     // Pretend the user hit print
  70     lppd->dwResultAction = PD_RESULT_PRINT;
  71
  72     // Pretend the page range is 1-5, but since lppd->Flags does not have
  73     // PD_SELECTION set, this really shouldn't matter.
  74     lppd->nPageRanges = 1;
  75     lppd->lpPageRanges[0].nFromPage = 1;
  76     lppd->lpPageRanges[0].nToPage = 5;
  77
  78     std::wstring printer_name = PrintingContextTest::GetDefaultPrinter();
  79     ScopedPrinterHandle printer;
  80     if (!printer.OpenPrinterWithName(printer_name.c_str()))
  81       return E_FAIL;
  82
  83     const DEVMODE* dev_mode = nullptr;
  84     lppd->hDC = nullptr;
  85     lppd->hDevMode = nullptr;
  86     lppd->hDevNames = nullptr;
  87
  88     PrinterInfo2 info_2;
  89     if (info_2.Init(printer.Get()))
  90       dev_mode = info_2.get()->pDevMode;
  91     if (!dev_mode)
  92       return E_FAIL;
  93
  94     base::win::ScopedCreateDC hdc(
  95         CreateDC(L"WINSPOOL", printer_name.c_str(), nullptr, dev_mode));
  96     if (!hdc.Get())
  97       return E_FAIL;
  98
  99     size_t dev_mode_size = dev_mode->dmSize + dev_mode->dmDriverExtra;
 100     ScopedGlobalAlloc dev_mode_mem(GlobalAlloc(GMEM_MOVEABLE, dev_mode_size));
 101     if (!dev_mode_mem.Get())
 102       return E_FAIL;
 103     void* dev_mode_ptr = GlobalLock(dev_mode_mem.Get());
 104     if (!dev_mode_ptr)
 105       return E_FAIL;
 106     memcpy(dev_mode_ptr, dev_mode, dev_mode_size);
 107     GlobalUnlock(dev_mode_mem.Get());
 108     dev_mode_ptr = nullptr;
 109
 110     size_t driver_size =
 111         2 + sizeof(wchar_t) * lstrlen(info_2.get()->pDriverName);
 112     size_t printer_size =
 113         2 + sizeof(wchar_t) * lstrlen(info_2.get()->pPrinterName);
 114     size_t port_size = 2 + sizeof(wchar_t) * lstrlen(info_2.get()->pPortName);
 115     size_t dev_names_size =
 116         sizeof(DEVNAMES) + driver_size + printer_size + port_size;
 117     ScopedGlobalAlloc dev_names_mem(GlobalAlloc(GHND, dev_names_size));
 118     if (!dev_names_mem.Get())
 119       return E_FAIL;
 120     void* dev_names_ptr = GlobalLock(dev_names_mem.Get());
 121     if (!dev_names_ptr)
 122       return E_FAIL;
 123     DEVNAMES* dev_names = reinterpret_cast<DEVNAMES*>(dev_names_ptr);
 124     dev_names->wDefault = 1;
 125     dev_names->wDriverOffset = sizeof(DEVNAMES) / sizeof(wchar_t);
 126     memcpy(reinterpret_cast<uint8_t*>(dev_names_ptr) + dev_names->wDriverOffset,
 127            info_2.get()->pDriverName, driver_size);
 128     dev_names->wDeviceOffset = base::checked_cast<WORD>(
 129         dev_names->wDriverOffset + driver_size / sizeof(wchar_t));
 130     memcpy(reinterpret_cast<uint8_t*>(dev_names_ptr) + dev_names->wDeviceOffset,
 131            info_2.get()->pPrinterName, printer_size);
 132     dev_names->wOutputOffset = base::checked_cast<WORD>(
 133         dev_names->wDeviceOffset + printer_size / sizeof(wchar_t));
 134     memcpy(reinterpret_cast<uint8_t*>(dev_names_ptr) + dev_names->wOutputOffset,
 135            info_2.get()->pPortName, port_size);
 136     GlobalUnlock(dev_names_mem.Get());
 137     dev_names_ptr = nullptr;
 138
 139     lppd->hDC = hdc.Take();
 140     lppd->hDevMode = dev_mode_mem.Take();
 141     lppd->hDevNames = dev_names_mem.Take();
 142     return S_OK;
 143   }
 144 };
 145
 146 // Disabled - see crbug.com/1231528 for context.
 147 TEST_F(PrintingContextTest, DISABLED_PrintAll) {
 148   if (IsTestCaseDisabled())
 149     return;
 150
 151   base::test::SingleThreadTaskEnvironment task_environment;
 152   MockPrintingContextWin context(this);
 153   context.AskUserForSettings(
 154       123, false, false,
 155       base::BindOnce(&PrintingContextTest::PrintSettingsCallback,
 156                      base::Unretained(this)));
 157   EXPECT_EQ(mojom::ResultCode::kSuccess, result());
 158   const PrintSettings& settings = context.settings();
 159   EXPECT_EQ(0u, settings.ranges().size());
 160 }
 161
 162 // Disabled - see crbug.com/1231528 for context.
 163 TEST_F(PrintingContextTest, DISABLED_Color) {
 164   if (IsTestCaseDisabled())
 165     return;
 166
 167   base::test::SingleThreadTaskEnvironment task_environment;
 168   MockPrintingContextWin context(this);
 169   context.AskUserForSettings(
 170       123, false, false,
 171       base::BindOnce(&PrintingContextTest::PrintSettingsCallback,
 172                      base::Unretained(this)));
 173   EXPECT_EQ(mojom::ResultCode::kSuccess, result());
 174   const PrintSettings& settings = context.settings();
 175   EXPECT_NE(settings.color(), mojom::ColorModel::kUnknownColorModel);
 176 }
 177
 178 // Disabled - see crbug.com/1231528 for context.
 179 TEST_F(PrintingContextTest, DISABLED_Base) {
 180   if (IsTestCaseDisabled())
 181     return;
 182
 183   auto settings = std::make_unique<PrintSettings>();
 184   settings->set_device_name(base::WideToUTF16(GetDefaultPrinter()));
 185   // Initialize it.
 186   PrintingContextWin context(this);
 187   EXPECT_EQ(mojom::ResultCode::kSuccess,
 188             context.InitWithSettingsForTest(std::move(settings)));
 189
 190   // The print may lie to use and may not support world transformation.
 191   // Verify right now.
 192   XFORM random_matrix = {1, 0.1f, 0, 1.5f, 0, 1};
 193   EXPECT_TRUE(SetWorldTransform(context.context(), &random_matrix));
 194   EXPECT_TRUE(ModifyWorldTransform(context.context(), nullptr, MWT_IDENTITY));
 195 }
 196
 197 }  // namespace printing