| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright 2017 The Chromium Authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #include "services/preferences/public/cpp/pref_store_manager_impl.h" | |
| 6 | |
| 7 #include <utility> | |
| 8 | |
| 9 #include "base/memory/ref_counted.h" | |
| 10 #include "base/threading/sequenced_worker_pool.h" | |
| 11 #include "components/prefs/pref_value_store.h" | |
| 12 #include "mojo/public/cpp/bindings/interface_request.h" | |
| 13 #include "services/preferences/persistent_pref_store_factory.h" | |
| 14 #include "services/preferences/persistent_pref_store_impl.h" | |
| 15 #include "services/service_manager/public/cpp/interface_registry.h" | |
| 16 | |
| 17 namespace prefs { | |
| 18 namespace { | |
| 19 | |
| 20 using ConnectCallback = mojom::PrefStoreConnector::ConnectCallback; | |
| 21 using PrefStorePtrs = | |
| 22 std::unordered_map<PrefValueStore::PrefStoreType, mojom::PrefStorePtr>; | |
| 23 | |
| 24 // Used to make sure all pref stores have been registered before replying to any | |
| 25 // Connect calls. | |
| 26 class ConnectionBarrier : public base::RefCounted<ConnectionBarrier> { | |
| 27 public: | |
| 28 static void Create(const PrefStorePtrs& pref_store_ptrs, | |
| 29 const ConnectCallback& callback); | |
| 30 | |
| 31 void Init(const PrefStorePtrs& pref_store_ptrs); | |
| 32 | |
| 33 private: | |
| 34 friend class base::RefCounted<ConnectionBarrier>; | |
| 35 ConnectionBarrier(const PrefStorePtrs& pref_store_ptrs, | |
| 36 const ConnectCallback& callback); | |
| 37 ~ConnectionBarrier() = default; | |
| 38 | |
| 39 void OnConnect(PrefValueStore::PrefStoreType type, | |
| 40 mojom::PrefStoreConnectionPtr connection_ptr); | |
| 41 | |
| 42 ConnectCallback callback_; | |
| 43 | |
| 44 std::unordered_map<PrefValueStore::PrefStoreType, | |
| 45 mojom::PrefStoreConnectionPtr> | |
| 46 connections_; | |
| 47 | |
| 48 const size_t expected_connections_; | |
| 49 | |
| 50 DISALLOW_COPY_AND_ASSIGN(ConnectionBarrier); | |
| 51 }; | |
| 52 | |
| 53 // static | |
| 54 void ConnectionBarrier::Create(const PrefStorePtrs& pref_store_ptrs, | |
| 55 const ConnectCallback& callback) { | |
| 56 make_scoped_refptr(new ConnectionBarrier(pref_store_ptrs, callback)) | |
| 57 ->Init(pref_store_ptrs); | |
| 58 } | |
| 59 | |
| 60 void ConnectionBarrier::Init(const PrefStorePtrs& pref_store_ptrs) { | |
| 61 for (const auto& ptr : pref_store_ptrs) { | |
| 62 ptr.second->AddObserver( | |
| 63 base::Bind(&ConnectionBarrier::OnConnect, this, ptr.first)); | |
| 64 } | |
| 65 } | |
| 66 | |
| 67 ConnectionBarrier::ConnectionBarrier(const PrefStorePtrs& pref_store_ptrs, | |
| 68 const ConnectCallback& callback) | |
| 69 : callback_(callback), expected_connections_(pref_store_ptrs.size()) {} | |
| 70 | |
| 71 void ConnectionBarrier::OnConnect( | |
| 72 PrefValueStore::PrefStoreType type, | |
| 73 mojom::PrefStoreConnectionPtr connection_ptr) { | |
| 74 connections_.insert(std::make_pair(type, std::move(connection_ptr))); | |
| 75 if (connections_.size() == expected_connections_) { | |
| 76 // After this method exits |this| will get destroyed so it's safe to move | |
| 77 // out the map. | |
| 78 callback_.Run(std::move(connections_)); | |
| 79 } | |
| 80 } | |
| 81 | |
| 82 } // namespace | |
| 83 | |
| 84 PrefStoreManagerImpl::PrefStoreManagerImpl( | |
| 85 PrefStoreTypes expected_pref_stores, | |
| 86 scoped_refptr<base::SequencedWorkerPool> worker_pool) | |
| 87 : expected_pref_stores_(std::move(expected_pref_stores)), | |
| 88 init_binding_(this), | |
| 89 worker_pool_(std::move(worker_pool)) {} | |
| 90 | |
| 91 PrefStoreManagerImpl::~PrefStoreManagerImpl() = default; | |
| 92 | |
| 93 void PrefStoreManagerImpl::Register(PrefValueStore::PrefStoreType type, | |
| 94 mojom::PrefStorePtr pref_store_ptr) { | |
| 95 if (expected_pref_stores_.count(type) == 0) { | |
| 96 LOG(WARNING) << "Not registering unexpected pref store: " << type; | |
| 97 return; | |
| 98 } | |
| 99 DVLOG(1) << "Registering pref store: " << type; | |
| 100 pref_store_ptr.set_connection_error_handler( | |
| 101 base::Bind(&PrefStoreManagerImpl::OnPrefStoreDisconnect, | |
| 102 base::Unretained(this), type)); | |
| 103 const bool success = | |
| 104 pref_store_ptrs_.insert(std::make_pair(type, std::move(pref_store_ptr))) | |
| 105 .second; | |
| 106 DCHECK(success) << "The same pref store registered twice: " << type; | |
| 107 if (AllConnected()) { | |
| 108 DVLOG(1) << "All pref stores registered."; | |
| 109 for (const auto& callback : pending_callbacks_) | |
| 110 ConnectionBarrier::Create(pref_store_ptrs_, callback); | |
| 111 pending_callbacks_.clear(); | |
| 112 } | |
| 113 } | |
| 114 | |
| 115 void PrefStoreManagerImpl::Connect(const ConnectCallback& callback) { | |
| 116 if (AllConnected()) | |
| 117 ConnectionBarrier::Create(pref_store_ptrs_, callback); | |
| 118 else | |
| 119 pending_callbacks_.push_back(callback); | |
| 120 } | |
| 121 | |
| 122 void PrefStoreManagerImpl::Create( | |
| 123 const service_manager::Identity& remote_identity, | |
| 124 prefs::mojom::PrefStoreConnectorRequest request) { | |
| 125 connector_bindings_.AddBinding(this, std::move(request)); | |
| 126 } | |
| 127 | |
| 128 void PrefStoreManagerImpl::Create( | |
| 129 const service_manager::Identity& remote_identity, | |
| 130 prefs::mojom::PrefStoreRegistryRequest request) { | |
| 131 registry_bindings_.AddBinding(this, std::move(request)); | |
| 132 } | |
| 133 | |
| 134 void PrefStoreManagerImpl::Create( | |
| 135 const service_manager::Identity& remote_identity, | |
| 136 prefs::mojom::PersistentPrefStoreConnectorRequest request) { | |
| 137 if (!persistent_pref_store_) { | |
| 138 pending_persistent_pref_store_requests_.push_back(std::move(request)); | |
| 139 return; | |
| 140 } | |
| 141 persistent_pref_store_bindings_.AddBinding(persistent_pref_store_.get(), | |
| 142 std::move(request)); | |
| 143 } | |
| 144 | |
| 145 void PrefStoreManagerImpl::Create( | |
| 146 const service_manager::Identity& remote_identity, | |
| 147 prefs::mojom::PrefServiceControlRequest request) { | |
| 148 if (init_binding_.is_bound()) { | |
| 149 LOG(ERROR) | |
| 150 << "Pref service received unexpected control interface connection from " | |
| 151 << remote_identity.name(); | |
| 152 return; | |
| 153 } | |
| 154 | |
| 155 init_binding_.Bind(std::move(request)); | |
| 156 } | |
| 157 | |
| 158 void PrefStoreManagerImpl::Init( | |
| 159 mojom::PersistentPrefStoreConfigurationPtr configuration) { | |
| 160 DCHECK(!persistent_pref_store_); | |
| 161 | |
| 162 persistent_pref_store_ = | |
| 163 CreatePersistentPrefStore(std::move(configuration), worker_pool_.get()); | |
| 164 DCHECK(persistent_pref_store_); | |
| 165 for (auto& request : pending_persistent_pref_store_requests_) { | |
| 166 persistent_pref_store_bindings_.AddBinding(persistent_pref_store_.get(), | |
| 167 std::move(request)); | |
| 168 } | |
| 169 pending_persistent_pref_store_requests_.clear(); | |
| 170 } | |
| 171 | |
| 172 void PrefStoreManagerImpl::OnStart() {} | |
| 173 | |
| 174 bool PrefStoreManagerImpl::OnConnect( | |
| 175 const service_manager::ServiceInfo& remote_info, | |
| 176 service_manager::InterfaceRegistry* registry) { | |
| 177 registry->AddInterface<prefs::mojom::PrefStoreConnector>(this); | |
| 178 registry->AddInterface<prefs::mojom::PrefStoreRegistry>(this); | |
| 179 registry->AddInterface<prefs::mojom::PersistentPrefStoreConnector>(this); | |
| 180 registry->AddInterface<prefs::mojom::PrefServiceControl>(this); | |
| 181 return true; | |
| 182 } | |
| 183 | |
| 184 void PrefStoreManagerImpl::OnPrefStoreDisconnect( | |
| 185 PrefValueStore::PrefStoreType type) { | |
| 186 DVLOG(1) << "Deregistering pref store: " << type; | |
| 187 pref_store_ptrs_.erase(type); | |
| 188 } | |
| 189 | |
| 190 bool PrefStoreManagerImpl::AllConnected() const { | |
| 191 return pref_store_ptrs_.size() == expected_pref_stores_.size(); | |
| 192 } | |
| 193 | |
| 194 } // namespace prefs | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2759413002:
Move PrefStoreManagerImpl into //services/preferences. (Closed)
