Add Chrome To Mobile Service and Views Page Action.

chrome/service/cloud_print/cloud_print_connector.cc

-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// 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"
 
 CloudPrintConnector::CloudPrintConnector(
     Client* client,
     const std::string& proxy_id,
     const GURL& cloud_print_server_url,
     const DictionaryValue* print_system_settings)
@@ skipping 144 matching lines @@
     if (message.empty())
       message = l10n_util::GetStringFUTF8(IDS_CLOUD_PRINT_ENUM_FAILED,
           l10n_util::GetStringUTF16(IDS_GOOGLE_CLOUD_PRINT));
     // There was a failure enumerating printers. Send a message to the server.
     ReportUserMessage(kEnumPrintersFailedMessageId, message);
   }
 
   // Go through the list of the cloud printers and init print job handlers.
   ListValue* printer_list = NULL;
   // There may be no "printers" value in the JSON
-  if (json_data->GetList(kPrinterListValue, &printer_list) && printer_list) {
+  if (json_data->GetList(cloud_print::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);
         if (RemovePrinterFromList(printer_name, &local_printers)) {
           InitJobHandlerForPrinter(printer_data);
         } else {
           // Cloud printer is not found on the local system.
           if (full_list) {  // Delete only if we get the full list of printer.
@@ skipping 35 matching lines @@
 CloudPrintConnector::HandleRegisterPrinterResponse(
     const content::URLFetcher* source,
     const GURL& url,
     DictionaryValue* json_data,
     bool succeeded) {
   VLOG(1) << "CP_CONNECTOR: Handler printer register response, succeeded:"
           << succeeded << " url: " << url;
   if (succeeded) {
     ListValue* printer_list = NULL;
     // There should be a "printers" value in the JSON
-    if (json_data->GetList(kPrinterListValue, &printer_list)) {
+    if (json_data->GetList(cloud_print::kPrinterListValue, &printer_list)) {
       DictionaryValue* printer_data = NULL;
       if (printer_list->GetDictionary(0, &printer_data))
         InitJobHandlerForPrinter(printer_data);
     }
   }
   ContinuePendingTaskProcessing();  // Continue processing background tasks.
   return CloudPrintURLFetcher::STOP_PROCESSING;
 }
 
 
@@ skipping 23 matching lines @@
   request_ = new CloudPrintURLFetcher;
   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;
-  CloudPrintHelpers::CreateMimeBoundaryForUpload(&mime_boundary);
+  cloud_print::CreateMimeBoundaryForUpload(&mime_boundary);
   GURL url = CloudPrintHelpers::GetUrlForUserMessage(cloud_print_server_url_,
                                                      message_id);
   std::string post_data;
-  CloudPrintHelpers::AddMultipartValueForUpload(kMessageTextValue,
-                                                failure_msg,
-                                                mime_boundary,
-                                                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,
                                           std::string());
 }
 
 bool CloudPrintConnector::RemovePrinterFromList(
@@ skipping 190 matching lines @@
     ReportUserMessage(kGetPrinterCapsFailedMessageId, status_message);
 
     ContinuePendingTaskProcessing();  // Skip this printer registration.
     return;
   }
 
   const printing::PrinterBasicInfo& info = pending_tasks_.front().printer_info;
   DCHECK(IsSamePrinter(info.printer_name, printer_name));
 
   std::string mime_boundary;
-  CloudPrintHelpers::CreateMimeBoundaryForUpload(&mime_boundary);
+  cloud_print::CreateMimeBoundaryForUpload(&mime_boundary);
   std::string post_data;
 
-  CloudPrintHelpers::AddMultipartValueForUpload(kProxyIdValue, proxy_id_,
-                                                mime_boundary,
-                                                std::string(), &post_data);
-  CloudPrintHelpers::AddMultipartValueForUpload(kPrinterNameValue,
-                                                info.printer_name,
-                                                mime_boundary,
-                                                std::string(), &post_data);
-  CloudPrintHelpers::AddMultipartValueForUpload(kPrinterDescValue,
-                                                info.printer_description,
-                                                mime_boundary,
-                                                std::string() , &post_data);
-  CloudPrintHelpers::AddMultipartValueForUpload(
-      kPrinterStatusValue, base::StringPrintf("%d", info.printer_status),
+  cloud_print::AddMultipartValueForUpload(kProxyIdValue, 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,
                                                              mime_boundary,
                                                              &post_data);
 
-  CloudPrintHelpers::AddMultipartValueForUpload(
-      kPrinterCapsValue, caps_and_defaults.printer_capabilities,
-      mime_boundary, caps_and_defaults.caps_mime_type,
-      &post_data);
-  CloudPrintHelpers::AddMultipartValueForUpload(
-      kPrinterDefaultsValue, caps_and_defaults.printer_defaults,
-      mime_boundary, caps_and_defaults.defaults_mime_type,
-      &post_data);
+  cloud_print::AddMultipartValueForUpload(kPrinterCapsValue,
+      caps_and_defaults.printer_capabilities, mime_boundary,
+      caps_and_defaults.caps_mime_type, &post_data);
+  cloud_print::AddMultipartValueForUpload(kPrinterDefaultsValue,
+      caps_and_defaults.printer_defaults, mime_boundary,
+      caps_and_defaults.defaults_mime_type, &post_data);
   // Send a hash of the printer capabilities to the server. We will use this
   // later to check if the capabilities have changed
-  CloudPrintHelpers::AddMultipartValueForUpload(
-      kPrinterCapsHashValue,
+  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_);
   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()));
 }