Cleanup: ResourceDispatcherHost::BeginDownload takes a scoped_ptr<URLRequest> argument.

content/browser/renderer_host/resource_dispatcher_host.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.
 
 // See http://dev.chromium.org/developers/design-documents/multi-process-resource-loading
 
 #include "content/browser/renderer_host/resource_dispatcher_host.h"
 
 #include <set>
 #include <vector>
@@ skipping 859 matching lines @@
     ResourceType::Type resource_type) {
   if (!url.is_valid() || !(url.SchemeIs("http") || url.SchemeIs("https")))
     return;
 
   filter_->GetURLRequestContext(resource_type)->http_transaction_factory()->
       GetCache()->OnExternalCacheHit(url, http_method);
 }
 
 // We are explicitly forcing the download of 'url'.
 void ResourceDispatcherHost::BeginDownload(
-    net::URLRequest* request,
+    scoped_ptr<net::URLRequest> request,
     const DownloadSaveInfo& save_info,
     bool prompt_for_save_location,
     const DownloadResourceHandler::OnStartedCallback& started_cb,
     int child_id,
     int route_id,
     const content::ResourceContext& context) {
-  scoped_ptr<net::URLRequest> delete_request(request);
   // If DownloadResourceHandler is not begun, then started_cb must be called
   // here in order to satisfy its semantics.
   if (is_shutdown_) {
     if (!started_cb.is_null())
       started_cb.Run(DownloadId::Invalid(), net::ERR_INSUFFICIENT_RESOURCES);
     // Time and RDH are resources that are running out.
     return;
   }
   const GURL& url = request->original_url();
   const net::URLRequestContext* request_context = context.request_context();
@@ skipping 18 matching lines @@
   DownloadId dl_id = context.download_id_factory()->GetNextId();
 
   scoped_refptr<ResourceHandler> handler(
       new DownloadResourceHandler(this,
                                   child_id,
                                   route_id,
                                   request_id_,
                                   url,
                                   dl_id,
                                   download_file_manager_.get(),
-                                  request,
+                                  request.get(),
                                   prompt_for_save_location,
                                   started_cb,
                                   save_info));
 
   if (delegate_) {
     handler = delegate_->DownloadStarting(
-        handler, context, request, child_id, route_id, request_id_, true);
+        handler, context, request.get(),
+        child_id, route_id, request_id_, true);
   }
 
   if (!request_context->job_factory()->IsHandledURL(url)) {
     VLOG(1) << "Download request for unsupported protocol: "
             << url.possibly_invalid_spec();
     if (!started_cb.is_null())
       started_cb.Run(DownloadId::Invalid(), net::ERR_ACCESS_DENIED);
     return;
   }
 
   ResourceDispatcherHostRequestInfo* extra_info =
       CreateRequestInfo(handler, child_id, route_id, true, context);
-  SetRequestInfo(request, extra_info);  // Request takes ownership.
+  SetRequestInfo(request.get(), extra_info);  // Request takes ownership.
 
-  BeginRequestInternal(delete_request.release());
+  BeginRequestInternal(request.release());
 }
 
 // This function is only used for saving feature.
 void ResourceDispatcherHost::BeginSaveFile(
     const GURL& url,
     const GURL& referrer,
     int child_id,
     int route_id,
     const content::ResourceContext& context) {
   if (is_shutdown_)
@@ skipping 43 matching lines @@
   if (i == pending_requests_.end() || !i->second->status().is_success()) {
     DLOG(WARNING) << "FollowDeferredRedirect for invalid request";
     return;
   }
 
   if (has_new_first_party_for_cookies)
     i->second->set_first_party_for_cookies(new_first_party_for_cookies);
   i->second->FollowDeferredRedirect();
 }
 
-void ResourceDispatcherHost::StartDeferredRequest(int process_unique_id,
+void ResourceDispatcherHost::StartDeferredRequest(int child_id,
                                                   int request_id) {
-  GlobalRequestID global_id(process_unique_id, request_id);
+  GlobalRequestID global_id(child_id, request_id);
   PendingRequestList::iterator i = pending_requests_.find(global_id);
   if (i == pending_requests_.end()) {
     // The request may have been destroyed
     LOG(WARNING) << "Trying to resume a non-existent request ("
-                 << process_unique_id << ", " << request_id << ")";
+                 << child_id << ", " << request_id << ")";
     return;
   }
 
   // TODO(eroman): are there other considerations for paused or blocked
   //               requests?
 
   net::URLRequest* request = i->second;
   InsertIntoResourceQueue(request, *InfoForRequest(request));
 }
 
@@ skipping 1223 matching lines @@
     const GlobalRequestID& transferred_request_id,
     net::URLRequest* ransferred_request) {
   transferred_navigations_[transferred_request_id] = ransferred_request;
 }
 
 bool ResourceDispatcherHost::IsTransferredNavigation(
     const content::GlobalRequestID& transferred_request_id) const {
   return transferred_navigations_.find(transferred_request_id) !=
       transferred_navigations_.end();
 }