Flesh out URLLoader's download_to_file function....

chrome/browser/renderer_host/resource_dispatcher_host.h

 // Copyright (c) 2010 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 29 matching lines @@
 class SocketStreamDispatcherHost;
 class SSLClientAuthHandler;
 class UserScriptListener;
 class URLRequestContext;
 class WebKitThread;
 struct DownloadSaveInfo;
 struct GlobalRequestID;
 struct ViewHostMsg_Resource_Request;
 struct ViewMsg_ClosePage_Params;
 
+namespace webkit_blob {
+class DeletableFileReference;
+}
+
 class ResourceDispatcherHost : public URLRequest::Delegate {
  public:
   // Implemented by the client of ResourceDispatcherHost to receive messages in
   // response to a resource load.  The messages are intended to be forwarded to
   // the ResourceDispatcher in the child process via an IPC channel that the
   // client manages.
   //
   // NOTE: This class unfortunately cannot be named 'Delegate' because that
   // conflicts with the name of ResourceDispatcherHost's base class.
   //
@@ skipping 197 matching lines @@
   void ResumeBlockedRequestsForRoute(int process_unique_id, int route_id);
 
   // Cancels any blocked request for the specified route id.
   void CancelBlockedRequestsForRoute(int process_unique_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);
 
+  // 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 receiver_id, int request_id,
+      webkit_blob::DeletableFileReference* reference);
+  void UnregisterDownloadedTempFile(int receiver_id, int request_id);
+
   // Needed for the sync IPC message dispatcher macros.
   bool Send(IPC::Message* message);
 
   // Controls if we launch or squash prefetch requests as they arrive
   // from renderers.
   static bool is_prefetch_enabled();
   static void set_is_prefetch_enabled(bool value);
 
  private:
   FRIEND_TEST_ALL_PREFIXES(ResourceDispatcherHostTest,
@@ skipping 113 matching lines @@
                          int request_id,
                          const ViewHostMsg_Resource_Request& request_data);
   void OnSyncLoad(int request_id,
                   const ViewHostMsg_Resource_Request& request_data,
                   IPC::Message* sync_result);
   void BeginRequest(int request_id,
                     const ViewHostMsg_Resource_Request& request_data,
                     IPC::Message* sync_result,  // only valid for sync
                     int route_id);  // only valid for async
   void OnDataReceivedACK(int request_id);
+  void OnDataDownloadedACK(int request_id);
   void OnUploadProgressACK(int request_id);
   void OnCancelRequest(int request_id);
   void OnFollowRedirect(int request_id,
                         bool has_new_first_party_for_cookies,
                         const GURL& new_first_party_for_cookies);
+  void OnReleaseDownloadedFile(int request_id);
 
   ResourceHandler* CreateSafeBrowsingResourceHandler(
       ResourceHandler* handler, int child_id, int route_id,
       ResourceType::Type resource_type);
 
   // Creates ResourceDispatcherHostRequestInfo for a browser-initiated request
   // (a download or a page save). |download| should be true if the request
   // is a file download.
   ResourceDispatcherHostRequestInfo* CreateRequestInfoForBrowserRequest(
       ResourceHandler* handler, int child_id, int route_id, bool download);
@@ skipping 10 matching lines @@
       const GURL& url,
       const ResourceType::Type& resource_type,
       ResourceDispatcherHostRequestInfo* request_info);
 
   // Determine request priority based on how critical this resource typically
   // is to user-perceived page load performance.
   static net::RequestPriority DetermineRequestPriority(ResourceType::Type type);
 
   PendingRequestList pending_requests_;
 
+  // Collection of temp files downloaded for child processes via
+  // the download_to_file mechanism. We avoid deleting them until
+  // the client no longer needs them.
+  typedef std::map<int, scoped_refptr<webkit_blob::DeletableFileReference> >
+      DeletableFilesMap;  // key is request id
+  typedef std::map<int, DeletableFilesMap>
+      RegisteredTempFiles;  // key is child process id
+  RegisteredTempFiles registered_temp_files_;
+
   // A timer that periodically calls UpdateLoadStates while pending_requests_
   // is not empty.
   base::RepeatingTimer<ResourceDispatcherHost> update_load_states_timer_;
 
   // Handles the resource requests from the moment we want to start them.
   ResourceQueue resource_queue_;
 
   // We own the download file writing thread and manager
   scoped_refptr<DownloadFileManager> download_file_manager_;
 
@@ skipping 52 matching lines @@
   // Used during IPC message dispatching so that the handlers can get a pointer
   // to the source of the message.
   Receiver* receiver_;
 
   static bool is_prefetch_enabled_;
 
   DISALLOW_COPY_AND_ASSIGN(ResourceDispatcherHost);
 };
 
 #endif  // CHROME_BROWSER_RENDERER_HOST_RESOURCE_DISPATCHER_HOST_H_