NQE: Use cached estimates

net/nqe/network_qualities_prefs_manager.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 "net/nqe/network_qualities_prefs_manager.h"
 
 #include <string>
 #include <utility>
 
 #include "base/bind.h"
+#include "base/rand_util.h"
 #include "base/sequenced_task_runner.h"
 #include "base/threading/thread_checker.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "net/nqe/network_quality_estimator.h"
 
 namespace net {
 
 namespace {
 
 // Maximum size of the prefs that hold the qualities of different networks.
@@ skipping 28 matching lines @@
   }
   return read_prefs;
 }
 
 }  // namespace
 
 NetworkQualitiesPrefsManager::NetworkQualitiesPrefsManager(
     std::unique_ptr<PrefDelegate> pref_delegate)
     : pref_delegate_(std::move(pref_delegate)),
       pref_task_runner_(base::ThreadTaskRunnerHandle::Get()),
-      prefs_(pref_delegate_->GetDictionaryValue().CreateDeepCopy()),
+      prefs_(pref_delegate_->GetDictionaryValue()),
       network_quality_estimator_(nullptr),
       read_prefs_startup_(ConvertDictionaryValueToMap(prefs_.get())),
       pref_weak_ptr_factory_(this) {
   DCHECK(pref_delegate_);
   DCHECK_GE(kMaxCacheSize, prefs_->size());
 
   pref_weak_ptr_ = pref_weak_ptr_factory_.GetWeakPtr();
 }
 
 NetworkQualitiesPrefsManager::~NetworkQualitiesPrefsManager() {
@@ skipping 55 matching lines @@
   // If the network ID contains a period, then return early since the dictionary
   // prefs cannot contain period in the path.
   if (network_id_string.find(".") != std::string::npos)
     return;
 
   prefs_->SetString(network_id_string,
                     GetNameForEffectiveConnectionType(
                         cached_network_quality.effective_connection_type()));
 
   if (prefs_->size() > kMaxCacheSize) {
-    // Delete one value that has key different than |network_id|.
+    // Delete one randomly selected value that has a key that is different from
+    // |network_id|.
     DCHECK_EQ(kMaxCacheSize + 1, prefs_->size());
+    // Generate a random number between 0 and |kMaxCacheSize| -1 (both
+    // inclusive) since the number of network IDs in |prefs_| other than
+    // |network_id| is |kMaxCacheSize|.
+    int index_to_delete = base::RandInt(0, kMaxCacheSize - 1);
+
     for (base::DictionaryValue::Iterator it(*prefs_); !it.IsAtEnd();
          it.Advance()) {
-      const nqe::internal::NetworkID it_network_id =
-          nqe::internal::NetworkID::FromString(it.key());
-      if (it_network_id != network_id) {
+      // Delete the kth element in the dictionary, not including the element
+      // that represents the current network. k == |index_to_delete|.
+      if (nqe::internal::NetworkID::FromString(it.key()) == network_id)
+        continue;
+
+      if (index_to_delete == 0) {
         prefs_->RemovePath(it.key(), nullptr);
         break;
       }
+      index_to_delete--;
     }
   }
   DCHECK_GE(kMaxCacheSize, prefs_->size());
 
   // Notify the pref delegate so that it updates the prefs on the disk.
   pref_delegate_->SetDictionaryValue(*prefs_);
 }
 
 ParsedPrefs NetworkQualitiesPrefsManager::ForceReadPrefsForTesting() const {
   DCHECK(pref_task_runner_->RunsTasksOnCurrentThread());
   std::unique_ptr<base::DictionaryValue> value(
-      pref_delegate_->GetDictionaryValue().CreateDeepCopy());
+      pref_delegate_->GetDictionaryValue());
   return ConvertDictionaryValueToMap(value.get());
 }
 
 }  // namespace net