OLD | NEW |
| (Empty) |
1 // Copyright (c) 2012 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 "components/syncable_prefs/pref_service_syncable.h" | |
6 | |
7 #include "base/bind.h" | |
8 #include "base/callback.h" | |
9 #include "base/files/file_path.h" | |
10 #include "base/strings/string_number_conversions.h" | |
11 #include "base/value_conversions.h" | |
12 #include "components/pref_registry/pref_registry_syncable.h" | |
13 #include "components/prefs/default_pref_store.h" | |
14 #include "components/prefs/overlay_user_pref_store.h" | |
15 #include "components/prefs/pref_notifier_impl.h" | |
16 #include "components/prefs/pref_registry.h" | |
17 #include "components/prefs/pref_value_store.h" | |
18 #include "components/syncable_prefs/pref_model_associator.h" | |
19 #include "components/syncable_prefs/pref_service_syncable_observer.h" | |
20 | |
21 namespace syncable_prefs { | |
22 | |
23 PrefServiceSyncable::PrefServiceSyncable( | |
24 PrefNotifierImpl* pref_notifier, | |
25 PrefValueStore* pref_value_store, | |
26 PersistentPrefStore* user_prefs, | |
27 user_prefs::PrefRegistrySyncable* pref_registry, | |
28 const PrefModelAssociatorClient* pref_model_associator_client, | |
29 base::Callback<void(PersistentPrefStore::PrefReadError)> | |
30 read_error_callback, | |
31 bool async) | |
32 : PrefService(pref_notifier, | |
33 pref_value_store, | |
34 user_prefs, | |
35 pref_registry, | |
36 read_error_callback, | |
37 async), | |
38 pref_service_forked_(false), | |
39 pref_sync_associator_(pref_model_associator_client, syncer::PREFERENCES), | |
40 priority_pref_sync_associator_(pref_model_associator_client, | |
41 syncer::PRIORITY_PREFERENCES) { | |
42 pref_sync_associator_.SetPrefService(this); | |
43 priority_pref_sync_associator_.SetPrefService(this); | |
44 | |
45 // Let PrefModelAssociators know about changes to preference values. | |
46 pref_value_store->set_callback(base::Bind( | |
47 &PrefServiceSyncable::ProcessPrefChange, base::Unretained(this))); | |
48 | |
49 // Add already-registered syncable preferences to PrefModelAssociator. | |
50 for (PrefRegistry::const_iterator it = pref_registry->begin(); | |
51 it != pref_registry->end(); ++it) { | |
52 const std::string& path = it->first; | |
53 AddRegisteredSyncablePreference(path, | |
54 pref_registry_->GetRegistrationFlags(path)); | |
55 } | |
56 | |
57 // Watch for syncable preferences registered after this point. | |
58 pref_registry->SetSyncableRegistrationCallback( | |
59 base::Bind(&PrefServiceSyncable::AddRegisteredSyncablePreference, | |
60 base::Unretained(this))); | |
61 } | |
62 | |
63 PrefServiceSyncable::~PrefServiceSyncable() { | |
64 // Remove our callback from the registry, since it may outlive us. | |
65 user_prefs::PrefRegistrySyncable* registry = | |
66 static_cast<user_prefs::PrefRegistrySyncable*>(pref_registry_.get()); | |
67 registry->SetSyncableRegistrationCallback( | |
68 user_prefs::PrefRegistrySyncable::SyncableRegistrationCallback()); | |
69 } | |
70 | |
71 PrefServiceSyncable* PrefServiceSyncable::CreateIncognitoPrefService( | |
72 PrefStore* incognito_extension_pref_store, | |
73 const std::vector<const char*>& overlay_pref_names) { | |
74 pref_service_forked_ = true; | |
75 PrefNotifierImpl* pref_notifier = new PrefNotifierImpl(); | |
76 OverlayUserPrefStore* incognito_pref_store = | |
77 new OverlayUserPrefStore(user_pref_store_.get()); | |
78 for (const char* overlay_pref_name : overlay_pref_names) | |
79 incognito_pref_store->RegisterOverlayPref(overlay_pref_name); | |
80 | |
81 scoped_refptr<user_prefs::PrefRegistrySyncable> forked_registry = | |
82 static_cast<user_prefs::PrefRegistrySyncable*>( | |
83 pref_registry_.get())->ForkForIncognito(); | |
84 PrefServiceSyncable* incognito_service = new PrefServiceSyncable( | |
85 pref_notifier, | |
86 pref_value_store_->CloneAndSpecialize(NULL, // managed | |
87 NULL, // supervised_user | |
88 incognito_extension_pref_store, | |
89 NULL, // command_line_prefs | |
90 incognito_pref_store, | |
91 NULL, // recommended | |
92 forked_registry->defaults().get(), | |
93 pref_notifier), | |
94 incognito_pref_store, | |
95 forked_registry.get(), | |
96 pref_sync_associator_.client(), | |
97 read_error_callback_, | |
98 false); | |
99 return incognito_service; | |
100 } | |
101 | |
102 bool PrefServiceSyncable::IsSyncing() { | |
103 return pref_sync_associator_.models_associated(); | |
104 } | |
105 | |
106 bool PrefServiceSyncable::IsPrioritySyncing() { | |
107 return priority_pref_sync_associator_.models_associated(); | |
108 } | |
109 | |
110 bool PrefServiceSyncable::IsPrefSynced(const std::string& name) const { | |
111 return pref_sync_associator_.IsPrefSynced(name) || | |
112 priority_pref_sync_associator_.IsPrefSynced(name); | |
113 } | |
114 | |
115 void PrefServiceSyncable::AddObserver(PrefServiceSyncableObserver* observer) { | |
116 observer_list_.AddObserver(observer); | |
117 } | |
118 | |
119 void PrefServiceSyncable::RemoveObserver( | |
120 PrefServiceSyncableObserver* observer) { | |
121 observer_list_.RemoveObserver(observer); | |
122 } | |
123 | |
124 syncer::SyncableService* PrefServiceSyncable::GetSyncableService( | |
125 const syncer::ModelType& type) { | |
126 if (type == syncer::PREFERENCES) { | |
127 return &pref_sync_associator_; | |
128 } else if (type == syncer::PRIORITY_PREFERENCES) { | |
129 return &priority_pref_sync_associator_; | |
130 } else { | |
131 NOTREACHED() << "invalid model type: " << type; | |
132 return NULL; | |
133 } | |
134 } | |
135 | |
136 void PrefServiceSyncable::UpdateCommandLinePrefStore( | |
137 PrefStore* cmd_line_store) { | |
138 // If |pref_service_forked_| is true, then this PrefService and the forked | |
139 // copies will be out of sync. | |
140 DCHECK(!pref_service_forked_); | |
141 PrefService::UpdateCommandLinePrefStore(cmd_line_store); | |
142 } | |
143 | |
144 void PrefServiceSyncable::AddSyncedPrefObserver(const std::string& name, | |
145 SyncedPrefObserver* observer) { | |
146 pref_sync_associator_.AddSyncedPrefObserver(name, observer); | |
147 priority_pref_sync_associator_.AddSyncedPrefObserver(name, observer); | |
148 } | |
149 | |
150 void PrefServiceSyncable::RemoveSyncedPrefObserver( | |
151 const std::string& name, | |
152 SyncedPrefObserver* observer) { | |
153 pref_sync_associator_.RemoveSyncedPrefObserver(name, observer); | |
154 priority_pref_sync_associator_.RemoveSyncedPrefObserver(name, observer); | |
155 } | |
156 | |
157 void PrefServiceSyncable::RegisterMergeDataFinishedCallback( | |
158 const base::Closure& callback) { | |
159 pref_sync_associator_.RegisterMergeDataFinishedCallback(callback); | |
160 } | |
161 | |
162 // Set the PrefModelAssociatorClient to use for that object during tests. | |
163 void PrefServiceSyncable::SetPrefModelAssociatorClientForTesting( | |
164 const PrefModelAssociatorClient* pref_model_associator_client) { | |
165 pref_sync_associator_.SetPrefModelAssociatorClientForTesting( | |
166 pref_model_associator_client); | |
167 priority_pref_sync_associator_.SetPrefModelAssociatorClientForTesting( | |
168 pref_model_associator_client); | |
169 } | |
170 | |
171 void PrefServiceSyncable::AddRegisteredSyncablePreference( | |
172 const std::string& path, | |
173 uint32_t flags) { | |
174 DCHECK(FindPreference(path)); | |
175 if (flags & user_prefs::PrefRegistrySyncable::SYNCABLE_PREF) { | |
176 pref_sync_associator_.RegisterPref(path.c_str()); | |
177 } else if (flags & user_prefs::PrefRegistrySyncable::SYNCABLE_PRIORITY_PREF) { | |
178 priority_pref_sync_associator_.RegisterPref(path.c_str()); | |
179 } | |
180 } | |
181 | |
182 void PrefServiceSyncable::OnIsSyncingChanged() { | |
183 for (auto& observer : observer_list_) | |
184 observer.OnIsSyncingChanged(); | |
185 } | |
186 | |
187 void PrefServiceSyncable::ProcessPrefChange(const std::string& name) { | |
188 pref_sync_associator_.ProcessPrefChange(name); | |
189 priority_pref_sync_associator_.ProcessPrefChange(name); | |
190 } | |
191 | |
192 } // namespace syncable_prefs | |
OLD | NEW |