Move common cloud print methods from service/cloud_print to common/cloud_print.

chrome/service/cloud_print/printer_job_handler.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/printer_job_handler.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/file_util.h"
 #include "base/json/json_reader.h"
 #include "base/md5.h"
 #include "base/stringprintf.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
+#include "chrome/common/cloud_print/cloud_print_constants.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 "chrome/service/cloud_print/job_status_updater.h"
 #include "googleurl/src/gurl.h"
 #include "grit/generated_resources.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_status_code.h"
 #include "printing/backend/print_backend.h"
 #include "ui/base/l10n/l10n_util.h"
 
+namespace cloud_print {
+
 PrinterJobHandler::JobDetails::JobDetails() {}
 
 PrinterJobHandler::JobDetails::~JobDetails() {}
 
 void PrinterJobHandler::JobDetails::Clear() {
   job_id_.clear();
   job_title_.clear();
   print_ticket_.clear();
   print_data_mime_type_.clear();
   print_data_file_path_ = FilePath();
   tags_.clear();
 }
 
 PrinterJobHandler::PrinterJobHandler(
     const printing::PrinterBasicInfo& printer_info,
     const PrinterInfoFromCloud& printer_info_cloud,
     const GURL& cloud_print_server_url,
-    cloud_print::PrintSystem* print_system,
+    PrintSystem* print_system,
     Delegate* delegate)
     : print_system_(print_system),
       printer_info_(printer_info),
       printer_info_cloud_(printer_info_cloud),
       cloud_print_server_url_(cloud_print_server_url),
       delegate_(delegate),
       local_job_id_(-1),
       next_json_data_handler_(NULL),
       next_data_handler_(NULL),
       server_error_count_(0),
@@ skipping 100 matching lines @@
 CloudPrintURLFetcher::ResponseAction PrinterJobHandler::OnRequestAuthError() {
   // We got an Auth error and have no idea how long it will take to refresh
   // auth information (may take forever). We'll drop current request and
   // propagate this error to the upper level. After auth issues will be
   // resolved, GCP connector will restart.
   OnAuthError();
   return CloudPrintURLFetcher::STOP_PROCESSING;
 }
 
 std::string PrinterJobHandler::GetAuthHeader() {
-  return CloudPrintHelpers::GetCloudPrintAuthHeaderFromStore();
+  return GetCloudPrintAuthHeaderFromStore();
 }
 
 // JobStatusUpdater::Delegate implementation
 bool PrinterJobHandler::OnJobCompleted(JobStatusUpdater* updater) {
   bool ret = false;
   for (JobStatusUpdaterList::iterator index = job_status_updater_list_.begin();
        index != job_status_updater_list_.end(); index++) {
     if (index->get() == updater) {
       job_status_updater_list_.erase(index);
       ret = true;
@@ skipping 26 matching lines @@
 void PrinterJobHandler::OnJobChanged() {
   // Some job on the printer changed. Loop through all our JobStatusUpdaters
   // and have them check for updates.
   for (JobStatusUpdaterList::iterator index = job_status_updater_list_.begin();
        index != job_status_updater_list_.end(); index++) {
     MessageLoop::current()->PostTask(
         FROM_HERE, base::Bind(&JobStatusUpdater::UpdateStatus, index->get()));
   }
 }
 
-void PrinterJobHandler::OnJobSpoolSucceeded(
-    const cloud_print::PlatformJobId& job_id) {
+void PrinterJobHandler::OnJobSpoolSucceeded(const PlatformJobId& job_id) {
   DCHECK(MessageLoop::current() == print_thread_.message_loop());
   job_spooler_ = NULL;
   job_handler_message_loop_proxy_->PostTask(
       FROM_HERE, base::Bind(&PrinterJobHandler::JobSpooled, this, job_id));
 }
 
 void PrinterJobHandler::OnJobSpoolFailed() {
   DCHECK(MessageLoop::current() == print_thread_.message_loop());
   job_spooler_ = NULL;
   VLOG(1) << "CP_CONNECTOR: Job failed (spool failed)";
@@ skipping 193 matching lines @@
       if (!task_in_progress_ && job_check_pending_) {
         task_in_progress_ = true;
         VLOG(1) << "CP_CONNECTOR: Changed task in progress"
                 ", printer id: " << printer_info_cloud_.printer_id
                 << ", task in progress: " << task_in_progress_;
         job_check_pending_ = false;
         // We need to fetch any pending jobs for this printer
         SetNextJSONHandler(&PrinterJobHandler::HandleJobMetadataResponse);
         request_ = new CloudPrintURLFetcher;
         request_->StartGetRequest(
-            CloudPrintHelpers::GetUrlForJobFetch(
+            GetUrlForJobFetch(
                 cloud_print_server_url_, printer_info_cloud_.printer_id,
                 job_fetch_reason_),
             this,
             kCloudPrintAPIMaxRetryCount,
             std::string());
         last_job_fetch_time_ = base::TimeTicks::Now();
         VLOG(1) << "CP_CONNECTOR: Last job fetch time"
                 << ", printer name: " << printer_info_.printer_name.c_str()
                 << ", timestamp: " << last_job_fetch_time_.ToInternalValue();
         job_fetch_reason_.clear();
@@ skipping 34 matching lines @@
   }
 }
 
 void PrinterJobHandler::Reset() {
   print_data_url_.clear();
   job_details_.Clear();
   request_ = NULL;
   print_thread_.Stop();
 }
 
-void PrinterJobHandler::UpdateJobStatus(cloud_print::PrintJobStatus status,
+void PrinterJobHandler::UpdateJobStatus(PrintJobStatus status,
                                         PrintJobError error) {
   VLOG(1) << "CP_CONNECTOR: Updating job status"
           << ", printer id: " << printer_info_cloud_.printer_id
           << ", job id: " << job_details_.job_id_
           << ", job status: " << status;
   if (shutting_down_) {
     VLOG(1) << "CP_CONNECTOR: Job status update aborted (shutting down)"
             << ", printer id: " << printer_info_cloud_.printer_id
             << ", job id: " << job_details_.job_id_;
     return;
   }
   if (job_details_.job_id_.empty()) {
     VLOG(1) << "CP_CONNECTOR: Job status update aborted (empty job id)"
             << ", printer id: " << printer_info_cloud_.printer_id;
     return;
   }
 
   if (error == SUCCESS) {
     SetNextJSONHandler(
         &PrinterJobHandler::HandleSuccessStatusUpdateResponse);
   } else {
     SetNextJSONHandler(
         &PrinterJobHandler::HandleFailureStatusUpdateResponse);
   }
   request_ = new CloudPrintURLFetcher;
-  request_->StartGetRequest(
-      CloudPrintHelpers::GetUrlForJobStatusUpdate(cloud_print_server_url_,
-                                                  job_details_.job_id_,
-                                                  status),
+  request_->StartGetRequest(GetUrlForJobStatusUpdate(cloud_print_server_url_,
+                                                     job_details_.job_id_,
+                                                     status),
       this,
       kCloudPrintAPIMaxRetryCount,
       std::string());
 }
 
 void PrinterJobHandler::SetNextJSONHandler(JSONDataHandler handler) {
   next_json_data_handler_ = handler;
   next_data_handler_ = NULL;
 }
 
 void PrinterJobHandler::SetNextDataHandler(DataHandler handler) {
   next_data_handler_ = handler;
   next_json_data_handler_ = NULL;
 }
 
 void PrinterJobHandler::JobFailed(PrintJobError error) {
   VLOG(1) << "CP_CONNECTOR: Job failed"
           << ", printer id: " << printer_info_cloud_.printer_id
           << ", job id: " << job_details_.job_id_
           << ", error: " << error;
   if (!shutting_down_) {
-    UpdateJobStatus(cloud_print::PRINT_JOB_STATUS_ERROR, error);
+    UpdateJobStatus(PRINT_JOB_STATUS_ERROR, error);
     // This job failed, but others may be pending.  Schedule a check.
     job_check_pending_ = true;
   }
 }
 
-void PrinterJobHandler::JobSpooled(cloud_print::PlatformJobId local_job_id) {
+void PrinterJobHandler::JobSpooled(PlatformJobId local_job_id) {
   VLOG(1) << "CP_CONNECTOR: Job spooled"
           << ", printer id: " << printer_info_cloud_.printer_id
           << ", job id: " << local_job_id;
   if (!shutting_down_) {
     local_job_id_ = local_job_id;
-    UpdateJobStatus(cloud_print::PRINT_JOB_STATUS_IN_PROGRESS, SUCCESS);
+    UpdateJobStatus(PRINT_JOB_STATUS_IN_PROGRESS, SUCCESS);
     print_thread_.Stop();
   }
 }
 
 bool PrinterJobHandler::UpdatePrinterInfo() {
   if (!printer_watcher_) {
     LOG(ERROR) << "CP_CONNECTOR: Printer watcher is missing."
                << " Check printer server url for printer id: "
                << printer_info_cloud_.printer_id;
     return false;
@@ skipping 35 matching lines @@
 void PrinterJobHandler::OnReceivePrinterCaps(
     bool succeeded,
     const std::string& printer_name,
     const printing::PrinterCapsAndDefaults& caps_and_defaults) {
   printing::PrinterBasicInfo printer_info;
   if (printer_watcher_)
     printer_watcher_->GetCurrentPrinterInfo(&printer_info);
 
   std::string post_data;
   std::string mime_boundary;
-  cloud_print::CreateMimeBoundaryForUpload(&mime_boundary);
+  CreateMimeBoundaryForUpload(&mime_boundary);
 
   if (succeeded) {
     std::string caps_hash =
         base::MD5String(caps_and_defaults.printer_capabilities);
     if (caps_hash != printer_info_cloud_.caps_hash) {
       // Hashes don't match, we need to upload new capabilities (the defaults
       // go for free along with the capabilities)
       printer_info_cloud_.caps_hash = caps_hash;
-      cloud_print::AddMultipartValueForUpload(kPrinterCapsValue,
+      AddMultipartValueForUpload(kPrinterCapsValue,
           caps_and_defaults.printer_capabilities, mime_boundary,
           caps_and_defaults.caps_mime_type, &post_data);
-      cloud_print::AddMultipartValueForUpload(kPrinterDefaultsValue,
+      AddMultipartValueForUpload(kPrinterDefaultsValue,
           caps_and_defaults.printer_defaults, mime_boundary,
           caps_and_defaults.defaults_mime_type, &post_data);
-      cloud_print::AddMultipartValueForUpload(kPrinterCapsHashValue,
+      AddMultipartValueForUpload(kPrinterCapsHashValue,
           caps_hash, mime_boundary, std::string(), &post_data);
     }
   } else {
     LOG(ERROR) << "Failed to get printer caps and defaults"
                << ", printer name: " << printer_name;
   }
 
-  std::string tags_hash = CloudPrintHelpers::GetHashOfPrinterTags(printer_info);
+  std::string tags_hash = GetHashOfPrinterInfo(printer_info);
   if (tags_hash != printer_info_cloud_.tags_hash) {
     printer_info_cloud_.tags_hash = tags_hash;
-    post_data += CloudPrintHelpers::GetPostDataForPrinterTags(printer_info,
-                                                              mime_boundary);
+    post_data += GetPostDataForPrinterInfo(printer_info, mime_boundary);
     // Remove all the existing proxy tags.
-    std::string cp_tag_wildcard(kProxyTagPrefix);
+    std::string cp_tag_wildcard(kCloudPrintServiceProxyTagPrefix);
     cp_tag_wildcard += ".*";
-    cloud_print::AddMultipartValueForUpload(kPrinterRemoveTagValue,
+    AddMultipartValueForUpload(kPrinterRemoveTagValue,
         cp_tag_wildcard, mime_boundary, std::string(), &post_data);
   }
 
   if (printer_info.printer_name != printer_info_.printer_name) {
-    cloud_print::AddMultipartValueForUpload(kPrinterNameValue,
+    AddMultipartValueForUpload(kPrinterNameValue,
         printer_info.printer_name, mime_boundary, std::string(), &post_data);
   }
   if (printer_info.printer_description != printer_info_.printer_description) {
-    cloud_print::AddMultipartValueForUpload(kPrinterDescValue,
+    AddMultipartValueForUpload(kPrinterDescValue,
       printer_info.printer_description, mime_boundary,
       std::string(), &post_data);
   }
   if (printer_info.printer_status != printer_info_.printer_status) {
-    cloud_print::AddMultipartValueForUpload(kPrinterStatusValue,
+    AddMultipartValueForUpload(kPrinterStatusValue,
         base::StringPrintf("%d", printer_info.printer_status), mime_boundary,
         std::string(), &post_data);
   }
   printer_info_ = printer_info;
   if (!post_data.empty()) {
     // Terminate the request body
     post_data.append("--" + mime_boundary + "--\r\n");
     std::string mime_type("multipart/form-data; boundary=");
     mime_type += mime_boundary;
     SetNextJSONHandler(&PrinterJobHandler::HandlePrinterUpdateResponse);
     request_ = new CloudPrintURLFetcher;
     request_->StartPostRequest(
-        CloudPrintHelpers::GetUrlForPrinterUpdate(
+        GetUrlForPrinterUpdate(
             cloud_print_server_url_, printer_info_cloud_.printer_id),
         this,
         kCloudPrintAPIMaxRetryCount,
         mime_type,
         post_data,
         std::string());
   } else {
     // We are done here. Go to the Stop state
     VLOG(1) << "CP_CONNECTOR: Stopping printer job handler"
             << ", printer name: " << printer_name;
@@ skipping 21 matching lines @@
   if (!job_spooler_->Spool(job_details.print_ticket_,
                            job_details.print_data_file_path_,
                            job_details.print_data_mime_type_,
                            printer_name,
                            UTF16ToUTF8(document_name),
                            job_details.tags_,
                            this)) {
     OnJobSpoolFailed();
   }
 }
+
+}  // namespace cloud_print