Split NQE to multiple files

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 <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"
@@ skipping 191 matching lines @@
   }
 
  private:
   scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
 
   base::WeakPtr<NetworkQualityEstimator> network_quality_estimator_;
 
   DISALLOW_COPY_AND_ASSIGN(SocketWatcherFactory);
 };
 
-const int32_t NetworkQualityEstimator::kInvalidThroughput = 0;
-
 NetworkQualityEstimator::NetworkQualityEstimator(
     std::unique_ptr<ExternalEstimateProvider> external_estimates_provider,
     const std::map<std::string, std::string>& variation_params)
     : NetworkQualityEstimator(std::move(external_estimates_provider),
                               variation_params,
                               false,
                               false) {}
 
 NetworkQualityEstimator::NetworkQualityEstimator(
     std::unique_ptr<ExternalEstimateProvider> external_estimates_provider,
@@ skipping 35 matching lines @@
     RecordExternalEstimateProviderMetrics(
         EXTERNAL_ESTIMATE_PROVIDER_STATUS_NOT_AVAILABLE);
   }
   current_network_id_ = GetCurrentNetworkID();
   AddDefaultEstimates();
 
   watcher_factory_.reset(new SocketWatcherFactory(
       base::ThreadTaskRunnerHandle::Get(), weak_ptr_factory_.GetWeakPtr()));
 }
 
-// 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());
 
   for (size_t i = 0; i <= NetworkChangeNotifier::CONNECTION_LAST; ++i) {
     NetworkChangeNotifier::ConnectionType type =
         static_cast<NetworkChangeNotifier::ConnectionType>(i);
-    DCHECK_EQ(InvalidRTT(), default_observations_[i].rtt());
-    DCHECK_EQ(kInvalidThroughput,
+    DCHECK_EQ(nqe::internal::InvalidRTT(), default_observations_[i].rtt());
+    DCHECK_EQ(nqe::internal::kInvalidThroughput,
               default_observations_[i].downstream_throughput_kbps());
     int32_t variations_value = kMinimumRTTVariationParameterMsec - 1;
     // Name of the parameter that holds the RTT value for this connection type.
     std::string rtt_parameter_name =
         std::string(GetNameForConnectionType(type))
             .append(kDefaultRTTMsecObservationSuffix);
     auto it = variation_params.find(rtt_parameter_name);
     if (it != variation_params.end() &&
         base::StringToInt(it->second, &variations_value) &&
         variations_value >= kMinimumRTTVariationParameterMsec) {
-      default_observations_[i] =
-          NetworkQuality(base::TimeDelta::FromMilliseconds(variations_value),
-                         default_observations_[i].downstream_throughput_kbps());
+      default_observations_[i] = nqe::internal::NetworkQuality(
+          base::TimeDelta::FromMilliseconds(variations_value),
+          default_observations_[i].downstream_throughput_kbps());
     }
 
     variations_value = kMinimumThroughputVariationParameterKbps - 1;
     // Name of the parameter that holds the Kbps value for this connection
     // type.
     std::string kbps_parameter_name =
         std::string(GetNameForConnectionType(type))
             .append(kDefaultKbpsObservationSuffix);
     it = variation_params.find(kbps_parameter_name);
     if (it != variation_params.end() &&
         base::StringToInt(it->second, &variations_value) &&
         variations_value >= kMinimumThroughputVariationParameterKbps) {
-      default_observations_[i] =
-          NetworkQuality(default_observations_[i].rtt(), variations_value);
+      default_observations_[i] = nqe::internal::NetworkQuality(
+          default_observations_[i].rtt(), variations_value);
     }
   }
 }
 
 void NetworkQualityEstimator::ObtainEffectiveConnectionTypeModelParams(
     const std::map<std::string, std::string>& variation_params) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   for (size_t i = 0; i < EFFECTIVE_CONNECTION_TYPE_LAST; ++i) {
     EffectiveConnectionType effective_connection_type =
         static_cast<EffectiveConnectionType>(i);
-    DCHECK_EQ(InvalidRTT(), connection_thresholds_[i].rtt());
-    DCHECK_EQ(kInvalidThroughput,
+    DCHECK_EQ(nqe::internal::InvalidRTT(), connection_thresholds_[i].rtt());
+    DCHECK_EQ(nqe::internal::kInvalidThroughput,
               connection_thresholds_[i].downstream_throughput_kbps());
     if (effective_connection_type == EFFECTIVE_CONNECTION_TYPE_UNKNOWN)
       continue;
 
     std::string connection_type_name = std::string(
         GetNameForEffectiveConnectionType(effective_connection_type));
 
     int32_t variations_value = kMinimumRTTVariationParameterMsec - 1;
     if (GetValueForVariationParam(
             variation_params, connection_type_name + kThresholdURLRTTMsecSuffix,
             &variations_value) &&
         variations_value >= kMinimumRTTVariationParameterMsec) {
       base::TimeDelta rtt(base::TimeDelta::FromMilliseconds(variations_value));
-      connection_thresholds_[i] = NetworkQuality(
+      connection_thresholds_[i] = nqe::internal::NetworkQuality(
           rtt, connection_thresholds_[i].downstream_throughput_kbps());
 
       // Verify that the RTT values are in decreasing order as the network
       // quality improves.
-      DCHECK(i == 0 || connection_thresholds_[i - 1].rtt() == InvalidRTT() ||
+      DCHECK(i == 0 ||
+             connection_thresholds_[i - 1].rtt() ==
+                 nqe::internal::InvalidRTT() ||
              rtt <= connection_thresholds_[i - 1].rtt());
     }
 
     variations_value = kMinimumThroughputVariationParameterKbps - 1;
     if (GetValueForVariationParam(variation_params,
                                   connection_type_name + kThresholdKbpsSuffix,
                                   &variations_value) &&
         variations_value >= kMinimumThroughputVariationParameterKbps) {
       int32_t throughput_kbps = variations_value;
-      connection_thresholds_[i] =
-          NetworkQuality(connection_thresholds_[i].rtt(), throughput_kbps);
+      connection_thresholds_[i] = nqe::internal::NetworkQuality(
+          connection_thresholds_[i].rtt(), throughput_kbps);
 
       // Verify that the throughput values are in increasing order as the
       // network quality improves.
       DCHECK(i == 0 ||
              connection_thresholds_[i - 1].downstream_throughput_kbps() ==
                  kMinimumThroughputVariationParameterKbps ||
              throughput_kbps >=
                  connection_thresholds_[i - 1].downstream_throughput_kbps());
     }
   }
 }
 
 void NetworkQualityEstimator::AddDefaultEstimates() {
   DCHECK(thread_checker_.CalledOnValidThread());
-  if (default_observations_[current_network_id_.type].rtt() != InvalidRTT()) {
+  if (default_observations_[current_network_id_.type].rtt() !=
+      nqe::internal::InvalidRTT()) {
     RttObservation rtt_observation(
         default_observations_[current_network_id_.type].rtt(),
-        base::TimeTicks::Now(), DEFAULT_FROM_PLATFORM);
+        base::TimeTicks::Now(),
+        NETWORK_QUALITY_OBSERVATION_SOURCE_DEFAULT_FROM_PLATFORM);
     rtt_observations_.AddObservation(rtt_observation);
     NotifyObserversOfRTT(rtt_observation);
   }
   if (default_observations_[current_network_id_.type]
-          .downstream_throughput_kbps() != kInvalidThroughput) {
+          .downstream_throughput_kbps() != nqe::internal::kInvalidThroughput) {
     ThroughputObservation throughput_observation(
         default_observations_[current_network_id_.type]
             .downstream_throughput_kbps(),
-        base::TimeTicks::Now(), DEFAULT_FROM_PLATFORM);
+        base::TimeTicks::Now(),
+        NETWORK_QUALITY_OBSERVATION_SOURCE_DEFAULT_FROM_PLATFORM);
     downstream_throughput_kbps_observations_.AddObservation(
         throughput_observation);
     NotifyObserversOfThroughput(throughput_observation);
   }
 }
 
 NetworkQualityEstimator::~NetworkQualityEstimator() {
   DCHECK(thread_checker_.CalledOnValidThread());
   NetworkChangeNotifier::RemoveConnectionTypeObserver(this);
 }
 
 void NetworkQualityEstimator::NotifyHeadersReceived(const URLRequest& request) {
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("net"),
                "NetworkQualityEstimator::NotifyHeadersReceived");
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (!RequestProvidesUsefulObservations(request))
     return;
 
   // Update |estimated_median_network_quality_| if this is a main frame request.
   if (request.load_flags() & LOAD_MAIN_FRAME) {
     base::TimeDelta rtt;
     if (!GetURLRequestRTTEstimate(&rtt))
-      rtt = InvalidRTT();
+      rtt = nqe::internal::InvalidRTT();
 
     int32_t downstream_throughput_kbps;
     if (!GetDownlinkThroughputKbpsEstimate(&downstream_throughput_kbps))
-      downstream_throughput_kbps = kInvalidThroughput;
+      downstream_throughput_kbps = nqe::internal::kInvalidThroughput;
 
     estimated_median_network_quality_ =
-        NetworkQuality(rtt, downstream_throughput_kbps);
+        nqe::internal::NetworkQuality(rtt, downstream_throughput_kbps);
   }
 
   base::TimeTicks now = base::TimeTicks::Now();
   LoadTimingInfo load_timing_info;
   request.GetLoadTimingInfo(&load_timing_info);
 
   // If the load timing info is unavailable, it probably means that the request
   // did not go over the network.
   if (load_timing_info.send_start.is_null() ||
       load_timing_info.receive_headers_end.is_null()) {
     return;
   }
 
   // Time when the resource was requested.
   base::TimeTicks request_start_time = load_timing_info.send_start;
 
   // Time when the headers were received.
   base::TimeTicks headers_received_time = load_timing_info.receive_headers_end;
 
   // Duration between when the resource was requested and when response
   // headers were received.
   base::TimeDelta observed_rtt = headers_received_time - request_start_time;
   DCHECK_GE(observed_rtt, base::TimeDelta());
   if (observed_rtt < peak_network_quality_.rtt()) {
-    peak_network_quality_ = NetworkQuality(
+    peak_network_quality_ = nqe::internal::NetworkQuality(
         observed_rtt, peak_network_quality_.downstream_throughput_kbps());
   }
 
-  RttObservation rtt_observation(observed_rtt, now, URL_REQUEST);
+  RttObservation rtt_observation(
+      observed_rtt, now, NETWORK_QUALITY_OBSERVATION_SOURCE_URL_REQUEST);
   rtt_observations_.AddObservation(rtt_observation);
   NotifyObserversOfRTT(rtt_observation);
 
   // Compare the RTT observation with the estimated value and record it.
-  if (estimated_median_network_quality_.rtt() != InvalidRTT()) {
+  if (estimated_median_network_quality_.rtt() != nqe::internal::InvalidRTT()) {
     RecordRTTUMA(estimated_median_network_quality_.rtt().InMilliseconds(),
                  observed_rtt.InMilliseconds());
   }
 }
 
 void NetworkQualityEstimator::NotifyRequestCompleted(
     const URLRequest& request) {
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("net"),
                "NetworkQualityEstimator::NotifyRequestCompleted");
   DCHECK(thread_checker_.CalledOnValidThread());
@@ skipping 42 matching lines @@
 
   // Round up |downstream_kbps_as_integer|. If the |downstream_kbps_as_integer|
   // is less than 1, it is set to 1 to differentiate from case when there is no
   // connection.
   if (downstream_kbps - downstream_kbps_as_integer > 0)
     downstream_kbps_as_integer++;
 
   DCHECK_GT(downstream_kbps_as_integer, 0.0);
   if (downstream_kbps_as_integer >
       peak_network_quality_.downstream_throughput_kbps())
-    peak_network_quality_ =
-        NetworkQuality(peak_network_quality_.rtt(), downstream_kbps_as_integer);
+    peak_network_quality_ = nqe::internal::NetworkQuality(
+        peak_network_quality_.rtt(), downstream_kbps_as_integer);
 
-  ThroughputObservation throughput_observation(downstream_kbps_as_integer, now,
-                                               URL_REQUEST);
+  ThroughputObservation throughput_observation(
+      downstream_kbps_as_integer, now,
+      NETWORK_QUALITY_OBSERVATION_SOURCE_URL_REQUEST);
   downstream_throughput_kbps_observations_.AddObservation(
       throughput_observation);
   NotifyObserversOfThroughput(throughput_observation);
 }
 
 void NetworkQualityEstimator::AddRTTObserver(RTTObserver* rtt_observer) {
   DCHECK(thread_checker_.CalledOnValidThread());
   rtt_observer_list_.AddObserver(rtt_observer);
 }
 
@@ skipping 70 matching lines @@
 
 void NetworkQualityEstimator::RecordExternalEstimateProviderMetrics(
     NQEExternalEstimateProviderStatus status) const {
   UMA_HISTOGRAM_ENUMERATION("NQE.ExternalEstimateProviderStatus", status,
                             EXTERNAL_ESTIMATE_PROVIDER_STATUS_BOUNDARY);
 }
 
 void NetworkQualityEstimator::OnConnectionTypeChanged(
     NetworkChangeNotifier::ConnectionType type) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  if (peak_network_quality_.rtt() != InvalidRTT()) {
+  if (peak_network_quality_.rtt() != nqe::internal::InvalidRTT()) {
     base::HistogramBase* rtt_histogram =
         GetHistogram("FastestRTT.", current_network_id_.type, 10 * 1000);
     rtt_histogram->Add(peak_network_quality_.rtt().InMilliseconds());
   }
 
   if (peak_network_quality_.downstream_throughput_kbps() !=
-      kInvalidThroughput) {
+      nqe::internal::kInvalidThroughput) {
     base::HistogramBase* downstream_throughput_histogram =
         GetHistogram("PeakKbps.", current_network_id_.type, 1000 * 1000);
     downstream_throughput_histogram->Add(
         peak_network_quality_.downstream_throughput_kbps());
   }
 
   base::TimeDelta rtt;
   if (GetURLRequestRTTEstimate(&rtt)) {
     // Add the 50th percentile value.
     base::HistogramBase* rtt_percentile =
         GetHistogram("RTT.Percentile50.", current_network_id_.type, 10 * 1000);
     rtt_percentile->Add(rtt.InMilliseconds());
 
     // Add the remaining percentile values.
     static const int kPercentiles[] = {0, 10, 90, 100};
-    std::vector<ObservationSource> disallowed_observation_sources;
-    disallowed_observation_sources.push_back(TCP);
-    disallowed_observation_sources.push_back(QUIC);
+    std::vector<NetworkQualityObservationSource> disallowed_observation_sources;
+    disallowed_observation_sources.push_back(
+        NETWORK_QUALITY_OBSERVATION_SOURCE_TCP);
+    disallowed_observation_sources.push_back(
+        NETWORK_QUALITY_OBSERVATION_SOURCE_QUIC);
     for (size_t i = 0; i < arraysize(kPercentiles); ++i) {
       rtt = GetRTTEstimateInternal(disallowed_observation_sources,
                                    base::TimeTicks(), kPercentiles[i]);
 
       rtt_percentile = GetHistogram(
           "RTT.Percentile" + base::IntToString(kPercentiles[i]) + ".",
           current_network_id_.type, 10 * 1000);  // 10 seconds
       rtt_percentile->Add(rtt.InMilliseconds());
     }
   }
 
   // Write the estimates of the previous network to the cache.
   CacheNetworkQualityEstimate();
 
   // Clear the local state.
   last_connection_change_ = base::TimeTicks::Now();
-  peak_network_quality_ = NetworkQuality();
+  peak_network_quality_ = nqe::internal::NetworkQuality();
   downstream_throughput_kbps_observations_.Clear();
   rtt_observations_.Clear();
   current_network_id_ = GetCurrentNetworkID();
 
   QueryExternalEstimateProvider();
 
   // Read any cached estimates for the new network. If cached estimates are
   // unavailable, add the default estimates.
   if (!ReadCachedNetworkQualityEstimate())
     AddDefaultEstimates();
-  estimated_median_network_quality_ = NetworkQuality();
+  estimated_median_network_quality_ = nqe::internal::NetworkQuality();
 }
 
 NetworkQualityEstimator::EffectiveConnectionType
 NetworkQualityEstimator::GetEffectiveConnectionType() const {
   DCHECK(thread_checker_.CalledOnValidThread());
 
-  base::TimeDelta url_request_rtt = InvalidRTT();
+  base::TimeDelta url_request_rtt = nqe::internal::InvalidRTT();
   if (!GetURLRequestRTTEstimate(&url_request_rtt))
-    url_request_rtt = InvalidRTT();
+    url_request_rtt = nqe::internal::InvalidRTT();
 
-  int32_t kbps = kInvalidThroughput;
+  int32_t kbps = nqe::internal::kInvalidThroughput;
   if (!GetDownlinkThroughputKbpsEstimate(&kbps))
-    kbps = kInvalidThroughput;
+    kbps = nqe::internal::kInvalidThroughput;
 
-  if (url_request_rtt == InvalidRTT() && kbps == kInvalidThroughput) {
+  if (url_request_rtt == nqe::internal::InvalidRTT() &&
+      kbps == nqe::internal::kInvalidThroughput) {
     // Quality of the current network is unknown.
     return EFFECTIVE_CONNECTION_TYPE_UNKNOWN;
   }
 
   // Search from the slowest connection type to the fastest to find the
   // EffectiveConnectionType that best matches the current connection's
   // performance. The match is done by comparing RTT and throughput.
   for (size_t i = 0; i < EFFECTIVE_CONNECTION_TYPE_LAST; ++i) {
     EffectiveConnectionType type = static_cast<EffectiveConnectionType>(i);
     if (i == EFFECTIVE_CONNECTION_TYPE_UNKNOWN)
       continue;
     bool estimated_rtt_is_higher_than_threshold =
-        url_request_rtt != InvalidRTT() &&
-        connection_thresholds_[i].rtt() != InvalidRTT() &&
+        url_request_rtt != nqe::internal::InvalidRTT() &&
+        connection_thresholds_[i].rtt() != nqe::internal::InvalidRTT() &&
         url_request_rtt >= connection_thresholds_[i].rtt();
     bool estimated_throughput_is_lower_than_threshold =
-        kbps != kInvalidThroughput &&
+        kbps != nqe::internal::kInvalidThroughput &&
         connection_thresholds_[i].downstream_throughput_kbps() !=
-            kInvalidThroughput &&
+            nqe::internal::kInvalidThroughput &&
         kbps <= connection_thresholds_[i].downstream_throughput_kbps();
     // Return |type| as the effective connection type if the current network's
     // RTT is worse than the threshold RTT for |type|, or if the current
     // network's throughput is lower than the threshold throughput for |type|.
     if (estimated_rtt_is_higher_than_threshold ||
         estimated_throughput_is_lower_than_threshold) {
       return type;
     }
   }
   // Return the fastest connection type.
   return static_cast<EffectiveConnectionType>(EFFECTIVE_CONNECTION_TYPE_LAST -
                                               1);
 }
 
 bool NetworkQualityEstimator::GetURLRequestRTTEstimate(
     base::TimeDelta* rtt) const {
   DCHECK(thread_checker_.CalledOnValidThread());
-  std::vector<ObservationSource> disallowed_observation_sources;
-  disallowed_observation_sources.push_back(TCP);
-  disallowed_observation_sources.push_back(QUIC);
+  std::vector<NetworkQualityObservationSource> disallowed_observation_sources;
+  disallowed_observation_sources.push_back(
+      NETWORK_QUALITY_OBSERVATION_SOURCE_TCP);
+  disallowed_observation_sources.push_back(
+      NETWORK_QUALITY_OBSERVATION_SOURCE_QUIC);
   *rtt = GetRTTEstimateInternal(disallowed_observation_sources,
                                 base::TimeTicks(), 50);
-  return (*rtt != InvalidRTT());
+  return (*rtt != nqe::internal::InvalidRTT());
 }
 
 bool NetworkQualityEstimator::GetDownlinkThroughputKbpsEstimate(
     int32_t* kbps) const {
   DCHECK(thread_checker_.CalledOnValidThread());
   *kbps = GetDownlinkThroughputKbpsEstimateInternal(base::TimeTicks(), 50);
-  return (*kbps != kInvalidThroughput);
+  return (*kbps != nqe::internal::kInvalidThroughput);
 }
 
 bool NetworkQualityEstimator::GetRecentURLRequestRTTMedian(
     const base::TimeTicks& begin_timestamp,
     base::TimeDelta* rtt) const {
   DCHECK(thread_checker_.CalledOnValidThread());
-  std::vector<ObservationSource> disallowed_observation_sources;
-  disallowed_observation_sources.push_back(TCP);
-  disallowed_observation_sources.push_back(QUIC);
+  std::vector<NetworkQualityObservationSource> disallowed_observation_sources;
+  disallowed_observation_sources.push_back(
+      NETWORK_QUALITY_OBSERVATION_SOURCE_TCP);
+  disallowed_observation_sources.push_back(
+      NETWORK_QUALITY_OBSERVATION_SOURCE_QUIC);
   *rtt = GetRTTEstimateInternal(disallowed_observation_sources, begin_timestamp,
                                 50);
-  return (*rtt != InvalidRTT());
+  return (*rtt != nqe::internal::InvalidRTT());
 }
 
 bool NetworkQualityEstimator::GetRecentMedianDownlinkThroughputKbps(
     const base::TimeTicks& begin_timestamp,
     int32_t* kbps) const {
   DCHECK(thread_checker_.CalledOnValidThread());
   *kbps = GetDownlinkThroughputKbpsEstimateInternal(begin_timestamp, 50);
-  return (*kbps != kInvalidThroughput);
+  return (*kbps != nqe::internal::kInvalidThroughput);
 }
 
-template <typename ValueType>
-NetworkQualityEstimator::ObservationBuffer<ValueType>::ObservationBuffer(
-    double weight_multiplier_per_second)
-    : weight_multiplier_per_second_(weight_multiplier_per_second) {
-  static_assert(kMaximumObservationsBufferSize > 0U,
-                "Minimum size of observation buffer must be > 0");
-  DCHECK_GE(weight_multiplier_per_second_, 0.0);
-  DCHECK_LE(weight_multiplier_per_second_, 1.0);
-}
-
-template <typename ValueType>
-NetworkQualityEstimator::ObservationBuffer<ValueType>::~ObservationBuffer() {}
-
 base::TimeDelta NetworkQualityEstimator::GetRTTEstimateInternal(
-    const std::vector<ObservationSource>& disallowed_observation_sources,
+    const std::vector<NetworkQualityObservationSource>&
+        disallowed_observation_sources,
     const base::TimeTicks& begin_timestamp,
     int percentile) const {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // RTT observations are sorted by duration from shortest to longest, thus
   // a higher percentile RTT will have a longer RTT than a lower percentile.
-  base::TimeDelta rtt = InvalidRTT();
+  base::TimeDelta rtt = nqe::internal::InvalidRTT();
   if (!rtt_observations_.GetPercentile(begin_timestamp, &rtt, percentile,
                                        disallowed_observation_sources)) {
-    return InvalidRTT();
+    return nqe::internal::InvalidRTT();
   }
   return rtt;
 }
 
 int32_t NetworkQualityEstimator::GetDownlinkThroughputKbpsEstimateInternal(
     const base::TimeTicks& begin_timestamp,
     int percentile) const {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // Throughput observations are sorted by kbps from slowest to fastest,
   // thus a higher percentile throughput will be faster than a lower one.
-  int32_t kbps = kInvalidThroughput;
+  int32_t kbps = nqe::internal::kInvalidThroughput;
   if (!downstream_throughput_kbps_observations_.GetPercentile(
           begin_timestamp, &kbps, 100 - percentile,
-          std::vector<ObservationSource>())) {
-    return kInvalidThroughput;
+          std::vector<NetworkQualityObservationSource>())) {
+    return nqe::internal::kInvalidThroughput;
   }
   return kbps;
 }
 
-template <typename ValueType>
-void NetworkQualityEstimator::ObservationBuffer<ValueType>::
-    ComputeWeightedObservations(
-        const base::TimeTicks& begin_timestamp,
-        std::vector<WeightedObservation<ValueType>>& weighted_observations,
-        double* total_weight,
-        const std::vector<ObservationSource>& disallowed_observation_sources)
-        const {
-  weighted_observations.clear();
-  double total_weight_observations = 0.0;
-  base::TimeTicks now = base::TimeTicks::Now();
-
-  for (const auto& observation : observations_) {
-    if (observation.timestamp < begin_timestamp)
-      continue;
-    bool disallowed = false;
-    for (const auto& disallowed_source : disallowed_observation_sources) {
-      if (disallowed_source == observation.source)
-        disallowed = true;
-    }
-    if (disallowed)
-      continue;
-    base::TimeDelta time_since_sample_taken = now - observation.timestamp;
-    double weight =
-        pow(weight_multiplier_per_second_, time_since_sample_taken.InSeconds());
-    weight = std::max(DBL_MIN, std::min(1.0, weight));
-
-    weighted_observations.push_back(
-        WeightedObservation<ValueType>(observation.value, weight));
-    total_weight_observations += weight;
-  }
-
-  // Sort the samples by value in ascending order.
-  std::sort(weighted_observations.begin(), weighted_observations.end());
-  *total_weight = total_weight_observations;
-}
-
-template <typename ValueType>
-bool NetworkQualityEstimator::ObservationBuffer<ValueType>::GetPercentile(
-    const base::TimeTicks& begin_timestamp,
-    ValueType* result,
-    int percentile,
-    const std::vector<ObservationSource>& disallowed_observation_sources)
-    const {
-  DCHECK(result);
-  DCHECK_GE(percentile, 0);
-  DCHECK_LE(percentile, 100);
-
-  // Stores WeightedObservation in increasing order of value.
-  std::vector<WeightedObservation<ValueType>> weighted_observations;
-
-  // Total weight of all observations in |weighted_observations|.
-  double total_weight = 0.0;
-
-  ComputeWeightedObservations(begin_timestamp, weighted_observations,
-                              &total_weight, disallowed_observation_sources);
-  if (weighted_observations.empty())
-    return false;
-
-  DCHECK(!weighted_observations.empty());
-  DCHECK_GT(total_weight, 0.0);
-
-  // weighted_observations may have a smaller size than observations_ since the
-  // former contains only the observations later than begin_timestamp.
-  DCHECK_GE(observations_.size(), weighted_observations.size());
-
-  double desired_weight = percentile / 100.0 * total_weight;
-
-  double cumulative_weight_seen_so_far = 0.0;
-  for (const auto& weighted_observation : weighted_observations) {
-    cumulative_weight_seen_so_far += weighted_observation.weight;
-
-    if (cumulative_weight_seen_so_far >= desired_weight) {
-      *result = weighted_observation.value;
-      return true;
-    }
-  }
-
-  // Computation may reach here due to floating point errors. This may happen
-  // if |percentile| was 100 (or close to 100), and |desired_weight| was
-  // slightly larger than |total_weight| (due to floating point errors).
-  // In this case, we return the highest |value| among all observations.
-  // This is same as value of the last observation in the sorted vector.
-  *result = weighted_observations.at(weighted_observations.size() - 1).value;
-  return true;
-}
-
 NetworkQualityEstimator::NetworkID
 NetworkQualityEstimator::GetCurrentNetworkID() const {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // TODO(tbansal): crbug.com/498068 Add NetworkQualityEstimatorAndroid class
   // that overrides this method on the Android platform.
 
   // It is possible that the connection type changed between when
   // GetConnectionType() was called and when the API to determine the
   // network name was called. Check if that happened and retry until the
@@ skipping 40 matching lines @@
   // If the network name is unavailable, caching should not be performed.
   if (current_network_id_.id.empty())
     return false;
 
   CachedNetworkQualities::const_iterator it =
       cached_network_qualities_.find(current_network_id_);
 
   if (it == cached_network_qualities_.end())
     return false;
 
-  NetworkQuality network_quality(it->second.network_quality());
+  nqe::internal::NetworkQuality network_quality(it->second.network_quality());
 
-  DCHECK_NE(InvalidRTT(), network_quality.rtt());
-  DCHECK_NE(kInvalidThroughput, network_quality.downstream_throughput_kbps());
+  DCHECK_NE(nqe::internal::InvalidRTT(), network_quality.rtt());
+  DCHECK_NE(nqe::internal::kInvalidThroughput,
+            network_quality.downstream_throughput_kbps());
 
   ThroughputObservation througphput_observation(
       network_quality.downstream_throughput_kbps(), base::TimeTicks::Now(),
-      CACHED_ESTIMATE);
+      NETWORK_QUALITY_OBSERVATION_SOURCE_CACHED_ESTIMATE);
   downstream_throughput_kbps_observations_.AddObservation(
       througphput_observation);
   NotifyObserversOfThroughput(througphput_observation);
 
-  RttObservation rtt_observation(network_quality.rtt(), base::TimeTicks::Now(),
-                                 CACHED_ESTIMATE);
+  RttObservation rtt_observation(
+      network_quality.rtt(), base::TimeTicks::Now(),
+      NETWORK_QUALITY_OBSERVATION_SOURCE_CACHED_ESTIMATE);
   rtt_observations_.AddObservation(rtt_observation);
   NotifyObserversOfRTT(rtt_observation);
 
   return true;
 }
 
 void NetworkQualityEstimator::OnUpdatedEstimateAvailable() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(external_estimate_provider_);
 
@@ skipping 51 matching lines @@
   }
 
   RecordExternalEstimateProviderMetrics(
       EXTERNAL_ESTIMATE_PROVIDER_STATUS_QUERY_SUCCESSFUL);
   base::TimeDelta rtt;
   if (external_estimate_provider_->GetRTT(&rtt)) {
     RecordExternalEstimateProviderMetrics(
         EXTERNAL_ESTIMATE_PROVIDER_STATUS_RTT_AVAILABLE);
     UMA_HISTOGRAM_TIMES("NQE.ExternalEstimateProvider.RTT", rtt);
     rtt_observations_.AddObservation(
-        RttObservation(rtt, base::TimeTicks::Now(), EXTERNAL_ESTIMATE));
+        RttObservation(rtt, base::TimeTicks::Now(),
+                       NETWORK_QUALITY_OBSERVATION_SOURCE_EXTERNAL_ESTIMATE));
   }
 
   int32_t downstream_throughput_kbps;
   if (external_estimate_provider_->GetDownstreamThroughputKbps(
           &downstream_throughput_kbps)) {
     RecordExternalEstimateProviderMetrics(
         EXTERNAL_ESTIMATE_PROVIDER_STATUS_DOWNLINK_BANDWIDTH_AVAILABLE);
     UMA_HISTOGRAM_COUNTS("NQE.ExternalEstimateProvider.DownlinkBandwidth",
                          downstream_throughput_kbps);
     downstream_throughput_kbps_observations_.AddObservation(
-        ThroughputObservation(downstream_throughput_kbps,
-                              base::TimeTicks::Now(), EXTERNAL_ESTIMATE));
+        ThroughputObservation(
+            downstream_throughput_kbps, base::TimeTicks::Now(),
+            NETWORK_QUALITY_OBSERVATION_SOURCE_EXTERNAL_ESTIMATE));
   }
 }
 
 void NetworkQualityEstimator::CacheNetworkQualityEstimate() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK_LE(cached_network_qualities_.size(),
             static_cast<size_t>(kMaximumNetworkQualityCacheSize));
 
   // If the network name is unavailable, caching should not be performed.
   if (current_network_id_.id.empty())
     return;
 
-  base::TimeDelta rtt = InvalidRTT();
-  int32_t downlink_throughput_kbps = kInvalidThroughput;
+  base::TimeDelta rtt = nqe::internal::InvalidRTT();
+  int32_t downlink_throughput_kbps = nqe::internal::kInvalidThroughput;
 
   if (!GetURLRequestRTTEstimate(&rtt) ||
       !GetDownlinkThroughputKbpsEstimate(&downlink_throughput_kbps)) {
     return;
   }
 
-  NetworkQuality network_quality =
-      NetworkQuality(rtt, downlink_throughput_kbps);
+  nqe::internal::NetworkQuality network_quality =
+      nqe::internal::NetworkQuality(rtt, downlink_throughput_kbps);
 
   if (cached_network_qualities_.size() == kMaximumNetworkQualityCacheSize) {
     // Remove the oldest entry.
     CachedNetworkQualities::iterator oldest_entry_iterator =
         cached_network_qualities_.begin();
 
     for (CachedNetworkQualities::iterator it =
              cached_network_qualities_.begin();
          it != cached_network_qualities_.end(); ++it) {
       if ((it->second).OlderThan(oldest_entry_iterator->second))
         oldest_entry_iterator = it;
     }
     cached_network_qualities_.erase(oldest_entry_iterator);
   }
   DCHECK_LT(cached_network_qualities_.size(),
             static_cast<size_t>(kMaximumNetworkQualityCacheSize));
 
-  cached_network_qualities_.insert(std::make_pair(
-      current_network_id_, CachedNetworkQuality(network_quality)));
+  cached_network_qualities_.insert(
+      std::make_pair(current_network_id_,
+                     nqe::internal::CachedNetworkQuality(network_quality)));
   DCHECK_LE(cached_network_qualities_.size(),
             static_cast<size_t>(kMaximumNetworkQualityCacheSize));
 }
 
 void NetworkQualityEstimator::OnUpdatedRTTAvailable(
     SocketPerformanceWatcherFactory::Protocol protocol,
     const base::TimeDelta& rtt) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   switch (protocol) {
     case SocketPerformanceWatcherFactory::PROTOCOL_TCP:
-      NotifyObserversOfRTT(RttObservation(rtt, base::TimeTicks::Now(), TCP));
+      NotifyObserversOfRTT(RttObservation(
+          rtt, base::TimeTicks::Now(), NETWORK_QUALITY_OBSERVATION_SOURCE_TCP));
       return;
     case SocketPerformanceWatcherFactory::PROTOCOL_QUIC:
-      NotifyObserversOfRTT(RttObservation(rtt, base::TimeTicks::Now(), QUIC));
+      NotifyObserversOfRTT(
+          RttObservation(rtt, base::TimeTicks::Now(),
+                         NETWORK_QUALITY_OBSERVATION_SOURCE_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));
 }
 
-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_) {}
-
-NetworkQualityEstimator::CachedNetworkQuality::~CachedNetworkQuality() {}
-
-bool NetworkQualityEstimator::CachedNetworkQuality::OlderThan(
-    const CachedNetworkQuality& cached_network_quality) const {
-  return last_update_time_ < cached_network_quality.last_update_time_;
-}
-
-NetworkQualityEstimator::NetworkQuality::NetworkQuality()
-    : NetworkQuality(NetworkQualityEstimator::InvalidRTT(),
-                     NetworkQualityEstimator::kInvalidThroughput) {}
-
-NetworkQualityEstimator::NetworkQuality::NetworkQuality(
-    const base::TimeDelta& rtt,
-    int32_t downstream_throughput_kbps)
-    : rtt_(rtt), downstream_throughput_kbps_(downstream_throughput_kbps) {
-  DCHECK_GE(rtt_, base::TimeDelta());
-  DCHECK_GE(downstream_throughput_kbps_, 0);
-}
-
-NetworkQualityEstimator::NetworkQuality::NetworkQuality(
-    const NetworkQuality& other)
-    : NetworkQuality(other.rtt_, other.downstream_throughput_kbps_) {}
-
-NetworkQualityEstimator::NetworkQuality::~NetworkQuality() {}
-
-NetworkQualityEstimator::NetworkQuality&
-NetworkQualityEstimator::NetworkQuality::operator=(
-    const NetworkQuality& other) {
-  rtt_ = other.rtt_;
-  downstream_throughput_kbps_ = other.downstream_throughput_kbps_;
-  return *this;
-}
-
 }  // namespace net