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 25 matching lines @@
       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(

[Albert Bodenhamer, 2012/08/22 01:02:23]

Prototype is the same on all platforms.  Move the #if inside the function.

[Vitaly Buka (NO REVIEWS), 2012/08/22 02:58:02]

Done.

     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) {
   FilePath ppd_file_path;
   if (!file_util::CreateTemporaryFile(&ppd_file_path))
     return false;
@@ skipping 49 matching lines @@
           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(
+#elif defined(OS_WIN)
+
+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) {
   // 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)
@@ skipping 16 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
+
+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) {
+  NOTIMPLEMENTED();
+  return false;
 }
 #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);

[Robert Toscano, 2012/08/22 01:05:31]

Is it Google C++ to leave off curlies on one-liner ifs?

[Albert Bodenhamer, 2012/08/22 01:09:41]

It's the preferred Chrome style.  I personally dislike it, but I've stopped
commenting on it either way.

[Vitaly Buka (NO REVIEWS), 2012/08/22 02:58:02]

Both styles are allowed.

+}