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

chrome/browser/renderer_host/resource_dispatcher_host.cc

 // 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.
 
 // See http://dev.chromium.org/developers/design-documents/multi-process-resource-loading
 
 #include <vector>
 
 #include "chrome/browser/renderer_host/resource_dispatcher_host.h"
 
@@ skipping 54 matching lines @@
 
 // ----------------------------------------------------------------------------
 
 // The interval for calls to ResourceDispatcherHost::UpdateLoadStates
 static const int kUpdateLoadStatesIntervalMsec = 100;
 
 // Maximum number of pending data messages sent to the renderer at any
 // given time for a given request.
 static const int kMaxPendingDataMessages = 20;
 
+// Maximum byte "cost" of all the outstanding requests for a renderer.
+// See delcaration of |max_outstanding_requests_cost_per_process_| for details.
+// This bound is 25MB, which allows for around 6000 outstanding requests.
+static const int kMaxOutstandingRequestsCostPerProcess = 26214400;
+
 // A ShutdownTask proxies a shutdown task from the UI thread to the IO thread.
 // It should be constructed on the UI thread and run in the IO thread.
 class ResourceDispatcherHost::ShutdownTask : public Task {
  public:
   explicit ShutdownTask(ResourceDispatcherHost* resource_dispatcher_host)
       : rdh_(resource_dispatcher_host) { }
 
   void Run() {
     rdh_->OnShutdown();
   }
@@ skipping 43 matching lines @@
 ResourceDispatcherHost::ResourceDispatcherHost(MessageLoop* io_loop)
     : ui_loop_(MessageLoop::current()),
       io_loop_(io_loop),
       download_file_manager_(new DownloadFileManager(ui_loop_, this)),
       download_request_manager_(new DownloadRequestManager(io_loop, ui_loop_)),
       save_file_manager_(new SaveFileManager(ui_loop_, io_loop, this)),
       safe_browsing_(new SafeBrowsingService),
       request_id_(-1),
       plugin_service_(PluginService::GetInstance()),
       method_runner_(this),
-      is_shutdown_(false) {
+      is_shutdown_(false),
+      max_outstanding_requests_cost_per_process_(kMaxOutstandingRequestsCostPerProcess) {
 }
 
 ResourceDispatcherHost::~ResourceDispatcherHost() {
   AsyncResourceHandler::GlobalCleanup();
   STLDeleteValues(&pending_requests_);
 
   // Clear blocked requests if any left.
   // Note that we have to do this in 2 passes as we cannot call
   // CancelBlockedRequestsForRenderView while iterating over
   // blocked_requests_map_, as it modifies it.
@@ skipping 412 matching lines @@
 
   // If we're resuming, kick the request to start reading again. Run the read
   // asynchronously to avoid recursion problems.
   if (info->pause_count == 0) {
     MessageLoop::current()->PostTask(FROM_HERE,
         method_runner_.NewRunnableMethod(
             &ResourceDispatcherHost::ResumeRequest, global_id));
   }
 }
 
+int ResourceDispatcherHost::GetOutstandingRequestsMemoryCost(
+    int render_process_host_id) const {
+  OutstandingRequestsMemoryCostMap::const_iterator entry =
+      outstanding_requests_memory_cost_map_.find(render_process_host_id);
+  return (entry == outstanding_requests_memory_cost_map_.end()) ?
+      0 : entry->second;
+}
+
 void ResourceDispatcherHost::OnClosePageACK(int render_process_host_id,
                                             int request_id) {
   GlobalRequestID global_id(render_process_host_id, request_id);
   PendingRequestList::iterator i = pending_requests_.find(global_id);
   if (i == pending_requests_.end()) {
     // If there are no matching pending requests, then this is not a
     // cross-site navigation and we are just closing the tab/browser.
     ui_loop_->PostTask(FROM_HERE, NewRunnableFunction(
         &RenderViewHost::ClosePageIgnoringUnloadEvents,
         render_process_host_id,
@@ skipping 86 matching lines @@
       GlobalRequestID(render_process_host_id, request_id));
   if (i == pending_requests_.end()) {
     NOTREACHED() << "Trying to remove a request that's not here";
     return;
   }
   RemovePendingRequest(i);
 }
 
 void ResourceDispatcherHost::RemovePendingRequest(
     const PendingRequestList::iterator& iter) {
+  ExtraRequestInfo* info = ExtraInfoForRequest(iter->second);
+
+  // Remove the memory credit that we added when pushing the request onto
+  // the pending list.
+  IncrementOutstandingRequestsMemoryCost(-1 * info->memory_cost,
+                                         info->render_process_host_id);
+
   // Notify the login handler that this request object is going away.
-  ExtraRequestInfo* info = ExtraInfoForRequest(iter->second);
   if (info && info->login_handler)
     info->login_handler->OnRequestCancelled();
 
   delete iter->second;
   pending_requests_.erase(iter);
 
   // If we have no more pending requests, then stop the load state monitor
   if (pending_requests_.empty())
     update_load_states_timer_.Stop();
 }
@@ skipping 127 matching lines @@
     DCHECK(!request->ssl_info().cert_status &&
            (request->ssl_info().security_bits == -1 ||
            request->ssl_info().security_bits == 0));
   }
 
   NotifyResponseStarted(request, info->render_process_host_id);
   return info->resource_handler->OnResponseStarted(info->request_id,
                                                    response.get());
 }
 
+int ResourceDispatcherHost::IncrementOutstandingRequestsMemoryCost(
+    int cost, int render_process_host_id) {
+  // Retrieve the previous value (defaulting to 0 if not found).
+  OutstandingRequestsMemoryCostMap::iterator prev_entry =
+      outstanding_requests_memory_cost_map_.find(render_process_host_id);
+  int new_cost = 0;
+  if (prev_entry != outstanding_requests_memory_cost_map_.end())
+    new_cost = prev_entry->second;
+
+  // Insert/update the total; delete entries when their value reaches 0.
+  new_cost += cost;
+  CHECK(new_cost >= 0);
+  if (new_cost == 0)
+    outstanding_requests_memory_cost_map_.erase(prev_entry);
+  else
+    outstanding_requests_memory_cost_map_[render_process_host_id] = new_cost;
+
+  return new_cost;
+}
+
+// static
+int ResourceDispatcherHost::CalculateApproximateMemoryCost(
+    URLRequest* request) {
+  // The following fields should be a minor size contribution (experimentally
+  // on the order of 100). However since they are variable length, it could
+  // in theory be a sizeable contribution.
+  int strings_cost = request->extra_request_headers().size() +
+                     request->original_url().spec().size() +
+                     request->referrer().size() +
+                     request->method().size();
+
+  int upload_cost = 0;
+
+  // TODO(eroman): don't enable the upload throttling until we have data
+  // showing what a reasonable limit is (restricting to 25MB of uploads may
+  // be too restrictive).
+#if 0
+  // Sum all the (non-file) upload data attached to the request, if any.
+  if (request->has_upload()) {
+    const std::vector<net::UploadData::Element>& uploads =
+        request->get_upload()->elements();
+    std::vector<net::UploadData::Element>::const_iterator iter;
+    for (iter = uploads.begin(); iter != uploads.end(); ++iter) {
+      if (iter->type() == net::UploadData::TYPE_BYTES) {
+        int64 element_size = iter->GetContentLength();
+        // This cast should not result in truncation.
+        upload_cost += static_cast<int>(element_size);
+      }
+    }
+  }
+#endif
+
+  // Note that this expression will typically be dominated by:
+  // |kAvgBytesPerOutstandingRequest|.
+  return kAvgBytesPerOutstandingRequest + strings_cost + upload_cost;
+}
+
 void ResourceDispatcherHost::BeginRequestInternal(URLRequest* request,
                                                   bool mixed_content) {
+  DCHECK(!request->is_pending());
   ExtraRequestInfo* info = ExtraInfoForRequest(request);
 
+  // Add the memory estimate that starting this request will consume.
+  info->memory_cost = CalculateApproximateMemoryCost(request);
+  int memory_cost = IncrementOutstandingRequestsMemoryCost(
+      info->memory_cost,
+      info->render_process_host_id);
+
+  // If enqueing/starting this request will exceed our per-process memory
+  // bound, abort it right away.
+  if (memory_cost > max_outstanding_requests_cost_per_process_) {
+    // We call "CancelWithError()" as a way of setting the URLRequest's
+    // status -- it has no effect beyond this, since the request hasn't started.
+    request->CancelWithError(net::ERR_INSUFFICIENT_RESOURCES);
+
+    // TODO(eroman): this is kinda funky -- we insert the unstarted request into
+    // |pending_requests_| simply to please OnResponseCompleted().
+    GlobalRequestID global_id(info->render_process_host_id, info->request_id);
+    pending_requests_[global_id] = request;
+    OnResponseCompleted(request);
+    return;
+  }
+
   std::pair<int, int> pair_id(info->render_process_host_id,
                               info->render_view_id);
   BlockedRequestMap::const_iterator iter = blocked_requests_map_.find(pair_id);
   if (iter != blocked_requests_map_.end()) {
     // The request should be blocked.
     iter->second->push_back(BlockedRequest(request, mixed_content));
     return;
   }
 
   GlobalRequestID global_id(info->render_process_host_id, info->request_id);
@@ skipping 470 matching lines @@
     return;
   }
 
   BlockedRequestsList* requests = iter->second;
 
   // Removing the vector from the map unblocks any subsequent requests.
   blocked_requests_map_.erase(iter);
 
   for (BlockedRequestsList::iterator req_iter = requests->begin();
        req_iter != requests->end(); ++req_iter) {
+    // Remove the memory credit that we added when pushing the request onto
+    // the blocked list.
+    ExtraRequestInfo* info = ExtraInfoForRequest(req_iter->url_request);
+    IncrementOutstandingRequestsMemoryCost(-1 * info->memory_cost,
+                                           info->render_process_host_id);
     if (cancel_requests)
       delete req_iter->url_request;
     else
       BeginRequestInternal(req_iter->url_request, req_iter->mixed_content);
   }
 
   delete requests;
 }