NQE: Add net log events when there is a significant change in metrics

net/nqe/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/nqe/network_quality_estimator.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <limits>
@@ skipping 174 matching lines @@
   context.set_network_quality_estimator(&estimator);
   context.Init();
 
   std::unique_ptr<URLRequest> request(context.CreateRequest(
       estimator.GetEchoURL(), DEFAULT_PRIORITY, &test_delegate));
   request->SetLoadFlags(request->load_flags() | LOAD_MAIN_FRAME_DEPRECATED);
   request->Start();
   base::RunLoop().Run();
 
   // Both RTT and downstream throughput should be updated.
-  EXPECT_TRUE(estimator.GetRecentHttpRTT(base::TimeTicks(), &rtt));
+  base::TimeDelta http_rtt;
+  EXPECT_TRUE(estimator.GetRecentHttpRTT(base::TimeTicks(), &http_rtt));
   EXPECT_TRUE(
       estimator.GetRecentDownlinkThroughputKbps(base::TimeTicks(), &kbps));
-  EXPECT_FALSE(estimator.GetRecentTransportRTT(base::TimeTicks(), &rtt));
+  base::TimeDelta transport_rtt;
+  EXPECT_FALSE(
+      estimator.GetRecentTransportRTT(base::TimeTicks(), &transport_rtt));
 
+  // Verify the contents of the net log.
   EXPECT_EQ(
-      1, estimator.GetEntriesCount(NetLogEventType::NETWORK_QUALITY_CHANGED));
+      2, estimator.GetEntriesCount(NetLogEventType::NETWORK_QUALITY_CHANGED));
+  EXPECT_EQ(http_rtt.InMilliseconds(),
+            estimator.GetNetLogLastIntegerValue(
+                NetLogEventType::NETWORK_QUALITY_CHANGED, "http_rtt_ms"));
+  EXPECT_EQ(-1,
+            estimator.GetNetLogLastIntegerValue(
+                NetLogEventType::NETWORK_QUALITY_CHANGED, "transport_rtt_ms"));
+  EXPECT_EQ(kbps, estimator.GetNetLogLastIntegerValue(
+                      NetLogEventType::NETWORK_QUALITY_CHANGED,
+                      "downstream_throughput_kbps"));
 
   // Check UMA histograms.
   histogram_tester.ExpectTotalCount("NQE.PeakKbps.Unknown", 0);
   histogram_tester.ExpectTotalCount("NQE.FastestRTT.Unknown", 0);
   histogram_tester.ExpectUniqueSample(
       "NQE.MainFrame.EffectiveConnectionType",
       EffectiveConnectionType::EFFECTIVE_CONNECTION_TYPE_UNKNOWN, 1);
   histogram_tester.ExpectUniqueSample(
       "NQE.MainFrame.EffectiveConnectionType.Unknown",
       EffectiveConnectionType::EFFECTIVE_CONNECTION_TYPE_UNKNOWN, 1);
@@ skipping 142 matching lines @@
   estimator.AddEffectiveConnectionTypeObserver(&observer);
   TestRTTObserver rtt_observer;
   estimator.AddRTTObserver(&rtt_observer);
   TestThroughputObserver throughput_observer;
   estimator.AddThroughputObserver(&throughput_observer);
 
   // |observer| should be notified as soon as it is added.
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(1U, observer.effective_connection_types().size());
   EXPECT_EQ(
-      1, estimator.GetEntriesCount(NetLogEventType::NETWORK_QUALITY_CHANGED));
+      2, estimator.GetEntriesCount(NetLogEventType::NETWORK_QUALITY_CHANGED));
 
   estimator.SimulateNetworkChange(
       NetworkChangeNotifier::ConnectionType::CONNECTION_2G, "test");
 
+  // Verify the contents of the net log.
   EXPECT_LE(
-      2, estimator.GetEntriesCount(NetLogEventType::NETWORK_QUALITY_CHANGED));
+      3, estimator.GetEntriesCount(NetLogEventType::NETWORK_QUALITY_CHANGED));
+  EXPECT_NE(-1, estimator.GetNetLogLastIntegerValue(
+                    NetLogEventType::NETWORK_QUALITY_CHANGED, "http_rtt_ms"));
+  EXPECT_EQ(-1,
+            estimator.GetNetLogLastIntegerValue(
+                NetLogEventType::NETWORK_QUALITY_CHANGED, "transport_rtt_ms"));
+  EXPECT_NE(-1, estimator.GetNetLogLastIntegerValue(
+                    NetLogEventType::NETWORK_QUALITY_CHANGED,
+                    "downstream_throughput_kbps"));
+  EXPECT_EQ(
+      GetNameForEffectiveConnectionType(estimator.GetEffectiveConnectionType()),
+      estimator.GetNetLogLastStringValue(
+          NetLogEventType::NETWORK_QUALITY_CHANGED,
+          "effective_connection_type"));
+
   histogram_tester.ExpectBucketCount("NQE.CachedNetworkQualityAvailable", true,
                                      1);
   histogram_tester.ExpectTotalCount("NQE.CachedNetworkQualityAvailable", 2);
   base::RunLoop().RunUntilIdle();
 
   // Verify that the cached network quality was read, and observers were
   // notified. |observer| must be notified once right after it was added, and
   // once again after the cached network quality was read.
   EXPECT_LE(2U, observer.effective_connection_types().size());
   EXPECT_EQ(estimator.GetEffectiveConnectionType(),
@@ skipping 137 matching lines @@
   EXPECT_EQ(749, kbps);
 
   EXPECT_NE(EFFECTIVE_CONNECTION_TYPE_UNKNOWN,
             estimator.GetEffectiveConnectionType());
   EXPECT_EQ(
       1U,
       effective_connection_type_observer.effective_connection_types().size());
   EXPECT_NE(
       EFFECTIVE_CONNECTION_TYPE_UNKNOWN,
       effective_connection_type_observer.effective_connection_types().front());
-  EXPECT_EQ(
-      2, estimator.GetEntriesCount(NetLogEventType::NETWORK_QUALITY_CHANGED));
+
+  // Verify the contents of the net log.
+  EXPECT_LE(
+      3, estimator.GetEntriesCount(NetLogEventType::NETWORK_QUALITY_CHANGED));
+  EXPECT_NE(
+      GetNameForEffectiveConnectionType(EFFECTIVE_CONNECTION_TYPE_UNKNOWN),
+      estimator.GetNetLogLastStringValue(
+          NetLogEventType::NETWORK_QUALITY_CHANGED,
+          "effective_connection_type"));
 
   EXPECT_EQ(3, rtt_throughput_estimates_observer.notifications_received());
   EXPECT_EQ(base::TimeDelta::FromMilliseconds(272),
             rtt_throughput_estimates_observer.http_rtt());
   EXPECT_EQ(base::TimeDelta::FromMilliseconds(209),
             rtt_throughput_estimates_observer.transport_rtt());
   EXPECT_EQ(749,
             rtt_throughput_estimates_observer.downstream_throughput_kbps());
 
   EXPECT_EQ(2U, rtt_observer.observations().size());
@@ skipping 989 matching lines @@
   tick_clock_ptr->Advance(base::TimeDelta::FromMinutes(60));
 
   std::unique_ptr<URLRequest> request(context.CreateRequest(
       estimator.GetEchoURL(), DEFAULT_PRIORITY, &test_delegate));
   request->SetLoadFlags(request->load_flags() | LOAD_MAIN_FRAME_DEPRECATED);
   request->Start();
   base::RunLoop().Run();
   EXPECT_EQ(1U, observer.effective_connection_types().size());
   EXPECT_EQ(
       1, estimator.GetEntriesCount(NetLogEventType::NETWORK_QUALITY_CHANGED));
+
+  // Verify the contents of the net log.
+  EXPECT_EQ(GetNameForEffectiveConnectionType(EFFECTIVE_CONNECTION_TYPE_2G),
+            estimator.GetNetLogLastStringValue(
+                NetLogEventType::NETWORK_QUALITY_CHANGED,
+                "effective_connection_type"));
+  EXPECT_EQ(1500, estimator.GetNetLogLastIntegerValue(
+                      NetLogEventType::NETWORK_QUALITY_CHANGED, "http_rtt_ms"));
+  EXPECT_EQ(-1,
+            estimator.GetNetLogLastIntegerValue(
+                NetLogEventType::NETWORK_QUALITY_CHANGED, "transport_rtt_ms"));
+  EXPECT_EQ(100000, estimator.GetNetLogLastIntegerValue(
+                        NetLogEventType::NETWORK_QUALITY_CHANGED,
+                        "downstream_throughput_kbps"));
+
   histogram_tester.ExpectUniqueSample("NQE.MainFrame.EffectiveConnectionType",
                                       EFFECTIVE_CONNECTION_TYPE_2G, 1);
   histogram_tester.ExpectUniqueSample(
       "NQE.MainFrame.EffectiveConnectionType.Unknown",
       EFFECTIVE_CONNECTION_TYPE_2G, 1);
 
   // Next request should not trigger recomputation of effective connection type
   // since there has been no change in the clock.
   std::unique_ptr<URLRequest> request2(context.CreateRequest(
       estimator.GetEchoURL(), DEFAULT_PRIORITY, &test_delegate));
@@ skipping 1158 matching lines @@
 
   // Cleanup.
   estimator.RemoveRTTObserver(&rtt_observer);
   estimator.RemoveThroughputObserver(&throughput_observer);
   estimator.RemoveRTTAndThroughputEstimatesObserver(&rtt_throughput_observer);
   estimator.RemoveEffectiveConnectionTypeObserver(
       &effective_connection_type_observer);
 }
 
 }  // namespace net