Add UMA for number of outstanding requests in ResourceDispatcherHostImpl

content/browser/loader/resource_dispatcher_host_impl.cc

 // Copyright (c) 2012 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/loader/resource_dispatcher_host_impl.h"
 
 #include <stddef.h>
 
@@ skipping 119 matching lines @@
 namespace content {
 
 namespace {
 
 static ResourceDispatcherHostImpl* g_resource_dispatcher_host;
 
 // The interval for calls to ResourceDispatcherHostImpl::UpdateLoadStates
 const int kUpdateLoadStatesIntervalMsec = 250;
 
 // Maximum byte "cost" of all the outstanding requests for a renderer.
-// See delcaration of |max_outstanding_requests_cost_per_process_| for details.
+// See declaration 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;
@@ skipping 192 matching lines @@
     CreateDownloadHandlerIntercept download_handler_intercept,
     const scoped_refptr<base::SingleThreadTaskRunner>& io_thread_runner)
     : request_id_(-1),
       is_shutdown_(false),
       num_in_flight_requests_(0),
       max_num_in_flight_requests_(base::SharedMemory::GetHandleLimit()),
       max_num_in_flight_requests_per_process_(static_cast<int>(
           max_num_in_flight_requests_ * kMaxRequestsPerProcessRatio)),
       max_outstanding_requests_cost_per_process_(
           kMaxOutstandingRequestsCostPerProcess),
+      largest_outstanding_request_count_seen_(0),
+      largest_outstanding_request_per_process_count_seen_(0),
       delegate_(nullptr),
       loader_delegate_(nullptr),
       allow_cross_origin_auth_prompt_(false),
       create_download_handler_intercept_(download_handler_intercept),
       main_thread_task_runner_(base::ThreadTaskRunnerHandle::Get()),
       io_thread_task_runner_(io_thread_runner) {
   DCHECK(main_thread_task_runner_->BelongsToCurrentThread());
   DCHECK(!g_resource_dispatcher_host);
   g_resource_dispatcher_host = this;
 
@@ skipping 1534 matching lines @@
   // in-flight requests for this process, in case we need to transfer it to
   // another process. This should be a toggle.
   DCHECK_NE(info->counted_as_in_flight_request(), count > 0);
   info->set_counted_as_in_flight_request(count > 0);
 
   OustandingRequestsStats stats = GetOutstandingRequestsStats(*info);
   stats.num_requests += count;
   DCHECK_GE(stats.num_requests, 0);
   UpdateOutstandingRequestsStats(*info, stats);
 
+  if (num_in_flight_requests_ > largest_outstanding_request_count_seen_) {

[Charlie Harrison, 2017/04/19 23:08:28]

I wonder if this would be better logged in Shutdown? Then you only get the max
requests for a given session.

[xunjieli, 2017/04/20 13:34:11]

Similar to crbug.com/704988, Chrome on Android never shuts down and some users 
seldom shut down their browser. 

[Charlie Harrison, 2017/04/20 13:39:16]

OK, this LGTM but it would be preferable to hook into NetworkMetricsProvider if
it's feasible.

[xunjieli, 2017/04/20 20:06:08]

Acknowledged. I didn't find a way to hook it up with NetworkMetricsProvider. I
don't think content/ can depend on components/, can it?

[Charlie Harrison, 2017/04/20 20:09:14]

One possible way to implement it would be to pull information out of the RDH
singleton in the component. It's pretty ugly though. We'd have to change it for
the network service later too. Let's just land this, and loop back if we think
the data is not up to snuff.

[xunjieli, 2017/04/20 20:14:15]

Acknowledged. Thanks.

+    largest_outstanding_request_count_seen_ = num_in_flight_requests_;
+    UMA_HISTOGRAM_COUNTS_1M(
+        "Net.ResourceDispatcherHost.OutstandingRequests.Total",
+        largest_outstanding_request_count_seen_);
+  }
+
+  if (stats.num_requests > largest_outstanding_request_count_seen_) {
+    largest_outstanding_request_per_process_count_seen_ = stats.num_requests;
+    UMA_HISTOGRAM_COUNTS_1M(
+        "Net.ResourceDispatcherHost.OutstandingRequests.PerProcess",
+        largest_outstanding_request_per_process_count_seen_);
+  }
+
   return stats;
 }
 
 bool ResourceDispatcherHostImpl::HasSufficientResourcesForRequest(
     net::URLRequest* request) {
   ResourceRequestInfoImpl* info = ResourceRequestInfoImpl::ForRequest(request);
   OustandingRequestsStats stats = IncrementOutstandingRequestsCount(1, info);
 
   if (stats.num_requests > max_num_in_flight_requests_per_process_)
     return false;
@@ skipping 709 matching lines @@
                                  &throttles);
     if (!throttles.empty()) {
       handler.reset(new ThrottlingResourceHandler(std::move(handler), request,
                                                   std::move(throttles)));
     }
   }
   return handler;
 }
 
 }  // namespace content