Changed cloud print private API to pass all page settings as single object.

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"
@@ skipping 72 matching lines @@
   DCHECK(printer_ids);
   printer_ids->clear();
   for (JobHandlerMap::const_iterator iter = job_handler_map_.begin();
        iter != job_handler_map_.end(); ++iter) {
     printer_ids->push_back(iter->first);
   }
 }
 
 void CloudPrintConnector::RegisterPrinters(
     const printing::PrinterList& printers) {
-  if (!settings_.connect_new_printers() || !IsRunning())
+  if (!IsRunning())
     return;
   printing::PrinterList::const_iterator it;
   for (it = printers.begin(); it != printers.end(); ++it) {
-    if (!settings_.IsPrinterBlacklisted(it->printer_name))
-      AddPendingRegisterTask(*it);
+    if (settings_.ShouldConnect(it->printer_name))
+      AddPendingRegisterTask(*it, settings_.GetDisplayName(it->printer_name));
   }
 }
 
 // Check for jobs for specific printer
 void CloudPrintConnector::CheckForJobs(const std::string& reason,
                                        const std::string& printer_id) {
   if (!IsRunning())
     return;
   if (!printer_id.empty()) {
     JobHandlerMap::iterator index = job_handler_map_.find(printer_id);
@@ skipping 96 matching lines @@
   ListValue* printer_list = NULL;
   // There may be no "printers" value in the JSON
   if (json_data->GetList(kPrinterListValue, &printer_list) && printer_list) {
     for (size_t index = 0; index < printer_list->GetSize(); index++) {
       DictionaryValue* printer_data = NULL;
       if (printer_list->GetDictionary(index, &printer_data)) {
         std::string printer_name;
         printer_data->GetString(kNameValue, &printer_name);
         std::string printer_id;
         printer_data->GetString(kIdValue, &printer_id);
-        if (settings_.IsPrinterBlacklisted(printer_name)) {
+
+        if (!settings_.ShouldConnect(printer_name)) {
           VLOG(1) << "CP_CONNECTOR: Deleting " << printer_name <<
               " id: " << printer_id << " as blacklisted";
           AddPendingDeleteTask(printer_id);
         } else if (RemovePrinterFromList(printer_name, &local_printers)) {
           InitJobHandlerForPrinter(printer_data);
         } else {
           // Cloud printer is not found on the local system.
           if (full_list || settings_.delete_on_enum_fail()) {
             // Delete if we get the full list of printers or
             // |delete_on_enum_fail_| is set.
@@ skipping 166 matching lines @@
 }
 
 void CloudPrintConnector::AddPendingDeleteTask(const std::string& id) {
   PendingTask task;
   task.type = PENDING_PRINTER_DELETE;
   task.printer_id = id;
   AddPendingTask(task);
 }
 
 void CloudPrintConnector::AddPendingRegisterTask(
-    const printing::PrinterBasicInfo& info) {
+    const printing::PrinterBasicInfo& info,
+    const std::string& display_name) {
   PendingTask task;
   task.type = PENDING_PRINTER_REGISTER;
   task.printer_info = info;
+  task.display_name = display_name;
   AddPendingTask(task);
 }
 
 void CloudPrintConnector::AddPendingTask(const PendingTask& task) {
   pending_tasks_.push_back(task);
   // If this is the only pending task, we need to start the process.
   if (pending_tasks_.size() == 1) {
     MessageLoop::current()->PostTask(
         FROM_HERE, base::Bind(&CloudPrintConnector::ProcessPendingTask, this));
   }
 }
 
 void CloudPrintConnector::ProcessPendingTask() {
   if (!IsRunning())
     return;  // Orphant call.
   if (pending_tasks_.size() == 0)
     return;  // No peding tasks.
 
   PendingTask task = pending_tasks_.front();
 
   switch (task.type) {
     case PENDING_PRINTERS_AVAILABLE :
       OnPrintersAvailable();
       break;
     case PENDING_PRINTER_REGISTER :
-      OnPrinterRegister(task.printer_info);
+      OnPrinterRegister(task.printer_info, task.display_name);
       break;
     case PENDING_PRINTER_DELETE :
       OnPrinterDelete(task.printer_id);
       break;
     default:
       NOTREACHED();
   }
 }
 
 void CloudPrintConnector::ContinuePendingTaskProcessing() {
@@ skipping 10 matching lines @@
 
 void CloudPrintConnector::OnPrintersAvailable() {
   GURL printer_list_url = GetUrlForPrinterList(
       settings_.server_url(), settings_.proxy_id());
   StartGetRequest(printer_list_url,
                   kCloudPrintRegisterMaxRetryCount,
                   &CloudPrintConnector::HandlePrinterListResponse);
 }
 
 void CloudPrintConnector::OnPrinterRegister(
-    const printing::PrinterBasicInfo& info) {
+    const printing::PrinterBasicInfo& info, const std::string& display_name) {
   for (JobHandlerMap::iterator it = job_handler_map_.begin();
        it != job_handler_map_.end(); ++it) {
     if (IsSamePrinter(it->second->GetPrinterName(), info.printer_name)) {
       // Printer already registered, continue to the next task.
       ContinuePendingTaskProcessing();
       return;
     }
   }
 
   // Asynchronously fetch the printer caps and defaults. The story will
   // continue in OnReceivePrinterCaps.
   print_system_->GetPrinterCapsAndDefaults(
       info.printer_name.c_str(),
       base::Bind(&CloudPrintConnector::OnReceivePrinterCaps,
-                 base::Unretained(this)));
+                 base::Unretained(this), display_name));
 }
 
 void CloudPrintConnector::OnPrinterDelete(const std::string& printer_id) {
   // 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 = GetUrlForPrinterDelete(
       settings_.server_url(), printer_id, "printer_deleted");
   StartGetRequest(url,
                   kCloudPrintAPIMaxRetryCount,
                   &CloudPrintConnector::HandlePrinterDeleteResponse);
 }
 
 void CloudPrintConnector::OnReceivePrinterCaps(
+    const std::string& display_name,
     bool succeeded,
     const std::string& printer_name,
     const printing::PrinterCapsAndDefaults& caps_and_defaults) {
   if (!IsRunning())
     return;  // Orphant call.
   DCHECK(pending_tasks_.size() > 0 &&
          pending_tasks_.front().type == PENDING_PRINTER_REGISTER);
 
   if (!succeeded) {
     LOG(ERROR) << "CP_CONNECTOR: Failed to get printer info"
@@ skipping 14 matching lines @@
   DCHECK(IsSamePrinter(info.printer_name, printer_name));
 
   std::string mime_boundary;
   CreateMimeBoundaryForUpload(&mime_boundary);
   std::string post_data;
 
   AddMultipartValueForUpload(kProxyIdValue,
       settings_.proxy_id(), mime_boundary, std::string(), &post_data);
   AddMultipartValueForUpload(kPrinterNameValue,
       info.printer_name, mime_boundary, std::string(), &post_data);
+  if (!display_name.empty()) {
+    AddMultipartValueForUpload(kPrinterDisplayNameValue,
+        display_name, mime_boundary, std::string(), &post_data);
+  }
   AddMultipartValueForUpload(kPrinterDescValue,
       info.printer_description, mime_boundary, std::string(), &post_data);
   AddMultipartValueForUpload(kPrinterStatusValue,
       base::StringPrintf("%d", info.printer_status),
       mime_boundary, std::string(), &post_data);
   post_data += GetPostDataForPrinterInfo(info, mime_boundary);
   AddMultipartValueForUpload(kPrinterCapsValue,
       caps_and_defaults.printer_capabilities, mime_boundary,
       caps_and_defaults.caps_mime_type, &post_data);
   AddMultipartValueForUpload(kPrinterDefaultsValue,
@@ skipping 17 matching lines @@
                    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()));
 }
 
 }  // namespace cloud_print