NQE: Make params a class

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 16 matching lines @@
 #include "base/trace_event/trace_event.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/trace_constants.h"
 #include "net/base/url_util.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_response_info.h"
 #include "net/http/http_status_code.h"
-#include "net/nqe/network_quality_estimator_params.h"
 #include "net/nqe/socket_watcher_factory.h"
 #include "net/nqe/throughput_analyzer.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_status.h"
 #include "url/gurl.h"
 
 #if defined(OS_ANDROID)
 #include "net/android/cellular_signal_strength.h"
 #include "net/android/network_library.h"
 #endif  // OS_ANDROID
 
 namespace net {
 
 namespace {
 
 // Returns the histogram that should be used to record the given statistic.
 // |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::GetNameForConnectionType(type),
+      "NQE." + statistic_name +
+          nqe::internal::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 166 matching lines @@
     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),
       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),
-      weight_multiplier_per_second_(
-          nqe::internal::GetWeightMultiplierPerSecond(variation_params)),
-      weight_multiplier_per_dbm_(
-          nqe::internal::GetWeightMultiplierPerDbm(variation_params)),
+      weight_multiplier_per_second_(params_.GetWeightMultiplierPerSecond()),
+      weight_multiplier_per_dbm_(params_.GetWeightMultiplierPerDbm()),
       effective_connection_type_algorithm_(
           algorithm_name_to_enum_.find(
-              nqe::internal::GetEffectiveConnectionTypeAlgorithm(
-                  variation_params)) == algorithm_name_to_enum_.end()
+              params_.GetEffectiveConnectionTypeAlgorithm()) ==
+                  algorithm_name_to_enum_.end()
               ? kDefaultEffectiveConnectionTypeAlgorithm
               : algorithm_name_to_enum_
-                    .find(nqe::internal::GetEffectiveConnectionTypeAlgorithm(
-                        variation_params))
+                    .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_(weight_multiplier_per_second_,
                                                weight_multiplier_per_dbm_),
       rtt_observations_(weight_multiplier_per_second_,
                         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),
       max_signal_strength_since_connection_change_(INT32_MIN),
       correlation_uma_logging_probability_(
-          nqe::internal::correlation_uma_logging_probability(variation_params)),
+          params_.correlation_uma_logging_probability()),
       forced_effective_connection_type_set_(
-          nqe::internal::forced_effective_connection_type_set(
-              variation_params)),
+          params_.forced_effective_connection_type_set()),
       forced_effective_connection_type_(
-          nqe::internal::forced_effective_connection_type(variation_params)),
+          params_.forced_effective_connection_type()),
       persistent_cache_reading_enabled_(
-          nqe::internal::persistent_cache_reading_enabled(variation_params)),
+          params_.persistent_cache_reading_enabled()),
       event_creator_(net_log),
       disallowed_observation_sources_for_http_(
           {NETWORK_QUALITY_OBSERVATION_SOURCE_TCP,
            NETWORK_QUALITY_OBSERVATION_SOURCE_QUIC,
            NETWORK_QUALITY_OBSERVATION_SOURCE_TRANSPORT_CACHED_ESTIMATE,
            NETWORK_QUALITY_OBSERVATION_SOURCE_DEFAULT_TRANSPORT_FROM_PLATFORM}),
       disallowed_observation_sources_for_transport_(
           {NETWORK_QUALITY_OBSERVATION_SOURCE_HTTP,
            NETWORK_QUALITY_OBSERVATION_SOURCE_HTTP_EXTERNAL_ESTIMATE,
            NETWORK_QUALITY_OBSERVATION_SOURCE_HTTP_CACHED_ESTIMATE,
            NETWORK_QUALITY_OBSERVATION_SOURCE_DEFAULT_HTTP_FROM_PLATFORM}),
       weak_ptr_factory_(this) {
   // None of the algorithms can have an empty name.
   DCHECK(algorithm_name_to_enum_.end() ==
          algorithm_name_to_enum_.find(std::string()));
 
   DCHECK_EQ(algorithm_name_to_enum_.size(),
             static_cast<size_t>(EffectiveConnectionTypeAlgorithm::
                                     EFFECTIVE_CONNECTION_TYPE_ALGORITHM_LAST));
   DCHECK_NE(EffectiveConnectionTypeAlgorithm::
                 EFFECTIVE_CONNECTION_TYPE_ALGORITHM_LAST,
             effective_connection_type_algorithm_);
 
   network_quality_store_.reset(new nqe::internal::NetworkQualityStore());
-  ObtainOperatingParams(variation_params);
+  ObtainOperatingParams();
   NetworkChangeNotifier::AddConnectionTypeObserver(this);
   if (external_estimate_provider_) {
     RecordExternalEstimateProviderMetrics(
         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(
       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(),
-      nqe::internal::GetMinSocketWatcherNotificationInterval(variation_params),
+      params_.GetMinSocketWatcherNotificationInterval(),
       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::ObtainOperatingParams(
-    const std::map<std::string, std::string>& variation_params) {
+void NetworkQualityEstimator::ObtainOperatingParams() {
   DCHECK(thread_checker_.CalledOnValidThread());
-  nqe::internal::ObtainDefaultObservations(variation_params,
-                                           default_observations_);
-  nqe::internal::ObtainEffectiveConnectionTypeModelParams(
-      variation_params, connection_thresholds_);
-  nqe::internal::ObtainTypicalNetworkQuality(typical_network_quality_);
+  params_.ObtainDefaultObservations(default_observations_);
+  params_.ObtainEffectiveConnectionTypeModelParams(connection_thresholds_);
+  params_.ObtainTypicalNetworkQuality(typical_network_quality_);
 }
 
 void NetworkQualityEstimator::AddDefaultEstimates() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (!add_default_platform_observations_)
     return;
 
   if (default_observations_[current_network_id_.type].http_rtt() !=
       nqe::internal::InvalidRTT()) {
@@ skipping 673 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::GetNameForConnectionType(current_network_id_.type),
+              nqe::internal::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 777 matching lines @@
   return base::Optional<base::TimeDelta>();
 }
 
 base::Optional<int32_t>
 NetworkQualityEstimator::NetworkQualityProvider::GetDownstreamThroughputKbps()
     const {
   return base::Optional<int32_t>();
 }
 
 }  // namespace net