Add ResourceRequestInfo.

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 14 matching lines @@
 #include "base/timer.h"
 #include "content/browser/download/download_resource_handler.h"
 #include "content/common/content_export.h"
 #include "content/public/browser/child_process_data.h"
 #include "content/public/browser/notification_types.h"
 #include "ipc/ipc_message.h"
 #include "net/url_request/url_request.h"
 #include "webkit/glue/resource_type.h"
 
 class DownloadFileManager;
-class ResourceDispatcherHostRequestInfo;
 class ResourceHandler;
 class ResourceMessageFilter;
 class SaveFileManager;
 class TabContents;
 struct DownloadSaveInfo;
 struct ResourceHostMsg_Request;
 struct ViewMsg_SwapOut_Params;
 
 namespace content {
 class ResourceContext;
 class ResourceDispatcherHostDelegate;
+class ResourceRequestInfoImpl;
 struct GlobalRequestID;
 }
 
 namespace net {
 class CookieList;
 class URLRequestJobFactory;
 }  // namespace net
 
 namespace webkit_blob {
 class ShareableFileReference;
@@ skipping 133 matching lines @@
                             const std::string& cookie_line,
                             net::CookieOptions* options) const OVERRIDE;
   virtual void OnResponseStarted(net::URLRequest* request) OVERRIDE;
   virtual void OnReadCompleted(net::URLRequest* request,
                                int bytes_read) OVERRIDE;
 
   void OnUserGesture(TabContents* tab);
 
   // Helper functions to get the dispatcher's request info for the request.
   // If the dispatcher didn't create the request then NULL is returned.
-  static ResourceDispatcherHostRequestInfo* InfoForRequest(
+  static content::ResourceRequestInfoImpl* InfoForRequest(
       net::URLRequest* request);
-  static const ResourceDispatcherHostRequestInfo* InfoForRequest(
+  static const content::ResourceRequestInfoImpl* InfoForRequest(
       const net::URLRequest* request);
 
   // Extracts the render view/process host's identifiers from the given request
   // and places them in the given out params (both required). If there are no
   // 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);
 
@@ skipping 59 matching lines @@
 
   scoped_refptr<ResourceHandler> CreateResourceHandlerForDownload(
       net::URLRequest* request,
       content::ResourceContext* context,
       int child_id,
       int route_id,
       int request_id,
       const DownloadSaveInfo& save_info,
       const DownloadResourceHandler::OnStartedCallback& started_cb);
 
+  static void ClearLoginDelegate(net::URLRequest* request);
+
  private:
   FRIEND_TEST_ALL_PREFIXES(ResourceDispatcherHostTest,
                            TestBlockedRequestsProcessDies);
   FRIEND_TEST_ALL_PREFIXES(ResourceDispatcherHostTest,
                            IncrementOutstandingRequestsMemoryCost);
   FRIEND_TEST_ALL_PREFIXES(ResourceDispatcherHostTest,
                            CalculateApproximateMemoryCost);
 
   class ShutdownTask;
 
   friend class ShutdownTask;
 
-  // Associates the given info with the given request. The info will then be
-  // owned by the request.
-  void SetRequestInfo(net::URLRequest* request,
-                      ResourceDispatcherHostRequestInfo* info);
-
   // A shutdown helper that runs on the IO thread.
   void OnShutdown();
 
   void StartRequest(net::URLRequest* request);
 
   // Returns true if the request is paused.
-  bool PauseRequestIfNeeded(ResourceDispatcherHostRequestInfo* info);
+  bool PauseRequestIfNeeded(content::ResourceRequestInfoImpl* info);
 
   // Resumes the given request by calling OnResponseStarted or OnReadCompleted.
   void ResumeRequest(const content::GlobalRequestID& request_id);
 
   // Internal function to start reading for the first time.
   void StartReading(net::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.
@@ skipping 62 matching lines @@
                               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,
+  void MaybeUpdateUploadProgress(content::ResourceRequestInfoImpl *info,
                                  net::URLRequest *request);
 
   // Resumes or cancels (if |cancel_requests| is true) any blocked requests.
   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,
                     const ResourceHostMsg_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 OnTransferRequestToNewPage(int new_routing_id, 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);
 
-  // Creates ResourceDispatcherHostRequestInfo for a download or page save.
+  // Creates ResourceRequestInfoImpl for a download or page save.
   // |download| should be true if the request is a file download.
-  ResourceDispatcherHostRequestInfo* CreateRequestInfo(
+  content::ResourceRequestInfoImpl* CreateRequestInfo(
       ResourceHandler* handler,
       int child_id,
       int route_id,
       bool download,
       content::ResourceContext* context);
 
   // Returns true if |request| is in |pending_requests_|.
   bool IsValidRequest(net::URLRequest* request);
 
   // Sends the given notification on the UI thread.  The RenderViewHost's
@@ skipping 94 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_