Record resource scheduler UMA

content/browser/loader/resource_scheduler_unittest.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 "content/browser/loader/resource_scheduler.h"
 
 #include <memory>
 #include <utility>
 #include <vector>
 
 #include "base/memory/ptr_util.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/field_trial_param_associator.h"
 #include "base/run_loop.h"
 #include "base/strings/string_number_conversions.h"
+#include "base/test/histogram_tester.h"
 #include "base/test/mock_entropy_provider.h"
 #include "base/test/scoped_feature_list.h"
 #include "base/timer/mock_timer.h"
 #include "base/timer/timer.h"
 #include "content/public/browser/resource_context.h"
 #include "content/public/browser/resource_throttle.h"
 #include "content/public/test/mock_render_process_host.h"
 #include "content/public/test/test_browser_context.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "content/test/test_render_view_host_factory.h"
 #include "content/test/test_web_contents.h"
 #include "net/base/host_port_pair.h"
 #include "net/base/request_priority.h"
 #include "net/http/http_server_properties_impl.h"
 #include "net/traffic_annotation/network_traffic_annotation_test_helper.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_test_util.h"
+#include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/latency/latency_info.h"
 #include "url/scheme_host_port.h"
 
 using std::string;
 
 namespace content {
 
 namespace {
 
@@ skipping 455 matching lines @@
   EXPECT_TRUE(low_spdy->started());
   EXPECT_FALSE(low->started());
 
   scheduler()->OnWillInsertBody(kChildId, kRouteId);
   high.reset();
   base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(low->started());
 }
 
 TEST_F(ResourceSchedulerTest, NavigationResetsState) {
+  base::HistogramTester histogram_tester;
   scheduler()->OnWillInsertBody(kChildId, kRouteId);
   scheduler()->OnNavigate(kChildId, kRouteId);
-  std::unique_ptr<TestRequest> high(
-      NewRequest("http://host/high", net::HIGHEST));
-  std::unique_ptr<TestRequest> low(NewRequest("http://host/low", net::LOWEST));
-  std::unique_ptr<TestRequest> low2(NewRequest("http://host/low", net::LOWEST));
-  EXPECT_TRUE(high->started());
-  EXPECT_TRUE(low->started());
-  EXPECT_FALSE(low2->started());
+
+  {
+    std::unique_ptr<TestRequest> high(
+        NewRequest("http://host/high", net::HIGHEST));
+    std::unique_ptr<TestRequest> low(
+        NewRequest("http://host/low", net::LOWEST));
+    std::unique_ptr<TestRequest> low2(
+        NewRequest("http://host/low", net::LOWEST));
+    EXPECT_TRUE(high->started());
+    EXPECT_TRUE(low->started());
+    EXPECT_FALSE(low2->started());
+  }
+
+  // Two samples are added when |high| and |low| are started. Two samples are
+  // added when |low| and |high| are erased.
+  histogram_tester.ExpectTotalCount("ResourceScheduler.RequestsCount.All", 4);
+  EXPECT_THAT(
+      histogram_tester.GetAllSamples("ResourceScheduler.RequestsCount.All"),
+      testing::ElementsAre(base::Bucket(0, 1), base::Bucket(1, 2),
+                           base::Bucket(2, 1)));
+
+  histogram_tester.ExpectTotalCount("ResourceScheduler.RequestsCount.Delayable",
+                                    4);
+  histogram_tester.ExpectTotalCount(
+      "ResourceScheduler.RequestsCount.NonDelayable", 4);
+  histogram_tester.ExpectTotalCount(
+      "ResourceScheduler.RequestsCount.TotalLayoutBlocking", 4);
+
+  // Two samples are added when |high| and |low| are started. One sample is
+  // added when |low| is erased while |high| is still in-flight.
+  histogram_tester.ExpectTotalCount(
+      "ResourceScheduler.RequestsCount.DelayableWhenLayoutBlocking", 3);
+  histogram_tester.ExpectTotalCount(
+      "ResourceScheduler.RequestsCount.DelayableWhenNonDelayable", 3);
+
+  histogram_tester.ExpectUniqueSample(
+      "ResourceScheduler.PeakDelayableRequestsInFlight.LayoutBlocking", 1, 1);
+  histogram_tester.ExpectUniqueSample(
+      "ResourceScheduler.PeakDelayableRequestsInFlight.NonDelayable", 1, 1);
 }
 
 TEST_F(ResourceSchedulerTest, BackgroundRequestStartsImmediately) {
   const int route_id = 0;  // Indicates a background request.
   std::unique_ptr<TestRequest> request(
       NewRequestWithRoute("http://host/1", net::LOWEST, route_id));
   EXPECT_TRUE(request->started());
 }
 
 TEST_F(ResourceSchedulerTest, MoreThanOneHighRequestBlocksDelayableRequests) {
@@ skipping 426 matching lines @@
   scheduler_->OnClientDeleted(kChildId2, kRouteId2);
   high.reset();
   delayable_requests.clear();
   base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(lowest->started());
 }
 
 }  // unnamed namespace
 
 }  // namespace content