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: "
           << 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;
@@ skipping 185 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));
   }
 }
 
@@ skipping 17 matching lines @@
     bool succeeded) {
   VLOG(1) << "CP_PROXY: 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: "
           << printer_info_cloud_.printer_id;
   bool job_available = false;
   if (succeeded) {
     ListValue* job_list = NULL;
@@ skipping 163 matching lines @@
 void PrinterJobHandler::Shutdown() {
   VLOG(1) << "CP_PROXY: 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: "
           << 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;
@@ skipping 20 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: " <<
         printer_info_.printer_name << ", job id: " << job_details_.job_id_;
     JobFailed(INVALID_JOB_DATA);
   }
 }
 
@@ skipping 26 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));
 }