As the first step in an effort to improve robustness of the cloud print proxy...

chrome/service/cloud_print/printer_job_handler.cc

 // Copyright (c) 2010 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/service/cloud_print/printer_job_handler.h"
 
 #include "base/file_util.h"
 #include "base/json/json_reader.h"
 #include "base/md5.h"
 #include "base/string_util.h"
@@ skipping 142 matching lines @@
     MessageLoop::current()->PostTask(
         FROM_HERE, NewRunnableMethod(this, &PrinterJobHandler::Start));
   }
 }
 
 bool PrinterJobHandler::UpdatePrinterInfo() {
   VLOG(1) << "CP_PROXY: Update printer info, id: "
           << printer_info_cloud_.printer_id;
   // We need to update the parts of the printer info that have changed
   // (could be printer name, description, status or capabilities).
+  // First asynchronously fetch the capabilities.
   printing::PrinterBasicInfo printer_info;
   printer_watcher_->GetCurrentPrinterInfo(&printer_info);
-  printing::PrinterCapsAndDefaults printer_caps;
+  cloud_print::PrintSystem::PrinterCapsAndDefaultsCallback* callback =
+       NewCallback(this,
+                   &PrinterJobHandler::OnReceivePrinterCaps);
+  // Asnchronously fetch the printer caps and defaults. The story will
+  // continue in OnReceivePrinterCaps.
+  print_system_->GetPrinterCapsAndDefaults(
+      printer_info.printer_name.c_str(), callback);
+  // While we are waiting for the data, pretend we have work to do and return
+  // true.
+  return true;
+}
+
+void PrinterJobHandler::OnReceivePrinterCaps(
+    bool succeeded,
+    const std::string& printer_name,
+    const printing::PrinterCapsAndDefaults& caps_and_defaults) {
+  printing::PrinterBasicInfo printer_info;
+  printer_watcher_->GetCurrentPrinterInfo(&printer_info);
+
   std::string post_data;
   std::string mime_boundary;
   CloudPrintHelpers::CreateMimeBoundaryForUpload(&mime_boundary);
-  if (print_system_->GetPrinterCapsAndDefaults(
-      printer_info.printer_name, &printer_caps)) {
-    std::string caps_hash = MD5String(printer_caps.printer_capabilities);
+
+  if (succeeded) {
+    std::string caps_hash = MD5String(caps_and_defaults.printer_capabilities);
     if (caps_hash != printer_info_cloud_.caps_hash) {
       // Hashes don't match, we need to upload new capabilities (the defaults
       // go for free along with the capabilities)
       printer_info_cloud_.caps_hash = caps_hash;
       CloudPrintHelpers::AddMultipartValueForUpload(
-          kPrinterCapsValue, printer_caps.printer_capabilities,
-          mime_boundary, printer_caps.caps_mime_type, &post_data);
+          kPrinterCapsValue, caps_and_defaults.printer_capabilities,
+          mime_boundary, caps_and_defaults.caps_mime_type, &post_data);
       CloudPrintHelpers::AddMultipartValueForUpload(
-          kPrinterDefaultsValue, printer_caps.printer_defaults,
-          mime_boundary, printer_caps.defaults_mime_type,
+          kPrinterDefaultsValue, caps_and_defaults.printer_defaults,
+          mime_boundary, caps_and_defaults.defaults_mime_type,
           &post_data);
       CloudPrintHelpers::AddMultipartValueForUpload(
           kPrinterCapsHashValue, caps_hash, mime_boundary, std::string(),
           &post_data);
     }
+  } else {
+    LOG(ERROR) << "Failed to get printer caps and defaults for printer: "
+               << printer_name;
   }
+
   std::string tags_hash =
       CloudPrintHelpers::GenerateHashOfStringMap(printer_info.options);
   if (tags_hash != printer_info_cloud_.tags_hash) {
     printer_info_cloud_.tags_hash = tags_hash;
     CloudPrintHelpers::GenerateMultipartPostDataForPrinterTags(
         printer_info.options, mime_boundary, &post_data);
     // Remove all the exising proxy tags.
     std::string cp_tag_wildcard(kProxyTagPrefix);
     cp_tag_wildcard += ".*";
     CloudPrintHelpers::AddMultipartValueForUpload(
@@ skipping 11 matching lines @@
     CloudPrintHelpers::AddMultipartValueForUpload(
         kPrinterDescValue, printer_info.printer_description, mime_boundary,
         std::string() , &post_data);
   }
   if (printer_info.printer_status != printer_info_.printer_status) {
     CloudPrintHelpers::AddMultipartValueForUpload(
         kPrinterStatusValue, StringPrintf("%d", printer_info.printer_status),
         mime_boundary, std::string(), &post_data);
   }
   printer_info_ = printer_info;
-  bool ret = false;
   if (!post_data.empty()) {
     // Terminate the request body
     post_data.append("--" + mime_boundary + "--\r\n");
     std::string mime_type("multipart/form-data; boundary=");
     mime_type += mime_boundary;
     SetNextJSONHandler(&PrinterJobHandler::HandlePrinterUpdateResponse);
     request_ = new CloudPrintURLFetcher;
     request_->StartPostRequest(
         CloudPrintHelpers::GetUrlForPrinterUpdate(
             cloud_print_server_url_, printer_info_cloud_.printer_id),
         this, auth_token_, kCloudPrintAPIMaxRetryCount, mime_type, post_data);
-    ret = true;
+  } else {
+    // We are done here. Go to the Stop state
+    MessageLoop::current()->PostTask(
+        FROM_HERE, NewRunnableMethod(this, &PrinterJobHandler::Stop));
   }
-  return ret;
 }
 
 // CloudPrintURLFetcher::Delegate implementation.
 CloudPrintURLFetcher::ResponseAction PrinterJobHandler::HandleRawData(
     const URLFetcher* source,
     const GURL& url,
     const std::string& data) {
   if (!next_data_handler_)
     return CloudPrintURLFetcher::CONTINUE_PROCESSING;
   return (this->*next_data_handler_)(source, url, data);
@@ skipping 364 matching lines @@
 }
 
 void PrinterJobHandler::OnJobSpoolFailed() {
   DCHECK(MessageLoop::current() == print_thread_.message_loop());
   job_spooler_ = NULL;
   job_handler_message_loop_proxy_->PostTask(FROM_HERE,
                                             NewRunnableMethod(this,
                                                 &PrinterJobHandler::JobFailed,
                                                 PRINT_FAILED));
 }