Redesign cloud printing subsystem layer.

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"
 #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/printer_job_handler.h"
 #include "chrome/common/net/notifier/listener/talk_mediator_impl.h"
 #include "chrome/service/gaia/service_gaia_authenticator.h"
 #include "chrome/service/net/service_network_change_notifier_thread.h"
 #include "chrome/service/service_process.h"
 
 #include "googleurl/src/gurl.h"
 #include "net/url_request/url_request_status.h"
 
 // The real guts of SyncBackendHost, to keep the public client API clean.
 class CloudPrintProxyBackend::Core
     : public base::RefCountedThreadSafe<CloudPrintProxyBackend::Core>,
       public URLFetcherDelegate,
-      public cloud_print::PrinterChangeNotifierDelegate,
+      public cloud_print::PrintServerWatcherDelegate,
       public PrinterJobHandlerDelegate,
       public notifier::TalkMediator::Delegate {
  public:
   explicit Core(CloudPrintProxyBackend* backend,
                 const GURL& cloud_print_server_url);
+
   // Note:
   //
   // The Do* methods are the various entry points from CloudPrintProxyBackend
   // It calls us on a dedicated thread to actually perform synchronous
   // (and potentially blocking) syncapi operations.
   //
   // Called on the CloudPrintProxyBackend core_thread_ to perform
   // initialization. When we are passed in an LSID we authenticate using that
   // and retrieve new auth tokens.
   void DoInitializeWithLsid(const std::string& lsid,
                             const std::string& proxy_id);
   void DoInitializeWithToken(const std::string cloud_print_token,
                              const std::string cloud_print_xmpp_token,
                              const std::string email,
                              const std::string& proxy_id);
 
   // Called on the CloudPrintProxyBackend core_thread_ to perform
   // shutdown.
   void DoShutdown();
   void DoRegisterSelectedPrinters(
       const cloud_print::PrinterList& printer_list);
   void DoHandlePrinterNotification(const std::string& printer_id);
 
   // URLFetcher::Delegate implementation.
   virtual void OnURLFetchComplete(const URLFetcher* source, const GURL& url,
                                   const URLRequestStatus& status,
                                   int response_code,
                                   const ResponseCookies& cookies,
                                   const std::string& data);
-// cloud_print::PrinterChangeNotifier::Delegate implementation
+  // cloud_print::PrintServerWatcherDelegate implementation
   virtual void OnPrinterAdded();
-  virtual void OnPrinterDeleted() {
-  }
-  virtual void OnPrinterChanged() {
-  }
-  virtual void OnJobChanged() {
-  }
   // PrinterJobHandler::Delegate implementation
   void OnPrinterJobHandlerShutdown(PrinterJobHandler* job_handler,
                                    const std::string& printer_id);
 
   // notifier::TalkMediator::Delegate implementation.
   virtual void OnNotificationStateChange(
       bool notifications_enabled);
 
   virtual void OnIncomingNotification(
       const IncomingNotificationData& notification_data);
@@ skipping 44 matching lines @@
   bool RemovePrinterFromList(const std::string& printer_name);
   // Initializes a job handler object for the specified printer. The job
   // handler is responsible for checking for pending print jobs for this
   // printer and print them.
   void InitJobHandlerForPrinter(DictionaryValue* printer_data);
 
   // Our parent CloudPrintProxyBackend
   CloudPrintProxyBackend* backend_;
 
   GURL cloud_print_server_url_;
+  // Pointer to current print system.
+  scoped_refptr<cloud_print::PrintSystem> print_system_;
   // The list of printers to be registered with the cloud print server.
   // To begin with,this list is initialized with the list of local and network
   // printers available. Then we query the server for the list of printers
   // already registered. We trim this list to remove the printers already
   // registered. We then pass a copy of this list to the frontend to give the
   // user a chance to further trim the list. When the frontend gives us the
   // final list we make a copy into this so that we can start registering.
   cloud_print::PrinterList printer_list_;
   // The URLFetcher instance for the current request
   scoped_ptr<URLFetcher> request_;
   // The index of the nex printer to be uploaded.
   size_t next_upload_index_;
   // The unique id for this proxy
   std::string proxy_id_;
   // The GAIA auth token
   std::string auth_token_;
   // The number of consecutive times that connecting to the server failed.
   int server_error_count_;
   // Cached info about the last printer that we tried to upload. We cache this
   // so we won't have to requery the printer if the upload fails and we need
   // to retry.
   std::string last_uploaded_printer_name_;
   cloud_print::PrinterCapsAndDefaults last_uploaded_printer_info_;
   // A map of printer id to job handler.
   typedef std::map<std::string, scoped_refptr<PrinterJobHandler> >
       JobHandlerMap;
   JobHandlerMap job_handler_map_;
   ResponseHandler next_response_handler_;
-  cloud_print::PrinterChangeNotifier printer_change_notifier_;
+  scoped_refptr<cloud_print::PrintSystem::PrintServerWatcher>
+      print_server_watcher_;
   bool new_printers_available_;
   // Notification (xmpp) handler.
   scoped_ptr<notifier::TalkMediator> talk_mediator_;
 
   DISALLOW_COPY_AND_ASSIGN(Core);
 };
 
 CloudPrintProxyBackend::CloudPrintProxyBackend(
     CloudPrintProxyFrontend* frontend, const GURL& cloud_print_server_url)
       : core_thread_("Chrome_CloudPrintProxyCoreThread"),
@@ skipping 55 matching lines @@
       NewRunnableMethod(
           core_.get(),
           &CloudPrintProxyBackend::Core::DoHandlePrinterNotification,
           printer_id));
 }
 
 CloudPrintProxyBackend::Core::Core(CloudPrintProxyBackend* backend,
                                    const GURL& cloud_print_server_url)
     : backend_(backend), cloud_print_server_url_(cloud_print_server_url),
       next_upload_index_(0), server_error_count_(0),
-     next_response_handler_(NULL), new_printers_available_(false) {
+      next_response_handler_(NULL), new_printers_available_(false) {
 }
 
 void CloudPrintProxyBackend::Core::DoInitializeWithLsid(
     const std::string& lsid, const std::string& proxy_id) {
   DCHECK(MessageLoop::current() == backend_->core_thread_.message_loop());
   // Since Talk does not accept a Cloud Print token, for now, we make 2 auth
   // requests, one for the chromiumsync service and another for print. This is
   // temporary and should be removed once Talk supports our token.
   // Note: The GAIA login is synchronous but that should be OK because we are in
   // the CloudPrintProxyCoreThread and we cannot really do anything else until
@@ skipping 23 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());
+
+  print_system_ = cloud_print::PrintSystem::CreateInstance();
+  if (!print_system_.get()) {
+    NOTREACHED();
+    return;  // No print system available, fail initalization.
+  }
+
   // TODO(sanjeevr): Validate the tokens.
   auth_token_ = cloud_print_token;
   talk_mediator_.reset(new notifier::TalkMediatorImpl(
       g_service_process->network_change_notifier_thread(), false));
   talk_mediator_->AddSubscribedServiceUrl(kCloudPrintTalkServiceUrl);
   talk_mediator_->SetDelegate(this);
   talk_mediator_->SetAuthToken(email, cloud_print_xmpp_token,
                                kSyncGaiaServiceId);
   talk_mediator_->Login();
-  printer_change_notifier_.StartWatching(std::string(), this);
+
+  print_server_watcher_ = print_system_->CreatePrintServerWatcher();
+  print_server_watcher_->StartWatching(this);
+
   proxy_id_ = proxy_id;
   StartRegistration();
 }
 
 void CloudPrintProxyBackend::Core::StartRegistration() {
   printer_list_.clear();
-  cloud_print::EnumeratePrinters(&printer_list_);
+  print_system_->EnumeratePrinters(&printer_list_);
   server_error_count_ = 0;
   // Now we need to ask the server about printers that were registered on the
   // server so that we can trim this list.
   GetRegisteredPrinters();
 }
 
 void CloudPrintProxyBackend::Core::EndRegistration() {
   request_.reset();
   if (new_printers_available_) {
     new_printers_available_ = false;
     StartRegistration();
   }
 }
 
 void CloudPrintProxyBackend::Core::DoShutdown() {
+  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) {
   JobHandlerMap::iterator index = job_handler_map_.find(printer_id);
@@ skipping 16 matching lines @@
 void CloudPrintProxyBackend::Core::RegisterNextPrinter() {
   // For the next printer to be uploaded, create a multi-part post request to
   // upload the printer capabilities and the printer defaults.
   if (next_upload_index_ < printer_list_.size()) {
     const cloud_print::PrinterBasicInfo& info =
         printer_list_.at(next_upload_index_);
     bool have_printer_info = true;
     // If we are retrying a previous upload, we don't need to fetch the caps
     // and defaults again.
     if (info.printer_name != last_uploaded_printer_name_) {
-      have_printer_info = cloud_print::GetPrinterCapsAndDefaults(
+      have_printer_info = print_system_->GetPrinterCapsAndDefaults(
           info.printer_name.c_str(), &last_uploaded_printer_info_);
     }
     if (have_printer_info) {
       last_uploaded_printer_name_ = info.printer_name;
       std::string mime_boundary;
       CloudPrintHelpers::CreateMimeBoundaryForUpload(&mime_boundary);
       std::string post_data;
       CloudPrintHelpers::AddMultipartValueForUpload(kProxyIdValue, proxy_id_,
                                                     mime_boundary,
                                                     std::string(), &post_data);
@@ skipping 44 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 {
-      NOTREACHED();
+      LOG(ERROR) << "CP: 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.
 void CloudPrintProxyBackend::Core::OnURLFetchComplete(
     const URLFetcher* source, const GURL& url, const URLRequestStatus& status,
     int response_code, const ResponseCookies& cookies,
@@ skipping 81 matching lines @@
     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_,
-                                        this);
+                                        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) {
   Task* next_task =
@@ skipping 70 matching lines @@
     StartRegistration();
   }
 }
 
 // PrinterJobHandler::Delegate implementation
 void CloudPrintProxyBackend::Core::OnPrinterJobHandlerShutdown(
     PrinterJobHandler* job_handler, const std::string& printer_id) {
   job_handler_map_.erase(printer_id);
 }