Add a constraint on how many requests can be outstanding for any given render (browser-side).

chrome/browser/renderer_host/resource_dispatcher_host.h

 // Copyright (c) 2006-2008 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 RenderProcessHosts, and dispatches them to URLRequests. It then
 // fowards 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 63 matching lines @@
           pending_data_count(0),
           is_download(false),
           pause_count(0),
           mixed_content(mixed_content),
           resource_type(resource_type),
           filter_policy(FilterPolicy::DONT_FILTER),
           last_load_state(net::LOAD_STATE_IDLE),
           upload_size(upload_size),
           last_upload_position(0),
           waiting_for_upload_progress_ack(false),
+          memory_cost(0),
           is_paused(false),
           has_started_reading(false),
           paused_read_bytes(0) {
     }
 
     // Top-level ResourceHandler servicing this request.
     scoped_refptr<ResourceHandler> resource_handler;
 
     // CrossSiteResourceHandler for this request, if it is a cross-site request.
     // (NULL otherwise.)  This handler is part of the chain of ResourceHandlers
@@ skipping 34 matching lines @@
     net::LoadState last_load_state;
 
     uint64 upload_size;
 
     uint64 last_upload_position;
 
     base::TimeTicks last_upload_ticks;
 
     bool waiting_for_upload_progress_ack;
 
+    // The approximate in-memory size (bytes) that we credited this request
+    // as consuming in |outstanding_requests_memory_cost_map_|.
+    int memory_cost;
+
    private:
     // Request is temporarily not handling network data. Should be used only
     // by the ResourceDispatcherHost, not the event handlers.
     bool is_paused;
 
     // Whether this request has started reading any bytes from the response
     // yet.  Will be true after the first (unpaused) call to Read.
     bool has_started_reading;
 
     // How many bytes have been read while this request has been paused.
@@ skipping 91 matching lines @@
   // case the caller should not send the data.
   bool WillSendData(int render_process_host_id, int request_id);
 
   // Pauses or resumes network activity for a particular request.
   void PauseRequest(int render_process_host_id, int request_id, bool pause);
 
   // Returns the number of pending requests. This is designed for the unittests
   int pending_requests() const {
     return static_cast<int>(pending_requests_.size());
   }
+  
+  // Intended for unit-tests only. Returns the memory cost of all the
+  // outstanding requests (pending and blocked) for |render_process_host_id|.
+  int GetOutstandingRequestsMemoryCost(int render_process_host_id) const;
+
+  // Used by unit-tests to override the max outstanding requests constraint.
+  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
+  // request. Experimentally obtained.
+  static const int kAvgBytesPerOutstandingRequest = 4400;
 
   DownloadFileManager* download_file_manager() const {
     return download_file_manager_;
   }
 
   DownloadRequestManager* download_request_manager() const {
     return download_request_manager_.get();
   }
 
   SaveFileManager* save_file_manager() const {
@@ skipping 75 matching lines @@
   // Resumes any blocked request for the specified RenderView.
   void ResumeBlockedRequestsForRenderView(int render_process_host_id,
                                           int render_view_id);
 
   // Cancels any blocked request for the specified RenderView.
   void CancelBlockedRequestsForRenderView(int render_process_host_id,
                                           int render_view_id);
 
  private:
   FRIEND_TEST(ResourceDispatcherHostTest, TestBlockedRequestsProcessDies);
+  FRIEND_TEST(ResourceDispatcherHostTest,
+              IncrementOutstandingRequestsMemoryCost);
+  FRIEND_TEST(ResourceDispatcherHostTest,
+              CalculateApproximateMemoryCost);
+
   class ShutdownTask;
 
   friend class ShutdownTask;
 
   struct BlockedRequest {
     BlockedRequest(URLRequest* url_request, bool mixed_content)
         : url_request(url_request),
           mixed_content(mixed_content) {
     }
     URLRequest* url_request;
@@ skipping 27 matching lines @@
   // renderer in the event of a download. If |allow_delete| is true and no IO
   // is pending, the request is removed and deleted.
   void CancelRequest(int render_process_host_id,
                      int request_id,
                      bool from_renderer,
                      bool allow_delete);
 
   // Helper function for regular and download requests.
   void BeginRequestInternal(URLRequest* request, bool mixed_content);
 
+  // Updates the "cost" of outstanding requests for |render_process_host_id|.
+  // The "cost" approximates how many bytes are consumed by all the in-memory
+  // data structures supporting this request (URLRequest object,
+  // HttpNetworkTransaction, etc...).
+  // The value of |cost| is added to the running total, and the resulting
+  // sum is returned. 
+  int IncrementOutstandingRequestsMemoryCost(int cost,
+                                             int render_process_host_id);
+
+  // Estimate how much heap space |request| will consume to run.
+  static int CalculateApproximateMemoryCost(URLRequest* request);
+
   // 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;
 
   // Deletes the pending request identified by the iterator passed in.
@@ skipping 69 matching lines @@
   ScopedRunnableMethodFactory<ResourceDispatcherHost> method_runner_;
 
   // True if the resource dispatcher host has been shut down.
   bool is_shutdown_;
 
   typedef std::vector<BlockedRequest> BlockedRequestsList;
   typedef std::pair<int, int> ProcessRendererIDs;
   typedef std::map<ProcessRendererIDs, BlockedRequestsList*> BlockedRequestMap;
   BlockedRequestMap blocked_requests_map_;
 
+  // Maps the render_process_host_ids to the approximate number of bytes 
+  // being used to service its resource requests. No entry implies 0 cost.
+  typedef std::map<int, int> OutstandingRequestsMemoryCostMap;
+  OutstandingRequestsMemoryCostMap outstanding_requests_memory_cost_map_;
+
+  // |max_outstanding_requests_cost_per_process_| is the upper bound on how
+  // many outstanding requests can be issued per render process host.
+  // The constraint is expressed in terms of bytes (where the cost of
+  // individual requests is given by CalculateApproximateMemoryCost).
+  // The total number of outstanding requests is roughly:
+  //   (max_outstanding_requests_cost_per_process_ /
+  //       kAvgBytesPerOutstandingRequest)
+  int max_outstanding_requests_cost_per_process_;
+
   DISALLOW_COPY_AND_ASSIGN(ResourceDispatcherHost);
 };
 
 #endif  // CHROME_BROWSER_RENDERER_HOST_RESOURCE_DISPATCHER_HOST_H_