Changing CloudPrintURLFetcher instantiation to be more testable

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"
@@ skipping 263 matching lines @@
         job_details_.tags_.clear();
         ListValue* tags = NULL;
         if (job_data->GetList(kTagsValue, &tags)) {
           for (size_t i = 0; i < tags->GetSize(); i++) {
             std::string value;
             if (tags->GetString(i, &value))
               job_details_.tags_.push_back(value);
           }
         }
         SetNextDataHandler(&PrinterJobHandler::HandlePrintTicketResponse);
-        request_ = new CloudPrintURLFetcher;
+        request_ = CloudPrintURLFetcher::Create();
         request_->StartGetRequest(GURL(print_ticket_url.c_str()),
                                   this,
                                   kCloudPrintAPIMaxRetryCount,
                                   std::string());
       }
     }
   }
   // If no jobs are available, go to the Stop state.
   if (!job_available) {
     VLOG(1) << "CP_CONNECTOR: Stopping printer job handler"
             << ", printer id: " << printer_info_cloud_.printer_id;
     MessageLoop::current()->PostTask(
         FROM_HERE, base::Bind(&PrinterJobHandler::Stop, this));
   }
   return CloudPrintURLFetcher::STOP_PROCESSING;
 }
 
 CloudPrintURLFetcher::ResponseAction
 PrinterJobHandler::HandlePrintTicketResponse(const net::URLFetcher* source,
                                              const GURL& url,
                                              const std::string& data) {
   VLOG(1) << "CP_CONNECTOR: Handling print ticket response"
           << ", printer id: " << printer_info_cloud_.printer_id;
   if (print_system_->ValidatePrintTicket(printer_info_.printer_name, data)) {
     job_details_.print_ticket_ = data;
     SetNextDataHandler(&PrinterJobHandler::HandlePrintDataResponse);
-    request_ = new CloudPrintURLFetcher;
+    request_ = CloudPrintURLFetcher::Create();
     std::string accept_headers = "Accept: ";
     accept_headers += print_system_->GetSupportedMimeTypes();
     request_->StartGetRequest(GURL(print_data_url_.c_str()),
                               this,
                               kJobDataMaxRetryCount,
                               accept_headers);
   } else {
     // The print ticket was not valid. We are done here.
     FailedFetchingJobData();
   }
@@ skipping 93 matching lines @@
                 << ", task in progress: " << task_in_progress_;
       }
       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_ = CloudPrintURLFetcher::Create();
         request_->StartGetRequest(
             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()
@@ skipping 61 matching lines @@
     return;
   }
 
   if (error == SUCCESS) {
     SetNextJSONHandler(
         &PrinterJobHandler::HandleSuccessStatusUpdateResponse);
   } else {
     SetNextJSONHandler(
         &PrinterJobHandler::HandleFailureStatusUpdateResponse);
   }
-  request_ = new CloudPrintURLFetcher;
+  request_ = CloudPrintURLFetcher::Create();
   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;
@@ skipping 127 matching lines @@
         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_ = CloudPrintURLFetcher::Create();
     request_->StartPostRequest(
         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
@@ skipping 25 matching lines @@
                            job_details.print_data_mime_type_,
                            printer_name,
                            UTF16ToUTF8(document_name),
                            job_details.tags_,
                            this)) {
     OnJobSpoolFailed();
   }
 }
 
 }  // namespace cloud_print