Pref service: Add a ScopedDictionaryPrefUpdate to track value changes.

services/preferences/persistent_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/persistent_pref_store_impl.h"
 
 #include <utility>
 
 #include "base/auto_reset.h"
 #include "base/memory/ptr_util.h"
 #include "base/stl_util.h"
 #include "base/values.h"
 #include "components/prefs/persistent_pref_store.h"
+#include "mojo/common/values_struct_traits.h"
 #include "mojo/public/cpp/bindings/binding.h"
+#include "services/preferences/public/cpp/lib/util.h"
 
 namespace prefs {
 
 class PersistentPrefStoreImpl::Connection : public mojom::PersistentPrefStore {
  public:
   Connection(PersistentPrefStoreImpl* pref_store,
              mojom::PersistentPrefStoreRequest request,
              mojom::PrefStoreObserverPtr observer,
              ObservedPrefs observed_keys)
       : pref_store_(pref_store),
         binding_(this, std::move(request)),
         observer_(std::move(observer)),
         observed_keys_(std::move(observed_keys)) {
     auto error_callback =
         base::Bind(&PersistentPrefStoreImpl::Connection::OnConnectionError,
                    base::Unretained(this));
     binding_.set_connection_error_handler(error_callback);
     observer_.set_connection_error_handler(error_callback);
   }
 
   ~Connection() override = default;
 
   void OnPrefValuesChanged(const std::vector<mojom::PrefUpdatePtr>& updates) {
     if (write_in_progress_)
       return;
 
     std::vector<mojom::PrefUpdatePtr> filtered_updates;
     for (const auto& update : updates) {
       if (base::ContainsKey(observed_keys_, update->key)) {
-        filtered_updates.push_back(mojom::PrefUpdate::New(
-            update->key,
-            update->value ? update->value->CreateDeepCopy() : nullptr, 0));
+        filtered_updates.push_back(update->Clone());
       }
     }
     if (!filtered_updates.empty())
       observer_->OnPrefsChanged(std::move(filtered_updates));
   }
 
  private:
   // mojom::PersistentPrefStore:
   void SetValues(std::vector<mojom::PrefUpdatePtr> updates) override {
     base::AutoReset<bool> scoped_call_in_progress(&write_in_progress_, true);
@@ skipping 69 matching lines @@
   initializing_ = false;
   std::move(on_initialized_).Run();
 }
 
 void PersistentPrefStoreImpl::SetValues(
     std::vector<mojom::PrefUpdatePtr> updates) {
   for (auto& entry : connections_)
     entry.first->OnPrefValuesChanged(updates);
 
   for (auto& update : updates) {
-    if (update->value) {
-      backing_pref_store_->SetValue(update->key, std::move(update->value),
+    if (update->value->is_atomic_update()) {
+      auto& value = update->value->get_atomic_update();
+      if (value) {
+        backing_pref_store_->SetValue(update->key, value->CreateDeepCopy(),

[tibell, 2017/04/12 07:13:52]

Can't we move out value?

+                                      update->flags);
+      } else {
+        backing_pref_store_->RemoveValue(update->key, update->flags);
+      }
+      continue;
+    }
+
+    DCHECK(update->value->is_split_updates());

[tibell, 2017/04/12 07:13:52]

I'd prefer that this was in an else block without the continue statement above.
If that's too much nesting pull it out into a helper function/method.

+    base::Value* mutable_value = nullptr;
+    base::DictionaryValue* dictionary_value = nullptr;
+    std::unique_ptr<base::DictionaryValue> pending_dictionary;
+    if (!backing_pref_store_->GetMutableValue(update->key, &mutable_value) ||
+        !mutable_value->GetAsDictionary(&dictionary_value)) {
+      pending_dictionary = base::MakeUnique<base::DictionaryValue>();
+      dictionary_value = pending_dictionary.get();
+    }
+    for (auto& split_update : update->value->get_split_updates()) {
+      if (split_update->path.empty())
+        continue;
+
+      SetValue(dictionary_value,
+               {split_update->path.begin(), split_update->path.end()},
+               std::move(split_update->value));
+    }
+    if (pending_dictionary) {
+      backing_pref_store_->SetValue(update->key, std::move(pending_dictionary),
                                     update->flags);
     } else {
-      backing_pref_store_->RemoveValue(update->key, update->flags);
+      backing_pref_store_->ReportValueChanged(update->key, update->flags);
     }
   }
 }
 
 void PersistentPrefStoreImpl::CommitPendingWrite() {
   backing_pref_store_->CommitPendingWrite();
 }
 
 void PersistentPrefStoreImpl::SchedulePendingLossyWrites() {
   backing_pref_store_->SchedulePendingLossyWrites();
 }
 
 void PersistentPrefStoreImpl::ClearMutableValues() {
   backing_pref_store_->ClearMutableValues();
 }
 
 void PersistentPrefStoreImpl::OnConnectionError(Connection* connection) {
   connections_.erase(connection);
 }
 
 }  // namespace prefs