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/sync_driver/sync_prefs.h" 6 7#include "base/command_line.h" 8#include "base/message_loop/message_loop.h" 9#include "base/prefs/pref_notifier_impl.h" 10#include "base/prefs/pref_value_store.h" 11#include "base/prefs/testing_pref_service.h" 12#include "base/time/time.h" 13#include "components/pref_registry/testing_pref_service_syncable.h" 14#include "components/sync_driver/pref_names.h" 15#include "sync/internal_api/public/base/model_type.h" 16#include "testing/gmock/include/gmock/gmock.h" 17#include "testing/gtest/include/gtest/gtest.h" 18 19namespace sync_driver { 20 21namespace { 22 23using ::testing::InSequence; 24using ::testing::StrictMock; 25 26class SyncPrefsTest : public testing::Test { 27 protected: 28 virtual void SetUp() OVERRIDE { 29 SyncPrefs::RegisterProfilePrefs(pref_service_.registry()); 30 } 31 32 user_prefs::TestingPrefServiceSyncable pref_service_; 33 34 private: 35 base::MessageLoop loop_; 36}; 37 38TEST_F(SyncPrefsTest, Basic) { 39 SyncPrefs sync_prefs(&pref_service_); 40 41 EXPECT_FALSE(sync_prefs.HasSyncSetupCompleted()); 42 sync_prefs.SetSyncSetupCompleted(); 43 EXPECT_TRUE(sync_prefs.HasSyncSetupCompleted()); 44 45 EXPECT_FALSE(sync_prefs.IsStartSuppressed()); 46 sync_prefs.SetStartSuppressed(true); 47 EXPECT_TRUE(sync_prefs.IsStartSuppressed()); 48 sync_prefs.SetStartSuppressed(false); 49 EXPECT_FALSE(sync_prefs.IsStartSuppressed()); 50 51 EXPECT_EQ(base::Time(), sync_prefs.GetLastSyncedTime()); 52 const base::Time& now = base::Time::Now(); 53 sync_prefs.SetLastSyncedTime(now); 54 EXPECT_EQ(now, sync_prefs.GetLastSyncedTime()); 55 56 EXPECT_TRUE(sync_prefs.HasKeepEverythingSynced()); 57 sync_prefs.SetKeepEverythingSynced(false); 58 EXPECT_FALSE(sync_prefs.HasKeepEverythingSynced()); 59 sync_prefs.SetKeepEverythingSynced(true); 60 EXPECT_TRUE(sync_prefs.HasKeepEverythingSynced()); 61 62 EXPECT_TRUE(sync_prefs.GetEncryptionBootstrapToken().empty()); 63 sync_prefs.SetEncryptionBootstrapToken("token"); 64 EXPECT_EQ("token", sync_prefs.GetEncryptionBootstrapToken()); 65} 66 67TEST_F(SyncPrefsTest, DefaultTypes) { 68 SyncPrefs sync_prefs(&pref_service_); 69 sync_prefs.SetKeepEverythingSynced(false); 70 71 // Only bookmarks and device info are enabled by default. 72 syncer::ModelTypeSet expected(syncer::BOOKMARKS, syncer::DEVICE_INFO); 73 syncer::ModelTypeSet preferred_types = 74 sync_prefs.GetPreferredDataTypes(syncer::UserTypes()); 75 EXPECT_TRUE(preferred_types.Equals(expected)); 76 77 // Simulate an upgrade to delete directives + proxy tabs support. None of the 78 // new types or their pref group types should be registering, ensuring they 79 // don't have pref values. 80 syncer::ModelTypeSet registered_types = syncer::UserTypes(); 81 registered_types.Remove(syncer::PROXY_TABS); 82 registered_types.Remove(syncer::TYPED_URLS); 83 registered_types.Remove(syncer::SESSIONS); 84 registered_types.Remove(syncer::HISTORY_DELETE_DIRECTIVES); 85 86 // Enable all other types. 87 sync_prefs.SetPreferredDataTypes(registered_types, registered_types); 88 89 // Manually enable typed urls (to simulate the old world). 90 pref_service_.SetBoolean(prefs::kSyncTypedUrls, true); 91 92 // Proxy tabs should not be enabled (since sessions wasn't), but history 93 // delete directives should (since typed urls was). 94 preferred_types = sync_prefs.GetPreferredDataTypes(syncer::UserTypes()); 95 EXPECT_FALSE(preferred_types.Has(syncer::PROXY_TABS)); 96 EXPECT_TRUE(preferred_types.Has(syncer::HISTORY_DELETE_DIRECTIVES)); 97 98 // Now manually enable sessions, which should result in proxy tabs also being 99 // enabled. Also, manually disable typed urls, which should mean that history 100 // delete directives are not enabled. 101 pref_service_.SetBoolean(prefs::kSyncTypedUrls, false); 102 pref_service_.SetBoolean(prefs::kSyncSessions, true); 103 preferred_types = sync_prefs.GetPreferredDataTypes(syncer::UserTypes()); 104 EXPECT_TRUE(preferred_types.Has(syncer::PROXY_TABS)); 105 EXPECT_FALSE(preferred_types.Has(syncer::HISTORY_DELETE_DIRECTIVES)); 106} 107 108TEST_F(SyncPrefsTest, PreferredTypesKeepEverythingSynced) { 109 SyncPrefs sync_prefs(&pref_service_); 110 111 EXPECT_TRUE(sync_prefs.HasKeepEverythingSynced()); 112 113 const syncer::ModelTypeSet user_types = syncer::UserTypes(); 114 EXPECT_TRUE(user_types.Equals(sync_prefs.GetPreferredDataTypes(user_types))); 115 const syncer::ModelTypeSet user_visible_types = syncer::UserSelectableTypes(); 116 for (syncer::ModelTypeSet::Iterator it = user_visible_types.First(); 117 it.Good(); 118 it.Inc()) { 119 syncer::ModelTypeSet preferred_types; 120 preferred_types.Put(it.Get()); 121 sync_prefs.SetPreferredDataTypes(user_types, preferred_types); 122 EXPECT_TRUE( 123 user_types.Equals(sync_prefs.GetPreferredDataTypes(user_types))); 124 } 125} 126 127TEST_F(SyncPrefsTest, PreferredTypesNotKeepEverythingSynced) { 128 SyncPrefs sync_prefs(&pref_service_); 129 130 sync_prefs.SetKeepEverythingSynced(false); 131 132 const syncer::ModelTypeSet user_types = syncer::UserTypes(); 133 EXPECT_FALSE(user_types.Equals(sync_prefs.GetPreferredDataTypes(user_types))); 134 const syncer::ModelTypeSet user_visible_types = syncer::UserSelectableTypes(); 135 for (syncer::ModelTypeSet::Iterator it = user_visible_types.First(); 136 it.Good(); 137 it.Inc()) { 138 syncer::ModelTypeSet preferred_types; 139 preferred_types.Put(it.Get()); 140 syncer::ModelTypeSet expected_preferred_types(preferred_types); 141 if (it.Get() == syncer::AUTOFILL) { 142 expected_preferred_types.Put(syncer::AUTOFILL_PROFILE); 143 } 144 if (it.Get() == syncer::PREFERENCES) { 145 expected_preferred_types.Put(syncer::DICTIONARY); 146 expected_preferred_types.Put(syncer::PRIORITY_PREFERENCES); 147 expected_preferred_types.Put(syncer::SEARCH_ENGINES); 148 } 149 if (it.Get() == syncer::APPS) { 150 expected_preferred_types.Put(syncer::APP_LIST); 151 expected_preferred_types.Put(syncer::APP_NOTIFICATIONS); 152 expected_preferred_types.Put(syncer::APP_SETTINGS); 153 } 154 if (it.Get() == syncer::EXTENSIONS) { 155 expected_preferred_types.Put(syncer::EXTENSION_SETTINGS); 156 } 157 if (it.Get() == syncer::TYPED_URLS) { 158 expected_preferred_types.Put(syncer::HISTORY_DELETE_DIRECTIVES); 159 expected_preferred_types.Put(syncer::SESSIONS); 160 expected_preferred_types.Put(syncer::FAVICON_IMAGES); 161 expected_preferred_types.Put(syncer::FAVICON_TRACKING); 162 } 163 if (it.Get() == syncer::PROXY_TABS) { 164 expected_preferred_types.Put(syncer::SESSIONS); 165 expected_preferred_types.Put(syncer::FAVICON_IMAGES); 166 expected_preferred_types.Put(syncer::FAVICON_TRACKING); 167 } 168 169 // Device info is always preferred. 170 expected_preferred_types.Put(syncer::DEVICE_INFO); 171 172 sync_prefs.SetPreferredDataTypes(user_types, preferred_types); 173 EXPECT_TRUE(expected_preferred_types.Equals( 174 sync_prefs.GetPreferredDataTypes(user_types))); 175 } 176} 177 178class MockSyncPrefObserver : public SyncPrefObserver { 179 public: 180 MOCK_METHOD1(OnSyncManagedPrefChange, void(bool)); 181}; 182 183TEST_F(SyncPrefsTest, ObservedPrefs) { 184 SyncPrefs sync_prefs(&pref_service_); 185 186 StrictMock<MockSyncPrefObserver> mock_sync_pref_observer; 187 InSequence dummy; 188 EXPECT_CALL(mock_sync_pref_observer, OnSyncManagedPrefChange(true)); 189 EXPECT_CALL(mock_sync_pref_observer, OnSyncManagedPrefChange(false)); 190 191 EXPECT_FALSE(sync_prefs.IsManaged()); 192 193 sync_prefs.AddSyncPrefObserver(&mock_sync_pref_observer); 194 195 sync_prefs.SetManagedForTest(true); 196 EXPECT_TRUE(sync_prefs.IsManaged()); 197 sync_prefs.SetManagedForTest(false); 198 EXPECT_FALSE(sync_prefs.IsManaged()); 199 200 sync_prefs.RemoveSyncPrefObserver(&mock_sync_pref_observer); 201} 202 203TEST_F(SyncPrefsTest, AcknowledgeSyncedTypes) { 204 SyncPrefs sync_prefs(&pref_service_); 205 206 syncer::ModelTypeSet expected_acknowledge_synced_types = 207 sync_prefs.GetAcknowledgeSyncedTypesForTest(); 208 for (int i = syncer::EXTENSION_SETTINGS; i < syncer::MODEL_TYPE_COUNT; ++i) { 209 const syncer::ModelType type = syncer::ModelTypeFromInt(i); 210 syncer::ModelTypeSet acknowledge_synced_types(type); 211 expected_acknowledge_synced_types.Put(type); 212 sync_prefs.AcknowledgeSyncedTypes(acknowledge_synced_types); 213 EXPECT_TRUE(expected_acknowledge_synced_types.Equals( 214 sync_prefs.GetAcknowledgeSyncedTypesForTest())); 215 } 216} 217 218TEST_F(SyncPrefsTest, ClearPreferences) { 219 SyncPrefs sync_prefs(&pref_service_); 220 221 EXPECT_FALSE(sync_prefs.HasSyncSetupCompleted()); 222 EXPECT_EQ(base::Time(), sync_prefs.GetLastSyncedTime()); 223 EXPECT_TRUE(sync_prefs.GetEncryptionBootstrapToken().empty()); 224 225 sync_prefs.SetSyncSetupCompleted(); 226 sync_prefs.SetLastSyncedTime(base::Time::Now()); 227 sync_prefs.SetEncryptionBootstrapToken("token"); 228 229 EXPECT_TRUE(sync_prefs.HasSyncSetupCompleted()); 230 EXPECT_NE(base::Time(), sync_prefs.GetLastSyncedTime()); 231 EXPECT_EQ("token", sync_prefs.GetEncryptionBootstrapToken()); 232 233 sync_prefs.ClearPreferences(); 234 235 EXPECT_FALSE(sync_prefs.HasSyncSetupCompleted()); 236 EXPECT_EQ(base::Time(), sync_prefs.GetLastSyncedTime()); 237 EXPECT_TRUE(sync_prefs.GetEncryptionBootstrapToken().empty()); 238} 239 240// Device info should always be enabled. 241TEST_F(SyncPrefsTest, DeviceInfo) { 242 SyncPrefs sync_prefs(&pref_service_); 243 EXPECT_TRUE(sync_prefs.GetPreferredDataTypes(syncer::UserTypes()) 244 .Has(syncer::DEVICE_INFO)); 245 sync_prefs.SetKeepEverythingSynced(true); 246 EXPECT_TRUE(sync_prefs.GetPreferredDataTypes(syncer::UserTypes()) 247 .Has(syncer::DEVICE_INFO)); 248 sync_prefs.SetKeepEverythingSynced(false); 249 EXPECT_TRUE(sync_prefs.GetPreferredDataTypes(syncer::UserTypes()) 250 .Has(syncer::DEVICE_INFO)); 251} 252 253} // namespace 254 255} // namespace sync_driver 256