PreferencesManager

chrome/browser/prefs/preferences_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 "chrome/browser/prefs/preferences_manager.h"
+
+#include "base/auto_reset.h"
+#include "base/bind.h"
+#include "base/values.h"
+#include "chrome/browser/profiles/profile.h"
+#include "components/prefs/pref_change_registrar.h"
+#include "components/prefs/pref_service.h"
+
+namespace chrome {
+
+PreferencesManager::PreferencesManager(Profile* profile)
+    : preferences_change_registrar_(new PrefChangeRegistrar),
+      setting_preferences_(false) {
+  DCHECK(profile);
+  service_ = profile->GetPrefs();
+  preferences_change_registrar_->Init(service_);
+}
+
+PreferencesManager::~PreferencesManager() {}
+
+void PreferencesManager::OnProfileDestroyed() {
+  preferences_change_registrar_.reset();
+}
+
+void PreferencesManager::PreferenceChanged(const std::string& preference_name) {
+  if (setting_preferences_)
+    return;
+  const PrefService::Preference* pref =
+      service_->FindPreference(preference_name);
+  base::DictionaryValue dictionary;
+  dictionary.Set(preference_name, pref->GetValue()->CreateDeepCopy());
+  client_->OnPreferencesChanged(dictionary);
+}
+
+void PreferencesManager::AddObserver(
+    prefs::mojom::PreferencesObserverPtr client) {
+  client_ = std::move(client);
+}
+
+void PreferencesManager::SetPreferences(
+    const base::DictionaryValue& preferences) {

[sky, 2016/12/06 23:37:37]

Do callers not care about error conditions such as no preference?

[jonross, 2016/12/07 00:31:28]

Current pattern involves chrome enforcing all preferences be registered at
startup. Then failing CHECKs if prefs are written to that aren't registered.

As for missing preferences, that currently relies on the PrefStore returning
false when missing values are accessed.

I'd be open to changing this with more explicit error notifications if desired.

[sky, 2016/12/07 18:05:16]

My concern is making it easy to diagnose doing the wrong thing vs failing in
weird ways later on. A success callback is one way, LOGs are another. LOGs are
likely easier as they don't involve callbacks and tracking when the call was
made.

[jonross, 2016/12/07 21:50:24]

Went with DLOGs as discussed offline.

+  DCHECK(!setting_preferences_);
+  // We ignore preference changes caused by us.
+  base::AutoReset<bool> setting_preferences(&setting_preferences_, true);
+  for (base::DictionaryValue::Iterator it(preferences); !it.IsAtEnd();
+       it.Advance()) {
+    if (!preferences_change_registrar_->IsObserved(it.key()))
+      continue;
+    const PrefService::Preference* pref = service_->FindPreference(it.key());
+    if (!pref)
+      continue;
+    if (it.value().Equals(pref->GetValue()))
+      continue;
+    service_->Set(it.key(), it.value());
+  }
+}
+
+void PreferencesManager::Subscribe(
+    const std::vector<std::string>& preferences) {
+  base::DictionaryValue dictionary;
+  for (auto& it : preferences) {
+    const PrefService::Preference* pref = service_->FindPreference(it);
+    if (!pref)
+      continue;
+    // PreferenceManager lifetime is managed by a mojo::StrongBindingPtr owned
+    // by PreferenceConnectionManager. It will outlive
+    // |preferences_change_registrar_| which it owns.
+    preferences_change_registrar_->Add(
+        it, base::Bind(&PreferencesManager::PreferenceChanged,
+                       base::Unretained(this)));
+    dictionary.Set(it, pref->GetValue()->CreateDeepCopy());
+  }
+
+  if (dictionary.empty())
+    return;
+  client_->OnPreferencesChanged(dictionary);
+}
+
+}  // namespace chrome