Redesign cloud printing subsystem layer.

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"
 #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/job_status_updater.h"
 #include "googleurl/src/gurl.h"
 #include "net/http/http_response_headers.h"
 
 PrinterJobHandler::PrinterJobHandler(
     const cloud_print::PrinterBasicInfo& printer_info,
     const std::string& printer_id,
     const std::string& caps_hash,
     const std::string& auth_token,
     const GURL& cloud_print_server_url,
+    cloud_print::PrintSystem* print_system,
     Delegate* delegate)
-    : printer_info_(printer_info),
+    : print_system_(print_system),
+      printer_info_(printer_info),
       printer_id_(printer_id),
       auth_token_(auth_token),
       last_caps_hash_(caps_hash),
       cloud_print_server_url_(cloud_print_server_url),
       delegate_(delegate),
       local_job_id_(-1),
       next_response_handler_(NULL),
       server_error_count_(0),
       print_thread_("Chrome_CloudPrintJobPrintThread"),
       shutting_down_(false),
       server_job_available_(false),
       printer_update_pending_(true),
       printer_delete_pending_(false),
       task_in_progress_(false) {
 }
 
 bool PrinterJobHandler::Initialize() {
-  if (cloud_print::IsValidPrinter(printer_info_.printer_name)) {
-    printer_change_notifier_.StartWatching(printer_info_.printer_name, this);
+  if (print_system_->IsValidPrinter(printer_info_.printer_name)) {
+    printer_watcher_ = print_system_->CreatePrinterWatcher(
+        printer_info_.printer_name);
+    printer_watcher_->StartWatching(this);
     NotifyJobAvailable();
   } else {
     // This printer does not exist any more. Delete it from the server.
     OnPrinterDeleted();
   }
   return true;
 }
 
 PrinterJobHandler::~PrinterJobHandler() {
-  printer_change_notifier_.StopWatching();
+  printer_watcher_->StopWatching();
 }
 
 void PrinterJobHandler::Reset() {
   print_data_url_.clear();
   job_details_.Clear();
   request_.reset();
   print_thread_.Stop();
 }
 
 void PrinterJobHandler::Start() {
@@ skipping 45 matching lines @@
   if (!task_in_progress_) {
     MessageLoop::current()->PostTask(
         FROM_HERE, NewRunnableMethod(this, &PrinterJobHandler::Start));
   }
 }
 
 bool PrinterJobHandler::UpdatePrinterInfo() {
   // 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_change_notifier_.GetCurrentPrinterInfo(&printer_info);
+  printer_watcher_->GetCurrentPrinterInfo(&printer_info);
   cloud_print::PrinterCapsAndDefaults printer_caps;
   std::string post_data;
   std::string mime_boundary;
-  if (cloud_print::GetPrinterCapsAndDefaults(printer_info.printer_name,
-                                             &printer_caps)) {
+  if (print_system_->GetPrinterCapsAndDefaults(printer_info.printer_name,
+                                               &printer_caps)) {
     std::string caps_hash = MD5String(printer_caps.printer_capabilities);
     CloudPrintHelpers::CreateMimeBoundaryForUpload(&mime_boundary);
     if (caps_hash != last_caps_hash_) {
       // Hashes don't match, we need to upload new capabilities (the defaults
       // go for free along with the capabilities)
       last_caps_hash_ = caps_hash;
       CloudPrintHelpers::AddMultipartValueForUpload(
           kPrinterCapsValue, printer_caps.printer_capabilities,
           mime_boundary, printer_caps.caps_mime_type, &post_data);
       CloudPrintHelpers::AddMultipartValueForUpload(
@@ skipping 69 matching lines @@
        index != job_status_updater_list_.end(); index++) {
     if (index->get() == updater) {
       job_status_updater_list_.erase(index);
       ret = true;
       break;
     }
   }
   return ret;
 }
 
-  // cloud_print::PrinterChangeNotifier::Delegate implementation
-void PrinterJobHandler::OnPrinterAdded() {
-  // Should never get this notification for a printer
-  NOTREACHED();
-}
-
 void PrinterJobHandler::OnPrinterDeleted() {
   printer_delete_pending_ = true;
   if (!task_in_progress_) {
     MessageLoop::current()->PostTask(
         FROM_HERE, NewRunnableMethod(this, &PrinterJobHandler::Start));
   }
 }
 
 void PrinterJobHandler::OnPrinterChanged() {
   printer_update_pending_ = true;
@@ skipping 117 matching lines @@
 
 bool PrinterJobHandler::HandlePrintTicketResponse(
     const URLFetcher* source, const GURL& url, const URLRequestStatus& status,
     int response_code, const ResponseCookies& cookies,
     const std::string& data) {
   // 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 (cloud_print::ValidatePrintTicket(printer_info_.printer_name, data)) {
+  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));
   } else {
     // The print ticket was not valid. We are done here.
     MessageLoop::current()->PostTask(
@@ skipping 39 matching lines @@
 void PrinterJobHandler::StartPrinting() {
   // 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, this,
+                                         printer_info_.printer_name,
+                                         print_system_, this,
                                          MessageLoop::current()));
     }
   }
 }
 
 void PrinterJobHandler::JobFailed(PrintJobError error) {
   if (!shutting_down_) {
     UpdateJobStatus(cloud_print::PRINT_JOB_STATUS_ERROR, error);
   }
 }
@@ skipping 57 matching lines @@
   // 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_,
-                           this);
+                           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));
   bool succeeded = false;
   CloudPrintHelpers::ParseResponseJSON(data, &succeeded, NULL);
   if (succeeded) {
     // Since we just printed successfully, we want to look for more jobs.
     server_job_available_ = true;
   }
@@ skipping 28 matching lines @@
   }
 }
 
 bool PrinterJobHandler::HavePendingTasks() {
   return server_job_available_ || printer_update_pending_ ||
          printer_delete_pending_;
 }
 
 
 void PrinterJobHandler::DoPrint(const JobDetails& job_details,
-                                const std::string& printer_name,
-                                PrinterJobHandler* job_handler,
-                                MessageLoop* job_message_loop) {
+                          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);
   cloud_print::PlatformJobId job_id = -1;
-  if (cloud_print::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)) {
+  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));
   }
 }