Add UMA to track the number of live URLRequests.

net/url_request/url_request_context.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.
 
 #include "net/url_request/url_request_context.h"
 
 #include <inttypes.h>
 
 #include "base/compiler_specific.h"
 #include "base/debug/alias.h"
 #include "base/memory/ptr_util.h"
+#include "base/metrics/histogram_macros.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/trace_event/memory_allocator_dump.h"
 #include "base/trace_event/memory_dump_manager.h"
 #include "base/trace_event/memory_dump_request_args.h"
 #include "base/trace_event/process_memory_dump.h"
 #include "net/base/sdch_manager.h"
 #include "net/cookies/cookie_store.h"
 #include "net/dns/host_resolver.h"
@@ skipping 22 matching lines @@
       http_transaction_factory_(nullptr),
       job_factory_(nullptr),
       throttler_manager_(nullptr),
       backoff_manager_(nullptr),
       sdch_manager_(nullptr),
       network_quality_estimator_(nullptr),
       reporting_service_(nullptr),
       url_requests_(new std::set<const URLRequest*>),
       enable_brotli_(false),
       check_cleartext_permitted_(false),
-      name_(nullptr) {
+      name_(nullptr),
+      largest_outstanding_requests_count_seen_(0) {
   base::trace_event::MemoryDumpManager::GetInstance()->RegisterDumpProvider(
       this, "URLRequestContext", base::ThreadTaskRunnerHandle::Get());
 }
 
 URLRequestContext::~URLRequestContext() {
   AssertNoURLRequests();
   base::trace_event::MemoryDumpManager::GetInstance()->UnregisterDumpProvider(
       this);
 }
 
@@ skipping 50 matching lines @@
     NetworkTrafficAnnotationTag traffic_annotation) const {
   // |traffic_annotation| is just a tag that is extracted during static
   // code analysis and can be ignored here.
   return CreateRequest(url, priority, delegate);
 }
 
 void URLRequestContext::set_cookie_store(CookieStore* cookie_store) {
   cookie_store_ = cookie_store;
 }
 
+void URLRequestContext::InsertURLRequest(const URLRequest* request) {
+  url_requests_->insert(request);
+  if (url_requests_->size() > largest_outstanding_requests_count_seen_) {
+    largest_outstanding_requests_count_seen_ = url_requests_->size();

[xunjieli, 2017/04/25 21:21:20]

Matt: sorry, I might be missing something. How do I modify the tracking variable
(|largest_outstanding_requests_count_seen_|) while keeping InsertURLRequest() a
const method?

Thanks!

[mmenke, 2017/04/25 21:50:48]

I assume this doesn't build because InsertURLRequest is not const?

I had assumed that since this was modifying url_requests_, we had non-const
access to the URLRequestContext, but I guess we store it in a unique_ptr just to
get around this issue?  That seems weird....  I'd suggest just making this
mutable instead.

Sorry that I didn't realize that earlier.  This solution would have worked with
your original CL, but I didn't realize the unique_ptr magic.  I think combining
this with set insertion is prettier, anyways, though.

+    UMA_HISTOGRAM_COUNTS_1M("Net.URLRequestContext.OutstandingRequests",
+                            largest_outstanding_requests_count_seen_);
+  }
+}
+
+void URLRequestContext::RemoveURLRequest(const URLRequest* request) {
+  DCHECK_EQ(1u, url_requests_->count(request));
+  url_requests_->erase(request);
+}
+
 void URLRequestContext::AssertNoURLRequests() const {
   int num_requests = url_requests_->size();
   if (num_requests != 0) {
     // We're leaking URLRequests :( Dump the URL of the first one and record how
     // many we leaked so we have an idea of how bad it is.
     char url_buf[128];
     const URLRequest* request = *url_requests_->begin();
     base::strlcpy(url_buf, request->url().spec().c_str(), arraysize(url_buf));
     int load_flags = request->load_flags();
     base::debug::Alias(url_buf);
@@ skipping 28 matching lines @@
     HttpCache* http_cache = transaction_factory->GetCache();
     if (http_cache)
       http_cache->DumpMemoryStats(pmd, dump->absolute_name());
   }
   if (sdch_manager_)
     sdch_manager_->DumpMemoryStats(pmd, dump_name);
   return true;
 }
 
 }  // namespace net