printing_context_win_unittest.cc 6.9 KB

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