Pref service: support for incognito prefs

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 <algorithm>
 #include <utility>
 
 #include "base/memory/ref_counted.h"
 #include "base/stl_util.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "components/prefs/default_pref_store.h"
 #include "components/prefs/pref_value_store.h"
 #include "mojo/public/cpp/bindings/interface_request.h"
 #include "services/preferences/persistent_pref_store_factory.h"
 #include "services/preferences/persistent_pref_store_impl.h"
+#include "services/preferences/public/cpp/pref_store_client.h"
 #include "services/preferences/public/cpp/pref_store_impl.h"
 #include "services/service_manager/public/cpp/bind_source_info.h"
 
 namespace prefs {
 namespace {
 
 using ConnectCallback = mojom::PrefStoreConnector::ConnectCallback;
 using PrefStorePtrs =
     std::unordered_map<PrefValueStore::PrefStoreType, mojom::PrefStore*>;
 
@@ skipping 93 matching lines @@
       defaults_(new DefaultPrefStore),
       defaults_wrapper_(base::MakeUnique<PrefStoreImpl>(
           defaults_,
           mojo::MakeRequest(&pref_store_ptrs_[PrefValueStore::DEFAULT_STORE]))),
       worker_pool_(std::move(worker_pool)) {
   DCHECK(
       base::ContainsValue(expected_pref_stores_, PrefValueStore::USER_STORE) &&
       base::ContainsValue(expected_pref_stores_, PrefValueStore::DEFAULT_STORE))
       << "expected_pref_stores must always include PrefValueStore::USER_STORE "
          "and PrefValueStore::DEFAULT_STORE.";
-  // The user store is not actually connected to in the implementation, but
-  // accessed directly.
+  // The user store is not actually registered or connected to in the
+  // implementation, but accessed directly.
   expected_pref_stores_.erase(PrefValueStore::USER_STORE);
+  DVLOG(1) << "Expecting " << expected_pref_stores_.size()
+           << " pref store(s) to register";
+  // This store is done in-process so it's already "registered":
+  DVLOG(1) << "Registering pref store: " << PrefValueStore::DEFAULT_STORE;
   registry_.AddInterface<prefs::mojom::PrefStoreConnector>(
       base::Bind(&PrefStoreManagerImpl::BindPrefStoreConnectorRequest,
                  base::Unretained(this)));
   registry_.AddInterface<prefs::mojom::PrefStoreRegistry>(
       base::Bind(&PrefStoreManagerImpl::BindPrefStoreRegistryRequest,
                  base::Unretained(this)));
   registry_.AddInterface<prefs::mojom::PrefServiceControl>(
       base::Bind(&PrefStoreManagerImpl::BindPrefServiceControlRequest,
                  base::Unretained(this)));
 }
 
-PrefStoreManagerImpl::~PrefStoreManagerImpl() = default;
+PrefStoreManagerImpl::~PrefStoreManagerImpl() {
+  // For logging consistency:
+  DVLOG(1) << "Deregistering pref store: " << PrefValueStore::DEFAULT_STORE;
+}
 
 struct PrefStoreManagerImpl::PendingConnect {
   mojom::PrefRegistryPtr pref_registry;
   // Pref stores the caller already is connected to (and hence we won't
   // connect to these).
   std::vector<PrefValueStore::PrefStoreType> already_connected_types;
   ConnectCallback callback;
 };
 
 void PrefStoreManagerImpl::Register(PrefValueStore::PrefStoreType type,
@@ skipping 13 matching lines @@
   if (AllConnected()) {
     DVLOG(1) << "All pref stores registered.";
     ProcessPendingConnects();
   }
 }
 
 void PrefStoreManagerImpl::Connect(
     mojom::PrefRegistryPtr pref_registry,
     const std::vector<PrefValueStore::PrefStoreType>& already_connected_types,
     const ConnectCallback& callback) {
+  DVLOG(1) << "Will connect to "
+           << expected_pref_stores_.size() - already_connected_types.size()
+           << " pref store(s)";
+  if (incognito_connector_ &&
+      !base::ContainsValue(already_connected_types,
+                           PrefValueStore::INCOGNITO_STORE)) {
+    incognito_connector_->ConnectToUserPrefStore(
+        mojo::MakeRequest(&pref_store_ptrs_[PrefValueStore::INCOGNITO_STORE]));
+  }
   if (AllConnected()) {
     ConnectImpl(std::move(pref_registry), already_connected_types, callback);
   } else {
     pending_connects_.push_back(
         {std::move(pref_registry), already_connected_types, callback});
   }
 }
 
+void PrefStoreManagerImpl::ConnectToUserPrefStore(
+    mojom::PrefStoreRequest request) {
+  pending_ro_persistent_pref_store_requests_.push_back(std::move(request));
+  if (AllConnected())
+    ProcessPendingConnects();
+}
+
 void PrefStoreManagerImpl::BindPrefStoreConnectorRequest(
     const service_manager::BindSourceInfo& source_info,
     prefs::mojom::PrefStoreConnectorRequest request) {
   connector_bindings_.AddBinding(this, std::move(request));
 }
 
 void PrefStoreManagerImpl::BindPrefStoreRegistryRequest(
     const service_manager::BindSourceInfo& source_info,
     prefs::mojom::PrefStoreRegistryRequest request) {
   registry_bindings_.AddBinding(this, std::move(request));
 }
 
 void PrefStoreManagerImpl::BindPrefServiceControlRequest(
     const service_manager::BindSourceInfo& source_info,
     prefs::mojom::PrefServiceControlRequest request) {
   if (init_binding_.is_bound()) {
     LOG(ERROR)
         << "Pref service received unexpected control interface connection from "
         << source_info.identity.name();
     return;
   }
 
   init_binding_.Bind(std::move(request));
 }
 
 void PrefStoreManagerImpl::Init(
     mojom::PersistentPrefStoreConfigurationPtr configuration) {
   DCHECK(!persistent_pref_store_);
 
+  if (configuration->is_incognito_configuration()) {
+    DCHECK(expected_pref_stores_.count(PrefValueStore::INCOGNITO_STORE))
+        << "expected_pref_stores must include PrefValueStore::INCOGNITO_STORE "
+        << "when creating an incognito instance";
+    incognito_connector_ =
+        std::move(configuration->get_incognito_configuration()->connector);
+  }
   persistent_pref_store_ = CreatePersistentPrefStore(
       std::move(configuration), worker_pool_.get(),
       base::Bind(&PrefStoreManagerImpl::OnPersistentPrefStoreReady,
                  base::Unretained(this)));
   DCHECK(persistent_pref_store_);
   if (AllConnected())
     ProcessPendingConnects();
 }
 
 void PrefStoreManagerImpl::OnStart() {}
 
 void PrefStoreManagerImpl::OnBindInterface(
     const service_manager::BindSourceInfo& source_info,
     const std::string& interface_name,
     mojo::ScopedMessagePipeHandle interface_pipe) {
   registry_.BindInterface(source_info, interface_name,
                           std::move(interface_pipe));
 }
 
 void PrefStoreManagerImpl::OnPrefStoreDisconnect(
     PrefValueStore::PrefStoreType type) {
   DVLOG(1) << "Deregistering pref store: " << type;
   pref_store_ptrs_.erase(type);
 }
 
 bool PrefStoreManagerImpl::AllConnected() const {
+  DCHECK_LE(pref_store_ptrs_.size(), expected_pref_stores_.size());
   return pref_store_ptrs_.size() == expected_pref_stores_.size() &&
          persistent_pref_store_ && persistent_pref_store_->initialized();
 }
 
 void PrefStoreManagerImpl::ProcessPendingConnects() {
+  DCHECK(persistent_pref_store_);
   for (auto& connect : pending_connects_)
     ConnectImpl(std::move(connect.pref_registry),
                 connect.already_connected_types, connect.callback);
   pending_connects_.clear();
+  ro_persistent_pref_store_bindings_.reset(
+      new mojo::BindingSet<mojom::PrefStore>());
+  for (auto& request : pending_ro_persistent_pref_store_requests_) {
+    ro_persistent_pref_store_bindings_->AddBinding(persistent_pref_store_.get(),
+                                                   std::move(request));
+  }
+  pending_ro_persistent_pref_store_requests_.clear();
 }
 
-void PrefStoreManagerImpl::ConnectImpl(
-    mojom::PrefRegistryPtr pref_registry,
-    const std::vector<PrefValueStore::PrefStoreType>& already_connected_types,
-    const ConnectCallback& callback) {
+std::vector<std::string> PrefStoreManagerImpl::RegisterPrefs(
+    mojom::PrefRegistryPtr pref_registry) {
   std::vector<std::string> observed_prefs;
   for (auto& registration : pref_registry->registrations) {
     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));
   }
+  return observed_prefs;
+}
 
+void PrefStoreManagerImpl::ConnectImpl(
+    mojom::PrefRegistryPtr pref_registry,
+    const std::vector<PrefValueStore::PrefStoreType>& already_connected_types,
+    const ConnectCallback& callback) {
+  std::vector<std::string> observed_prefs =
+      RegisterPrefs(std::move(pref_registry));
   // Only connect to pref stores the client isn't already connected to.
   PrefStorePtrs ptrs;
   for (const auto& entry : pref_store_ptrs_) {
     if (!base::ContainsValue(already_connected_types, entry.first)) {
       ptrs.insert(std::make_pair(entry.first, entry.second.get()));
     }
   }
   ConnectionBarrier::Create(
       ptrs,
       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