Code to send diagnostic messages about cloud print proxy. Currently diagnosti...

chrome/service/cloud_print/cloud_print_proxy_backend.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/cloud_print_proxy_backend.h"
 
 #include <map>
 #include <vector>
 
+#include "app/l10n_util.h"
 #include "base/file_util.h"
 #include "base/md5.h"
 #include "base/rand_util.h"
 #include "base/string_number_conversions.h"
 #include "base/string_split.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/service/cloud_print/cloud_print_consts.h"
 #include "chrome/service/cloud_print/cloud_print_helpers.h"
 #include "chrome/service/cloud_print/cloud_print_url_fetcher.h"
 #include "chrome/service/cloud_print/printer_job_handler.h"
 #include "chrome/service/gaia/service_gaia_authenticator.h"
 #include "chrome/service/service_process.h"
 #include "googleurl/src/gurl.h"
+#include "grit/generated_resources.h"
 #include "jingle/notifier/base/notifier_options.h"
 #include "jingle/notifier/listener/push_notifications_thread.h"
 #include "jingle/notifier/listener/talk_mediator_impl.h"
 #include "net/url_request/url_request_status.h"
 
 // The real guts of CloudPrintProxyBackend, to keep the public client API clean.
 class CloudPrintProxyBackend::Core
     : public base::RefCountedThreadSafe<CloudPrintProxyBackend::Core>,
       public CloudPrintURLFetcherDelegate,
       public cloud_print::PrintServerWatcherDelegate,
@@ skipping 64 matching lines @@
       const URLFetcher* source,
       const GURL& url,
       DictionaryValue* json_data,
       bool succeeded);
 
   CloudPrintURLFetcher::ResponseAction HandleRegisterPrinterResponse(
       const URLFetcher* source,
       const GURL& url,
       DictionaryValue* json_data,
       bool succeeded);
+
+  CloudPrintURLFetcher::ResponseAction HandleRegisterFailedStatusResponse(
+      const URLFetcher* source,
+      const GURL& url,
+      DictionaryValue* json_data,
+      bool succeeded);
+
+CloudPrintURLFetcher::ResponseAction HandlePrintSystemUnavailableResponse(
+      const URLFetcher* source,
+      const GURL& url,
+      DictionaryValue* json_data,
+      bool succeeded);
   // End response handlers
 
   // NotifyXXX is how the Core communicates with the frontend across
   // threads.
   void NotifyPrinterListAvailable(
       const printing::PrinterList& printer_list);
   void NotifyAuthenticated(
     const std::string& cloud_print_token,
     const std::string& cloud_print_xmpp_token,
     const std::string& email);
   void NotifyAuthenticationFailed();
+  void NotifyPrintSystemUnavailable();
 
   // Starts a new printer registration process.
   void StartRegistration();
   // Ends the printer registration process.
   void EndRegistration();
   // Registers printer capabilities and defaults for the next printer in the
   // list with the cloud print server.
   void RegisterNextPrinter();
   // Retrieves the list of registered printers for this user/proxy combination
   // from the cloud print server.
   void GetRegisteredPrinters();
   // Removes the given printer from the list. Returns false if the printer
   // did not exist in the list.
   bool RemovePrinterFromList(const std::string& printer_name);
   // Initializes a job handler object for the specified printer. The job
   // handler is responsible for checking for pending print jobs for this
   // printer and print them.
   void InitJobHandlerForPrinter(DictionaryValue* printer_data);
+  // Sends a diagnostic message to the cloud print server that the print
+  // system failed to initialize.
+  void ReportPrintSystemUnavailable(const std::string& failure_message);
 
   // Callback method for GetPrinterCapsAndDefaults.
   void OnReceivePrinterCaps(
       bool succeeded,
       const std::string& printer_name,
       const printing::PrinterCapsAndDefaults& caps_and_defaults);
 
   void HandlePrinterNotification(const std::string& printer_id);
   void PollForJobs();
   // Schedules a task to poll for jobs. Does nothing if a task is already
@@ skipping 178 matching lines @@
   DCHECK(MessageLoop::current() == backend_->core_thread_.message_loop());
   VLOG(1) << "CP_PROXY: Starting proxy, id: " << proxy_id;
 
   print_system_ =
       cloud_print::PrintSystem::CreateInstance(print_system_settings_.get());
   if (!print_system_.get()) {
     NOTREACHED();
     return;  // No print system available, fail initalization.
   }
 
-  print_system_->Init();
+  cloud_print::PrintSystem::PrintSystemResult result = print_system_->Init();
 
   // TODO(sanjeevr): Validate the tokens.
   auth_token_ = cloud_print_token;
 
-  const notifier::NotifierOptions kNotifierOptions;
-  const bool kInvalidateXmppAuthToken = false;
-  const bool kAllowInsecureXmppConnection = false;
-  talk_mediator_.reset(new notifier::TalkMediatorImpl(
-      new notifier::PushNotificationsThread(kNotifierOptions,
-                                            kCloudPrintPushNotificationsSource),
-      kInvalidateXmppAuthToken,
-      kAllowInsecureXmppConnection));
-  push_notifications_channel_ = kCloudPrintPushNotificationsSource;
-  push_notifications_channel_.append("/proxy/");
-  push_notifications_channel_.append(proxy_id);
-  talk_mediator_->AddSubscribedServiceUrl(push_notifications_channel_);
-  talk_mediator_->SetDelegate(this);
-  talk_mediator_->SetAuthToken(email, cloud_print_xmpp_token,
-                               kSyncGaiaServiceId);
-  talk_mediator_->Login();
+  if (result.succeeded()) {
+    const notifier::NotifierOptions kNotifierOptions;
+    const bool kInvalidateXmppAuthToken = false;
+    const bool kAllowInsecureXmppConnection = false;
+    talk_mediator_.reset(new notifier::TalkMediatorImpl(
+        new notifier::PushNotificationsThread(
+            kNotifierOptions,
+            kCloudPrintPushNotificationsSource),
+        kInvalidateXmppAuthToken,
+        kAllowInsecureXmppConnection));
+    push_notifications_channel_ = kCloudPrintPushNotificationsSource;
+    push_notifications_channel_.append("/proxy/");
+    push_notifications_channel_.append(proxy_id);
+    talk_mediator_->AddSubscribedServiceUrl(push_notifications_channel_);
+    talk_mediator_->SetDelegate(this);
+    talk_mediator_->SetAuthToken(email, cloud_print_xmpp_token,
+                                 kSyncGaiaServiceId);
+    talk_mediator_->Login();
 
-  print_server_watcher_ = print_system_->CreatePrintServerWatcher();
-  print_server_watcher_->StartWatching(this);
+    print_server_watcher_ = print_system_->CreatePrintServerWatcher();
+    print_server_watcher_->StartWatching(this);
 
-  proxy_id_ = proxy_id;
+    proxy_id_ = proxy_id;
 
-  StartRegistration();
+    StartRegistration();
+  } else {
+    // We could not initialize the print system. We need to notify the server.
+    ReportPrintSystemUnavailable(result.message());
+  }
 }
 
 void CloudPrintProxyBackend::Core::StartRegistration() {
   DCHECK(MessageLoop::current() == backend_->core_thread_.message_loop());
   printer_list_.clear();
   print_system_->EnumeratePrinters(&printer_list_);
   // Now we need to ask the server about printers that were registered on the
   // server so that we can trim this list.
   GetRegisteredPrinters();
 }
@@ skipping 74 matching lines @@
   } else {
     EndRegistration();
   }
 }
 
 void CloudPrintProxyBackend::Core::OnReceivePrinterCaps(
     bool succeeded,
     const std::string& printer_name,
     const printing::PrinterCapsAndDefaults& caps_and_defaults) {
   DCHECK(next_upload_index_ < printer_list_.size());
+  std::string mime_boundary;
+  CloudPrintHelpers::CreateMimeBoundaryForUpload(&mime_boundary);
+  std::string post_data;
+  GURL post_url;
   if (succeeded) {
     const printing::PrinterBasicInfo& info =
         printer_list_.at(next_upload_index_);
 
     last_uploaded_printer_name_ = info.printer_name;
     last_uploaded_printer_info_ = caps_and_defaults;
 
-    std::string mime_boundary;
-    CloudPrintHelpers::CreateMimeBoundaryForUpload(&mime_boundary);
-    std::string post_data;
     CloudPrintHelpers::AddMultipartValueForUpload(kProxyIdValue, proxy_id_,
                                                   mime_boundary,
                                                   std::string(), &post_data);
     CloudPrintHelpers::AddMultipartValueForUpload(kPrinterNameValue,
                                                   info.printer_name,
                                                   mime_boundary,
                                                   std::string(), &post_data);
     CloudPrintHelpers::AddMultipartValueForUpload(kPrinterDescValue,
                                                   info.printer_description,
                                                   mime_boundary,
@@ skipping 13 matching lines @@
     CloudPrintHelpers::AddMultipartValueForUpload(
         kPrinterDefaultsValue, last_uploaded_printer_info_.printer_defaults,
         mime_boundary, last_uploaded_printer_info_.defaults_mime_type,
         &post_data);
     // Send a hash of the printer capabilities to the server. We will use this
     // later to check if the capabilities have changed
     CloudPrintHelpers::AddMultipartValueForUpload(
         kPrinterCapsHashValue,
         MD5String(last_uploaded_printer_info_.printer_capabilities),
         mime_boundary, std::string(), &post_data);
-    // Terminate the request body
-    post_data.append("--" + mime_boundary + "--\r\n");
-    std::string mime_type("multipart/form-data; boundary=");
-    mime_type += mime_boundary;
-    GURL register_url = CloudPrintHelpers::GetUrlForPrinterRegistration(
+    post_url = CloudPrintHelpers::GetUrlForPrinterRegistration(
         cloud_print_server_url_);
 
     next_response_handler_ =
         &CloudPrintProxyBackend::Core::HandleRegisterPrinterResponse;
-    request_ = new CloudPrintURLFetcher;
-    request_->StartPostRequest(register_url, this, auth_token_,
-                               kCloudPrintAPIMaxRetryCount, mime_type,
-                               post_data);
   } else {
     LOG(ERROR) << "CP_PROXY: Failed to get printer info for: " <<
         printer_name;
-    next_upload_index_++;
-    MessageLoop::current()->PostTask(FROM_HERE, NewRunnableMethod(this,
-        &CloudPrintProxyBackend::Core::RegisterNextPrinter));
+    // This printer failed to register, notify the server of this failure.
+    post_url = CloudPrintHelpers::GetUrlForUserMessage(
+        cloud_print_server_url_,
+        kGetPrinterCapsFailedMessageId);
+    string16 printer_name_utf16 = UTF8ToUTF16(printer_name);
+    std::string status_message = l10n_util::GetStringFUTF8(
+        IDS_CLOUD_PRINT_REGISTER_PRINTER_FAILED,
+        printer_name_utf16);
+    CloudPrintHelpers::AddMultipartValueForUpload(kMessageTextValue,
+                                                  status_message,
+                                                  mime_boundary,
+                                                  std::string(),
+                                                  &post_data);
+    next_response_handler_ =
+        &CloudPrintProxyBackend::Core::HandleRegisterFailedStatusResponse;
   }
+  // Terminate the request body
+  post_data.append("--" + mime_boundary + "--\r\n");
+  std::string mime_type("multipart/form-data; boundary=");
+  mime_type += mime_boundary;
+  request_ = new CloudPrintURLFetcher;
+  request_->StartPostRequest(post_url, this, auth_token_,
+                             kCloudPrintAPIMaxRetryCount, mime_type,
+                             post_data);
 }
 
 void CloudPrintProxyBackend::Core::HandlePrinterNotification(
     const std::string& printer_id) {
   DCHECK(MessageLoop::current() == backend_->core_thread_.message_loop());
   VLOG(1) << "CP_PROXY: Handle printer notification, id: " << printer_id;
   JobHandlerMap::iterator index = job_handler_map_.find(printer_id);
   if (index != job_handler_map_.end())
     index->second->CheckForJobs(kJobFetchReasonNotified);
 }
@@ skipping 57 matching lines @@
   DCHECK(MessageLoop::current() == backend_->frontend_loop_);
   backend_->frontend_->OnAuthenticated(cloud_print_token,
                                        cloud_print_xmpp_token, email);
 }
 
 void CloudPrintProxyBackend::Core::NotifyAuthenticationFailed() {
   DCHECK(MessageLoop::current() == backend_->frontend_loop_);
   backend_->frontend_->OnAuthenticationFailed();
 }
 
+void CloudPrintProxyBackend::Core::NotifyPrintSystemUnavailable() {
+  DCHECK(MessageLoop::current() == backend_->frontend_loop_);
+  backend_->frontend_->OnPrintSystemUnavailable();
+}
+
 CloudPrintURLFetcher::ResponseAction
 CloudPrintProxyBackend::Core::HandlePrinterListResponse(
     const URLFetcher* source,
     const GURL& url,
     DictionaryValue* json_data,
     bool succeeded) {
   DCHECK(MessageLoop::current() == backend_->core_thread_.message_loop());
   if (!succeeded) {
     NOTREACHED();
     return CloudPrintURLFetcher::RETRY_REQUEST;
@@ skipping 69 matching lines @@
     }
     scoped_refptr<PrinterJobHandler> job_handler;
     job_handler = new PrinterJobHandler(printer_info, printer_info_cloud,
                                         auth_token_, cloud_print_server_url_,
                                         print_system_.get(), this);
     job_handler_map_[printer_info_cloud.printer_id] = job_handler;
     job_handler->Initialize();
   }
 }
 
+void CloudPrintProxyBackend::Core::ReportPrintSystemUnavailable(
+    const std::string& failure_message) {
+  DCHECK(MessageLoop::current() == backend_->core_thread_.message_loop());
+  std::string mime_boundary;
+  CloudPrintHelpers::CreateMimeBoundaryForUpload(&mime_boundary);
+  GURL post_url = CloudPrintHelpers::GetUrlForUserMessage(
+      cloud_print_server_url_,
+      kPrintSystemFailedMessageId);
+  std::string post_data;
+  CloudPrintHelpers::AddMultipartValueForUpload(kMessageTextValue,
+                                                failure_message,
+                                                mime_boundary,
+                                                std::string(),
+                                                &post_data);
+  next_response_handler_ =
+      &CloudPrintProxyBackend::Core::HandlePrintSystemUnavailableResponse;
+// Terminate the request body

[Scott Byer, 2011/01/20 19:09:03]

nit: indentation

+  post_data.append("--" + mime_boundary + "--\r\n");
+  std::string mime_type("multipart/form-data; boundary=");
+  mime_type += mime_boundary;
+  request_ = new CloudPrintURLFetcher;
+  request_->StartPostRequest(post_url, this, auth_token_,
+                             kCloudPrintAPIMaxRetryCount, mime_type,
+                             post_data);
+}
+
 CloudPrintURLFetcher::ResponseAction
 CloudPrintProxyBackend::Core::HandleRegisterPrinterResponse(
     const URLFetcher* source,
     const GURL& url,
     DictionaryValue* json_data,
     bool succeeded) {
   DCHECK(MessageLoop::current() == backend_->core_thread_.message_loop());
   if (succeeded) {
     ListValue* printer_list = NULL;
     json_data->GetList(kPrinterListValue, &printer_list);
     // There should be a "printers" value in the JSON
     DCHECK(printer_list);
     if (printer_list) {
       DictionaryValue* printer_data = NULL;
       if (printer_list->GetDictionary(0, &printer_data))
         InitJobHandlerForPrinter(printer_data);
     }
   }
   next_upload_index_++;
   MessageLoop::current()->PostTask(
       FROM_HERE,
       NewRunnableMethod(this,
                         &CloudPrintProxyBackend::Core::RegisterNextPrinter));
   return CloudPrintURLFetcher::STOP_PROCESSING;
 }
 
+CloudPrintURLFetcher::ResponseAction
+CloudPrintProxyBackend::Core::HandleRegisterFailedStatusResponse(
+    const URLFetcher* source,
+    const GURL& url,
+    DictionaryValue* json_data,
+    bool succeeded) {
+  DCHECK(MessageLoop::current() == backend_->core_thread_.message_loop());
+  next_upload_index_++;
+  MessageLoop::current()->PostTask(
+      FROM_HERE,
+      NewRunnableMethod(this,
+                        &CloudPrintProxyBackend::Core::RegisterNextPrinter));
+  return CloudPrintURLFetcher::STOP_PROCESSING;
+}
+
+CloudPrintURLFetcher::ResponseAction
+CloudPrintProxyBackend::Core::HandlePrintSystemUnavailableResponse(
+    const URLFetcher* source,
+    const GURL& url,
+    DictionaryValue* json_data,
+    bool succeeded) {
+  DCHECK(MessageLoop::current() == backend_->core_thread_.message_loop());
+  // Let the frontend know that we do not have a print system.
+  backend_->frontend_loop_->PostTask(FROM_HERE, NewRunnableMethod(this,

[Scott Byer, 2011/01/20 19:09:03]

nit: indentation clearer in HandleRegisterFailedStatusResponse

+      &Core::NotifyPrintSystemUnavailable));
+  return CloudPrintURLFetcher::STOP_PROCESSING;
+}
+
 bool CloudPrintProxyBackend::Core::RemovePrinterFromList(
     const std::string& printer_name) {
   DCHECK(MessageLoop::current() == backend_->core_thread_.message_loop());
   for (printing::PrinterList::iterator index = printer_list_.begin();
        index != printer_list_.end(); index++) {
     if (0 == base::strcasecmp(index->printer_name.c_str(),
                               printer_name.c_str())) {
       index = printer_list_.erase(index);
       return true;
     }
@@ skipping 56 matching lines @@
   VLOG(1) << "CP_PROXY: Printer job handle shutdown, id " << printer_id;
   job_handler_map_.erase(printer_id);
 }
 
 void CloudPrintProxyBackend::Core::OnAuthError() {
   DCHECK(MessageLoop::current() == backend_->core_thread_.message_loop());
   VLOG(1) << "CP_PROXY: Auth Error";
   backend_->frontend_loop_->PostTask(FROM_HERE, NewRunnableMethod(this,
       &Core::NotifyAuthenticationFailed));
 }