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 19 matching lines @@
       transport_security_state_(nullptr),
       cert_transparency_verifier_(nullptr),
       ct_policy_enforcer_(nullptr),
       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) const {
+  url_requests_.insert(request);
+  if (url_requests_.size() > largest_outstanding_requests_count_seen_) {
+    largest_outstanding_requests_count_seen_ = url_requests_.size();
+    UMA_HISTOGRAM_COUNTS_1M("Net.URLRequestContext.OutstandingRequests",
+                            largest_outstanding_requests_count_seen_);
+  }
+}
+
+void URLRequestContext::RemoveURLRequest(const URLRequest* request) const {
+  DCHECK_EQ(1u, url_requests_.count(request));
+  url_requests_.erase(request);
+}
+
 void URLRequestContext::AssertNoURLRequests() const {
-  int num_requests = url_requests_->size();
+  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();
+    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);
     base::debug::Alias(&num_requests);
     base::debug::Alias(&load_flags);
     CHECK(false) << "Leaked " << num_requests << " URLRequest(s). First URL: "
                  << request->url().spec().c_str() << ".";
   }
 }
 
 bool URLRequestContext::OnMemoryDump(
     const base::trace_event::MemoryDumpArgs& args,
     base::trace_event::ProcessMemoryDump* pmd) {
   if (!name_)
     name_ = "unknown";
 
   SSLClientSocketImpl::DumpSSLClientSessionMemoryStats(pmd);
 
   std::string dump_name =
       base::StringPrintf("net/url_request_context/%s/0x%" PRIxPTR, name_,
                          reinterpret_cast<uintptr_t>(this));
   base::trace_event::MemoryAllocatorDump* dump =
       pmd->CreateAllocatorDump(dump_name);
   dump->AddScalar(base::trace_event::MemoryAllocatorDump::kNameObjectCount,
                   base::trace_event::MemoryAllocatorDump::kUnitsObjects,
-                  url_requests_->size());
+                  url_requests_.size());
   HttpTransactionFactory* transaction_factory = http_transaction_factory();
   if (transaction_factory) {
     HttpNetworkSession* network_session = transaction_factory->GetSession();
     if (network_session)
       network_session->DumpMemoryStats(pmd, dump->absolute_name());
     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