Add SocketWatcherFactory as a helper class to NQE

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>
 #include <utility>
 #include <vector>
 
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/metrics/histogram_base.h"
 #include "base/strings/string_number_conversions.h"
+#include "base/thread_task_runner_handle.h"
 #include "build/build_config.h"
 #include "net/base/load_flags.h"
 #include "net/base/load_timing_info.h"
 #include "net/base/network_interfaces.h"
 #include "net/base/url_util.h"
 #include "net/url_request/url_request.h"
 #include "url/gurl.h"
 
 #if defined(OS_ANDROID)
 #include "net/android/network_library.h"
@@ skipping 106 matching lines @@
     bool allow_smaller_responses_for_tests)
     : allow_localhost_requests_(allow_local_host_requests_for_tests),
       allow_small_responses_(allow_smaller_responses_for_tests),
       last_connection_change_(base::TimeTicks::Now()),
       current_network_id_(
           NetworkID(NetworkChangeNotifier::ConnectionType::CONNECTION_UNKNOWN,
                     std::string())),
       downstream_throughput_kbps_observations_(
           GetWeightMultiplierPerSecond(variation_params)),
       rtt_observations_(GetWeightMultiplierPerSecond(variation_params)),
-      external_estimate_provider_(std::move(external_estimates_provider)) {
+      external_estimate_provider_(std::move(external_estimates_provider)),
+      weak_ptr_factory_(this) {
   static_assert(kMinRequestDurationMicroseconds > 0,
                 "Minimum request duration must be > 0");
   static_assert(kDefaultHalfLifeSeconds > 0,
                 "Default half life duration must be > 0");
   static_assert(kMaximumNetworkQualityCacheSize > 0,
                 "Size of the network quality cache must be > 0");
   // This limit should not be increased unless the logic for removing the
   // oldest cache entry is rewritten to use a doubly-linked-list LRU queue.
   static_assert(kMaximumNetworkQualityCacheSize <= 10,
                 "Size of the network quality cache must <= 10");
 
   ObtainOperatingParams(variation_params);
   NetworkChangeNotifier::AddConnectionTypeObserver(this);
   if (external_estimate_provider_) {
     RecordExternalEstimateProviderMetrics(
         EXTERNAL_ESTIMATE_PROVIDER_STATUS_AVAILABLE);
     external_estimate_provider_->SetUpdatedEstimateDelegate(this);
     QueryExternalEstimateProvider();
   } else {
     RecordExternalEstimateProviderMetrics(
         EXTERNAL_ESTIMATE_PROVIDER_STATUS_NOT_AVAILABLE);
   }
   current_network_id_ = GetCurrentNetworkID();
   AddDefaultEstimates();
+
+  watcher_factory_.reset(new SocketWatcherFactory(
+      base::ThreadTaskRunnerHandle::Get(), GetWeakPtr()));

[Ryan Sleevi, 2016/04/02 00:48:20]

s/GetWeakPtr()/weak_factory_.GetWeakPtr())

[tbansal1, 2016/04/04 16:55:44]

Done.

 }
 
 // static
 const base::TimeDelta NetworkQualityEstimator::InvalidRTT() {
   return base::TimeDelta::Max();
 }
 
 void NetworkQualityEstimator::ObtainOperatingParams(
     const std::map<std::string, std::string>& variation_params) {
   DCHECK(thread_checker_.CalledOnValidThread());
@@ skipping 190 matching lines @@
   DCHECK(thread_checker_.CalledOnValidThread());
   throughput_observer_list_.AddObserver(throughput_observer);
 }
 
 void NetworkQualityEstimator::RemoveThroughputObserver(
     ThroughputObserver* throughput_observer) {
   DCHECK(thread_checker_.CalledOnValidThread());
   throughput_observer_list_.RemoveObserver(throughput_observer);
 }
 
+SocketPerformanceWatcherFactory*
+NetworkQualityEstimator::GetSocketPerformanceWatcherFactory() {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  return watcher_factory_.get();
+}
+
 void NetworkQualityEstimator::RecordRTTUMA(int32_t estimated_value_msec,
                                            int32_t actual_value_msec) const {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // Record the difference between the actual and the estimated value.
   if (estimated_value_msec >= actual_value_msec) {
     base::HistogramBase* difference_rtt =
         GetHistogram("DifferenceRTTEstimatedAndActual.",
                      current_network_id_.type, 10 * 1000);  // 10 seconds
     difference_rtt->Add(estimated_value_msec - actual_value_msec);
@@ skipping 237 matching lines @@
   // a higher percentile RTT will have a longer RTT than a lower percentile.
   base::TimeDelta rtt = InvalidRTT();
   std::vector<ObservationSource> disallowed_observation_sources;
   disallowed_observation_sources.push_back(TCP);
   disallowed_observation_sources.push_back(QUIC);
   rtt_observations_.GetPercentile(begin_timestamp, &rtt, percentile,
                                   disallowed_observation_sources);
   return rtt;
 }
 
+NetworkQualityEstimator::SocketWatcherFactory::SocketWatcherFactory(
+    const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
+    const base::WeakPtr<NetworkQualityEstimator>& network_quality_estimator)
+    : task_runner_(task_runner),
+      network_quality_estimator_(network_quality_estimator) {
+  DCHECK(task_runner_);
+}
+
+NetworkQualityEstimator::SocketWatcherFactory::~SocketWatcherFactory() {}
+
+scoped_ptr<SocketPerformanceWatcher>
+NetworkQualityEstimator::SocketWatcherFactory::CreateSocketPerformanceWatcher(
+    SocketPerformanceWatcherFactory::Protocol protocol) {
+  return scoped_ptr<SocketPerformanceWatcher>(
+      new SocketWatcher(protocol, task_runner_, network_quality_estimator_));
+}
+
+NetworkQualityEstimator::SocketWatcher::SocketWatcher(
+    SocketPerformanceWatcherFactory::Protocol protocol,
+    const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
+    const base::WeakPtr<NetworkQualityEstimator>& network_quality_estimator)
+    : protocol_(protocol),
+      task_runner_(task_runner),
+      network_quality_estimator_(network_quality_estimator) {
+  DCHECK(task_runner_);
+  DCHECK(network_quality_estimator_);
+}
+
+NetworkQualityEstimator::SocketWatcher::~SocketWatcher() {}
+
+void NetworkQualityEstimator::SocketWatcher::OnUpdatedRTTAvailable(
+    const base::TimeDelta& rtt) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  task_runner_->PostTask(
+      FROM_HERE, base::Bind(&NetworkQualityEstimator::OnUpdatedRTTAvailable,
+                            network_quality_estimator_, protocol_, rtt));
+}
+
+bool NetworkQualityEstimator::SocketWatcher::ShouldNotifyUpdatedRTT() const {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  return true;
+}
+
+void NetworkQualityEstimator::SocketWatcher::Reset() {
+  DCHECK(thread_checker_.CalledOnValidThread());
+}
+
 int32_t NetworkQualityEstimator::GetDownlinkThroughputKbpsEstimateInternal(
     const base::TimeTicks& begin_timestamp,
     int percentile) const {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK_GE(percentile, 0);
   DCHECK_LE(percentile, 100);
   if (downstream_throughput_kbps_observations_.Size() == 0)
     return kInvalidThroughput;
 
   // Throughput observations are sorted by kbps from slowest to fastest,
@@ skipping 251 matching lines @@
   }
   DCHECK_LT(cached_network_qualities_.size(),
             static_cast<size_t>(kMaximumNetworkQualityCacheSize));
 
   cached_network_qualities_.insert(std::make_pair(
       current_network_id_, CachedNetworkQuality(network_quality)));
   DCHECK_LE(cached_network_qualities_.size(),
             static_cast<size_t>(kMaximumNetworkQualityCacheSize));
 }
 
-scoped_ptr<SocketPerformanceWatcher>
-NetworkQualityEstimator::CreateSocketPerformanceWatcher(
-    const Protocol protocol) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-
-  return scoped_ptr<SocketPerformanceWatcher>(
-      new SocketPerformanceWatcher(protocol, this));
-}
-
 void NetworkQualityEstimator::OnUpdatedRTTAvailable(
-    const Protocol protocol,
+    SocketPerformanceWatcherFactory::Protocol protocol,
     const base::TimeDelta& rtt) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   switch (protocol) {
-    case PROTOCOL_TCP:
+    case SocketPerformanceWatcherFactory::PROTOCOL_TCP:
       NotifyObserversOfRTT(RttObservation(rtt, base::TimeTicks::Now(), TCP));
       return;
-    case PROTOCOL_QUIC:
+    case SocketPerformanceWatcherFactory::PROTOCOL_QUIC:
       NotifyObserversOfRTT(RttObservation(rtt, base::TimeTicks::Now(), QUIC));
       return;
     default:
       NOTREACHED();
   }
 }
 
 void NetworkQualityEstimator::NotifyObserversOfRTT(
     const RttObservation& observation) {
   FOR_EACH_OBSERVER(
       RTTObserver, rtt_observer_list_,
       OnRTTObservation(observation.value.InMilliseconds(),
                        observation.timestamp, observation.source));
 }
 
 void NetworkQualityEstimator::NotifyObserversOfThroughput(
     const ThroughputObservation& observation) {
   FOR_EACH_OBSERVER(
       ThroughputObserver, throughput_observer_list_,
       OnThroughputObservation(observation.value, observation.timestamp,
                               observation.source));
 }
 
+base::WeakPtr<NetworkQualityEstimator> NetworkQualityEstimator::GetWeakPtr() {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  return weak_ptr_factory_.GetWeakPtr();
+}
+
 NetworkQualityEstimator::CachedNetworkQuality::CachedNetworkQuality(
     const NetworkQuality& network_quality)
     : last_update_time_(base::TimeTicks::Now()),
       network_quality_(network_quality) {
 }
 
 NetworkQualityEstimator::CachedNetworkQuality::CachedNetworkQuality(
     const CachedNetworkQuality& other)
     : last_update_time_(other.last_update_time_),
       network_quality_(other.network_quality_) {
@@ skipping 27 matching lines @@
 
 NetworkQualityEstimator::NetworkQuality&
     NetworkQualityEstimator::NetworkQuality::
     operator=(const NetworkQuality& other) {
   rtt_ = other.rtt_;
   downstream_throughput_kbps_ = other.downstream_throughput_kbps_;
   return *this;
 }
 
 }  // namespace net