Expose a method GetRecentEffectiveConnectionType in NQE.

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 682 matching lines @@
           "TransportRTT.Percentile" + base::IntToString(kPercentiles[i]) + ".",
           current_network_id_.type, 10 * 1000);  // 10 seconds
       transport_rtt_percentile->Add(rtt.InMilliseconds());
     }
   }
 }
 
 NetworkQualityEstimator::EffectiveConnectionType
 NetworkQualityEstimator::GetEffectiveConnectionType() const {
   DCHECK(thread_checker_.CalledOnValidThread());
+  return GetRecentEffectiveConnectionType(base::TimeTicks());
+}
+
+NetworkQualityEstimator::EffectiveConnectionType
+NetworkQualityEstimator::GetRecentEffectiveConnectionType(
+    const base::TimeTicks& start_time) const {
+  DCHECK(thread_checker_.CalledOnValidThread());
 
   // If the device is currently offline, then return
   // EFFECTIVE_CONNECTION_TYPE_OFFLINE.
   if (GetCurrentNetworkID().type == NetworkChangeNotifier::CONNECTION_NONE)
     return EFFECTIVE_CONNECTION_TYPE_OFFLINE;
 
   base::TimeDelta http_rtt = nqe::internal::InvalidRTT();
-  if (!GetHttpRTTEstimate(&http_rtt))
+  if (!GetRecentHttpRTTMedian(start_time, &http_rtt))
     http_rtt = nqe::internal::InvalidRTT();
 
   int32_t kbps = nqe::internal::kInvalidThroughput;
-  if (!GetDownlinkThroughputKbpsEstimate(&kbps))
+  if (!GetRecentMedianDownlinkThroughputKbps(start_time, &kbps))
     kbps = nqe::internal::kInvalidThroughput;
 
   if (http_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_http_rtt_is_higher_than_threshold =
         http_rtt != nqe::internal::InvalidRTT() &&
         connection_thresholds_[i].http_rtt() != nqe::internal::InvalidRTT() &&
         http_rtt >= connection_thresholds_[i].http_rtt();
     bool estimated_throughput_is_lower_than_threshold =
         kbps != nqe::internal::kInvalidThroughput &&
         connection_thresholds_[i].downstream_throughput_kbps() !=
             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_http_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::GetHttpRTTEstimate(base::TimeDelta* rtt) const {
   DCHECK(thread_checker_.CalledOnValidThread());
-  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 != nqe::internal::InvalidRTT());
+  return GetRecentHttpRTTMedian(base::TimeTicks(), rtt);
 }
 
 bool NetworkQualityEstimator::GetTransportRTTEstimate(
     base::TimeDelta* rtt) const {
   DCHECK(thread_checker_.CalledOnValidThread());
-  std::vector<NetworkQualityObservationSource> disallowed_observation_sources;
-  disallowed_observation_sources.push_back(
-      NETWORK_QUALITY_OBSERVATION_SOURCE_URL_REQUEST);
-  // Disallow external estimate provider since it provides RTT at HTTP layer.
-  disallowed_observation_sources.push_back(
-      NETWORK_QUALITY_OBSERVATION_SOURCE_EXTERNAL_ESTIMATE);
-  disallowed_observation_sources.push_back(
-      NETWORK_QUALITY_OBSERVATION_SOURCE_CACHED_ESTIMATE);
-  disallowed_observation_sources.push_back(
-      NETWORK_QUALITY_OBSERVATION_SOURCE_DEFAULT_FROM_PLATFORM);
-
-  *rtt = GetRTTEstimateInternal(disallowed_observation_sources,
-                                base::TimeTicks(), 50);
-  return (*rtt != nqe::internal::InvalidRTT());
+  return GetRecentTransportRTTMedian(base::TimeTicks(), rtt);
 }
 
 bool NetworkQualityEstimator::GetDownlinkThroughputKbpsEstimate(
     int32_t* kbps) const {
   DCHECK(thread_checker_.CalledOnValidThread());
-  *kbps = GetDownlinkThroughputKbpsEstimateInternal(base::TimeTicks(), 50);
-  return (*kbps != nqe::internal::kInvalidThroughput);
+  return GetRecentMedianDownlinkThroughputKbps(base::TimeTicks(), kbps);
 }
 
 bool NetworkQualityEstimator::GetRecentHttpRTTMedian(
     const base::TimeTicks& start_time,
     base::TimeDelta* rtt) const {
   DCHECK(thread_checker_.CalledOnValidThread());
   std::vector<NetworkQualityObservationSource> disallowed_observation_sources;
   disallowed_observation_sources.push_back(
       NETWORK_QUALITY_OBSERVATION_SOURCE_TCP);
   disallowed_observation_sources.push_back(
@@ skipping 328 matching lines @@
   }
   ThroughputObservation throughput_observation(
       downstream_kbps, base::TimeTicks::Now(),
       NETWORK_QUALITY_OBSERVATION_SOURCE_URL_REQUEST);
   downstream_throughput_kbps_observations_.AddObservation(
       throughput_observation);
   NotifyObserversOfThroughput(throughput_observation);
 }
 
 }  // namespace net