Pref service: Add initial support for pref registration.

services/preferences/persistent_pref_store_impl_unittest.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/macros.h"
 #include "base/memory/ptr_util.h"
@@ skipping 73 matching lines @@
   ~InitializationMockPersistentPrefStore() override = default;
 
   bool initialized_ = false;
   bool success_;
   PersistentPrefStore::PrefReadError read_error_;
   bool read_only_;
   base::ObserverList<PrefStore::Observer, true> observers_;
 };
 
 constexpr char kKey[] = "path.to.key";
+constexpr char kOtherKey[] = "path.to.other_key";
 
 class PersistentPrefStoreImplTest : public testing::Test {
  public:
   PersistentPrefStoreImplTest() = default;
 
   // testing::Test:
   void TearDown() override {
     pref_store_ = nullptr;
     base::RunLoop().RunUntilIdle();
     impl_.reset();
     base::RunLoop().RunUntilIdle();
   }
 
   void CreateImpl(scoped_refptr<PersistentPrefStore> backing_pref_store) {
     base::RunLoop run_loop;
     bool initialized = backing_pref_store->IsInitializationComplete();
     impl_ = base::MakeUnique<PersistentPrefStoreImpl>(
         std::move(backing_pref_store), nullptr, run_loop.QuitClosure());
     if (!initialized)
       run_loop.Run();
     pref_store_ = CreateConnection();
   }
 
-  scoped_refptr<PersistentPrefStore> CreateConnection() {
-    return make_scoped_refptr(
-        new PersistentPrefStoreClient(impl_->CreateConnection()));
+  scoped_refptr<PersistentPrefStore> CreateConnection(
+      PersistentPrefStoreImpl::ObservedPrefs observed_prefs =
+          PersistentPrefStoreImpl::ObservedPrefs()) {
+    if (observed_prefs.empty())
+      observed_prefs.insert({kKey, kOtherKey});
+    return make_scoped_refptr(new PersistentPrefStoreClient(
+        impl_->CreateConnection(std::move(observed_prefs))));
   }
 
   PersistentPrefStore* pref_store() { return pref_store_.get(); }
 
  private:
   base::MessageLoop message_loop_;
 
   std::unique_ptr<PersistentPrefStoreImpl> impl_;
 
   scoped_refptr<PersistentPrefStore> pref_store_;
@@ skipping 83 matching lines @@
       .Times(1)
       .WillOnce(WithoutArgs(Invoke([&run_loop]() { run_loop.Quit(); })));
   run_loop.Run();
   other_pref_store->RemoveObserver(&observer);
 
   const base::Value* output = nullptr;
   ASSERT_TRUE(other_pref_store->GetValue(kKey, &output));
   EXPECT_TRUE(value.Equals(output));
 }
 
+TEST_F(PersistentPrefStoreImplTest, UnregisteredPrefNotObservedByOtherClient) {
+  auto backing_pref_store = make_scoped_refptr(new InMemoryPrefStore());
+  CreateImpl(backing_pref_store);
+  EXPECT_TRUE(pref_store()->IsInitializationComplete());
+
+  PersistentPrefStoreImpl::ObservedPrefs observed_prefs;
+  observed_prefs.insert(kKey);
+
+  auto other_pref_store = CreateConnection(std::move(observed_prefs));
+  EXPECT_TRUE(other_pref_store->IsInitializationComplete());
+
+  pref_store()->SetValue(kOtherKey, base::MakeUnique<base::Value>(123), 0);
+  pref_store()->SetValue(kKey, base::MakeUnique<base::Value>("value"), 0);
+
+  PrefStoreObserverMock observer;
+  other_pref_store->AddObserver(&observer);
+  base::RunLoop run_loop;
+  EXPECT_CALL(observer, OnPrefValueChanged(kOtherKey)).Times(0);
+  EXPECT_CALL(observer, OnPrefValueChanged(kKey))
+      .Times(1)
+      .WillOnce(WithoutArgs(Invoke([&run_loop]() { run_loop.Quit(); })));
+  run_loop.Run();
+  other_pref_store->RemoveObserver(&observer);
+
+  EXPECT_FALSE(other_pref_store->GetValue(kOtherKey, nullptr));
+}
+
 TEST_F(PersistentPrefStoreImplTest,
        WriteWithoutPathExpansionObservedByOtherClient) {
   auto backing_pref_store = make_scoped_refptr(new InMemoryPrefStore());
   CreateImpl(backing_pref_store);
   EXPECT_TRUE(pref_store()->IsInitializationComplete());
 
   auto other_pref_store = CreateConnection();
   EXPECT_TRUE(other_pref_store->IsInitializationComplete());
 
   base::DictionaryValue dict;
@@ skipping 115 matching lines @@
   EXPECT_CALL(*backing_store, ClearMutableValues())
       .Times(1)
       .WillOnce(WithoutArgs(Invoke([&run_loop]() { run_loop.Quit(); })));
   EXPECT_CALL(*backing_store, CommitPendingWrite()).Times(1);
   pref_store()->ClearMutableValues();
   run_loop.Run();
 }
 
 }  // namespace
 }  // namespace prefs