Add Network Quality Estimator (NQE) pref manager

net/nqe/network_qualities_prefs_manager.cc

Index: net/nqe/network_qualities_prefs_manager.cc
diff --git a/net/nqe/network_qualities_prefs_manager.cc b/net/nqe/network_qualities_prefs_manager.cc
new file mode 100644
index 0000000000000000000000000000000000000000..4025fabff89f867231a8e69ce876f0301cc9fb3f
--- /dev/null
+++ b/net/nqe/network_qualities_prefs_manager.cc
@@ -0,0 +1,81 @@
+// 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 <utility>
+
+#include "base/bind.h"
+#include "base/sequenced_task_runner.h"
+#include "base/threading/thread_checker.h"
+#include "base/threading/thread_task_runner_handle.h"
+#include "base/values.h"
+#include "net/nqe/cached_network_quality.h"
+#include "net/nqe/network_quality_estimator.h"
+
+namespace net {
+
+NetworkQualitiesPrefsManager::NetworkQualitiesPrefsManager(

[bengr, 2016/09/22 23:35:46]

Is the NetworkQualitiesPrefsManager a Pref thread object? Was wondering about a
race on ShutdownOnPrefThread if not. 

[tbansal1, 2016/09/23 17:10:32]

It will be created and destroyed by UI_NQE keyed service.
It is created on pref thread (takes ownership of PrefDelegate), initialized on
network thread (starts listening to NQE notifications), shutdown on pref thread
(where it will delete PrefDelegate), and then destroyed on network thread (where
it stops listening to notifications from NQE).

This lifecycle is complex, but AFAICT there is no way to simplify it. That's
because it is owned by keyed service (UI thread), so first step of construction
happens on UI thread (then rest of the initialization happens on network).
Similarly, shutdown first happens on UI thread, and the rest of it on network
thread.

ShutdownOnPrefThread is guaranteed to be called after pref_delegate has been
set.

+    std::unique_ptr<PrefDelegate> pref_delegate)
+    : pref_delegate_(std::move(pref_delegate)),
+      pref_task_runner_(base::ThreadTaskRunnerHandle::Get()),
+      network_quality_estimator_(nullptr),
+      pref_weak_ptr_factory_(this) {
+  DCHECK(pref_delegate_);
+
+  pref_weak_ptr_ = pref_weak_ptr_factory_.GetWeakPtr();
+}
+
+NetworkQualitiesPrefsManager::~NetworkQualitiesPrefsManager() {
+  DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
+  network_quality_estimator_->RemoveNetworkQualitiesCacheObserver(this);

[bengr, 2016/09/22 23:35:46]

This seems unsafe, e.g., if called before InitializeOnNetworkThread().
network_quality_estimator_ is constructed with nullptr.

[tbansal1, 2016/09/23 17:10:32]

Done.

+}
+
+void NetworkQualitiesPrefsManager::InitializeOnNetworkThread(
+    NetworkQualityEstimator* network_quality_estimator) {
+  DCHECK(!network_task_runner_);
+  DCHECK(network_quality_estimator);
+
+  network_task_runner_ = base::ThreadTaskRunnerHandle::Get();
+

[bengr, 2016/09/22 23:35:46]

nit: I'd remove the blank lines on 41 and 43.

[tbansal1, 2016/09/23 17:10:32]

Done.

+  network_quality_estimator_ = network_quality_estimator;
+
+  network_quality_estimator_->AddNetworkQualitiesCacheObserver(this);
+}
+
+void NetworkQualitiesPrefsManager::OnChangeInCachedNetworkQuality(
+    const nqe::internal::NetworkID& network_id,
+    const nqe::internal::CachedNetworkQuality& cached_network_quality) {
+  DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
+
+  // Notify |this| on the pref thread.
+  pref_task_runner_->PostTask(
+      FROM_HERE,
+      base::Bind(&NetworkQualitiesPrefsManager::
+                     OnChangeInCachedNetworkQualityOnPrefThread,
+                 pref_weak_ptr_, network_id, cached_network_quality));
+}
+
+void NetworkQualitiesPrefsManager::ShutdownOnPrefThread() {
+  DCHECK(pref_task_runner_->RunsTasksOnCurrentThread());
+  pref_delegate_.reset();
+}
+
+void NetworkQualitiesPrefsManager::OnChangeInCachedNetworkQualityOnPrefThread(
+    const nqe::internal::NetworkID& network_id,
+    const nqe::internal::CachedNetworkQuality& cached_network_quality) {
+  // The prefs can only be written on the pref thread.
+  DCHECK(pref_task_runner_->RunsTasksOnCurrentThread());
+
+  base::DictionaryValue dictionary_value;
+  dictionary_value.SetString(
+      network_id.ToString(),
+      GetNameForEffectiveConnectionType(
+          cached_network_quality.effective_connection_type()));
+
+  // Notify the pref delegate so that it updates the prefs on the disk.

[bengr, 2016/09/22 23:35:46]

Do all pref delegates update to disk? I'd remove "on the disk"

[tbansal1, 2016/09/23 17:10:32]

Yes. They all update to disk.

+  pref_delegate_->SetDictionaryValue(dictionary_value);
+}
+
+}  // namespace net