NQE: Use cached estimates

chrome/browser/net/nqe/ui_network_quality_estimator_service.cc

 // 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.
 
 #include "chrome/browser/net/nqe/ui_network_quality_estimator_service.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/memory/ptr_util.h"
@@ skipping 21 matching lines @@
   std::map<std::string, std::string> network_quality_estimator_params;
   // Name of the network quality estimator field trial.
   variations::GetVariationParams("NetworkQualityEstimator",
                                  &network_quality_estimator_params);
 
   const auto it = network_quality_estimator_params.find(parameter_name);
   return it == network_quality_estimator_params.end() ? default_value
                                                       : it->second;
 }
 
-// Returns true if persistent caching has been enabled in the field trial.
-bool persistent_caching_enabled() {
+// Returns true if writing to the persistent cache has been enabled via field
+// trial.
+bool persistent_cache_writing_enabled() {
   return GetStringValueForVariationParamWithDefaultValue(
-             "persistent_caching_enabled", "false") == "true";
+             "persistent_cache_writing_enabled", "false") == "true";
+}
+
+// Returns true if reading from the persistent cache has been enabled via field
+// trial.
+bool persistent_cache_reading_enabled() {
+  return GetStringValueForVariationParamWithDefaultValue(
+             "persistent_cache_reading_enabled", "false") == "true";
 }
 
 // PrefDelegateImpl writes the provided dictionary value to the network quality
 // estimator prefs on the disk.
 class PrefDelegateImpl
     : public net::NetworkQualitiesPrefsManager::PrefDelegate {
  public:
   // |pref_service| is used to read and write prefs from/to the disk.
   explicit PrefDelegateImpl(PrefService* pref_service)
       : pref_service_(pref_service), path_(prefs::kNetworkQualities) {
     DCHECK(pref_service_);
   }
   ~PrefDelegateImpl() override {}
 
   void SetDictionaryValue(const base::DictionaryValue& value) override {
     DCHECK(thread_checker_.CalledOnValidThread());
-    if (!persistent_caching_enabled())
+    if (!persistent_cache_writing_enabled())
       return;
 
     pref_service_->Set(path_, value);
     UMA_HISTOGRAM_COUNTS_1000("NQE.Prefs.WriteCount", 1);
   }
 
-  const base::DictionaryValue& GetDictionaryValue() override {
+  std::unique_ptr<base::DictionaryValue> GetDictionaryValue() override {
     DCHECK(thread_checker_.CalledOnValidThread());
+    if (!persistent_cache_reading_enabled())
+      return base::WrapUnique(new base::DictionaryValue());
     UMA_HISTOGRAM_COUNTS_1000("NQE.Prefs.ReadCount", 1);
-    return *pref_service_->GetDictionary(path_);
+    return pref_service_->GetDictionary(path_)->CreateDeepCopy();
   }
 
  private:
   PrefService* pref_service_;
 
   // |path_| is the location of the network quality estimator prefs.
   const std::string path_;
 
   base::ThreadChecker thread_checker_;
 
@@ skipping 183 matching lines @@
 
 std::map<net::nqe::internal::NetworkID,
          net::nqe::internal::CachedNetworkQuality>
 UINetworkQualityEstimatorService::ForceReadPrefsForTesting() const {
   if (!prefs_manager_) {
     return std::map<net::nqe::internal::NetworkID,
                     net::nqe::internal::CachedNetworkQuality>();
   }
   return prefs_manager_->ForceReadPrefsForTesting();
 }