Pref service: Filter updates from read-only pref stores.

services/preferences/pref_store_manager_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/pref_store_manager_impl.h"
 
 #include <utility>
 
 #include "base/memory/ref_counted.h"
 #include "base/threading/sequenced_worker_pool.h"
@@ skipping 12 matching lines @@
 using PrefStorePtrs =
     std::unordered_map<PrefValueStore::PrefStoreType, mojom::PrefStorePtr>;
 
 // Used to make sure all pref stores have been registered before replying to any
 // Connect calls.
 class ConnectionBarrier : public base::RefCounted<ConnectionBarrier> {
  public:
   static void Create(
       const PrefStorePtrs& pref_store_ptrs,
       mojom::PersistentPrefStoreConnectionPtr persistent_pref_store_connection,
+      const std::vector<std::string>& observed_prefs,
       const ConnectCallback& callback);
 
-  void Init(const PrefStorePtrs& pref_store_ptrs);
+  void Init(const PrefStorePtrs& pref_store_ptrs,
+            const std::vector<std::string>& observed_prefs);
 
  private:
   friend class base::RefCounted<ConnectionBarrier>;
   ConnectionBarrier(
       const PrefStorePtrs& pref_store_ptrs,
       mojom::PersistentPrefStoreConnectionPtr persistent_pref_store_connection,
       const ConnectCallback& callback);
   ~ConnectionBarrier() = default;
 
   void OnConnect(PrefValueStore::PrefStoreType type,
                  mojom::PrefStoreConnectionPtr connection_ptr);
 
   ConnectCallback callback_;
 
   std::unordered_map<PrefValueStore::PrefStoreType,
                      mojom::PrefStoreConnectionPtr>
       connections_;
 
   const size_t expected_connections_;
 
   mojom::PersistentPrefStoreConnectionPtr persistent_pref_store_connection_;
 
   DISALLOW_COPY_AND_ASSIGN(ConnectionBarrier);
 };
 
 // static
 void ConnectionBarrier::Create(
     const PrefStorePtrs& pref_store_ptrs,
     mojom::PersistentPrefStoreConnectionPtr persistent_pref_store_connection,
+    const std::vector<std::string>& observed_prefs,
     const ConnectCallback& callback) {
   make_scoped_refptr(new ConnectionBarrier(
                          pref_store_ptrs,
                          std::move(persistent_pref_store_connection), callback))
-      ->Init(pref_store_ptrs);
+      ->Init(pref_store_ptrs, observed_prefs);
 }
 
-void ConnectionBarrier::Init(const PrefStorePtrs& pref_store_ptrs) {
+void ConnectionBarrier::Init(const PrefStorePtrs& pref_store_ptrs,
+                             const std::vector<std::string>& observed_prefs) {
   for (const auto& ptr : pref_store_ptrs) {
     ptr.second->AddObserver(
+        observed_prefs,
         base::Bind(&ConnectionBarrier::OnConnect, this, ptr.first));
   }
 }
 
 ConnectionBarrier::ConnectionBarrier(
     const PrefStorePtrs& pref_store_ptrs,
     mojom::PersistentPrefStoreConnectionPtr persistent_pref_store_connection,
     const ConnectCallback& callback)
     : callback_(callback),
       expected_connections_(pref_store_ptrs.size()),
@@ skipping 120 matching lines @@
 }
 
 void PrefStoreManagerImpl::ProcessPendingConnects() {
   for (auto& connect : pending_connects_)
     ConnectImpl(std::move(connect.second), connect.first);
   pending_connects_.clear();
 }
 
 void PrefStoreManagerImpl::ConnectImpl(mojom::PrefRegistryPtr pref_registry,
                                        const ConnectCallback& callback) {
-  PersistentPrefStoreImpl::ObservedPrefs observed_prefs;
+  std::vector<std::string> observed_prefs;
   for (auto& registration : pref_registry->registrations) {
-    observed_prefs.insert(registration.first);
+    observed_prefs.push_back(registration.first);
     const auto& key = registration.first;
     auto& default_value = registration.second->default_value;
     const base::Value* old_default = nullptr;
     // TODO(sammc): Once non-owning registrations are supported, disallow
     // multiple owners instead of just checking for consistent defaults.
     if (defaults_->GetValue(key, &old_default))
       DCHECK(old_default->Equals(default_value.get()));
     else
       defaults_->SetDefaultValue(key, std::move(default_value));
   }
   ConnectionBarrier::Create(
       pref_store_ptrs_,
-      persistent_pref_store_->CreateConnection(std::move(observed_prefs)),
-      callback);
+      persistent_pref_store_->CreateConnection(
+          PersistentPrefStoreImpl::ObservedPrefs(observed_prefs.begin(),
+                                                 observed_prefs.end())),
+      observed_prefs, callback);
 }
 
 void PrefStoreManagerImpl::OnPersistentPrefStoreReady() {
   DVLOG(1) << "PersistentPrefStore ready";
   if (AllConnected()) {
     ProcessPendingConnects();
   }
 }
 
 }  // namespace prefs