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