Read NQE prefs to network quality store under all cases

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 271 matching lines @@
       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)),
       forced_effective_connection_type_set_(
           nqe::internal::forced_effective_connection_type_set(
               variation_params)),
       forced_effective_connection_type_(
           nqe::internal::forced_effective_connection_type(variation_params)),
+      persistent_cache_reading_enabled_(
+          nqe::internal::persistent_cache_reading_enabled(variation_params)),
       event_creator_(net_log),
       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::
@@ skipping 1097 matching lines @@
 
     if (network_id.type == NetworkChangeNotifier::GetConnectionType())
       return network_id;
   }
   NOTREACHED();
 }
 
 bool NetworkQualityEstimator::ReadCachedNetworkQualityEstimate() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
+  if (!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);
   UMA_HISTOGRAM_BOOLEAN("NQE.CachedNetworkQualityAvailable",
                         cached_estimate_available);
 
   if (!cached_estimate_available)
     return false;
 
@@ skipping 269 matching lines @@
 
     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 (!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);
   rtt_observations_.AddObservation(http_rtt_observation);
@@ skipping 15 matching lines @@
         NETWORK_QUALITY_OBSERVATION_SOURCE_HTTP_CACHED_ESTIMATE);
     downstream_throughput_kbps_observations_.AddObservation(
         throughput_observation);
     NotifyObserversOfThroughput(throughput_observation);
   }
 
   ComputeEffectiveConnectionType();
 }
 
 }  // namespace net