Record how frequently EEP provides valid estimates

net/base/network_quality_estimator_unittest.cc

 // Copyright 2015 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/base/network_quality_estimator.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <limits>
@@ skipping 938 matching lines @@
  private:
   // Keeps track of number of times different functions were called.
   mutable size_t get_rtt_count_;
 
   DISALLOW_COPY_AND_ASSIGN(InvalidExternalEstimateProvider);
 };
 
 // Tests if the RTT value from external estimate provider is discarded if the
 // external estimate provider is invalid.
 TEST(NetworkQualityEstimatorTest, InvalidExternalEstimateProvider) {
+  base::HistogramTester histogram_tester;
   InvalidExternalEstimateProvider* invalid_external_estimate_provider =
       new InvalidExternalEstimateProvider();
   std::unique_ptr<ExternalEstimateProvider> external_estimate_provider(
       invalid_external_estimate_provider);
 
   TestNetworkQualityEstimator estimator(std::map<std::string, std::string>(),
                                         std::move(external_estimate_provider));
 
   base::TimeDelta rtt;
   int32_t kbps;
   EXPECT_EQ(1U, invalid_external_estimate_provider->get_rtt_count());
   EXPECT_FALSE(estimator.GetURLRequestRTTEstimate(&rtt));
   EXPECT_FALSE(estimator.GetDownlinkThroughputKbpsEstimate(&kbps));
+  histogram_tester.ExpectTotalCount("NQE.ExternalEstimateProviderStatus", 3);
+
+  histogram_tester.ExpectBucketCount(
+      "NQE.ExternalEstimateProviderStatus",
+      1 /* EXTERNAL_ESTIMATE_PROVIDER_STATUS_AVAILABLE */, 1);
+  histogram_tester.ExpectBucketCount(
+      "NQE.ExternalEstimateProviderStatus",
+      2 /* EXTERNAL_ESTIMATE_PROVIDER_STATUS_QUERIED */, 1);
+  histogram_tester.ExpectBucketCount(
+      "NQE.ExternalEstimateProviderStatus",
+      3 /* EXTERNAL_ESTIMATE_PROVIDER_STATUS_QUERY_SUCCESSFUL */, 1);
+  histogram_tester.ExpectTotalCount("NQE.ExternalEstimateProvider.RTT", 0);
+  histogram_tester.ExpectTotalCount(
+      "NQE.ExternalEstimateProvider.DownlinkBandwidth", 0);
 }
 
 class TestExternalEstimateProvider : public ExternalEstimateProvider {
  public:
   TestExternalEstimateProvider(base::TimeDelta rtt,
                                int32_t downstream_throughput_kbps)
       : rtt_(rtt),
         downstream_throughput_kbps_(downstream_throughput_kbps),
         time_since_last_update_(base::TimeDelta::FromSeconds(1)),
         get_time_since_last_update_count_(0),
@@ skipping 64 matching lines @@
   mutable size_t get_rtt_count_;
   mutable size_t get_downstream_throughput_kbps_count_;
   mutable size_t update_count_;
 
   DISALLOW_COPY_AND_ASSIGN(TestExternalEstimateProvider);
 };
 
 // Tests if the external estimate provider is called in the constructor and
 // on network change notification.
 TEST(NetworkQualityEstimatorTest, TestExternalEstimateProvider) {
+  base::HistogramTester histogram_tester;
   TestExternalEstimateProvider* test_external_estimate_provider =
       new TestExternalEstimateProvider(base::TimeDelta::FromMilliseconds(1),
                                        100);
   std::unique_ptr<ExternalEstimateProvider> external_estimate_provider(
       test_external_estimate_provider);
   std::map<std::string, std::string> variation_params;
   TestNetworkQualityEstimator estimator(variation_params,
                                         std::move(external_estimate_provider));
 
   base::TimeDelta rtt;
   int32_t kbps;
   EXPECT_TRUE(estimator.GetURLRequestRTTEstimate(&rtt));
   EXPECT_TRUE(estimator.GetDownlinkThroughputKbpsEstimate(&kbps));
 
+  histogram_tester.ExpectTotalCount("NQE.ExternalEstimateProviderStatus", 5);
+
+  histogram_tester.ExpectBucketCount(
+      "NQE.ExternalEstimateProviderStatus",
+      1 /* EXTERNAL_ESTIMATE_PROVIDER_STATUS_AVAILABLE */, 1);
+  histogram_tester.ExpectBucketCount(
+      "NQE.ExternalEstimateProviderStatus",
+      2 /* EXTERNAL_ESTIMATE_PROVIDER_STATUS_QUERIED */, 1);
+  histogram_tester.ExpectBucketCount(
+      "NQE.ExternalEstimateProviderStatus",
+      3 /* EXTERNAL_ESTIMATE_PROVIDER_STATUS_QUERY_SUCCESSFUL */, 1);
+  histogram_tester.ExpectBucketCount(
+      "NQE.ExternalEstimateProviderStatus",
+      5 /* EXTERNAL_ESTIMATE_PROVIDER_STATUS_RTT_AVAILABLE */, 1);
+  histogram_tester.ExpectBucketCount(
+      "NQE.ExternalEstimateProviderStatus",
+      6 /* EXTERNAL_ESTIMATE_PROVIDER_STATUS_DOWNLINK_BANDWIDTH_AVAILABLE */,
+      1);
+  histogram_tester.ExpectTotalCount("NQE.ExternalEstimateProvider.RTT", 1);
+  histogram_tester.ExpectBucketCount("NQE.ExternalEstimateProvider.RTT", 1, 1);
+
+  histogram_tester.ExpectTotalCount(
+      "NQE.ExternalEstimateProvider.DownlinkBandwidth", 1);
+  histogram_tester.ExpectBucketCount(
+      "NQE.ExternalEstimateProvider.DownlinkBandwidth", 100, 1);
+
   EXPECT_EQ(
       1U, test_external_estimate_provider->get_time_since_last_update_count());
   EXPECT_EQ(1U, test_external_estimate_provider->get_rtt_count());
   EXPECT_EQ(
       1U,
       test_external_estimate_provider->get_downstream_throughput_kbps_count());
 
   // Change network type to WiFi. Number of queries to External estimate
   // provider must increment.
   estimator.SimulateNetworkChangeTo(
@@ skipping 210 matching lines @@
     }
     // At least one notification should be received per socket performance
     // watcher.
     EXPECT_LE(1U, after_count_tcp_rtt_observations -
                       before_count_tcp_rtt_observations)
         << i;
   }
 }
 
 }  // namespace net