Notify NQE of TCP RTT values

net/base/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/base/network_quality_estimator.h"
 
 #include <float.h>
 #include <algorithm>
 #include <cmath>
 #include <limits>
@@ skipping 894 matching lines @@
       NotifyObserversOfRTT(RttObservation(rtt, base::TimeTicks::Now(), TCP));
       return;
     case PROTOCOL_QUIC:
       NotifyObserversOfRTT(RttObservation(rtt, base::TimeTicks::Now(), QUIC));
       return;
     default:
       NOTREACHED();
   }
 }
 
+void NetworkQualityEstimator::OnWatcherReset() {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  // Nothing needs to be done for RTT observations since NetworkQualityEstimator
+  // does not maintain any watcher-specific state.
+}
+
 void NetworkQualityEstimator::NotifyObserversOfRTT(
     const RttObservation& observation) {
   FOR_EACH_OBSERVER(
       RTTObserver, rtt_observer_list_,
       OnRTTObservation(observation.value.InMilliseconds(),

[mmenke, 2016/02/23 21:28:39]

Drive-by comment (More on pre-existing stuff) calling observers synchronously
from the bottom of the network stack seems like a really, really bad idea.

Suppose I'm an observer...I have a URLRequest that's low priority, but active,
because bandwidth is plentiful, and not much is going on.  Suddenly, I see
everything become sluggish because of a notification, so let's cancel the
request!  But the request I closed was the one that caused the notification in
the first place....

For that reason, I think we really want all callbacks here to be async.

                        observation.timestamp, observation.source));
 }
 
 void NetworkQualityEstimator::NotifyObserversOfThroughput(
     const ThroughputObservation& observation) {
   FOR_EACH_OBSERVER(
       ThroughputObserver, throughput_observer_list_,
       OnThroughputObservation(observation.value, observation.timestamp,
                               observation.source));
 }
@@ skipping 38 matching lines @@
 
 NetworkQualityEstimator::NetworkQuality&
     NetworkQualityEstimator::NetworkQuality::
     operator=(const NetworkQuality& other) {
   rtt_ = other.rtt_;
   downstream_throughput_kbps_ = other.downstream_throughput_kbps_;
   return *this;
 }
 
 }  // namespace net