Add histograms to track the number of job controller and job that are

net/http/http_stream_factory_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.
 
 #include "net/http/http_stream_factory_impl.h"
 
 #include <string>
 #include <tuple>
 
 #include "base/logging.h"
@@ skipping 86 matching lines @@
 
 HttpStreamFactoryImpl::HttpStreamFactoryImpl(HttpNetworkSession* session,
                                              bool for_websockets)
     : session_(session),
       job_factory_(new DefaultJobFactory()),
       for_websockets_(for_websockets) {}
 
 HttpStreamFactoryImpl::~HttpStreamFactoryImpl() {
   DCHECK(request_map_.empty());
   DCHECK(spdy_session_request_map_.empty());
+  size_t alt_job_count = 0;
+  size_t main_job_count = 0;
+  size_t preconnect_controller_count = 0;

[Alexei Svitkine (slow), 2017/03/20 15:51:58]

Nit: Just use int since these are not compared with size_t types (like
vector.size()).

[xunjieli, 2017/03/20 16:37:35]

Is this written somewhere?
According to
https://chromium.googlesource.com/chromium/src/+/master/styleguide/c++/c++.md...
, for object counts, "size_t" is recommended.

[Alexei Svitkine (slow), 2017/03/20 16:56:04]

The normal C++ style guide suggests to use int types unless there's a reason not
to:
https://google.github.io/styleguide/cppguide.html#Integer_Types

In Chromium, often there's a reason to use size_t because those end up being
compared with standard library sizes - as I mentioned, but here it's not the
case. You only end up passing the values to the histogram macros, which end up
being a signed type (HistogramBase::Sample which is int32_t).

[Zhongyi Shi, 2017/03/20 21:26:35]

Done.

+  for (const auto& it : job_controller_set_) {
+    DCHECK(it->HasPendingAltJob() || it->HasPendingMainJob());
+    // For a preconnect controller, it should have exactly the main job.
+    if (it->is_preconnect()) {
+      preconnect_controller_count++;
+      continue;
+    }
+    // For non-preconnects.
+    if (it->HasPendingAltJob())
+      alt_job_count++;
+    if (it->HasPendingMainJob())
+      main_job_count++;
+  }
+  UMA_HISTOGRAM_COUNTS_1M("Net.JobControllerSet.CountOfPreconnect",
+                          preconnect_controller_count);
+  UMA_HISTOGRAM_COUNTS_1M("Net.JobControllerSet.CountOfNonPreconnectAltJob",
+                          alt_job_count);
+  UMA_HISTOGRAM_COUNTS_1M("Net.JobControllerSet.CountOfNonPreconnectMainJob",
+                          main_job_count);
 }
 
 HttpStreamRequest* HttpStreamFactoryImpl::RequestStream(
     const HttpRequestInfo& request_info,
     RequestPriority priority,
     const SSLConfig& server_ssl_config,
     const SSLConfig& proxy_ssl_config,
     HttpStreamRequest::Delegate* delegate,
     const NetLogWithSource& net_log) {
   DCHECK(!for_websockets_);
@@ skipping 255 matching lines @@
   factory_dump->AddScalar("main_job_count",
                           base::trace_event::MemoryAllocatorDump::kUnitsObjects,
                           main_job_count);
   // The number of preconnect controllers.
   factory_dump->AddScalar("preconnect_count",
                           base::trace_event::MemoryAllocatorDump::kUnitsObjects,
                           preconnect_controller_count);
 }
 
 }  // namespace net