Move useful printing backend code from chrome/service/cloud_print to printing...

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 <map>
+#include <vector>
+
 #include "base/file_util.h"
 #include "base/md5.h"
 #include "base/rand_util.h"
 #include "base/string_split.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/common/net/http_return.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/service/gaia/service_gaia_authenticator.h"
 #include "chrome/service/service_process.h"
+#include "googleurl/src/gurl.h"
 #include "jingle/notifier/base/notifier_options.h"
 #include "jingle/notifier/listener/push_notifications_thread.h"
 #include "jingle/notifier/listener/talk_mediator_impl.h"
-
-#include "googleurl/src/gurl.h"
 #include "net/url_request/url_request_status.h"
 
 // The real guts of CloudPrintProxyBackend, to keep the public client API clean.
 class CloudPrintProxyBackend::Core
     : public base::RefCountedThreadSafe<CloudPrintProxyBackend::Core>,
       public URLFetcherDelegate,
       public cloud_print::PrintServerWatcherDelegate,
       public PrinterJobHandlerDelegate,
       public notifier::TalkMediator::Delegate {
  public:
@@ skipping 16 matching lines @@
                             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);
+      const printing::PrinterList& printer_list);
 
   // 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::PrintServerWatcherDelegate implementation
   virtual void OnPrinterAdded();
   // PrinterJobHandler::Delegate implementation
@@ skipping 24 matching lines @@
                                      const GURL& url,
                                      const URLRequestStatus& status,
                                      int response_code,
                                      const ResponseCookies& cookies,
                                      const std::string& data);
   // End response handlers
 
   // NotifyXXX is how the Core communicates with the frontend across
   // threads.
   void NotifyPrinterListAvailable(
-      const cloud_print::PrinterList& printer_list);
+      const printing::PrinterList& printer_list);
   void NotifyAuthenticated(
     const std::string& cloud_print_token,
     const std::string& cloud_print_xmpp_token,
     const std::string& email);
   void NotifyAuthenticationFailed();
 
   // Starts a new printer registration process.
   void StartRegistration();
   // Ends the printer registration process.
   void EndRegistration();
@@ skipping 25 matching lines @@
   scoped_ptr<DictionaryValue> print_system_settings_;
   // 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_;
+  printing::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_;
+  printing::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_;
   scoped_refptr<cloud_print::PrintSystem::PrintServerWatcher>
       print_server_watcher_;
   bool new_printers_available_;
   // Notification (xmpp) handler.
   scoped_ptr<notifier::TalkMediator> talk_mediator_;
@@ skipping 50 matching lines @@
 
 void CloudPrintProxyBackend::Shutdown() {
   core_thread_.message_loop()->PostTask(FROM_HERE,
       NewRunnableMethod(core_.get(),
                         &CloudPrintProxyBackend::Core::DoShutdown));
   core_thread_.Stop();
   core_ = NULL;  // Releases reference to core_.
 }
 
 void CloudPrintProxyBackend::RegisterPrinters(
-    const cloud_print::PrinterList& printer_list) {
+    const printing::PrinterList& printer_list) {
   core_thread_.message_loop()->PostTask(FROM_HERE,
       NewRunnableMethod(
           core_.get(),
           &CloudPrintProxyBackend::Core::DoRegisterSelectedPrinters,
           printer_list));
 }
 
 CloudPrintProxyBackend::Core::Core(CloudPrintProxyBackend* backend,
                                    const GURL& cloud_print_server_url,
                                    const DictionaryValue* print_system_settings)
@@ skipping 88 matching lines @@
   print_server_watcher_ = print_system_->CreatePrintServerWatcher();
   print_server_watcher_->StartWatching(this);
 
   proxy_id_ = proxy_id;
   StartRegistration();
 }
 
 void CloudPrintProxyBackend::Core::StartRegistration() {
   DCHECK(MessageLoop::current() == backend_->core_thread_.message_loop());
   printer_list_.clear();
-  print_system_->EnumeratePrinters(&printer_list_);
+  print_system_->GetPrintBackend()->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() {
   DCHECK(MessageLoop::current() == backend_->core_thread_.message_loop());
   request_.reset();
   if (new_printers_available_) {
@@ skipping 16 matching lines @@
     index->second->Shutdown();
   }
   // Important to delete the TalkMediator on this thread.
   talk_mediator_.reset();
   notifications_enabled_ = false;
   request_.reset();
   MessageLoop::current()->QuitNow();
 }
 
 void CloudPrintProxyBackend::Core::DoRegisterSelectedPrinters(
-    const cloud_print::PrinterList& printer_list) {
+    const printing::PrinterList& printer_list) {
   DCHECK(MessageLoop::current() == backend_->core_thread_.message_loop());
   if (!print_system_.get())
     return;  // No print system available.
   server_error_count_ = 0;
   printer_list_.assign(printer_list.begin(), printer_list.end());
   next_upload_index_ = 0;
   RegisterNextPrinter();
 }
 
 void CloudPrintProxyBackend::Core::GetRegisteredPrinters() {
   DCHECK(MessageLoop::current() == backend_->core_thread_.message_loop());
   request_.reset(
       new URLFetcher(
           CloudPrintHelpers::GetUrlForPrinterList(cloud_print_server_url_,
                                                   proxy_id_),
           URLFetcher::GET, this));
   CloudPrintHelpers::PrepCloudPrintRequest(request_.get(), auth_token_);
   next_response_handler_ =
       &CloudPrintProxyBackend::Core::HandlePrinterListResponse;
   request_->Start();
 }
 
 void CloudPrintProxyBackend::Core::RegisterNextPrinter() {
   DCHECK(MessageLoop::current() == backend_->core_thread_.message_loop());
   // 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 =
+    const printing::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 = print_system_->GetPrinterCapsAndDefaults(
-          info.printer_name.c_str(), &last_uploaded_printer_info_);
+      have_printer_info =
+          print_system_->GetPrintBackend()->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);
       CloudPrintHelpers::AddMultipartValueForUpload(kPrinterNameValue,
@@ skipping 99 matching lines @@
         &Core::NotifyAuthenticationFailed));
   } else {
     // We need a next response handler
     DCHECK(next_response_handler_);
     (this->*next_response_handler_)(source, url, status, response_code,
                                     cookies, data);
   }
 }
 
 void CloudPrintProxyBackend::Core::NotifyPrinterListAvailable(
-    const cloud_print::PrinterList& printer_list) {
+    const printing::PrinterList& printer_list) {
   DCHECK(MessageLoop::current() == backend_->frontend_loop_);
   backend_->frontend_->OnPrinterListAvailable(printer_list);
 }
 
 void CloudPrintProxyBackend::Core::NotifyAuthenticated(
     const std::string& cloud_print_token,
     const std::string& cloud_print_xmpp_token,
     const std::string& email) {
   DCHECK(MessageLoop::current() == backend_->frontend_loop_);
   backend_->frontend_->OnAuthenticated(cloud_print_token,
@@ skipping 60 matching lines @@
   DCHECK(printer_data);
   PrinterJobHandler::PrinterInfoFromCloud printer_info_cloud;
   printer_data->GetString(kIdValue, &printer_info_cloud.printer_id);
   DCHECK(!printer_info_cloud.printer_id.empty());
   VLOG(1) << "CP_PROXY: Init job handler for printer id: "
           << printer_info_cloud.printer_id;
   JobHandlerMap::iterator index = job_handler_map_.find(
       printer_info_cloud.printer_id);
   // We might already have a job handler for this printer
   if (index == job_handler_map_.end()) {
-    cloud_print::PrinterBasicInfo printer_info;
+    printing::PrinterBasicInfo printer_info;
     printer_data->GetString(kNameValue, &printer_info.printer_name);
     DCHECK(!printer_info.printer_name.empty());
     printer_data->GetString(kPrinterDescValue,
                             &printer_info.printer_description);
     printer_data->GetInteger(kPrinterStatusValue,
                              &printer_info.printer_status);
     printer_data->GetString(kPrinterCapsHashValue,
         &printer_info_cloud.caps_hash);
     ListValue* tags_list = NULL;
     printer_data->GetList(kPrinterTagsValue, &tags_list);
     if (tags_list) {
       for (size_t index = 0; index < tags_list->GetSize(); index++) {
         std::string tag;
         tags_list->GetString(index, &tag);
         if (StartsWithASCII(tag, kTagsHashTagName, false)) {
           std::vector<std::string> tag_parts;
           base::SplitStringDontTrim(tag, '=', &tag_parts);
-          DCHECK(tag_parts.size() == 2);
+          DCHECK_EQ(tag_parts.size(), 2U);
           if (tag_parts.size() == 2)
             printer_info_cloud.tags_hash = tag_parts[1];
         }
       }
     }
     scoped_refptr<PrinterJobHandler> job_handler;
     job_handler = new PrinterJobHandler(printer_info, printer_info_cloud,
                                         auth_token_, cloud_print_server_url_,
                                         print_system_.get(), this);
     job_handler_map_[printer_info_cloud.printer_id] = job_handler;
@@ skipping 39 matching lines @@
   DCHECK(MessageLoop::current() == backend_->core_thread_.message_loop());
   VLOG(1) << "CP_PROXY: Server error.";
   CloudPrintHelpers::HandleServerError(
       &server_error_count_, -1, kMaxRetryInterval, kBaseRetryInterval,
       task_to_retry, NULL);
 }
 
 bool CloudPrintProxyBackend::Core::RemovePrinterFromList(
     const std::string& printer_name) {
   DCHECK(MessageLoop::current() == backend_->core_thread_.message_loop());
-  for (cloud_print::PrinterList::iterator index = printer_list_.begin();
+  for (printing::PrinterList::iterator index = printer_list_.begin();
        index != printer_list_.end(); index++) {
     if (0 == base::strcasecmp(index->printer_name.c_str(),
                               printer_name.c_str())) {
       index = printer_list_.erase(index);
       return true;
     }
   }
   return false;
 }
 
@@ skipping 42 matching lines @@
   VLOG(1) << "CP_PROXY: Printer job handle shutdown, id " << printer_id;
   job_handler_map_.erase(printer_id);
 }
 
 void CloudPrintProxyBackend::Core::OnAuthError() {
   DCHECK(MessageLoop::current() == backend_->core_thread_.message_loop());
   VLOG(1) << "CP_PROXY: Auth Error";
   backend_->frontend_loop_->PostTask(FROM_HERE, NewRunnableMethod(this,
       &Core::NotifyAuthenticationFailed));
 }
-