Pass parsed network quality estimator params when constructing 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>
 #include <vector>
 
 #include "base/bind_helpers.h"
 #include "base/location.h"
 #include "base/logging.h"
+#include "base/memory/ptr_util.h"
 #include "base/metrics/histogram.h"
 #include "base/metrics/histogram_base.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/metrics/sparse_histogram.h"
 #include "base/rand_util.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_piece.h"
 #include "base/strings/stringprintf.h"
 #include "base/threading/thread_task_runner_handle.h"
@@ skipping 27 matching lines @@
 // |max_limit| is the maximum value that can be stored in the histogram.
 base::HistogramBase* GetHistogram(const std::string& statistic_name,
                                   NetworkChangeNotifier::ConnectionType type,
                                   int32_t max_limit) {
   const base::LinearHistogram::Sample kLowerLimit = 1;
   DCHECK_GT(max_limit, kLowerLimit);
   const size_t kBucketCount = 50;
 
   return base::Histogram::FactoryGet(
       "NQE." + statistic_name +
-          nqe::internal::NetworkQualityEstimatorParams::
-              GetNameForConnectionType(type),
+          NetworkQualityEstimatorParams::GetNameForConnectionType(type),
       kLowerLimit, max_limit, kBucketCount,
       base::HistogramBase::kUmaTargetedHistogramFlag);
 }
 
 NetworkQualityObservationSource ProtocolSourceToObservationSource(
     SocketPerformanceWatcherFactory::Protocol protocol) {
   switch (protocol) {
     case SocketPerformanceWatcherFactory::PROTOCOL_TCP:
       return NETWORK_QUALITY_OBSERVATION_SOURCE_TCP;
     case SocketPerformanceWatcherFactory::PROTOCOL_QUIC:
@@ skipping 129 matching lines @@
       histogram_name, 0, EFFECTIVE_CONNECTION_TYPE_LAST,
       EFFECTIVE_CONNECTION_TYPE_LAST /* Number of buckets */,
       base::HistogramBase::kUmaTargetedHistogramFlag);
   histogram->Add(std::abs(metric));
 }
 
 }  // namespace
 
 NetworkQualityEstimator::NetworkQualityEstimator(
     std::unique_ptr<ExternalEstimateProvider> external_estimates_provider,
-    const std::map<std::string, std::string>& variation_params,
-    NetLog* net_log)
-    : NetworkQualityEstimator(std::move(external_estimates_provider),
-                              variation_params,
-                              false,
-                              false,
-                              net_log) {}
-
-NetworkQualityEstimator::NetworkQualityEstimator(
-    std::unique_ptr<ExternalEstimateProvider> external_estimates_provider,
-    const std::map<std::string, std::string>& variation_params,
-    bool use_local_host_requests_for_tests,
-    bool use_smaller_responses_for_tests,
+    std::unique_ptr<NetworkQualityEstimatorParams> params,
     NetLog* net_log)
     : NetworkQualityEstimator(
           std::move(external_estimates_provider),
-          variation_params,
-          use_local_host_requests_for_tests,
-          use_smaller_responses_for_tests,
+          std::move(params),
+          false,
+          false,
           true,
           NetLogWithSource::Make(
               net_log,
               net::NetLogSourceType::NETWORK_QUALITY_ESTIMATOR)) {}
 
 NetworkQualityEstimator::NetworkQualityEstimator(
     std::unique_ptr<ExternalEstimateProvider> external_estimates_provider,
-    const std::map<std::string, std::string>& variation_params,
+    std::unique_ptr<NetworkQualityEstimatorParams> params,
     bool use_local_host_requests_for_tests,
     bool use_smaller_responses_for_tests,
     bool add_default_platform_observations,
     const NetLogWithSource& net_log)
     : algorithm_name_to_enum_({{"HttpRTTAndDownstreamThroughput",
                                 EffectiveConnectionTypeAlgorithm::
                                     HTTP_RTT_AND_DOWNSTREAM_THROUGHOUT},
                                {"TransportRTTOrDownstreamThroughput",
                                 EffectiveConnectionTypeAlgorithm::
                                     TRANSPORT_RTT_OR_DOWNSTREAM_THROUGHOUT}}),
-      params_(variation_params),
+      params_(std::move(params)),
       use_localhost_requests_(use_local_host_requests_for_tests),
       use_small_responses_(use_smaller_responses_for_tests),
       disable_offline_check_(false),
       add_default_platform_observations_(add_default_platform_observations),
       effective_connection_type_algorithm_(
           algorithm_name_to_enum_.find(
-              params_.GetEffectiveConnectionTypeAlgorithm()) ==
+              params_->GetEffectiveConnectionTypeAlgorithm()) ==
                   algorithm_name_to_enum_.end()
               ? kDefaultEffectiveConnectionTypeAlgorithm
               : algorithm_name_to_enum_
-                    .find(params_.GetEffectiveConnectionTypeAlgorithm())
+                    .find(params_->GetEffectiveConnectionTypeAlgorithm())
                     ->second),
       tick_clock_(new base::DefaultTickClock()),
       last_connection_change_(tick_clock_->NowTicks()),
       current_network_id_(nqe::internal::NetworkID(
           NetworkChangeNotifier::ConnectionType::CONNECTION_UNKNOWN,
           std::string())),
       downstream_throughput_kbps_observations_(
-          params_.weight_multiplier_per_second(),
-          params_.weight_multiplier_per_dbm()),
-      rtt_observations_(params_.weight_multiplier_per_second(),
-                        params_.weight_multiplier_per_dbm()),
+          params_->weight_multiplier_per_second(),
+          params_->weight_multiplier_per_dbm()),
+      rtt_observations_(params_->weight_multiplier_per_second(),
+                        params_->weight_multiplier_per_dbm()),
       effective_connection_type_at_last_main_frame_(
           EFFECTIVE_CONNECTION_TYPE_UNKNOWN),
       external_estimate_provider_(std::move(external_estimates_provider)),
       effective_connection_type_recomputation_interval_(
           base::TimeDelta::FromSeconds(10)),
       rtt_observations_size_at_last_ect_computation_(0),
       throughput_observations_size_at_last_ect_computation_(0),
       effective_connection_type_(EFFECTIVE_CONNECTION_TYPE_UNKNOWN),
       signal_strength_dbm_(INT32_MIN),
       min_signal_strength_since_connection_change_(INT32_MAX),
@@ skipping 28 matching lines @@
         EXTERNAL_ESTIMATE_PROVIDER_STATUS_AVAILABLE);
     external_estimate_provider_->SetUpdatedEstimateDelegate(this);
   } else {
     RecordExternalEstimateProviderMetrics(
         EXTERNAL_ESTIMATE_PROVIDER_STATUS_NOT_AVAILABLE);
   }
   current_network_id_ = GetCurrentNetworkID();
   AddDefaultEstimates();
 
   throughput_analyzer_.reset(new nqe::internal::ThroughputAnalyzer(
-      &params_, base::ThreadTaskRunnerHandle::Get(),
+      params_.get(), base::ThreadTaskRunnerHandle::Get(),
       base::Bind(&NetworkQualityEstimator::OnNewThroughputObservationAvailable,
                  base::Unretained(this)),
       use_localhost_requests_, use_smaller_responses_for_tests));
 
   watcher_factory_.reset(new nqe::internal::SocketWatcherFactory(
       base::ThreadTaskRunnerHandle::Get(),
-      params_.min_socket_watcher_notification_interval(),
+      params_->min_socket_watcher_notification_interval(),
       base::Bind(&NetworkQualityEstimator::OnUpdatedRTTAvailable,
                  base::Unretained(this)),
       tick_clock_.get()));
 
   // Record accuracy after a 15 second interval. The values used here must
   // remain in sync with the suffixes specified in
   // tools/metrics/histograms/histograms.xml.
   accuracy_recording_intervals_.push_back(base::TimeDelta::FromSeconds(15));
 
   for (int i = 0; i < STATISTIC_LAST; ++i)
     http_rtt_at_last_main_frame_[i] = nqe::internal::InvalidRTT();
 }
 
 void NetworkQualityEstimator::AddDefaultEstimates() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (!add_default_platform_observations_)
     return;
 
-  if (params_.DefaultObservation(current_network_id_.type).http_rtt() !=
+  if (params_->DefaultObservation(current_network_id_.type).http_rtt() !=
       nqe::internal::InvalidRTT()) {
     RttObservation rtt_observation(
-        params_.DefaultObservation(current_network_id_.type).http_rtt(),
+        params_->DefaultObservation(current_network_id_.type).http_rtt(),
         tick_clock_->NowTicks(), INT32_MIN,
         NETWORK_QUALITY_OBSERVATION_SOURCE_DEFAULT_HTTP_FROM_PLATFORM);
     rtt_observations_.AddObservation(rtt_observation);
     NotifyObserversOfRTT(rtt_observation);
   }
 
-  if (params_.DefaultObservation(current_network_id_.type).transport_rtt() !=
+  if (params_->DefaultObservation(current_network_id_.type).transport_rtt() !=
       nqe::internal::InvalidRTT()) {
     RttObservation rtt_observation(
-        params_.DefaultObservation(current_network_id_.type).transport_rtt(),
+        params_->DefaultObservation(current_network_id_.type).transport_rtt(),
         tick_clock_->NowTicks(), INT32_MIN,
         NETWORK_QUALITY_OBSERVATION_SOURCE_DEFAULT_TRANSPORT_FROM_PLATFORM);
     rtt_observations_.AddObservation(rtt_observation);
     NotifyObserversOfRTT(rtt_observation);
   }
 
-  if (params_.DefaultObservation(current_network_id_.type)
+  if (params_->DefaultObservation(current_network_id_.type)
           .downstream_throughput_kbps() != nqe::internal::kInvalidThroughput) {
     ThroughputObservation throughput_observation(
-        params_.DefaultObservation(current_network_id_.type)
+        params_->DefaultObservation(current_network_id_.type)
             .downstream_throughput_kbps(),
         tick_clock_->NowTicks(), INT32_MIN,
         NETWORK_QUALITY_OBSERVATION_SOURCE_DEFAULT_HTTP_FROM_PLATFORM);
     downstream_throughput_kbps_observations_.AddObservation(
         throughput_observation);
     NotifyObserversOfThroughput(throughput_observation);
   }
 }
 
 NetworkQualityEstimator::~NetworkQualityEstimator() {
@@ skipping 224 matching lines @@
   RecordCorrelationMetric(request, net_error);
 }
 
 void NetworkQualityEstimator::RecordCorrelationMetric(const URLRequest& request,
                                                       int net_error) const {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // The histogram is recorded randomly to reduce overhead involved with sparse
   // histograms. Furthermore, recording the correlation on each request is
   // unnecessary.
-  if (RandDouble() >= params_.correlation_uma_logging_probability())
+  if (RandDouble() >= params_->correlation_uma_logging_probability())
     return;
 
   if (request.response_info().was_cached ||
       !request.response_info().network_accessed) {
     return;
   }
 
   LoadTimingInfo load_timing_info;
   request.GetLoadTimingInfo(&load_timing_info);
   // If the load timing info is unavailable, it probably means that the request
@@ skipping 139 matching lines @@
   disable_offline_check_ = disable_offline_check;
   network_quality_store_->DisableOfflineCheckForTesting(disable_offline_check_);
 }
 
 void NetworkQualityEstimator::ReportEffectiveConnectionTypeForTesting(
     EffectiveConnectionType effective_connection_type) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   event_creator_.MaybeAddNetworkQualityChangedEventToNetLog(
       effective_connection_type_,
-      params_.TypicalNetworkQuality(effective_connection_type));
+      params_->TypicalNetworkQuality(effective_connection_type));
 
   for (auto& observer : effective_connection_type_observer_list_)
     observer.OnEffectiveConnectionTypeChanged(effective_connection_type);
 
   network_quality_store_->Add(current_network_id_,
                               nqe::internal::CachedNetworkQuality(
                                   tick_clock_->NowTicks(), network_quality_,
                                   effective_connection_type));
 }
 
@@ skipping 38 matching lines @@
                                last_effective_connection_type_computation_,
                                network_quality_, effective_connection_type_));
 
   // Clear the local state.
   last_connection_change_ = tick_clock_->NowTicks();
   peak_network_quality_ = nqe::internal::NetworkQuality();
   downstream_throughput_kbps_observations_.Clear();
   rtt_observations_.Clear();
 
 #if defined(OS_ANDROID)
-  if (params_.weight_multiplier_per_dbm() < 1.0 &&
+  if (params_->weight_multiplier_per_dbm() < 1.0 &&
       NetworkChangeNotifier::IsConnectionCellular(current_network_id_.type)) {
     UMA_HISTOGRAM_BOOLEAN(
         "NQE.CellularSignalStrengthAvailable",
         min_signal_strength_since_connection_change_ != INT32_MAX &&
             max_signal_strength_since_connection_change_ != INT32_MIN);
 
     if (min_signal_strength_since_connection_change_ != INT32_MAX &&
         max_signal_strength_since_connection_change_ != INT32_MIN) {
       UMA_HISTOGRAM_COUNTS_100(
           "NQE.CellularSignalStrengthDifference",
@@ skipping 41 matching lines @@
       current_network_id_.type != NetworkChangeNotifier::CONNECTION_ETHERNET &&
       current_network_id_.type != NetworkChangeNotifier::CONNECTION_BLUETOOTH) {
     RecordExternalEstimateProviderMetrics(
         EXTERNAL_ESTIMATE_PROVIDER_STATUS_QUERIED);
     external_estimate_provider_->Update();
   }
 }
 
 void NetworkQualityEstimator::UpdateSignalStrength() {
 #if defined(OS_ANDROID)
-  if (params_.weight_multiplier_per_dbm() >= 1.0 ||
+  if (params_->weight_multiplier_per_dbm() >= 1.0 ||
       !NetworkChangeNotifier::IsConnectionCellular(current_network_id_.type) ||
       !android::cellular_signal_strength::GetSignalStrengthDbm(
           &signal_strength_dbm_)) {
     signal_strength_dbm_ = INT32_MIN;
   }
   min_signal_strength_since_connection_change_ = std::min(
       min_signal_strength_since_connection_change_, signal_strength_dbm_);
   max_signal_strength_since_connection_change_ = std::max(
       max_signal_strength_since_connection_change_, signal_strength_dbm_);
 #endif  // OS_ANDROID
@@ skipping 114 matching lines @@
       "NQE.EstimateAvailable.MainFrame.Kbps",
       estimated_quality_at_last_main_frame_.downstream_throughput_kbps() !=
           nqe::internal::kInvalidThroughput);
 
   UMA_HISTOGRAM_ENUMERATION("NQE.MainFrame.EffectiveConnectionType",
                             effective_connection_type_at_last_main_frame_,
                             EFFECTIVE_CONNECTION_TYPE_LAST);
   base::HistogramBase* effective_connection_type_histogram =
       base::Histogram::FactoryGet(
           std::string("NQE.MainFrame.EffectiveConnectionType.") +
-              nqe::internal::NetworkQualityEstimatorParams::
-                  GetNameForConnectionType(current_network_id_.type),
+              NetworkQualityEstimatorParams::GetNameForConnectionType(
+                  current_network_id_.type),
           0, EFFECTIVE_CONNECTION_TYPE_LAST,
           EFFECTIVE_CONNECTION_TYPE_LAST /* Number of buckets */,
           base::HistogramBase::kUmaTargetedHistogramFlag);
 
   effective_connection_type_histogram->Add(
       effective_connection_type_at_last_main_frame_);
 
   // Record the HTTP RTT at the main frames for experimental statistics.
   for (int i = 0; i < STATISTIC_LAST; ++i) {
     if (http_rtt_at_last_main_frame_[i] != nqe::internal::InvalidRTT()) {
@@ skipping 139 matching lines @@
     NetworkQualityEstimator::MetricUsage downstream_throughput_kbps_metric,
     base::TimeDelta* http_rtt,
     base::TimeDelta* transport_rtt,
     int32_t* downstream_throughput_kbps) const {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   *http_rtt = nqe::internal::InvalidRTT();
   *transport_rtt = nqe::internal::InvalidRTT();
   *downstream_throughput_kbps = nqe::internal::kInvalidThroughput;
 
-  if (params_.forced_effective_connection_type()) {
+  if (params_->forced_effective_connection_type()) {
     *http_rtt = params_
-                    .TypicalNetworkQuality(
-                        params_.forced_effective_connection_type().value())
+                    ->TypicalNetworkQuality(
+                        params_->forced_effective_connection_type().value())
                     .http_rtt();
-    *transport_rtt = params_
-                         .TypicalNetworkQuality(
-                             params_.forced_effective_connection_type().value())
-                         .transport_rtt();
+    *transport_rtt =
+        params_
+            ->TypicalNetworkQuality(
+                params_->forced_effective_connection_type().value())
+            .transport_rtt();
     *downstream_throughput_kbps =
         params_
-            .TypicalNetworkQuality(
-                params_.forced_effective_connection_type().value())
+            ->TypicalNetworkQuality(
+                params_->forced_effective_connection_type().value())
             .downstream_throughput_kbps();
-    return params_.forced_effective_connection_type().value();
+    return params_->forced_effective_connection_type().value();
   }
 
   // If the device is currently offline, then return
   // EFFECTIVE_CONNECTION_TYPE_OFFLINE.
 
   if (current_network_id_.type == NetworkChangeNotifier::CONNECTION_NONE &&
       !disable_offline_check_) {
     return EFFECTIVE_CONNECTION_TYPE_OFFLINE;
   }
 
@@ skipping 34 matching lines @@
   // 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;
 
     const bool estimated_http_rtt_is_higher_than_threshold =
         http_rtt_metric != NetworkQualityEstimator::MetricUsage::DO_NOT_USE &&
         *http_rtt != nqe::internal::InvalidRTT() &&
-        params_.ConnectionThreshold(type).http_rtt() !=
+        params_->ConnectionThreshold(type).http_rtt() !=
             nqe::internal::InvalidRTT() &&
-        *http_rtt >= params_.ConnectionThreshold(type).http_rtt();
+        *http_rtt >= params_->ConnectionThreshold(type).http_rtt();
 
     const bool estimated_transport_rtt_is_higher_than_threshold =
         transport_rtt_metric !=
             NetworkQualityEstimator::MetricUsage::DO_NOT_USE &&
         *transport_rtt != nqe::internal::InvalidRTT() &&
-        params_.ConnectionThreshold(type).transport_rtt() !=
+        params_->ConnectionThreshold(type).transport_rtt() !=
             nqe::internal::InvalidRTT() &&
-        *transport_rtt >= params_.ConnectionThreshold(type).transport_rtt();
+        *transport_rtt >= params_->ConnectionThreshold(type).transport_rtt();
 
     const bool estimated_throughput_is_lower_than_threshold =
         downstream_throughput_kbps_metric !=
             NetworkQualityEstimator::MetricUsage::DO_NOT_USE &&
         *downstream_throughput_kbps != nqe::internal::kInvalidThroughput &&
-        params_.ConnectionThreshold(type).downstream_throughput_kbps() !=
+        params_->ConnectionThreshold(type).downstream_throughput_kbps() !=
             nqe::internal::kInvalidThroughput &&
         *downstream_throughput_kbps <=
-            params_.ConnectionThreshold(type).downstream_throughput_kbps();
+            params_->ConnectionThreshold(type).downstream_throughput_kbps();
 
     if (estimated_http_rtt_is_higher_than_threshold ||
         estimated_transport_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);
@@ skipping 169 matching lines @@
 
     if (network_id.type == NetworkChangeNotifier::GetConnectionType())
       return network_id;
   }
   NOTREACHED();
 }
 
 bool NetworkQualityEstimator::ReadCachedNetworkQualityEstimate() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
-  if (!params_.persistent_cache_reading_enabled())
+  if (!params_->persistent_cache_reading_enabled())
     return false;
 
   nqe::internal::CachedNetworkQuality cached_network_quality;
 
   const bool cached_estimate_available = network_quality_store_->GetById(
       current_network_id_, &cached_network_quality);
   if (network_quality_store_->EligibleForCaching(current_network_id_)) {
     UMA_HISTOGRAM_BOOLEAN("NQE.CachedNetworkQualityAvailable",
                           cached_estimate_available);
   }
@@ skipping 269 matching lines @@
     // RTT and throughput values are not set in the prefs.
     DCHECK_EQ(nqe::internal::InvalidRTT(),
               it.second.network_quality().http_rtt());
     DCHECK_EQ(nqe::internal::InvalidRTT(),
               it.second.network_quality().transport_rtt());
     DCHECK_EQ(nqe::internal::kInvalidThroughput,
               it.second.network_quality().downstream_throughput_kbps());
 
     nqe::internal::CachedNetworkQuality cached_network_quality(
         base::TimeTicks::Now(),
-        params_.TypicalNetworkQuality(effective_connection_type),
+        params_->TypicalNetworkQuality(effective_connection_type),
         effective_connection_type);
 
     network_quality_store_->Add(it.first, cached_network_quality);
     MaybeUpdateNetworkQualityFromCache(it.first, cached_network_quality);
   }
 }
 
 void NetworkQualityEstimator::MaybeUpdateNetworkQualityFromCache(
     const nqe::internal::NetworkID& network_id,
     const nqe::internal::CachedNetworkQuality& cached_network_quality) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
-  if (!params_.persistent_cache_reading_enabled())
+  if (!params_->persistent_cache_reading_enabled())
     return;
   if (network_id != current_network_id_)
     return;
 
   // Since the cached network quality is for the current network, add it to
   // the current observations.
   RttObservation http_rtt_observation(
       cached_network_quality.network_quality().http_rtt(),
       base::TimeTicks::Now(), INT32_MIN,
       NETWORK_QUALITY_OBSERVATION_SOURCE_HTTP_CACHED_ESTIMATE);
@@ skipping 47 matching lines @@
   return base::Optional<base::TimeDelta>();
 }
 
 base::Optional<int32_t>
 NetworkQualityEstimator::NetworkQualityProvider::GetDownstreamThroughputKbps()
     const {
   return base::Optional<int32_t>();
 }
 
 }  // namespace net