GetPrinterDriverInfo returns string.

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 <algorithm>
 #include <objidl.h>
 #include <winspool.h>
 
 #include "base/file_path.h"
 #include "base/file_version_info.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/string_piece.h"
 #include "base/utf_string_conversions.h"
 #include "base/win/scoped_bstr.h"
 #include "base/win/scoped_comptr.h"
@@ skipping 26 matching lines @@
   virtual ~PrintBackendWin() {}
 
   virtual bool EnumeratePrinters(PrinterList* printer_list);
 
   virtual std::string GetDefaultPrinterName();
 
   virtual bool GetPrinterCapsAndDefaults(const std::string& printer_name,
                                          PrinterCapsAndDefaults* printer_info);
 
   virtual bool GetPrinterDriverInfo(const std::string& printer_name,
-                                    PrinterDriverInfo* driver_info);
+                                    std::string* driver_info);
 
   virtual bool IsValidPrinter(const std::string& printer_name);
 };
 
 bool PrintBackendWin::EnumeratePrinters(PrinterList* printer_list) {
   DCHECK(printer_list);
   DWORD bytes_needed = 0;
   DWORD count_returned = 0;
   BOOL ret = EnumPrinters(PRINTER_ENUM_LOCAL|PRINTER_ENUM_CONNECTIONS, NULL, 2,
                           NULL, 0, &bytes_needed, &count_returned);
@@ skipping 107 matching lines @@
         }
       }
     }
     XPSModule::CloseProvider(provider);
   }
   return true;
 }
 
 // Gets the information about driver for a specific printer.
 bool PrintBackendWin::GetPrinterDriverInfo(const std::string& printer_name,
-                                           PrinterDriverInfo* driver_info) {
+                                           std::string* driver_info) {
   DCHECK(driver_info);
   ScopedPrinterHandle printer_handle;
   if (!::OpenPrinter(const_cast<LPTSTR>(UTF8ToWide(printer_name).c_str()),
                      printer_handle.Receive(), NULL)) {
     return false;
   }
   DCHECK(printer_handle.IsValid());
   DWORD bytes_needed = 0;
   ::GetPrinterDriver(printer_handle, NULL, 6, NULL, 0, &bytes_needed);
   scoped_array<BYTE> driver_info_buffer(new BYTE[bytes_needed]);
   if (!bytes_needed || !driver_info_buffer.get())
     return false;
   if (!::GetPrinterDriver(printer_handle, NULL, 6, driver_info_buffer.get(),
                           bytes_needed, &bytes_needed)) {
     return false;
   }
   if (!bytes_needed)
     return false;
   const DRIVER_INFO_6* driver_info_6 =
       reinterpret_cast<DRIVER_INFO_6*>(driver_info_buffer.get());
 
+  std::string info[4];
+
   if (driver_info_6->pName)
-    driver_info->driver_name = WideToUTF8(driver_info_6->pName);
+    info[0] = WideToUTF8(driver_info_6->pName);
 
   if (driver_info_6->pDriverPath) {
     scoped_ptr<FileVersionInfo> version_info(
         FileVersionInfo::CreateFileVersionInfo(
             FilePath(driver_info_6->pDriverPath)));
-    driver_info->driver_version = WideToUTF8(version_info->file_version());
-    driver_info->product_name = WideToUTF8(version_info->product_name());
-    driver_info->product_version = WideToUTF8(version_info->product_version());
+    info[1] = WideToUTF8(version_info->file_version());
+    info[2] = WideToUTF8(version_info->product_name());
+    info[3] = WideToUTF8(version_info->product_version());
+  }
+
+  for (size_t i = 0; i < arraysize(info); ++i) {
+    std::replace(info[i].begin(), info[i].end(), ';', ',');
+    driver_info->append(info[i]);
+    driver_info->append(";");
   }
 
   return true;
 }
 
 bool PrintBackendWin::IsValidPrinter(const std::string& printer_name) {
   ScopedPrinterHandle printer_handle;
   OpenPrinter(const_cast<LPTSTR>(UTF8ToWide(printer_name).c_str()),
               printer_handle.Receive(), NULL);
   return printer_handle.IsValid();
 }
 
 scoped_refptr<PrintBackend> PrintBackend::CreateInstance(
     const base::DictionaryValue* print_backend_settings) {
   return new PrintBackendWin;
 }
 
 }  // namespace printing