Mojom interface for Preferences

services/preferences/public/cpp/pref_observer_store.cc

Index: services/preferences/public/cpp/pref_observer_store.cc
diff --git a/services/preferences/public/cpp/pref_observer_store.cc b/services/preferences/public/cpp/pref_observer_store.cc
new file mode 100644
index 0000000000000000000000000000000000000000..a3ec92b164c5e05b4a6a00c0c6a404cb82687f23
--- /dev/null
+++ b/services/preferences/public/cpp/pref_observer_store.cc
@@ -0,0 +1,130 @@
+// 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 "services/preferences/public/cpp/pref_observer_store.h"
+
+#include "base/values.h"
+#include "mojo/public/cpp/bindings/array.h"
+#include "services/shell/public/cpp/connector.h"
+
+PrefObserverStore::PrefObserverStore(shell::Connector* connector)
+    : prefs_binding_(this), prefs_manager_(nullptr), initialized_(false) {
+  if (connector) {
+    connector->ConnectToInterface("exe:chrome", &prefs_manager_ptr_);

[sadrul, 2016/07/25 15:32:18]

Send the |prefs_manager_ptr_| from the caller, instead of from here. (see
https://codereview.chromium.org/1992443002/#msg24)

[jonross, 2016/07/26 19:27:36]

Done.

+    prefs_manager_ = prefs_manager_ptr_.get();
+  }
+}
+
+void PrefObserverStore::Init(const std::set<std::string>& keys) {
+  DCHECK(prefs_manager_);
+  keys_ = keys;

[sadrul, 2016/07/25 15:32:18]

DCHECK(!initialized_)

[jonross, 2016/07/26 19:27:36]

Done.

+
+  prefs::mojom::PreferenceListPtr prefs_list =
+      prefs::mojom::PreferenceList::New();
+  mojo::Array<mojo::String> pref_array = mojo::Array<mojo::String>::From(keys);
+  prefs_list->preferences = std::move(pref_array);
+  prefs_manager_->AddObserver(std::move(prefs_list),
+                              prefs_binding_.CreateInterfacePtrAndBind());
+}
+
+bool PrefObserverStore::GetValue(const std::string& key,
+                                 const base::Value** value) const {
+  DCHECK(initialized_);
+  DCHECK(keys_.find(key) != keys_.end());
+
+  return ValueMapPrefStore::GetValue(key, value);
+}
+
+void PrefObserverStore::SetValue(const std::string& key,
+                                 std::unique_ptr<base::Value> value,
+                                 uint32_t flags) {
+  DCHECK(keys_.find(key) != keys_.end());
+
+  SetValueOnPreferenceManager(key, value.get());
+  ValueMapPrefStore::SetValue(key, std::move(value), flags);
+}
+
+void PrefObserverStore::RemoveValue(const std::string& key, uint32_t flags) {
+  // TODO(jonross): add preference removal to preferences.mojom
+  NOTIMPLEMENTED();
+}
+
+bool PrefObserverStore::GetMutableValue(const std::string& key,
+                                        base::Value** value) {
+  // TODO(jonross): determine how we can track edits to base::Value so that we
+  // can appropriately set the value on the PreferenceManger.

[sadrul, 2016/07/25 15:32:17]

Looks like the callers are expected to call ReportValueChanged when they change
some value in the returned base::Value, so we should be good (i.e. we don't need
to introduce anything that tracks whether base::Value changed)?

[jonross, 2016/07/26 19:27:36]

Yeah that seems to be true. I'll update this to forward on the mutable value
with that expectation.

+  NOTIMPLEMENTED();
+  return false;
+}
+
+void PrefObserverStore::ReportValueChanged(const std::string& key,
+                                           uint32_t flags) {
+  ValueMapPrefStore::ReportValueChanged(key, flags);
+}
+
+void PrefObserverStore::SetValueSilently(const std::string& key,
+                                         std::unique_ptr<base::Value> value,
+                                         uint32_t flags) {
+  SetValueOnPreferenceManager(key, value.get());
+  ValueMapPrefStore::SetValueSilently(key, std::move(value), flags);
+}
+
+PrefObserverStore::~PrefObserverStore() {}
+
+void PrefObserverStore::SetValueOnPreferenceManager(const std::string& key,
+                                                    base::Value* value) {
+  if (keys_.find(key) == keys_.end())
+    return;
+
+  // TODO(jonross): replace with struct traits for base::Value

[sadrul, 2016/07/25 15:32:18]

Do we need to check |initialized_| here, and queue the updates until we are
initialized?

[jonross, 2016/07/26 19:27:36]

This is a possible way to handle it.

Another is to send the signals to the PrefsManager, and allow it to
accept/reject setting changes as desired.

We could also further look to the WTClient model, where the client tracks all
inflight changes in its local state, reverts on failures.

+  prefs::mojom::PreferencePtr pref = prefs::mojom::Preference::New();
+  switch (value->GetType()) {
+    case base::Value::TYPE_INTEGER: {
+      pref->type = prefs::mojom::Preference::PreferenceType::INT;
+      int val = 0;
+      value->GetAsInteger(&val);

[sadrul, 2016/07/25 15:32:18]

Check return value

[jonross, 2016/07/26 19:27:36]

Done.

+      pref->integer_value_ = val;
+    } break;
+    case base::Value::TYPE_STRING: {
+      pref->type = prefs::mojom::Preference::PreferenceType::STRING;
+      std::string str;
+      value->GetAsString(&str);

[sadrul, 2016/07/25 15:32:17]

ditto

[jonross, 2016/07/26 19:27:36]

Done.

+      pref->string_value_ = str;
+    } break;
+    default:
+      NOTIMPLEMENTED();
+      return;
+  }
+
+  prefs::mojom::PreferenceMapPtr pref_map = prefs::mojom::PreferenceMap::New();
+  pref_map->preferences.insert(key, std::move(pref));
+  prefs_manager_->SetPreferences(std::move(pref_map));
+}
+
+void PrefObserverStore::OnPreferencesChanged(
+    prefs::mojom::PreferenceMapPtr preferences) {
+  for (auto& it : preferences->preferences) {
+    if (keys_.find(it.first) == keys_.end())
+      continue;
+    // TODO(jonross): replace with struct traits for base::Value
+    base::Value* value;

[sadrul, 2016/07/25 15:32:17]

value = nullptr;

[jonross, 2016/07/26 19:27:36]

Done.

+    switch (it.second->type) {
+      case prefs::mojom::Preference::PreferenceType::INT:
+        value = new base::FundamentalValue((int)it.second->integer_value_);
+        break;
+      case prefs::mojom::Preference::PreferenceType::STRING:
+        value = new base::StringValue(it.second->string_value_);
+        break;
+      default:
+        NOTIMPLEMENTED();
+        return;
+    }
+    ValueMapPrefStore::SetValue(it.first, base::WrapUnique(value), 0);
+  }
+
+  if (!initialized_) {
+    initialized_ = true;
+    NotifyInitializationCompleted();
+  }
+}