Added ConnectorSettings class.

chrome/service/cloud_print/cloud_print_connector.cc

 // Copyright (c) 2012 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_connector.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/md5.h"
 #include "base/rand_util.h"
 #include "base/string_number_conversions.h"
 #include "base/string_split.h"
 #include "base/stringprintf.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/common/cloud_print/cloud_print_helpers.h"
 #include "chrome/service/cloud_print/cloud_print_consts.h"
 #include "chrome/service/cloud_print/cloud_print_helpers.h"
 #include "grit/generated_resources.h"
 #include "ui/base/l10n/l10n_util.h"
 
-const char kDeleteOnEnumFail[] = "delete_on_enum_fail";
-
-CloudPrintConnector::CloudPrintConnector(
-    Client* client,
-    const std::string& proxy_id,
-    const GURL& cloud_print_server_url,
-    const DictionaryValue* print_system_settings)
+CloudPrintConnector::CloudPrintConnector(Client* client,
+                                         const ConnectorSettings& settings)
   : client_(client),
-    proxy_id_(proxy_id),
-    cloud_print_server_url_(cloud_print_server_url),
-    next_response_handler_(NULL),
-    delete_on_enum_fail_(false) {
-  if (print_system_settings) {
-    // It is possible to have no print settings specified.
-    print_system_settings_.reset(print_system_settings->DeepCopy());
-  }
+    next_response_handler_(NULL) {
+  settings_.CopyFrom(settings);
 }
 
 bool CloudPrintConnector::InitPrintSystem() {
   if (print_system_.get())
     return true;
   print_system_ = cloud_print::PrintSystem::CreateInstance(
-      print_system_settings_.get());
+      settings_.print_system_settings());
   if (!print_system_.get()) {
     NOTREACHED();
     return false;  // No memory.
   }
-  if (print_system_settings_.get()) {
-    bool delete_on_enum_fail = false;
-    print_system_settings_->GetBoolean(kDeleteOnEnumFail,
-                                       &delete_on_enum_fail);
-    delete_on_enum_fail_ = delete_on_enum_fail;
-  }
   cloud_print::PrintSystem::PrintSystemResult result = print_system_->Init();
   if (!result.succeeded()) {
     print_system_ = NULL;
     // We could not initialize the print system. We need to notify the server.
     ReportUserMessage(kPrintSystemFailedMessageId, result.message());
     return false;
   }
   return true;
 }
 
 bool CloudPrintConnector::Start() {
   VLOG(1) << "CP_CONNECTOR: Starting connector"
-          << ", proxy id: " << proxy_id_;
+          << ", proxy id: " << settings_.proxy_id();
 
   pending_tasks_.clear();
 
   if (!InitPrintSystem())
     return false;
 
   // Start watching for updates from the print system.
   print_server_watcher_ = print_system_->CreatePrintServerWatcher();
   print_server_watcher_->StartWatching(this);
 
   // Get list of registered printers.
   AddPendingAvailableTask();
   return true;
 }
 
 void CloudPrintConnector::Stop() {
   VLOG(1) << "CP_CONNECTOR: Stopping connector"
-          << ", proxy id: " << proxy_id_;
+          << ", proxy id: " << settings_.proxy_id();
   DCHECK(IsRunning());
   // Do uninitialization here.
   pending_tasks_.clear();
   print_server_watcher_ = NULL;
   request_ = NULL;
 }
 
 bool CloudPrintConnector::IsRunning() {
   return print_server_watcher_.get() != NULL;
 }
@@ skipping 128 matching lines @@
       DictionaryValue* printer_data = NULL;
       if (printer_list->GetDictionary(index, &printer_data)) {
         std::string printer_name;
         printer_data->GetString(kNameValue, &printer_name);
         if (RemovePrinterFromList(printer_name, &local_printers)) {
           InitJobHandlerForPrinter(printer_data);
         } else {
           // Cloud printer is not found on the local system.
           std::string printer_id;
           printer_data->GetString(kIdValue, &printer_id);
-          if (full_list || delete_on_enum_fail_) {
+          if (full_list || settings_.delete_on_enum_fail()) {
             // Delete if we get the full list of printers or
             // |delete_on_enum_fail_| is set.
             VLOG(1) << "CP_CONNECTOR: Deleting " << printer_name <<
               " id: " << printer_id <<
               " full_list: " << full_list <<
-              " delete_on_enum_fail: " << delete_on_enum_fail_;
+              " delete_on_enum_fail: " << settings_.delete_on_enum_fail();
             AddPendingDeleteTask(printer_id);
           } else {
             LOG(ERROR) << "CP_CONNECTOR: Printer: " << printer_name <<
                 " id: " << printer_id <<
                 " not found in print system and full printer list was" <<
                 " not received.  Printer will not be able to process" <<
                 " jobs.";
           }
         }
       } else {
@@ skipping 67 matching lines @@
   request_->StartPostRequest(
       url, this, max_retries, mime_type, post_data, std::string());
 }
 
 void CloudPrintConnector::ReportUserMessage(const std::string& message_id,
                                             const std::string& failure_msg) {
   // This is a fire and forget type of function.
   // Result of this request will be ignored.
   std::string mime_boundary;
   cloud_print::CreateMimeBoundaryForUpload(&mime_boundary);
-  GURL url = CloudPrintHelpers::GetUrlForUserMessage(cloud_print_server_url_,
+  GURL url = CloudPrintHelpers::GetUrlForUserMessage(settings_.server_url(),
                                                      message_id);
   std::string post_data;
   cloud_print::AddMultipartValueForUpload(kMessageTextValue, failure_msg,
       mime_boundary, std::string(), &post_data);
   // Terminate the request body
   post_data.append("--" + mime_boundary + "--\r\n");
   std::string mime_type("multipart/form-data; boundary=");
   mime_type += mime_boundary;
   user_message_request_ = new CloudPrintURLFetcher;
   user_message_request_->StartPostRequest(url, this, 1, mime_type, post_data,
@@ skipping 48 matching lines @@
         base::SplitStringDontTrim(tag, '=', &tag_parts);
         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,
-                                      cloud_print_server_url_,
+                                      settings_.server_url(),
                                       print_system_.get(),
                                       this);
   job_handler_map_[printer_info_cloud.printer_id] = job_handler;
   job_handler->Initialize();
 }
 
 void CloudPrintConnector::AddPendingAvailableTask() {
   PendingTask task;
   task.type = PENDING_PRINTERS_AVAILABLE;
   AddPendingTask(task);
@@ skipping 52 matching lines @@
 
   // Delete current task and repost if we have more task available.
   pending_tasks_.pop_front();
   if (pending_tasks_.size() != 0) {
     MessageLoop::current()->PostTask(
         FROM_HERE, base::Bind(&CloudPrintConnector::ProcessPendingTask, this));
   }
 }
 
 void CloudPrintConnector::OnPrintersAvailable() {
-  GURL printer_list_url =
-      CloudPrintHelpers::GetUrlForPrinterList(cloud_print_server_url_,
-                                              proxy_id_);
+  GURL printer_list_url = CloudPrintHelpers::GetUrlForPrinterList(
+      settings_.server_url(), settings_.proxy_id());
   StartGetRequest(printer_list_url,
                   kCloudPrintRegisterMaxRetryCount,
                   &CloudPrintConnector::HandlePrinterListResponse);
 }
 
 void CloudPrintConnector::OnPrinterRegister(
     const printing::PrinterBasicInfo& info) {
   for (JobHandlerMap::iterator it = job_handler_map_.begin();
        it != job_handler_map_.end(); ++it) {
     if (IsSamePrinter(it->second->GetPrinterName(), info.printer_name)) {
@@ skipping 15 matching lines @@
   // Remove corresponding printer job handler.
   JobHandlerMap::iterator it = job_handler_map_.find(printer_id);
   if (it != job_handler_map_.end()) {
     it->second->Shutdown();
     job_handler_map_.erase(it);
   }
 
   // TODO(gene): We probably should not try indefinitely here. Just once or
   // twice should be enough.
   // Bug: http://code.google.com/p/chromium/issues/detail?id=101850
-  GURL url = CloudPrintHelpers::GetUrlForPrinterDelete(cloud_print_server_url_,
-                                                       printer_id,
-                                                       "printer_deleted");
+  GURL url = CloudPrintHelpers::GetUrlForPrinterDelete(
+      settings_.server_url(), printer_id, "printer_deleted");
   StartGetRequest(url,
                   kCloudPrintAPIMaxRetryCount,
                   &CloudPrintConnector::HandlePrinterDeleteResponse);
 }
 
 void CloudPrintConnector::OnReceivePrinterCaps(
     bool succeeded,
     const std::string& printer_name,
     const printing::PrinterCapsAndDefaults& caps_and_defaults) {
   if (!IsRunning())
@@ skipping 16 matching lines @@
     return;
   }
 
   const printing::PrinterBasicInfo& info = pending_tasks_.front().printer_info;
   DCHECK(IsSamePrinter(info.printer_name, printer_name));
 
   std::string mime_boundary;
   cloud_print::CreateMimeBoundaryForUpload(&mime_boundary);
   std::string post_data;
 
-  cloud_print::AddMultipartValueForUpload(kProxyIdValue, proxy_id_,
+  cloud_print::AddMultipartValueForUpload(kProxyIdValue, settings_.proxy_id(),
       mime_boundary, std::string(), &post_data);
   cloud_print::AddMultipartValueForUpload(kPrinterNameValue, info.printer_name,
       mime_boundary, std::string(), &post_data);
   cloud_print::AddMultipartValueForUpload(kPrinterDescValue,
       info.printer_description, mime_boundary, std::string() , &post_data);
   cloud_print::AddMultipartValueForUpload(kPrinterStatusValue,
       base::StringPrintf("%d", info.printer_status),
       mime_boundary, std::string(), &post_data);
   // Add printer options as tags.
   CloudPrintHelpers::GenerateMultipartPostDataForPrinterTags(info.options,
@@ skipping 11 matching lines @@
   cloud_print::AddMultipartValueForUpload(kPrinterCapsHashValue,
       base::MD5String(caps_and_defaults.printer_capabilities),
       mime_boundary, std::string(), &post_data);
 
   // Terminate the request body
   post_data.append("--" + mime_boundary + "--\r\n");
   std::string mime_type("multipart/form-data; boundary=");
   mime_type += mime_boundary;
 
   GURL post_url = CloudPrintHelpers::GetUrlForPrinterRegistration(
-      cloud_print_server_url_);
+      settings_.server_url());
   StartPostRequest(post_url,
                    kCloudPrintAPIMaxRetryCount,
                    mime_type,
                    post_data,
                    &CloudPrintConnector::HandleRegisterPrinterResponse);
 }
 
 bool CloudPrintConnector::IsSamePrinter(const std::string& name1,
                                         const std::string& name2) const {
   return (0 == base::strcasecmp(name1.c_str(), name2.c_str()));
 }