Pref service: expose all read-only PrefStores through Mojo

services/preferences/public/cpp/pref_store_impl.cc

+// Copyright 2017 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 "services/preferences/public/cpp/pref_store_impl.h"
+
+#include <memory>
+
+#include "base/values.h"
+
+namespace prefs {
+
+// static
+std::unique_ptr<PrefStoreImpl> PrefStoreImpl::Create(
+    mojom::PrefStoreRegistryPtr registry_ptr,
+    scoped_refptr<::PrefStore> pref_store,
+    PrefValueStore::PrefStoreType type) {
+  mojom::PrefStorePtr ptr;
+  auto impl = base::MakeUnique<PrefStoreImpl>(std::move(pref_store),
+                                              mojo::MakeRequest(&ptr));
+  registry_ptr->Register(std::move(ptr), type);
+  return impl;
+}
+
+PrefStoreImpl::PrefStoreImpl(scoped_refptr<::PrefStore> pref_store,
+                             mojom::PrefStoreRequest request)
+    : backing_pref_store_(std::move(pref_store)),
+      initialized_(false),
+      binding_(this, std::move(request)) {
+  DCHECK(backing_pref_store_);
+  if (backing_pref_store_->IsInitializationComplete())
+    OnInitializationCompleted(true);
+  backing_pref_store_->AddObserver(this);
+}
+
+PrefStoreImpl::~PrefStoreImpl() {
+  backing_pref_store_->RemoveObserver(this);
+}
+
+void PrefStoreImpl::OnPrefValueChanged(const std::string& key) {
+  auto dictionary = base::MakeUnique<base::DictionaryValue>();
+  const base::Value* value = nullptr;
+  if (backing_pref_store_->GetValue(key, &value)) {
+    dictionary->SetWithoutPathExpansion(key, value->CreateDeepCopy());
+  } else {
+    dictionary->SetWithoutPathExpansion(key, base::Value::CreateNullValue());
+  }
+  for (const auto& observer : observers_)
+    observer->OnPreferencesChanged(dictionary->CreateDeepCopy());
+}
+
+void PrefStoreImpl::OnInitializationCompleted(bool succeeded) {
+  // Some pref stores call this more than once. We just ignore all calls after
+  // the first.
+  if (initialized_) {

[Sam McNally, 2017/02/24 04:14:53]

Do we want to catch success after failure as well as failure after success?

[tibell, 2017/02/27 00:02:54]

We could. We'd have to change initialized_ to a 3 state enum to do that. What do
you think?

[Sam McNally, 2017/02/27 03:22:20]

Ideally PrefStores should behave correctly, but in the mean time, I would prefer
this treating success followed by failure and failure followed by success as
incorrect.

+    DCHECK(succeeded);
+    return;

[Sam McNally, 2017/02/24 04:14:53]

No error handling after DCHECKing.

[tibell, 2017/02/27 00:02:54]

Done.

+  }
+  initialized_ = succeeded;
+  for (const auto& observer : observers_)
+    observer->OnInitializationCompleted(succeeded);
+}
+
+void PrefStoreImpl::AddObserver(const AddObserverCallback& callback) {
+  mojom::PrefStoreObserverPtr observer_ptr;
+  auto request = mojo::MakeRequest(&observer_ptr);
+  observers_.push_back(std::move(observer_ptr));
+  mojom::PrefStoreConnectionPtr connection = mojom::PrefStoreConnection::New();
+  connection->observer = std::move(request);
+  connection->initial_prefs = backing_pref_store_->GetValues();
+  connection->is_initialized = backing_pref_store_->IsInitializationComplete();
+  callback.Run(std::move(connection));
+}
+
+}  // namespace prefs