Add functionality for embedders to configure NQE

net/nqe/network_quality_estimator_params.h

 // Copyright 2016 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.
 
 #ifndef NET_NQE_NETWORK_QUALITY_ESTIMATOR_PARAMS_H_
 #define NET_NQE_NETWORK_QUALITY_ESTIMATOR_PARAMS_H_
 
 #include <map>
 #include <string>
 
 #include "base/macros.h"
 #include "base/optional.h"
-#include "base/threading/thread_checker.h"
+#include "base/sequence_checker.h"
 #include "net/base/net_export.h"
 #include "net/base/network_change_notifier.h"
 #include "net/nqe/effective_connection_type.h"
 #include "net/nqe/network_quality.h"
 
 namespace net {
 
 // Forces NQE to return a specific effective connection type. Set using the
 // |params| provided to the NetworkQualityEstimatorParams constructor.
 NET_EXPORT extern const char kForceEffectiveConnectionType[];
@@ skipping 65 matching lines @@
   // UMA.
   double correlation_uma_logging_probability() const {
     return correlation_uma_logging_probability_;
   }
 
   // Returns an unset value if the effective connection type has not been forced
   // via the |params| provided to this class. Otherwise, returns a value set to
   // the effective connection type that has been forced.
   base::Optional<EffectiveConnectionType> forced_effective_connection_type()
       const {
+    DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
     return forced_effective_connection_type_;
   }
 
+  void SetForcedEffectiveConnectionType(
+      EffectiveConnectionType forced_effective_connection_type) {
+    DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
+    forced_effective_connection_type_ = forced_effective_connection_type;
+  }
+
   // Returns true if reading from the persistent cache is enabled.
   bool persistent_cache_reading_enabled() const {
+    DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
     return persistent_cache_reading_enabled_;
   }
 
+  void set_persistent_cache_reading_enabled(
+      bool persistent_cache_reading_enabled) {
+    DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
+    persistent_cache_reading_enabled_ = persistent_cache_reading_enabled;
+  }
+
   // Returns the the minimum interval betweeen consecutive notifications to a
   // single socket watcher.
   base::TimeDelta min_socket_watcher_notification_interval() const {
     return min_socket_watcher_notification_interval_;
   }
 
   // Returns the algorithm that should be used for computing effective
   // connection type. Returns an empty string if a valid algorithm parameter is
   // not specified.
   static EffectiveConnectionTypeAlgorithm
   GetEffectiveConnectionTypeAlgorithmFromString(
       const std::string& algorithm_param_value);
 
+  void SetEffectiveConnectionTypeAlgorithm(
+      EffectiveConnectionTypeAlgorithm algorithm) {
+    DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
+    effective_connection_type_algorithm_ = algorithm;
+  }
+
  private:
   // Map containing all field trial parameters related to
   // NetworkQualityEstimator field trial.
   const std::map<std::string, std::string> params_;
 
   const size_t throughput_min_requests_in_flight_;
   const double weight_multiplier_per_second_;
   const double weight_multiplier_per_signal_strength_level_;
   const double correlation_uma_logging_probability_;
-  const base::Optional<EffectiveConnectionType>
-      forced_effective_connection_type_;
-  const bool persistent_cache_reading_enabled_;
+  base::Optional<EffectiveConnectionType> forced_effective_connection_type_;
+  bool persistent_cache_reading_enabled_;
   const base::TimeDelta min_socket_watcher_notification_interval_;
 
   EffectiveConnectionTypeAlgorithm effective_connection_type_algorithm_;
 
   // Default network quality observations obtained from |params_|.
   nqe::internal::NetworkQuality
       default_observations_[NetworkChangeNotifier::CONNECTION_LAST + 1];
 
   // Typical network quality for different effective connection types obtained
   // from |params_|.
   nqe::internal::NetworkQuality typical_network_quality_
       [EffectiveConnectionType::EFFECTIVE_CONNECTION_TYPE_LAST];
 
   // Thresholds for different effective connection types obtained from
   // |params_|. These thresholds encode how different connection types behave
   // in general.
   nqe::internal::NetworkQuality connection_thresholds_
       [EffectiveConnectionType::EFFECTIVE_CONNECTION_TYPE_LAST];
 
-  base::ThreadChecker thread_checker_;
+  SEQUENCE_CHECKER(sequence_checker_);
 
   DISALLOW_COPY_AND_ASSIGN(NetworkQualityEstimatorParams);
 };
 
 }  // namespace net
 
 #endif  // NET_NQE_NETWORK_QUALITY_ESTIMATOR_PARAMS_H_