Preliminary work on resuming downloads whose connections have expired.

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
 
 #ifndef CHROME_BROWSER_RENDERER_HOST_RESOURCE_DISPATCHER_HOST_H_
 #define CHROME_BROWSER_RENDERER_HOST_RESOURCE_DISPATCHER_HOST_H_
 #pragma once
 
 #include <map>
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/gtest_prod_util.h"
 #include "base/observer_list.h"
 #include "base/scoped_ptr.h"
 #include "base/timer.h"
 #include "chrome/common/child_process_info.h"
+#include "chrome/browser/renderer_host/global_request_id.h"
 #include "chrome/browser/renderer_host/resource_queue.h"
 #include "ipc/ipc_message.h"
 #include "net/url_request/url_request.h"
 #include "webkit/glue/resource_type.h"
 
 class CrossSiteResourceHandler;
 class DownloadFileManager;
 class DownloadRequestLimiter;
 class LoginHandler;
 class PluginService;
 class ResourceDispatcherHostRequestInfo;
 class ResourceHandler;
 class SafeBrowsingService;
 class SaveFileManager;
 class SocketStreamDispatcherHost;
 class SSLClientAuthHandler;
 class UserScriptListener;
 class URLRequestContext;
 class WebKitThread;
+struct DownloadCreateInfo;
 struct DownloadSaveInfo;
-struct GlobalRequestID;
 struct ViewHostMsg_Resource_Request;
 struct ViewMsg_ClosePage_Params;
 
 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.
   //
@@ skipping 47 matching lines @@
                          bool* message_was_ok);
 
   // Initiates a download from the browser process (as opposed to a resource
   // request from the renderer or another child process).
   void BeginDownload(const GURL& url,
                      const GURL& referrer,
                      const DownloadSaveInfo& save_info,
                      bool prompt_for_save_location,
                      int process_unique_id,
                      int route_id,
-                     URLRequestContext* request_context);
+                     URLRequestContext* request_context,
+                     uint64 start_offset);
 
   // 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 route_id,
                      URLRequestContext* request_context);
 
   // Cancels the given request if it still exists. We ignore cancels from the
@@ skipping 18 matching lines @@
   void StartDeferredRequest(int process_unique_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);
 
   // Pauses or resumes network activity for a particular request.
   void PauseRequest(int process_unique_id, int request_id, bool pause);
 
+  // Restarts network activity for a particular request.
+  void RestartRequest(int process_unique_id,
+                      int request_id,
+                      DownloadCreateInfo* info);
+
   // Returns the number of pending requests. This is designed for the unittests
-  int pending_requests() const {
+  int pending_request_count() const {
     return static_cast<int>(pending_requests_.size());
   }
 
+  int interrupted_request_count() const {
+    return static_cast<int>(interrupted_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;
 
   // 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
@@ skipping 71 matching lines @@
   // Removes an observer.
   void RemoveObserver(Observer* obs);
 
   // Retrieves a URLRequest.  Must be called from the IO thread.
   URLRequest* GetURLRequest(const GlobalRequestID& request_id) const;
 
   // Notifies our observers that a request has been cancelled.
   void NotifyResponseCompleted(URLRequest* request, int process_unique_id);
 
   void RemovePendingRequest(int process_unique_id, int request_id);
+  void RemoveInterruptedRequest(int process_unique_id, int request_id);
+  void MovePendingRequestToInterrupted(int process_unique_id, int request_id);
+  void MoveInterruptedRequestToPending(int process_unique_id, int request_id);
 
   // Causes all new requests for the route identified by
   // |process_unique_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);
 
   // Resumes any blocked request for the specified route id.
   void ResumeBlockedRequestsForRoute(int process_unique_id, int route_id);
 
@@ skipping 36 matching lines @@
 
   // A shutdown helper that runs on the IO thread.
   void OnShutdown();
 
   // Returns true if the request is paused.
   bool PauseRequestIfNeeded(ResourceDispatcherHostRequestInfo* info);
 
   // Resumes the given request by calling OnResponseStarted or OnReadCompleted.
   void ResumeRequest(const GlobalRequestID& request_id);
 
+  // Restarts the given request's download operation.
+  static void RestartDownload(ResourceDispatcherHost* rdh,
+                              const GlobalRequestID& request_id,
+                              DownloadCreateInfo* info);
+
   // Internal function to start reading for the first time.
   void StartReading(URLRequest* request);
 
   // Reads data from the response using our internal buffer as async IO.
   // Returns true if data is available immediately, false otherwise.  If the
   // return value is false, we will receive a OnReadComplete() callback later.
   bool Read(URLRequest* request, int* bytes_read);
 
   // Internal function to finish an async IO which has completed.  Returns
   // true if there is more data to read (e.g. we haven't read EOF yet and
@@ skipping 29 matching lines @@
 
   // 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<GlobalRequestID, URLRequest*> PendingRequestList;
 
+  // Accumulates matching requests from the given list.
+  std::vector<GlobalRequestID> GetMatchingRequests(
+      int process_unique_id,
+      int route_id,
+      const PendingRequestList& requests);
+
   // 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);
+  void RemoveRequestFromMap(const PendingRequestList::iterator& iter);
 
   // Notify our observers that we started receiving a response for a request.
   void NotifyResponseStarted(URLRequest* request, int process_unique_id);
 
   // Notify our observers that a request has been redirected.
   void NotifyReceivedRedirect(URLRequest* request,
                               int process_unique_id,
                               const GURL& new_url);
 
   // Tries to handle the url with an external protocol. If the request is
@@ skipping 29 matching lines @@
                     IPC::Message* sync_result,  // only valid for sync
                     int route_id);  // only valid for async
   void OnDataReceivedACK(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);
 
   ResourceHandler* CreateSafeBrowsingResourceHandler(
-      ResourceHandler* handler, int child_id, int route_id,
+      ResourceHandler* handler, int process_unique_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);
+      ResourceHandler* handler,
+      int process_unique_id,
+      int route_id,
+      bool download);
 
-  // Returns true if |request| is in |pending_requests_|.
+  // Returns true if |request| is in |pending_requests_| or
+  // |interrupted_requests_|.
   bool IsValidRequest(URLRequest* request);
 
+  // Returns true if |request| is in |interrupted_requests_|.
+  bool IsInterruptedRequest(URLRequest* request);
+
   // Returns true if the message passed in is a resource related message.
   static bool IsResourceDispatcherHostMessage(const IPC::Message&);
 
   // Sets replace_extension_localization_templates on all text/css requests that
   // have "chrome-extension://" scheme.
   static void ApplyExtensionLocalizationFilter(
       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_;
 
+  // This list contains all the interrupted requests.
+  PendingRequestList interrupted_requests_;
+
   // 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_