Expose RTT and downlink bandwidth using experimental Javascript API

net/nqe/network_quality_estimator.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 <algorithm>
 #include <cmath>
 #include <limits>
 #include <utility>
@@ skipping 275 matching lines @@
       disallowed_observation_sources_for_http_(
           {NETWORK_QUALITY_OBSERVATION_SOURCE_TCP,
            NETWORK_QUALITY_OBSERVATION_SOURCE_QUIC,
            NETWORK_QUALITY_OBSERVATION_SOURCE_TRANSPORT_CACHED_ESTIMATE,
            NETWORK_QUALITY_OBSERVATION_SOURCE_DEFAULT_TRANSPORT_FROM_PLATFORM}),
       disallowed_observation_sources_for_transport_(
           {NETWORK_QUALITY_OBSERVATION_SOURCE_HTTP,
            NETWORK_QUALITY_OBSERVATION_SOURCE_HTTP_EXTERNAL_ESTIMATE,
            NETWORK_QUALITY_OBSERVATION_SOURCE_HTTP_CACHED_ESTIMATE,
            NETWORK_QUALITY_OBSERVATION_SOURCE_DEFAULT_HTTP_FROM_PLATFORM}),
+      suppress_notifications_for_testing_(false),
       weak_ptr_factory_(this) {
   // None of the algorithms can have an empty name.
   DCHECK(algorithm_name_to_enum_.end() ==
          algorithm_name_to_enum_.find(std::string()));
 
   DCHECK_EQ(algorithm_name_to_enum_.size(),
             static_cast<size_t>(EffectiveConnectionTypeAlgorithm::
                                     EFFECTIVE_CONNECTION_TYPE_ALGORITHM_LAST));
   DCHECK_NE(EffectiveConnectionTypeAlgorithm::
                 EFFECTIVE_CONNECTION_TYPE_ALGORITHM_LAST,
@@ skipping 1274 matching lines @@
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK_NE(nqe::internal::InvalidRTT(), observation.value);
   DCHECK_GT(NETWORK_QUALITY_OBSERVATION_SOURCE_MAX, observation.source);
 
   UMA_HISTOGRAM_ENUMERATION("NQE.RTT.ObservationSource", observation.source,
                             NETWORK_QUALITY_OBSERVATION_SOURCE_MAX);
 
   // Maybe recompute the effective connection type since a new RTT observation
   // is available.
   MaybeComputeEffectiveConnectionType();
+
+  if (suppress_notifications_for_testing_)
+    return;
+
   for (auto& observer : rtt_observer_list_) {
     observer.OnRTTObservation(observation.value.InMilliseconds(),
                               observation.timestamp, observation.source);
   }
 }
 
 void NetworkQualityEstimator::NotifyObserversOfThroughput(
     const ThroughputObservation& observation) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK_NE(nqe::internal::kInvalidThroughput, observation.value);
   DCHECK_GT(NETWORK_QUALITY_OBSERVATION_SOURCE_MAX, observation.source);
 
   UMA_HISTOGRAM_ENUMERATION("NQE.Kbps.ObservationSource", observation.source,
                             NETWORK_QUALITY_OBSERVATION_SOURCE_MAX);
 
   // Maybe recompute the effective connection type since a new throughput
   // observation is available.
   MaybeComputeEffectiveConnectionType();
+
+  if (suppress_notifications_for_testing_)
+    return;
+
   for (auto& observer : throughput_observer_list_) {

[bengr, 2017/05/12 19:09:54]

I'd prefer that you didn't add test support into non-test code. Can you instead
put  the call to observer.OnThroughputObservation into its own virtualized
method? Alternatively, could you subclass the observer, virtualize
onThroughputObservation, and pass a subclass instance into NQE?

[tbansal1, 2017/05/12 22:18:17]

Done.

     observer.OnThroughputObservation(observation.value, observation.timestamp,
                                      observation.source);
   }
 }
 
 void NetworkQualityEstimator::OnNewThroughputObservationAvailable(
     int32_t downstream_kbps) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (downstream_kbps == 0)
@@ skipping 42 matching lines @@
     return;
   }
   ComputeEffectiveConnectionType();
 }
 
 void NetworkQualityEstimator::
     NotifyObserversOfEffectiveConnectionTypeChanged() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK_NE(EFFECTIVE_CONNECTION_TYPE_LAST, effective_connection_type_);
 
-  // TODO(tbansal): Add hysteresis in the notification.
-  for (auto& observer : effective_connection_type_observer_list_)
-    observer.OnEffectiveConnectionTypeChanged(effective_connection_type_);
-
   // Add the estimates of the current network to the cache store.
   if (effective_connection_type_ != EFFECTIVE_CONNECTION_TYPE_UNKNOWN) {
     network_quality_store_->Add(current_network_id_,
                                 nqe::internal::CachedNetworkQuality(
                                     tick_clock_->NowTicks(), network_quality_,
                                     effective_connection_type_));
   }
+
+  if (suppress_notifications_for_testing_)
+    return;
+
+  // TODO(tbansal): Add hysteresis in the notification.

[bengr, 2017/05/12 19:09:55]

What kind of hysteresis? Consider making the hysteresis part of the observer.

[tbansal1, 2017/05/12 22:18:17]

Removed this. We can consider adding hysteresis in the observer interface at
some point. Currently, hysteresis already exists for the notifications sent from
the browser to the render processes.

+  for (auto& observer : effective_connection_type_observer_list_)
+    observer.OnEffectiveConnectionTypeChanged(effective_connection_type_);
 }
 
 void NetworkQualityEstimator::NotifyObserversOfRTTOrThroughputComputed() const {
   DCHECK(thread_checker_.CalledOnValidThread());
 
+  if (suppress_notifications_for_testing_)

[bengr, 2017/05/12 19:09:55]

Yeah, this is gross. Virtualize.

[tbansal1, 2017/05/12 22:18:17]

Done.

+    return;
+
   // TODO(tbansal): Add hysteresis in the notification.
   for (auto& observer : rtt_and_throughput_estimates_observer_list_) {
     observer.OnRTTOrThroughputEstimatesComputed(
         network_quality_.http_rtt(), network_quality_.transport_rtt(),
         network_quality_.downstream_throughput_kbps());
   }
 }
 
 void NetworkQualityEstimator::NotifyEffectiveConnectionTypeObserverIfPresent(
     EffectiveConnectionTypeObserver* observer) const {
   DCHECK(thread_checker_.CalledOnValidThread());
 
+  if (suppress_notifications_for_testing_)
+    return;
   if (!effective_connection_type_observer_list_.HasObserver(observer))
     return;
   if (effective_connection_type_ == EFFECTIVE_CONNECTION_TYPE_UNKNOWN)
     return;
   observer->OnEffectiveConnectionTypeChanged(effective_connection_type_);
 }
 
 void NetworkQualityEstimator::NotifyRTTAndThroughputEstimatesObserverIfPresent(
     RTTAndThroughputEstimatesObserver* observer) const {
   DCHECK(thread_checker_.CalledOnValidThread());
 
+  if (suppress_notifications_for_testing_)
+    return;
   if (!rtt_and_throughput_estimates_observer_list_.HasObserver(observer))
     return;
   observer->OnRTTOrThroughputEstimatesComputed(
       network_quality_.http_rtt(), network_quality_.transport_rtt(),
       network_quality_.downstream_throughput_kbps());
 }
 
 void NetworkQualityEstimator::AddNetworkQualitiesCacheObserver(
     nqe::internal::NetworkQualityStore::NetworkQualitiesCacheObserver*
         observer) {
@@ skipping 93 matching lines @@
     case STATISTIC_UNWEIGHTED_AVERAGE:
       return "UnweightedAverage";
     case STATISTIC_LAST:
       NOTREACHED();
       return "";
   }
   NOTREACHED();
   return "";
 }
 
+void NetworkQualityEstimator::SuppressNotificationsForTesting() {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  suppress_notifications_for_testing_ = true;
+}
+
 base::Optional<base::TimeDelta>
 NetworkQualityEstimator::NetworkQualityProvider::GetHttpRTT() const {
   return base::Optional<base::TimeDelta>();
 }
 
 base::Optional<base::TimeDelta>
 NetworkQualityEstimator::NetworkQualityProvider::GetTransportRTT() const {
   return base::Optional<base::TimeDelta>();
 }
 
 base::Optional<int32_t>
 NetworkQualityEstimator::NetworkQualityProvider::GetDownstreamThroughputKbps()
     const {
   return base::Optional<int32_t>();
 }
 
 }  // namespace net