Add load flag indicating a request is probably the result of a user gesture.

content/browser/renderer_host/resource_dispatcher_host.cc

 // Copyright (c) 2011 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 "content/browser/renderer_host/resource_dispatcher_host.h"
 
 #include <set>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/shared_memory.h"
 #include "base/stl_util.h"
-#include "base/time.h"
 #include "chrome/browser/download/download_file_manager.h"
 #include "chrome/browser/download/download_manager.h"
 #include "chrome/browser/download/download_request_limiter.h"
 #include "chrome/browser/download/download_util.h"
 #include "chrome/browser/renderer_host/download_resource_handler.h"
 #include "content/browser/appcache/chrome_appcache_service.h"
 #include "content/browser/cert_store.h"
 #include "content/browser/child_process_security_policy.h"
 #include "content/browser/chrome_blob_storage_context.h"
 #include "content/browser/content_browser_client.h"
@@ skipping 77 matching lines @@
 
 // Maximum number of pending data messages sent to the renderer at any
 // given time for a given request.
 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.
 const int kMaxOutstandingRequestsCostPerProcess = 26214400;
 
+// The number of milliseconds after noting a user gesture that we will
+// tag newly-created URLRequest objects with the
+// net::LOAD_MAYBE_USER_GESTURE load flag. This is a fairly arbitrary
+// guess at how long to expect direct impact from a user gesture, but
+// this should be OK as the load flag is a best-effort thing only,
+// rather than being intended as fully accurate.
+const int kUserGestureWindowMs = 3500;
+
 // All possible error codes from the network module. Note that the error codes
 // are all positive (since histograms expect positive sample values).
 const int kAllNetErrorCodes[] = {
 #define NET_ERROR(label, value) -(value),
 #include "net/base/net_error_list.h"
 #undef NET_ERROR
 };
 
 // Aborts a request before an URLRequest has actually been created.
 void AbortRequestBeforeItStarts(ResourceMessageFilter* filter,
@@ skipping 1273 matching lines @@
 
   // Note that this expression will typically be dominated by:
   // |kAvgBytesPerOutstandingRequest|.
   return kAvgBytesPerOutstandingRequest + strings_cost + upload_cost;
 }
 
 void ResourceDispatcherHost::BeginRequestInternal(net::URLRequest* request) {
   DCHECK(!request->is_pending());
   ResourceDispatcherHostRequestInfo* info = InfoForRequest(request);
 
+  if ((TimeTicks::Now() - last_user_gesture_time_) <
+      TimeDelta::FromMilliseconds(kUserGestureWindowMs)) {
+    request->set_load_flags(
+        request->load_flags() | net::LOAD_MAYBE_USER_GESTURE);
+  }
+
   // Add the memory estimate that starting this request will consume.
   info->set_memory_cost(CalculateApproximateMemoryCost(request));
   int memory_cost = IncrementOutstandingRequestsMemoryCost(info->memory_cost(),
                                                            info->child_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 "SimulateError()" as a way of setting the net::URLRequest's
     // status -- it has no effect beyond this, since the request hasn't started.
@@ skipping 245 matching lines @@
                                                     request->status(),
                                                     security_info)) {
 
     // The request is complete so we can remove it.
     RemovePendingRequest(info->child_id(), info->request_id());
   }
   // If the handler's OnResponseCompleted returns false, we are deferring the
   // call until later.  We will notify the world and clean up when we resume.
 }
 
+void ResourceDispatcherHost::OnUserGesture(TabContents* tab) {
+  download_request_limiter()->OnUserGesture(tab);
+
+  last_user_gesture_time_ = TimeTicks::Now();
+}
+
 // static
 ResourceDispatcherHostRequestInfo* ResourceDispatcherHost::InfoForRequest(
     net::URLRequest* request) {
   // Avoid writing this function twice by casting the const version.
   const net::URLRequest* const_request = request;
   return const_cast<ResourceDispatcherHostRequestInfo*>(
       InfoForRequest(const_request));
 }
 
 // static
@@ skipping 419 matching lines @@
   return HTTP_AUTH_RESOURCE_BLOCKED_CROSS;
 }
 
 bool ResourceDispatcherHost::allow_cross_origin_auth_prompt() {
   return allow_cross_origin_auth_prompt_;
 }
 
 void ResourceDispatcherHost::set_allow_cross_origin_auth_prompt(bool value) {
   allow_cross_origin_auth_prompt_ = value;
 }