src/content/browser/loader/resource_dispatcher_host_impl.h

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 // This is the browser side of the resource dispatcher, it receives requests
   6 // from the child process (i.e. [Renderer, Plugin, Worker]ProcessHost), and
   7 // dispatches them to URLRequests. It then forwards the messages from the
   8 // URLRequests back to the correct process for handling.
   9 //
  10 // See http://dev.chromium.org/developers/design-documents/multi-process-resource-loading
  11
  12 #ifndef CONTENT_BROWSER_LOADER_RESOURCE_DISPATCHER_HOST_IMPL_H_
  13 #define CONTENT_BROWSER_LOADER_RESOURCE_DISPATCHER_HOST_IMPL_H_
  14
  15 #include <map>
  16 #include <set>
  17 #include <string>
  18 #include <vector>
  19
  20 #include "base/basictypes.h"
  21 #include "base/gtest_prod_util.h"
  22 #include "base/memory/linked_ptr.h"
  23 #include "base/memory/scoped_ptr.h"
  24 #include "base/observer_list.h"
  25 #include "base/time/time.h"
  26 #include "base/timer/timer.h"
  27 #include "content/browser/download/download_resource_handler.h"
  28 #include "content/browser/loader/global_routing_id.h"
  29 #include "content/browser/loader/offline_policy.h"
  30 #include "content/browser/loader/resource_loader.h"
  31 #include "content/browser/loader/resource_loader_delegate.h"
  32 #include "content/browser/loader/resource_scheduler.h"
  33 #include "content/common/content_export.h"
  34 #include "content/public/browser/child_process_data.h"
  35 #include "content/public/browser/download_item.h"
  36 #include "content/public/browser/download_url_parameters.h"
  37 #include "content/public/browser/global_request_id.h"
  38 #include "content/public/browser/notification_types.h"
  39 #include "content/public/browser/resource_dispatcher_host.h"
  40 #include "ipc/ipc_message.h"
  41 #include "net/cookies/canonical_cookie.h"
  42 #include "net/url_request/url_request.h"
  43 #include "webkit/common/resource_type.h"
  44
  45 class ResourceHandler;
  46 struct ResourceHostMsg_Request;
  47
  48 namespace net {
  49 class URLRequestJobFactory;
  50 }
  51
  52 namespace webkit_blob {
  53 class ShareableFileReference;
  54 }
  55
  56 namespace content {
  57 class ResourceContext;
  58 class ResourceDispatcherHostDelegate;
  59 class ResourceMessageDelegate;
  60 class ResourceMessageFilter;
  61 class ResourceRequestInfoImpl;
  62 class SaveFileManager;
  63 class WebContentsImpl;
  64 struct DownloadSaveInfo;
  65 struct Referrer;
  66
  67 class CONTENT_EXPORT ResourceDispatcherHostImpl
  68     : public ResourceDispatcherHost,
  69       public ResourceLoaderDelegate {
  70  public:
  71   ResourceDispatcherHostImpl();
  72   virtual ~ResourceDispatcherHostImpl();
  73
  74   // Returns the current ResourceDispatcherHostImpl. May return NULL if it
  75   // hasn't been created yet.
  76   static ResourceDispatcherHostImpl* Get();
  77
  78   // ResourceDispatcherHost implementation:
  79   virtual void SetDelegate(ResourceDispatcherHostDelegate* delegate) OVERRIDE;
  80   virtual void SetAllowCrossOriginAuthPrompt(bool value) OVERRIDE;
  81   virtual net::Error BeginDownload(
  82       scoped_ptr<net::URLRequest> request,
  83       const Referrer& referrer,
  84       bool is_content_initiated,
  85       ResourceContext* context,
  86       int child_id,
  87       int route_id,
  88       bool prefer_cache,
  89       scoped_ptr<DownloadSaveInfo> save_info,
  90       uint32 download_id,
  91       const DownloadStartedCallback& started_callback) OVERRIDE;
  92   virtual void ClearLoginDelegateForRequest(net::URLRequest* request) OVERRIDE;
  93   virtual void BlockRequestsForRoute(int child_id, int route_id) OVERRIDE;
  94   virtual void ResumeBlockedRequestsForRoute(
  95       int child_id, int route_id) OVERRIDE;
  96
  97   // Puts the resource dispatcher host in an inactive state (unable to begin
  98   // new requests).  Cancels all pending requests.
  99   void Shutdown();
 100
 101   // Notify the ResourceDispatcherHostImpl of a new resource context.
 102   void AddResourceContext(ResourceContext* context);
 103
 104   // Notify the ResourceDispatcherHostImpl of a resource context destruction.
 105   void RemoveResourceContext(ResourceContext* context);
 106
 107   // Force cancels any pending requests for the given |context|. This is
 108   // necessary to ensure that before |context| goes away, all requests
 109   // for it are dead.
 110   void CancelRequestsForContext(ResourceContext* context);
 111
 112   // Returns true if the message was a resource message that was processed.
 113   // If it was, message_was_ok will be false iff the message was corrupt.
 114   bool OnMessageReceived(const IPC::Message& message,
 115                          ResourceMessageFilter* filter,
 116                          bool* message_was_ok);
 117
 118   // Initiates a save file from the browser process (as opposed to a resource
 119   // request from the renderer or another child process).
 120   void BeginSaveFile(const GURL& url,
 121                      const Referrer& referrer,
 122                      int child_id,
 123                      int route_id,
 124                      ResourceContext* context);
 125
 126   // Cancels the given request if it still exists. We ignore cancels from the
 127   // renderer in the event of a download.
 128   void CancelRequest(int child_id,
 129                      int request_id,
 130                      bool from_renderer);
 131
 132   // Marks the request as "parked". This happens if a request is
 133   // redirected cross-site and needs to be resumed by a new render view.
 134   void MarkAsTransferredNavigation(const GlobalRequestID& id,
 135                                    const GURL& target_url);
 136
 137   // Resumes the request without transferring it to a new render view.
 138   void ResumeDeferredNavigation(const GlobalRequestID& id);
 139
 140   // Returns the number of pending requests. This is designed for the unittests
 141   int pending_requests() const {
 142     return static_cast<int>(pending_loaders_.size());
 143   }
 144
 145   // Intended for unit-tests only. Overrides the outstanding requests bound.
 146   void set_max_outstanding_requests_cost_per_process(int limit) {
 147     max_outstanding_requests_cost_per_process_ = limit;
 148   }
 149   void set_max_num_in_flight_requests_per_process(int limit) {
 150     max_num_in_flight_requests_per_process_ = limit;
 151   }
 152   void set_max_num_in_flight_requests(int limit) {
 153     max_num_in_flight_requests_ = limit;
 154   }
 155
 156   // The average private bytes increase of the browser for each new pending
 157   // request. Experimentally obtained.
 158   static const int kAvgBytesPerOutstandingRequest = 4400;
 159
 160   SaveFileManager* save_file_manager() const {
 161     return save_file_manager_.get();
 162   }
 163
 164   // Called when a RenderViewHost is created.
 165   void OnRenderViewHostCreated(int child_id, int route_id);
 166
 167   // Called when a RenderViewHost is deleted.
 168   void OnRenderViewHostDeleted(int child_id, int route_id);
 169
 170   // Force cancels any pending requests for the given process.
 171   void CancelRequestsForProcess(int child_id);
 172
 173   void OnUserGesture(WebContentsImpl* contents);
 174
 175   // Retrieves a net::URLRequest.  Must be called from the IO thread.
 176   net::URLRequest* GetURLRequest(const GlobalRequestID& request_id);
 177
 178   void RemovePendingRequest(int child_id, int request_id);
 179
 180   // Cancels any blocked request for the specified route id.
 181   void CancelBlockedRequestsForRoute(int child_id, int route_id);
 182
 183   // Maintains a collection of temp files created in support of
 184   // the download_to_file capability. Used to grant access to the
 185   // child process and to defer deletion of the file until it's
 186   // no longer needed.
 187   void RegisterDownloadedTempFile(
 188       int child_id, int request_id,
 189       webkit_blob::ShareableFileReference* reference);
 190   void UnregisterDownloadedTempFile(int child_id, int request_id);
 191
 192   // Needed for the sync IPC message dispatcher macros.
 193   bool Send(IPC::Message* message);
 194
 195   // Indicates whether third-party sub-content can pop-up HTTP basic auth
 196   // dialog boxes.
 197   bool allow_cross_origin_auth_prompt();
 198
 199   ResourceDispatcherHostDelegate* delegate() {
 200     return delegate_;
 201   }
 202
 203   // Must be called after the ResourceRequestInfo has been created
 204   // and associated with the request.
 205   // |id| should be |content::DownloadItem::kInvalidId| to request automatic
 206   // assignment.
 207   scoped_ptr<ResourceHandler> CreateResourceHandlerForDownload(
 208       net::URLRequest* request,
 209       bool is_content_initiated,
 210       bool must_download,
 211       uint32 id,
 212       scoped_ptr<DownloadSaveInfo> save_info,
 213       const DownloadUrlParameters::OnStartedCallback& started_cb);
 214
 215   // Must be called after the ResourceRequestInfo has been created
 216   // and associated with the request.
 217   scoped_ptr<ResourceHandler> MaybeInterceptAsStream(
 218       net::URLRequest* request,
 219       ResourceResponse* response);
 220
 221   void ClearSSLClientAuthHandlerForRequest(net::URLRequest* request);
 222
 223   ResourceScheduler* scheduler() { return scheduler_.get(); }
 224
 225   // Called by a ResourceHandler when it's ready to start reading data and
 226   // sending it to the renderer. Returns true if there are enough file
 227   // descriptors available for the shared memory buffer. If false is returned,
 228   // the request should cancel.
 229   bool HasSufficientResourcesForRequest(const net::URLRequest* request_);
 230
 231   // Called by a ResourceHandler after it has finished its request and is done
 232   // using its shared memory buffer. Frees up that file descriptor to be used
 233   // elsewhere.
 234   void FinishedWithResourcesForRequest(const net::URLRequest* request_);
 235
 236  private:
 237   FRIEND_TEST_ALL_PREFIXES(ResourceDispatcherHostTest,
 238                            TestBlockedRequestsProcessDies);
 239   FRIEND_TEST_ALL_PREFIXES(ResourceDispatcherHostTest,
 240                            CalculateApproximateMemoryCost);
 241
 242   class ShutdownTask;
 243
 244   struct OustandingRequestsStats {
 245     int memory_cost;
 246     int num_requests;
 247   };
 248
 249   friend class ShutdownTask;
 250   friend class ResourceMessageDelegate;
 251
 252   // ResourceLoaderDelegate implementation:
 253   virtual ResourceDispatcherHostLoginDelegate* CreateLoginDelegate(
 254       ResourceLoader* loader,
 255       net::AuthChallengeInfo* auth_info) OVERRIDE;
 256   virtual bool AcceptAuthRequest(
 257       ResourceLoader* loader,
 258       net::AuthChallengeInfo* auth_info) OVERRIDE;
 259   virtual bool AcceptSSLClientCertificateRequest(
 260       ResourceLoader* loader,
 261       net::SSLCertRequestInfo* cert_info) OVERRIDE;
 262   virtual bool HandleExternalProtocol(ResourceLoader* loader,
 263                                       const GURL& url) OVERRIDE;
 264   virtual void DidStartRequest(ResourceLoader* loader) OVERRIDE;
 265   virtual void DidReceiveRedirect(ResourceLoader* loader,
 266                                   const GURL& new_url) OVERRIDE;
 267   virtual void DidReceiveResponse(ResourceLoader* loader) OVERRIDE;
 268   virtual void DidFinishLoading(ResourceLoader* loader) OVERRIDE;
 269
 270   // Extracts the render view/process host's identifiers from the given request
 271   // and places them in the given out params (both required). If there are no
 272   // such IDs associated with the request (such as non-page-related requests),
 273   // this function will return false and both out params will be -1.
 274   static bool RenderViewForRequest(const net::URLRequest* request,
 275                                    int* render_process_host_id,
 276                                    int* render_view_host_id);
 277
 278   // An init helper that runs on the IO thread.
 279   void OnInit();
 280
 281   // A shutdown helper that runs on the IO thread.
 282   void OnShutdown();
 283
 284   // Helper function for regular and download requests.
 285   void BeginRequestInternal(scoped_ptr<net::URLRequest> request,
 286                             scoped_ptr<ResourceHandler> handler);
 287
 288   void StartLoading(ResourceRequestInfoImpl* info,
 289                     const linked_ptr<ResourceLoader>& loader);
 290
 291   // We keep track of how much memory each request needs and how many requests
 292   // are issued by each renderer. These are known as OustandingRequestStats.
 293   // Memory limits apply to all requests sent to us by the renderers. There is a
 294   // limit for each renderer. File descriptor limits apply to requests that are
 295   // receiving their body. These are known as in-flight requests. There is a
 296   // global limit that applies for the browser process. Each render is allowed
 297   // to use up to a fraction of that.
 298
 299   // Returns the OustandingRequestsStats for |info|'s renderer, or an empty
 300   // struct if that renderer has no outstanding requests.
 301   OustandingRequestsStats GetOutstandingRequestsStats(
 302       const ResourceRequestInfoImpl& info);
 303
 304   // Updates |outstanding_requests_stats_map_| with the specified |stats| for
 305   // the renderer that made the request in |info|.
 306   void UpdateOutstandingRequestsStats(const ResourceRequestInfoImpl& info,
 307                                       const OustandingRequestsStats& stats);
 308
 309   // Called every time an outstanding request is created or deleted. |count|
 310   // indicates whether the request is new or deleted. |count| must be 1 or -1.
 311   OustandingRequestsStats IncrementOutstandingRequestsMemory(
 312       int count,
 313       const ResourceRequestInfoImpl& info);
 314
 315   // Called every time an in flight request is issued or finished. |count|
 316   // indicates whether the request is issuing or finishing. |count| must be 1
 317   // or -1.
 318   OustandingRequestsStats IncrementOutstandingRequestsCount(
 319       int count,
 320       const ResourceRequestInfoImpl& info);
 321
 322   // Estimate how much heap space |request| will consume to run.
 323   static int CalculateApproximateMemoryCost(net::URLRequest* request);
 324
 325   // Force cancels any pending requests for the given route id.  This method
 326   // acts like CancelRequestsForProcess when route_id is -1.
 327   void CancelRequestsForRoute(int child_id, int route_id);
 328
 329   // The list of all requests that we have pending. This list is not really
 330   // optimized, and assumes that we have relatively few requests pending at once
 331   // since some operations require brute-force searching of the list.
 332   //
 333   // It may be enhanced in the future to provide some kind of prioritization
 334   // mechanism. We should also consider a hashtable or binary tree if it turns
 335   // out we have a lot of things here.
 336   typedef std::map<GlobalRequestID, linked_ptr<ResourceLoader> > LoaderMap;
 337
 338   // Deletes the pending request identified by the iterator passed in.
 339   // This function will invalidate the iterator passed in. Callers should
 340   // not rely on this iterator being valid on return.
 341   void RemovePendingLoader(const LoaderMap::iterator& iter);
 342
 343   // Checks all pending requests and updates the load states and upload
 344   // progress if necessary.
 345   void UpdateLoadStates();
 346
 347   // Resumes or cancels (if |cancel_requests| is true) any blocked requests.
 348   void ProcessBlockedRequestsForRoute(int child_id,
 349                                       int route_id,
 350                                       bool cancel_requests);
 351
 352   void OnRequestResource(const IPC::Message& msg,
 353                          int request_id,
 354                          const ResourceHostMsg_Request& request_data);
 355   void OnSyncLoad(int request_id,
 356                   const ResourceHostMsg_Request& request_data,
 357                   IPC::Message* sync_result);
 358
 359   // Update the ResourceRequestInfo and internal maps when a request is
 360   // transferred from one process to another.
 361   void UpdateRequestForTransfer(int child_id,
 362                                 int route_id,
 363                                 int request_id,
 364                                 const ResourceHostMsg_Request& request_data,
 365                                 const linked_ptr<ResourceLoader>& loader);
 366
 367   void BeginRequest(int request_id,
 368                     const ResourceHostMsg_Request& request_data,
 369                     IPC::Message* sync_result,  // only valid for sync
 370                     int route_id);  // only valid for async
 371   void OnDataDownloadedACK(int request_id);
 372   void OnUploadProgressACK(int request_id);
 373   void OnCancelRequest(int request_id);
 374   void OnReleaseDownloadedFile(int request_id);
 375
 376   // Creates ResourceRequestInfoImpl for a download or page save.
 377   // |download| should be true if the request is a file download.
 378   ResourceRequestInfoImpl* CreateRequestInfo(
 379       int child_id,
 380       int route_id,
 381       bool download,
 382       ResourceContext* context);
 383
 384   // Relationship of resource being authenticated with the top level page.
 385   enum HttpAuthRelationType {
 386     HTTP_AUTH_RELATION_TOP,            // Top-level page itself
 387     HTTP_AUTH_RELATION_SAME_DOMAIN,    // Sub-content from same domain
 388     HTTP_AUTH_RELATION_BLOCKED_CROSS,  // Blocked Sub-content from cross domain
 389     HTTP_AUTH_RELATION_ALLOWED_CROSS,  // Allowed Sub-content per command line
 390     HTTP_AUTH_RELATION_LAST
 391   };
 392
 393   HttpAuthRelationType HttpAuthRelationTypeOf(const GURL& request_url,
 394                                               const GURL& first_party);
 395
 396   // Returns whether the URLRequest identified by |transferred_request_id| is
 397   // currently in the process of being transferred to a different renderer.
 398   // This happens if a request is redirected cross-site and needs to be resumed
 399   // by a new render view.
 400   bool IsTransferredNavigation(
 401       const GlobalRequestID& transferred_request_id) const;
 402
 403   ResourceLoader* GetLoader(const GlobalRequestID& id) const;
 404   ResourceLoader* GetLoader(int child_id, int request_id) const;
 405
 406   // Registers |delegate| to receive resource IPC messages targeted to the
 407   // specified |id|.
 408   void RegisterResourceMessageDelegate(const GlobalRequestID& id,
 409                                        ResourceMessageDelegate* delegate);
 410   void UnregisterResourceMessageDelegate(const GlobalRequestID& id,
 411                                          ResourceMessageDelegate* delegate);
 412
 413   int BuildLoadFlagsForRequest(const ResourceHostMsg_Request& request_data,
 414                                int child_id,
 415                                bool is_sync_load);
 416
 417   LoaderMap pending_loaders_;
 418
 419   // Collection of temp files downloaded for child processes via
 420   // the download_to_file mechanism. We avoid deleting them until
 421   // the client no longer needs them.
 422   typedef std::map<int, scoped_refptr<webkit_blob::ShareableFileReference> >
 423       DeletableFilesMap;  // key is request id
 424   typedef std::map<int, DeletableFilesMap>
 425       RegisteredTempFiles;  // key is child process id
 426   RegisteredTempFiles registered_temp_files_;
 427
 428   // A timer that periodically calls UpdateLoadStates while pending_requests_
 429   // is not empty.
 430   scoped_ptr<base::RepeatingTimer<ResourceDispatcherHostImpl> >
 431       update_load_states_timer_;
 432
 433   // We own the save file manager.
 434   scoped_refptr<SaveFileManager> save_file_manager_;
 435
 436   // Request ID for browser initiated requests. request_ids generated by
 437   // child processes are counted up from 0, while browser created requests
 438   // start at -2 and go down from there. (We need to start at -2 because -1 is
 439   // used as a special value all over the resource_dispatcher_host for
 440   // uninitialized variables.) This way, we no longer have the unlikely (but
 441   // observed in the real world!) event where we have two requests with the same
 442   // request_id_.
 443   int request_id_;
 444
 445   // True if the resource dispatcher host has been shut down.
 446   bool is_shutdown_;
 447
 448   typedef std::vector<linked_ptr<ResourceLoader> > BlockedLoadersList;
 449   typedef std::map<GlobalRoutingID, BlockedLoadersList*> BlockedLoadersMap;
 450   BlockedLoadersMap blocked_loaders_map_;
 451
 452   // Maps the child_ids to the approximate number of bytes
 453   // being used to service its resource requests. No entry implies 0 cost.
 454   typedef std::map<int, OustandingRequestsStats> OutstandingRequestsStatsMap;
 455   OutstandingRequestsStatsMap outstanding_requests_stats_map_;
 456
 457   // |num_in_flight_requests_| is the total number of requests currently issued
 458   // summed across all renderers.
 459   int num_in_flight_requests_;
 460
 461   // |max_num_in_flight_requests_| is the upper bound on how many requests
 462   // can be in flight at once. It's based on the maximum number of file
 463   // descriptors open per process. We need a global limit for the browser
 464   // process.
 465   int max_num_in_flight_requests_;
 466
 467   // |max_num_in_flight_requests_| is the upper bound on how many requests
 468   // can be issued at once. It's based on the maximum number of file
 469   // descriptors open per process. We need a per-renderer limit so that no
 470   // single renderer can hog the browser's limit.
 471   int max_num_in_flight_requests_per_process_;
 472
 473   // |max_outstanding_requests_cost_per_process_| is the upper bound on how
 474   // many outstanding requests can be issued per child process host.
 475   // The constraint is expressed in terms of bytes (where the cost of
 476   // individual requests is given by CalculateApproximateMemoryCost).
 477   // The total number of outstanding requests is roughly:
 478   //   (max_outstanding_requests_cost_per_process_ /
 479   //       kAvgBytesPerOutstandingRequest)
 480   int max_outstanding_requests_cost_per_process_;
 481
 482   // Time of the last user gesture. Stored so that we can add a load
 483   // flag to requests occurring soon after a gesture to indicate they
 484   // may be because of explicit user action.
 485   base::TimeTicks last_user_gesture_time_;
 486
 487   // Used during IPC message dispatching so that the handlers can get a pointer
 488   // to the source of the message.
 489   ResourceMessageFilter* filter_;
 490
 491   ResourceDispatcherHostDelegate* delegate_;
 492
 493   bool allow_cross_origin_auth_prompt_;
 494
 495   // http://crbug.com/90971 - Assists in tracking down use-after-frees on
 496   // shutdown.
 497   std::set<const ResourceContext*> active_resource_contexts_;
 498
 499   typedef std::map<GlobalRequestID,
 500                    ObserverList<ResourceMessageDelegate>*> DelegateMap;
 501   DelegateMap delegate_map_;
 502
 503   scoped_ptr<ResourceScheduler> scheduler_;
 504
 505   typedef std::map<GlobalRoutingID, OfflinePolicy*> OfflineMap;
 506
 507   OfflineMap offline_policy_map_;
 508
 509   DISALLOW_COPY_AND_ASSIGN(ResourceDispatcherHostImpl);
 510 };
 511
 512 }  // namespace content
 513
 514 #endif  // CONTENT_BROWSER_LOADER_RESOURCE_DISPATCHER_HOST_IMPL_H_