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

content/browser/renderer_host/resource_dispatcher_host.h

 // 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.
 
 // This is the browser side of the resource dispatcher, it receives requests
 // from the child process (i.e. [Renderer, Plugin, Worker]ProcessHost), and
 // dispatches them to URLRequests. It then forwards the messages from the
 // URLRequests back to the correct process for handling.
 //
 // See http://dev.chromium.org/developers/design-documents/multi-process-resource-loading
@@ skipping 67 matching lines @@
   // If it was, message_was_ok will be false iff the message was corrupt.
   bool OnMessageReceived(const IPC::Message& message,
                          ResourceMessageFilter* filter,
                          bool* message_was_ok);
 
   // Initiates a download by explicit request of the renderer, e.g. due to
   // alt-clicking a link.  If |request| is malformed or not permitted or the RDH
   // is shutting down, then |started_cb| will be called immediately. There is no
   // situation in which |started_cb| will never be called.
   void BeginDownload(
-      net::URLRequest* request,  // ownership is taken
+      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);
 
   // Initiates a save file from the browser process (as opposed to a resource
   // request from the renderer or another child process).
   void BeginSaveFile(const GURL& url,
                      const GURL& referrer,
-                     int process_unique_id,
+                     int child_id,
                      int route_id,
                      const content::ResourceContext& context);
 
   // Cancels the given request if it still exists. We ignore cancels from the
   // renderer in the event of a download.
-  void CancelRequest(int process_unique_id,
+  void CancelRequest(int child_id,
                      int request_id,
                      bool from_renderer);
 
   // Follows a deferred redirect for the given request.
   // new_first_party_for_cookies, if non-empty, is the new cookie policy URL
   // for the redirected URL.  If the cookie policy URL needs changing, pass
   // true as has_new_first_party_for_cookies and the new cookie policy URL as
   // new_first_party_for_cookies.  Otherwise, pass false as
   // has_new_first_party_for_cookies, and new_first_party_for_cookies will not
   // be used.
-  void FollowDeferredRedirect(int process_unique_id,
+  void FollowDeferredRedirect(int child_id,
                               int request_id,
                               bool has_new_first_party_for_cookies,
                               const GURL& new_first_party_for_cookies);
 
   // Starts a request that was deferred during ResourceHandler::OnWillStart().
-  void StartDeferredRequest(int process_unique_id, int request_id);
+  void StartDeferredRequest(int child_id, int request_id);
 
   // Returns true if it's ok to send the data. If there are already too many
   // data messages pending, it pauses the request and returns false. In this
   // case the caller should not send the data.
-  bool WillSendData(int process_unique_id, int request_id);
+  bool WillSendData(int child_id, int request_id);
 
   // Pauses or resumes network activity for a particular request.
-  void PauseRequest(int process_unique_id, int request_id, bool pause);
+  void PauseRequest(int child_id, int request_id, bool pause);
 
   // Returns the number of pending requests. This is designed for the unittests
   int pending_requests() const {
     return static_cast<int>(pending_requests_.size());
   }
 
   // Intended for unit-tests only. Returns the memory cost of all the
-  // outstanding requests (pending and blocked) for |process_unique_id|.
-  int GetOutstandingRequestsMemoryCost(int process_unique_id) const;
+  // outstanding requests (pending and blocked) for |child_id|.
+  int GetOutstandingRequestsMemoryCost(int child_id) const;
 
   // Intended for unit-tests only. Overrides the outstanding requests bound.
   void set_max_outstanding_requests_cost_per_process(int limit) {
     max_outstanding_requests_cost_per_process_ = limit;
   }
 
   // The average private bytes increase of the browser for each new pending
   // request. Experimentally obtained.
   static const int kAvgBytesPerOutstandingRequest = 4400;
 
   DownloadFileManager* download_file_manager() const {
     return download_file_manager_;
   }
 
   SaveFileManager* save_file_manager() const {
     return save_file_manager_;
   }
 
   // Called when the unload handler for a cross-site request has finished.
   void OnSwapOutACK(const ViewMsg_SwapOut_Params& params);
 
   // Called when the renderer loads a resource from its internal cache.
   void OnDidLoadResourceFromMemoryCache(const GURL& url,
                                         const std::string& security_info,
                                         const std::string& http_method,
                                         ResourceType::Type resource_type);
 
   // Force cancels any pending requests for the given process.
-  void CancelRequestsForProcess(int process_unique_id);
+  void CancelRequestsForProcess(int child_id);
 
   // Force cancels any pending requests for the given route id.  This method
   // acts like CancelRequestsForProcess when route_id is -1.
-  void CancelRequestsForRoute(int process_unique_id, int route_id);
+  void CancelRequestsForRoute(int child_id, int route_id);
 
   // Force cancels any pending requests for the given |context|. This is
   // necessary to ensure that before |context| goes away, all requests
   // for it are dead.
   void CancelRequestsForContext(const content::ResourceContext* context);
 
   // net::URLRequest::Delegate
   virtual void OnReceivedRedirect(net::URLRequest* request,
                                   const GURL& new_url,
                                   bool* defer_redirect) OVERRIDE;
@@ skipping 30 matching lines @@
   // such IDs associated with the request (such as non-page-related requests),
   // this function will return false and both out params will be -1.
   static bool RenderViewForRequest(const net::URLRequest* request,
                                    int* render_process_host_id,
                                    int* render_view_host_id);
 
   // Retrieves a net::URLRequest.  Must be called from the IO thread.
   net::URLRequest* GetURLRequest(
       const content::GlobalRequestID& request_id) const;
 
-  void RemovePendingRequest(int process_unique_id, int request_id);
+  void RemovePendingRequest(int child_id, int request_id);
 
   // Causes all new requests for the route identified by
-  // |process_unique_id| and |route_id| to be blocked (not being
+  // |child_id| and |route_id| to be blocked (not being
   // started) until ResumeBlockedRequestsForRoute or
   // CancelBlockedRequestsForRoute is called.
-  void BlockRequestsForRoute(int process_unique_id, int route_id);
+  void BlockRequestsForRoute(int child_id, int route_id);
 
   // Resumes any blocked request for the specified route id.
-  void ResumeBlockedRequestsForRoute(int process_unique_id, int route_id);
+  void ResumeBlockedRequestsForRoute(int child_id, int route_id);
 
   // Cancels any blocked request for the specified route id.
-  void CancelBlockedRequestsForRoute(int process_unique_id, int route_id);
+  void CancelBlockedRequestsForRoute(int child_id, int route_id);
 
   // Decrements the pending_data_count for the request and resumes
   // the request if it was paused due to too many pending data
   // messages sent.
-  void DataReceivedACK(int process_unique_id, int request_id);
+  void DataReceivedACK(int child_id, int request_id);
 
   // Maintains a collection of temp files created in support of
   // the download_to_file capability. Used to grant access to the
   // child process and to defer deletion of the file until it's
   // no longer needed.
   void RegisterDownloadedTempFile(
       int child_id, int request_id,
       webkit_blob::DeletableFileReference* reference);
   void UnregisterDownloadedTempFile(int child_id, int request_id);
 
@@ skipping 74 matching lines @@
   // Helper function that cancels |request|.  Returns whether the
   // request was actually cancelled.  If a renderer cancels a request
   // for a download, we ignore the cancellation.
   bool CancelRequestInternal(net::URLRequest* request, bool from_renderer);
 
   // Helper function that inserts |request| into the resource queue.
   void InsertIntoResourceQueue(
       net::URLRequest* request,
       const ResourceDispatcherHostRequestInfo& request_info);
 
-  // Updates the "cost" of outstanding requests for |process_unique_id|.
+  // Updates the "cost" of outstanding requests for |child_id|.
   // The "cost" approximates how many bytes are consumed by all the in-memory
   // data structures supporting this request (net::URLRequest object,
   // HttpNetworkTransaction, etc...).
   // The value of |cost| is added to the running total, and the resulting
   // sum is returned.
   int IncrementOutstandingRequestsMemoryCost(int cost,
-                                             int process_unique_id);
+                                             int child_id);
 
   // Estimate how much heap space |request| will consume to run.
   static int CalculateApproximateMemoryCost(net::URLRequest* request);
 
   // The list of all requests that we have pending. This list is not really
   // optimized, and assumes that we have relatively few requests pending at once
   // since some operations require brute-force searching of the list.
   //
   // It may be enhanced in the future to provide some kind of prioritization
   // mechanism. We should also consider a hashtable or binary tree if it turns
   // out we have a lot of things here.
   typedef std::map<content::GlobalRequestID, net::URLRequest*>
       PendingRequestList;
 
   // Deletes the pending request identified by the iterator passed in.
   // This function will invalidate the iterator passed in. Callers should
   // not rely on this iterator being valid on return.
   void RemovePendingRequest(const PendingRequestList::iterator& iter);
 
   // Notify our observers that we started receiving a response for a request.
-  void NotifyResponseStarted(net::URLRequest* request, int process_unique_id);
+  void NotifyResponseStarted(net::URLRequest* request, int child_id);
 
   // Notify our observers that a request has been redirected.
   void NotifyReceivedRedirect(net::URLRequest* request,
-                              int process_unique_id,
+                              int child_id,
                               const GURL& new_url);
 
   // Tries to handle the url with an external protocol. If the request is
   // handled, the function returns true. False otherwise.
   bool HandleExternalProtocol(int request_id,
-                              int process_unique_id,
+                              int child_id,
                               int route_id,
                               const GURL& url,
                               ResourceType::Type resource_type,
                               const net::URLRequestJobFactory& job_factory,
                               ResourceHandler* handler);
 
   // Checks all pending requests and updates the load states and upload
   // progress if necessary.
   void UpdateLoadStates();
 
   // Checks the upload state and sends an update if one is necessary.
   void MaybeUpdateUploadProgress(ResourceDispatcherHostRequestInfo *info,
                                  net::URLRequest *request);
 
   // Resumes or cancels (if |cancel_requests| is true) any blocked requests.
-  void ProcessBlockedRequestsForRoute(int process_unique_id,
+  void ProcessBlockedRequestsForRoute(int child_id,
                                       int route_id,
                                       bool cancel_requests);
 
   void OnRequestResource(const IPC::Message& msg,
                          int request_id,
                          const ResourceHostMsg_Request& request_data);
   void OnSyncLoad(int request_id,
                   const ResourceHostMsg_Request& request_data,
                   IPC::Message* sync_result);
   void BeginRequest(int request_id,
@@ skipping 88 matching lines @@
   base::WeakPtrFactory<ResourceDispatcherHost> weak_factory_;
 
   // True if the resource dispatcher host has been shut down.
   bool is_shutdown_;
 
   typedef std::vector<net::URLRequest*> BlockedRequestsList;
   typedef std::pair<int, int> ProcessRouteIDs;
   typedef std::map<ProcessRouteIDs, BlockedRequestsList*> BlockedRequestMap;
   BlockedRequestMap blocked_requests_map_;
 
-  // Maps the process_unique_ids to the approximate number of bytes
+  // Maps the child_ids to the approximate number of bytes
   // being used to service its resource requests. No entry implies 0 cost.
   typedef std::map<int, int> OutstandingRequestsMemoryCostMap;
   OutstandingRequestsMemoryCostMap outstanding_requests_memory_cost_map_;
 
   // |max_outstanding_requests_cost_per_process_| is the upper bound on how
   // many outstanding requests can be issued per child process host.
   // The constraint is expressed in terms of bytes (where the cost of
   // individual requests is given by CalculateApproximateMemoryCost).
   // The total number of outstanding requests is roughly:
   //   (max_outstanding_requests_cost_per_process_ /
@@ skipping 17 matching lines @@
   // Maps the request ID of request that is being transferred to a new RVH
   // to the respective request.
   typedef std::map<content::GlobalRequestID, net::URLRequest*>
       TransferredNavigations;
   TransferredNavigations transferred_navigations_;
 
   DISALLOW_COPY_AND_ASSIGN(ResourceDispatcherHost);
 };
 
 #endif  // CONTENT_BROWSER_RENDERER_HOST_RESOURCE_DISPATCHER_HOST_H_