Pref service: Add a ScopedDictionaryPrefUpdate to track value changes.

services/preferences/pref_service_factory_unittest.cc

 // Copyright (c) 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_service_factory.h"
 
 #include "base/files/scoped_temp_dir.h"
 #include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
+#include "base/strings/utf_string_conversions.h"
 #include "base/test/sequenced_worker_pool_owner.h"
 #include "components/prefs/pref_change_registrar.h"
 #include "components/prefs/pref_registry_simple.h"
 #include "components/prefs/pref_service.h"
 #include "components/prefs/value_map_pref_store.h"
 #include "components/prefs/writeable_pref_store.h"
 #include "mojo/public/cpp/bindings/binding_set.h"
 #include "services/preferences/public/cpp/pref_service_main.h"
 #include "services/preferences/public/cpp/pref_store_impl.h"
+#include "services/preferences/public/cpp/scoped_pref_update.h"
 #include "services/preferences/public/interfaces/preferences.mojom.h"
 #include "services/service_manager/public/cpp/binder_registry.h"
 #include "services/service_manager/public/cpp/interface_factory.h"
 #include "services/service_manager/public/cpp/service_context.h"
 #include "services/service_manager/public/cpp/service_test.h"
 #include "services/service_manager/public/interfaces/service_factory.mojom.h"
 
 namespace prefs {
 namespace {
 
@@ skipping 40 matching lines @@
   service_manager::BinderRegistry registry_;
   mojo::BindingSet<service_manager::mojom::ServiceFactory>
       service_factory_bindings_;
   std::unique_ptr<service_manager::ServiceContext> pref_service_context_;
 };
 
 constexpr int kInitialValue = 1;
 constexpr int kUpdatedValue = 2;
 constexpr char kKey[] = "some_key";
 constexpr char kOtherKey[] = "some_other_key";
+constexpr char kDictionaryKey[] = "a.dictionary.pref";
 
 class PrefServiceFactoryTest : public base::MessageLoop::DestructionObserver,
                                public service_manager::test::ServiceTest {
  public:
   PrefServiceFactoryTest() : ServiceTest("prefs_unittests", false) {}
 
  protected:
   void SetUp() override {
     ServiceTest::SetUp();
     ASSERT_TRUE(profile_dir_.CreateUniqueTempDir());
@@ skipping 35 matching lines @@
   // base::MessageLoop::DestructionObserver
   void WillDestroyCurrentMessageLoop() override { worker_pool_owner_.reset(); }
 
   // Create a fully initialized PrefService synchronously.
   std::unique_ptr<PrefService> Create() {
     std::unique_ptr<PrefService> pref_service;
     base::RunLoop run_loop;
     auto pref_registry = make_scoped_refptr(new PrefRegistrySimple());
     pref_registry->RegisterIntegerPref(kKey, kInitialValue);
     pref_registry->RegisterIntegerPref(kOtherKey, kInitialValue);
+    pref_registry->RegisterDictionaryPref(kDictionaryKey);
     ConnectToPrefService(connector(), pref_registry,
                          std::vector<PrefValueStore::PrefStoreType>(),
                          base::Bind(&PrefServiceFactoryTest::OnCreate,
                                     run_loop.QuitClosure(), &pref_service));
     run_loop.Run();
     return pref_service;
   }
 
   // Wait until first update of the pref |key| in |pref_service| synchronously.
   void WaitForPrefChange(PrefService* pref_service, const std::string& key) {
@@ skipping 114 matching lines @@
 
   above_user_prefs_pref_store()->SetValue(kKey,
                                           base::MakeUnique<base::Value>(2), 0);
   WaitForPrefChange(pref_service.get(), kKey);
   EXPECT_EQ(2, pref_service->GetInteger(kKey));
 
   pref_service->SetInteger(kKey, 3);
   EXPECT_EQ(2, pref_service->GetInteger(kKey));
 }
 
+void Fail(PrefService* pref_service) {
+  FAIL() << "Unexpected change notification: "
+         << *pref_service->GetDictionary(kDictionaryKey);
+}
+
+TEST_F(PrefServiceFactoryTest, MultipleClients_SubPrefUpdates_Basic) {
+  auto pref_service = Create();
+  auto pref_service2 = Create();
+
+  void (*updates[])(ScopedDictionaryPrefUpdate*) = {
+      [](ScopedDictionaryPrefUpdate* update) {
+        (*update)->SetInteger("path.to.integer", 1);
+        int out = 0;
+        ASSERT_TRUE((*update)->GetInteger("path.to.integer", &out));
+        EXPECT_EQ(1, out);
+      },
+      [](ScopedDictionaryPrefUpdate* update) {
+        (*update)->SetIntegerWithoutPathExpansion("key.for.integer", 2);
+        int out = 0;
+        ASSERT_TRUE(
+            (*update)->GetIntegerWithoutPathExpansion("key.for.integer", &out));
+        EXPECT_EQ(2, out);
+      },
+      [](ScopedDictionaryPrefUpdate* update) {
+        (*update)->SetDouble("path.to.double", 3);
+        double out = 0;
+        ASSERT_TRUE((*update)->GetDouble("path.to.double", &out));
+        EXPECT_EQ(3, out);
+      },
+      [](ScopedDictionaryPrefUpdate* update) {
+        (*update)->SetDoubleWithoutPathExpansion("key.for.double", 4);
+        double out = 0;
+        ASSERT_TRUE(
+            (*update)->GetDoubleWithoutPathExpansion("key.for.double", &out));
+        EXPECT_EQ(4, out);
+      },
+      [](ScopedDictionaryPrefUpdate* update) {
+        (*update)->SetBoolean("path.to.boolean", true);
+        bool out = 0;
+        ASSERT_TRUE((*update)->GetBoolean("path.to.boolean", &out));
+        EXPECT_TRUE(out);
+      },
+      [](ScopedDictionaryPrefUpdate* update) {
+        (*update)->SetBooleanWithoutPathExpansion("key.for.boolean", false);
+        bool out = 0;
+        ASSERT_TRUE(
+            (*update)->GetBooleanWithoutPathExpansion("key.for.boolean", &out));
+        EXPECT_FALSE(out);
+      },
+      [](ScopedDictionaryPrefUpdate* update) {
+        (*update)->SetString("path.to.string", "hello");
+        std::string out;
+        ASSERT_TRUE((*update)->GetString("path.to.string", &out));
+        EXPECT_EQ("hello", out);
+      },
+      [](ScopedDictionaryPrefUpdate* update) {
+        (*update)->SetStringWithoutPathExpansion("key.for.string", "prefs!");
+        std::string out;
+        ASSERT_TRUE(
+            (*update)->GetStringWithoutPathExpansion("key.for.string", &out));
+        EXPECT_EQ("prefs!", out);
+      },
+      [](ScopedDictionaryPrefUpdate* update) {
+        (*update)->SetString("path.to.string", base::ASCIIToUTF16("hello"));
+        base::string16 out;
+        ASSERT_TRUE((*update)->GetString("path.to.string", &out));
+        EXPECT_EQ(base::ASCIIToUTF16("hello"), out);
+      },
+      [](ScopedDictionaryPrefUpdate* update) {
+        (*update)->SetStringWithoutPathExpansion("key.for.string16",
+                                                 base::ASCIIToUTF16("prefs!"));
+        base::string16 out;
+        ASSERT_TRUE(
+            (*update)->GetStringWithoutPathExpansion("key.for.string16", &out));
+        EXPECT_EQ(base::ASCIIToUTF16("prefs!"), out);
+      },
+      [](ScopedDictionaryPrefUpdate* update) {
+        base::Value buffer(std::vector<char>{1, 2, 3, 4, 5});
+        (*update)->Set("path.to.binary", base::MakeUnique<base::Value>(buffer));
+        const base::Value* out;
+        ASSERT_TRUE((*update)->GetBinary("path.to.binary", &out));
+        EXPECT_EQ(buffer, *out);
+      },
+      [](ScopedDictionaryPrefUpdate* update) {
+        base::ListValue list;
+        list.AppendInteger(1);
+        list.AppendDouble(2);
+        list.AppendBoolean(true);
+        list.AppendString("four");
+        (*update)->Set("path.to.list", list.CreateDeepCopy());
+        const base::ListValue* out = nullptr;
+        ASSERT_TRUE((*update)->GetList("path.to.list", &out));
+        EXPECT_EQ(list, *out);
+      },
+      [](ScopedDictionaryPrefUpdate* update) {
+        base::ListValue list;
+        list.AppendInteger(1);
+        list.AppendDouble(2);
+        list.AppendBoolean(true);
+        list.AppendString("four");
+        (*update)->SetWithoutPathExpansion("key.for.list",
+                                           list.CreateDeepCopy());
+        const base::ListValue* out = nullptr;
+        ASSERT_TRUE(
+            (*update)->GetListWithoutPathExpansion("key.for.list", &out));
+        EXPECT_EQ(list, *out);
+      },
+      [](ScopedDictionaryPrefUpdate* update) {
+        base::DictionaryValue dict;
+        dict.SetInteger("int", 1);
+        dict.SetDouble("double", 2);
+        dict.SetBoolean("bool", true);
+        dict.SetString("string", "four");
+        (*update)->Set("path.to.dict", dict.CreateDeepCopy());
+        const base::DictionaryValue* out = nullptr;
+        ASSERT_TRUE((*update)->GetDictionary("path.to.dict", &out));
+        EXPECT_EQ(dict, *out);
+      },
+      [](ScopedDictionaryPrefUpdate* update) {
+        base::DictionaryValue dict;
+        dict.SetInteger("int", 1);
+        dict.SetDouble("double", 2);
+        dict.SetBoolean("bool", true);
+        dict.SetString("string", "four");
+        (*update)->SetWithoutPathExpansion("key.for.dict",
+                                           dict.CreateDeepCopy());
+        const base::DictionaryValue* out = nullptr;
+        ASSERT_TRUE(
+            (*update)->GetDictionaryWithoutPathExpansion("key.for.dict", &out));
+        EXPECT_EQ(dict, *out);
+      },
+  };
+  int current_value = kInitialValue + 1;
+  for (auto& mutation : updates) {
+    base::DictionaryValue expected_value;
+    {
+      ScopedDictionaryPrefUpdate update(pref_service.get(), kDictionaryKey);
+      EXPECT_EQ(update->AsConstDictionary()->empty(), update->empty());
+      EXPECT_EQ(update->AsConstDictionary()->size(), update->size());
+      mutation(&update);
+      EXPECT_EQ(update->AsConstDictionary()->empty(), update->empty());
+      EXPECT_EQ(update->AsConstDictionary()->size(), update->size());
+      expected_value = *update->AsConstDictionary();
+    }
+
+    EXPECT_EQ(expected_value, *pref_service->GetDictionary(kDictionaryKey));
+    WaitForPrefChange(pref_service2.get(), kDictionaryKey);
+    EXPECT_EQ(expected_value, *pref_service2->GetDictionary(kDictionaryKey));
+
+    {
+      ScopedDictionaryPrefUpdate update(pref_service.get(), kDictionaryKey);
+      mutation(&update);
+      EXPECT_EQ(expected_value, *update->AsConstDictionary());
+    }
+    {
+      PrefChangeRegistrar registrar;
+      registrar.Init(pref_service2.get());
+      registrar.Add(kDictionaryKey, base::Bind(&Fail, pref_service2.get()));
+      pref_service->SetInteger(kKey, ++current_value);
+      WaitForPrefChange(pref_service2.get(), kKey);
+    }
+    if (!pref_service->GetDictionary(kDictionaryKey)->empty()) {
+      {
+        ScopedDictionaryPrefUpdate update(pref_service.get(), kDictionaryKey);
+        update->Clear();
+      }
+      WaitForPrefChange(pref_service2.get(), kDictionaryKey);
+    }
+  }
+}
+
+TEST_F(PrefServiceFactoryTest, MultipleClients_SubPrefUpdates_Erase) {
+  auto pref_service = Create();
+  auto pref_service2 = Create();
+  {
+    ScopedDictionaryPrefUpdate update(pref_service.get(), kDictionaryKey);
+    update->SetInteger("path.to.integer", 1);
+  }
+  WaitForPrefChange(pref_service2.get(), kDictionaryKey);
+
+  {
+    ScopedDictionaryPrefUpdate update(pref_service.get(), kDictionaryKey);
+    ASSERT_TRUE(update->RemovePath("path.to.integer", nullptr));
+  }
+  WaitForPrefChange(pref_service2.get(), kDictionaryKey);
+  EXPECT_TRUE(pref_service2->GetDictionary(kDictionaryKey)->empty());
+}
+
+TEST_F(PrefServiceFactoryTest, MultipleClients_SubPrefUpdates_ClearDictionary) {
+  auto pref_service = Create();
+  auto pref_service2 = Create();
+
+  { ScopedDictionaryPrefUpdate update(pref_service.get(), kDictionaryKey); }
+  WaitForPrefChange(pref_service2.get(), kDictionaryKey);
+
+  {
+    ScopedDictionaryPrefUpdate update(pref_service.get(), kDictionaryKey);
+    update->Clear();
+  }
+  PrefChangeRegistrar registrar;
+  registrar.Init(pref_service2.get());
+  registrar.Add(kDictionaryKey, base::Bind(&Fail, pref_service2.get()));
+  pref_service->SetInteger(kKey, kUpdatedValue);
+  WaitForPrefChange(pref_service2.get(), kKey);
+}
+
 }  // namespace
 }  // namespace prefs