printing/printing_context_win_unittest.cc

   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
   5 #include "printing/printing_context_win.h"
   6
   7 #include "base/bind.h"
   8 #include "base/message_loop/message_loop.h"
   9 #include "printing/backend/printing_info_win.h"
  10 #include "printing/backend/win_helper.h"
  11 #include "printing/print_settings.h"
  12 #include "printing/printing_context_system_dialog_win.h"
  13 #include "printing/printing_test.h"
  14 #include "testing/gtest/include/gtest/gtest.h"
  15
  16 namespace printing {
  17
  18 // This test is automatically disabled if no printer is available.
  19 class PrintingContextTest : public PrintingTest<testing::Test>,
  20                             public PrintingContext::Delegate {
  21  public:
  22   void PrintSettingsCallback(PrintingContext::Result result) {
  23     result_ = result;
  24   }
  25
  26   // PrintingContext::Delegate methods.
  27   virtual gfx::NativeView GetParentView() OVERRIDE { return NULL; }
  28   virtual std::string GetAppLocale() OVERRIDE { return std::string(); }
  29
  30  protected:
  31   PrintingContext::Result result() const { return result_; }
  32
  33  private:
  34   PrintingContext::Result result_;
  35 };
  36
  37 class MockPrintingContextWin : public PrintingContextSytemDialogWin {
  38  public:
  39   MockPrintingContextWin(Delegate* delegate)
  40       : PrintingContextSytemDialogWin(delegate) {}
  41
  42  protected:
  43   // This is a fake PrintDlgEx implementation that sets the right fields in
  44   // |lppd| to trigger a bug in older revisions of PrintingContext.
  45   HRESULT ShowPrintDialog(PRINTDLGEX* lppd) OVERRIDE {
  46     // The interesting bits:
  47     // Pretend the user hit print
  48     lppd->dwResultAction = PD_RESULT_PRINT;
  49
  50     // Pretend the page range is 1-5, but since lppd->Flags does not have
  51     // PD_SELECTION set, this really shouldn't matter.
  52     lppd->nPageRanges = 1;
  53     lppd->lpPageRanges[0].nFromPage = 1;
  54     lppd->lpPageRanges[0].nToPage = 5;
  55
  56     base::string16 printer_name = PrintingContextTest::GetDefaultPrinter();
  57     ScopedPrinterHandle printer;
  58     if (!printer.OpenPrinter(printer_name.c_str()))
  59       return E_FAIL;
  60
  61     scoped_ptr<uint8[]> buffer;
  62     const DEVMODE* dev_mode = NULL;
  63     HRESULT result = S_OK;
  64     lppd->hDC = NULL;
  65     lppd->hDevMode = NULL;
  66     lppd->hDevNames = NULL;
  67
  68     PrinterInfo2 info_2;
  69     if (info_2.Init(printer.Get())) {
  70       dev_mode = info_2.get()->pDevMode;
  71     }
  72     if (!dev_mode) {
  73       result = E_FAIL;
  74       goto Cleanup;
  75     }
  76
  77     lppd->hDC = CreateDC(L"WINSPOOL", printer_name.c_str(), NULL, dev_mode);
  78     if (!lppd->hDC) {
  79       result = E_FAIL;
  80       goto Cleanup;
  81     }
  82
  83     size_t dev_mode_size = dev_mode->dmSize + dev_mode->dmDriverExtra;
  84     lppd->hDevMode = GlobalAlloc(GMEM_MOVEABLE, dev_mode_size);
  85     if (!lppd->hDevMode) {
  86       result = E_FAIL;
  87       goto Cleanup;
  88     }
  89     void* dev_mode_ptr = GlobalLock(lppd->hDevMode);
  90     if (!dev_mode_ptr) {
  91       result = E_FAIL;
  92       goto Cleanup;
  93     }
  94     memcpy(dev_mode_ptr, dev_mode, dev_mode_size);
  95     GlobalUnlock(lppd->hDevMode);
  96     dev_mode_ptr = NULL;
  97
  98     size_t driver_size =
  99         2 + sizeof(wchar_t) * lstrlen(info_2.get()->pDriverName);
 100     size_t printer_size =
 101         2 + sizeof(wchar_t) * lstrlen(info_2.get()->pPrinterName);
 102     size_t port_size = 2 + sizeof(wchar_t) * lstrlen(info_2.get()->pPortName);
 103     size_t dev_names_size =
 104         sizeof(DEVNAMES) + driver_size + printer_size + port_size;
 105     lppd->hDevNames = GlobalAlloc(GHND, dev_names_size);
 106     if (!lppd->hDevNames) {
 107       result = E_FAIL;
 108       goto Cleanup;
 109     }
 110     void* dev_names_ptr = GlobalLock(lppd->hDevNames);
 111     if (!dev_names_ptr) {
 112       result = E_FAIL;
 113       goto Cleanup;
 114     }
 115     DEVNAMES* dev_names = reinterpret_cast<DEVNAMES*>(dev_names_ptr);
 116     dev_names->wDefault = 1;
 117     dev_names->wDriverOffset = sizeof(DEVNAMES) / sizeof(wchar_t);
 118     memcpy(reinterpret_cast<uint8*>(dev_names_ptr) + dev_names->wDriverOffset,
 119            info_2.get()->pDriverName,
 120            driver_size);
 121     dev_names->wDeviceOffset =
 122         dev_names->wDriverOffset + driver_size / sizeof(wchar_t);
 123     memcpy(reinterpret_cast<uint8*>(dev_names_ptr) + dev_names->wDeviceOffset,
 124            info_2.get()->pPrinterName,
 125            printer_size);
 126     dev_names->wOutputOffset =
 127         dev_names->wDeviceOffset + printer_size / sizeof(wchar_t);
 128     memcpy(reinterpret_cast<uint8*>(dev_names_ptr) + dev_names->wOutputOffset,
 129            info_2.get()->pPortName,
 130            port_size);
 131     GlobalUnlock(lppd->hDevNames);
 132     dev_names_ptr = NULL;
 133
 134   Cleanup:
 135     // Note: This section does proper deallocation/free of DC/global handles. We
 136     //       did not use ScopedHGlobal or ScopedHandle because they did not
 137     //       perform what we need.  Goto's are used based on Windows programming
 138     //       idiom, to avoid deeply nested if's, and try-catch-finally is not
 139     //       allowed in Chromium.
 140     if (FAILED(result)) {
 141       if (lppd->hDC) {
 142         DeleteDC(lppd->hDC);
 143       }
 144       if (lppd->hDevMode) {
 145         GlobalFree(lppd->hDevMode);
 146       }
 147       if (lppd->hDevNames) {
 148         GlobalFree(lppd->hDevNames);
 149       }
 150     }
 151     return result;
 152   }
 153 };
 154
 155 TEST_F(PrintingContextTest, PrintAll) {
 156   base::MessageLoop message_loop;
 157   if (IsTestCaseDisabled())
 158     return;
 159
 160   MockPrintingContextWin context(this);
 161   context.AskUserForSettings(
 162       123,
 163       false,
 164       base::Bind(&PrintingContextTest::PrintSettingsCallback,
 165                  base::Unretained(this)));
 166   EXPECT_EQ(PrintingContext::OK, result());
 167   PrintSettings settings = context.settings();
 168   EXPECT_EQ(settings.ranges().size(), 0);
 169 }
 170
 171 TEST_F(PrintingContextTest, Base) {
 172   if (IsTestCaseDisabled())
 173     return;
 174
 175   PrintSettings settings;
 176   settings.set_device_name(GetDefaultPrinter());
 177   // Initialize it.
 178   scoped_ptr<PrintingContext> context(PrintingContext::Create(this));
 179   EXPECT_EQ(PrintingContext::OK, context->InitWithSettings(settings));
 180
 181   // The print may lie to use and may not support world transformation.
 182   // Verify right now.
 183   XFORM random_matrix = { 1, 0.1f, 0, 1.5f, 0, 1 };
 184   EXPECT_TRUE(SetWorldTransform(context->context(), &random_matrix));
 185   EXPECT_TRUE(ModifyWorldTransform(context->context(), NULL, MWT_IDENTITY));
 186 }
 187
 188 }  // namespace printing