NQE: Notify observer as soon as it is added

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 333 matching lines @@
   estimator.AddThroughputObserver(&throughput_observer);
 
   estimator.SimulateNetworkChange(
       NetworkChangeNotifier::ConnectionType::CONNECTION_2G, "test");
   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.
-  EXPECT_EQ(1U, observer.effective_connection_types().size());
+  // notified. |observer| must be notified once right after it was added, and
+  // once again after the cached network quality was read.
+  EXPECT_EQ(2U, observer.effective_connection_types().size());
   EXPECT_EQ(1U, rtt_observer.observations().size());
   EXPECT_EQ(1U, throughput_observer.observations().size());
 }
 
 TEST(NetworkQualityEstimatorTest, StoreObservations) {
   std::map<std::string, std::string> variation_params;
   TestNetworkQualityEstimator estimator(variation_params);
 
   base::TimeDelta rtt;
   int32_t kbps;
@@ skipping 1061 matching lines @@
   estimator.SimulateNetworkChange(NetworkChangeNotifier::CONNECTION_WIFI,
                                   "test");
   EXPECT_EQ(2U, observer.effective_connection_types().size());
 
   // A change in effective connection type does not trigger notification to the
   // observers, since it is not accompanied by any new observation or a network
   // change event.
   estimator.set_start_time_null_http_rtt(
       base::TimeDelta::FromMilliseconds(100));
   EXPECT_EQ(2U, observer.effective_connection_types().size());
+
+  TestEffectiveConnectionTypeObserver observer_2;
+  estimator.AddEffectiveConnectionTypeObserver(&observer_2);
+  EXPECT_EQ(0U, observer_2.effective_connection_types().size());
+  base::RunLoop().RunUntilIdle();
+  // |observer_2| must be notified as soon as it is added.
+  EXPECT_EQ(1U, observer_2.effective_connection_types().size());
+
+  // |observer_3| should not be notified since it unregisters before the
+  // message loop is run.
+  TestEffectiveConnectionTypeObserver observer_3;
+  estimator.AddEffectiveConnectionTypeObserver(&observer_3);
+  EXPECT_EQ(0U, observer_3.effective_connection_types().size());
+  estimator.RemoveEffectiveConnectionTypeObserver(&observer_3);
+  base::RunLoop().RunUntilIdle();
+  EXPECT_EQ(0U, observer_3.effective_connection_types().size());
 }
 
 // Tests that the network quality is computed at the specified interval, and
 // that the network quality observers are notified of any change.
 TEST(NetworkQualityEstimatorTest, TestRTTAndThroughputEstimatesObserver) {
   base::HistogramTester histogram_tester;
   std::unique_ptr<base::SimpleTestTickClock> tick_clock(
       new base::SimpleTestTickClock());
   base::SimpleTestTickClock* tick_clock_ptr = tick_clock.get();
 
@@ skipping 53 matching lines @@
   EXPECT_LE(1, observer.notifications_received() - notifications_received);
   notifications_received = observer.notifications_received();
 
   // A change in effective connection type does not trigger notification to the
   // observers, since it is not accompanied by any new observation or a network
   // change event.
   estimator.set_start_time_null_http_rtt(
       base::TimeDelta::FromMilliseconds(10000));
   estimator.set_start_time_null_http_rtt(base::TimeDelta::FromMilliseconds(1));
   EXPECT_EQ(0, observer.notifications_received() - notifications_received);
+
+  TestRTTAndThroughputEstimatesObserver observer_2;
+  estimator.AddRTTAndThroughputEstimatesObserver(&observer_2);
+  EXPECT_EQ(nqe::internal::InvalidRTT(), observer_2.http_rtt());
+  EXPECT_EQ(nqe::internal::InvalidRTT(), observer_2.transport_rtt());
+  EXPECT_EQ(nqe::internal::kInvalidThroughput,
+            observer_2.downstream_throughput_kbps());
+  base::RunLoop().RunUntilIdle();
+  EXPECT_NE(nqe::internal::InvalidRTT(), observer_2.http_rtt());
+  EXPECT_NE(nqe::internal::InvalidRTT(), observer_2.transport_rtt());
+  EXPECT_NE(nqe::internal::kInvalidThroughput,
+            observer_2.downstream_throughput_kbps());
+
+  // |observer_3| should not be notified because it is unregisters before the
+  // message loop is run.
+  TestRTTAndThroughputEstimatesObserver observer_3;
+  estimator.AddRTTAndThroughputEstimatesObserver(&observer_3);
+  EXPECT_EQ(nqe::internal::InvalidRTT(), observer_3.http_rtt());
+  EXPECT_EQ(nqe::internal::InvalidRTT(), observer_3.transport_rtt());
+  EXPECT_EQ(nqe::internal::kInvalidThroughput,
+            observer_3.downstream_throughput_kbps());
+  estimator.RemoveRTTAndThroughputEstimatesObserver(&observer_3);
+  base::RunLoop().RunUntilIdle();
+  EXPECT_EQ(nqe::internal::InvalidRTT(), observer_3.http_rtt());
+  EXPECT_EQ(nqe::internal::InvalidRTT(), observer_3.transport_rtt());
+  EXPECT_EQ(nqe::internal::kInvalidThroughput,
+            observer_3.downstream_throughput_kbps());
 }
 
 // Tests that the effective connection type is computed on every RTT
 // observation if the last computed effective connection type was unknown.
 TEST(NetworkQualityEstimatorTest, UnknownEffectiveConnectionType) {
   std::unique_ptr<base::SimpleTestTickClock> tick_clock(
       new base::SimpleTestTickClock());
   base::SimpleTestTickClock* tick_clock_ptr = tick_clock.get();
 
   TestEffectiveConnectionTypeObserver observer;
@@ skipping 800 matching lines @@
     if (expected_count == 1) {
       EffectiveConnectionType last_notified_type =
           observer.effective_connection_types().at(
               observer.effective_connection_types().size() - 1);
       EXPECT_EQ(i, last_notified_type);
     }
   }
 }
 
 }  // namespace net