Wrapers for PRINTER_INFO_* and DRIVER_INFO_*.

printing/printing_context_win_unittest.cc

 // Copyright (c) 2011 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 <ocidl.h>
 #include <commdlg.h>
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/memory/scoped_ptr.h"
+#include "printing/backend/printing_info_win.h"
 #include "printing/printing_test.h"
 #include "printing/printing_context.h"
 #include "printing/printing_context_win.h"
 #include "printing/print_settings.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 // This test is automatically disabled if no printer is available.
 class PrintingContextTest : public PrintingTest<testing::Test> {
  public:
   void PrintSettingsCallback(printing::PrintingContext::Result result) {
@@ skipping 20 matching lines @@
   lppd->lpPageRanges[0].nFromPage = 1;
   lppd->lpPageRanges[0].nToPage = 5;
 
   // Painful paperwork.
   std::wstring printer_name = PrintingContextTest::GetDefaultPrinter();
   HANDLE printer;
   if (!OpenPrinter(const_cast<wchar_t*>(printer_name.c_str()), &printer, NULL))
     return E_FAIL;
 
   scoped_array<uint8> buffer;
-  DEVMODE* dev_mode = NULL;
-  PRINTER_INFO_2* info_2 = NULL;
+  const DEVMODE* dev_mode = NULL;
   HRESULT result = S_OK;
   lppd->hDC = NULL;
   lppd->hDevMode = NULL;
   lppd->hDevNames = NULL;
 
-  printing::PrintingContextWin::GetPrinterHelper(printer, 2, &buffer);
-  if (buffer.get()) {
-    info_2 = reinterpret_cast<PRINTER_INFO_2*>(buffer.get());
-    if (info_2->pDevMode != NULL)
-      dev_mode = info_2->pDevMode;
+  printing::PrinterInfo2 info_2;
+  if (info_2.Init(printer)) {
+    dev_mode = info_2.get()->pDevMode;
   }
   if (!dev_mode) {
     result = E_FAIL;
     goto Cleanup;
   }
 
   if (!printing::PrintingContextWin::AllocateContext(printer_name, dev_mode,
       &lppd->hDC)) {
     result = E_FAIL;
     goto Cleanup;
   }
 
   size_t dev_mode_size = dev_mode->dmSize + dev_mode->dmDriverExtra;
   lppd->hDevMode = GlobalAlloc(GMEM_MOVEABLE, dev_mode_size);
   if (!lppd->hDevMode) {
     result = E_FAIL;
     goto Cleanup;
   }
   void* dev_mode_ptr = GlobalLock(lppd->hDevMode);
   if (!dev_mode_ptr) {
     result = E_FAIL;
     goto Cleanup;
   }
   memcpy(dev_mode_ptr, dev_mode, dev_mode_size);
   GlobalUnlock(lppd->hDevMode);
   dev_mode_ptr = NULL;
 
-  size_t driver_size = 2 + sizeof(wchar_t) * lstrlen(info_2->pDriverName);
-  size_t printer_size = 2 + sizeof(wchar_t) * lstrlen(info_2->pPrinterName);
-  size_t port_size = 2 + sizeof(wchar_t) * lstrlen(info_2->pPortName);
+  size_t driver_size = 2 + sizeof(wchar_t) * lstrlen(info_2.get()->pDriverName);
+  size_t printer_size = 2 + sizeof(wchar_t) *
+                            lstrlen(info_2.get()->pPrinterName);
+  size_t port_size = 2 + sizeof(wchar_t) * lstrlen(info_2.get()->pPortName);
   size_t dev_names_size = sizeof(DEVNAMES) + driver_size + printer_size +
-      port_size;
+                          port_size;
   lppd->hDevNames = GlobalAlloc(GHND, dev_names_size);
   if (!lppd->hDevNames) {
     result = E_FAIL;
     goto Cleanup;
   }
   void* dev_names_ptr = GlobalLock(lppd->hDevNames);
   if (!dev_names_ptr) {
     result = E_FAIL;
     goto Cleanup;
   }
   DEVNAMES* dev_names = reinterpret_cast<DEVNAMES*>(dev_names_ptr);
   dev_names->wDefault = 1;
   dev_names->wDriverOffset = sizeof(DEVNAMES);
   memcpy(reinterpret_cast<uint8*>(dev_names_ptr) + dev_names->wDriverOffset,
-      info_2->pDriverName, driver_size);
+         info_2.get()->pDriverName, driver_size);
   dev_names->wDeviceOffset = dev_names->wDriverOffset + driver_size;
   memcpy(reinterpret_cast<uint8*>(dev_names_ptr) + dev_names->wDeviceOffset,
-      info_2->pPrinterName, printer_size);
+         info_2.get()->pPrinterName, printer_size);
   dev_names->wOutputOffset = dev_names->wDeviceOffset + printer_size;
   memcpy(reinterpret_cast<uint8*>(dev_names_ptr) + dev_names->wOutputOffset,
-      info_2->pPortName, port_size);
+         info_2.get()->pPortName, port_size);
   GlobalUnlock(lppd->hDevNames);
   dev_names_ptr = NULL;
 
 Cleanup:
   // Note: This section does proper deallocation/free of DC/global handles.  We
   //       did not use ScopedHGlobal or ScopedHandle because they did not
   //       perform what we need.  Goto's are used based on Windows programming
   //       idiom, to avoid deeply nested if's, and try-catch-finally is not
   //       allowed in Chromium.
   if (FAILED(result)) {
@@ skipping 38 matching lines @@
   std::string dummy_locale;
   printing::PrintingContextWin context(dummy_locale);
   context.SetPrintDialog(&PrintDlgExMock);
   context.AskUserForSettings(
       NULL, 123, false, base::Bind(&PrintingContextTest::PrintSettingsCallback,
                                    base::Unretained(this)));
   EXPECT_EQ(printing::PrintingContext::OK, result());
   printing::PrintSettings settings = context.settings();
   EXPECT_EQ(settings.ranges.size(), 0);
 }