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

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 51 matching lines @@
 }
 
 void PrinterJobHandler::Reset() {
   print_data_url_.clear();
   job_details_.Clear();
   request_.reset();
   print_thread_.Stop();
 }
 
 void PrinterJobHandler::Start() {
+  LOG(INFO) << "CP_PROXY: Start printer job handler, id: " << printer_id_ <<
+    ", task in progress: " << task_in_progress_;
   if (task_in_progress_) {
     // Multiple Starts can get posted because of multiple notifications
     // We want to ignore the other ones that happen when a task is in progress.
     return;
   }
   Reset();
   if (!shutting_down_) {
     // Check if we have work to do.
     if (HavePendingTasks()) {
       if (printer_delete_pending_) {
@@ skipping 17 matching lines @@
             CloudPrintHelpers::GetUrlForJobFetch(
                 cloud_print_server_url_, printer_id_),
             &PrinterJobHandler::HandleJobMetadataResponse,
             &PrinterJobHandler::Stop);
       }
     }
   }
 }
 
 void PrinterJobHandler::Stop() {
+  LOG(INFO) << "CP_PROXY: Stop printer job handler, id: " << printer_id_;
   task_in_progress_ = false;
   Reset();
   if (HavePendingTasks()) {
     MessageLoop::current()->PostTask(
         FROM_HERE, NewRunnableMethod(this, &PrinterJobHandler::Start));
   }
 }
 
 void PrinterJobHandler::NotifyJobAvailable() {
+  LOG(INFO) << "CP_PROXY: Notify job available, id: " << printer_id_ <<
+    ", task in progress: " << task_in_progress_;
   server_job_available_ = true;
   if (!task_in_progress_) {
     MessageLoop::current()->PostTask(
         FROM_HERE, NewRunnableMethod(this, &PrinterJobHandler::Start));
   }
 }
 
 bool PrinterJobHandler::UpdatePrinterInfo() {
+  LOG(INFO) << "CP_PROXY: Update printer info, id: " << printer_id_;
   // We need to update the parts of the printer info that have changed
   // (could be printer name, description, status or capabilities).
   cloud_print::PrinterBasicInfo printer_info;
   printer_watcher_->GetCurrentPrinterInfo(&printer_info);
   cloud_print::PrinterCapsAndDefaults printer_caps;
   std::string post_data;
   std::string mime_boundary;
   if (print_system_->GetPrinterCapsAndDefaults(printer_info.printer_name,
                                                &printer_caps)) {
     std::string caps_hash = MD5String(printer_caps.printer_capabilities);
@@ skipping 49 matching lines @@
     ret = true;
   }
   return ret;
 }
 
 // URLFetcher::Delegate implementation.
 void PrinterJobHandler::OnURLFetchComplete(
     const URLFetcher* source, const GURL& url, const URLRequestStatus& status,
     int response_code, const ResponseCookies& cookies,
     const std::string& data) {
+  LOG(INFO) << "CP_PROXY: Printer job handler, OnURLFetchComplete, url: " <<
+      url << ", response code: " << response_code;
   if (!shutting_down_) {
     DCHECK(source == request_.get());
     // We need a next response handler because we are strictly a sequential
     // state machine. We need each response handler to tell us which state to
     //  advance to next.
     DCHECK(next_response_handler_);
     if (!(this->*next_response_handler_)(source, url, status,
                                          response_code, cookies, data)) {
       // By contract, if the response handler returns false, it wants us to
       // retry the request (upto the usual limit after which we give up and
@@ skipping 42 matching lines @@
         FROM_HERE, NewRunnableMethod(index->get(),
                                      &JobStatusUpdater::UpdateStatus));
   }
 }
 
 bool PrinterJobHandler::HandlePrinterUpdateResponse(
     const URLFetcher* source, const GURL& url, const URLRequestStatus& status,
     int response_code, const ResponseCookies& cookies,
     const std::string& data) {
   bool ret = false;
+  LOG(INFO) << "CP_PROXY: Handle printer update response, id: " << printer_id_;
   // If there was a network error or a non-200 response (which, for our purposes
   // is the same as a network error), we want to retry.
   if (status.is_success() && (response_code == 200)) {
     bool succeeded = false;
     DictionaryValue* response_dict = NULL;
     CloudPrintHelpers::ParseResponseJSON(data, &succeeded, &response_dict);
     // If we get valid JSON back, we are done.
     if (NULL != response_dict) {
       ret = true;
     }
   }
   if (ret) {
     // We are done here. Go to the Stop state
     MessageLoop::current()->PostTask(
         FROM_HERE, NewRunnableMethod(this, &PrinterJobHandler::Stop));
   } else {
     // Since we failed to update the server, set the flag again.
     printer_update_pending_ = true;
   }
   return ret;
 }
 
 bool PrinterJobHandler::HandlePrinterDeleteResponse(
     const URLFetcher* source, const GURL& url, const URLRequestStatus& status,
     int response_code, const ResponseCookies& cookies,
     const std::string& data) {
   bool ret = false;
+  LOG(INFO) << "CP_PROXY: Handler printer delete response, id: " << printer_id_;
   // If there was a network error or a non-200 response (which, for our purposes
   // is the same as a network error), we want to retry.
   if (status.is_success() && (response_code == 200)) {
     bool succeeded = false;
     DictionaryValue* response_dict = NULL;
     CloudPrintHelpers::ParseResponseJSON(data, &succeeded, &response_dict);
     // If we get valid JSON back, we are done.
     if (NULL != response_dict) {
       ret = true;
     }
   }
   if (ret) {
     // The printer has been deleted. Shutdown the handler class.
     MessageLoop::current()->PostTask(
         FROM_HERE, NewRunnableMethod(this, &PrinterJobHandler::Shutdown));
   } else {
     // Since we failed to update the server, set the flag again.
     printer_delete_pending_ = true;
   }
   return ret;
 }
 
 bool PrinterJobHandler::HandleJobMetadataResponse(
     const URLFetcher* source, const GURL& url, const URLRequestStatus& status,
     int response_code, const ResponseCookies& cookies,
     const std::string& data) {
+  LOG(INFO) << "CP_PROXY: Handle job metadata response, id: " << printer_id_;
   // If there was a network error or a non-200 response (which, for our purposes
   // is the same as a network error), we want to retry.
   if (!status.is_success() || (response_code != 200)) {
     return false;
   }
   bool succeeded = false;
   DictionaryValue* response_dict = NULL;
   CloudPrintHelpers::ParseResponseJSON(data, &succeeded, &response_dict);
   if (NULL == response_dict) {
     // If we did not get a valid JSON response, we need to retry.
@@ skipping 28 matching lines @@
   delete response_dict;
   DCHECK(next_task);
   MessageLoop::current()->PostTask(FROM_HERE, next_task);
   return true;
 }
 
 bool PrinterJobHandler::HandlePrintTicketResponse(
     const URLFetcher* source, const GURL& url, const URLRequestStatus& status,
     int response_code, const ResponseCookies& cookies,
     const std::string& data) {
+  LOG(INFO) << "CP_PROXY: Handle print ticket response, id: " << printer_id_;
   // If there was a network error or a non-200 response (which, for our purposes
   // is the same as a network error), we want to retry.
   if (!status.is_success() || (response_code != 200)) {
     return false;
   }
   if (print_system_->ValidatePrintTicket(printer_info_.printer_name, data)) {
     job_details_.print_ticket_ = data;
     MessageLoop::current()->PostTask(
         FROM_HERE,
         NewRunnableMethod(this,
                           &PrinterJobHandler::MakeServerRequest,
                           GURL(print_data_url_.c_str()),
                           &PrinterJobHandler::HandlePrintDataResponse,
                           &PrinterJobHandler::FailedFetchingJobData));
   } else {
     // The print ticket was not valid. We are done here.
     FailedFetchingJobData();
   }
   return true;
 }
 
 bool PrinterJobHandler::HandlePrintDataResponse(const URLFetcher* source,
                                                 const GURL& url,
                                                 const URLRequestStatus& status,
                                                 int response_code,
                                                 const ResponseCookies& cookies,
                                                 const std::string& data) {
+  LOG(INFO) << "CP_PROXY: Handle print data response, id: " << printer_id_;
   // If there was a network error or a non-200 response (which, for our purposes
   // is the same as a network error), we want to retry.
   if (!status.is_success() || (response_code != 200)) {
     return false;
   }
   Task* next_task = NULL;
   if (file_util::CreateTemporaryFile(&job_details_.print_data_file_path_)) {
     int ret = file_util::WriteFile(job_details_.print_data_file_path_,
                                    data.c_str(),
                                    data.length());
     source->response_headers()->GetMimeType(
         &job_details_.print_data_mime_type_);
     DCHECK(ret == static_cast<int>(data.length()));
     if (ret == static_cast<int>(data.length())) {
       next_task = NewRunnableMethod(this, &PrinterJobHandler::StartPrinting);
     }
   }
   // If there was no task allocated above, then there was an error in
   // saving the print data, bail out here.
   if (!next_task) {
     next_task = NewRunnableMethod(this, &PrinterJobHandler::JobFailed,
                                   JOB_DOWNLOAD_FAILED);
   }
   MessageLoop::current()->PostTask(FROM_HERE, next_task);
   return true;
 }
 
 void PrinterJobHandler::StartPrinting() {
+  LOG(INFO) << "CP_PROXY: Start printing, id: " << printer_id_;
   // We are done with the request object for now.
   request_.reset();
   if (!shutting_down_) {
     if (!print_thread_.Start()) {
       JobFailed(PRINT_FAILED);
     } else {
       print_thread_.message_loop()->PostTask(
           FROM_HERE, NewRunnableFunction(&PrinterJobHandler::DoPrint,
                                          job_details_,
                                          printer_info_.printer_name,
                                          print_system_, this,
                                          MessageLoop::current()));
     }
   }
 }
 
 void PrinterJobHandler::JobFailed(PrintJobError error) {
+  LOG(INFO) << "CP_PROXY: Job failed, id: " << printer_id_;
   if (!shutting_down_) {
     UpdateJobStatus(cloud_print::PRINT_JOB_STATUS_ERROR, error);
   }
 }
 
 void PrinterJobHandler::JobSpooled(cloud_print::PlatformJobId local_job_id) {
+  LOG(INFO) << "CP_PROXY: Job spooled, printer id: " << printer_id_ <<
+      ", job id: " << local_job_id;
   if (!shutting_down_) {
     local_job_id_ = local_job_id;
     UpdateJobStatus(cloud_print::PRINT_JOB_STATUS_IN_PROGRESS, SUCCESS);
     print_thread_.Stop();
   }
 }
 
 void PrinterJobHandler::Shutdown() {
+  LOG(INFO) << "CP_PROXY: Printer job handler shutdown, id: " << printer_id_;
   Reset();
   shutting_down_ = true;
   while (!job_status_updater_list_.empty()) {
     // Calling Stop() will cause the OnJobCompleted to be called which will
     // remove the updater object from the list.
     job_status_updater_list_.front()->Stop();
   }
   if (delegate_) {
     delegate_->OnPrinterJobHandlerShutdown(this, printer_id_);
   }
 }
 
 void PrinterJobHandler::HandleServerError(const GURL& url) {
+  LOG(INFO) << "CP_PROXY: Handle server error, printer id: " << printer_id_ <<
+      ", url: " << url;
   Task* task_to_retry = NewRunnableMethod(this,
                                           &PrinterJobHandler::FetchURL, url);
   Task* task_on_give_up = NewRunnableMethod(this, next_failure_handler_);
   CloudPrintHelpers::HandleServerError(&server_error_count_, kMaxRetryCount,
                                        -1, kBaseRetryInterval, task_to_retry,
                                        task_on_give_up);
 }
 
 void PrinterJobHandler::UpdateJobStatus(cloud_print::PrintJobStatus status,
                                         PrintJobError error) {
+  LOG(INFO) << "CP_PROXY: Update job status, id: " << printer_id_;
   if (!shutting_down_) {
     if (!job_details_.job_id_.empty()) {
-      LOG(INFO) << "CP: Updating status, jod id: " << job_details_.job_id_ <<
-          ", status: " << status;
+      LOG(INFO) << "CP_PROXY: Updating status, jod id: " <<
+          job_details_.job_id_ << ", status: " << status;
 
       ResponseHandler response_handler = NULL;
       if (error == SUCCESS) {
         response_handler =
             &PrinterJobHandler::HandleSuccessStatusUpdateResponse;
       } else {
         response_handler =
             &PrinterJobHandler::HandleFailureStatusUpdateResponse;
       }
       MakeServerRequest(
           CloudPrintHelpers::GetUrlForJobStatusUpdate(cloud_print_server_url_,
                                                       job_details_.job_id_,
                                                       status),
           response_handler,
           &PrinterJobHandler::Stop);
     }
   }
 }
 
 bool PrinterJobHandler::HandleSuccessStatusUpdateResponse(
     const URLFetcher* source, const GURL& url, const URLRequestStatus& status,
     int response_code, const ResponseCookies& cookies,
     const std::string& data) {
+  LOG(INFO) << "CP_PROXY: Handle success status update response, id: " <<
+      printer_id_;
   // If there was a network error or a non-200 response (which, for our purposes
   // is the same as a network error), we want to retry.
   if (!status.is_success() || (response_code != 200)) {
     return false;
   }
   // The print job has been spooled locally. We now need to create an object
   // that monitors the status of the job and updates the server.
   scoped_refptr<JobStatusUpdater> job_status_updater =
       new JobStatusUpdater(printer_info_.printer_name, job_details_.job_id_,
                            local_job_id_, auth_token_, cloud_print_server_url_,
@@ skipping 10 matching lines @@
   }
   MessageLoop::current()->PostTask(
       FROM_HERE, NewRunnableMethod(this, &PrinterJobHandler::Stop));
   return true;
 }
 
 bool PrinterJobHandler::HandleFailureStatusUpdateResponse(
     const URLFetcher* source, const GURL& url, const URLRequestStatus& status,
     int response_code, const ResponseCookies& cookies,
     const std::string& data) {
+  LOG(INFO) << "CP_PROXY: Handle failure status update response, id: " <<
+      printer_id_;
   // If there was a network error or a non-200 response (which, for our purposes
   // is the same as a network error), we want to retry.
   if (!status.is_success() || (response_code != 200)) {
     return false;
   }
   MessageLoop::current()->PostTask(
       FROM_HERE, NewRunnableMethod(this, &PrinterJobHandler::Stop));
   return true;
 }
 
 void PrinterJobHandler::MakeServerRequest(const GURL& url,
                                           ResponseHandler response_handler,
                                           FailureHandler failure_handler) {
+  LOG(INFO) << "CP_PROXY: Printer job handle, make server request, id: " <<
+    printer_id_ << ", url: " << url;
   if (!shutting_down_) {
     server_error_count_ = 0;
     // Set up the next response handler
     next_response_handler_ = response_handler;
     next_failure_handler_ = failure_handler;
     FetchURL(url);
   }
 }
 
 void PrinterJobHandler::FetchURL(const GURL& url) {
+  LOG(INFO) << "CP_PROXY: PrinterJobHandler::FetchURL, url: " << url;
   request_.reset(new URLFetcher(url, URLFetcher::GET, this));
   CloudPrintHelpers::PrepCloudPrintRequest(request_.get(), auth_token_);
   request_->Start();
 }
 
 bool PrinterJobHandler::HavePendingTasks() {
   return server_job_available_ || printer_update_pending_ ||
          printer_delete_pending_;
 }
 
 void PrinterJobHandler::FailedFetchingJobData() {
   if (!shutting_down_) {
-    LOG(ERROR) << "CP: Failed fetching job data for printer: " <<
+    LOG(ERROR) << "CP_PROXY: Failed fetching job data for printer: " <<
         printer_info_.printer_name << ", job id: " << job_details_.job_id_;
     JobFailed(INVALID_JOB_DATA);
   }
 }
 
 void PrinterJobHandler::DoPrint(const JobDetails& job_details,
                           const std::string& printer_name,
                           scoped_refptr<cloud_print::PrintSystem> print_system,
                           PrinterJobHandler* job_handler,
                           MessageLoop* job_message_loop) {
   DCHECK(job_handler);
   DCHECK(job_message_loop);
+  LOG(INFO) << "CP_PROXY: Printing: " << printer_name;
   cloud_print::PlatformJobId job_id = -1;
   if (print_system->SpoolPrintJob(job_details.print_ticket_,
                                   job_details.print_data_file_path_,
                                   job_details.print_data_mime_type_,
                                   printer_name,
                                   job_details.job_title_, &job_id)) {
     job_message_loop->PostTask(FROM_HERE,
                                NewRunnableMethod(job_handler,
                                                  &PrinterJobHandler::JobSpooled,
                                                  job_id));
   } else {
     job_message_loop->PostTask(FROM_HERE,
                                NewRunnableMethod(job_handler,
                                                  &PrinterJobHandler::JobFailed,
                                                  PRINT_FAILED));
   }
 }