Print Preview: Get printer info with capabilities.

printing/backend/print_backend_win.cc

 // Copyright (c) 2012 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 "printing/backend/print_backend.h"
 
 #include <objidl.h>
 #include <stddef.h>
 #include <winspool.h>
 
@@ skipping 144 matching lines @@
 
 }  // namespace
 
 class PrintBackendWin : public PrintBackend {
  public:
   PrintBackendWin() {}
 
   // PrintBackend implementation.
   bool EnumeratePrinters(PrinterList* printer_list) override;
   std::string GetDefaultPrinterName() override;
+  bool GetPrinterBasicInfo(const std::string& printer_name,
+                           PrinterBasicInfo* printer_info) override;
   bool GetPrinterSemanticCapsAndDefaults(
       const std::string& printer_name,
       PrinterSemanticCapsAndDefaults* printer_info) override;
   bool GetPrinterCapsAndDefaults(
       const std::string& printer_name,
       PrinterCapsAndDefaults* printer_info) override;
   std::string GetPrinterDriverInfo(
       const std::string& printer_name) override;
   bool IsValidPrinter(const std::string& printer_name) override;
 
  protected:
   ~PrintBackendWin() override {}
 };
 
 bool PrintBackendWin::EnumeratePrinters(PrinterList* printer_list) {
   DCHECK(printer_list);
   DWORD bytes_needed = 0;
   DWORD count_returned = 0;
   const DWORD kLevel = 4;
-  BOOL ret = EnumPrinters(PRINTER_ENUM_LOCAL|PRINTER_ENUM_CONNECTIONS, NULL,
-                          kLevel, NULL, 0, &bytes_needed, &count_returned);
+  EnumPrinters(PRINTER_ENUM_LOCAL | PRINTER_ENUM_CONNECTIONS, nullptr, kLevel,
+               nullptr, 0, &bytes_needed, &count_returned);
   if (!bytes_needed)
     return false;
   std::unique_ptr<BYTE[]> printer_info_buffer(new BYTE[bytes_needed]);
-  ret = EnumPrinters(PRINTER_ENUM_LOCAL|PRINTER_ENUM_CONNECTIONS, NULL, kLevel,
-                     printer_info_buffer.get(), bytes_needed, &bytes_needed,
-                     &count_returned);
-  DCHECK(ret);
-  if (!ret)
+  if (!EnumPrinters(PRINTER_ENUM_LOCAL | PRINTER_ENUM_CONNECTIONS, nullptr,
+                    kLevel, printer_info_buffer.get(), bytes_needed,
+                    &bytes_needed, &count_returned)) {
+    NOTREACHED();
     return false;
+  }
 
   std::string default_printer = GetDefaultPrinterName();
   PRINTER_INFO_4* printer_info =
       reinterpret_cast<PRINTER_INFO_4*>(printer_info_buffer.get());
   for (DWORD index = 0; index < count_returned; index++) {
     ScopedPrinterHandle printer;
     PrinterBasicInfo info;
     if (printer.OpenPrinter(printer_info[index].pPrinterName) &&
         InitBasicPrinterInfo(printer.Get(), &info)) {
       info.is_default = (info.printer_name == default_printer);
       printer_list->push_back(info);
     }
   }
   return true;
 }
 
 std::string PrintBackendWin::GetDefaultPrinterName() {
   DWORD size = MAX_PATH;
   TCHAR default_printer_name[MAX_PATH];
-  if (!::GetDefaultPrinter(default_printer_name, &size))
-    return std::string();
-  return base::WideToUTF8(default_printer_name);
+  std::string ret;
+  if (::GetDefaultPrinter(default_printer_name, &size))
+    ret = base::WideToUTF8(default_printer_name);
+  return ret;
+}
+
+bool PrintBackendWin::GetPrinterBasicInfo(const std::string& printer_name,
+                                          PrinterBasicInfo* printer_info) {
+  ScopedPrinterHandle printer_handle;
+  if (!printer_handle.OpenPrinter(base::UTF8ToWide(printer_name).c_str()))
+    return false;
+
+  if (!InitBasicPrinterInfo(printer_handle.Get(), printer_info))
+    return false;
+
+  std::string default_printer = GetDefaultPrinterName();
+  printer_info->is_default = (printer_info->printer_name == default_printer);
+  return true;
 }
 
 bool PrintBackendWin::GetPrinterSemanticCapsAndDefaults(
     const std::string& printer_name,
     PrinterSemanticCapsAndDefaults* printer_info) {
   ScopedPrinterHandle printer_handle;
   if (!printer_handle.OpenPrinter(base::UTF8ToWide(printer_name).c_str())) {
     LOG(WARNING) << "Failed to open printer, error = " << GetLastError();
     return false;
   }
@@ skipping 136 matching lines @@
   ScopedPrinterHandle printer_handle;
   return printer_handle.OpenPrinter(base::UTF8ToWide(printer_name).c_str());
 }
 
 scoped_refptr<PrintBackend> PrintBackend::CreateInstance(
     const base::DictionaryValue* print_backend_settings) {
   return new PrintBackendWin;
 }
 
 }  // namespace printing