Chrome proxy refactoring.

chrome/service/cloud_print/printer_job_handler.cc

 // Copyright (c) 2011 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/stringprintf.h"
@@ skipping 33 matching lines @@
       local_job_id_(-1),
       next_json_data_handler_(NULL),
       next_data_handler_(NULL),
       server_error_count_(0),
       print_thread_("Chrome_CloudPrintJobPrintThread"),
       job_handler_message_loop_proxy_(
           base::MessageLoopProxy::current()),
       shutting_down_(false),
       job_check_pending_(false),
       printer_update_pending_(true),
-      printer_delete_pending_(false),
       task_in_progress_(false) {
 }
 
 bool PrinterJobHandler::Initialize() {
-  if (print_system_->IsValidPrinter(
-      printer_info_.printer_name)) {
-    printer_watcher_ = print_system_->CreatePrinterWatcher(
-        printer_info_.printer_name);
-    printer_watcher_->StartWatching(this);
-    CheckForJobs(kJobFetchReasonStartup);
-  } else {
-    // This printer does not exist any more. Check if we should delete it from
-    // the server.
-    bool delete_from_server = false;
-    delegate_->OnPrinterNotFound(printer_info_.printer_name,
-                                 &delete_from_server);
-    if (delete_from_server)
-      OnPrinterDeleted();
-  }
+  if (!print_system_->IsValidPrinter(printer_info_.printer_name))
+    return false;
+
+  printer_watcher_ = print_system_->CreatePrinterWatcher(
+      printer_info_.printer_name);
+  printer_watcher_->StartWatching(this);
+  CheckForJobs(kJobFetchReasonStartup);
   return true;
 }
 
 PrinterJobHandler::~PrinterJobHandler() {
   if (printer_watcher_)
     printer_watcher_->StopWatching();
 }
 
 void PrinterJobHandler::Reset() {
   print_data_url_.clear();
   job_details_.Clear();
   request_ = NULL;
   print_thread_.Stop();
 }
 
+std::string PrinterJobHandler::GetPrinterName() const {
+  return printer_info_.printer_name;
+}
+
 void PrinterJobHandler::Start() {
-  VLOG(1) << "CP_PROXY: Start printer job handler, id: "
+  VLOG(1) << "CP_CONNECTOR: Start printer job handler, id: "
           << printer_info_cloud_.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_) {
-        printer_delete_pending_ = false;
-        task_in_progress_ = true;
-        SetNextJSONHandler(&PrinterJobHandler::HandlePrinterDeleteResponse);
-        request_ = new CloudPrintURLFetcher;
-        request_->StartGetRequest(
-            CloudPrintHelpers::GetUrlForPrinterDelete(
-                cloud_print_server_url_, printer_info_cloud_.printer_id),
-            this,
-            kCloudPrintAPIMaxRetryCount,
-            std::string());
-      }
       if (!task_in_progress_ && printer_update_pending_) {
         printer_update_pending_ = false;
         task_in_progress_ = UpdatePrinterInfo();
       }
       if (!task_in_progress_ && job_check_pending_) {
         task_in_progress_ = true;
         job_check_pending_ = false;
         // We need to fetch any pending jobs for this printer
         SetNextJSONHandler(&PrinterJobHandler::HandleJobMetadataResponse);
         request_ = new CloudPrintURLFetcher;
         request_->StartGetRequest(
             CloudPrintHelpers::GetUrlForJobFetch(
                 cloud_print_server_url_, printer_info_cloud_.printer_id,
                 job_fetch_reason_),
             this,
             kCloudPrintAPIMaxRetryCount,
             std::string());
         last_job_fetch_time_ = base::TimeTicks::Now();
         VLOG(1) << "Last job fetch time for printer "
                 << printer_info_.printer_name.c_str() << " is "
                 << last_job_fetch_time_.ToInternalValue();
         job_fetch_reason_.clear();
       }
     }
   }
 }
 
 void PrinterJobHandler::Stop() {
-  VLOG(1) << "CP_PROXY: Stop printer job handler, id: "
+  VLOG(1) << "CP_CONNECTOR: Stop printer job handler, id: "
           << printer_info_cloud_.printer_id;
   task_in_progress_ = false;
   Reset();
   if (HavePendingTasks()) {
     MessageLoop::current()->PostTask(
         FROM_HERE, NewRunnableMethod(this, &PrinterJobHandler::Start));
   }
 }
 
 void PrinterJobHandler::CheckForJobs(const std::string& reason) {
-  VLOG(1) << "CP_PROXY: CheckForJobs, id: "
+  VLOG(1) << "CP_CONNECTOR: CheckForJobs, id: "
           << printer_info_cloud_.printer_id
           << ", reason: " << reason
           << ", task in progress: " << task_in_progress_;
   job_fetch_reason_ = reason;
   job_check_pending_ = true;
   if (!task_in_progress_) {
     MessageLoop::current()->PostTask(
         FROM_HERE, NewRunnableMethod(this, &PrinterJobHandler::Start));
   }
 }
 
 bool PrinterJobHandler::UpdatePrinterInfo() {
   if (!printer_watcher_) {
-    LOG(ERROR) << "CP_PROXY: Printer watcher is missing."
+    LOG(ERROR) << "CP_CONNECTOR: Printer watcher is missing."
                << "Check printer server url for printer id: "
                << printer_info_cloud_.printer_id;
     return false;
   }
 
-  VLOG(1) << "CP_PROXY: Update printer info, id: "
+  VLOG(1) << "CP_CONNECTOR: 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);
   cloud_print::PrintSystem::PrinterCapsAndDefaultsCallback* callback =
        NewCallback(this,
                    &PrinterJobHandler::OnReceivePrinterCaps);
   // Asnchronously fetch the printer caps and defaults. The story will
@@ skipping 125 matching lines @@
     return CloudPrintURLFetcher::CONTINUE_PROCESSING;
   return (this->*next_data_handler_)(source, url, data);
 }
 
 CloudPrintURLFetcher::ResponseAction PrinterJobHandler::HandleJSONData(
     const content::URLFetcher* source,
     const GURL& url,
     DictionaryValue* json_data,
     bool succeeded) {
   DCHECK(next_json_data_handler_);
-  return (this->*next_json_data_handler_)(source,
-                                          url,
-                                          json_data,
-                                          succeeded);
+  return (this->*next_json_data_handler_)(source, url, json_data, succeeded);
 }
 
 void PrinterJobHandler::OnRequestGiveUp() {
   // The only time we call CloudPrintURLFetcher::StartGetRequest() with a
   // specified number of retries, is when we are trying to fetch print job
   // data. So, this function will be reached only if we failed to get job data.
   // In that case, we should make job as error and should not try it later.
   MessageLoop::current()->PostTask(
       FROM_HERE,
       NewRunnableMethod(this, &PrinterJobHandler::JobFailed,
                         JOB_DOWNLOAD_FAILED));
 }
 
-void PrinterJobHandler::OnRequestAuthError() {
+CloudPrintURLFetcher::ResponseAction PrinterJobHandler::OnRequestAuthError() {
+  // TODO(gene): We might consider stop processing if we get auth error here.
   OnAuthError();
+  // Continue processing as a network error.
+  return CloudPrintURLFetcher::CONTINUE_PROCESSING;
+}
+
+std::string PrinterJobHandler::GetAuthHeader() {
+  return CloudPrintHelpers::GetCloudPrintAuthHeader();
 }
 
 // JobStatusUpdater::Delegate implementation
 bool PrinterJobHandler::OnJobCompleted(JobStatusUpdater* updater) {
   bool ret = false;
   for (JobStatusUpdaterList::iterator index = job_status_updater_list_.begin();
        index != job_status_updater_list_.end(); index++) {
     if (index->get() == updater) {
       job_status_updater_list_.erase(index);
       ret = true;
       break;
     }
   }
   return ret;
 }
 
 void PrinterJobHandler::OnAuthError() {
   if (delegate_)
     delegate_->OnAuthError();
 }
 
 void PrinterJobHandler::OnPrinterDeleted() {
-  printer_delete_pending_ = true;
-  if (!task_in_progress_) {
-    MessageLoop::current()->PostTask(
-        FROM_HERE, NewRunnableMethod(this, &PrinterJobHandler::Start));
-  }
+  if (delegate_)
+    delegate_->OnPrinterDeleted(printer_info_cloud_.printer_id);
 }
 
 void PrinterJobHandler::OnPrinterChanged() {
   printer_update_pending_ = true;
   if (!task_in_progress_) {
     MessageLoop::current()->PostTask(
         FROM_HERE, NewRunnableMethod(this, &PrinterJobHandler::Start));
   }
 }
 
 void PrinterJobHandler::OnJobChanged() {
   // Some job on the printer changed. Loop through all our JobStatusUpdaters
   // and have them check for updates.
   for (JobStatusUpdaterList::iterator index = job_status_updater_list_.begin();
        index != job_status_updater_list_.end(); index++) {
     MessageLoop::current()->PostTask(
         FROM_HERE, NewRunnableMethod(index->get(),
                                      &JobStatusUpdater::UpdateStatus));
   }
 }
 
 // Begin Response handlers
 CloudPrintURLFetcher::ResponseAction
 PrinterJobHandler::HandlePrinterUpdateResponse(
     const content::URLFetcher* source,
     const GURL& url,
     DictionaryValue* json_data,
     bool succeeded) {
-  VLOG(1) << "CP_PROXY: Handle printer update response, id: "
+  VLOG(1) << "CP_CONNECTOR: Handle printer update response, id: "
           << printer_info_cloud_.printer_id;
   // We are done here. Go to the Stop state
   MessageLoop::current()->PostTask(
       FROM_HERE, NewRunnableMethod(this, &PrinterJobHandler::Stop));
   return CloudPrintURLFetcher::STOP_PROCESSING;
 }
 
 CloudPrintURLFetcher::ResponseAction
-PrinterJobHandler::HandlePrinterDeleteResponse(
-    const content::URLFetcher* source,
-    const GURL& url,
-    DictionaryValue* json_data,
-    bool succeeded) {
-  VLOG(1) << "CP_PROXY: Handler printer delete response, id: "
-          << printer_info_cloud_.printer_id;
-  // The printer has been deleted. Shutdown the handler class.
-  MessageLoop::current()->PostTask(
-      FROM_HERE, NewRunnableMethod(this, &PrinterJobHandler::Shutdown));
-  return CloudPrintURLFetcher::STOP_PROCESSING;
-}
-
-CloudPrintURLFetcher::ResponseAction
 PrinterJobHandler::HandleJobMetadataResponse(
     const content::URLFetcher* source,
     const GURL& url,
     DictionaryValue* json_data,
     bool succeeded) {
-  VLOG(1) << "CP_PROXY: Handle job metadata response, id: "
+  VLOG(1) << "CP_CONNECTOR: Handle job metadata response, id: "
           << printer_info_cloud_.printer_id;
   bool job_available = false;
   if (succeeded) {
     ListValue* job_list = NULL;
     if (json_data->GetList(kJobListValue, &job_list) && job_list) {
       // Even though it is a job list, for now we are only interested in the
       // first job
       DictionaryValue* job_data = NULL;
       if (job_list->GetDictionary(0, &job_data)) {
         job_available = true;
@@ skipping 26 matching lines @@
   if (!job_available)
     MessageLoop::current()->PostTask(
         FROM_HERE, NewRunnableMethod(this, &PrinterJobHandler::Stop));
   return CloudPrintURLFetcher::STOP_PROCESSING;
 }
 
 CloudPrintURLFetcher::ResponseAction
 PrinterJobHandler::HandlePrintTicketResponse(const content::URLFetcher* source,
                                              const GURL& url,
                                              const std::string& data) {
-  VLOG(1) << "CP_PROXY: Handle print ticket response, id: "
+  VLOG(1) << "CP_CONNECTOR: Handle print ticket response, id: "
           << printer_info_cloud_.printer_id;
   if (print_system_->ValidatePrintTicket(printer_info_.printer_name, data)) {
     job_details_.print_ticket_ = data;
     SetNextDataHandler(&PrinterJobHandler::HandlePrintDataResponse);
     request_ = new CloudPrintURLFetcher;
     std::string accept_headers = "Accept: ";
     accept_headers += print_system_->GetSupportedMimeTypes();
     request_->StartGetRequest(GURL(print_data_url_.c_str()),
                               this,
                               kJobDataMaxRetryCount,
                               accept_headers);
   } else {
     // The print ticket was not valid. We are done here.
     FailedFetchingJobData();
   }
   return CloudPrintURLFetcher::STOP_PROCESSING;
 }
 
 CloudPrintURLFetcher::ResponseAction
 PrinterJobHandler::HandlePrintDataResponse(const content::URLFetcher* source,
                                            const GURL& url,
                                            const std::string& data) {
-  VLOG(1) << "CP_PROXY: Handle print data response, id: "
+  VLOG(1) << "CP_CONNECTOR: Handle print data response, id: "
           << printer_info_cloud_.printer_id;
   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->GetResponseHeaders()->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 CloudPrintURLFetcher::STOP_PROCESSING;
 }
 
 CloudPrintURLFetcher::ResponseAction
 PrinterJobHandler::HandleSuccessStatusUpdateResponse(
     const content::URLFetcher* source,
     const GURL& url,
     DictionaryValue* json_data,
     bool succeeded) {
-  VLOG(1) << "CP_PROXY: Handle success status update response, id: "
+  VLOG(1) << "CP_CONNECTOR: Handle success status update response, id: "
           << printer_info_cloud_.printer_id;
   // 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_, cloud_print_server_url_,
                            print_system_.get(), this));
   job_status_updater_list_.push_back(job_status_updater);
   MessageLoop::current()->PostTask(
       FROM_HERE, NewRunnableMethod(job_status_updater.get(),
                                    &JobStatusUpdater::UpdateStatus));
   if (succeeded) {
     // Since we just printed successfully, we want to look for more jobs.
     CheckForJobs(kJobFetchReasonQueryMore);
   }
   MessageLoop::current()->PostTask(
       FROM_HERE, NewRunnableMethod(this, &PrinterJobHandler::Stop));
   return CloudPrintURLFetcher::STOP_PROCESSING;
 }
 
 CloudPrintURLFetcher::ResponseAction
 PrinterJobHandler::HandleFailureStatusUpdateResponse(
     const content::URLFetcher* source,
     const GURL& url,
     DictionaryValue* json_data,
     bool succeeded) {
-  VLOG(1) << "CP_PROXY: Handle failure status update response, id: "
+  VLOG(1) << "CP_CONNECTOR: Handle failure status update response, id: "
           << printer_info_cloud_.printer_id;
   MessageLoop::current()->PostTask(
       FROM_HERE, NewRunnableMethod(this, &PrinterJobHandler::Stop));
   return CloudPrintURLFetcher::STOP_PROCESSING;
 }
 // End Response handlers
 
 void PrinterJobHandler::StartPrinting() {
-  VLOG(1) << "CP_PROXY: Start printing, id: " << printer_info_cloud_.printer_id;
+  VLOG(1) << "CP_CONNECTOR: Start printing, id: "
+          << printer_info_cloud_.printer_id;
   // We are done with the request object for now.
   request_ = NULL;
   if (!shutting_down_) {
     if (!print_thread_.Start()) {
       JobFailed(PRINT_FAILED);
     } else {
       print_thread_.message_loop()->PostTask(
           FROM_HERE, NewRunnableMethod(this, &PrinterJobHandler::DoPrint,
                                        job_details_,
                                        printer_info_.printer_name));
     }
   }
 }
 
 void PrinterJobHandler::JobFailed(PrintJobError error) {
-  VLOG(1) << "CP_PROXY: Job failed, id: " << printer_info_cloud_.printer_id;
+  VLOG(1) << "CP_CONNECTOR: Job failed, id: " << printer_info_cloud_.printer_id;
   if (!shutting_down_) {
     UpdateJobStatus(cloud_print::PRINT_JOB_STATUS_ERROR, error);
   }
 }
 
 void PrinterJobHandler::JobSpooled(cloud_print::PlatformJobId local_job_id) {
-  VLOG(1) << "CP_PROXY: Job spooled, printer id: "
+  VLOG(1) << "CP_CONNECTOR: Job spooled, printer id: "
           << printer_info_cloud_.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() {
-  VLOG(1) << "CP_PROXY: Printer job handler shutdown, id: "
+  VLOG(1) << "CP_CONNECTOR: Printer job handler shutdown, id: "
           << printer_info_cloud_.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_info_cloud_.printer_id);
-  }
 }
 
 void PrinterJobHandler::UpdateJobStatus(cloud_print::PrintJobStatus status,
                                         PrintJobError error) {
-  VLOG(1) << "CP_PROXY: Update job status, id: "
+  VLOG(1) << "CP_CONNECTOR: Update job status, id: "
           << printer_info_cloud_.printer_id;
   if (!shutting_down_) {
     if (!job_details_.job_id_.empty()) {
-      VLOG(1) << "CP_PROXY: Updating status, job id: " << job_details_.job_id_
-              << ", status: " << status;
+      VLOG(1) << "CP_CONNECTOR: Updating status, job id: "
+              << job_details_.job_id_ << ", status: " << status;
       if (error == SUCCESS) {
         SetNextJSONHandler(
             &PrinterJobHandler::HandleSuccessStatusUpdateResponse);
       } else {
         SetNextJSONHandler(
             &PrinterJobHandler::HandleFailureStatusUpdateResponse);
       }
       request_ = new CloudPrintURLFetcher;
       request_->StartGetRequest(
           CloudPrintHelpers::GetUrlForJobStatusUpdate(cloud_print_server_url_,
@@ skipping 10 matching lines @@
   next_json_data_handler_ = handler;
   next_data_handler_ = NULL;
 }
 
 void PrinterJobHandler::SetNextDataHandler(DataHandler handler) {
   next_data_handler_ = handler;
   next_json_data_handler_ = NULL;
 }
 
 bool PrinterJobHandler::HavePendingTasks() {
-  return (job_check_pending_ || printer_update_pending_ ||
-          printer_delete_pending_);
+  return (job_check_pending_ || printer_update_pending_);
 }
 
 void PrinterJobHandler::FailedFetchingJobData() {
   if (!shutting_down_) {
-    LOG(ERROR) << "CP_PROXY: Failed fetching job data for printer: " <<
+    LOG(ERROR) << "CP_CONNECTOR: Failed fetching job data for printer: " <<
         printer_info_.printer_name << ", job id: " << job_details_.job_id_;
     JobFailed(INVALID_JOB_DATA);
   }
 }
 
 // The following methods are called on |print_thread_|. It is not safe to
 // access any members other than |job_handler_message_loop_proxy_|,
 // |job_spooler_| and |print_system_|.
 void PrinterJobHandler::DoPrint(const JobDetails& job_details,
                                 const std::string& printer_name) {
@@ skipping 21 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));
 }