No actual code change. Just added more logging information to help...

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 "base/file_util.h"
 #include "base/md5.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
@@ skipping 272 matching lines @@
                             proxy_id);
     }
   }
 }
 
 void CloudPrintProxyBackend::Core::DoInitializeWithToken(
     const std::string cloud_print_token,
     const std::string cloud_print_xmpp_token,
     const std::string email, const std::string& proxy_id) {
   DCHECK(MessageLoop::current() == backend_->core_thread_.message_loop());
+  LOG(INFO) << "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.
   }
 
   // TODO(sanjeevr): Validate the tokens.
   auth_token_ = cloud_print_token;
@@ skipping 29 matching lines @@
 
 void CloudPrintProxyBackend::Core::EndRegistration() {
   request_.reset();
   if (new_printers_available_) {
     new_printers_available_ = false;
     StartRegistration();
   }
 }
 
 void CloudPrintProxyBackend::Core::DoShutdown() {
+  LOG(INFO) << "CP_PROXY: Shutdown proxy.";

[sanjeevr, 2010/06/25 20:39:42]

Trace proxy id here as well

   if (print_server_watcher_ != NULL)
     print_server_watcher_->StopWatching();
 
   // Need to kill all running jobs.
   while (!job_handler_map_.empty()) {
     JobHandlerMap::iterator index = job_handler_map_.begin();
     // Shutdown will call our OnPrinterJobHandlerShutdown method which will
     // remove this from the map.
     index->second->Shutdown();
   }
 }
 
 void CloudPrintProxyBackend::Core::DoRegisterSelectedPrinters(
     const cloud_print::PrinterList& printer_list) {
   if (!print_system_.get())
     return;  // No print system available.
   server_error_count_ = 0;
   printer_list_.assign(printer_list.begin(), printer_list.end());
   DCHECK(MessageLoop::current() == backend_->core_thread_.message_loop());
   next_upload_index_ = 0;
   RegisterNextPrinter();
 }
 
 void CloudPrintProxyBackend::Core::DoHandlePrinterNotification(
     const std::string& printer_id) {
+  LOG(INFO) << "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->NotifyJobAvailable();
 }
 
 void CloudPrintProxyBackend::Core::GetRegisteredPrinters() {
   request_.reset(
       new URLFetcher(
           CloudPrintHelpers::GetUrlForPrinterList(cloud_print_server_url_,
                                                   proxy_id_),
@@ skipping 34 matching lines @@
                                                     mime_boundary,
                                                     std::string() , &post_data);
       CloudPrintHelpers::AddMultipartValueForUpload(
           kPrinterStatusValue, StringPrintf("%d", info.printer_status),
           mime_boundary, std::string(), &post_data);
       // Add printer options as tags.
       std::map<std::string, std::string>::const_iterator it;
       for (it = info.options.begin(); it != info.options.end(); ++it) {
         // TODO(gene) Escape '=' char from name. Warning for now.
         if (it->first.find('=') != std::string::npos) {
-          LOG(WARNING) << "CUPS option name contains '=' character";
+          LOG(WARNING) << "CP_PROXY: CUPS option name contains '=' character";
           NOTREACHED();
         }
         std::string msg(it->first);
         msg += "=";
         msg += it->second;
         CloudPrintHelpers::AddMultipartValueForUpload(
             kPrinterTagValue, msg, mime_boundary, std::string(), &post_data);
       }
       CloudPrintHelpers::AddMultipartValueForUpload(
           kPrinterCapsValue, last_uploaded_printer_info_.printer_capabilities,
@@ skipping 17 matching lines @@
           new URLFetcher(
               CloudPrintHelpers::GetUrlForPrinterRegistration(
                   cloud_print_server_url_),
               URLFetcher::POST, this));
       CloudPrintHelpers::PrepCloudPrintRequest(request_.get(), auth_token_);
       request_->set_upload_data(mime_type, post_data);
       next_response_handler_ =
           &CloudPrintProxyBackend::Core::HandleRegisterPrinterResponse;
       request_->Start();
     } else {
-      LOG(ERROR) << "CP: Failed to get printer info for: " << info.printer_name;
+      LOG(ERROR) << "CP_PROXY: Failed to get printer info for: " <<
+          info.printer_name;
       next_upload_index_++;
       MessageLoop::current()->PostTask(FROM_HERE, NewRunnableMethod(this,
           &CloudPrintProxyBackend::Core::RegisterNextPrinter));
     }
   } else {
     EndRegistration();
   }
 }
 
 // URLFetcher::Delegate implementation.
@@ skipping 69 matching lines @@
     HandleServerError(NewRunnableMethod(this, &Core::GetRegisteredPrinters));
   }
 }
 
 void CloudPrintProxyBackend::Core::InitJobHandlerForPrinter(
     DictionaryValue* printer_data) {
   DCHECK(printer_data);
   std::string printer_id;
   printer_data->GetString(kIdValue, &printer_id);
   DCHECK(!printer_id.empty());
+  LOG(INFO) << "CP_PROXY: Init job handler for printer id: " << printer_id;
   JobHandlerMap::iterator index = job_handler_map_.find(printer_id);
   // We might already have a job handler for this printer
   if (index == job_handler_map_.end()) {
     cloud_print::PrinterBasicInfo printer_info;
     printer_data->GetString(kNameValue, &printer_info.printer_name);
     DCHECK(!printer_info.printer_name.empty());
     printer_data->GetString(UTF8ToWide(kPrinterDescValue),
                             &printer_info.printer_description);
     printer_data->GetInteger(UTF8ToWide(kPrinterStatusValue),
                              &printer_info.printer_status);
     std::string caps_hash;
     printer_data->GetString(kPrinterCapsHashValue, &caps_hash);
     scoped_refptr<PrinterJobHandler> job_handler;
     job_handler = new PrinterJobHandler(printer_info, printer_id, caps_hash,
                                         auth_token_, cloud_print_server_url_,
                                         print_system_.get(), this);
     job_handler_map_[printer_id] = job_handler;
     job_handler->Initialize();
   }
 }
 
 void CloudPrintProxyBackend::Core::HandleRegisterPrinterResponse(
     const URLFetcher* source, const GURL& url, const URLRequestStatus& status,
     int response_code, const ResponseCookies& cookies,
     const std::string& data) {
+  LOG(INFO) << "CP_PROXY: Handle register printer response, code: " <<
+      response_code;
   Task* next_task =
       NewRunnableMethod(this,
                         &CloudPrintProxyBackend::Core::RegisterNextPrinter);
   if (status.is_success() && (response_code == 200)) {
     bool succeeded = false;
     DictionaryValue* response_dict = NULL;
     CloudPrintHelpers::ParseResponseJSON(data, &succeeded, &response_dict);
     if (succeeded) {
       DCHECK(response_dict);
       ListValue* printer_list = NULL;
       response_dict->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);
         }
       }
     }
     server_error_count_ = 0;
     next_upload_index_++;
     MessageLoop::current()->PostTask(FROM_HERE, next_task);
   } else {
     HandleServerError(next_task);
   }
 }
 
 void CloudPrintProxyBackend::Core::HandleServerError(Task* task_to_retry) {
+  LOG(INFO) << "CP_PROXY: Server error.";
   CloudPrintHelpers::HandleServerError(
       &server_error_count_, -1, kMaxRetryInterval, kBaseRetryInterval,
       task_to_retry, NULL);
 }
 
 bool CloudPrintProxyBackend::Core::RemovePrinterFromList(
     const std::string& printer_name) {
   bool ret = false;
   for (cloud_print::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);
       ret = true;
       break;
     }
   }
   return ret;
 }
 
 void CloudPrintProxyBackend::Core::OnNotificationStateChange(
     bool notification_enabled) {}
 
 void CloudPrintProxyBackend::Core::OnIncomingNotification(
     const IncomingNotificationData& notification_data) {
+  LOG(INFO) << "CP_PROXY: Incoming notification.";
   if (0 == base::strcasecmp(kCloudPrintTalkServiceUrl,
                              notification_data.service_url.c_str())) {
     backend_->core_thread_.message_loop()->PostTask(
         FROM_HERE,
         NewRunnableMethod(
             this, &CloudPrintProxyBackend::Core::DoHandlePrinterNotification,
             notification_data.service_specific_data));
   }
 }
 
 void CloudPrintProxyBackend::Core::OnOutgoingNotification() {}
 
 // cloud_print::PrinterChangeNotifier::Delegate implementation
 void CloudPrintProxyBackend::Core::OnPrinterAdded() {
   if (request_.get()) {
     new_printers_available_ = true;
   } else {
     StartRegistration();
   }
 }
 
 // PrinterJobHandler::Delegate implementation
 void CloudPrintProxyBackend::Core::OnPrinterJobHandlerShutdown(
     PrinterJobHandler* job_handler, const std::string& printer_id) {
+  LOG(INFO) << "CP_PROXY: Printer job handle shutdown, id " << printer_id;
   job_handler_map_.erase(printer_id);
 }