Notify print preview UI if getting capabilityes failed.

chrome/browser/printing/print_system_task_proxy.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 "chrome/browser/printing/print_system_task_proxy.h"
 
 #include <ctype.h>
 
 #include <string>
 #include <vector>
@@ skipping 301 matching lines @@
       print_backend_(print_backend),
       has_logged_printers_count_(has_logged_printers_count) {
 }
 
 PrintSystemTaskProxy::~PrintSystemTaskProxy() {
 }
 
 void PrintSystemTaskProxy::GetDefaultPrinter() {
   VLOG(1) << "Get default printer start";
 
-  std::string* default_printer = NULL;
-  default_printer = new std::string(print_backend_->GetDefaultPrinterName());
-
   VLOG(1) << "Get default printer finished, found: "
-          << *default_printer;
-
-  std::string* cloud_print_data = new std::string;
+          << print_backend_->GetDefaultPrinterName();
 
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&PrintSystemTaskProxy::SendDefaultPrinter, this,
-                 default_printer, cloud_print_data));
+                 print_backend_->GetDefaultPrinterName(),
+                 std::string()));
 }
 
 void PrintSystemTaskProxy::SendDefaultPrinter(
-    const std::string* default_printer, const std::string* cloud_print_data) {
+    const std::string& default_printer,
+    const std::string& cloud_print_data) {
   if (handler_)
-    handler_->SendInitialSettings(*default_printer, *cloud_print_data);
-  delete default_printer;
+    handler_->SendInitialSettings(default_printer, cloud_print_data);
 }
 
 void PrintSystemTaskProxy::EnumeratePrinters() {
   VLOG(1) << "Enumerate printers start";
   ListValue* printers = new ListValue;
   printing::PrinterList printer_list;
   print_backend_->EnumeratePrinters(&printer_list);
 
   if (!has_logged_printers_count_) {
     // Record the total number of printers.
@@ skipping 24 matching lines @@
       BrowserThread::UI, FROM_HERE,
       base::Bind(&PrintSystemTaskProxy::SetupPrinterList, this, printers));
 }
 
 void PrintSystemTaskProxy::SetupPrinterList(ListValue* printers) {
   if (handler_)
     handler_->SetupPrinterList(*printers);
   delete printers;
 }
 
-#if defined(USE_CUPS)
-// static
-bool PrintSystemTaskProxy::GetPrinterCapabilitiesCUPS(
+bool PrintSystemTaskProxy::ParsePrinterCapabilities(
     const printing::PrinterCapsAndDefaults& printer_info,
     const std::string& printer_name,
     bool* set_color_as_default,
     int* printer_color_space_for_color,
     int* printer_color_space_for_black,
     bool* set_duplex_as_default,
     int* default_duplex_setting_value) {
+#if defined(USE_CUPS)
   FilePath ppd_file_path;
   if (!file_util::CreateTemporaryFile(&ppd_file_path))
     return false;
 
   int data_size = printer_info.printer_capabilities.length();
   if (data_size != file_util::WriteFile(
                        ppd_file_path,
                        printer_info.printer_capabilities.data(),
                        data_size)) {
     file_util::Delete(ppd_file_path, false);
@@ skipping 41 matching lines @@
               printer_color_space_for_color, set_color_as_default) ||
           getProcessColorModelSettings(
               ppd, printer_color_space_for_black,
               printer_color_space_for_color, set_color_as_default))) {
       VLOG(1) << "Unknown printer color model";
     }
     ppdClose(ppd);
   }
   file_util::Delete(ppd_file_path, false);
   return true;
-}
-#endif  // defined(USE_CUPS)
 
-#if defined(OS_WIN)
-void PrintSystemTaskProxy::GetPrinterCapabilitiesWin(
-    const printing::PrinterCapsAndDefaults& printer_info,
-    bool* set_color_as_default,
-    int* printer_color_space_for_color,
-    int* printer_color_space_for_black,
-    bool* set_duplex_as_default,
-    int* default_duplex_setting_value) {
+#elif defined(OS_WIN)
+
   // According to XPS 1.0 spec, only color printers have psk:Color.
   // Therefore we don't need to parse the whole XML file, we just need to
   // search the string.  The spec can be found at:
   // http://msdn.microsoft.com/en-us/windows/hardware/gg463431.
   if (printer_info.printer_capabilities.find(kPskColor) != std::string::npos)
     *printer_color_space_for_color = printing::COLOR;
 
   if ((printer_info.printer_capabilities.find(kPskGray) !=
           std::string::npos) ||
       (printer_info.printer_capabilities.find(kPskMonochrome) !=
@@ skipping 11 matching lines @@
 
   if (printer_info.printer_defaults.find(kPskDuplexFeature) !=
           std::string::npos) {
       if (printer_info.printer_defaults.find(kPskTwoSided) !=
               std::string::npos) {
         *default_duplex_setting_value = printing::LONG_EDGE;
       } else {
         *default_duplex_setting_value = printing::SIMPLEX;
     }
   }
+  return true;
+
+#else
+
+  NOTIMPLEMENTED();
+  return false;
+
+#endif  // defined(OS_WIN)
 }
-#endif  // defined(OS_WIN)
+
 
 void PrintSystemTaskProxy::GetPrinterCapabilities(
     const std::string& printer_name) {
   VLOG(1) << "Get printer capabilities start for " << printer_name;
   child_process_logging::ScopedPrinterInfoSetter prn_info(
       print_backend_->GetPrinterDriverInfo(printer_name));
 
   bool set_color_as_default = false;
   bool set_duplex_as_default = false;
   int printer_color_space_for_color = printing::UNKNOWN_COLOR_MODEL;
   int printer_color_space_for_black = printing::UNKNOWN_COLOR_MODEL;
   int default_duplex_setting_value = printing::UNKNOWN_DUPLEX_MODE;
 
   printing::PrinterCapsAndDefaults printer_info;
-  if (print_backend_->GetPrinterCapsAndDefaults(printer_name,
-                                                &printer_info)) {
-#if defined(USE_CUPS)
-    if (!GetPrinterCapabilitiesCUPS(printer_info,
-                                    printer_name,
-                                    &set_color_as_default,
-                                    &printer_color_space_for_color,
-                                    &printer_color_space_for_black,
-                                    &set_duplex_as_default,
-                                    &default_duplex_setting_value)) {
-      return;
-    }
-#elif defined(OS_WIN)
-    GetPrinterCapabilitiesWin(printer_info,
-                              &set_color_as_default,
-                              &printer_color_space_for_color,
-                              &printer_color_space_for_black,
-                              &set_duplex_as_default,
-                              &default_duplex_setting_value);
-#else
-    NOTIMPLEMENTED();
-#endif
+  if (!print_backend_->GetPrinterCapsAndDefaults(printer_name,
+                                                 &printer_info) ||
+      !ParsePrinterCapabilities(printer_info,
+                                printer_name,
+                                &set_color_as_default,
+                                &printer_color_space_for_color,
+                                &printer_color_space_for_black,
+                                &set_duplex_as_default,
+                                &default_duplex_setting_value)) {
+    BrowserThread::PostTask(
+        BrowserThread::UI, FROM_HERE,
+        base::Bind(&PrintSystemTaskProxy::SendFailedToGetPrinterCapabilities,
+                   this, printer_name));
+    return;
   }
   bool disable_color_options = (!printer_color_space_for_color ||
                                 !printer_color_space_for_black ||
                                 (printer_color_space_for_color ==
                                  printer_color_space_for_black));
 
   DictionaryValue settings_info;
   settings_info.SetString(kPrinterId, printer_name);
   settings_info.SetBoolean(kDisableColorOption, disable_color_options);
   if (printer_color_space_for_color == printing::UNKNOWN_COLOR_MODEL)
@@ skipping 16 matching lines @@
       base::Bind(&PrintSystemTaskProxy::SendPrinterCapabilities, this,
                  settings_info.DeepCopy()));
 }
 
 void PrintSystemTaskProxy::SendPrinterCapabilities(
     DictionaryValue* settings_info) {
   if (handler_)
     handler_->SendPrinterCapabilities(*settings_info);
   delete settings_info;
 }
+
+void PrintSystemTaskProxy::SendFailedToGetPrinterCapabilities(
+    const std::string& printer_name) {
+  if (handler_)
+    handler_->SendFailedToGetPrinterCapabilities(printer_name);
+}