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"
+
+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::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);

[dcheng, 2016/12/08 23:13:01]

Why just a single observer? That feels a bit surprising to me. Is it the case
that we'll only ever want one observer?

[jonross, 2016/12/08 23:32:55]

These will end up pairing 1:1 with connecting clients.
   -  We do not want to notify a client of changes which it just requested.
   -  In the cases where the multiple clients want the same pref we still want
to notify the others.

So a PreferencesManager will handle the connection to a single client, cleaning
itself up when the connection is terminated.
PreferencesConnectionManager will coordinate the requests from various clients
wanting prefs.

For example Ash will only connect to Chrome once for preferences. Other
processes would also each connect once.

[dcheng, 2016/12/09 05:26:41]

If that's the case, should this always have exactly 1 client? Things like
PreferenceChanged() don't check that client_ is bound.

If there's only ever one client, I think it would be better if we could vend
this interface out of a factory, and ensure the client is always bound: that
way, we don't have to trust the other end, e.g. something like:

interface PreferencesManagerFactory {
  Create(PreferencesObserverPtr) => (PreferencesManager);
}

(Also as a minor nit, I would then call it a client or delegate; it's custom for
it to be possible to be multiple observers, while a client / delegate should
have a 1:1 relationship)

[jonross, 2016/12/09 20:49:04]

I'll look into the factory style

[jonross, 2016/12/13 01:30:18]

Similar to the factory pattern (eg media/mojo/interfaces/remoting.mojom) the
binding between PreferencesManager and PreferencesObserver is already enforced
by being in a StrongBindingPtr. The addition of the onConnectionError handler
verifies that. I could further add DCHECKs in this class if desired.

However I'm not sure I see any additional advantage of a factory indirection at
the mojom level.

If the 1:1 ratio of Manager:Observer is more representative of a client/delegate
I'd prefer to pursue that as a follow on refactor. That way we can unblock
chrome-ash preference communications, and the mojom interface can be refined
underneath subsequent work.

+}
+
+void PreferencesManager::SetPreferences(
+    const base::DictionaryValue& preferences) {
+  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) {
+      DLOG(ERROR) << "Preference " << it.key() << " not found.\n";
+      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) {
+      DLOG(ERROR) << "Preference " << it << " not found.\n";
+      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);
+}