diff options
110 files changed, 2235 insertions, 1490 deletions
diff --git a/chrome/browser/about_flags_unittest.cc b/chrome/browser/about_flags_unittest.cc index 32b002d..21a85cb 100644 --- a/chrome/browser/about_flags_unittest.cc +++ b/chrome/browser/about_flags_unittest.cc @@ -86,11 +86,18 @@ static Experiment kExperiments[] = { class AboutFlagsTest : public ::testing::Test { protected: AboutFlagsTest() { - prefs_.RegisterListPref(prefs::kEnabledLabsExperiments); + prefs_.RegisterListPref(prefs::kEnabledLabsExperiments, + PrefService::UNSYNCABLE_PREF); #if defined(OS_CHROMEOS) - prefs_.RegisterBooleanPref(prefs::kLabsMediaplayerEnabled, false); - prefs_.RegisterBooleanPref(prefs::kLabsAdvancedFilesystemEnabled, false); - prefs_.RegisterBooleanPref(prefs::kUseVerticalTabs, false); + prefs_.RegisterBooleanPref(prefs::kLabsMediaplayerEnabled, + false, + PrefService::UNSYNCABLE_PREF); + prefs_.RegisterBooleanPref(prefs::kLabsAdvancedFilesystemEnabled, + false, + PrefService::UNSYNCABLE_PREF); + prefs_.RegisterBooleanPref(prefs::kUseVerticalTabs, + false, + PrefService::UNSYNCABLE_PREF); #endif testing::ClearState(); } diff --git a/chrome/browser/autofill/autofill_manager.cc b/chrome/browser/autofill/autofill_manager.cc index 699b93d..c5f6781 100644 --- a/chrome/browser/autofill/autofill_manager.cc +++ b/chrome/browser/autofill/autofill_manager.cc @@ -250,16 +250,24 @@ void AutofillManager::RegisterBrowserPrefs(PrefService* prefs) { // static void AutofillManager::RegisterUserPrefs(PrefService* prefs) { - prefs->RegisterBooleanPref(prefs::kAutofillEnabled, true); + prefs->RegisterBooleanPref(prefs::kAutofillEnabled, + true, + PrefService::SYNCABLE_PREF); #if defined(OS_MACOSX) - prefs->RegisterBooleanPref(prefs::kAutofillAuxiliaryProfilesEnabled, true); + prefs->RegisterBooleanPref(prefs::kAutofillAuxiliaryProfilesEnabled, + true, + PrefService::SYNCABLE_PREF); #else - prefs->RegisterBooleanPref(prefs::kAutofillAuxiliaryProfilesEnabled, false); + prefs->RegisterBooleanPref(prefs::kAutofillAuxiliaryProfilesEnabled, + false, + PrefService::UNSYNCABLE_PREF); #endif prefs->RegisterDoublePref(prefs::kAutofillPositiveUploadRate, - kAutofillPositiveUploadRateDefaultValue); + kAutofillPositiveUploadRateDefaultValue, + PrefService::UNSYNCABLE_PREF); prefs->RegisterDoublePref(prefs::kAutofillNegativeUploadRate, - kAutofillNegativeUploadRateDefaultValue); + kAutofillNegativeUploadRateDefaultValue, + PrefService::UNSYNCABLE_PREF); } void AutofillManager::DidNavigateMainFramePostCommit( diff --git a/chrome/browser/background_contents_service.cc b/chrome/browser/background_contents_service.cc index 4ac5c5f..1c22b51 100644 --- a/chrome/browser/background_contents_service.cc +++ b/chrome/browser/background_contents_service.cc @@ -553,7 +553,8 @@ const string16& BackgroundContentsService::GetParentApplicationId( // static void BackgroundContentsService::RegisterUserPrefs(PrefService* prefs) { - prefs->RegisterDictionaryPref(prefs::kRegisteredBackgroundContents); + prefs->RegisterDictionaryPref(prefs::kRegisteredBackgroundContents, + PrefService::UNSYNCABLE_PREF); } void BackgroundContentsService::AddTabContents( diff --git a/chrome/browser/bookmarks/bookmark_utils.cc b/chrome/browser/bookmarks/bookmark_utils.cc index d5846a6..22a2d21 100644 --- a/chrome/browser/bookmarks/bookmark_utils.cc +++ b/chrome/browser/bookmarks/bookmark_utils.cc @@ -624,8 +624,12 @@ void ToggleWhenVisible(Profile* profile) { } void RegisterUserPrefs(PrefService* prefs) { - prefs->RegisterBooleanPref(prefs::kShowBookmarkBar, false); - prefs->RegisterBooleanPref(prefs::kEditBookmarksEnabled, true); + prefs->RegisterBooleanPref(prefs::kShowBookmarkBar, + false, + PrefService::SYNCABLE_PREF); + prefs->RegisterBooleanPref(prefs::kEditBookmarksEnabled, + true, + PrefService::UNSYNCABLE_PREF); } void GetURLAndTitleToBookmark(TabContents* tab_contents, diff --git a/chrome/browser/chromeos/audio_mixer_alsa.cc b/chrome/browser/chromeos/audio_mixer_alsa.cc index 1bb3edc..a97e27a 100644 --- a/chrome/browser/chromeos/audio_mixer_alsa.cc +++ b/chrome/browser/chromeos/audio_mixer_alsa.cc @@ -198,9 +198,13 @@ AudioMixer::State AudioMixerAlsa::GetState() const { // static void AudioMixerAlsa::RegisterPrefs(PrefService* local_state) { if (!local_state->FindPreference(prefs::kAudioVolume)) - local_state->RegisterDoublePref(prefs::kAudioVolume, kPrefVolumeInvalid); + local_state->RegisterDoublePref(prefs::kAudioVolume, + kPrefVolumeInvalid, + PrefService::UNSYNCABLE_PREF); if (!local_state->FindPreference(prefs::kAudioMute)) - local_state->RegisterIntegerPref(prefs::kAudioMute, kPrefMuteInvalid); + local_state->RegisterIntegerPref(prefs::kAudioMute, + kPrefMuteInvalid, + PrefService::UNSYNCABLE_PREF); } //////////////////////////////////////////////////////////////////////////////// diff --git a/chrome/browser/chromeos/customization_document.cc b/chrome/browser/chromeos/customization_document.cc index 37323cf..35557d9 100644 --- a/chrome/browser/chromeos/customization_document.cc +++ b/chrome/browser/chromeos/customization_document.cc @@ -264,7 +264,8 @@ ServicesCustomizationDocument* ServicesCustomizationDocument::GetInstance() { // static void ServicesCustomizationDocument::RegisterPrefs(PrefService* local_state) { - local_state->RegisterBooleanPref(kServicesCustomizationAppliedPref, false); + local_state->RegisterBooleanPref(kServicesCustomizationAppliedPref, false, + PrefService::UNSYNCABLE_PREF); } // static diff --git a/chrome/browser/chromeos/login/user_manager.cc b/chrome/browser/chromeos/login/user_manager.cc index a296993..30afc50 100644 --- a/chrome/browser/chromeos/login/user_manager.cc +++ b/chrome/browser/chromeos/login/user_manager.cc @@ -236,8 +236,9 @@ UserManager* UserManager::Get() { // static void UserManager::RegisterPrefs(PrefService* local_state) { - local_state->RegisterListPref(kLoggedInUsers); - local_state->RegisterDictionaryPref(kUserImages); + local_state->RegisterListPref(kLoggedInUsers, PrefService::UNSYNCABLE_PREF); + local_state->RegisterDictionaryPref(kUserImages, + PrefService::UNSYNCABLE_PREF); } std::vector<UserManager::User> UserManager::GetUsers() const { diff --git a/chrome/browser/chromeos/login/wizard_controller.cc b/chrome/browser/chromeos/login/wizard_controller.cc index 1f9db18..d04aae1 100644 --- a/chrome/browser/chromeos/login/wizard_controller.cc +++ b/chrome/browser/chromeos/login/wizard_controller.cc @@ -436,14 +436,24 @@ void WizardController::SkipRegistration() { // static void WizardController::RegisterPrefs(PrefService* local_state) { - local_state->RegisterBooleanPref(kOobeComplete, false); - local_state->RegisterIntegerPref(kDeviceRegistered, -1); - local_state->RegisterBooleanPref(kEulaAccepted, false); - local_state->RegisterStringPref(kInitialLocale, "en-US"); + local_state->RegisterBooleanPref(kOobeComplete, + false, + PrefService::UNSYNCABLE_PREF); + local_state->RegisterIntegerPref(kDeviceRegistered, + -1, + PrefService::UNSYNCABLE_PREF); + local_state->RegisterBooleanPref(kEulaAccepted, + false, + PrefService::UNSYNCABLE_PREF); + local_state->RegisterStringPref(kInitialLocale, + "en-US", + PrefService::UNSYNCABLE_PREF); // Check if the pref is already registered in case // Preferences::RegisterUserPrefs runs before this code in the future. if (local_state->FindPreference(prefs::kAccessibilityEnabled) == NULL) { - local_state->RegisterBooleanPref(prefs::kAccessibilityEnabled, false); + local_state->RegisterBooleanPref(prefs::kAccessibilityEnabled, + false, + PrefService::UNSYNCABLE_PREF); } } diff --git a/chrome/browser/chromeos/preferences.cc b/chrome/browser/chromeos/preferences.cc index 5dbb173..8e040c0 100644 --- a/chrome/browser/chromeos/preferences.cc +++ b/chrome/browser/chromeos/preferences.cc @@ -33,109 +33,154 @@ Preferences::~Preferences() {} // static void Preferences::RegisterUserPrefs(PrefService* prefs) { - prefs->RegisterBooleanPref(prefs::kTapToClickEnabled, false); - prefs->RegisterBooleanPref(prefs::kLabsMediaplayerEnabled, false); - prefs->RegisterBooleanPref(prefs::kLabsAdvancedFilesystemEnabled, false); + prefs->RegisterBooleanPref(prefs::kTapToClickEnabled, + false, + PrefService::SYNCABLE_PREF); + prefs->RegisterBooleanPref(prefs::kLabsMediaplayerEnabled, + false, + PrefService::UNSYNCABLE_PREF); + prefs->RegisterBooleanPref(prefs::kLabsAdvancedFilesystemEnabled, + false, + PrefService::UNSYNCABLE_PREF); // Check if the accessibility pref is already registered, which can happen // in WizardController::RegisterPrefs. We still want to try to register // the pref here in case of Chrome/Linux with ChromeOS=1. if (prefs->FindPreference(prefs::kAccessibilityEnabled) == NULL) { - prefs->RegisterBooleanPref(prefs::kAccessibilityEnabled, false); + prefs->RegisterBooleanPref(prefs::kAccessibilityEnabled, + false, + PrefService::UNSYNCABLE_PREF); } - prefs->RegisterIntegerPref(prefs::kTouchpadSensitivity, 3); - // Set the default based on the hour clock type of the current locale. + prefs->RegisterIntegerPref(prefs::kTouchpadSensitivity, + 3, + PrefService::UNSYNCABLE_PREF); prefs->RegisterBooleanPref(prefs::kUse24HourClock, - base::GetHourClockType() == base::k24HourClock); - prefs->RegisterStringPref(prefs::kLanguageCurrentInputMethod, ""); - prefs->RegisterStringPref(prefs::kLanguagePreviousInputMethod, ""); + base::GetHourClockType() == base::k24HourClock, + PrefService::SYNCABLE_PREF); + prefs->RegisterStringPref(prefs::kLanguageCurrentInputMethod, + "", + PrefService::UNSYNCABLE_PREF); + prefs->RegisterStringPref(prefs::kLanguagePreviousInputMethod, + "", + PrefService::UNSYNCABLE_PREF); prefs->RegisterStringPref(prefs::kLanguageHotkeyNextEngineInMenu, - language_prefs::kHotkeyNextEngineInMenu); + language_prefs::kHotkeyNextEngineInMenu, + PrefService::UNSYNCABLE_PREF); prefs->RegisterStringPref(prefs::kLanguageHotkeyPreviousEngine, - language_prefs::kHotkeyPreviousEngine); + language_prefs::kHotkeyPreviousEngine, + PrefService::UNSYNCABLE_PREF); prefs->RegisterStringPref(prefs::kLanguagePreferredLanguages, - kFallbackInputMethodLocale); - prefs->RegisterStringPref( - prefs::kLanguagePreloadEngines, - input_method::GetHardwareInputMethodId()); + kFallbackInputMethodLocale, + PrefService::SYNCABLE_PREF); + prefs->RegisterStringPref(prefs::kLanguagePreloadEngines, + input_method::GetHardwareInputMethodId(), + PrefService::SYNCABLE_PREF); for (size_t i = 0; i < language_prefs::kNumChewingBooleanPrefs; ++i) { prefs->RegisterBooleanPref( language_prefs::kChewingBooleanPrefs[i].pref_name, - language_prefs::kChewingBooleanPrefs[i].default_pref_value); + language_prefs::kChewingBooleanPrefs[i].default_pref_value, + PrefService::UNSYNCABLE_PREF); } for (size_t i = 0; i < language_prefs::kNumChewingMultipleChoicePrefs; ++i) { prefs->RegisterStringPref( language_prefs::kChewingMultipleChoicePrefs[i].pref_name, - language_prefs::kChewingMultipleChoicePrefs[i].default_pref_value); + language_prefs::kChewingMultipleChoicePrefs[i].default_pref_value, + PrefService::UNSYNCABLE_PREF); } prefs->RegisterIntegerPref( language_prefs::kChewingHsuSelKeyType.pref_name, - language_prefs::kChewingHsuSelKeyType.default_pref_value); + language_prefs::kChewingHsuSelKeyType.default_pref_value, + PrefService::UNSYNCABLE_PREF); for (size_t i = 0; i < language_prefs::kNumChewingIntegerPrefs; ++i) { prefs->RegisterIntegerPref( language_prefs::kChewingIntegerPrefs[i].pref_name, - language_prefs::kChewingIntegerPrefs[i].default_pref_value); + language_prefs::kChewingIntegerPrefs[i].default_pref_value, + PrefService::UNSYNCABLE_PREF); } prefs->RegisterStringPref( prefs::kLanguageHangulKeyboard, - language_prefs::kHangulKeyboardNameIDPairs[0].keyboard_id); + language_prefs::kHangulKeyboardNameIDPairs[0].keyboard_id, + PrefService::SYNCABLE_PREF); prefs->RegisterStringPref(prefs::kLanguageHangulHanjaKeys, - language_prefs::kHangulHanjaKeys); + language_prefs::kHangulHanjaKeys, + PrefService::UNSYNCABLE_PREF); for (size_t i = 0; i < language_prefs::kNumPinyinBooleanPrefs; ++i) { prefs->RegisterBooleanPref( language_prefs::kPinyinBooleanPrefs[i].pref_name, - language_prefs::kPinyinBooleanPrefs[i].default_pref_value); + language_prefs::kPinyinBooleanPrefs[i].default_pref_value, + PrefService::UNSYNCABLE_PREF); } for (size_t i = 0; i < language_prefs::kNumPinyinIntegerPrefs; ++i) { prefs->RegisterIntegerPref( language_prefs::kPinyinIntegerPrefs[i].pref_name, - language_prefs::kPinyinIntegerPrefs[i].default_pref_value); + language_prefs::kPinyinIntegerPrefs[i].default_pref_value, + PrefService::UNSYNCABLE_PREF); } prefs->RegisterIntegerPref( language_prefs::kPinyinDoublePinyinSchema.pref_name, - language_prefs::kPinyinDoublePinyinSchema.default_pref_value); + language_prefs::kPinyinDoublePinyinSchema.default_pref_value, + PrefService::UNSYNCABLE_PREF); for (size_t i = 0; i < language_prefs::kNumMozcBooleanPrefs; ++i) { prefs->RegisterBooleanPref( language_prefs::kMozcBooleanPrefs[i].pref_name, - language_prefs::kMozcBooleanPrefs[i].default_pref_value); + language_prefs::kMozcBooleanPrefs[i].default_pref_value, + PrefService::UNSYNCABLE_PREF); } for (size_t i = 0; i < language_prefs::kNumMozcMultipleChoicePrefs; ++i) { prefs->RegisterStringPref( language_prefs::kMozcMultipleChoicePrefs[i].pref_name, - language_prefs::kMozcMultipleChoicePrefs[i].default_pref_value); + language_prefs::kMozcMultipleChoicePrefs[i].default_pref_value, + PrefService::UNSYNCABLE_PREF); } for (size_t i = 0; i < language_prefs::kNumMozcIntegerPrefs; ++i) { prefs->RegisterIntegerPref( language_prefs::kMozcIntegerPrefs[i].pref_name, - language_prefs::kMozcIntegerPrefs[i].default_pref_value); + language_prefs::kMozcIntegerPrefs[i].default_pref_value, + PrefService::UNSYNCABLE_PREF); } prefs->RegisterIntegerPref(prefs::kLanguageXkbRemapSearchKeyTo, - input_method::kSearchKey); + input_method::kSearchKey, + PrefService::SYNCABLE_PREF); prefs->RegisterIntegerPref(prefs::kLanguageXkbRemapControlKeyTo, - input_method::kLeftControlKey); + input_method::kLeftControlKey, + PrefService::SYNCABLE_PREF); prefs->RegisterIntegerPref(prefs::kLanguageXkbRemapAltKeyTo, - input_method::kLeftAltKey); - prefs->RegisterBooleanPref(prefs::kLanguageXkbAutoRepeatEnabled, true); + input_method::kLeftAltKey, + PrefService::SYNCABLE_PREF); + prefs->RegisterBooleanPref(prefs::kLanguageXkbAutoRepeatEnabled, + true, + PrefService::UNSYNCABLE_PREF); prefs->RegisterIntegerPref(prefs::kLanguageXkbAutoRepeatDelay, - language_prefs::kXkbAutoRepeatDelayInMs); + language_prefs::kXkbAutoRepeatDelayInMs, + PrefService::UNSYNCABLE_PREF); prefs->RegisterIntegerPref(prefs::kLanguageXkbAutoRepeatInterval, - language_prefs::kXkbAutoRepeatIntervalInMs); + language_prefs::kXkbAutoRepeatIntervalInMs, + PrefService::UNSYNCABLE_PREF); // Screen lock default to off. - prefs->RegisterBooleanPref(prefs::kEnableScreenLock, false); + prefs->RegisterBooleanPref(prefs::kEnableScreenLock, + false, + PrefService::SYNCABLE_PREF); // Mobile plan notifications default to on. - prefs->RegisterBooleanPref(prefs::kShowPlanNotifications, true); + prefs->RegisterBooleanPref(prefs::kShowPlanNotifications, + true, + PrefService::SYNCABLE_PREF); // 3G first-time usage promo will be shown at least once. - prefs->RegisterBooleanPref(prefs::kShow3gPromoNotification, true); + prefs->RegisterBooleanPref(prefs::kShow3gPromoNotification, + true, + PrefService::UNSYNCABLE_PREF); // Carrier deal notification shown count defaults to 0. - prefs->RegisterIntegerPref(prefs::kCarrierDealPromoShown, 0); + prefs->RegisterIntegerPref(prefs::kCarrierDealPromoShown, + 0, + PrefService::UNSYNCABLE_PREF); // The map of timestamps of the last used file browser handlers. - prefs->RegisterDictionaryPref(prefs::kLastUsedFileBrowserHandlers); + prefs->RegisterDictionaryPref(prefs::kLastUsedFileBrowserHandlers, + PrefService::UNSYNCABLE_PREF); } void Preferences::Init(PrefService* prefs) { diff --git a/chrome/browser/chromeos/status/input_method_menu.cc b/chrome/browser/chromeos/status/input_method_menu.cc index 71d1e64..9594b4f 100644 --- a/chrome/browser/chromeos/status/input_method_menu.cc +++ b/chrome/browser/chromeos/status/input_method_menu.cc @@ -644,7 +644,9 @@ std::wstring InputMethodMenu::GetTextForMenu( } void InputMethodMenu::RegisterPrefs(PrefService* local_state) { - local_state->RegisterStringPref(language_prefs::kPreferredKeyboardLayout, ""); + local_state->RegisterStringPref(language_prefs::kPreferredKeyboardLayout, + "", + PrefService::UNSYNCABLE_PREF); } void InputMethodMenu::Observe(NotificationType type, diff --git a/chrome/browser/chromeos/user_cros_settings_provider.cc b/chrome/browser/chromeos/user_cros_settings_provider.cc index 8286428..f44cb43 100644 --- a/chrome/browser/chromeos/user_cros_settings_provider.cc +++ b/chrome/browser/chromeos/user_cros_settings_provider.cc @@ -77,17 +77,25 @@ bool IsControlledListSetting(const std::string& pref_path) { void RegisterSetting(PrefService* local_state, const std::string& pref_path) { local_state->RegisterBooleanPref((pref_path + kTrustedSuffix).c_str(), - false); + false, + PrefService::UNSYNCABLE_PREF); if (IsControlledBooleanSetting(pref_path)) { if (pref_path == kSignedDataRoamingEnabled) - local_state->RegisterBooleanPref(pref_path.c_str(), false); + local_state->RegisterBooleanPref(pref_path.c_str(), + false, + PrefService::UNSYNCABLE_PREF); else - local_state->RegisterBooleanPref(pref_path.c_str(), true); + local_state->RegisterBooleanPref(pref_path.c_str(), + true, + PrefService::UNSYNCABLE_PREF); } else if (IsControlledStringSetting(pref_path)) { - local_state->RegisterStringPref(pref_path.c_str(), ""); + local_state->RegisterStringPref(pref_path.c_str(), + "", + PrefService::UNSYNCABLE_PREF); } else { DCHECK(IsControlledListSetting(pref_path)); - local_state->RegisterListPref(pref_path.c_str()); + local_state->RegisterListPref(pref_path.c_str(), + PrefService::UNSYNCABLE_PREF); } } diff --git a/chrome/browser/content_settings/content_settings_notification_provider.cc b/chrome/browser/content_settings/content_settings_notification_provider.cc index 835bb14..fe3554c 100644 --- a/chrome/browser/content_settings/content_settings_notification_provider.cc +++ b/chrome/browser/content_settings/content_settings_notification_provider.cc @@ -35,9 +35,11 @@ namespace content_settings { // static void NotificationProvider::RegisterUserPrefs(PrefService* user_prefs) { if (!user_prefs->FindPreference(prefs::kDesktopNotificationAllowedOrigins)) - user_prefs->RegisterListPref(prefs::kDesktopNotificationAllowedOrigins); + user_prefs->RegisterListPref(prefs::kDesktopNotificationAllowedOrigins, + PrefService::SYNCABLE_PREF); if (!user_prefs->FindPreference(prefs::kDesktopNotificationDeniedOrigins)) - user_prefs->RegisterListPref(prefs::kDesktopNotificationDeniedOrigins); + user_prefs->RegisterListPref(prefs::kDesktopNotificationDeniedOrigins, + PrefService::SYNCABLE_PREF); } // TODO(markusheintz): Re-factoring in progress. Do not move or touch the diff --git a/chrome/browser/content_settings/content_settings_policy_provider.cc b/chrome/browser/content_settings/content_settings_policy_provider.cc index d80da5d..0855c2d 100644 --- a/chrome/browser/content_settings/content_settings_policy_provider.cc +++ b/chrome/browser/content_settings/content_settings_policy_provider.cc @@ -241,15 +241,20 @@ void PolicyDefaultProvider::RegisterUserPrefs(PrefService* prefs) { // Preferences for default content setting policies. A policy is not set of // the corresponding preferences below is set to CONTENT_SETTING_DEFAULT. prefs->RegisterIntegerPref(prefs::kManagedDefaultCookiesSetting, - CONTENT_SETTING_DEFAULT); + CONTENT_SETTING_DEFAULT, + PrefService::UNSYNCABLE_PREF); prefs->RegisterIntegerPref(prefs::kManagedDefaultImagesSetting, - CONTENT_SETTING_DEFAULT); + CONTENT_SETTING_DEFAULT, + PrefService::UNSYNCABLE_PREF); prefs->RegisterIntegerPref(prefs::kManagedDefaultJavaScriptSetting, - CONTENT_SETTING_DEFAULT); + CONTENT_SETTING_DEFAULT, + PrefService::UNSYNCABLE_PREF); prefs->RegisterIntegerPref(prefs::kManagedDefaultPluginsSetting, - CONTENT_SETTING_DEFAULT); + CONTENT_SETTING_DEFAULT, + PrefService::UNSYNCABLE_PREF); prefs->RegisterIntegerPref(prefs::kManagedDefaultPopupsSetting, - CONTENT_SETTING_DEFAULT); + CONTENT_SETTING_DEFAULT, + PrefService::UNSYNCABLE_PREF); } // //////////////////////////////////////////////////////////////////////////// @@ -257,17 +262,28 @@ void PolicyDefaultProvider::RegisterUserPrefs(PrefService* prefs) { // static void PolicyProvider::RegisterUserPrefs(PrefService* prefs) { - prefs->RegisterListPref(prefs::kManagedCookiesAllowedForUrls); - prefs->RegisterListPref(prefs::kManagedCookiesBlockedForUrls); - prefs->RegisterListPref(prefs::kManagedCookiesSessionOnlyForUrls); - prefs->RegisterListPref(prefs::kManagedImagesAllowedForUrls); - prefs->RegisterListPref(prefs::kManagedImagesBlockedForUrls); - prefs->RegisterListPref(prefs::kManagedJavaScriptAllowedForUrls); - prefs->RegisterListPref(prefs::kManagedJavaScriptBlockedForUrls); - prefs->RegisterListPref(prefs::kManagedPluginsAllowedForUrls); - prefs->RegisterListPref(prefs::kManagedPluginsBlockedForUrls); - prefs->RegisterListPref(prefs::kManagedPopupsAllowedForUrls); - prefs->RegisterListPref(prefs::kManagedPopupsBlockedForUrls); + prefs->RegisterListPref(prefs::kManagedCookiesAllowedForUrls, + PrefService::UNSYNCABLE_PREF); + prefs->RegisterListPref(prefs::kManagedCookiesBlockedForUrls, + PrefService::UNSYNCABLE_PREF); + prefs->RegisterListPref(prefs::kManagedCookiesSessionOnlyForUrls, + PrefService::UNSYNCABLE_PREF); + prefs->RegisterListPref(prefs::kManagedImagesAllowedForUrls, + PrefService::UNSYNCABLE_PREF); + prefs->RegisterListPref(prefs::kManagedImagesBlockedForUrls, + PrefService::UNSYNCABLE_PREF); + prefs->RegisterListPref(prefs::kManagedJavaScriptAllowedForUrls, + PrefService::UNSYNCABLE_PREF); + prefs->RegisterListPref(prefs::kManagedJavaScriptBlockedForUrls, + PrefService::UNSYNCABLE_PREF); + prefs->RegisterListPref(prefs::kManagedPluginsAllowedForUrls, + PrefService::UNSYNCABLE_PREF); + prefs->RegisterListPref(prefs::kManagedPluginsBlockedForUrls, + PrefService::UNSYNCABLE_PREF); + prefs->RegisterListPref(prefs::kManagedPopupsAllowedForUrls, + PrefService::UNSYNCABLE_PREF); + prefs->RegisterListPref(prefs::kManagedPopupsBlockedForUrls, + PrefService::UNSYNCABLE_PREF); } PolicyProvider::PolicyProvider(Profile* profile) diff --git a/chrome/browser/content_settings/content_settings_pref_provider.cc b/chrome/browser/content_settings/content_settings_pref_provider.cc index acf4e91..467d502 100644 --- a/chrome/browser/content_settings/content_settings_pref_provider.cc +++ b/chrome/browser/content_settings/content_settings_pref_provider.cc @@ -313,12 +313,14 @@ void PrefDefaultProvider::RegisterUserPrefs(PrefService* prefs) { DictionaryValue* default_content_settings = new DictionaryValue(); SetDefaultContentSettings(default_content_settings); prefs->RegisterDictionaryPref(prefs::kDefaultContentSettings, - default_content_settings); + default_content_settings, + PrefService::SYNCABLE_PREF); // Obsolete prefs, for migrations: prefs->RegisterIntegerPref( prefs::kDesktopNotificationDefaultContentSetting, - kDefaultSettings[CONTENT_SETTINGS_TYPE_NOTIFICATIONS]); + kDefaultSettings[CONTENT_SETTINGS_TYPE_NOTIFICATIONS], + PrefService::SYNCABLE_PREF); } // //////////////////////////////////////////////////////////////////////////// @@ -327,13 +329,18 @@ void PrefDefaultProvider::RegisterUserPrefs(PrefService* prefs) { // static void PrefProvider::RegisterUserPrefs(PrefService* prefs) { - prefs->RegisterIntegerPref(prefs::kContentSettingsVersion, - ContentSettingsPattern::kContentSettingsPatternVersion); - prefs->RegisterDictionaryPref(prefs::kContentSettingsPatterns); + prefs->RegisterIntegerPref( + prefs::kContentSettingsVersion, + ContentSettingsPattern::kContentSettingsPatternVersion, + PrefService::UNSYNCABLE_PREF); + prefs->RegisterDictionaryPref(prefs::kContentSettingsPatterns, + PrefService::SYNCABLE_PREF); // Obsolete prefs, for migration: - prefs->RegisterListPref(prefs::kPopupWhitelistedHosts); - prefs->RegisterDictionaryPref(prefs::kPerHostContentSettings); + prefs->RegisterListPref(prefs::kPopupWhitelistedHosts, + PrefService::UNSYNCABLE_PREF); + prefs->RegisterDictionaryPref(prefs::kPerHostContentSettings, + PrefService::UNSYNCABLE_PREF); } PrefProvider::PrefProvider(Profile* profile) diff --git a/chrome/browser/content_settings/host_content_settings_map.cc b/chrome/browser/content_settings/host_content_settings_map.cc index 09f4f5c..ffc253b0 100644 --- a/chrome/browser/content_settings/host_content_settings_map.cc +++ b/chrome/browser/content_settings/host_content_settings_map.cc @@ -113,13 +113,20 @@ HostContentSettingsMap::HostContentSettingsMap(Profile* profile) // static void HostContentSettingsMap::RegisterUserPrefs(PrefService* prefs) { - prefs->RegisterBooleanPref(prefs::kBlockThirdPartyCookies, false); - prefs->RegisterBooleanPref(prefs::kBlockNonsandboxedPlugins, false); - prefs->RegisterIntegerPref(prefs::kContentSettingsWindowLastTabIndex, 0); + prefs->RegisterBooleanPref(prefs::kBlockThirdPartyCookies, + false, + PrefService::SYNCABLE_PREF); + prefs->RegisterBooleanPref(prefs::kBlockNonsandboxedPlugins, + false, + PrefService::UNSYNCABLE_PREF); + prefs->RegisterIntegerPref(prefs::kContentSettingsWindowLastTabIndex, + 0, + PrefService::UNSYNCABLE_PREF); // Obsolete prefs, for migration: prefs->RegisterIntegerPref(prefs::kCookieBehavior, - net::StaticCookiePolicy::ALLOW_ALL_COOKIES); + net::StaticCookiePolicy::ALLOW_ALL_COOKIES, + PrefService::UNSYNCABLE_PREF); // Register the prefs for the content settings providers. content_settings::PrefDefaultProvider::RegisterUserPrefs(prefs); diff --git a/chrome/browser/custom_handlers/protocol_handler_registry.cc b/chrome/browser/custom_handlers/protocol_handler_registry.cc index f2ea2f6..7edb280 100644 --- a/chrome/browser/custom_handlers/protocol_handler_registry.cc +++ b/chrome/browser/custom_handlers/protocol_handler_registry.cc @@ -274,9 +274,12 @@ void ProtocolHandlerRegistry::OnIgnoreRegisterProtocolHandler( } void ProtocolHandlerRegistry::RegisterPrefs(PrefService* prefService) { - prefService->RegisterListPref(prefs::kRegisteredProtocolHandlers); - prefService->RegisterListPref(prefs::kIgnoredProtocolHandlers); - prefService->RegisterBooleanPref(prefs::kCustomHandlersEnabled, true); + prefService->RegisterListPref(prefs::kRegisteredProtocolHandlers, + PrefService::UNSYNCABLE_PREF); + prefService->RegisterListPref(prefs::kIgnoredProtocolHandlers, + PrefService::UNSYNCABLE_PREF); + prefService->RegisterBooleanPref(prefs::kCustomHandlersEnabled, true, + PrefService::UNSYNCABLE_PREF); } void ProtocolHandlerRegistry::SetDefault(const ProtocolHandler& handler) { diff --git a/chrome/browser/debugger/devtools_manager.cc b/chrome/browser/debugger/devtools_manager.cc index 61dec4b..34e935d 100644 --- a/chrome/browser/debugger/devtools_manager.cc +++ b/chrome/browser/debugger/devtools_manager.cc @@ -36,7 +36,9 @@ DevToolsManager* DevToolsManager::GetInstance() { // static void DevToolsManager::RegisterUserPrefs(PrefService* prefs) { - prefs->RegisterBooleanPref(prefs::kDevToolsOpenDocked, true); + prefs->RegisterBooleanPref(prefs::kDevToolsOpenDocked, + true, + PrefService::UNSYNCABLE_PREF); } DevToolsManager::DevToolsManager() diff --git a/chrome/browser/debugger/devtools_window.cc b/chrome/browser/debugger/devtools_window.cc index 8145ff7..f824768 100644 --- a/chrome/browser/debugger/devtools_window.cc +++ b/chrome/browser/debugger/devtools_window.cc @@ -226,7 +226,7 @@ void DevToolsWindow::CreateDevToolsBrowser() { PrefService* prefs = profile_->GetPrefs(); if (!prefs->FindPreference(wp_key.c_str())) { - prefs->RegisterDictionaryPref(wp_key.c_str()); + prefs->RegisterDictionaryPref(wp_key.c_str(), PrefService::UNSYNCABLE_PREF); } const DictionaryValue* wp_pref = prefs->GetDictionary(wp_key.c_str()); diff --git a/chrome/browser/download/download_prefs.cc b/chrome/browser/download/download_prefs.cc index 6d1cd67..d55db9a 100644 --- a/chrome/browser/download/download_prefs.cc +++ b/chrome/browser/download/download_prefs.cc @@ -46,17 +46,25 @@ DownloadPrefs::~DownloadPrefs() { // static void DownloadPrefs::RegisterUserPrefs(PrefService* prefs) { - prefs->RegisterBooleanPref(prefs::kPromptForDownload, false); - prefs->RegisterStringPref(prefs::kDownloadExtensionsToOpen, ""); - prefs->RegisterBooleanPref(prefs::kDownloadDirUpgraded, false); + prefs->RegisterBooleanPref(prefs::kPromptForDownload, + false, + PrefService::SYNCABLE_PREF); + prefs->RegisterStringPref(prefs::kDownloadExtensionsToOpen, + "", + PrefService::UNSYNCABLE_PREF); + prefs->RegisterBooleanPref(prefs::kDownloadDirUpgraded, + false, + PrefService::UNSYNCABLE_PREF); prefs->RegisterIntegerPref(prefs::kSaveFileType, - SavePackage::SAVE_AS_COMPLETE_HTML); + SavePackage::SAVE_AS_COMPLETE_HTML, + PrefService::UNSYNCABLE_PREF); // The default download path is userprofile\download. const FilePath& default_download_path = download_util::GetDefaultDownloadDirectory(); prefs->RegisterFilePathPref(prefs::kDownloadDefaultDirectory, - default_download_path); + default_download_path, + PrefService::UNSYNCABLE_PREF); #if defined(OS_CHROMEOS) // Ensure that the download directory specified in the preferences exists. diff --git a/chrome/browser/extensions/apps_promo.cc b/chrome/browser/extensions/apps_promo.cc index efbcecd..8c43af9 100644 --- a/chrome/browser/extensions/apps_promo.cc +++ b/chrome/browser/extensions/apps_promo.cc @@ -29,10 +29,15 @@ void AppsPromo::RegisterPrefs(PrefService* local_state) { void AppsPromo::RegisterUserPrefs(PrefService* prefs) { // Set the default value for the counter to max+1 since we don't install // default apps for new users. - prefs->RegisterIntegerPref( - prefs::kAppsPromoCounter, kDefaultAppsCounterMax + 1); - prefs->RegisterBooleanPref(prefs::kDefaultAppsInstalled, false); - prefs->RegisterStringPref(prefs::kNTPWebStorePromoLastId, std::string()); + prefs->RegisterIntegerPref(prefs::kAppsPromoCounter, + kDefaultAppsCounterMax + 1, + PrefService::UNSYNCABLE_PREF); + prefs->RegisterBooleanPref(prefs::kDefaultAppsInstalled, + false, + PrefService::UNSYNCABLE_PREF); + prefs->RegisterStringPref(prefs::kNTPWebStorePromoLastId, + std::string(), + PrefService::UNSYNCABLE_PREF); } // static diff --git a/chrome/browser/extensions/extension_prefs.cc b/chrome/browser/extensions/extension_prefs.cc index b77181f..e6c9395 100644 --- a/chrome/browser/extensions/extension_prefs.cc +++ b/chrome/browser/extensions/extension_prefs.cc @@ -1544,12 +1544,20 @@ bool ExtensionPrefs::HasIncognitoPrefValue(const std::string& pref_key) { // static void ExtensionPrefs::RegisterUserPrefs(PrefService* prefs) { - prefs->RegisterDictionaryPref(kExtensionsPref); - prefs->RegisterListPref(kExtensionToolbar); - prefs->RegisterIntegerPref(prefs::kExtensionToolbarSize, -1); - prefs->RegisterDictionaryPref(kExtensionsBlacklistUpdate); - prefs->RegisterListPref(prefs::kExtensionInstallAllowList); - prefs->RegisterListPref(prefs::kExtensionInstallDenyList); - prefs->RegisterListPref(prefs::kExtensionInstallForceList); - prefs->RegisterStringPref(kWebStoreLogin, std::string() /* default_value */); + prefs->RegisterDictionaryPref(kExtensionsPref, PrefService::UNSYNCABLE_PREF); + prefs->RegisterListPref(kExtensionToolbar, PrefService::UNSYNCABLE_PREF); + prefs->RegisterIntegerPref(prefs::kExtensionToolbarSize, + -1, + PrefService::UNSYNCABLE_PREF); + prefs->RegisterDictionaryPref(kExtensionsBlacklistUpdate, + PrefService::UNSYNCABLE_PREF); + prefs->RegisterListPref(prefs::kExtensionInstallAllowList, + PrefService::UNSYNCABLE_PREF); + prefs->RegisterListPref(prefs::kExtensionInstallDenyList, + PrefService::UNSYNCABLE_PREF); + prefs->RegisterListPref(prefs::kExtensionInstallForceList, + PrefService::UNSYNCABLE_PREF); + prefs->RegisterStringPref(kWebStoreLogin, + std::string() /* default_value */, + PrefService::UNSYNCABLE_PREF); } diff --git a/chrome/browser/extensions/extension_prefs_unittest.cc b/chrome/browser/extensions/extension_prefs_unittest.cc index 866b52f..bf7f0a2 100644 --- a/chrome/browser/extensions/extension_prefs_unittest.cc +++ b/chrome/browser/extensions/extension_prefs_unittest.cc @@ -678,10 +678,18 @@ class ExtensionPrefsPreferencesBase : public ExtensionPrefsTest { } void RegisterPreferences() { - prefs()->pref_service()->RegisterStringPref(kPref1, kDefaultPref1); - prefs()->pref_service()->RegisterStringPref(kPref2, kDefaultPref2); - prefs()->pref_service()->RegisterStringPref(kPref3, kDefaultPref3); - prefs()->pref_service()->RegisterStringPref(kPref4, kDefaultPref4); + prefs()->pref_service()->RegisterStringPref(kPref1, + kDefaultPref1, + PrefService::UNSYNCABLE_PREF); + prefs()->pref_service()->RegisterStringPref(kPref2, + kDefaultPref2, + PrefService::UNSYNCABLE_PREF); + prefs()->pref_service()->RegisterStringPref(kPref3, + kDefaultPref3, + PrefService::UNSYNCABLE_PREF); + prefs()->pref_service()->RegisterStringPref(kPref4, + kDefaultPref4, + PrefService::UNSYNCABLE_PREF); } void InstallExtControlledPref(Extension *ext, diff --git a/chrome/browser/extensions/extension_updater.cc b/chrome/browser/extensions/extension_updater.cc index 57adabd..a340755 100644 --- a/chrome/browser/extensions/extension_updater.cc +++ b/chrome/browser/extensions/extension_updater.cc @@ -499,12 +499,15 @@ ExtensionUpdater::~ExtensionUpdater() { static void EnsureInt64PrefRegistered(PrefService* prefs, const char name[]) { if (!prefs->FindPreference(name)) - prefs->RegisterInt64Pref(name, 0); + prefs->RegisterInt64Pref(name, 0, PrefService::UNSYNCABLE_PREF); } static void EnsureBlacklistVersionPrefRegistered(PrefService* prefs) { - if (!prefs->FindPreference(kExtensionBlacklistUpdateVersion)) - prefs->RegisterStringPref(kExtensionBlacklistUpdateVersion, "0"); + if (!prefs->FindPreference(kExtensionBlacklistUpdateVersion)) { + prefs->RegisterStringPref(kExtensionBlacklistUpdateVersion, + "0", + PrefService::UNSYNCABLE_PREF); + } } // The overall goal here is to balance keeping clients up to date while diff --git a/chrome/browser/extensions/extension_web_ui.cc b/chrome/browser/extensions/extension_web_ui.cc index 6c7e0d8..e398c46 100644 --- a/chrome/browser/extensions/extension_web_ui.cc +++ b/chrome/browser/extensions/extension_web_ui.cc @@ -240,7 +240,8 @@ gfx::NativeView ExtensionWebUI::GetNativeViewOfHost() { // static void ExtensionWebUI::RegisterUserPrefs(PrefService* prefs) { - prefs->RegisterDictionaryPref(kExtensionURLOverrides); + prefs->RegisterDictionaryPref(kExtensionURLOverrides, + PrefService::UNSYNCABLE_PREF); } // static diff --git a/chrome/browser/extensions/extensions_ui.cc b/chrome/browser/extensions/extensions_ui.cc index 5b1fe2b..8022dc4 100644 --- a/chrome/browser/extensions/extensions_ui.cc +++ b/chrome/browser/extensions/extensions_ui.cc @@ -839,5 +839,7 @@ RefCountedMemory* ExtensionsUI::GetFaviconResourceBytes() { // static void ExtensionsUI::RegisterUserPrefs(PrefService* prefs) { - prefs->RegisterBooleanPref(prefs::kExtensionsUIDeveloperMode, false); + prefs->RegisterBooleanPref(prefs::kExtensionsUIDeveloperMode, + false, + PrefService::SYNCABLE_PREF); } diff --git a/chrome/browser/first_run/first_run.cc b/chrome/browser/first_run/first_run.cc index a7390ec..24ff8e9 100644 --- a/chrome/browser/first_run/first_run.cc +++ b/chrome/browser/first_run/first_run.cc @@ -409,8 +409,7 @@ bool FirstRun::SetOEMFirstRunBubblePref() { if (!local_state) return false; if (!local_state->FindPreference(prefs::kShouldUseOEMFirstRunBubble)) { - local_state->RegisterBooleanPref(prefs::kShouldUseOEMFirstRunBubble, - false); + local_state->RegisterBooleanPref(prefs::kShouldUseOEMFirstRunBubble, false); local_state->SetBoolean(prefs::kShouldUseOEMFirstRunBubble, true); } return true; diff --git a/chrome/browser/geolocation/geolocation_content_settings_map.cc b/chrome/browser/geolocation/geolocation_content_settings_map.cc index 5239bf2..daee1bd 100644 --- a/chrome/browser/geolocation/geolocation_content_settings_map.cc +++ b/chrome/browser/geolocation/geolocation_content_settings_map.cc @@ -50,8 +50,10 @@ GeolocationContentSettingsMap::GeolocationContentSettingsMap(Profile* profile) // static void GeolocationContentSettingsMap::RegisterUserPrefs(PrefService* prefs) { prefs->RegisterIntegerPref(prefs::kGeolocationDefaultContentSetting, - CONTENT_SETTING_ASK); - prefs->RegisterDictionaryPref(prefs::kGeolocationContentSettings); + CONTENT_SETTING_ASK, + PrefService::SYNCABLE_PREF); + prefs->RegisterDictionaryPref(prefs::kGeolocationContentSettings, + PrefService::SYNCABLE_PREF); } ContentSetting GeolocationContentSettingsMap::GetDefaultContentSetting() const { diff --git a/chrome/browser/instant/instant_controller.cc b/chrome/browser/instant/instant_controller.cc index 35fbb31..d063092 100644 --- a/chrome/browser/instant/instant_controller.cc +++ b/chrome/browser/instant/instant_controller.cc @@ -58,10 +58,18 @@ InstantController::~InstantController() { // static void InstantController::RegisterUserPrefs(PrefService* prefs) { - prefs->RegisterBooleanPref(prefs::kInstantConfirmDialogShown, false); - prefs->RegisterBooleanPref(prefs::kInstantEnabled, false); - prefs->RegisterBooleanPref(prefs::kInstantEnabledOnce, false); - prefs->RegisterInt64Pref(prefs::kInstantEnabledTime, false); + prefs->RegisterBooleanPref(prefs::kInstantConfirmDialogShown, + false, + PrefService::UNSYNCABLE_PREF); + prefs->RegisterBooleanPref(prefs::kInstantEnabled, + false, + PrefService::UNSYNCABLE_PREF); + prefs->RegisterBooleanPref(prefs::kInstantEnabledOnce, + false, + PrefService::UNSYNCABLE_PREF); + prefs->RegisterInt64Pref(prefs::kInstantEnabledTime, + false, + PrefService::UNSYNCABLE_PREF); PromoCounter::RegisterUserPrefs(prefs, prefs::kInstantPromo); } diff --git a/chrome/browser/instant/promo_counter.cc b/chrome/browser/instant/promo_counter.cc index 91df78e..52e1afc 100644 --- a/chrome/browser/instant/promo_counter.cc +++ b/chrome/browser/instant/promo_counter.cc @@ -1,4 +1,4 @@ -// Copyright (c) 2010 The Chromium Authors. All rights reserved. +// Copyright (c) 2011 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. @@ -39,9 +39,15 @@ PromoCounter::~PromoCounter() { // static void PromoCounter::RegisterUserPrefs(PrefService* prefs, const std::string& base_key) { - prefs->RegisterBooleanPref((base_key + kShowKey).c_str(), true); - prefs->RegisterIntegerPref((base_key + kNumSessionsKey).c_str(), 0); - prefs->RegisterInt64Pref((base_key + kInitialTimeKey).c_str(), 0); + prefs->RegisterBooleanPref((base_key + kShowKey).c_str(), + true, + PrefService::UNSYNCABLE_PREF); + prefs->RegisterIntegerPref((base_key + kNumSessionsKey).c_str(), + 0, + PrefService::UNSYNCABLE_PREF); + prefs->RegisterInt64Pref((base_key + kInitialTimeKey).c_str(), + 0, + PrefService::UNSYNCABLE_PREF); } bool PromoCounter::ShouldShow(base::Time current_time) { diff --git a/chrome/browser/net/net_pref_observer.cc b/chrome/browser/net/net_pref_observer.cc index 597af94..b125dae 100644 --- a/chrome/browser/net/net_pref_observer.cc +++ b/chrome/browser/net/net_pref_observer.cc @@ -71,7 +71,13 @@ void NetPrefObserver::ApplySettings(const std::string* pref_name) { // static void NetPrefObserver::RegisterPrefs(PrefService* prefs) { - prefs->RegisterBooleanPref(prefs::kNetworkPredictionEnabled, true); - prefs->RegisterBooleanPref(prefs::kDisableSpdy, false); - prefs->RegisterBooleanPref(prefs::kHttpThrottlingEnabled, false); + prefs->RegisterBooleanPref(prefs::kNetworkPredictionEnabled, + true, + PrefService::SYNCABLE_PREF); + prefs->RegisterBooleanPref(prefs::kDisableSpdy, + false, + PrefService::UNSYNCABLE_PREF); + prefs->RegisterBooleanPref(prefs::kHttpThrottlingEnabled, + false, + PrefService::UNSYNCABLE_PREF); } diff --git a/chrome/browser/net/predictor_api.cc b/chrome/browser/net/predictor_api.cc index 5cdf5c9..9f80f28 100644 --- a/chrome/browser/net/predictor_api.cc +++ b/chrome/browser/net/predictor_api.cc @@ -145,8 +145,10 @@ void DiscardInitialNavigationHistory() { } void RegisterUserPrefs(PrefService* user_prefs) { - user_prefs->RegisterListPref(prefs::kDnsPrefetchingStartupList); - user_prefs->RegisterListPref(prefs::kDnsPrefetchingHostReferralList); + user_prefs->RegisterListPref(prefs::kDnsPrefetchingStartupList, + PrefService::UNSYNCABLE_PREF); + user_prefs->RegisterListPref(prefs::kDnsPrefetchingHostReferralList, + PrefService::UNSYNCABLE_PREF); } // When enabled, we use the following instance to service all requests in the @@ -414,8 +416,10 @@ static void InitNetworkPredictor(TimeDelta max_dns_queue_delay, int current_version = local_state->GetInteger(prefs::kMultipleProfilePrefMigration); if ((current_version & browser::DNS_PREFS) == 0) { - local_state->RegisterListPref(prefs::kDnsStartupPrefetchList); - local_state->RegisterListPref(prefs::kDnsHostReferralList); + local_state->RegisterListPref(prefs::kDnsStartupPrefetchList, + PrefService::UNSYNCABLE_PREF); + local_state->RegisterListPref(prefs::kDnsHostReferralList, + PrefService::UNSYNCABLE_PREF); local_state->ClearPref(prefs::kDnsStartupPrefetchList); local_state->ClearPref(prefs::kDnsHostReferralList); local_state->SetInteger(prefs::kMultipleProfilePrefMigration, diff --git a/chrome/browser/net/pref_proxy_config_service.cc b/chrome/browser/net/pref_proxy_config_service.cc index f867923..a07a340 100644 --- a/chrome/browser/net/pref_proxy_config_service.cc +++ b/chrome/browser/net/pref_proxy_config_service.cc @@ -269,5 +269,7 @@ void PrefProxyConfigService::RegisterObservers() { // static void PrefProxyConfigService::RegisterPrefs(PrefService* pref_service) { DictionaryValue* default_settings = ProxyConfigDictionary::CreateSystem(); - pref_service->RegisterDictionaryPref(prefs::kProxy, default_settings); + pref_service->RegisterDictionaryPref(prefs::kProxy, + default_settings, + PrefService::UNSYNCABLE_PREF); } diff --git a/chrome/browser/net/ssl_config_service_manager_pref.cc b/chrome/browser/net/ssl_config_service_manager_pref.cc index 71e385b..54ab554 100644 --- a/chrome/browser/net/ssl_config_service_manager_pref.cc +++ b/chrome/browser/net/ssl_config_service_manager_pref.cc @@ -125,15 +125,18 @@ void SSLConfigServiceManagerPref::RegisterPrefs(PrefService* prefs) { net::SSLConfig default_config; if (!prefs->FindPreference(prefs::kCertRevocationCheckingEnabled)) { prefs->RegisterBooleanPref(prefs::kCertRevocationCheckingEnabled, - default_config.rev_checking_enabled); + default_config.rev_checking_enabled, + PrefService::UNSYNCABLE_PREF); } if (!prefs->FindPreference(prefs::kSSL3Enabled)) { prefs->RegisterBooleanPref(prefs::kSSL3Enabled, - default_config.ssl3_enabled); + default_config.ssl3_enabled, + PrefService::UNSYNCABLE_PREF); } if (!prefs->FindPreference(prefs::kTLS1Enabled)) { prefs->RegisterBooleanPref(prefs::kTLS1Enabled, - default_config.tls1_enabled); + default_config.tls1_enabled, + PrefService::UNSYNCABLE_PREF); } } diff --git a/chrome/browser/password_manager/password_manager.cc b/chrome/browser/password_manager/password_manager.cc index b5dc14c..b08330fd 100644 --- a/chrome/browser/password_manager/password_manager.cc +++ b/chrome/browser/password_manager/password_manager.cc @@ -24,8 +24,12 @@ using webkit_glue::PasswordFormMap; // static void PasswordManager::RegisterUserPrefs(PrefService* prefs) { - prefs->RegisterBooleanPref(prefs::kPasswordManagerEnabled, true); - prefs->RegisterBooleanPref(prefs::kPasswordManagerAllowShowPasswords, true); + prefs->RegisterBooleanPref(prefs::kPasswordManagerEnabled, + true, + PrefService::SYNCABLE_PREF); + prefs->RegisterBooleanPref(prefs::kPasswordManagerAllowShowPasswords, + true, + PrefService::UNSYNCABLE_PREF); } // This routine is called when PasswordManagers are constructed. diff --git a/chrome/browser/password_manager/password_store_default.cc b/chrome/browser/password_manager/password_store_default.cc index d99ba4a..0adf126 100644 --- a/chrome/browser/password_manager/password_store_default.cc +++ b/chrome/browser/password_manager/password_store_default.cc @@ -94,7 +94,8 @@ void PasswordStoreDefault::MigrateHelper::OnWebDataServiceRequestDone( } if (handles_.empty()) { profile_->GetPrefs()->RegisterBooleanPref(prefs::kLoginDatabaseMigrated, - true); + true, + PrefService::UNSYNCABLE_PREF); } } diff --git a/chrome/browser/password_manager/password_store_default_unittest.cc b/chrome/browser/password_manager/password_store_default_unittest.cc index 212de2f..1b6bd8d 100644 --- a/chrome/browser/password_manager/password_store_default_unittest.cc +++ b/chrome/browser/password_manager/password_store_default_unittest.cc @@ -152,7 +152,8 @@ MATCHER(EmptyWDResult, "") { TEST_F(PasswordStoreDefaultTest, NonASCIIData) { // Prentend that the migration has already taken place. profile_->GetPrefs()->RegisterBooleanPref(prefs::kLoginDatabaseMigrated, - true); + true, + PrefService::UNSYNCABLE_PREF); // Initializing the PasswordStore shouldn't trigger a migration. scoped_refptr<PasswordStoreDefault> store( @@ -399,7 +400,8 @@ TEST_F(PasswordStoreDefaultTest, MigrationAlreadyDone) { // Prentend that the migration has already taken place. profile_->GetPrefs()->RegisterBooleanPref(prefs::kLoginDatabaseMigrated, - true); + true, + PrefService::UNSYNCABLE_PREF); // Initializing the PasswordStore shouldn't trigger a migration. scoped_refptr<PasswordStore> store( @@ -430,7 +432,8 @@ TEST_F(PasswordStoreDefaultTest, MigrationAlreadyDone) { TEST_F(PasswordStoreDefaultTest, Notifications) { // Prentend that the migration has already taken place. profile_->GetPrefs()->RegisterBooleanPref(prefs::kLoginDatabaseMigrated, - true); + true, + PrefService::UNSYNCABLE_PREF); // Initializing the PasswordStore shouldn't trigger a migration. scoped_refptr<PasswordStore> store( diff --git a/chrome/browser/password_manager/password_store_win_unittest.cc b/chrome/browser/password_manager/password_store_win_unittest.cc index 6477b12..310b9e2 100644 --- a/chrome/browser/password_manager/password_store_win_unittest.cc +++ b/chrome/browser/password_manager/password_store_win_unittest.cc @@ -169,7 +169,8 @@ TEST_F(PasswordStoreWinTest, DISABLED_ConvertIE7Login) { // Prentend that the migration has already taken place. profile_->GetPrefs()->RegisterBooleanPref(prefs::kLoginDatabaseMigrated, - true); + true, + PrefService::UNSYNCABLE_PREF); // Initializing the PasswordStore shouldn't trigger a migration. scoped_refptr<PasswordStore> store( @@ -228,7 +229,8 @@ TEST_F(PasswordStoreWinTest, DISABLED_ConvertIE7Login) { TEST_F(PasswordStoreWinTest, OutstandingWDSQueries) { // Prentend that the migration has already taken place. profile_->GetPrefs()->RegisterBooleanPref(prefs::kLoginDatabaseMigrated, - true); + true, + PrefService::UNSYNCABLE_PREF); // Initializing the PasswordStore shouldn't trigger a migration. scoped_refptr<PasswordStore> store( @@ -278,7 +280,8 @@ TEST_F(PasswordStoreWinTest, DISABLED_MultipleWDSQueriesOnDifferentThreads) { // Prentend that the migration has already taken place. profile_->GetPrefs()->RegisterBooleanPref(prefs::kLoginDatabaseMigrated, - true); + true, + PrefService::UNSYNCABLE_PREF); // Initializing the PasswordStore shouldn't trigger a migration. scoped_refptr<PasswordStore> store( diff --git a/chrome/browser/password_manager/password_store_x_unittest.cc b/chrome/browser/password_manager/password_store_x_unittest.cc index 721368d..7e6ed72 100644 --- a/chrome/browser/password_manager/password_store_x_unittest.cc +++ b/chrome/browser/password_manager/password_store_x_unittest.cc @@ -475,7 +475,8 @@ TEST_P(PasswordStoreXTest, WDSMigrationAlreadyDone) { // Prentend that the migration has already taken place. profile_->GetPrefs()->RegisterBooleanPref(prefs::kLoginDatabaseMigrated, - true); + true, + PrefService::UNSYNCABLE_PREF); // Initializing the PasswordStore shouldn't trigger a migration. scoped_refptr<PasswordStoreX> store( @@ -508,7 +509,8 @@ TEST_P(PasswordStoreXTest, WDSMigrationAlreadyDone) { TEST_P(PasswordStoreXTest, Notifications) { // Pretend that the migration has already taken place. profile_->GetPrefs()->RegisterBooleanPref(prefs::kLoginDatabaseMigrated, - true); + true, + PrefService::UNSYNCABLE_PREF); // Initializing the PasswordStore shouldn't trigger a migration. scoped_refptr<PasswordStoreX> store( @@ -646,7 +648,8 @@ TEST_P(PasswordStoreXTest, NativeMigration) { // Pretend that the WDS migration has already taken place. profile_->GetPrefs()->RegisterBooleanPref(prefs::kLoginDatabaseMigrated, - true); + true, + PrefService::UNSYNCABLE_PREF); // Initializing the PasswordStore shouldn't trigger a native migration (yet). scoped_refptr<PasswordStoreX> store( diff --git a/chrome/browser/plugin_updater.cc b/chrome/browser/plugin_updater.cc index 95c2c5f..6033c73 100644 --- a/chrome/browser/plugin_updater.cc +++ b/chrome/browser/plugin_updater.cc @@ -339,8 +339,12 @@ void PluginUpdater::RegisterPrefs(PrefService* prefs) { FilePath internal_dir; PathService::Get(chrome::DIR_INTERNAL_PLUGINS, &internal_dir); prefs->RegisterFilePathPref(prefs::kPluginsLastInternalDirectory, - internal_dir); - prefs->RegisterListPref(prefs::kPluginsDisabledPlugins); - prefs->RegisterListPref(prefs::kPluginsDisabledPluginsExceptions); - prefs->RegisterListPref(prefs::kPluginsEnabledPlugins); + internal_dir, + PrefService::UNSYNCABLE_PREF); + prefs->RegisterListPref(prefs::kPluginsDisabledPlugins, + PrefService::UNSYNCABLE_PREF); + prefs->RegisterListPref(prefs::kPluginsDisabledPluginsExceptions, + PrefService::UNSYNCABLE_PREF); + prefs->RegisterListPref(prefs::kPluginsEnabledPlugins, + PrefService::UNSYNCABLE_PREF); } diff --git a/chrome/browser/policy/cloud_policy_subsystem.cc b/chrome/browser/policy/cloud_policy_subsystem.cc index 77752b0..5ed979a 100644 --- a/chrome/browser/policy/cloud_policy_subsystem.cc +++ b/chrome/browser/policy/cloud_policy_subsystem.cc @@ -145,7 +145,8 @@ ConfigurationPolicyProvider* // static void CloudPolicySubsystem::RegisterPrefs(PrefService* pref_service) { pref_service->RegisterIntegerPref(prefs::kPolicyRefreshRate, - kDefaultPolicyRefreshRateMs); + kDefaultPolicyRefreshRateMs, + PrefService::UNSYNCABLE_PREF); } void CloudPolicySubsystem::UpdatePolicyRefreshRate() { diff --git a/chrome/browser/policy/managed_prefs_banner_base_unittest.cc b/chrome/browser/policy/managed_prefs_banner_base_unittest.cc index 3f2569d..82d5f27 100644 --- a/chrome/browser/policy/managed_prefs_banner_base_unittest.cc +++ b/chrome/browser/policy/managed_prefs_banner_base_unittest.cc @@ -1,4 +1,4 @@ -// Copyright (c) 2010 The Chromium Authors. All rights reserved. +// Copyright (c) 2011 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. @@ -16,11 +16,17 @@ class ManagedPrefsBannerBaseTest : public testing::Test { public: virtual void SetUp() { user_prefs_.reset(new TestingPrefService); - user_prefs_->RegisterBooleanPref(prefs::kHomePageIsNewTabPage, false); - user_prefs_->RegisterBooleanPref(prefs::kSearchSuggestEnabled, false); + user_prefs_->RegisterBooleanPref(prefs::kHomePageIsNewTabPage, + false, + PrefService::UNSYNCABLE_PREF); + user_prefs_->RegisterBooleanPref(prefs::kSearchSuggestEnabled, + false, + PrefService::UNSYNCABLE_PREF); local_state_.reset(new TestingPrefService); - local_state_->RegisterBooleanPref(prefs::kHomePageIsNewTabPage, false); - local_state_->RegisterBooleanPref(prefs::kMetricsReportingEnabled, false); + local_state_->RegisterBooleanPref(prefs::kHomePageIsNewTabPage, + false); + local_state_->RegisterBooleanPref(prefs::kMetricsReportingEnabled, + false); } scoped_ptr<TestingPrefService> local_state_; diff --git a/chrome/browser/prefs/pref_member_unittest.cc b/chrome/browser/prefs/pref_member_unittest.cc index 9fca66b..3cc4cb6 100644 --- a/chrome/browser/prefs/pref_member_unittest.cc +++ b/chrome/browser/prefs/pref_member_unittest.cc @@ -21,10 +21,12 @@ const char kDoublePref[] = "double"; const char kStringPref[] = "string"; void RegisterTestPrefs(PrefService* prefs) { - prefs->RegisterBooleanPref(kBoolPref, false); - prefs->RegisterIntegerPref(kIntPref, 0); - prefs->RegisterDoublePref(kDoublePref, 0.0); - prefs->RegisterStringPref(kStringPref, "default"); + prefs->RegisterBooleanPref(kBoolPref, false, PrefService::UNSYNCABLE_PREF); + prefs->RegisterIntegerPref(kIntPref, 0, PrefService::UNSYNCABLE_PREF); + prefs->RegisterDoublePref(kDoublePref, 0.0, PrefService::UNSYNCABLE_PREF); + prefs->RegisterStringPref(kStringPref, + "default", + PrefService::UNSYNCABLE_PREF); } class GetPrefValueCallback diff --git a/chrome/browser/prefs/pref_model_associator.cc b/chrome/browser/prefs/pref_model_associator.cc new file mode 100644 index 0000000..9875d77 --- /dev/null +++ b/chrome/browser/prefs/pref_model_associator.cc @@ -0,0 +1,505 @@ +// Copyright (c) 2011 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 "chrome/browser/prefs/pref_model_associator.h" + +#include "base/auto_reset.h" +#include "base/json/json_reader.h" +#include "base/logging.h" +#include "base/utf_string_conversions.h" +#include "base/values.h" +#include "chrome/browser/profiles/profile.h" +#include "chrome/browser/sync/engine/syncapi.h" +#include "chrome/browser/sync/glue/generic_change_processor.h" +#include "chrome/browser/sync/profile_sync_service.h" +#include "chrome/browser/sync/protocol/preference_specifics.pb.h" +#include "chrome/common/pref_names.h" +#include "content/browser/browser_thread.h" +#include "content/common/json_value_serializer.h" +#include "content/common/notification_service.h" + +using syncable::PREFERENCES; + +PrefModelAssociator::PrefModelAssociator() + : pref_service_(NULL), + sync_service_(NULL), + models_associated_(false), + processing_syncer_changes_(false), + change_processor_(NULL) { +} + +PrefModelAssociator::PrefModelAssociator( + PrefService* pref_service) + : pref_service_(pref_service), + sync_service_(NULL), + models_associated_(false), + processing_syncer_changes_(false), + change_processor_(NULL) { + DCHECK(CalledOnValidThread()); +} + +PrefModelAssociator::~PrefModelAssociator() { + DCHECK(CalledOnValidThread()); + change_processor_ = NULL; + sync_service_ = NULL; + pref_service_ = NULL; +} + +bool PrefModelAssociator::InitPrefNodeAndAssociate( + sync_api::WriteTransaction* trans, + const sync_api::BaseNode& root, + const PrefService::Preference* pref) { + DCHECK(pref); + + base::JSONReader reader; + std::string tag = pref->name(); + sync_api::WriteNode node(trans); + if (node.InitByClientTagLookup(PREFERENCES, tag)) { + // The server has a value for the preference. + const sync_pb::PreferenceSpecifics& preference( + node.GetPreferenceSpecifics()); + DCHECK_EQ(tag, preference.name()); + + if (!pref->IsUserModifiable()) { + Associate(pref, node.GetId()); + return true; + } + + scoped_ptr<Value> value( + reader.JsonToValue(preference.value(), false, false)); + std::string pref_name = preference.name(); + if (!value.get()) { + LOG(ERROR) << "Failed to deserialize preference value: " + << reader.GetErrorMessage(); + return false; + } + + // Merge the server value of this preference with the local value. + scoped_ptr<Value> new_value(MergePreference(*pref, *value)); + + // Update the local preference based on what we got from the + // sync server. + if (new_value->IsType(Value::TYPE_NULL)) { + pref_service_->ClearPref(pref_name.c_str()); + } else if (!new_value->IsType(pref->GetType())) { + LOG(WARNING) << "Synced value for " << preference.name() + << " is of type " << new_value->GetType() + << " which doesn't match pref type " << pref->GetType(); + } else if (!pref->GetValue()->Equals(new_value.get())) { + pref_service_->Set(pref_name.c_str(), *new_value); + } + + SendUpdateNotificationsIfNecessary(pref_name); + + // If the merge resulted in an updated value, write it back to + // the sync node. + if (!value->Equals(new_value.get()) && + !WritePreferenceToNode(pref->name(), *new_value, &node)) { + return false; + } + Associate(pref, node.GetId()); + } else if (pref->IsUserControlled()) { + // The server doesn't have a value, but we have a user-controlled value, + // so we push it to the server. + sync_api::WriteNode write_node(trans); + if (!write_node.InitUniqueByCreation(PREFERENCES, root, tag)) { + LOG(ERROR) << "Failed to create preference sync node."; + return false; + } + + // Update the sync node with the local value for this preference. + if (!WritePreferenceToNode(pref->name(), *pref->GetValue(), &write_node)) + return false; + + Associate(pref, write_node.GetId()); + } else { + // This preference is handled by policy, not the user, and therefore + // we do not associate it. + } + + return true; +} + +bool PrefModelAssociator::AssociateModels() { + DCHECK(CalledOnValidThread()); + + int64 root_id; + if (!GetSyncIdForTaggedNode(syncable::ModelTypeToRootTag(PREFERENCES), + &root_id)) { + LOG(ERROR) << "Server did not create the top-level preferences node. We " + << "might be running against an out-of-date server."; + return false; + } + + sync_api::WriteTransaction trans(sync_service_->GetUserShare()); + sync_api::ReadNode root(&trans); + if (!root.InitByIdLookup(root_id)) { + LOG(ERROR) << "Server did not create the top-level preferences node. We " + << "might be running against an out-of-date server."; + return false; + } + + for (std::set<std::string>::iterator it = synced_preferences_.begin(); + it != synced_preferences_.end(); ++it) { + std::string name = *it; + const PrefService::Preference* pref = + pref_service_->FindPreference(name.c_str()); + VLOG(1) << "Associating preference " << name; + DCHECK(pref); + if (!pref->IsUserModifiable()) + continue; // We don't sync preferences the user cannot change. + InitPrefNodeAndAssociate(&trans, root, pref); + } + models_associated_ = true; + return true; +} + +bool PrefModelAssociator::DisassociateModels() { + id_map_.clear(); + id_map_inverse_.clear(); + models_associated_ = false; + return true; +} + +bool PrefModelAssociator::SyncModelHasUserCreatedNodes(bool* has_nodes) { + DCHECK(has_nodes); + *has_nodes = false; + int64 preferences_sync_id; + if (!GetSyncIdForTaggedNode(syncable::ModelTypeToRootTag(PREFERENCES), + &preferences_sync_id)) { + LOG(ERROR) << "Server did not create the top-level preferences node. We " + << "might be running against an out-of-date server."; + return false; + } + sync_api::ReadTransaction trans(sync_service_->GetUserShare()); + + sync_api::ReadNode preferences_node(&trans); + if (!preferences_node.InitByIdLookup(preferences_sync_id)) { + LOG(ERROR) << "Server did not create the top-level preferences node. We " + << "might be running against an out-of-date server."; + return false; + } + + // The sync model has user created nodes if the preferences folder has any + // children. + *has_nodes = sync_api::kInvalidId != preferences_node.GetFirstChildId(); + return true; +} + +int64 PrefModelAssociator::GetSyncIdFromChromeId( + const std::string& preference_name) { + PreferenceNameToSyncIdMap::const_iterator iter = + id_map_.find(preference_name); + return iter == id_map_.end() ? sync_api::kInvalidId : iter->second; +} + +void PrefModelAssociator::Associate( + const PrefService::Preference* preference, int64 sync_id) { + DCHECK(CalledOnValidThread()); + + std::string name = preference->name(); + DCHECK_NE(sync_api::kInvalidId, sync_id); + DCHECK_EQ(0U, id_map_.count(name)); + DCHECK_EQ(0U, id_map_inverse_.count(sync_id)); + id_map_[name] = sync_id; + id_map_inverse_[sync_id] = name; +} + +void PrefModelAssociator::Disassociate(int64 sync_id) { + DCHECK(CalledOnValidThread()); + SyncIdToPreferenceNameMap::iterator iter = id_map_inverse_.find(sync_id); + if (iter == id_map_inverse_.end()) + return; + id_map_.erase(iter->second); + id_map_inverse_.erase(iter); +} + +bool PrefModelAssociator::GetSyncIdForTaggedNode(const std::string& tag, + int64* sync_id) { + sync_api::ReadTransaction trans(sync_service_->GetUserShare()); + sync_api::ReadNode sync_node(&trans); + if (!sync_node.InitByTagLookup(tag.c_str())) + return false; + *sync_id = sync_node.GetId(); + return true; +} + +Value* PrefModelAssociator::MergePreference( + const PrefService::Preference& local_pref, + const Value& server_value) { + const std::string& name(local_pref.name()); + if (name == prefs::kURLsToRestoreOnStartup || + name == prefs::kDesktopNotificationAllowedOrigins || + name == prefs::kDesktopNotificationDeniedOrigins) { + return MergeListValues(*local_pref.GetValue(), server_value); + } + + if (name == prefs::kContentSettingsPatterns || + name == prefs::kGeolocationContentSettings) { + return MergeDictionaryValues(*local_pref.GetValue(), server_value); + } + + // If this is not a specially handled preference, server wins. + return server_value.DeepCopy(); +} + +bool PrefModelAssociator::WritePreferenceToNode( + const std::string& name, + const Value& value, + sync_api::WriteNode* node) { + std::string serialized; + JSONStringValueSerializer json(&serialized); + if (!json.Serialize(value)) { + LOG(ERROR) << "Failed to serialize preference value."; + return false; + } + + sync_pb::PreferenceSpecifics preference; + preference.set_name(name); + preference.set_value(serialized); + node->SetPreferenceSpecifics(preference); + // TODO(viettrungluu): eliminate conversion (it's temporary) + node->SetTitle(UTF8ToWide(name)); + return true; +} + +Value* PrefModelAssociator::MergeListValues(const Value& from_value, + const Value& to_value) { + if (from_value.GetType() == Value::TYPE_NULL) + return to_value.DeepCopy(); + if (to_value.GetType() == Value::TYPE_NULL) + return from_value.DeepCopy(); + + DCHECK(from_value.GetType() == Value::TYPE_LIST); + DCHECK(to_value.GetType() == Value::TYPE_LIST); + const ListValue& from_list_value = static_cast<const ListValue&>(from_value); + const ListValue& to_list_value = static_cast<const ListValue&>(to_value); + ListValue* result = to_list_value.DeepCopy(); + + for (ListValue::const_iterator i = from_list_value.begin(); + i != from_list_value.end(); ++i) { + Value* value = (*i)->DeepCopy(); + result->AppendIfNotPresent(value); + } + return result; +} + +Value* PrefModelAssociator::MergeDictionaryValues( + const Value& from_value, + const Value& to_value) { + if (from_value.GetType() == Value::TYPE_NULL) + return to_value.DeepCopy(); + if (to_value.GetType() == Value::TYPE_NULL) + return from_value.DeepCopy(); + + DCHECK_EQ(from_value.GetType(), Value::TYPE_DICTIONARY); + DCHECK_EQ(to_value.GetType(), Value::TYPE_DICTIONARY); + const DictionaryValue& from_dict_value = + static_cast<const DictionaryValue&>(from_value); + const DictionaryValue& to_dict_value = + static_cast<const DictionaryValue&>(to_value); + DictionaryValue* result = to_dict_value.DeepCopy(); + + for (DictionaryValue::key_iterator key = from_dict_value.begin_keys(); + key != from_dict_value.end_keys(); ++key) { + Value* from_value; + bool success = from_dict_value.GetWithoutPathExpansion(*key, &from_value); + DCHECK(success); + + Value* to_key_value; + if (result->GetWithoutPathExpansion(*key, &to_key_value)) { + if (to_key_value->GetType() == Value::TYPE_DICTIONARY) { + Value* merged_value = MergeDictionaryValues(*from_value, *to_key_value); + result->SetWithoutPathExpansion(*key, merged_value); + } + // Note that for all other types we want to preserve the "to" + // values so we do nothing here. + } else { + result->SetWithoutPathExpansion(*key, from_value->DeepCopy()); + } + } + return result; +} + +void PrefModelAssociator::SendUpdateNotificationsIfNecessary( + const std::string& pref_name) { + // The bookmark bar visibility preference requires a special + // notification to update the UI. + if (0 == pref_name.compare(prefs::kShowBookmarkBar)) { + NotificationService::current()->Notify( + NotificationType::BOOKMARK_BAR_VISIBILITY_PREF_CHANGED, + Source<PrefModelAssociator>(this), + NotificationService::NoDetails()); + } +} + +// Not implemented. +void PrefModelAssociator::AbortAssociation() {} + +bool PrefModelAssociator::CryptoReadyIfNecessary() { + // We only access the cryptographer while holding a transaction. + sync_api::ReadTransaction trans(sync_service_->GetUserShare()); + syncable::ModelTypeSet encrypted_types; + sync_service_->GetEncryptedDataTypes(&encrypted_types); + return encrypted_types.count(PREFERENCES) == 0 || + sync_service_->IsCryptographerReady(&trans); +} + +void PrefModelAssociator::SetupSync( + ProfileSyncService* sync_service, + browser_sync::GenericChangeProcessor* change_processor) { + sync_service_ = sync_service; + change_processor_ = change_processor; +} + +void PrefModelAssociator::ApplyChangesFromSync( + const sync_api::BaseTransaction* trans, + const sync_api::SyncManager::ChangeRecord* changes, + int change_count) { + if (!models_associated_) + return; + AutoReset<bool> processing_changes(&processing_syncer_changes_, true); + for (int i = 0; i < change_count; ++i) { + if (sync_api::SyncManager::ChangeRecord::ACTION_DELETE == + changes[i].action) { + // We never delete preferences. + NOTREACHED(); + } + + sync_api::ReadNode node(trans); + if (!node.InitByIdLookup(changes[i].id)) { + LOG(ERROR) << "Preference node lookup failed."; + return; + } + DCHECK(PREFERENCES == node.GetModelType()); + std::string name; + sync_pb::PreferenceSpecifics pref_specifics = + node.GetPreferenceSpecifics(); + scoped_ptr<Value> value(ReadPreferenceSpecifics(pref_specifics, + &name)); + // Skip values we can't deserialize. + if (!value.get()) + continue; + + // It is possible that we may receive a change to a preference we do not + // want to sync. For example if the user is syncing a Mac client and a + // Windows client, the Windows client does not support + // kConfirmToQuitEnabled. Ignore updates from these preferences. + const char* pref_name = name.c_str(); + if (!IsPrefRegistered(pref_name)) + continue; + + const PrefService::Preference* pref = + pref_service_->FindPreference(pref_name); + DCHECK(pref); + if (!pref->IsUserModifiable()) { + continue; + } + + if (sync_api::SyncManager::ChangeRecord::ACTION_DELETE == + changes[i].action) { + pref_service_->ClearPref(pref_name); + } else { + pref_service_->Set(pref_name, *value); + + // If this is a newly added node, associate. + if (sync_api::SyncManager::ChangeRecord::ACTION_ADD == + changes[i].action) { + Associate(pref, changes[i].id); + } + + SendUpdateNotificationsIfNecessary(name); + } + } +} + +Value* PrefModelAssociator::ReadPreferenceSpecifics( + const sync_pb::PreferenceSpecifics& preference, + std::string* name) { + base::JSONReader reader; + scoped_ptr<Value> value(reader.JsonToValue(preference.value(), false, false)); + if (!value.get()) { + std::string err = "Failed to deserialize preference value: " + + reader.GetErrorMessage(); + LOG(ERROR) << err; + return NULL; + } + *name = preference.name(); + return value.release(); +} + + +std::set<std::string> PrefModelAssociator::synced_preferences() const { + return synced_preferences_; +} + +void PrefModelAssociator::RegisterPref(const char* name) { + DCHECK(!models_associated_ && synced_preferences_.count(name) == 0); + synced_preferences_.insert(name); +} + +bool PrefModelAssociator::IsPrefRegistered(const char* name) { + return synced_preferences_.count(name) > 0; +} + +void PrefModelAssociator::ProcessPrefChange(const std::string& name) { + if (processing_syncer_changes_) + return; // These are changes originating from us, ignore. + + // We only process changes if we've already associated models. + if (!sync_service_ || !models_associated_) + return; + + const PrefService::Preference* preference = + pref_service_->FindPreference(name.c_str()); + if (!IsPrefRegistered(name.c_str())) + return; // We are not syncing this preference. + + // The preference does not have a node. This can happen if the preference + // held the default value at association time. Create one and associate. + int64 root_id; + if (!GetSyncIdForTaggedNode(syncable::ModelTypeToRootTag(PREFERENCES), + &root_id)) { + LOG(ERROR) << "Server did not create the top-level preferences node. We " + << "might be running against an out-of-date server."; + return; + } + + int64 sync_id = GetSyncIdFromChromeId(name); + if (!preference->IsUserModifiable()) { + // If the preference is not currently user modifiable, disassociate, so that + // if it becomes user modifiable me pick up the server value. + Disassociate(sync_id); + return; + } + + AutoReset<bool> processing_changes(&processing_syncer_changes_, true); + sync_api::WriteTransaction trans(sync_service_->GetUserShare()); + + // Since we don't create sync nodes for preferences that are not under control + // of the user or still have their default value, this changed preference may + // not have a sync node yet. If so, we create a node. Similarly, a preference + // may become user-modifiable (e.g. due to laxer policy configuration), in + // which case we also need to create a sync node and associate it. + if (sync_id == sync_api::kInvalidId) { + sync_api::ReadNode root(&trans); + if (!root.InitByIdLookup(root_id)) { + LOG(ERROR) << "Server did not create the top-level preferences node. We " + << "might be running against an out-of-date server."; + return; + } + InitPrefNodeAndAssociate(&trans, root, preference); + } else { + sync_api::WriteNode node(&trans); + if (!node.InitByIdLookup(sync_id)) { + LOG(ERROR) << "Preference node lookup failed."; + return; + } + + if (!WritePreferenceToNode(name, *preference->GetValue(), &node)) { + LOG(ERROR) << "Failed to update preference node."; + return; + } + } +} diff --git a/chrome/browser/prefs/pref_model_associator.h b/chrome/browser/prefs/pref_model_associator.h new file mode 100644 index 0000000..7b24153 --- /dev/null +++ b/chrome/browser/prefs/pref_model_associator.h @@ -0,0 +1,152 @@ +// Copyright (c) 2011 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. + +#ifndef CHROME_BROWSER_PREFS_PREF_MODEL_ASSOCIATOR_H_ +#define CHROME_BROWSER_PREFS_PREF_MODEL_ASSOCIATOR_H_ +#pragma once + +#include <map> +#include <set> +#include <string> + +#include "base/basictypes.h" +#include "base/compiler_specific.h" +#include "base/threading/non_thread_safe.h" +#include "chrome/browser/prefs/pref_service.h" +#include "chrome/browser/sync/syncable_service.h" +#include "chrome/browser/sync/unrecoverable_error_handler.h" + +class Profile; +class ProfileSyncService; +class Value; + +namespace sync_api { +class WriteNode; +class WriteTransaction; +} + +namespace browser_sync { +class ChangeProcessor; +class GenericChangeProcessor; +} + +// Contains all model association related logic: +// * Algorithm to associate preferences model and sync model. +// TODO(sync): Rewrite to use change processor instead of transactions. +// TODO(sync): Merge this into PrefService. We don't actually need the id_map +// mapping since the sync node tags are the same as the pref names. +class PrefModelAssociator + : public SyncableService, + public base::NonThreadSafe { + public: + explicit PrefModelAssociator(PrefService* pref_service); + virtual ~PrefModelAssociator(); + + // SyncableService implementation. + virtual bool AssociateModels() OVERRIDE; + virtual bool DisassociateModels() OVERRIDE; + virtual bool SyncModelHasUserCreatedNodes(bool* has_nodes) OVERRIDE; + virtual void AbortAssociation() OVERRIDE; // Not implemented. + virtual bool CryptoReadyIfNecessary() OVERRIDE; + virtual void ApplyChangesFromSync( + const sync_api::BaseTransaction* trans, + const sync_api::SyncManager::ChangeRecord* changes, + int change_count) OVERRIDE; + virtual void SetupSync( + ProfileSyncService* sync_service, + browser_sync::GenericChangeProcessor* change_processor) OVERRIDE; + + // Returns the list of preference names that should be monitored for changes. + // Only preferences that are registered will be in this list. + std::set<std::string> synced_preferences() const; + + // Register a preference with the specified name for syncing. We do not care + // about the type at registration time, but when changes arrive from the + // syncer, we check if they can be applied and if not drop them. + virtual void RegisterPref(const char* name); + + // Returns true if the specified preference is registered for syncing. + virtual bool IsPrefRegistered(const char* name); + + // Process a local preference change. + virtual void ProcessPrefChange(const std::string& name); + + // Merges the value of local_pref into the supplied server_value and returns + // the result (caller takes ownership). If there is a conflict, the server + // value always takes precedence. Note that only certain preferences will + // actually be merged, all others will return a copy of the server value. See + // the method's implementation for details. + static Value* MergePreference(const PrefService::Preference& local_pref, + const Value& server_value); + + // Writes the value of pref into the specified node. Returns true + // upon success. + static bool WritePreferenceToNode(const std::string& name, + const Value& value, + sync_api::WriteNode* node); + + // Extract preference value and name from sync specifics. + Value* ReadPreferenceSpecifics( + const sync_pb::PreferenceSpecifics& specifics, + std::string* name); + + // Returns the sync id for the given preference name, or sync_api::kInvalidId + // if the preference name is not associated to any sync id. + int64 GetSyncIdFromChromeId(const std::string& node_id); + protected: + friend class ProfileSyncServicePreferenceTest; + + // For testing. + PrefModelAssociator(); + + // Create an association for a given preference. A sync node is created if + // necessary and the value is read from or written to the node as appropriate. + bool InitPrefNodeAndAssociate(sync_api::WriteTransaction* trans, + const sync_api::BaseNode& root, + const PrefService::Preference* pref); + + // Associates the given preference name with the given sync id. + void Associate(const PrefService::Preference* node, int64 sync_id); + + // Remove the association that corresponds to the given sync id. + void Disassociate(int64 sync_id); + + // Returns whether a node with the given permanent tag was found and update + // |sync_id| with that node's id. + bool GetSyncIdForTaggedNode(const std::string& tag, int64* sync_id); + + // Perform any additional operations that need to happen after a preference + // has been updated. + void SendUpdateNotificationsIfNecessary(const std::string& pref_name); + + typedef std::map<std::string, int64> PreferenceNameToSyncIdMap; + typedef std::map<int64, std::string> SyncIdToPreferenceNameMap; + + static Value* MergeListValues(const Value& from_value, const Value& to_value); + static Value* MergeDictionaryValues(const Value& from_value, + const Value& to_value); + + PrefService* pref_service_; + ProfileSyncService* sync_service_; + + // Do we have an active association between the preferences and sync models? + // Set by AssociateModels, reset by DisassociateModels. + bool models_associated_; + + // Whether we're currently processing changes from the syncer. While this is + // true, we ignore any pref changes, since we triggered them. + bool processing_syncer_changes_; + + PreferenceNameToSyncIdMap id_map_; + SyncIdToPreferenceNameMap id_map_inverse_; + std::set<std::string> synced_preferences_; + + // TODO(zea): Get rid of this and use one owned by the PSS. + // We create, but don't own this (will be destroyed by data type controller). + browser_sync::GenericChangeProcessor* change_processor_; + + DISALLOW_COPY_AND_ASSIGN(PrefModelAssociator); +}; + +#endif // CHROME_BROWSER_PREFS_PREF_MODEL_ASSOCIATOR_H_ diff --git a/chrome/browser/sync/glue/preference_model_associator_unittest.cc b/chrome/browser/prefs/pref_model_associator_unittest.cc index 7ed60b0..6abf38e 100644 --- a/chrome/browser/sync/glue/preference_model_associator_unittest.cc +++ b/chrome/browser/prefs/pref_model_associator_unittest.cc @@ -4,14 +4,12 @@ #include "base/memory/scoped_ptr.h" #include "base/values.h" +#include "chrome/browser/prefs/pref_model_associator.h" #include "chrome/browser/prefs/scoped_user_pref_update.h" -#include "chrome/browser/sync/glue/preference_model_associator.h" #include "chrome/common/pref_names.h" #include "chrome/test/testing_profile.h" #include "testing/gtest/include/gtest/gtest.h" -using browser_sync::PreferenceModelAssociator; - class AbstractPreferenceMergeTest : public testing::Test { protected: virtual void SetUp() { @@ -81,7 +79,7 @@ TEST_F(ListPreferenceMergeTest, NotListOrDictionary) { pref_service_->FindPreference(prefs::kHomePage); scoped_ptr<Value> server_value(Value::CreateStringValue(server_url0_)); scoped_ptr<Value> merged_value( - PreferenceModelAssociator::MergePreference(*pref, *server_value)); + PrefModelAssociator::MergePreference(*pref, *server_value)); EXPECT_TRUE(merged_value->Equals(server_value.get())); } @@ -90,7 +88,7 @@ TEST_F(ListPreferenceMergeTest, LocalEmpty) { const PrefService::Preference* pref = pref_service_->FindPreference(prefs::kURLsToRestoreOnStartup); scoped_ptr<Value> merged_value( - PreferenceModelAssociator::MergePreference(*pref, server_url_list_)); + PrefModelAssociator::MergePreference(*pref, server_url_list_)); EXPECT_TRUE(merged_value->Equals(&server_url_list_)); } @@ -105,7 +103,7 @@ TEST_F(ListPreferenceMergeTest, ServerNull) { const PrefService::Preference* pref = pref_service_->FindPreference(prefs::kURLsToRestoreOnStartup); scoped_ptr<Value> merged_value( - PreferenceModelAssociator::MergePreference(*pref, *null_value)); + PrefModelAssociator::MergePreference(*pref, *null_value)); const ListValue* local_list_value = pref_service_->GetList(prefs::kURLsToRestoreOnStartup); EXPECT_TRUE(merged_value->Equals(local_list_value)); @@ -122,7 +120,7 @@ TEST_F(ListPreferenceMergeTest, ServerEmpty) { const PrefService::Preference* pref = pref_service_->FindPreference(prefs::kURLsToRestoreOnStartup); scoped_ptr<Value> merged_value( - PreferenceModelAssociator::MergePreference(*pref, *empty_value)); + PrefModelAssociator::MergePreference(*pref, *empty_value)); const ListValue* local_list_value = pref_service_->GetList(prefs::kURLsToRestoreOnStartup); EXPECT_TRUE(merged_value->Equals(local_list_value)); @@ -139,7 +137,7 @@ TEST_F(ListPreferenceMergeTest, Merge) { const PrefService::Preference* pref = pref_service_->FindPreference(prefs::kURLsToRestoreOnStartup); scoped_ptr<Value> merged_value( - PreferenceModelAssociator::MergePreference(*pref, server_url_list_)); + PrefModelAssociator::MergePreference(*pref, server_url_list_)); ListValue expected; expected.Append(Value::CreateStringValue(server_url0_)); @@ -161,7 +159,7 @@ TEST_F(ListPreferenceMergeTest, Duplicates) { const PrefService::Preference* pref = pref_service_->FindPreference(prefs::kURLsToRestoreOnStartup); scoped_ptr<Value> merged_value( - PreferenceModelAssociator::MergePreference(*pref, server_url_list_)); + PrefModelAssociator::MergePreference(*pref, server_url_list_)); ListValue expected; expected.Append(Value::CreateStringValue(server_url0_)); @@ -182,7 +180,7 @@ TEST_F(ListPreferenceMergeTest, Equals) { const PrefService::Preference* pref = pref_service_->FindPreference(prefs::kURLsToRestoreOnStartup); scoped_ptr<Value> merged_value( - PreferenceModelAssociator::MergePreference(*pref, server_url_list_)); + PrefModelAssociator::MergePreference(*pref, server_url_list_)); EXPECT_TRUE(merged_value->Equals(original.get())); } @@ -215,7 +213,7 @@ TEST_F(DictionaryPreferenceMergeTest, LocalEmpty) { const PrefService::Preference* pref = pref_service_->FindPreference(prefs::kContentSettingsPatterns); scoped_ptr<Value> merged_value( - PreferenceModelAssociator::MergePreference(*pref, server_patterns_)); + PrefModelAssociator::MergePreference(*pref, server_patterns_)); EXPECT_TRUE(merged_value->Equals(&server_patterns_)); } @@ -230,7 +228,7 @@ TEST_F(DictionaryPreferenceMergeTest, ServerNull) { const PrefService::Preference* pref = pref_service_->FindPreference(prefs::kContentSettingsPatterns); scoped_ptr<Value> merged_value( - PreferenceModelAssociator::MergePreference(*pref, *null_value)); + PrefModelAssociator::MergePreference(*pref, *null_value)); const DictionaryValue* local_dict_value = pref_service_->GetDictionary(prefs::kContentSettingsPatterns); EXPECT_TRUE(merged_value->Equals(local_dict_value)); @@ -247,7 +245,7 @@ TEST_F(DictionaryPreferenceMergeTest, ServerEmpty) { const PrefService::Preference* pref = pref_service_->FindPreference(prefs::kContentSettingsPatterns); scoped_ptr<Value> merged_value( - PreferenceModelAssociator::MergePreference(*pref, *empty_value)); + PrefModelAssociator::MergePreference(*pref, *empty_value)); const DictionaryValue* local_dict_value = pref_service_->GetDictionary(prefs::kContentSettingsPatterns); EXPECT_TRUE(merged_value->Equals(local_dict_value)); @@ -260,7 +258,7 @@ TEST_F(DictionaryPreferenceMergeTest, MergeNoConflicts) { SetContentPattern(local_dict_value, expression2_, content_type0_, 1); } - scoped_ptr<Value> merged_value(PreferenceModelAssociator::MergePreference( + scoped_ptr<Value> merged_value(PrefModelAssociator::MergePreference( *pref_service_->FindPreference(prefs::kContentSettingsPatterns), server_patterns_)); @@ -282,7 +280,7 @@ TEST_F(DictionaryPreferenceMergeTest, MergeConflicts) { SetContentPattern(local_dict_value, expression2_, content_type0_, 2); } - scoped_ptr<Value> merged_value(PreferenceModelAssociator::MergePreference( + scoped_ptr<Value> merged_value(PrefModelAssociator::MergePreference( *pref_service_->FindPreference(prefs::kContentSettingsPatterns), server_patterns_)); @@ -304,7 +302,7 @@ TEST_F(DictionaryPreferenceMergeTest, Equal) { SetContentPattern(local_dict_value, expression1_, content_type0_, 1); } - scoped_ptr<Value> merged_value(PreferenceModelAssociator::MergePreference( + scoped_ptr<Value> merged_value(PrefModelAssociator::MergePreference( *pref_service_->FindPreference(prefs::kContentSettingsPatterns), server_patterns_)); EXPECT_TRUE(merged_value->Equals(&server_patterns_)); @@ -319,7 +317,7 @@ TEST_F(DictionaryPreferenceMergeTest, ConflictButServerWins) { SetContentPattern(local_dict_value, expression1_, content_type0_, 1); } - scoped_ptr<Value> merged_value(PreferenceModelAssociator::MergePreference( + scoped_ptr<Value> merged_value(PrefModelAssociator::MergePreference( *pref_service_->FindPreference(prefs::kContentSettingsPatterns), server_patterns_)); EXPECT_TRUE(merged_value->Equals(&server_patterns_)); @@ -347,7 +345,7 @@ class IndividualPreferenceMergeTest : public AbstractPreferenceMergeTest { local_list_value->Append(Value::CreateStringValue(url1_)); } - scoped_ptr<Value> merged_value(PreferenceModelAssociator::MergePreference( + scoped_ptr<Value> merged_value(PrefModelAssociator::MergePreference( *pref_service_->FindPreference(pref), server_url_list_)); @@ -364,7 +362,7 @@ class IndividualPreferenceMergeTest : public AbstractPreferenceMergeTest { SetContentPattern(local_dict_value, expression1_, content_type0_, 1); } - scoped_ptr<Value> merged_value(PreferenceModelAssociator::MergePreference( + scoped_ptr<Value> merged_value(PrefModelAssociator::MergePreference( *pref_service_->FindPreference(pref), server_patterns_)); diff --git a/chrome/browser/prefs/pref_notifier_impl_unittest.cc b/chrome/browser/prefs/pref_notifier_impl_unittest.cc index aaea66f..096b625 100644 --- a/chrome/browser/prefs/pref_notifier_impl_unittest.cc +++ b/chrome/browser/prefs/pref_notifier_impl_unittest.cc @@ -56,8 +56,12 @@ class MockPrefNotifier : public PrefNotifierImpl { class PrefNotifierTest : public testing::Test { protected: virtual void SetUp() { - pref_service_.RegisterBooleanPref(kChangedPref, true); - pref_service_.RegisterBooleanPref(kUnchangedPref, true); + pref_service_.RegisterBooleanPref(kChangedPref, + true, + PrefService::UNSYNCABLE_PREF); + pref_service_.RegisterBooleanPref(kUnchangedPref, + true, + PrefService::UNSYNCABLE_PREF); } TestingPrefService pref_service_; diff --git a/chrome/browser/prefs/pref_service.cc b/chrome/browser/prefs/pref_service.cc index 8ea2d2a4..5096d1d 100644 --- a/chrome/browser/prefs/pref_service.cc +++ b/chrome/browser/prefs/pref_service.cc @@ -18,11 +18,13 @@ #include "base/string_util.h" #include "base/value_conversions.h" #include "build/build_config.h" +#include "chrome/browser/browser_process.h" #include "chrome/browser/extensions/extension_pref_store.h" #include "chrome/browser/policy/configuration_policy_pref_store.h" #include "chrome/browser/prefs/command_line_pref_store.h" #include "chrome/browser/prefs/default_pref_store.h" #include "chrome/browser/prefs/overlay_persistent_pref_store.h" +#include "chrome/browser/prefs/pref_model_associator.h" #include "chrome/browser/prefs/pref_notifier_impl.h" #include "chrome/browser/prefs/pref_value_store.h" #include "chrome/browser/ui/profile_error_dialog.h" @@ -149,6 +151,7 @@ PrefService::PrefService(PrefStore* managed_platform_prefs, : user_pref_store_(user_prefs), default_store_(default_store), delegate_(delegate) { + pref_sync_associator_.reset(new PrefModelAssociator(this)); pref_notifier_.reset(new PrefNotifierImpl(this)); pref_value_store_.reset( new PrefValueStore(managed_platform_prefs, @@ -159,6 +162,7 @@ PrefService::PrefService(PrefStore* managed_platform_prefs, recommended_platform_prefs, recommended_cloud_prefs, default_store, + pref_sync_associator_.get(), pref_notifier_.get())); InitFromStorage(); } @@ -169,6 +173,7 @@ PrefService::PrefService(const PrefService& original, new OverlayPersistentPrefStore(original.user_pref_store_.get())), default_store_(original.default_store_.get()), delegate_(NULL) { + // Incognito mode doesn't sync, so no need to create PrefModelAssociator. pref_notifier_.reset(new PrefNotifierImpl(this)); pref_value_store_.reset(original.pref_value_store_->CloneAndSpecialize( NULL, // managed_platform_prefs @@ -179,6 +184,7 @@ PrefService::PrefService(const PrefService& original, NULL, // recommended_platform_prefs NULL, // recommended_cloud_prefs default_store_.get(), + NULL, // pref_sync_associator_ pref_notifier_.get())); InitFromStorage(); } @@ -192,6 +198,9 @@ PrefService::~PrefService() { pref_value_store_.reset(); user_pref_store_ = NULL; default_store_ = NULL; + if (pref_sync_associator_.get()) + pref_sync_associator_->DisassociateModels(); + pref_sync_associator_.reset(); } void PrefService::OnPrefsRead(PersistentPrefStore::PrefReadError error, @@ -258,72 +267,286 @@ void PrefService::CommitPendingWrite() { user_pref_store_->CommitPendingWrite(); } +namespace { + +// If there's no g_browser_process or no local state, return true (for testing). +bool IsLocalStatePrefService(PrefService* prefs){ + return (!g_browser_process || + !g_browser_process->local_state() || + g_browser_process->local_state() == prefs); +} + +// If there's no g_browser_process, return true (for testing). +bool IsProfilePrefService(PrefService* prefs){ + // TODO(zea): uncomment this once all preferences are only ever registered + // with either the local_state's pref service or the profile's pref service. + // return (!g_browser_process || g_browser_process->local_state() != prefs); + return true; +} + +} // namespace + + +// Local State prefs. void PrefService::RegisterBooleanPref(const char* path, bool default_value) { - RegisterPreference(path, Value::CreateBooleanValue(default_value)); + // If this fails, the pref service in use is a profile pref service, so the + // sync status must be provided (see profile pref registration calls below). + DCHECK(IsLocalStatePrefService(this)); + RegisterPreference(path, + Value::CreateBooleanValue(default_value), + UNSYNCABLE_PREF); } void PrefService::RegisterIntegerPref(const char* path, int default_value) { - RegisterPreference(path, Value::CreateIntegerValue(default_value)); + // If this fails, the pref service in use is a profile pref service, so the + // sync status must be provided (see profile pref registration calls below). + DCHECK(IsLocalStatePrefService(this)); + RegisterPreference(path, + Value::CreateIntegerValue(default_value), + UNSYNCABLE_PREF); } void PrefService::RegisterDoublePref(const char* path, double default_value) { - RegisterPreference(path, Value::CreateDoubleValue(default_value)); + // If this fails, the pref service in use is a profile pref service, so the + // sync status must be provided (see profile pref registration calls below). + DCHECK(IsLocalStatePrefService(this)); + RegisterPreference(path, + Value::CreateDoubleValue(default_value), + UNSYNCABLE_PREF); } void PrefService::RegisterStringPref(const char* path, const std::string& default_value) { - RegisterPreference(path, Value::CreateStringValue(default_value)); + // If this fails, the pref service in use is a profile pref service, so the + // sync status must be provided (see profile pref registration calls below). + DCHECK(IsLocalStatePrefService(this)); + RegisterPreference(path, + Value::CreateStringValue(default_value), + UNSYNCABLE_PREF); } void PrefService::RegisterFilePathPref(const char* path, const FilePath& default_value) { - RegisterPreference(path, Value::CreateStringValue(default_value.value())); + // If this fails, the pref service in use is a profile pref service, so the + // sync status must be provided (see profile pref registration calls below). + DCHECK(IsLocalStatePrefService(this)); + RegisterPreference(path, + Value::CreateStringValue(default_value.value()), + UNSYNCABLE_PREF); } void PrefService::RegisterListPref(const char* path) { - RegisterPreference(path, new ListValue()); + // If this fails, the pref service in use is a profile pref service, so the + // sync status must be provided (see profile pref registration calls below). + DCHECK(IsLocalStatePrefService(this)); + RegisterPreference(path, + new ListValue(), + UNSYNCABLE_PREF); } void PrefService::RegisterListPref(const char* path, ListValue* default_value) { - RegisterPreference(path, default_value); + // If this fails, the pref service in use is a profile pref service, so the + // sync status must be provided (see profile pref registration calls below). + DCHECK(IsLocalStatePrefService(this)); + RegisterPreference(path, + default_value, + UNSYNCABLE_PREF); } void PrefService::RegisterDictionaryPref(const char* path) { - RegisterPreference(path, new DictionaryValue()); + // If this fails, the pref service in use is a profile pref service, so the + // sync status must be provided (see profile pref registration calls below). + DCHECK(IsLocalStatePrefService(this)); + RegisterPreference(path, + new DictionaryValue(), + UNSYNCABLE_PREF); } void PrefService::RegisterDictionaryPref(const char* path, DictionaryValue* default_value) { - RegisterPreference(path, default_value); + // If this fails, the pref service in use is a profile pref service, so the + // sync status must be provided (see profile pref registration calls below). + DCHECK(IsLocalStatePrefService(this)); + RegisterPreference(path, + default_value, + UNSYNCABLE_PREF); } void PrefService::RegisterLocalizedBooleanPref(const char* path, int locale_default_message_id) { + // If this fails, the pref service in use is a profile pref service, so the + // sync status must be provided (see profile pref registration calls below). + DCHECK(IsLocalStatePrefService(this)); RegisterPreference( path, - CreateLocaleDefaultValue(Value::TYPE_BOOLEAN, locale_default_message_id)); + CreateLocaleDefaultValue(Value::TYPE_BOOLEAN, locale_default_message_id), + UNSYNCABLE_PREF); } void PrefService::RegisterLocalizedIntegerPref(const char* path, int locale_default_message_id) { + // If this fails, the pref service in use is a profile pref service, so the + // sync status must be provided (see profile pref registration calls below). + DCHECK(IsLocalStatePrefService(this)); RegisterPreference( path, - CreateLocaleDefaultValue(Value::TYPE_INTEGER, locale_default_message_id)); + CreateLocaleDefaultValue(Value::TYPE_INTEGER, locale_default_message_id), + UNSYNCABLE_PREF); } void PrefService::RegisterLocalizedDoublePref(const char* path, int locale_default_message_id) { + // If this fails, the pref service in use is a profile pref service, so the + // sync status must be provided (see profile pref registration calls below). + DCHECK(IsLocalStatePrefService(this)); RegisterPreference( path, - CreateLocaleDefaultValue(Value::TYPE_DOUBLE, locale_default_message_id)); + CreateLocaleDefaultValue(Value::TYPE_DOUBLE, locale_default_message_id), + UNSYNCABLE_PREF); } void PrefService::RegisterLocalizedStringPref(const char* path, int locale_default_message_id) { + // If this fails, the pref service in use is a profile pref service, so the + // sync status must be provided (see profile pref registration calls below). + DCHECK(IsLocalStatePrefService(this)); + RegisterPreference( + path, + CreateLocaleDefaultValue(Value::TYPE_STRING, locale_default_message_id), + UNSYNCABLE_PREF); +} + +void PrefService::RegisterInt64Pref(const char* path, int64 default_value) { + // If this fails, the pref service in use is a profile pref service, so the + // sync status must be provided (see profile pref registration calls below). + DCHECK(IsLocalStatePrefService(this)); + RegisterPreference( + path, + Value::CreateStringValue(base::Int64ToString(default_value)), + UNSYNCABLE_PREF); +} + +// Profile prefs (must use the sync_status variable). +void PrefService::RegisterBooleanPref(const char* path, + bool default_value, + PrefSyncStatus sync_status) { + DCHECK(IsProfilePrefService(this)); + RegisterPreference(path, + Value::CreateBooleanValue(default_value), + sync_status); +} + +void PrefService::RegisterIntegerPref(const char* path, + int default_value, + PrefSyncStatus sync_status) { + DCHECK(IsProfilePrefService(this)); + RegisterPreference(path, + Value::CreateIntegerValue(default_value), + sync_status); +} + +void PrefService::RegisterDoublePref(const char* path, + double default_value, + PrefSyncStatus sync_status) { + DCHECK(IsProfilePrefService(this)); + RegisterPreference(path, + Value::CreateDoubleValue(default_value), + sync_status); +} + +void PrefService::RegisterStringPref(const char* path, + const std::string& default_value, + PrefSyncStatus sync_status) { + DCHECK(IsProfilePrefService(this)); + RegisterPreference(path, + Value::CreateStringValue(default_value), + sync_status); +} + +void PrefService::RegisterFilePathPref(const char* path, + const FilePath& default_value, + PrefSyncStatus sync_status) { + DCHECK(IsProfilePrefService(this)); + RegisterPreference(path, + Value::CreateStringValue(default_value.value()), + sync_status); +} + +void PrefService::RegisterListPref(const char* path, + PrefSyncStatus sync_status) { + DCHECK(IsProfilePrefService(this)); + RegisterPreference(path, new ListValue(), sync_status); +} + +void PrefService::RegisterListPref(const char* path, + ListValue* default_value, + PrefSyncStatus sync_status) { + DCHECK(IsProfilePrefService(this)); + RegisterPreference(path, default_value, sync_status); +} + +void PrefService::RegisterDictionaryPref(const char* path, + PrefSyncStatus sync_status) { + DCHECK(IsProfilePrefService(this)); + RegisterPreference(path, new DictionaryValue(), sync_status); +} + +void PrefService::RegisterDictionaryPref(const char* path, + DictionaryValue* default_value, + PrefSyncStatus sync_status) { + DCHECK(IsProfilePrefService(this)); + RegisterPreference(path, default_value, sync_status); +} + +void PrefService::RegisterLocalizedBooleanPref(const char* path, + int locale_default_message_id, + PrefSyncStatus sync_status) { + DCHECK(IsProfilePrefService(this)); + RegisterPreference( + path, + CreateLocaleDefaultValue(Value::TYPE_BOOLEAN,locale_default_message_id), + sync_status); +} + +void PrefService::RegisterLocalizedIntegerPref(const char* path, + int locale_default_message_id, + PrefSyncStatus sync_status) { + DCHECK(IsProfilePrefService(this)); + RegisterPreference( + path, + CreateLocaleDefaultValue(Value::TYPE_INTEGER, locale_default_message_id), + sync_status); +} + +void PrefService::RegisterLocalizedDoublePref(const char* path, + int locale_default_message_id, + PrefSyncStatus sync_status) { + DCHECK(IsProfilePrefService(this)); RegisterPreference( path, - CreateLocaleDefaultValue(Value::TYPE_STRING, locale_default_message_id)); + CreateLocaleDefaultValue(Value::TYPE_DOUBLE, locale_default_message_id), + sync_status); +} + +void PrefService::RegisterLocalizedStringPref(const char* path, + int locale_default_message_id, + PrefSyncStatus sync_status) { + DCHECK(IsProfilePrefService(this)); + RegisterPreference( + path, + CreateLocaleDefaultValue(Value::TYPE_STRING, locale_default_message_id), + sync_status); +} + +void PrefService::RegisterInt64Pref(const char* path, + int64 default_value, + PrefSyncStatus sync_status) { + DCHECK(IsProfilePrefService(this)); + RegisterPreference( + path, + Value::CreateStringValue(base::Int64ToString(default_value)), + sync_status); } bool PrefService::GetBoolean(const char* path) const { @@ -486,7 +709,9 @@ void PrefService::RemovePrefObserver(const char* path, pref_notifier_->RemovePrefObserver(path, obs); } -void PrefService::RegisterPreference(const char* path, Value* default_value) { +void PrefService::RegisterPreference(const char* path, + Value* default_value, + PrefSyncStatus sync_status) { DCHECK(CalledOnValidThread()); // The main code path takes ownership, but most don't. We'll be safe. @@ -503,6 +728,10 @@ void PrefService::RegisterPreference(const char* path, Value* default_value) { // Hand off ownership. default_store_->SetDefaultValue(path, scoped_value.release()); + + // Register with sync if necessary. + if (sync_status == SYNCABLE_PREF && pref_sync_associator_.get()) + pref_sync_associator_->RegisterPref(path); } void PrefService::ClearPref(const char* path) { @@ -561,11 +790,6 @@ int64 PrefService::GetInt64(const char* path) const { return val; } -void PrefService::RegisterInt64Pref(const char* path, int64 default_value) { - RegisterPreference( - path, Value::CreateStringValue(base::Int64ToString(default_value))); -} - Value* PrefService::GetMutableUserPref(const char* path, Value::ValueType type) { CHECK(type == Value::TYPE_DICTIONARY || type == Value::TYPE_LIST); @@ -626,6 +850,10 @@ void PrefService::SetUserPrefValue(const char* path, Value* new_value) { user_pref_store_->SetValue(path, owned_value.release()); } +SyncableService* PrefService::GetSyncableService() { + return pref_sync_associator_.get(); +} + /////////////////////////////////////////////////////////////////////////////// // PrefService::Preference diff --git a/chrome/browser/prefs/pref_service.h b/chrome/browser/prefs/pref_service.h index bf904a4..3990d5a 100644 --- a/chrome/browser/prefs/pref_service.h +++ b/chrome/browser/prefs/pref_service.h @@ -21,12 +21,13 @@ class DefaultPrefStore; class FilePath; class NotificationObserver; class PersistentPrefStore; -class PrefChangeObserver; +class PrefModelAssociator; class PrefNotifier; class PrefNotifierImpl; class PrefStore; class PrefValueStore; class Profile; +class SyncableService; namespace subtle { class PrefMemberBase; @@ -43,6 +44,14 @@ class PrefServiceDelegate { class PrefService : public base::NonThreadSafe, public JsonPrefStore::Delegate { public: + // Enum used when registering preferences to determine if it should be synced + // or not. This is only used for profile prefs, not local state prefs. + // See the Register*Pref methods for profile prefs below. + enum PrefSyncStatus { + UNSYNCABLE_PREF, + SYNCABLE_PREF + }; + // A helper class to store all the information associated with a preference. class Preference { public: @@ -172,6 +181,8 @@ class PrefService : public base::NonThreadSafe, void CommitPendingWrite(); // Make the PrefService aware of a pref. + // TODO(zea): split local state and profile prefs into their own subclasses. + // ---------- Local state prefs ---------- void RegisterBooleanPref(const char* path, bool default_value); void RegisterIntegerPref(const char* path, int default_value); void RegisterDoublePref(const char* path, double default_value); @@ -182,7 +193,6 @@ class PrefService : public base::NonThreadSafe, // These take ownership of the default_value: void RegisterListPref(const char* path, ListValue* default_value); void RegisterDictionaryPref(const char* path, DictionaryValue* default_value); - // These variants use a default value from the locale dll instead. void RegisterLocalizedBooleanPref(const char* path, int locale_default_message_id); @@ -192,6 +202,51 @@ class PrefService : public base::NonThreadSafe, int locale_default_message_id); void RegisterLocalizedStringPref(const char* path, int locale_default_message_id); + void RegisterInt64Pref(const char* path, int64 default_value); + + // ---------- Profile prefs ---------- + // Profile prefs must specify whether the pref should be synchronized across + // machines or not (see PrefSyncStatus enum above). + void RegisterBooleanPref(const char* path, + bool default_value, + PrefSyncStatus sync_status); + void RegisterIntegerPref(const char* path, + int default_value, + PrefSyncStatus sync_status); + void RegisterDoublePref(const char* path, + double default_value, + PrefSyncStatus sync_status); + void RegisterStringPref(const char* path, + const std::string& default_value, + PrefSyncStatus sync_status); + void RegisterFilePathPref(const char* path, + const FilePath& default_value, + PrefSyncStatus sync_status); + void RegisterListPref(const char* path, PrefSyncStatus sync_status); + void RegisterDictionaryPref(const char* path, PrefSyncStatus sync_status); + // These take ownership of the default_value: + void RegisterListPref(const char* path, + ListValue* default_value, + PrefSyncStatus sync_status); + void RegisterDictionaryPref(const char* path, + DictionaryValue* default_value, + PrefSyncStatus sync_status); + // These variants use a default value from the locale dll instead. + void RegisterLocalizedBooleanPref(const char* path, + int locale_default_message_id, + PrefSyncStatus sync_status); + void RegisterLocalizedIntegerPref(const char* path, + int locale_default_message_id, + PrefSyncStatus sync_status); + void RegisterLocalizedDoublePref(const char* path, + int locale_default_message_id, + PrefSyncStatus sync_status); + void RegisterLocalizedStringPref(const char* path, + int locale_default_message_id, + PrefSyncStatus sync_status); + void RegisterInt64Pref(const char* path, + int64 default_value, + PrefSyncStatus sync_status); // If the path is valid and the value at the end of the path matches the type // specified, it will return the specified value. Otherwise, the default @@ -228,7 +283,6 @@ class PrefService : public base::NonThreadSafe, // Value type will be TYPE_STRING. void SetInt64(const char* path, int64 value); int64 GetInt64(const char* path) const; - void RegisterInt64Pref(const char* path, int64 default_value); // Returns true if a value has been set for the specified path. // NOTE: this is NOT the same as FindPreference. In particular @@ -246,6 +300,10 @@ class PrefService : public base::NonThreadSafe, bool ReadOnly() const; + // SyncableService getter. + // TODO(zea): Have PrefService implement SyncableService directly. + SyncableService* GetSyncableService(); + protected: // Construct a new pref service, specifying the pref sources as explicit // PrefStore pointers. This constructor is what CreatePrefService() ends up @@ -308,7 +366,9 @@ class PrefService : public base::NonThreadSafe, // NULL as it determines the preference value's type. // RegisterPreference must not be called twice for the same path. // This method takes ownership of |default_value|. - void RegisterPreference(const char* path, Value* default_value); + void RegisterPreference(const char* path, + Value* default_value, + PrefSyncStatus sync_status); // Sets the value for this pref path in the user pref store and informs the // PrefNotifier of the change. @@ -344,6 +404,9 @@ class PrefService : public base::NonThreadSafe, // is used. PrefServiceDelegate* delegate_; + // The model associator that maintains the links with the sync db. + scoped_ptr<PrefModelAssociator> pref_sync_associator_; + DISALLOW_COPY_AND_ASSIGN(PrefService); }; diff --git a/chrome/browser/prefs/pref_set_observer_unittest.cc b/chrome/browser/prefs/pref_set_observer_unittest.cc index 41dcfe6..49fc507 100644 --- a/chrome/browser/prefs/pref_set_observer_unittest.cc +++ b/chrome/browser/prefs/pref_set_observer_unittest.cc @@ -1,4 +1,4 @@ -// Copyright (c) 2010 The Chromium Authors. All rights reserved. +// Copyright (c) 2011 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. @@ -16,9 +16,15 @@ class PrefSetObserverTest : public testing::Test { public: virtual void SetUp() { pref_service_.reset(new TestingPrefService); - pref_service_->RegisterStringPref(prefs::kHomePage, "http://google.com"); - pref_service_->RegisterBooleanPref(prefs::kHomePageIsNewTabPage, false); - pref_service_->RegisterStringPref(prefs::kApplicationLocale, ""); + pref_service_->RegisterStringPref(prefs::kHomePage, + "http://google.com", + PrefService::UNSYNCABLE_PREF); + pref_service_->RegisterBooleanPref(prefs::kHomePageIsNewTabPage, + false, + PrefService::UNSYNCABLE_PREF); + pref_service_->RegisterStringPref(prefs::kApplicationLocale, + "", + PrefService::UNSYNCABLE_PREF); } PrefSetObserver* CreatePrefSetObserver(NotificationObserver* observer) { diff --git a/chrome/browser/prefs/pref_value_store.cc b/chrome/browser/prefs/pref_value_store.cc index 3318a1d..dbb29ae 100644 --- a/chrome/browser/prefs/pref_value_store.cc +++ b/chrome/browser/prefs/pref_value_store.cc @@ -4,6 +4,7 @@ #include "chrome/browser/prefs/pref_value_store.h" +#include "chrome/browser/prefs/pref_model_associator.h" #include "chrome/browser/prefs/pref_notifier.h" PrefValueStore::PrefStoreKeeper::PrefStoreKeeper() @@ -49,8 +50,10 @@ PrefValueStore::PrefValueStore(PrefStore* managed_platform_prefs, PrefStore* recommended_platform_prefs, PrefStore* recommended_cloud_prefs, PrefStore* default_prefs, + PrefModelAssociator* pref_sync_associator, PrefNotifier* pref_notifier) - : pref_notifier_(pref_notifier) { + : pref_sync_associator_(pref_sync_associator), + pref_notifier_(pref_notifier) { InitPrefStore(MANAGED_PLATFORM_STORE, managed_platform_prefs); InitPrefStore(MANAGED_CLOUD_STORE, managed_cloud_prefs); InitPrefStore(EXTENSION_STORE, extension_prefs); @@ -74,6 +77,7 @@ PrefValueStore* PrefValueStore::CloneAndSpecialize( PrefStore* recommended_platform_prefs, PrefStore* recommended_cloud_prefs, PrefStore* default_prefs, + PrefModelAssociator* pref_sync_associator, PrefNotifier* pref_notifier) { DCHECK(pref_notifier); if (!managed_platform_prefs) @@ -96,7 +100,7 @@ PrefValueStore* PrefValueStore::CloneAndSpecialize( return new PrefValueStore( managed_platform_prefs, managed_cloud_prefs, extension_prefs, command_line_prefs, user_prefs, recommended_platform_prefs, - recommended_cloud_prefs, default_prefs, + recommended_cloud_prefs, default_prefs, pref_sync_associator, pref_notifier); } @@ -129,8 +133,11 @@ void PrefValueStore::NotifyPrefChanged( // If the pref is controlled by a higher-priority store, its effective value // cannot have changed. PrefStoreType controller = ControllingPrefStoreForPref(path); - if (controller == INVALID_STORE || controller >= new_store) + if (controller == INVALID_STORE || controller >= new_store) { pref_notifier_->OnPreferenceChanged(path); + if (pref_sync_associator_) + pref_sync_associator_->ProcessPrefChange(path); + } } bool PrefValueStore::PrefValueInManagedStore(const char* name) const { diff --git a/chrome/browser/prefs/pref_value_store.h b/chrome/browser/prefs/pref_value_store.h index 6a492ba..07a5b61 100644 --- a/chrome/browser/prefs/pref_value_store.h +++ b/chrome/browser/prefs/pref_value_store.h @@ -18,6 +18,7 @@ #include "content/browser/browser_thread.h" class FilePath; +class PrefModelAssociator; class PrefNotifier; class PrefStore; @@ -56,6 +57,7 @@ class PrefValueStore { PrefStore* recommended_platform_prefs, PrefStore* recommended_cloud_prefs, PrefStore* default_prefs, + PrefModelAssociator* pref_sync_associator, PrefNotifier* pref_notifier); virtual ~PrefValueStore(); @@ -69,6 +71,7 @@ class PrefValueStore { PrefStore* recommended_platform_prefs, PrefStore* recommended_cloud_prefs, PrefStore* default_prefs, + PrefModelAssociator* pref_sync_associator, PrefNotifier* pref_notifier); // Gets the value for the given preference name that has the specified value @@ -233,6 +236,9 @@ class PrefValueStore { // Keeps the PrefStore references in order of precedence. PrefStoreKeeper pref_stores_[PREF_STORE_TYPE_MAX + 1]; + // The associator for syncing preferences. + PrefModelAssociator* pref_sync_associator_; + // Used for generating PREF_CHANGED and PREF_INITIALIZATION_COMPLETED // notifications. This is a weak reference, since the notifier is owned by the // corresponding PrefService. diff --git a/chrome/browser/prefs/pref_value_store_unittest.cc b/chrome/browser/prefs/pref_value_store_unittest.cc index 6819e46..17d939c 100644 --- a/chrome/browser/prefs/pref_value_store_unittest.cc +++ b/chrome/browser/prefs/pref_value_store_unittest.cc @@ -9,6 +9,7 @@ #include "base/values.h" #include "chrome/browser/policy/configuration_policy_pref_store.h" #include "chrome/browser/policy/dummy_configuration_policy_provider.h" +#include "chrome/browser/prefs/pref_model_associator.h" #include "chrome/browser/prefs/pref_notifier.h" #include "chrome/browser/prefs/pref_value_store.h" #include "chrome/browser/prefs/testing_pref_store.h" @@ -31,6 +32,12 @@ class MockPrefNotifier : public PrefNotifier { MOCK_METHOD0(OnInitializationCompleted, void()); }; +// Allows to capture sync model associator interaction. +class MockPrefModelAssociator : public PrefModelAssociator { + public: + MOCK_METHOD1(ProcessPrefChange, void(const std::string&)); +}; + } // namespace // Names of the preferences used in this test. @@ -121,6 +128,7 @@ class PrefValueStoreTest : public testing::Test { CreateRecommendedPlatformPrefs(); CreateRecommendedCloudPrefs(); CreateDefaultPrefs(); + sync_associator_.reset(new MockPrefModelAssociator()); // Create a fresh PrefValueStore. pref_value_store_.reset(new PrefValueStore( @@ -132,6 +140,7 @@ class PrefValueStoreTest : public testing::Test { recommended_platform_pref_store_, recommended_cloud_pref_store_, default_pref_store_, + sync_associator_.get(), &pref_notifier_)); } @@ -276,6 +285,7 @@ class PrefValueStoreTest : public testing::Test { } MockPrefNotifier pref_notifier_; + scoped_ptr<MockPrefModelAssociator> sync_associator_; scoped_ptr<PrefValueStore> pref_value_store_; scoped_refptr<TestingPrefStore> managed_platform_pref_store_; @@ -365,11 +375,15 @@ TEST_F(PrefValueStoreTest, GetValue) { TEST_F(PrefValueStoreTest, PrefChanges) { // Check pref controlled by highest-priority store. EXPECT_CALL(pref_notifier_, OnPreferenceChanged(prefs::kManagedPlatformPref)); + EXPECT_CALL(*sync_associator_, + ProcessPrefChange(prefs::kManagedPlatformPref)); managed_platform_pref_store_->NotifyPrefValueChanged( prefs::kManagedPlatformPref); Mock::VerifyAndClearExpectations(&pref_notifier_); + Mock::VerifyAndClearExpectations(sync_associator_.get()); EXPECT_CALL(pref_notifier_, OnPreferenceChanged(_)).Times(0); + EXPECT_CALL(*sync_associator_, ProcessPrefChange(_)).Times(0); managed_cloud_pref_store_->NotifyPrefValueChanged( prefs::kManagedPlatformPref); extension_pref_store_->NotifyPrefValueChanged( @@ -385,29 +399,41 @@ TEST_F(PrefValueStoreTest, PrefChanges) { default_pref_store_->NotifyPrefValueChanged( prefs::kManagedPlatformPref); Mock::VerifyAndClearExpectations(&pref_notifier_); + Mock::VerifyAndClearExpectations(sync_associator_.get()); // Check pref controlled by user store. EXPECT_CALL(pref_notifier_, OnPreferenceChanged(prefs::kUserPref)); + EXPECT_CALL(*sync_associator_, ProcessPrefChange(prefs::kUserPref)); managed_platform_pref_store_->NotifyPrefValueChanged(prefs::kUserPref); Mock::VerifyAndClearExpectations(&pref_notifier_); + Mock::VerifyAndClearExpectations(sync_associator_.get()); EXPECT_CALL(pref_notifier_, OnPreferenceChanged(prefs::kUserPref)); + EXPECT_CALL(*sync_associator_, ProcessPrefChange(prefs::kUserPref)); managed_cloud_pref_store_->NotifyPrefValueChanged(prefs::kUserPref); Mock::VerifyAndClearExpectations(&pref_notifier_); + Mock::VerifyAndClearExpectations(sync_associator_.get()); EXPECT_CALL(pref_notifier_, OnPreferenceChanged(prefs::kUserPref)); + EXPECT_CALL(*sync_associator_, ProcessPrefChange(prefs::kUserPref)); extension_pref_store_->NotifyPrefValueChanged(prefs::kUserPref); Mock::VerifyAndClearExpectations(&pref_notifier_); + Mock::VerifyAndClearExpectations(sync_associator_.get()); EXPECT_CALL(pref_notifier_, OnPreferenceChanged(prefs::kUserPref)); + EXPECT_CALL(*sync_associator_, ProcessPrefChange(prefs::kUserPref)); command_line_pref_store_->NotifyPrefValueChanged(prefs::kUserPref); Mock::VerifyAndClearExpectations(&pref_notifier_); + Mock::VerifyAndClearExpectations(sync_associator_.get()); EXPECT_CALL(pref_notifier_, OnPreferenceChanged(prefs::kUserPref)); + EXPECT_CALL(*sync_associator_, ProcessPrefChange(prefs::kUserPref)); user_pref_store_->NotifyPrefValueChanged(prefs::kUserPref); Mock::VerifyAndClearExpectations(&pref_notifier_); + Mock::VerifyAndClearExpectations(sync_associator_.get()); EXPECT_CALL(pref_notifier_, OnPreferenceChanged(_)).Times(0); + EXPECT_CALL(*sync_associator_, ProcessPrefChange(_)).Times(0); recommended_platform_pref_store_->NotifyPrefValueChanged( prefs::kUserPref); recommended_cloud_pref_store_->NotifyPrefValueChanged( @@ -415,39 +441,56 @@ TEST_F(PrefValueStoreTest, PrefChanges) { default_pref_store_->NotifyPrefValueChanged( prefs::kUserPref); Mock::VerifyAndClearExpectations(&pref_notifier_); + Mock::VerifyAndClearExpectations(sync_associator_.get()); // Check pref controlled by default-pref store. EXPECT_CALL(pref_notifier_, OnPreferenceChanged(prefs::kDefaultPref)); + EXPECT_CALL(*sync_associator_, ProcessPrefChange(prefs::kDefaultPref)); managed_platform_pref_store_->NotifyPrefValueChanged(prefs::kDefaultPref); Mock::VerifyAndClearExpectations(&pref_notifier_); + Mock::VerifyAndClearExpectations(sync_associator_.get()); EXPECT_CALL(pref_notifier_, OnPreferenceChanged(prefs::kDefaultPref)); + EXPECT_CALL(*sync_associator_, ProcessPrefChange(prefs::kDefaultPref)); managed_cloud_pref_store_->NotifyPrefValueChanged(prefs::kDefaultPref); Mock::VerifyAndClearExpectations(&pref_notifier_); + Mock::VerifyAndClearExpectations(sync_associator_.get()); EXPECT_CALL(pref_notifier_, OnPreferenceChanged(prefs::kDefaultPref)); + EXPECT_CALL(*sync_associator_, ProcessPrefChange(prefs::kDefaultPref)); extension_pref_store_->NotifyPrefValueChanged(prefs::kDefaultPref); Mock::VerifyAndClearExpectations(&pref_notifier_); + Mock::VerifyAndClearExpectations(sync_associator_.get()); EXPECT_CALL(pref_notifier_, OnPreferenceChanged(prefs::kDefaultPref)); + EXPECT_CALL(*sync_associator_, ProcessPrefChange(prefs::kDefaultPref)); command_line_pref_store_->NotifyPrefValueChanged(prefs::kDefaultPref); Mock::VerifyAndClearExpectations(&pref_notifier_); + Mock::VerifyAndClearExpectations(sync_associator_.get()); EXPECT_CALL(pref_notifier_, OnPreferenceChanged(prefs::kDefaultPref)); + EXPECT_CALL(*sync_associator_, ProcessPrefChange(prefs::kDefaultPref)); user_pref_store_->NotifyPrefValueChanged(prefs::kDefaultPref); Mock::VerifyAndClearExpectations(&pref_notifier_); + Mock::VerifyAndClearExpectations(sync_associator_.get()); EXPECT_CALL(pref_notifier_, OnPreferenceChanged(prefs::kDefaultPref)); + EXPECT_CALL(*sync_associator_, ProcessPrefChange(prefs::kDefaultPref)); recommended_platform_pref_store_->NotifyPrefValueChanged(prefs::kDefaultPref); Mock::VerifyAndClearExpectations(&pref_notifier_); + Mock::VerifyAndClearExpectations(sync_associator_.get()); EXPECT_CALL(pref_notifier_, OnPreferenceChanged(prefs::kDefaultPref)); + EXPECT_CALL(*sync_associator_, ProcessPrefChange(prefs::kDefaultPref)); recommended_cloud_pref_store_->NotifyPrefValueChanged(prefs::kDefaultPref); Mock::VerifyAndClearExpectations(&pref_notifier_); + Mock::VerifyAndClearExpectations(sync_associator_.get()); EXPECT_CALL(pref_notifier_, OnPreferenceChanged(prefs::kDefaultPref)); + EXPECT_CALL(*sync_associator_, ProcessPrefChange(prefs::kDefaultPref)); default_pref_store_->NotifyPrefValueChanged(prefs::kDefaultPref); Mock::VerifyAndClearExpectations(&pref_notifier_); + Mock::VerifyAndClearExpectations(sync_associator_.get()); } TEST_F(PrefValueStoreTest, OnInitializationCompleted) { diff --git a/chrome/browser/prefs/scoped_user_pref_update_unittest.cc b/chrome/browser/prefs/scoped_user_pref_update_unittest.cc index 88faebe..f68452d 100644 --- a/chrome/browser/prefs/scoped_user_pref_update_unittest.cc +++ b/chrome/browser/prefs/scoped_user_pref_update_unittest.cc @@ -18,7 +18,7 @@ class ScopedUserPrefUpdateTest : public testing::Test { protected: virtual void SetUp() { - prefs_.RegisterDictionaryPref(kPref); + prefs_.RegisterDictionaryPref(kPref, PrefService::UNSYNCABLE_PREF); registrar_.Init(&prefs_); registrar_.Add(kPref, &observer_); } diff --git a/chrome/browser/prefs/session_startup_pref.cc b/chrome/browser/prefs/session_startup_pref.cc index de5cf76..59e262f 100644 --- a/chrome/browser/prefs/session_startup_pref.cc +++ b/chrome/browser/prefs/session_startup_pref.cc @@ -46,8 +46,11 @@ SessionStartupPref::Type PrefValueToType(int pref_value) { // static void SessionStartupPref::RegisterUserPrefs(PrefService* prefs) { prefs->RegisterIntegerPref(prefs::kRestoreOnStartup, - TypeToPrefValue(browser_defaults::kDefaultSessionStartupType)); - prefs->RegisterListPref(prefs::kURLsToRestoreOnStartup); + TypeToPrefValue( + browser_defaults::kDefaultSessionStartupType), + PrefService::SYNCABLE_PREF); + prefs->RegisterListPref(prefs::kURLsToRestoreOnStartup, + PrefService::SYNCABLE_PREF); } // static diff --git a/chrome/browser/printing/cloud_print/cloud_print_url.cc b/chrome/browser/printing/cloud_print/cloud_print_url.cc index a36cc51..c6e8c7c 100644 --- a/chrome/browser/printing/cloud_print/cloud_print_url.cc +++ b/chrome/browser/printing/cloud_print/cloud_print_url.cc @@ -24,7 +24,8 @@ void CloudPrintURL::RegisterPreferences() { if (pref_service->FindPreference(prefs::kCloudPrintServiceURL)) return; pref_service->RegisterStringPref(prefs::kCloudPrintServiceURL, - kDefaultCloudPrintServiceURL); + kDefaultCloudPrintServiceURL, + PrefService::UNSYNCABLE_PREF); } // Returns the root service URL for the cloud print service. The default is to diff --git a/chrome/browser/printing/print_dialog_cloud.cc b/chrome/browser/printing/print_dialog_cloud.cc index 64c2fea..052aa9a 100644 --- a/chrome/browser/printing/print_dialog_cloud.cc +++ b/chrome/browser/printing/print_dialog_cloud.cc @@ -533,11 +533,13 @@ void CreateDialogImpl(const FilePath& path_to_file, DCHECK(pref_service); if (!pref_service->FindPreference(prefs::kCloudPrintDialogWidth)) { pref_service->RegisterIntegerPref(prefs::kCloudPrintDialogWidth, - kDefaultWidth); + kDefaultWidth, + PrefService::UNSYNCABLE_PREF); } if (!pref_service->FindPreference(prefs::kCloudPrintDialogHeight)) { pref_service->RegisterIntegerPref(prefs::kCloudPrintDialogHeight, - kDefaultHeight); + kDefaultHeight, + PrefService::UNSYNCABLE_PREF); } int width = pref_service->GetInteger(prefs::kCloudPrintDialogWidth); diff --git a/chrome/browser/profiles/profile.cc b/chrome/browser/profiles/profile.cc index f83b7f2..a2c0d6f 100644 --- a/chrome/browser/profiles/profile.cc +++ b/chrome/browser/profiles/profile.cc @@ -96,37 +96,68 @@ const ProfileId Profile::kInvalidProfileId = static_cast<ProfileId>(0); // static void Profile::RegisterUserPrefs(PrefService* prefs) { - prefs->RegisterBooleanPref(prefs::kSearchSuggestEnabled, true); - prefs->RegisterBooleanPref(prefs::kSessionExitedCleanly, true); - prefs->RegisterBooleanPref(prefs::kSafeBrowsingEnabled, true); - prefs->RegisterBooleanPref(prefs::kSafeBrowsingReportingEnabled, false); + prefs->RegisterBooleanPref(prefs::kSearchSuggestEnabled, + true, + PrefService::SYNCABLE_PREF); + prefs->RegisterBooleanPref(prefs::kSessionExitedCleanly, + true, + PrefService::UNSYNCABLE_PREF); + prefs->RegisterBooleanPref(prefs::kSafeBrowsingEnabled, + true, + PrefService::SYNCABLE_PREF); + prefs->RegisterBooleanPref(prefs::kSafeBrowsingReportingEnabled, + false, + PrefService::UNSYNCABLE_PREF); // TODO(estade): IDS_SPELLCHECK_DICTIONARY should be an ASCII string. prefs->RegisterLocalizedStringPref(prefs::kSpellCheckDictionary, - IDS_SPELLCHECK_DICTIONARY); - prefs->RegisterBooleanPref(prefs::kEnableSpellCheck, true); - prefs->RegisterBooleanPref(prefs::kEnableAutoSpellCorrect, true); + IDS_SPELLCHECK_DICTIONARY, + PrefService::UNSYNCABLE_PREF); + prefs->RegisterBooleanPref(prefs::kEnableSpellCheck, + true, + PrefService::SYNCABLE_PREF); + prefs->RegisterBooleanPref(prefs::kEnableAutoSpellCorrect, + true, + PrefService::UNSYNCABLE_PREF); #if defined(TOOLKIT_USES_GTK) prefs->RegisterBooleanPref(prefs::kUsesSystemTheme, - GtkThemeService::DefaultUsesSystemTheme()); + GtkThemeService::DefaultUsesSystemTheme(), + PrefService::UNSYNCABLE_PREF); #endif - prefs->RegisterFilePathPref(prefs::kCurrentThemePackFilename, FilePath()); + prefs->RegisterFilePathPref(prefs::kCurrentThemePackFilename, + FilePath(), + PrefService::UNSYNCABLE_PREF); prefs->RegisterStringPref(prefs::kCurrentThemeID, - ThemeService::kDefaultThemeID); - prefs->RegisterDictionaryPref(prefs::kCurrentThemeImages); - prefs->RegisterDictionaryPref(prefs::kCurrentThemeColors); - prefs->RegisterDictionaryPref(prefs::kCurrentThemeTints); - prefs->RegisterDictionaryPref(prefs::kCurrentThemeDisplayProperties); - prefs->RegisterBooleanPref(prefs::kDisableExtensions, false); - prefs->RegisterStringPref(prefs::kSelectFileLastDirectory, ""); + ThemeService::kDefaultThemeID, + PrefService::UNSYNCABLE_PREF); + prefs->RegisterDictionaryPref(prefs::kCurrentThemeImages, + PrefService::UNSYNCABLE_PREF); + prefs->RegisterDictionaryPref(prefs::kCurrentThemeColors, + PrefService::UNSYNCABLE_PREF); + prefs->RegisterDictionaryPref(prefs::kCurrentThemeTints, + PrefService::UNSYNCABLE_PREF); + prefs->RegisterDictionaryPref(prefs::kCurrentThemeDisplayProperties, + PrefService::UNSYNCABLE_PREF); + prefs->RegisterBooleanPref(prefs::kDisableExtensions, + false, + PrefService::UNSYNCABLE_PREF); + prefs->RegisterStringPref(prefs::kSelectFileLastDirectory, + "", + PrefService::UNSYNCABLE_PREF); #if defined(OS_CHROMEOS) // TODO(dilmah): For OS_CHROMEOS we maintain kApplicationLocale in both // local state and user's profile. For other platforms we maintain // kApplicationLocale only in local state. // In the future we may want to maintain kApplicationLocale // in user's profile for other platforms as well. - prefs->RegisterStringPref(prefs::kApplicationLocale, ""); - prefs->RegisterStringPref(prefs::kApplicationLocaleBackup, ""); - prefs->RegisterStringPref(prefs::kApplicationLocaleAccepted, ""); + prefs->RegisterStringPref(prefs::kApplicationLocale, + "", + PrefService::SYNCABLE_PREF); + prefs->RegisterStringPref(prefs::kApplicationLocaleBackup, + "", + PrefService::UNSYNCABLE_PREF); + prefs->RegisterStringPref(prefs::kApplicationLocaleAccepted, + "", + PrefService::UNSYNCABLE_PREF); #endif } diff --git a/chrome/browser/profiles/profile_impl.cc b/chrome/browser/profiles/profile_impl.cc index 8f56eef..216eed9 100644 --- a/chrome/browser/profiles/profile_impl.cc +++ b/chrome/browser/profiles/profile_impl.cc @@ -257,8 +257,12 @@ Profile* Profile::CreateProfileAsync(const FilePath&path, // static void ProfileImpl::RegisterUserPrefs(PrefService* prefs) { - prefs->RegisterBooleanPref(prefs::kSavingBrowserHistoryDisabled, false); - prefs->RegisterBooleanPref(prefs::kClearSiteDataOnExit, false); + prefs->RegisterBooleanPref(prefs::kSavingBrowserHistoryDisabled, + false, + PrefService::UNSYNCABLE_PREF); + prefs->RegisterBooleanPref(prefs::kClearSiteDataOnExit, + false, + PrefService::SYNCABLE_PREF); } ProfileImpl::ProfileImpl(const FilePath& path, diff --git a/chrome/browser/search_engines/template_url_model.cc b/chrome/browser/search_engines/template_url_model.cc index a2def18..75886a3 100644 --- a/chrome/browser/search_engines/template_url_model.cc +++ b/chrome/browser/search_engines/template_url_model.cc @@ -589,26 +589,36 @@ void TemplateURLModel::Observe(NotificationType type, // static void TemplateURLModel::RegisterUserPrefs(PrefService* prefs) { - prefs->RegisterBooleanPref( - prefs::kDefaultSearchProviderEnabled, true); - prefs->RegisterStringPref( - prefs::kDefaultSearchProviderName, std::string()); - prefs->RegisterStringPref( - prefs::kDefaultSearchProviderID, std::string()); - prefs->RegisterStringPref( - prefs::kDefaultSearchProviderPrepopulateID, std::string()); - prefs->RegisterStringPref( - prefs::kDefaultSearchProviderSuggestURL, std::string()); - prefs->RegisterStringPref( - prefs::kDefaultSearchProviderSearchURL, std::string()); - prefs->RegisterStringPref( - prefs::kDefaultSearchProviderInstantURL, std::string()); - prefs->RegisterStringPref( - prefs::kDefaultSearchProviderKeyword, std::string()); - prefs->RegisterStringPref( - prefs::kDefaultSearchProviderIconURL, std::string()); - prefs->RegisterStringPref( - prefs::kDefaultSearchProviderEncodings, std::string()); + prefs->RegisterBooleanPref(prefs::kDefaultSearchProviderEnabled, + true, + PrefService::UNSYNCABLE_PREF); + prefs->RegisterStringPref(prefs::kDefaultSearchProviderName, + std::string(), + PrefService::UNSYNCABLE_PREF); + prefs->RegisterStringPref(prefs::kDefaultSearchProviderID, + std::string(), + PrefService::UNSYNCABLE_PREF); + prefs->RegisterStringPref(prefs::kDefaultSearchProviderPrepopulateID, + std::string(), + PrefService::UNSYNCABLE_PREF); + prefs->RegisterStringPref(prefs::kDefaultSearchProviderSuggestURL, + std::string(), + PrefService::UNSYNCABLE_PREF); + prefs->RegisterStringPref(prefs::kDefaultSearchProviderSearchURL, + std::string(), + PrefService::UNSYNCABLE_PREF); + prefs->RegisterStringPref(prefs::kDefaultSearchProviderInstantURL, + std::string(), + PrefService::UNSYNCABLE_PREF); + prefs->RegisterStringPref(prefs::kDefaultSearchProviderKeyword, + std::string(), + PrefService::UNSYNCABLE_PREF); + prefs->RegisterStringPref(prefs::kDefaultSearchProviderIconURL, + std::string(), + PrefService::UNSYNCABLE_PREF); + prefs->RegisterStringPref(prefs::kDefaultSearchProviderEncodings, + std::string(), + PrefService::UNSYNCABLE_PREF); } void TemplateURLModel::SetKeywordSearchTermsForURL(const TemplateURL* t_url, diff --git a/chrome/browser/search_engines/template_url_prepopulate_data.cc b/chrome/browser/search_engines/template_url_prepopulate_data.cc index 4498c48..e19384e 100644 --- a/chrome/browser/search_engines/template_url_prepopulate_data.cc +++ b/chrome/browser/search_engines/template_url_prepopulate_data.cc @@ -3341,11 +3341,18 @@ void GetPrepopulationSetFromCountryID(PrefService* prefs, namespace TemplateURLPrepopulateData { void RegisterUserPrefs(PrefService* prefs) { - prefs->RegisterIntegerPref(prefs::kCountryIDAtInstall, kCountryIDUnknown); - prefs->RegisterListPref(prefs::kSearchProviderOverrides); - prefs->RegisterIntegerPref(prefs::kSearchProviderOverridesVersion, -1); + prefs->RegisterIntegerPref(prefs::kCountryIDAtInstall, + kCountryIDUnknown, + PrefService::UNSYNCABLE_PREF); + prefs->RegisterListPref(prefs::kSearchProviderOverrides, + PrefService::UNSYNCABLE_PREF); + prefs->RegisterIntegerPref(prefs::kSearchProviderOverridesVersion, + -1, + PrefService::UNSYNCABLE_PREF); // Obsolete pref, for migration. - prefs->RegisterIntegerPref(prefs::kGeoIDAtInstall, -1); + prefs->RegisterIntegerPref(prefs::kGeoIDAtInstall, + -1, + PrefService::UNSYNCABLE_PREF); } int GetDataVersion(PrefService* prefs) { diff --git a/chrome/browser/sync/abstract_profile_sync_service_test.cc b/chrome/browser/sync/abstract_profile_sync_service_test.cc index 355437b..366230b 100644 --- a/chrome/browser/sync/abstract_profile_sync_service_test.cc +++ b/chrome/browser/sync/abstract_profile_sync_service_test.cc @@ -5,12 +5,6 @@ #include "chrome/browser/sync/abstract_profile_sync_service_test.h" #include "chrome/browser/sync/engine/syncapi.h" -#include "chrome/browser/sync/glue/autofill_model_associator.h" -#include "chrome/browser/sync/glue/autofill_profile_model_associator.h" -#include "chrome/browser/sync/glue/password_model_associator.h" -#include "chrome/browser/sync/glue/preference_model_associator.h" -#include "chrome/browser/sync/glue/session_model_associator.h" -#include "chrome/browser/sync/glue/typed_url_model_associator.h" #include "chrome/browser/sync/protocol/sync.pb.h" #include "chrome/browser/sync/syncable/directory_manager.h" #include "chrome/browser/sync/syncable/syncable.h" @@ -39,27 +33,7 @@ using syncable::WriteTransaction; const std::string ProfileSyncServiceTestHelper::GetTagForType( ModelType model_type) { - switch (model_type) { - case syncable::AUTOFILL: - return browser_sync::kAutofillTag; - case syncable::AUTOFILL_PROFILE: - return browser_sync::kAutofillProfileTag; - case syncable::PREFERENCES: - return browser_sync::kPreferencesTag; - case syncable::PASSWORDS: - return browser_sync::kPasswordTag; - case syncable::NIGORI: - return browser_sync::kNigoriTag; - case syncable::TYPED_URLS: - return browser_sync::kTypedUrlTag; - case syncable::SESSIONS: - return browser_sync::kSessionsTag; - case syncable::BOOKMARKS: - return "google_chrome_bookmarks"; - default: - NOTREACHED(); - } - return std::string(); + return syncable::ModelTypeToRootTag(model_type); } bool ProfileSyncServiceTestHelper::CreateRoot( diff --git a/chrome/browser/sync/glue/app_data_type_controller.cc b/chrome/browser/sync/glue/app_data_type_controller.cc index cf025f6..5be7863 100644 --- a/chrome/browser/sync/glue/app_data_type_controller.cc +++ b/chrome/browser/sync/glue/app_data_type_controller.cc @@ -35,9 +35,8 @@ void AppDataTypeController::CreateSyncComponents() { ProfileSyncFactory::SyncComponents sync_components = profile_sync_factory_->CreateAppSyncComponents(sync_service_, this); - model_associator_.reset(sync_components.model_associator); - change_processor_.reset(sync_components.change_processor); -} + set_model_associator(sync_components.model_associator); + set_change_processor(sync_components.change_processor);} void AppDataTypeController::RecordUnrecoverableError( const tracked_objects::Location& from_here, diff --git a/chrome/browser/sync/glue/bookmark_data_type_controller.cc b/chrome/browser/sync/glue/bookmark_data_type_controller.cc index 4415240..7819468 100644 --- a/chrome/browser/sync/glue/bookmark_data_type_controller.cc +++ b/chrome/browser/sync/glue/bookmark_data_type_controller.cc @@ -65,8 +65,8 @@ syncable::ModelType BookmarkDataTypeController::type() const { void BookmarkDataTypeController::CreateSyncComponents() { ProfileSyncFactory::SyncComponents sync_components = profile_sync_factory_-> CreateBookmarkSyncComponents(sync_service_, this); - model_associator_.reset(sync_components.model_associator); - change_processor_.reset(sync_components.change_processor); + set_model_associator(sync_components.model_associator); + set_change_processor(sync_components.change_processor); } void BookmarkDataTypeController::RecordUnrecoverableError( diff --git a/chrome/browser/sync/glue/change_processor.cc b/chrome/browser/sync/glue/change_processor.cc index f779070..dcf7800 100644 --- a/chrome/browser/sync/glue/change_processor.cc +++ b/chrome/browser/sync/glue/change_processor.cc @@ -1,4 +1,4 @@ -// Copyright (c) 2006-2009 The Chromium Authors. All rights reserved. +// Copyright (c) 2011 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. @@ -7,6 +7,11 @@ namespace browser_sync { +ChangeProcessor::ChangeProcessor(UnrecoverableErrorHandler* error_handler) + : running_(false), + error_handler_(error_handler), + share_handle_(NULL) {} + ChangeProcessor::~ChangeProcessor() { DCHECK(!running_) << "ChangeProcessor dtor while running"; } @@ -31,4 +36,15 @@ bool ChangeProcessor::IsRunning() const { return running_; } +// Not implemented by default. +void ChangeProcessor::CommitChangesFromSyncModel() {} + +UnrecoverableErrorHandler* ChangeProcessor::error_handler() { + return error_handler_; +} + +sync_api::UserShare* ChangeProcessor::share_handle() { + return share_handle_; +} + } // namespace browser_sync diff --git a/chrome/browser/sync/glue/change_processor.h b/chrome/browser/sync/glue/change_processor.h index 3e8a467..b698809 100644 --- a/chrome/browser/sync/glue/change_processor.h +++ b/chrome/browser/sync/glue/change_processor.h @@ -1,4 +1,4 @@ -// Copyright (c) 2006-2009 The Chromium Authors. All rights reserved. +// Copyright (c) 2011 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. @@ -20,8 +20,7 @@ class UnrecoverableErrorHandler; // native model. This does not currently distinguish between model data types. class ChangeProcessor { public: - explicit ChangeProcessor(UnrecoverableErrorHandler* error_handler) - : running_(false), error_handler_(error_handler), share_handle_(NULL) {} + explicit ChangeProcessor(UnrecoverableErrorHandler* error_handler); virtual ~ChangeProcessor(); // Call when the processor should accept changes from either provided model @@ -45,11 +44,13 @@ class ChangeProcessor { int change_count) = 0; // The changes found in ApplyChangesFromSyncModel may be too slow to be - // performed while holding a [Read/Write]Transaction lock. This function - // is called once the lock is released and performs any slow I/O operations - // without unnecessarily slowing the UI. Note that not all datatypes need - // this, so we provide an empty default version. - virtual void CommitChangesFromSyncModel() { } + // performed while holding a [Read/Write]Transaction lock or may interact + // with another thread, which might itself be waiting on the transaction lock, + // putting us at risk of deadlock. + // This function is called once the transactional lock is released and it is + // safe to perform inter-thread or slow I/O operations. Note that not all + // datatypes need this, so we provide an empty default version. + virtual void CommitChangesFromSyncModel(); protected: // These methods are invoked by Start() and Stop() to do @@ -58,8 +59,8 @@ class ChangeProcessor { virtual void StopImpl() = 0; bool running() { return running_; } - UnrecoverableErrorHandler* error_handler() { return error_handler_; } - sync_api::UserShare* share_handle() { return share_handle_; } + UnrecoverableErrorHandler* error_handler(); + sync_api::UserShare* share_handle(); private: bool running_; // True if we have been told it is safe to process changes. diff --git a/chrome/browser/sync/glue/extension_data_type_controller.cc b/chrome/browser/sync/glue/extension_data_type_controller.cc index 07d4d1c..11f4a72 100644 --- a/chrome/browser/sync/glue/extension_data_type_controller.cc +++ b/chrome/browser/sync/glue/extension_data_type_controller.cc @@ -35,8 +35,8 @@ void ExtensionDataTypeController::CreateSyncComponents() { ProfileSyncFactory::SyncComponents sync_components = profile_sync_factory_->CreateExtensionSyncComponents(sync_service_, this); - model_associator_.reset(sync_components.model_associator); - change_processor_.reset(sync_components.change_processor); + set_model_associator(sync_components.model_associator); + set_change_processor(sync_components.change_processor); } void ExtensionDataTypeController::RecordUnrecoverableError( diff --git a/chrome/browser/sync/glue/frontend_data_type_controller.cc b/chrome/browser/sync/glue/frontend_data_type_controller.cc index edec12c..ca1ed73 100644 --- a/chrome/browser/sync/glue/frontend_data_type_controller.cc +++ b/chrome/browser/sync/glue/frontend_data_type_controller.cc @@ -78,19 +78,19 @@ bool FrontendDataTypeController::Associate() { DCHECK_EQ(state_, ASSOCIATING); CreateSyncComponents(); - if (!model_associator_->CryptoReadyIfNecessary()) { + if (!model_associator()->CryptoReadyIfNecessary()) { StartFailed(NEEDS_CRYPTO, FROM_HERE); return false; } bool sync_has_nodes = false; - if (!model_associator_->SyncModelHasUserCreatedNodes(&sync_has_nodes)) { + if (!model_associator()->SyncModelHasUserCreatedNodes(&sync_has_nodes)) { StartFailed(UNRECOVERABLE_ERROR, FROM_HERE); return false; } base::TimeTicks start_time = base::TimeTicks::Now(); - bool merge_success = model_associator_->AssociateModels(); + bool merge_success = model_associator()->AssociateModels(); RecordAssociationTime(base::TimeTicks::Now() - start_time); if (!merge_success) { StartFailed(ASSOCIATION_FAILED, FROM_HERE); @@ -107,7 +107,7 @@ void FrontendDataTypeController::StartFailed(StartResult result, const tracked_objects::Location& location) { DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); CleanUpState(); - model_associator_.reset(); + set_model_associator(NULL); change_processor_.reset(); state_ = NOT_RUNNING; RecordStartFailure(result); @@ -144,14 +144,14 @@ void FrontendDataTypeController::Stop() { CleanUpState(); - if (change_processor_ != NULL) + if (change_processor_.get()) sync_service_->DeactivateDataType(this, change_processor_.get()); - if (model_associator_ != NULL) - model_associator_->DisassociateModels(); + if (model_associator()) + model_associator()->DisassociateModels(); + set_model_associator(NULL); change_processor_.reset(); - model_associator_.reset(); state_ = NOT_RUNNING; } @@ -181,4 +181,22 @@ void FrontendDataTypeController::OnUnrecoverableError( sync_service_->OnUnrecoverableError(from_here, message); } +AssociatorInterface* FrontendDataTypeController::model_associator() const { + return model_associator_.get(); +} + +void FrontendDataTypeController::set_model_associator( + AssociatorInterface* model_associator) { + model_associator_.reset(model_associator); +} + +ChangeProcessor* FrontendDataTypeController::change_processor() const { + return change_processor_.get(); +} + +void FrontendDataTypeController::set_change_processor( + ChangeProcessor* change_processor) { + change_processor_.reset(change_processor); +} + } // namespace browser_sync diff --git a/chrome/browser/sync/glue/frontend_data_type_controller.h b/chrome/browser/sync/glue/frontend_data_type_controller.h index 6a2d863..86c3e60 100644 --- a/chrome/browser/sync/glue/frontend_data_type_controller.h +++ b/chrome/browser/sync/glue/frontend_data_type_controller.h @@ -55,6 +55,7 @@ class FrontendDataTypeController : public DataTypeController { // UnrecoverableErrorHandler interface. virtual void OnUnrecoverableError(const tracked_objects::Location& from_here, const std::string& message); + protected: // For testing only. FrontendDataTypeController(); @@ -100,6 +101,11 @@ class FrontendDataTypeController : public DataTypeController { // Record causes of start failure. virtual void RecordStartFailure(StartResult result) = 0; + virtual AssociatorInterface* model_associator() const; + virtual void set_model_associator(AssociatorInterface* associator); + virtual ChangeProcessor* change_processor() const; + virtual void set_change_processor(ChangeProcessor* processor); + ProfileSyncFactory* const profile_sync_factory_; Profile* const profile_; ProfileSyncService* const sync_service_; @@ -107,6 +113,8 @@ class FrontendDataTypeController : public DataTypeController { State state_; scoped_ptr<StartCallback> start_callback_; + // TODO(sync): transition all datatypes to SyncableService and deprecate + // AssociatorInterface. scoped_ptr<AssociatorInterface> model_associator_; scoped_ptr<ChangeProcessor> change_processor_; diff --git a/chrome/browser/sync/glue/frontend_data_type_controller_mock.h b/chrome/browser/sync/glue/frontend_data_type_controller_mock.h index a32f3f5..783b203 100644 --- a/chrome/browser/sync/glue/frontend_data_type_controller_mock.h +++ b/chrome/browser/sync/glue/frontend_data_type_controller_mock.h @@ -36,6 +36,10 @@ class FrontendDataTypeControllerMock : public FrontendDataTypeController { MOCK_METHOD2(FinishStart, void(StartResult result, const tracked_objects::Location& from_here)); MOCK_METHOD0(CleanUpState, void()); + MOCK_CONST_METHOD0(model_associator, AssociatorInterface*()); + MOCK_METHOD1(set_model_associator, void(AssociatorInterface* associator)); + MOCK_CONST_METHOD0(change_processor, ChangeProcessor*()); + MOCK_METHOD1(set_change_processor, void(ChangeProcessor* processor)); MOCK_METHOD2(RecordUnrecoverableError, void(const tracked_objects::Location&, const std::string&)); MOCK_METHOD1(RecordAssociationTime, void(base::TimeDelta time)); diff --git a/chrome/browser/sync/glue/generic_change_processor.cc b/chrome/browser/sync/glue/generic_change_processor.cc new file mode 100644 index 0000000..dabf031 --- /dev/null +++ b/chrome/browser/sync/glue/generic_change_processor.cc @@ -0,0 +1,35 @@ +// Copyright (c) 2011 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 "chrome/browser/sync/glue/generic_change_processor.h" + +#include "chrome/browser/sync/glue/model_associator.h" +#include "chrome/browser/sync/syncable_service.h" + +namespace browser_sync { + +GenericChangeProcessor::GenericChangeProcessor( + SyncableService* local_service, + UnrecoverableErrorHandler* error_handler) + : ChangeProcessor(error_handler), + local_service_(local_service) { + DCHECK(local_service_); +} +GenericChangeProcessor::~GenericChangeProcessor() { + // Set to null to ensure it's not used after destruction. + local_service_ = NULL; +} + +void GenericChangeProcessor::ApplyChangesFromSyncModel( + const sync_api::BaseTransaction* trans, + const sync_api::SyncManager::ChangeRecord* changes, + int change_count) { + local_service_->ApplyChangesFromSync(trans, changes, change_count); +} + +void GenericChangeProcessor::StartImpl(Profile* profile) {} + +void GenericChangeProcessor::StopImpl() {} + +} // namespace browser_sync diff --git a/chrome/browser/sync/glue/generic_change_processor.h b/chrome/browser/sync/glue/generic_change_processor.h new file mode 100644 index 0000000..a5547c2 --- /dev/null +++ b/chrome/browser/sync/glue/generic_change_processor.h @@ -0,0 +1,41 @@ +// Copyright (c) 2011 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. + +#ifndef CHROME_BROWSER_SYNC_GLUE_GENERIC_CHANGE_PROCESSOR_H_ +#define CHROME_BROWSER_SYNC_GLUE_GENERIC_CHANGE_PROCESSOR_H_ +#pragma once + +#include "chrome/browser/sync/glue/change_processor.h" + +class SyncableService; + +namespace browser_sync { + +// TODO(sync): Have this become a SyncableService implementation and deprecate +// ChangeProcessor. +// For now, it acts as a dummy change processor that just passes all +// ApplySyncChanges commands onto the local SyncableService.. +class GenericChangeProcessor : public ChangeProcessor { + public: + GenericChangeProcessor(SyncableService* local_service, + UnrecoverableErrorHandler* error_handler); + ~GenericChangeProcessor(); + + // ChangeProcessor interface. + // Just passes all arguments onto the |local_service_| + virtual void ApplyChangesFromSyncModel( + const sync_api::BaseTransaction* trans, + const sync_api::SyncManager::ChangeRecord* changes, + int change_count); + protected: + // ChangeProcessor interface. + virtual void StartImpl(Profile* profile); // Not implemented. + virtual void StopImpl(); // Not implemented. + private: + SyncableService* local_service_; +}; + +} // namespace browser_sync + +#endif // CHROME_BROWSER_SYNC_GLUE_GENERIC_CHANGE_PROCESSOR_H_ diff --git a/chrome/browser/sync/glue/non_frontend_data_type_controller.cc b/chrome/browser/sync/glue/non_frontend_data_type_controller.cc index d26baef..661583b 100644 --- a/chrome/browser/sync/glue/non_frontend_data_type_controller.cc +++ b/chrome/browser/sync/glue/non_frontend_data_type_controller.cc @@ -194,7 +194,7 @@ void NonFrontendDataTypeController::Stop() { // Deactivate the change processor on the UI thread. We dont want to listen // for any more changes or process them from server. - if (change_processor_ != NULL) + if (change_processor_.get()) profile_sync_service_->DeactivateDataType(this, change_processor_.get()); if (StopAssociationAsync()) { @@ -215,10 +215,10 @@ void NonFrontendDataTypeController::StopModels() { void NonFrontendDataTypeController::StopAssociation() { DCHECK(!BrowserThread::CurrentlyOn(BrowserThread::UI)); - if (model_associator_ != NULL) + if (model_associator_.get()) model_associator_->DisassociateModels(); - change_processor_.reset(); model_associator_.reset(); + change_processor_.reset(); datatype_stopped_.Signal(); } diff --git a/chrome/browser/sync/glue/preference_change_processor.cc b/chrome/browser/sync/glue/preference_change_processor.cc deleted file mode 100644 index 6a6840b..0000000 --- a/chrome/browser/sync/glue/preference_change_processor.cc +++ /dev/null @@ -1,228 +0,0 @@ -// Copyright (c) 2011 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 "chrome/browser/sync/glue/preference_change_processor.h" - -#include <set> -#include <string> - -#include "base/auto_reset.h" -#include "base/json/json_reader.h" -#include "base/utf_string_conversions.h" -#include "chrome/browser/profiles/profile.h" -#include "chrome/browser/sync/glue/preference_model_associator.h" -#include "chrome/browser/sync/profile_sync_service.h" -#include "chrome/browser/sync/protocol/preference_specifics.pb.h" -#include "chrome/common/pref_names.h" -#include "content/browser/browser_thread.h" -#include "content/common/json_value_serializer.h" -#include "content/common/notification_details.h" -#include "content/common/notification_source.h" - -namespace browser_sync { - -PreferenceChangeProcessor::PreferenceChangeProcessor( - PreferenceModelAssociator* model_associator, - UnrecoverableErrorHandler* error_handler) - : ChangeProcessor(error_handler), - pref_service_(NULL), - model_associator_(model_associator), - processing_pref_change_(false) { - DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); - DCHECK(model_associator); - DCHECK(error_handler); -} - -PreferenceChangeProcessor::~PreferenceChangeProcessor() { - DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); -} - -void PreferenceChangeProcessor::Observe(NotificationType type, - const NotificationSource& source, - const NotificationDetails& details) { - DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); - DCHECK(running()); - DCHECK(NotificationType::PREF_CHANGED == type); - DCHECK_EQ(pref_service_, Source<PrefService>(source).ptr()); - - // Avoid recursion. - if (processing_pref_change_) - return; - - AutoReset<bool> guard(&processing_pref_change_, true); - std::string* name = Details<std::string>(details).ptr(); - const PrefService::Preference* preference = - pref_service_->FindPreference((*name).c_str()); - DCHECK(preference); - int64 sync_id = model_associator_->GetSyncIdFromChromeId(*name); - bool user_modifiable = preference->IsUserModifiable(); - if (!user_modifiable) { - // We do not track preferences the user cannot change. - model_associator_->Disassociate(sync_id); - return; - } - - sync_api::WriteTransaction trans(share_handle()); - sync_api::WriteNode node(&trans); - - // Since we don't create sync nodes for preferences that are not under control - // of the user or still have their default value, this changed preference may - // not have a sync node yet. If so, we create a node. Similarly, a preference - // may become user-modifiable (e.g. due to laxer policy configuration), in - // which case we also need to create a sync node and associate it. - if (sync_api::kInvalidId == sync_id) { - sync_api::ReadNode root(&trans); - if (!root.InitByTagLookup(browser_sync::kPreferencesTag)) { - error_handler()->OnUnrecoverableError(FROM_HERE, "Can't find root."); - return; - } - - // InitPrefNodeAndAssociate takes care of writing the value to the sync - // node if appropriate. - if (!model_associator_->InitPrefNodeAndAssociate(&trans, - root, - preference)) { - error_handler()->OnUnrecoverableError(FROM_HERE, - "Can't create sync node."); - } - return; - } - - if (!node.InitByIdLookup(sync_id)) { - error_handler()->OnUnrecoverableError(FROM_HERE, - "Preference node lookup failed."); - return; - } - - if (!PreferenceModelAssociator::WritePreferenceToNode( - preference->name(), - *preference->GetValue(), - &node)) { - error_handler()->OnUnrecoverableError(FROM_HERE, - "Failed to update preference node."); - return; - } -} - -void PreferenceChangeProcessor::ApplyChangesFromSyncModel( - const sync_api::BaseTransaction* trans, - const sync_api::SyncManager::ChangeRecord* changes, - int change_count) { - DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); - if (!running()) - return; - StopObserving(); - - for (int i = 0; i < change_count; ++i) { - sync_api::ReadNode node(trans); - // TODO(ncarter): Can't look up the name for deletions: lookup of - // deleted items fails at the syncapi layer. However, the node should - // generally still exist in the syncable database; we just need to - // plumb the syncapi so that it succeeds. - if (sync_api::SyncManager::ChangeRecord::ACTION_DELETE == - changes[i].action) { - // Until the above is fixed, we have no choice but to ignore deletions. - LOG(ERROR) << "No way to handle pref deletion"; - continue; - } - - if (!node.InitByIdLookup(changes[i].id)) { - error_handler()->OnUnrecoverableError(FROM_HERE, - "Preference node lookup failed."); - return; - } - DCHECK(syncable::PREFERENCES == node.GetModelType()); - - std::string name; - scoped_ptr<Value> value(ReadPreference(&node, &name)); - // Skip values we can't deserialize. - if (!value.get()) - continue; - - // It is possible that we may receive a change to a preference we - // do not want to sync. For example if the user is syncing a Mac - // client and a Windows client, the Windows client does not - // support kConfirmToQuitEnabled. Ignore updates from these - // preferences. - const char* pref_name = name.c_str(); - if (model_associator_->synced_preferences().count(pref_name) == 0) - continue; - - // Don't try to overwrite preferences not controllable by the user. - const PrefService::Preference* pref = - pref_service_->FindPreference(pref_name); - DCHECK(pref); - if (!pref->IsUserModifiable()) - continue; - - if (sync_api::SyncManager::ChangeRecord::ACTION_DELETE == - changes[i].action) { - pref_service_->ClearPref(pref_name); - } else { - pref_service_->Set(pref_name, *value); - - // If this is a newly added node, associate. - if (sync_api::SyncManager::ChangeRecord::ACTION_ADD == - changes[i].action) { - const PrefService::Preference* preference = - pref_service_->FindPreference(name.c_str()); - model_associator_->Associate(preference, changes[i].id); - } - - model_associator_->AfterUpdateOperations(name); - } - } - StartObserving(); -} - -Value* PreferenceChangeProcessor::ReadPreference( - sync_api::ReadNode* node, - std::string* name) { - const sync_pb::PreferenceSpecifics& preference( - node->GetPreferenceSpecifics()); - base::JSONReader reader; - scoped_ptr<Value> value(reader.JsonToValue(preference.value(), false, false)); - if (!value.get()) { - std::string err = "Failed to deserialize preference value: " + - reader.GetErrorMessage(); - error_handler()->OnUnrecoverableError(FROM_HERE, err); - return NULL; - } - *name = preference.name(); - return value.release(); -} - -void PreferenceChangeProcessor::StartImpl(Profile* profile) { - DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); - pref_service_ = profile->GetPrefs(); - registrar_.Init(pref_service_); - StartObserving(); -} - -void PreferenceChangeProcessor::StopImpl() { - DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); - StopObserving(); - pref_service_ = NULL; -} - - -void PreferenceChangeProcessor::StartObserving() { - DCHECK(pref_service_); - for (std::set<std::string>::const_iterator it = - model_associator_->synced_preferences().begin(); - it != model_associator_->synced_preferences().end(); ++it) { - registrar_.Add((*it).c_str(), this); - } -} - -void PreferenceChangeProcessor::StopObserving() { - DCHECK(pref_service_); - for (std::set<std::string>::const_iterator it = - model_associator_->synced_preferences().begin(); - it != model_associator_->synced_preferences().end(); ++it) { - registrar_.Remove((*it).c_str(), this); - } -} - -} // namespace browser_sync diff --git a/chrome/browser/sync/glue/preference_change_processor.h b/chrome/browser/sync/glue/preference_change_processor.h deleted file mode 100644 index 8111775..0000000 --- a/chrome/browser/sync/glue/preference_change_processor.h +++ /dev/null @@ -1,71 +0,0 @@ -// Copyright (c) 2011 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. - -#ifndef CHROME_BROWSER_SYNC_GLUE_PREFERENCE_CHANGE_PROCESSOR_H_ -#define CHROME_BROWSER_SYNC_GLUE_PREFERENCE_CHANGE_PROCESSOR_H_ -#pragma once - -#include <string> - -#include "chrome/browser/prefs/pref_change_registrar.h" -#include "chrome/browser/prefs/pref_service.h" -#include "chrome/browser/sync/engine/syncapi.h" -#include "chrome/browser/sync/glue/change_processor.h" -#include "chrome/browser/sync/glue/sync_backend_host.h" -#include "content/common/notification_observer.h" - -namespace browser_sync { - -class PreferenceModelAssociator; -class UnrecoverableErrorHandler; - -// This class is responsible for taking changes from the PrefService and -// applying them to the sync_api 'syncable' model, and vice versa. All -// operations and use of this class are from the UI thread. -class PreferenceChangeProcessor : public ChangeProcessor, - public NotificationObserver { - public: - PreferenceChangeProcessor(PreferenceModelAssociator* model_associator, - UnrecoverableErrorHandler* error_handler); - virtual ~PreferenceChangeProcessor(); - - // NotificationObserver implementation. - // PrefService -> sync_api model change application. - virtual void Observe(NotificationType type, - const NotificationSource& source, - const NotificationDetails& details); - - // sync_api model -> PrefService change application. - virtual void ApplyChangesFromSyncModel( - const sync_api::BaseTransaction* trans, - const sync_api::SyncManager::ChangeRecord* changes, - int change_count); - - protected: - virtual void StartImpl(Profile* profile); - virtual void StopImpl(); - - private: - Value* ReadPreference(sync_api::ReadNode* node, std::string* name); - - void StartObserving(); - void StopObserving(); - - // The model we are processing changes from. Non-NULL when |running_| is true. - PrefService* pref_service_; - - // The two models should be associated according to this ModelAssociator. - PreferenceModelAssociator* model_associator_; - - // Whether we are currently processing a preference change notification. - bool processing_pref_change_; - - PrefChangeRegistrar registrar_; - - DISALLOW_COPY_AND_ASSIGN(PreferenceChangeProcessor); -}; - -} // namespace browser_sync - -#endif // CHROME_BROWSER_SYNC_GLUE_PREFERENCE_CHANGE_PROCESSOR_H_ diff --git a/chrome/browser/sync/glue/preference_data_type_controller.cc b/chrome/browser/sync/glue/preference_data_type_controller.cc index 3331bd3..5285b92 100644 --- a/chrome/browser/sync/glue/preference_data_type_controller.cc +++ b/chrome/browser/sync/glue/preference_data_type_controller.cc @@ -5,7 +5,11 @@ #include "chrome/browser/sync/glue/preference_data_type_controller.h" #include "base/metrics/histogram.h" +#include "chrome/browser/prefs/pref_service.h" +#include "chrome/browser/profiles/profile.h" +#include "chrome/browser/sync/glue/generic_change_processor.h" #include "chrome/browser/sync/profile_sync_factory.h" +#include "chrome/browser/sync/syncable_service.h" namespace browser_sync { @@ -15,20 +19,36 @@ PreferenceDataTypeController::PreferenceDataTypeController( ProfileSyncService* sync_service) : FrontendDataTypeController(profile_sync_factory, profile, - sync_service) { + sync_service), + pref_sync_service_(NULL) { } -PreferenceDataTypeController::~PreferenceDataTypeController() {} +PreferenceDataTypeController::~PreferenceDataTypeController() { + pref_sync_service_ = NULL; +} syncable::ModelType PreferenceDataTypeController::type() const { return syncable::PREFERENCES; } void PreferenceDataTypeController::CreateSyncComponents() { - ProfileSyncFactory::SyncComponents sync_components = profile_sync_factory_-> - CreatePreferenceSyncComponents(sync_service_, this); - model_associator_.reset(sync_components.model_associator); - change_processor_.reset(sync_components.change_processor); + ProfileSyncFactory::SyncComponents sync_components = + profile_sync_factory_->CreatePreferenceSyncComponents(sync_service_, + this); + set_model_associator(sync_components.model_associator); + set_change_processor(sync_components.change_processor); + reinterpret_cast<SyncableService*>(model_associator())-> + SetupSync(sync_service_, + reinterpret_cast<GenericChangeProcessor*>(change_processor())); +} + +AssociatorInterface* PreferenceDataTypeController::model_associator() const { + return pref_sync_service_; +} + +void PreferenceDataTypeController::set_model_associator( + AssociatorInterface* associator) { + pref_sync_service_ = associator; } void PreferenceDataTypeController::RecordUnrecoverableError( diff --git a/chrome/browser/sync/glue/preference_data_type_controller.h b/chrome/browser/sync/glue/preference_data_type_controller.h index 3f375b15..f126bdf 100644 --- a/chrome/browser/sync/glue/preference_data_type_controller.h +++ b/chrome/browser/sync/glue/preference_data_type_controller.h @@ -8,6 +8,7 @@ #include <string> +#include "base/compiler_specific.h" #include "chrome/browser/sync/glue/frontend_data_type_controller.h" namespace browser_sync { @@ -21,16 +22,24 @@ class PreferenceDataTypeController : public FrontendDataTypeController { virtual ~PreferenceDataTypeController(); // FrontendDataTypeController implementation. - virtual syncable::ModelType type() const; + virtual syncable::ModelType type() const OVERRIDE; + virtual AssociatorInterface* model_associator() const OVERRIDE; + virtual void set_model_associator(AssociatorInterface* associator) OVERRIDE; private: // FrontendDataTypeController implementations. - virtual void CreateSyncComponents(); + // TODO(zea): Remove this once everything uses the NewAssociatorInterface. + virtual void CreateSyncComponents() OVERRIDE; virtual void RecordUnrecoverableError( const tracked_objects::Location& from_here, - const std::string& message); - virtual void RecordAssociationTime(base::TimeDelta time); - virtual void RecordStartFailure(StartResult result); + const std::string& message) OVERRIDE; + virtual void RecordAssociationTime(base::TimeDelta time) OVERRIDE; + virtual void RecordStartFailure(StartResult result) OVERRIDE; + + // Owned by pref service. + // TODO(zea): Make this a SyncableService once AssociatorInterface is + // deprecated. + AssociatorInterface* pref_sync_service_; DISALLOW_COPY_AND_ASSIGN(PreferenceDataTypeController); }; diff --git a/chrome/browser/sync/glue/preference_data_type_controller_unittest.cc b/chrome/browser/sync/glue/preference_data_type_controller_unittest.cc index 4df8b3f..42d563a 100644 --- a/chrome/browser/sync/glue/preference_data_type_controller_unittest.cc +++ b/chrome/browser/sync/glue/preference_data_type_controller_unittest.cc @@ -11,16 +11,15 @@ #include "base/tracked_objects.h" #include "chrome/browser/sync/glue/preference_data_type_controller.h" #include "chrome/browser/sync/glue/change_processor_mock.h" -#include "chrome/browser/sync/glue/model_associator_mock.h" #include "chrome/browser/sync/profile_sync_factory_mock.h" #include "chrome/browser/sync/profile_sync_service_mock.h" +#include "chrome/browser/sync/syncable_service_mock.h" #include "chrome/test/profile_mock.h" #include "content/browser/browser_thread.h" using browser_sync::PreferenceDataTypeController; using browser_sync::ChangeProcessorMock; using browser_sync::DataTypeController; -using browser_sync::ModelAssociatorMock; using testing::_; using testing::DoAll; using testing::InvokeWithoutArgs; @@ -48,11 +47,13 @@ class PreferenceDataTypeControllerTest : public testing::Test { protected: void SetStartExpectations() { - model_associator_ = new ModelAssociatorMock(); + model_associator_.reset(new SyncableServiceMock()); change_processor_ = new ChangeProcessorMock(); EXPECT_CALL(*profile_sync_factory_, CreatePreferenceSyncComponents(_, _)). - WillOnce(Return(ProfileSyncFactory::SyncComponents(model_associator_, - change_processor_))); + WillOnce(Return( + ProfileSyncFactory::SyncComponents(model_associator_.get(), + change_processor_))); + EXPECT_CALL(*model_associator_, SetupSync(_,_)).Times(1); } void SetAssociateExpectations() { @@ -79,7 +80,7 @@ class PreferenceDataTypeControllerTest : public testing::Test { scoped_ptr<ProfileSyncFactoryMock> profile_sync_factory_; ProfileMock profile_; ProfileSyncServiceMock service_; - ModelAssociatorMock* model_associator_; + scoped_ptr<SyncableServiceMock> model_associator_; ChangeProcessorMock* change_processor_; StartCallback start_callback_; }; diff --git a/chrome/browser/sync/glue/preference_model_associator.cc b/chrome/browser/sync/glue/preference_model_associator.cc deleted file mode 100644 index 7d75c38..0000000 --- a/chrome/browser/sync/glue/preference_model_associator.cc +++ /dev/null @@ -1,338 +0,0 @@ -// Copyright (c) 2011 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 "chrome/browser/sync/glue/preference_model_associator.h" - -#include "base/json/json_reader.h" -#include "base/logging.h" -#include "base/utf_string_conversions.h" -#include "base/values.h" -#include "chrome/browser/prefs/pref_service.h" -#include "chrome/browser/profiles/profile.h" -#include "chrome/browser/sync/engine/syncapi.h" -#include "chrome/browser/sync/glue/synchronized_preferences.h" -#include "chrome/browser/sync/profile_sync_service.h" -#include "chrome/browser/sync/protocol/preference_specifics.pb.h" -#include "chrome/common/pref_names.h" -#include "content/browser/browser_thread.h" -#include "content/common/json_value_serializer.h" -#include "content/common/notification_service.h" - -namespace browser_sync { - -PreferenceModelAssociator::PreferenceModelAssociator( - ProfileSyncService* sync_service) - : sync_service_(sync_service), - preferences_node_id_(sync_api::kInvalidId) { - DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); - DCHECK(sync_service_); - - // Add the list of kSynchronizedPreferences to our local - // synced_preferences set, taking care to filter out any preferences - // that are not registered. - PrefService* pref_service = sync_service_->profile()->GetPrefs(); - for (size_t i = 0; i < arraysize(kSynchronizedPreferences); ++i) { - if (pref_service->FindPreference(kSynchronizedPreferences[i])) - synced_preferences_.insert(kSynchronizedPreferences[i]); - } -} - -PreferenceModelAssociator::~PreferenceModelAssociator() { - DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); -} - -bool PreferenceModelAssociator::InitPrefNodeAndAssociate( - sync_api::WriteTransaction* trans, - const sync_api::BaseNode& root, - const PrefService::Preference* pref) { - DCHECK(pref); - - PrefService* pref_service = sync_service_->profile()->GetPrefs(); - base::JSONReader reader; - std::string tag = pref->name(); - sync_api::WriteNode node(trans); - if (node.InitByClientTagLookup(syncable::PREFERENCES, tag)) { - // The server has a value for the preference. - const sync_pb::PreferenceSpecifics& preference( - node.GetPreferenceSpecifics()); - DCHECK_EQ(tag, preference.name()); - - if (pref->IsUserModifiable()) { - scoped_ptr<Value> value( - reader.JsonToValue(preference.value(), false, false)); - std::string pref_name = preference.name(); - if (!value.get()) { - LOG(ERROR) << "Failed to deserialize preference value: " - << reader.GetErrorMessage(); - return false; - } - - // Merge the server value of this preference with the local value. - scoped_ptr<Value> new_value(MergePreference(*pref, *value)); - - // Update the local preference based on what we got from the - // sync server. - if (new_value->IsType(Value::TYPE_NULL)) { - pref_service->ClearPref(pref_name.c_str()); - } else if (!new_value->IsType(pref->GetType())) { - LOG(WARNING) << "Synced value for " << preference.name() - << " is of type " << new_value->GetType() - << " which doesn't match pref type " << pref->GetType(); - } else if (!pref->GetValue()->Equals(new_value.get())) { - pref_service->Set(pref_name.c_str(), *new_value); - } - - AfterUpdateOperations(pref_name); - - // If the merge resulted in an updated value, write it back to - // the sync node. - if (!value->Equals(new_value.get()) && - !WritePreferenceToNode(pref->name(), *new_value, &node)) - return false; - } - Associate(pref, node.GetId()); - } else if (pref->IsUserControlled()) { - // The server doesn't have a value, but we have a user-controlled value, - // so we push it to the server. - sync_api::WriteNode write_node(trans); - if (!write_node.InitUniqueByCreation(syncable::PREFERENCES, root, tag)) { - LOG(ERROR) << "Failed to create preference sync node."; - return false; - } - - // Update the sync node with the local value for this preference. - if (!WritePreferenceToNode(pref->name(), *pref->GetValue(), &write_node)) - return false; - - Associate(pref, write_node.GetId()); - } - - return true; -} - -bool PreferenceModelAssociator::AssociateModels() { - DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); - PrefService* pref_service = sync_service_->profile()->GetPrefs(); - - int64 root_id; - if (!GetSyncIdForTaggedNode(kPreferencesTag, &root_id)) { - LOG(ERROR) << "Server did not create the top-level preferences node. We " - << "might be running against an out-of-date server."; - return false; - } - - sync_api::WriteTransaction trans(sync_service_->GetUserShare()); - sync_api::ReadNode root(&trans); - if (!root.InitByIdLookup(root_id)) { - LOG(ERROR) << "Server did not create the top-level preferences node. We " - << "might be running against an out-of-date server."; - return false; - } - - for (std::set<std::string>::iterator it = synced_preferences_.begin(); - it != synced_preferences_.end(); ++it) { - const PrefService::Preference* pref = - pref_service->FindPreference((*it).c_str()); - DCHECK(pref); - InitPrefNodeAndAssociate(&trans, root, pref); - } - return true; -} - -bool PreferenceModelAssociator::DisassociateModels() { - id_map_.clear(); - id_map_inverse_.clear(); - return true; -} - -bool PreferenceModelAssociator::SyncModelHasUserCreatedNodes(bool* has_nodes) { - DCHECK(has_nodes); - *has_nodes = false; - int64 preferences_sync_id; - if (!GetSyncIdForTaggedNode(kPreferencesTag, &preferences_sync_id)) { - LOG(ERROR) << "Server did not create the top-level preferences node. We " - << "might be running against an out-of-date server."; - return false; - } - sync_api::ReadTransaction trans(sync_service_->GetUserShare()); - - sync_api::ReadNode preferences_node(&trans); - if (!preferences_node.InitByIdLookup(preferences_sync_id)) { - LOG(ERROR) << "Server did not create the top-level preferences node. We " - << "might be running against an out-of-date server."; - return false; - } - - // The sync model has user created nodes if the preferences folder has any - // children. - *has_nodes = sync_api::kInvalidId != preferences_node.GetFirstChildId(); - return true; -} - -const PrefService::Preference* -PreferenceModelAssociator::GetChromeNodeFromSyncId(int64 sync_id) { - return NULL; -} - -bool PreferenceModelAssociator::InitSyncNodeFromChromeId( - const std::string& node_id, - sync_api::BaseNode* sync_node) { - return false; -} - -int64 PreferenceModelAssociator::GetSyncIdFromChromeId( - const std::string& preference_name) { - PreferenceNameToSyncIdMap::const_iterator iter = - id_map_.find(preference_name); - return iter == id_map_.end() ? sync_api::kInvalidId : iter->second; -} - -void PreferenceModelAssociator::Associate( - const PrefService::Preference* preference, int64 sync_id) { - DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); - DCHECK_NE(sync_api::kInvalidId, sync_id); - DCHECK(id_map_.find(preference->name()) == id_map_.end()); - DCHECK(id_map_inverse_.find(sync_id) == id_map_inverse_.end()); - id_map_[preference->name()] = sync_id; - id_map_inverse_[sync_id] = preference->name(); -} - -void PreferenceModelAssociator::Disassociate(int64 sync_id) { - DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); - SyncIdToPreferenceNameMap::iterator iter = id_map_inverse_.find(sync_id); - if (iter == id_map_inverse_.end()) - return; - id_map_.erase(iter->second); - id_map_inverse_.erase(iter); -} - -bool PreferenceModelAssociator::GetSyncIdForTaggedNode(const std::string& tag, - int64* sync_id) { - sync_api::ReadTransaction trans(sync_service_->GetUserShare()); - sync_api::ReadNode sync_node(&trans); - if (!sync_node.InitByTagLookup(tag.c_str())) - return false; - *sync_id = sync_node.GetId(); - return true; -} - -Value* PreferenceModelAssociator::MergePreference( - const PrefService::Preference& local_pref, - const Value& server_value) { - const std::string& name(local_pref.name()); - if (name == prefs::kURLsToRestoreOnStartup || - name == prefs::kDesktopNotificationAllowedOrigins || - name == prefs::kDesktopNotificationDeniedOrigins) { - return MergeListValues(*local_pref.GetValue(), server_value); - } - - if (name == prefs::kContentSettingsPatterns || - name == prefs::kGeolocationContentSettings) { - return MergeDictionaryValues(*local_pref.GetValue(), server_value); - } - - // If this is not a specially handled preference, server wins. - return server_value.DeepCopy(); -} - -bool PreferenceModelAssociator::WritePreferenceToNode( - const std::string& name, - const Value& value, - sync_api::WriteNode* node) { - std::string serialized; - JSONStringValueSerializer json(&serialized); - if (!json.Serialize(value)) { - LOG(ERROR) << "Failed to serialize preference value."; - return false; - } - - sync_pb::PreferenceSpecifics preference; - preference.set_name(name); - preference.set_value(serialized); - node->SetPreferenceSpecifics(preference); - // TODO(viettrungluu): eliminate conversion (it's temporary) - node->SetTitle(UTF8ToWide(name)); - return true; -} - -Value* PreferenceModelAssociator::MergeListValues(const Value& from_value, - const Value& to_value) { - if (from_value.GetType() == Value::TYPE_NULL) - return to_value.DeepCopy(); - if (to_value.GetType() == Value::TYPE_NULL) - return from_value.DeepCopy(); - - DCHECK(from_value.GetType() == Value::TYPE_LIST); - DCHECK(to_value.GetType() == Value::TYPE_LIST); - const ListValue& from_list_value = static_cast<const ListValue&>(from_value); - const ListValue& to_list_value = static_cast<const ListValue&>(to_value); - ListValue* result = to_list_value.DeepCopy(); - - for (ListValue::const_iterator i = from_list_value.begin(); - i != from_list_value.end(); ++i) { - Value* value = (*i)->DeepCopy(); - result->AppendIfNotPresent(value); - } - return result; -} - -Value* PreferenceModelAssociator::MergeDictionaryValues( - const Value& from_value, - const Value& to_value) { - if (from_value.GetType() == Value::TYPE_NULL) - return to_value.DeepCopy(); - if (to_value.GetType() == Value::TYPE_NULL) - return from_value.DeepCopy(); - - DCHECK(from_value.GetType() == Value::TYPE_DICTIONARY); - DCHECK(to_value.GetType() == Value::TYPE_DICTIONARY); - const DictionaryValue& from_dict_value = - static_cast<const DictionaryValue&>(from_value); - const DictionaryValue& to_dict_value = - static_cast<const DictionaryValue&>(to_value); - DictionaryValue* result = to_dict_value.DeepCopy(); - - for (DictionaryValue::key_iterator key = from_dict_value.begin_keys(); - key != from_dict_value.end_keys(); ++key) { - Value* from_value; - bool success = from_dict_value.GetWithoutPathExpansion(*key, &from_value); - DCHECK(success); - - Value* to_key_value; - if (result->GetWithoutPathExpansion(*key, &to_key_value)) { - if (to_key_value->GetType() == Value::TYPE_DICTIONARY) { - Value* merged_value = MergeDictionaryValues(*from_value, *to_key_value); - result->SetWithoutPathExpansion(*key, merged_value); - } - // Note that for all other types we want to preserve the "to" - // values so we do nothing here. - } else { - result->SetWithoutPathExpansion(*key, from_value->DeepCopy()); - } - } - return result; -} - -void PreferenceModelAssociator::AfterUpdateOperations( - const std::string& pref_name) { - // The bookmark bar visibility preference requires a special - // notification to update the UI. - if (0 == pref_name.compare(prefs::kShowBookmarkBar)) { - NotificationService::current()->Notify( - NotificationType::BOOKMARK_BAR_VISIBILITY_PREF_CHANGED, - Source<PreferenceModelAssociator>(this), - NotificationService::NoDetails()); - } -} - -bool PreferenceModelAssociator::CryptoReadyIfNecessary() { - // We only access the cryptographer while holding a transaction. - sync_api::ReadTransaction trans(sync_service_->GetUserShare()); - syncable::ModelTypeSet encrypted_types; - sync_service_->GetEncryptedDataTypes(&encrypted_types); - return encrypted_types.count(syncable::PREFERENCES) == 0 || - sync_service_->IsCryptographerReady(&trans); -} - -} // namespace browser_sync diff --git a/chrome/browser/sync/glue/preference_model_associator.h b/chrome/browser/sync/glue/preference_model_associator.h deleted file mode 100644 index 5c661b2..0000000 --- a/chrome/browser/sync/glue/preference_model_associator.h +++ /dev/null @@ -1,135 +0,0 @@ -// Copyright (c) 2011 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. - -#ifndef CHROME_BROWSER_SYNC_GLUE_PREFERENCE_MODEL_ASSOCIATOR_H_ -#define CHROME_BROWSER_SYNC_GLUE_PREFERENCE_MODEL_ASSOCIATOR_H_ -#pragma once - -#include <map> -#include <set> -#include <string> - -#include "base/basictypes.h" -#include "chrome/browser/prefs/pref_service.h" -#include "chrome/browser/sync/glue/model_associator.h" -#include "chrome/browser/sync/unrecoverable_error_handler.h" - -class ProfileSyncService; -class Value; - -namespace sync_api { -class WriteNode; -class WriteTransaction; -} - -namespace browser_sync { - -class PreferenceChangeProcessor; - -static const char kPreferencesTag[] = "google_chrome_preferences"; - -// Contains all model association related logic: -// * Algorithm to associate preferences model and sync model. -class PreferenceModelAssociator - : public PerDataTypeAssociatorInterface<PrefService::Preference, - std::string> { - public: - static syncable::ModelType model_type() { return syncable::PREFERENCES; } - explicit PreferenceModelAssociator(ProfileSyncService* sync_service); - virtual ~PreferenceModelAssociator(); - - // Returns the list of preference names that should be monitored for - // changes. Only preferences that are registered will be in this - // list. - const std::set<std::string>& synced_preferences() { - return synced_preferences_; - } - - // Create an association for a given preference. A sync node is created if - // necessary and the value is read from or written to the node as appropriate. - bool InitPrefNodeAndAssociate(sync_api::WriteTransaction* trans, - const sync_api::BaseNode& root, - const PrefService::Preference* pref); - - // PerDataTypeAssociatorInterface implementation. - // - // Iterates through the sync model looking for matched pairs of items. - virtual bool AssociateModels(); - - // Clears all associations. - virtual bool DisassociateModels(); - - // Returns whether the sync model has nodes other than the permanent tagged - // nodes. - virtual bool SyncModelHasUserCreatedNodes(bool* has_nodes); - - virtual void AbortAssociation() { - // No implementation needed, this associator runs on the main - // thread. - } - - // See ModelAssociator interface. - virtual bool CryptoReadyIfNecessary(); - - // Not implemented. - virtual const PrefService::Preference* GetChromeNodeFromSyncId(int64 sync_id); - - // Not implemented. - virtual bool InitSyncNodeFromChromeId(const std::string& node_id, - sync_api::BaseNode* sync_node); - - // Returns the sync id for the given preference name, or sync_api::kInvalidId - // if the preference name is not associated to any sync id. - virtual int64 GetSyncIdFromChromeId(const std::string& node_id); - - // Associates the given preference name with the given sync id. - virtual void Associate(const PrefService::Preference* node, int64 sync_id); - - // Remove the association that corresponds to the given sync id. - virtual void Disassociate(int64 sync_id); - - // Returns whether a node with the given permanent tag was found and update - // |sync_id| with that node's id. - virtual bool GetSyncIdForTaggedNode(const std::string& tag, int64* sync_id); - - // Merges the value of local_pref into the supplied server_value and - // returns the result (caller takes ownership). If there is a - // conflict, the server value always takes precedence. Note that - // only certain preferences will actually be merged, all others will - // return a copy of the server value. See the method's - // implementation for details. - static Value* MergePreference(const PrefService::Preference& local_pref, - const Value& server_value); - - // Writes the value of pref into the specified node. Returns true - // upon success. - static bool WritePreferenceToNode(const std::string& name, - const Value& value, - sync_api::WriteNode* node); - - // Perform any additional operations that need to happen after a preference - // has been updated. - void AfterUpdateOperations(const std::string& pref_name); - - private: - typedef std::map<std::string, int64> PreferenceNameToSyncIdMap; - typedef std::map<int64, std::string> SyncIdToPreferenceNameMap; - - static Value* MergeListValues(const Value& from_value, const Value& to_value); - static Value* MergeDictionaryValues(const Value& from_value, - const Value& to_value); - - ProfileSyncService* sync_service_; - std::set<std::string> synced_preferences_; - int64 preferences_node_id_; - - PreferenceNameToSyncIdMap id_map_; - SyncIdToPreferenceNameMap id_map_inverse_; - - DISALLOW_COPY_AND_ASSIGN(PreferenceModelAssociator); -}; - -} // namespace browser_sync - -#endif // CHROME_BROWSER_SYNC_GLUE_PREFERENCE_MODEL_ASSOCIATOR_H_ diff --git a/chrome/browser/sync/glue/session_data_type_controller.cc b/chrome/browser/sync/glue/session_data_type_controller.cc index 68186cb..5d84b29 100644 --- a/chrome/browser/sync/glue/session_data_type_controller.cc +++ b/chrome/browser/sync/glue/session_data_type_controller.cc @@ -31,8 +31,8 @@ syncable::ModelType SessionDataTypeController::type() const { void SessionDataTypeController::CreateSyncComponents() { ProfileSyncFactory::SyncComponents sync_components = profile_sync_factory_-> CreateSessionSyncComponents(sync_service_, this); - model_associator_.reset(sync_components.model_associator); - change_processor_.reset(sync_components.change_processor); + set_model_associator(sync_components.model_associator); + set_change_processor(sync_components.change_processor); } void SessionDataTypeController::RecordUnrecoverableError( diff --git a/chrome/browser/sync/glue/sync_backend_host.cc b/chrome/browser/sync/glue/sync_backend_host.cc index d039471..c3a8bff 100644 --- a/chrome/browser/sync/glue/sync_backend_host.cc +++ b/chrome/browser/sync/glue/sync_backend_host.cc @@ -515,6 +515,9 @@ void SyncBackendHost::ActivateDataType( // processors so it can receive updates. DCHECK_EQ(processors_.count(type), 0U); processors_[type] = change_processor; + + // Start the change processor. + change_processor->Start(profile_, GetUserShare()); } void SyncBackendHost::DeactivateDataType( @@ -523,6 +526,8 @@ void SyncBackendHost::DeactivateDataType( base::AutoLock lock(registrar_lock_); registrar_.routing_info.erase(data_type_controller->type()); + // Stop the change processor and remove it from the list of processors. + change_processor->Stop(); std::map<syncable::ModelType, ChangeProcessor*>::size_type erased = processors_.erase(data_type_controller->type()); DCHECK_EQ(erased, 1U); diff --git a/chrome/browser/sync/glue/synchronized_preferences.h b/chrome/browser/sync/glue/synchronized_preferences.h deleted file mode 100644 index beb8166..0000000 --- a/chrome/browser/sync/glue/synchronized_preferences.h +++ /dev/null @@ -1,205 +0,0 @@ -// Copyright (c) 2011 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. - -// Defines a list of the preferences that the -// PreferencesChangeProcessor should process changes for. - -#ifndef CHROME_BROWSER_SYNC_GLUE_SYNCHRONIZED_PREFERENCES_H_ -#define CHROME_BROWSER_SYNC_GLUE_SYNCHRONIZED_PREFERENCES_H_ -#pragma once - -#include "chrome/browser/translate/translate_prefs.h" -#include "chrome/common/pref_names.h" - -namespace browser_sync { - -static const char* kSynchronizedPreferences[] = { - // Options dialog: Basics tab. - prefs::kRestoreOnStartup, - prefs::kURLsToRestoreOnStartup, - prefs::kShowBookmarkBar, - prefs::kHomePageIsNewTabPage, - prefs::kHomePage, - prefs::kShowHomeButton, - // Default Search is not synced, needs a new data type. See - // http://crbug.com/40482 - - // Options dialog: Personal Stuff tab. - prefs::kPasswordManagerEnabled, - prefs::kAutofillEnabled, - prefs::kUseCustomChromeFrame, - - // Options dialog: Under the hood -> Content Settings -> Cookies. - // Cookie settings and exceptions not working - prefs::kBlockThirdPartyCookies, - prefs::kClearSiteDataOnExit, - - // Options dialog: Under the hood -> Content Settings -> - // Images, JavaScript, Plug-ins, Pop-ups. - prefs::kDefaultContentSettings, - prefs::kContentSettingsPatterns, - - // Options dialog: Under the hood -> Content Settings -> Location. - // Exceptions not working (dialog not working either). - prefs::kGeolocationContentSettings, - prefs::kGeolocationDefaultContentSetting, - - // Options dialog: under the hood -> Content Settings -> Notifications. - prefs::kDesktopNotificationDefaultContentSetting, - - // Options dialog: Under the hood -> Clear browsing data. - // All working but no live update. - prefs::kDeleteBrowsingHistory, - prefs::kDeleteDownloadHistory, - prefs::kDeleteCache, - prefs::kDeleteCookies, - prefs::kDeletePasswords, - prefs::kDeleteFormData, - prefs::kDeleteTimePeriod, - - // Options dialog: Under the hood -> Change proxy settings. - // Uses native OS dialog, not synced. - - // Options dialog: Under the hood -> Change font and language settings. - // Serif, San Serif, Fixed font settings not synced. - prefs::kDefaultCharset, - // There is no dialog to modify the kAcceptLanguages list on OSX, so - // don't sync it. -#if !defined(OS_MACOSX) - prefs::kAcceptLanguages, -#endif - prefs::kEnableSpellCheck, - // Spell checker language not synced. - prefs::kApplicationLocale, - - // Options dialog: Under the hood. - prefs::kAlternateErrorPagesEnabled, - prefs::kSearchSuggestEnabled, - prefs::kNetworkPredictionEnabled, - prefs::kSafeBrowsingEnabled, - prefs::kEnableTranslate, - // Download directory not synced. - // Clear auto-opening settings not synced. - prefs::kPromptForDownload, - - // Wrench menu -> Extensions. - prefs::kExtensionsUIDeveloperMode, // no live update - - // Document menu -> Zoom. - // prefs::kPerHostZoomLevels creates bad UX when synced, see - // http://crbug.com/47359. - - // Document menu -> Encoding -> Auto Detect. - prefs::kWebKitUsesUniversalDetector, - - // Autofill dialog. -#if defined(OS_MACOSX) - prefs::kAutofillAuxiliaryProfilesEnabled, -#endif - - // Translate preferences. - TranslatePrefs::kPrefTranslateLanguageBlacklist, - TranslatePrefs::kPrefTranslateSiteBlacklist, - TranslatePrefs::kPrefTranslateWhitelists, - TranslatePrefs::kPrefTranslateDeniedCount, - TranslatePrefs::kPrefTranslateAcceptedCount, - - // Desktop notification permissions. - prefs::kDesktopNotificationAllowedOrigins, - prefs::kDesktopNotificationDeniedOrigins, - - // (Mac) Application menu. - prefs::kConfirmToQuitEnabled, - -#if defined(OS_CHROMEOS) - // IME prefs - prefs::kLanguageChewingAddPhraseDirection, - prefs::kLanguageChewingAutoShiftCur, - prefs::kLanguageChewingCandPerPage, - prefs::kLanguageChewingEasySymbolInput, - prefs::kLanguageChewingEscCleanAllBuf, - prefs::kLanguageChewingForceLowercaseEnglish, - prefs::kLanguageChewingHsuSelKeyType, - prefs::kLanguageChewingKeyboardType, - prefs::kLanguageChewingMaxChiSymbolLen, - prefs::kLanguageChewingPhraseChoiceRearward, - prefs::kLanguageChewingPlainZhuyin, - prefs::kLanguageChewingSelKeys, - prefs::kLanguageChewingSpaceAsSelection, - prefs::kLanguageHangulKeyboard, - prefs::kLanguageMozcHistoryLearningLevel, - prefs::kLanguageMozcIncognitoMode, - prefs::kLanguageMozcNumpadCharacterForm, - prefs::kLanguageMozcPreeditMethod, - prefs::kLanguageMozcPunctuationMethod, - prefs::kLanguageMozcSessionKeymap, - prefs::kLanguageMozcShiftKeyModeSwitch, - prefs::kLanguageMozcSpaceCharacterForm, - prefs::kLanguageMozcSuggestionsSize, - prefs::kLanguageMozcSymbolMethod, - prefs::kLanguageMozcUseAutoImeTurnOff, - prefs::kLanguageMozcUseDateConversion, - prefs::kLanguageMozcUseDictionarySuggest, - prefs::kLanguageMozcUseHistorySuggest, - prefs::kLanguageMozcUseNumberConversion, - prefs::kLanguageMozcUseSingleKanjiConversion, - prefs::kLanguageMozcUseSymbolConversion, - prefs::kLanguagePinyinAutoCommit, - prefs::kLanguagePinyinCommaPeriodPage, - prefs::kLanguagePinyinCorrectPinyin, - prefs::kLanguagePinyinDoublePinyin, - prefs::kLanguagePinyinDoublePinyinSchema, - prefs::kLanguagePinyinFuzzyPinyin, - prefs::kLanguagePinyinInitChinese, - prefs::kLanguagePinyinInitFull, - prefs::kLanguagePinyinInitFullPunct, - prefs::kLanguagePinyinInitSimplifiedChinese, - prefs::kLanguagePinyinMinusEqualPage, - prefs::kLanguagePinyinShiftSelectCandidate, - prefs::kLanguagePinyinTradCandidate, - prefs::kLanguagePreferredLanguages, - prefs::kLanguagePreloadEngines, - - // We don't sync the following IME prefs since they are not user-configurable - // (yet): - // prefs::kLanguageHangulHanjaKeys, - // prefs::kLanguageHotkeyNextEngineInMenu, - // prefs::kLanguageHotkeyPreviousEngine, - // prefs::kLanguageMozcSelectionShortcut, - // prefs::kLanguagePinyinLookupTablePageSize, - // - // We don't sync prefs::kLanguageCurrentInputMethod and PreviousInputMethod. - - // Keyboard prefs - prefs::kLanguageXkbRemapAltKeyTo, - prefs::kLanguageXkbRemapControlKeyTo, - prefs::kLanguageXkbRemapSearchKeyTo, - - // We don't sync the following keyboard prefs since they are not user- - // configurable: - // prefs::kLanguageXkbAutoRepeatDelay, - // prefs::kLanguageXkbAutoRepeatEnabled, - // prefs::kLanguageXkbAutoRepeatInterval, - - // Whether to show mobile plan notifications. - // Settings -> Internet -> Mobile plan details - prefs::kShowPlanNotifications, - - // Whether to require password to wake up from sleep - // Settings -> Personal Stuff -> Account - prefs::kEnableScreenLock, - - // Whether to enable tap-to-click - // Settings -> System -> Touchpad - prefs::kTapToClickEnabled, - - // Whether to use the 24-hour clock format. - // Settings -> System -> Date and Time - prefs::kUse24HourClock, -#endif -}; - -} // namespace browser_sync - -#endif // CHROME_BROWSER_SYNC_GLUE_SYNCHRONIZED_PREFERENCES_H_ diff --git a/chrome/browser/sync/glue/theme_data_type_controller.cc b/chrome/browser/sync/glue/theme_data_type_controller.cc index efcbe11..3e30b84 100644 --- a/chrome/browser/sync/glue/theme_data_type_controller.cc +++ b/chrome/browser/sync/glue/theme_data_type_controller.cc @@ -35,8 +35,8 @@ void ThemeDataTypeController::CreateSyncComponents() { ProfileSyncFactory::SyncComponents sync_components = profile_sync_factory_->CreateThemeSyncComponents(sync_service_, this); - model_associator_.reset(sync_components.model_associator); - change_processor_.reset(sync_components.change_processor); + set_model_associator(sync_components.model_associator); + set_change_processor(sync_components.change_processor); } void ThemeDataTypeController::RecordUnrecoverableError( diff --git a/chrome/browser/sync/profile_sync_factory_impl.cc b/chrome/browser/sync/profile_sync_factory_impl.cc index ef701ff..9ca4ede 100644 --- a/chrome/browser/sync/profile_sync_factory_impl.cc +++ b/chrome/browser/sync/profile_sync_factory_impl.cc @@ -22,12 +22,11 @@ #include "chrome/browser/sync/glue/extension_data_type_controller.h" #include "chrome/browser/sync/glue/extension_model_associator.h" #include "chrome/browser/sync/glue/extension_sync_traits.h" +#include "chrome/browser/sync/glue/generic_change_processor.h" #include "chrome/browser/sync/glue/password_change_processor.h" #include "chrome/browser/sync/glue/password_data_type_controller.h" #include "chrome/browser/sync/glue/password_model_associator.h" -#include "chrome/browser/sync/glue/preference_change_processor.h" #include "chrome/browser/sync/glue/preference_data_type_controller.h" -#include "chrome/browser/sync/glue/preference_model_associator.h" #include "chrome/browser/sync/glue/session_change_processor.h" #include "chrome/browser/sync/glue/session_data_type_controller.h" #include "chrome/browser/sync/glue/session_model_associator.h" @@ -40,6 +39,7 @@ #include "chrome/browser/sync/glue/typed_url_model_associator.h" #include "chrome/browser/sync/profile_sync_service.h" #include "chrome/browser/sync/profile_sync_factory_impl.h" +#include "chrome/browser/sync/syncable_service.h" #include "chrome/browser/webdata/web_data_service.h" #include "chrome/common/chrome_switches.h" @@ -61,12 +61,11 @@ using browser_sync::DataTypeManagerImpl; using browser_sync::ExtensionChangeProcessor; using browser_sync::ExtensionDataTypeController; using browser_sync::ExtensionModelAssociator; +using browser_sync::GenericChangeProcessor; using browser_sync::PasswordChangeProcessor; using browser_sync::PasswordDataTypeController; using browser_sync::PasswordModelAssociator; -using browser_sync::PreferenceChangeProcessor; using browser_sync::PreferenceDataTypeController; -using browser_sync::PreferenceModelAssociator; using browser_sync::SessionChangeProcessor; using browser_sync::SessionDataTypeController; using browser_sync::SessionModelAssociator; @@ -273,12 +272,11 @@ ProfileSyncFactory::SyncComponents ProfileSyncFactoryImpl::CreatePreferenceSyncComponents( ProfileSyncService* profile_sync_service, UnrecoverableErrorHandler* error_handler) { - PreferenceModelAssociator* model_associator = - new PreferenceModelAssociator(profile_sync_service); - PreferenceChangeProcessor* change_processor = - new PreferenceChangeProcessor(model_associator, - error_handler); - return SyncComponents(model_associator, change_processor); + SyncableService* pref_sync_service = + profile_->GetPrefs()->GetSyncableService(); + GenericChangeProcessor* change_processor = + new GenericChangeProcessor(pref_sync_service, error_handler); + return SyncComponents(pref_sync_service, change_processor); } ProfileSyncFactory::SyncComponents diff --git a/chrome/browser/sync/profile_sync_service.cc b/chrome/browser/sync/profile_sync_service.cc index f432b5c..798d305 100644 --- a/chrome/browser/sync/profile_sync_service.cc +++ b/chrome/browser/sync/profile_sync_service.cc @@ -242,9 +242,15 @@ void ProfileSyncService::RegisterPreferences() { PrefService* pref_service = profile_->GetPrefs(); if (pref_service->FindPreference(prefs::kSyncLastSyncedTime)) return; - pref_service->RegisterInt64Pref(prefs::kSyncLastSyncedTime, 0); - pref_service->RegisterBooleanPref(prefs::kSyncHasSetupCompleted, false); - pref_service->RegisterBooleanPref(prefs::kSyncSuppressStart, false); + pref_service->RegisterInt64Pref(prefs::kSyncLastSyncedTime, + 0, + PrefService::UNSYNCABLE_PREF); + pref_service->RegisterBooleanPref(prefs::kSyncHasSetupCompleted, + false, + PrefService::UNSYNCABLE_PREF); + pref_service->RegisterBooleanPref(prefs::kSyncSuppressStart, + false, + PrefService::UNSYNCABLE_PREF); // If you've never synced before, or if you're using Chrome OS, all datatypes // are on by default. @@ -257,22 +263,46 @@ void ProfileSyncService::RegisterPreferences() { !pref_service->HasPrefPath(prefs::kSyncHasSetupCompleted); #endif - pref_service->RegisterBooleanPref(prefs::kSyncBookmarks, true); - pref_service->RegisterBooleanPref(prefs::kSyncPasswords, enable_by_default); - pref_service->RegisterBooleanPref(prefs::kSyncPreferences, enable_by_default); - pref_service->RegisterBooleanPref(prefs::kSyncAutofill, enable_by_default); - pref_service->RegisterBooleanPref(prefs::kSyncThemes, enable_by_default); - pref_service->RegisterBooleanPref(prefs::kSyncTypedUrls, enable_by_default); - pref_service->RegisterBooleanPref(prefs::kSyncExtensions, enable_by_default); - pref_service->RegisterBooleanPref(prefs::kSyncApps, enable_by_default); - pref_service->RegisterBooleanPref(prefs::kSyncSessions, enable_by_default); + pref_service->RegisterBooleanPref(prefs::kSyncBookmarks, + true, + PrefService::UNSYNCABLE_PREF); + pref_service->RegisterBooleanPref(prefs::kSyncPasswords, + enable_by_default, + PrefService::UNSYNCABLE_PREF); + pref_service->RegisterBooleanPref(prefs::kSyncPreferences, + enable_by_default, + PrefService::UNSYNCABLE_PREF); + pref_service->RegisterBooleanPref(prefs::kSyncAutofill, + enable_by_default, + PrefService::UNSYNCABLE_PREF); + pref_service->RegisterBooleanPref(prefs::kSyncThemes, + enable_by_default, + PrefService::UNSYNCABLE_PREF); + pref_service->RegisterBooleanPref(prefs::kSyncTypedUrls, + enable_by_default, + PrefService::UNSYNCABLE_PREF); + pref_service->RegisterBooleanPref(prefs::kSyncExtensions, + enable_by_default, + PrefService::UNSYNCABLE_PREF); + pref_service->RegisterBooleanPref(prefs::kSyncApps, + enable_by_default, + PrefService::UNSYNCABLE_PREF); + pref_service->RegisterBooleanPref(prefs::kSyncSessions, + enable_by_default, + PrefService::UNSYNCABLE_PREF); pref_service->RegisterBooleanPref(prefs::kKeepEverythingSynced, - enable_by_default); - pref_service->RegisterBooleanPref(prefs::kSyncManaged, false); - pref_service->RegisterStringPref(prefs::kEncryptionBootstrapToken, ""); + enable_by_default, + PrefService::UNSYNCABLE_PREF); + pref_service->RegisterBooleanPref(prefs::kSyncManaged, + false, + PrefService::UNSYNCABLE_PREF); + pref_service->RegisterStringPref(prefs::kEncryptionBootstrapToken, + "", + PrefService::UNSYNCABLE_PREF); pref_service->RegisterBooleanPref(prefs::kSyncAutofillProfile, - enable_by_default); + enable_by_default, + PrefService::UNSYNCABLE_PREF); } void ProfileSyncService::ClearPreferences() { @@ -1099,16 +1129,15 @@ void ProfileSyncService::ActivateDataType( return; } DCHECK(backend_initialized_); - change_processor->Start(profile(), backend_->GetUserShare()); backend_->ActivateDataType(data_type_controller, change_processor); } void ProfileSyncService::DeactivateDataType( DataTypeController* data_type_controller, ChangeProcessor* change_processor) { - change_processor->Stop(); - if (backend_.get()) - backend_->DeactivateDataType(data_type_controller, change_processor); + if (!backend_.get()) + return; + backend_->DeactivateDataType(data_type_controller, change_processor); } void ProfileSyncService::SetPassphrase(const std::string& passphrase, diff --git a/chrome/browser/sync/profile_sync_service.h b/chrome/browser/sync/profile_sync_service.h index fa203a8..490d050 100644 --- a/chrome/browser/sync/profile_sync_service.h +++ b/chrome/browser/sync/profile_sync_service.h @@ -396,6 +396,7 @@ class ProfileSyncService : public browser_sync::SyncFrontend, syncable::AutofillMigrationDebugInfo::PropertyToSet property_to_set, const syncable::AutofillMigrationDebugInfo& info); + // TODO(zea): Remove these and have the dtc's call directly into the SBH. virtual void ActivateDataType( browser_sync::DataTypeController* data_type_controller, browser_sync::ChangeProcessor* change_processor); diff --git a/chrome/browser/sync/profile_sync_service_preference_unittest.cc b/chrome/browser/sync/profile_sync_service_preference_unittest.cc index db01007..12488bc 100644 --- a/chrome/browser/sync/profile_sync_service_preference_unittest.cc +++ b/chrome/browser/sync/profile_sync_service_preference_unittest.cc @@ -9,12 +9,12 @@ #include "base/stl_util-inl.h" #include "base/string_piece.h" #include "base/task.h" +#include "chrome/browser/prefs/pref_model_associator.h" #include "chrome/browser/prefs/scoped_user_pref_update.h" #include "chrome/browser/sync/abstract_profile_sync_service_test.h" #include "chrome/browser/sync/engine/syncapi.h" -#include "chrome/browser/sync/glue/preference_change_processor.h" +#include "chrome/browser/sync/glue/generic_change_processor.h" #include "chrome/browser/sync/glue/preference_data_type_controller.h" -#include "chrome/browser/sync/glue/preference_model_associator.h" #include "chrome/browser/sync/glue/sync_backend_host.h" #include "chrome/browser/sync/profile_sync_test_util.h" #include "chrome/browser/sync/protocol/preference_specifics.pb.h" @@ -29,9 +29,8 @@ #include "testing/gtest/include/gtest/gtest.h" using base::JSONReader; -using browser_sync::PreferenceChangeProcessor; +using browser_sync::GenericChangeProcessor; using browser_sync::PreferenceDataTypeController; -using browser_sync::PreferenceModelAssociator; using browser_sync::SyncBackendHost; using sync_api::SyncManager; using testing::_; @@ -57,7 +56,8 @@ class ProfileSyncServicePreferenceTest prefs_ = profile_->GetTestingPrefService(); prefs_->RegisterStringPref(not_synced_preference_name_.c_str(), - not_synced_preference_default_value_); + not_synced_preference_default_value_, + PrefService::UNSYNCABLE_PREF); } virtual void TearDown() { @@ -72,12 +72,10 @@ class ProfileSyncServicePreferenceTest service_.reset(new TestProfileSyncService( &factory_, profile_.get(), "test", false, task)); - - // Register the preference data type. model_associator_ = - new PreferenceModelAssociator(service_.get()); - change_processor_ = new PreferenceChangeProcessor(model_associator_, - service_.get()); + reinterpret_cast<PrefModelAssociator*>(prefs_->GetSyncableService()); + change_processor_ = new GenericChangeProcessor(model_associator_, + service_.get()); EXPECT_CALL(factory_, CreatePreferenceSyncComponents(_, _)). WillOnce(Return(ProfileSyncFactory::SyncComponents( model_associator_, change_processor_))); @@ -85,12 +83,13 @@ class ProfileSyncServicePreferenceTest EXPECT_CALL(factory_, CreateDataTypeManager(_, _)). WillOnce(ReturnNewDataTypeManager()); - service_->RegisterDataTypeController( - new PreferenceDataTypeController(&factory_, - profile_.get(), - service_.get())); + dtc_ = new PreferenceDataTypeController(&factory_, + profile_.get(), + service_.get()); + service_->RegisterDataTypeController(dtc_); profile_->GetTokenService()->IssueAuthTokenForTest( GaiaConstants::kSyncService, "token"); + service_->Initialize(); MessageLoop::current()->Run(); return true; @@ -123,7 +122,7 @@ class ProfileSyncServicePreferenceTest int64 WriteSyncedValue(const std::string& name, const Value& value, sync_api::WriteNode* node) { - if (!PreferenceModelAssociator::WritePreferenceToNode(name, value, node)) + if (!PrefModelAssociator::WritePreferenceToNode(name, value, node)) return sync_api::kInvalidId; return node->GetId(); } @@ -131,8 +130,10 @@ class ProfileSyncServicePreferenceTest int64 SetSyncedValue(const std::string& name, const Value& value) { sync_api::WriteTransaction trans(service_->GetUserShare()); sync_api::ReadNode root(&trans); - if (!root.InitByTagLookup(browser_sync::kPreferencesTag)) + if (!root.InitByTagLookup( + syncable::ModelTypeToRootTag(syncable::PREFERENCES))) { return sync_api::kInvalidId; + } sync_api::WriteNode tag_node(&trans); sync_api::WriteNode node(&trans); @@ -174,8 +175,10 @@ class ProfileSyncServicePreferenceTest scoped_ptr<TestingProfile> profile_; TestingPrefService* prefs_; - PreferenceModelAssociator* model_associator_; - PreferenceChangeProcessor* change_processor_; + PreferenceDataTypeController* dtc_; + PrefModelAssociator* model_associator_; + GenericChangeProcessor* change_processor_; + std::string example_url0_; std::string example_url1_; std::string example_url2_; @@ -223,7 +226,7 @@ TEST_F(ProfileSyncServicePreferenceTest, WritePreferenceToNode) { EXPECT_TRUE(node.InitByClientTagLookup(syncable::PREFERENCES, prefs::kHomePage)); - EXPECT_TRUE(PreferenceModelAssociator::WritePreferenceToNode( + EXPECT_TRUE(PrefModelAssociator::WritePreferenceToNode( pref->name(), *pref->GetValue(), &node)); EXPECT_EQ(UTF8ToWide(prefs::kHomePage), node.GetTitle()); const sync_pb::PreferenceSpecifics& specifics(node.GetPreferenceSpecifics()); diff --git a/chrome/browser/sync/signin_manager.cc b/chrome/browser/sync/signin_manager.cc index b052175..1ec73e2 100644 --- a/chrome/browser/sync/signin_manager.cc +++ b/chrome/browser/sync/signin_manager.cc @@ -21,7 +21,9 @@ SigninManager::~SigninManager() {} // static void SigninManager::RegisterUserPrefs(PrefService* user_prefs) { - user_prefs->RegisterStringPref(prefs::kGoogleServicesUsername, ""); + user_prefs->RegisterStringPref(prefs::kGoogleServicesUsername, + "", + PrefService::UNSYNCABLE_PREF); } void SigninManager::Initialize(Profile* profile) { diff --git a/chrome/browser/sync/syncable_service.cc b/chrome/browser/sync/syncable_service.cc new file mode 100644 index 0000000..f8e7d51 --- /dev/null +++ b/chrome/browser/sync/syncable_service.cc @@ -0,0 +1,9 @@ +// Copyright (c) 2011 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 "chrome/browser/sync/syncable_service.h" + +SyncableService::SyncableService() {} + +SyncableService::~SyncableService() {} diff --git a/chrome/browser/sync/syncable_service.h b/chrome/browser/sync/syncable_service.h new file mode 100644 index 0000000..9b06ea8 --- /dev/null +++ b/chrome/browser/sync/syncable_service.h @@ -0,0 +1,55 @@ +// Copyright (c) 2011 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. + +#ifndef CHROME_BROWSER_SYNC_SYNCABLE_SERVICE_H_ +#define CHROME_BROWSER_SYNC_SYNCABLE_SERVICE_H_ +#pragma once + +#include "chrome/browser/sync/engine/syncapi.h" // TODO(zea): remove this. +#include "chrome/browser/sync/glue/model_associator.h" + +class ProfileSyncService; + +namespace browser_sync { +class GenericChangeProcessor; +} + +// TODO(sync): Define SyncData type for passing sync changes here. + +// TODO(sync): Have this become an independent class and deprecate +// AssociatorInterface. +class SyncableService : public browser_sync::AssociatorInterface { + public: + SyncableService(); + virtual ~SyncableService(); + + // Future methods for SyncableService: + // StartSyncing + // StopSyncing + // GetAllSyncData + // ProcessNewSyncData (replaces ApplyChangeFromSync) + + // TODO(sync): remove these once we switch to the real SyncableService + // interface. This just keeps us going while we use the model associator/ + // change processor way of things. + + // AssociatorInterface implementation. + virtual bool AssociateModels() = 0; + virtual bool DisassociateModels() = 0; + virtual bool SyncModelHasUserCreatedNodes(bool* has_nodes) = 0; + virtual void AbortAssociation() = 0; + virtual bool CryptoReadyIfNecessary() = 0; + + // Receive changes from change processor (the ChangeRecord dependency is + // the reason we must include syncapi.h). + virtual void ApplyChangesFromSync( + const sync_api::BaseTransaction* trans, + const sync_api::SyncManager::ChangeRecord* changes, + int change_count) = 0; + virtual void SetupSync( + ProfileSyncService* sync_service, + browser_sync::GenericChangeProcessor* change_processor) = 0; +}; + +#endif // CHROME_BROWSER_SYNC_SYNCABLE_SERVICE_H_ diff --git a/chrome/browser/sync/syncable_service_mock.cc b/chrome/browser/sync/syncable_service_mock.cc new file mode 100644 index 0000000..3050fde --- /dev/null +++ b/chrome/browser/sync/syncable_service_mock.cc @@ -0,0 +1,9 @@ +// Copyright (c) 2011 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 "chrome/browser/sync/syncable_service_mock.h" + +SyncableServiceMock::SyncableServiceMock() {} + +SyncableServiceMock::~SyncableServiceMock() {} diff --git a/chrome/browser/sync/syncable_service_mock.h b/chrome/browser/sync/syncable_service_mock.h new file mode 100644 index 0000000..b1ea235 --- /dev/null +++ b/chrome/browser/sync/syncable_service_mock.h @@ -0,0 +1,31 @@ +// Copyright (c) 2011 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. + +#ifndef CHROME_BROWSER_SYNC_SYNCABLE_SERVICE_MOCK_H_ +#define CHROME_BROWSER_SYNC_SYNCABLE_SERVICE_MOCK_H_ +#pragma once + +#include "chrome/browser/sync/syncable_service.h" +#include "testing/gmock/include/gmock/gmock.h" + +class SyncableServiceMock : public SyncableService { + public: + SyncableServiceMock(); + virtual ~SyncableServiceMock(); + + MOCK_METHOD0(AssociateModels, bool()); + MOCK_METHOD0(DisassociateModels, bool()); + MOCK_METHOD1(SyncModelHasUserCreatedNodes, bool(bool* has_nodes)); + MOCK_METHOD0(AbortAssociation, void()); + MOCK_METHOD0(CryptoReadyIfNecessary, bool()); + MOCK_METHOD3(ApplyChangesFromSync, void( + const sync_api::BaseTransaction* trans, + const sync_api::SyncManager::ChangeRecord* changes, + int change_count)); + MOCK_METHOD2(SetupSync, void( + ProfileSyncService* sync_service, + browser_sync::GenericChangeProcessor* change_processor)); +}; + +#endif // CHROME_BROWSER_SYNC_SYNCABLE_SERVICE_MOCK_H_ diff --git a/chrome/browser/tabs/pinned_tab_codec.cc b/chrome/browser/tabs/pinned_tab_codec.cc index 91279e0..1dfc57e 100644 --- a/chrome/browser/tabs/pinned_tab_codec.cc +++ b/chrome/browser/tabs/pinned_tab_codec.cc @@ -89,7 +89,7 @@ static bool DecodeTab(const DictionaryValue& value, Tab* tab) { // static void PinnedTabCodec::RegisterUserPrefs(PrefService* prefs) { - prefs->RegisterListPref(prefs::kPinnedTabs); + prefs->RegisterListPref(prefs::kPinnedTabs, PrefService::UNSYNCABLE_PREF); } // static diff --git a/chrome/browser/translate/translate_prefs.cc b/chrome/browser/translate/translate_prefs.cc index cc04f42..3aca798 100644 --- a/chrome/browser/translate/translate_prefs.cc +++ b/chrome/browser/translate/translate_prefs.cc @@ -152,17 +152,22 @@ bool TranslatePrefs::ShouldAutoTranslate(PrefService* user_prefs, void TranslatePrefs::RegisterUserPrefs(PrefService* user_prefs) { if (!user_prefs->FindPreference(kPrefTranslateLanguageBlacklist)) - user_prefs->RegisterListPref(kPrefTranslateLanguageBlacklist); + user_prefs->RegisterListPref(kPrefTranslateLanguageBlacklist, + PrefService::SYNCABLE_PREF); if (!user_prefs->FindPreference(kPrefTranslateSiteBlacklist)) - user_prefs->RegisterListPref(kPrefTranslateSiteBlacklist); + user_prefs->RegisterListPref(kPrefTranslateSiteBlacklist, + PrefService::SYNCABLE_PREF); if (!user_prefs->FindPreference(kPrefTranslateWhitelists)) { - user_prefs->RegisterDictionaryPref(kPrefTranslateWhitelists); + user_prefs->RegisterDictionaryPref(kPrefTranslateWhitelists, + PrefService::SYNCABLE_PREF); MigrateTranslateWhitelists(user_prefs); } if (!user_prefs->FindPreference(kPrefTranslateDeniedCount)) - user_prefs->RegisterDictionaryPref(kPrefTranslateDeniedCount); + user_prefs->RegisterDictionaryPref(kPrefTranslateDeniedCount, + PrefService::SYNCABLE_PREF); if (!user_prefs->FindPreference(kPrefTranslateAcceptedCount)) - user_prefs->RegisterDictionaryPref(kPrefTranslateAcceptedCount); + user_prefs->RegisterDictionaryPref(kPrefTranslateAcceptedCount, + PrefService::SYNCABLE_PREF); } // TranslatePrefs: private, static: -------------------------------------------- diff --git a/chrome/browser/ui/browser.cc b/chrome/browser/ui/browser.cc index 5cbc616..41716b5 100644 --- a/chrome/browser/ui/browser.cc +++ b/chrome/browser/ui/browser.cc @@ -2089,9 +2089,14 @@ void Browser::RegisterPrefs(PrefService* prefs) { // static void Browser::RegisterUserPrefs(PrefService* prefs) { prefs->RegisterStringPref(prefs::kHomePage, - chrome::kChromeUINewTabURL); - prefs->RegisterBooleanPref(prefs::kHomePageIsNewTabPage, true); - prefs->RegisterBooleanPref(prefs::kShowHomeButton, false); + chrome::kChromeUINewTabURL, + PrefService::SYNCABLE_PREF); + prefs->RegisterBooleanPref(prefs::kHomePageIsNewTabPage, + true, + PrefService::SYNCABLE_PREF); + prefs->RegisterBooleanPref(prefs::kShowHomeButton, + false, + PrefService::SYNCABLE_PREF); #if defined(OS_MACOSX) // This really belongs in platform code, but there's no good place to // initialize it between the time when the AppController is created @@ -2101,46 +2106,112 @@ void Browser::RegisterUserPrefs(PrefService* prefs) { // pref to be already initialized. Doing it here also saves us from having // to hard-code pref registration in the several unit tests that use // this preference. - prefs->RegisterBooleanPref(prefs::kConfirmToQuitEnabled, false); - prefs->RegisterBooleanPref(prefs::kShowUpdatePromotionInfoBar, true); + prefs->RegisterBooleanPref(prefs::kConfirmToQuitEnabled, + false, + PrefService::SYNCABLE_PREF); + prefs->RegisterBooleanPref(prefs::kShowUpdatePromotionInfoBar, + true, + PrefService::UNSYNCABLE_PREF); #endif - prefs->RegisterBooleanPref(prefs::kDeleteBrowsingHistory, true); - prefs->RegisterBooleanPref(prefs::kDeleteDownloadHistory, true); - prefs->RegisterBooleanPref(prefs::kDeleteCache, true); - prefs->RegisterBooleanPref(prefs::kDeleteCookies, true); - prefs->RegisterBooleanPref(prefs::kDeletePasswords, false); - prefs->RegisterBooleanPref(prefs::kDeleteFormData, false); - prefs->RegisterIntegerPref(prefs::kDeleteTimePeriod, 0); - prefs->RegisterBooleanPref(prefs::kCheckDefaultBrowser, true); - prefs->RegisterBooleanPref(prefs::kShowOmniboxSearchHint, true); - prefs->RegisterBooleanPref(prefs::kWebAppCreateOnDesktop, true); - prefs->RegisterBooleanPref(prefs::kWebAppCreateInAppsMenu, true); - prefs->RegisterBooleanPref(prefs::kWebAppCreateInQuickLaunchBar, true); - prefs->RegisterBooleanPref(prefs::kUseVerticalTabs, false); - prefs->RegisterBooleanPref(prefs::kEnableTranslate, true); - prefs->RegisterBooleanPref(prefs::kEnableBookmarkBar, true); - prefs->RegisterBooleanPref(prefs::kRemotingHasSetupCompleted, false); - prefs->RegisterBooleanPref(prefs::kChromotingEnabled, false); - prefs->RegisterBooleanPref(prefs::kChromotingHostEnabled, false); - prefs->RegisterBooleanPref(prefs::kChromotingHostFirewallTraversal, false); - prefs->RegisterStringPref(prefs::kCloudPrintEmail, std::string()); - prefs->RegisterBooleanPref(prefs::kCloudPrintProxyEnabled, true); - prefs->RegisterBooleanPref(prefs::kDevToolsDisabled, false); - prefs->RegisterBooleanPref(prefs::kIncognitoEnabled, true); - prefs->RegisterIntegerPref(prefs::kDevToolsSplitLocation, -1); - prefs->RegisterDictionaryPref(prefs::kBrowserWindowPlacement); - prefs->RegisterDictionaryPref(prefs::kPreferencesWindowPlacement); + prefs->RegisterBooleanPref(prefs::kDeleteBrowsingHistory, + true, + PrefService::SYNCABLE_PREF); + prefs->RegisterBooleanPref(prefs::kDeleteDownloadHistory, + true, + PrefService::SYNCABLE_PREF); + prefs->RegisterBooleanPref(prefs::kDeleteCache, + true, + PrefService::SYNCABLE_PREF); + prefs->RegisterBooleanPref(prefs::kDeleteCookies, + true, + PrefService::SYNCABLE_PREF); + prefs->RegisterBooleanPref(prefs::kDeletePasswords, + false, + PrefService::SYNCABLE_PREF); + prefs->RegisterBooleanPref(prefs::kDeleteFormData, + false, + PrefService::SYNCABLE_PREF); + prefs->RegisterIntegerPref(prefs::kDeleteTimePeriod, + 0, + PrefService::SYNCABLE_PREF); + prefs->RegisterBooleanPref(prefs::kCheckDefaultBrowser, + true, + PrefService::UNSYNCABLE_PREF); + prefs->RegisterBooleanPref(prefs::kShowOmniboxSearchHint, + true, + PrefService::UNSYNCABLE_PREF); + prefs->RegisterBooleanPref(prefs::kWebAppCreateOnDesktop, + true, + PrefService::UNSYNCABLE_PREF); + prefs->RegisterBooleanPref(prefs::kWebAppCreateInAppsMenu, + true, + PrefService::UNSYNCABLE_PREF); + prefs->RegisterBooleanPref(prefs::kWebAppCreateInQuickLaunchBar, + true, + PrefService::UNSYNCABLE_PREF); + prefs->RegisterBooleanPref(prefs::kUseVerticalTabs, + false, + PrefService::UNSYNCABLE_PREF); + prefs->RegisterBooleanPref(prefs::kEnableTranslate, + true, + PrefService::SYNCABLE_PREF); + prefs->RegisterBooleanPref(prefs::kEnableBookmarkBar, + true, + PrefService::UNSYNCABLE_PREF); + prefs->RegisterBooleanPref(prefs::kRemotingHasSetupCompleted, + false, + PrefService::UNSYNCABLE_PREF); + prefs->RegisterBooleanPref(prefs::kChromotingEnabled, + false, + PrefService::UNSYNCABLE_PREF); + prefs->RegisterBooleanPref(prefs::kChromotingHostEnabled, + false, + PrefService::UNSYNCABLE_PREF); + prefs->RegisterBooleanPref(prefs::kChromotingHostFirewallTraversal, + false, + PrefService::UNSYNCABLE_PREF); + prefs->RegisterStringPref(prefs::kCloudPrintEmail, + std::string(), + PrefService::UNSYNCABLE_PREF); + prefs->RegisterBooleanPref(prefs::kCloudPrintProxyEnabled, + true, + PrefService::UNSYNCABLE_PREF); + prefs->RegisterBooleanPref(prefs::kDevToolsDisabled, + false, + PrefService::UNSYNCABLE_PREF); + prefs->RegisterBooleanPref(prefs::kIncognitoEnabled, + true, + PrefService::UNSYNCABLE_PREF); + prefs->RegisterIntegerPref(prefs::kDevToolsSplitLocation, + -1, + PrefService::UNSYNCABLE_PREF); + prefs->RegisterDictionaryPref(prefs::kBrowserWindowPlacement, + PrefService::UNSYNCABLE_PREF); + prefs->RegisterDictionaryPref(prefs::kPreferencesWindowPlacement, + PrefService::UNSYNCABLE_PREF); // We need to register the type of these preferences in order to query - // them even though they're typically only controlled via policy or command - // line switches. - prefs->RegisterBooleanPref(prefs::kDisable3DAPIs, false); - prefs->RegisterBooleanPref(prefs::kPluginsAllowOutdated, false); - prefs->RegisterBooleanPref(prefs::kPluginsAlwaysAuthorize, false); - prefs->RegisterBooleanPref(prefs::kEnableHyperlinkAuditing, true); - prefs->RegisterBooleanPref(prefs::kEnableReferrers, true); - prefs->RegisterBooleanPref(prefs::kWebKitAllowRunningInsecureContent, false); + // them even though they're only typically controlled via policy. + prefs->RegisterBooleanPref(prefs::kDisable3DAPIs, + false, + PrefService::UNSYNCABLE_PREF); + prefs->RegisterBooleanPref(prefs::kPluginsAllowOutdated, + false, + PrefService::UNSYNCABLE_PREF); + prefs->RegisterBooleanPref(prefs::kPluginsAlwaysAuthorize, + false, + PrefService::UNSYNCABLE_PREF); + prefs->RegisterBooleanPref(prefs::kEnableHyperlinkAuditing, + true, + PrefService::UNSYNCABLE_PREF); + prefs->RegisterBooleanPref(prefs::kEnableReferrers, + true, + PrefService::UNSYNCABLE_PREF); + prefs->RegisterBooleanPref(prefs::kWebKitAllowRunningInsecureContent, + false, + PrefService::UNSYNCABLE_PREF); prefs->RegisterBooleanPref(prefs::kWebKitAllowDisplayingInsecureContent, - true); + true, + PrefService::UNSYNCABLE_PREF); } // static @@ -4363,8 +4434,10 @@ void Browser::RegisterAppPrefs(const std::string& app_name, Profile* profile) { window_pref.append("_"); window_pref.append(app_name); PrefService* prefs = profile->GetPrefs(); - if (!prefs->FindPreference(window_pref.c_str())) - prefs->RegisterDictionaryPref(window_pref.c_str()); + if (!prefs->FindPreference(window_pref.c_str())) { + prefs->RegisterDictionaryPref(window_pref.c_str(), + PrefService::UNSYNCABLE_PREF); + } } void Browser::TabRestoreServiceChanged(TabRestoreService* service) { diff --git a/chrome/browser/ui/cocoa/extensions/browser_actions_controller.mm b/chrome/browser/ui/cocoa/extensions/browser_actions_controller.mm index 4cb1774..279be6c 100644 --- a/chrome/browser/ui/cocoa/extensions/browser_actions_controller.mm +++ b/chrome/browser/ui/cocoa/extensions/browser_actions_controller.mm @@ -417,7 +417,9 @@ class ExtensionServiceObserverBridge : public NotificationObserver, } + (void)registerUserPrefs:(PrefService*)prefs { - prefs->RegisterDoublePref(prefs::kBrowserActionContainerWidth, 0); + prefs->RegisterDoublePref(prefs::kBrowserActionContainerWidth, + 0, + PrefService::UNSYNCABLE_PREF); } #pragma mark - diff --git a/chrome/browser/ui/cocoa/window_size_autosaver_unittest.mm b/chrome/browser/ui/cocoa/window_size_autosaver_unittest.mm index 7b93717..70d0b09 100644 --- a/chrome/browser/ui/cocoa/window_size_autosaver_unittest.mm +++ b/chrome/browser/ui/cocoa/window_size_autosaver_unittest.mm @@ -26,7 +26,9 @@ class WindowSizeAutosaverTest : public CocoaTest { NSResizableWindowMask backing:NSBackingStoreBuffered defer:NO]; - browser_helper_.profile()->GetPrefs()->RegisterDictionaryPref(path_); + browser_helper_.profile()->GetPrefs()->RegisterDictionaryPref( + path_, + PrefService::UNSYNCABLE_PREF); } virtual void TearDown() { diff --git a/chrome/browser/ui/gtk/browser_window_gtk.cc b/chrome/browser/ui/gtk/browser_window_gtk.cc index 67ed90b..36bc6fa 100644 --- a/chrome/browser/ui/gtk/browser_window_gtk.cc +++ b/chrome/browser/ui/gtk/browser_window_gtk.cc @@ -1512,8 +1512,9 @@ void BrowserWindowGtk::RegisterUserPrefs(PrefService* prefs) { !prefs->HasPrefPath(prefs::kUseCustomChromeFrame)) { custom_frame_default = GetCustomFramePrefDefault(); } - prefs->RegisterBooleanPref( - prefs::kUseCustomChromeFrame, custom_frame_default); + prefs->RegisterBooleanPref(prefs::kUseCustomChromeFrame, + custom_frame_default, + PrefService::SYNCABLE_PREF); } void BrowserWindowGtk::BookmarkBarIsFloating(bool is_floating) { diff --git a/chrome/browser/ui/tab_contents/tab_contents_wrapper.cc b/chrome/browser/ui/tab_contents/tab_contents_wrapper.cc index 7437b8f..6e4a979 100644 --- a/chrome/browser/ui/tab_contents/tab_contents_wrapper.cc +++ b/chrome/browser/ui/tab_contents/tab_contents_wrapper.cc @@ -109,60 +109,97 @@ PropertyAccessor<TabContentsWrapper*>* TabContentsWrapper::property_accessor() { } void TabContentsWrapper::RegisterUserPrefs(PrefService* prefs) { - prefs->RegisterBooleanPref(prefs::kAlternateErrorPagesEnabled, true); + prefs->RegisterBooleanPref(prefs::kAlternateErrorPagesEnabled, + true, + PrefService::SYNCABLE_PREF); WebPreferences pref_defaults; prefs->RegisterBooleanPref(prefs::kWebKitJavascriptEnabled, - pref_defaults.javascript_enabled); + pref_defaults.javascript_enabled, + PrefService::UNSYNCABLE_PREF); prefs->RegisterBooleanPref(prefs::kWebKitWebSecurityEnabled, - pref_defaults.web_security_enabled); + pref_defaults.web_security_enabled, + PrefService::UNSYNCABLE_PREF); prefs->RegisterBooleanPref( - prefs::kWebKitJavascriptCanOpenWindowsAutomatically, true); + prefs::kWebKitJavascriptCanOpenWindowsAutomatically, + true, + PrefService::UNSYNCABLE_PREF); prefs->RegisterBooleanPref(prefs::kWebKitLoadsImagesAutomatically, - pref_defaults.loads_images_automatically); + pref_defaults.loads_images_automatically, + PrefService::UNSYNCABLE_PREF); prefs->RegisterBooleanPref(prefs::kWebKitPluginsEnabled, - pref_defaults.plugins_enabled); + pref_defaults.plugins_enabled, + PrefService::UNSYNCABLE_PREF); prefs->RegisterBooleanPref(prefs::kWebKitDomPasteEnabled, - pref_defaults.dom_paste_enabled); + pref_defaults.dom_paste_enabled, + PrefService::UNSYNCABLE_PREF); prefs->RegisterBooleanPref(prefs::kWebKitShrinksStandaloneImagesToFit, - pref_defaults.shrinks_standalone_images_to_fit); - prefs->RegisterDictionaryPref(prefs::kWebKitInspectorSettings); + pref_defaults.shrinks_standalone_images_to_fit, + PrefService::UNSYNCABLE_PREF); + prefs->RegisterDictionaryPref(prefs::kWebKitInspectorSettings, + PrefService::UNSYNCABLE_PREF); prefs->RegisterBooleanPref(prefs::kWebKitTextAreasAreResizable, - pref_defaults.text_areas_are_resizable); + pref_defaults.text_areas_are_resizable, + PrefService::UNSYNCABLE_PREF); prefs->RegisterBooleanPref(prefs::kWebKitJavaEnabled, - pref_defaults.java_enabled); + pref_defaults.java_enabled, + PrefService::UNSYNCABLE_PREF); prefs->RegisterBooleanPref(prefs::kWebkitTabsToLinks, - pref_defaults.tabs_to_links); + pref_defaults.tabs_to_links, + PrefService::UNSYNCABLE_PREF); +#if !defined(OS_MACOSX) prefs->RegisterLocalizedStringPref(prefs::kAcceptLanguages, - IDS_ACCEPT_LANGUAGES); + IDS_ACCEPT_LANGUAGES, + PrefService::SYNCABLE_PREF); +#else + // Not used in OSX. + prefs->RegisterLocalizedStringPref(prefs::kAcceptLanguages, + IDS_ACCEPT_LANGUAGES, + PrefService::UNSYNCABLE_PREF); +#endif prefs->RegisterLocalizedStringPref(prefs::kDefaultCharset, - IDS_DEFAULT_ENCODING); + IDS_DEFAULT_ENCODING, + PrefService::SYNCABLE_PREF); prefs->RegisterLocalizedStringPref(prefs::kWebKitStandardFontFamily, - IDS_STANDARD_FONT_FAMILY); + IDS_STANDARD_FONT_FAMILY, + PrefService::UNSYNCABLE_PREF); prefs->RegisterLocalizedStringPref(prefs::kWebKitFixedFontFamily, - IDS_FIXED_FONT_FAMILY); + IDS_FIXED_FONT_FAMILY, + PrefService::UNSYNCABLE_PREF); prefs->RegisterLocalizedStringPref(prefs::kWebKitSerifFontFamily, - IDS_SERIF_FONT_FAMILY); + IDS_SERIF_FONT_FAMILY, + PrefService::UNSYNCABLE_PREF); prefs->RegisterLocalizedStringPref(prefs::kWebKitSansSerifFontFamily, - IDS_SANS_SERIF_FONT_FAMILY); + IDS_SANS_SERIF_FONT_FAMILY, + PrefService::UNSYNCABLE_PREF); prefs->RegisterLocalizedStringPref(prefs::kWebKitCursiveFontFamily, - IDS_CURSIVE_FONT_FAMILY); + IDS_CURSIVE_FONT_FAMILY, + PrefService::UNSYNCABLE_PREF); prefs->RegisterLocalizedStringPref(prefs::kWebKitFantasyFontFamily, - IDS_FANTASY_FONT_FAMILY); + IDS_FANTASY_FONT_FAMILY, + PrefService::UNSYNCABLE_PREF); prefs->RegisterLocalizedIntegerPref(prefs::kWebKitDefaultFontSize, - IDS_DEFAULT_FONT_SIZE); + IDS_DEFAULT_FONT_SIZE, + PrefService::UNSYNCABLE_PREF); prefs->RegisterLocalizedIntegerPref(prefs::kWebKitDefaultFixedFontSize, - IDS_DEFAULT_FIXED_FONT_SIZE); + IDS_DEFAULT_FIXED_FONT_SIZE, + PrefService::UNSYNCABLE_PREF); prefs->RegisterLocalizedIntegerPref(prefs::kWebKitMinimumFontSize, - IDS_MINIMUM_FONT_SIZE); + IDS_MINIMUM_FONT_SIZE, + PrefService::UNSYNCABLE_PREF); prefs->RegisterLocalizedIntegerPref(prefs::kWebKitMinimumLogicalFontSize, - IDS_MINIMUM_LOGICAL_FONT_SIZE); + IDS_MINIMUM_LOGICAL_FONT_SIZE, + PrefService::UNSYNCABLE_PREF); prefs->RegisterLocalizedBooleanPref(prefs::kWebKitUsesUniversalDetector, - IDS_USES_UNIVERSAL_DETECTOR); + IDS_USES_UNIVERSAL_DETECTOR, + PrefService::SYNCABLE_PREF); prefs->RegisterLocalizedStringPref(prefs::kStaticEncodings, - IDS_STATIC_ENCODING_LIST); - prefs->RegisterStringPref(prefs::kRecentlySelectedEncoding, ""); + IDS_STATIC_ENCODING_LIST, + PrefService::UNSYNCABLE_PREF); + prefs->RegisterStringPref(prefs::kRecentlySelectedEncoding, + "", + PrefService::UNSYNCABLE_PREF); } string16 TabContentsWrapper::GetDefaultTitle() { diff --git a/chrome/browser/ui/views/browser_actions_container.cc b/chrome/browser/ui/views/browser_actions_container.cc index 942d92d..70b8df3 100644 --- a/chrome/browser/ui/views/browser_actions_container.cc +++ b/chrome/browser/ui/views/browser_actions_container.cc @@ -391,7 +391,9 @@ BrowserActionsContainer::~BrowserActionsContainer() { // Static. void BrowserActionsContainer::RegisterUserPrefs(PrefService* prefs) { - prefs->RegisterIntegerPref(prefs::kBrowserActionContainerWidth, 0); + prefs->RegisterIntegerPref(prefs::kBrowserActionContainerWidth, + 0, + PrefService::UNSYNCABLE_PREF); } void BrowserActionsContainer::Init() { diff --git a/chrome/browser/ui/webui/ntp/most_visited_handler.cc b/chrome/browser/ui/webui/ntp/most_visited_handler.cc index 8b145f3..d6063a6 100644 --- a/chrome/browser/ui/webui/ntp/most_visited_handler.cc +++ b/chrome/browser/ui/webui/ntp/most_visited_handler.cc @@ -368,8 +368,10 @@ std::string MostVisitedHandler::GetDictionaryKeyForURL(const std::string& url) { // static void MostVisitedHandler::RegisterUserPrefs(PrefService* prefs) { - prefs->RegisterDictionaryPref(prefs::kNTPMostVisitedURLsBlacklist); - prefs->RegisterDictionaryPref(prefs::kNTPMostVisitedPinnedURLs); + prefs->RegisterDictionaryPref(prefs::kNTPMostVisitedURLsBlacklist, + PrefService::UNSYNCABLE_PREF); + prefs->RegisterDictionaryPref(prefs::kNTPMostVisitedPinnedURLs, + PrefService::UNSYNCABLE_PREF); } // static diff --git a/chrome/browser/ui/webui/ntp/new_tab_ui.cc b/chrome/browser/ui/webui/ntp/new_tab_ui.cc index ba1b8d0..1431437 100644 --- a/chrome/browser/ui/webui/ntp/new_tab_ui.cc +++ b/chrome/browser/ui/webui/ntp/new_tab_ui.cc @@ -461,7 +461,9 @@ void NewTabUI::InitializeCSSCaches() { // static void NewTabUI::RegisterUserPrefs(PrefService* prefs) { - prefs->RegisterIntegerPref(prefs::kNTPPrefVersion, 0); + prefs->RegisterIntegerPref(prefs::kNTPPrefVersion, + 0, + PrefService::UNSYNCABLE_PREF); MostVisitedHandler::RegisterUserPrefs(prefs); ShownSectionsHandler::RegisterUserPrefs(prefs); diff --git a/chrome/browser/ui/webui/ntp/shown_sections_handler.cc b/chrome/browser/ui/webui/ntp/shown_sections_handler.cc index 003c34f..fdc42a8 100644 --- a/chrome/browser/ui/webui/ntp/shown_sections_handler.cc +++ b/chrome/browser/ui/webui/ntp/shown_sections_handler.cc @@ -105,9 +105,12 @@ void ShownSectionsHandler::RegisterUserPrefs(PrefService* pref_service) { #if defined(OS_CHROMEOS) // Default to have expanded APPS and all other sections are minimized. pref_service->RegisterIntegerPref(prefs::kNTPShownSections, - APPS | MENU_THUMB | MENU_RECENT); + APPS | MENU_THUMB | MENU_RECENT, + PrefService::UNSYNCABLE_PREF); #else - pref_service->RegisterIntegerPref(prefs::kNTPShownSections, THUMB); + pref_service->RegisterIntegerPref(prefs::kNTPShownSections, + THUMB, + PrefService::UNSYNCABLE_PREF); #endif } diff --git a/chrome/browser/ui/webui/options/extension_settings_handler.cc b/chrome/browser/ui/webui/options/extension_settings_handler.cc index 5f47f7c..0aa8434 100644 --- a/chrome/browser/ui/webui/options/extension_settings_handler.cc +++ b/chrome/browser/ui/webui/options/extension_settings_handler.cc @@ -919,5 +919,7 @@ RefCountedMemory* ExtensionsUI::GetFaviconResourceBytes() { // static void ExtensionsUI::RegisterUserPrefs(PrefService* prefs) { - prefs->RegisterBooleanPref(prefs::kExtensionsUIDeveloperMode, false); + prefs->RegisterBooleanPref(prefs::kExtensionsUIDeveloperMode, + false, + PrefService::SYNCABLE_PREF); } diff --git a/chrome/browser/ui/webui/plugins_ui.cc b/chrome/browser/ui/webui/plugins_ui.cc index af93b93..7672fd4 100644 --- a/chrome/browser/ui/webui/plugins_ui.cc +++ b/chrome/browser/ui/webui/plugins_ui.cc @@ -368,8 +368,15 @@ RefCountedMemory* PluginsUI::GetFaviconResourceBytes() { // static void PluginsUI::RegisterUserPrefs(PrefService* prefs) { - prefs->RegisterListPref(prefs::kPluginsPluginsList); - prefs->RegisterBooleanPref(prefs::kPluginsEnabledInternalPDF, false); - prefs->RegisterBooleanPref(prefs::kPluginsShowDetails, false); - prefs->RegisterBooleanPref(prefs::kPluginsShowSetReaderDefaultInfobar, true); + prefs->RegisterListPref(prefs::kPluginsPluginsList, + PrefService::UNSYNCABLE_PREF); + prefs->RegisterBooleanPref(prefs::kPluginsEnabledInternalPDF, + false, + PrefService::UNSYNCABLE_PREF); + prefs->RegisterBooleanPref(prefs::kPluginsShowDetails, + false, + PrefService::UNSYNCABLE_PREF); + prefs->RegisterBooleanPref(prefs::kPluginsShowSetReaderDefaultInfobar, + true, + PrefService::UNSYNCABLE_PREF); } diff --git a/chrome/browser/web_resource/promo_resource_service.cc b/chrome/browser/web_resource/promo_resource_service.cc index d9f526f..8d9d145 100644 --- a/chrome/browser/web_resource/promo_resource_service.cc +++ b/chrome/browser/web_resource/promo_resource_service.cc @@ -62,16 +62,34 @@ void PromoResourceService::RegisterPrefs(PrefService* local_state) { // static void PromoResourceService::RegisterUserPrefs(PrefService* prefs) { - prefs->RegisterDoublePref(prefs::kNTPCustomLogoStart, 0); - prefs->RegisterDoublePref(prefs::kNTPCustomLogoEnd, 0); - prefs->RegisterDoublePref(prefs::kNTPPromoStart, 0); - prefs->RegisterDoublePref(prefs::kNTPPromoEnd, 0); - prefs->RegisterStringPref(prefs::kNTPPromoLine, std::string()); - prefs->RegisterBooleanPref(prefs::kNTPPromoClosed, false); - prefs->RegisterIntegerPref(prefs::kNTPPromoGroup, -1); - prefs->RegisterIntegerPref(prefs::kNTPPromoBuild, - CANARY_BUILD | DEV_BUILD | BETA_BUILD | STABLE_BUILD); - prefs->RegisterIntegerPref(prefs::kNTPPromoGroupTimeSlice, 0); + prefs->RegisterDoublePref(prefs::kNTPCustomLogoStart, + 0, + PrefService::UNSYNCABLE_PREF); + prefs->RegisterDoublePref(prefs::kNTPCustomLogoEnd, + 0, + PrefService::UNSYNCABLE_PREF); + prefs->RegisterDoublePref(prefs::kNTPPromoStart, + 0, + PrefService::UNSYNCABLE_PREF); + prefs->RegisterDoublePref(prefs::kNTPPromoEnd, + 0, + PrefService::UNSYNCABLE_PREF); + prefs->RegisterStringPref(prefs::kNTPPromoLine, + std::string(), + PrefService::UNSYNCABLE_PREF); + prefs->RegisterBooleanPref(prefs::kNTPPromoClosed, + false, + PrefService::UNSYNCABLE_PREF); + prefs->RegisterIntegerPref(prefs::kNTPPromoGroup, + -1, + PrefService::UNSYNCABLE_PREF); + prefs->RegisterIntegerPref( + prefs::kNTPPromoBuild, + CANARY_BUILD | DEV_BUILD | BETA_BUILD | STABLE_BUILD, + PrefService::UNSYNCABLE_PREF); + prefs->RegisterIntegerPref(prefs::kNTPPromoGroupTimeSlice, + 0, + PrefService::UNSYNCABLE_PREF); } // static diff --git a/chrome/browser/web_resource/web_resource_service.cc b/chrome/browser/web_resource/web_resource_service.cc index 83c4b40..47496ea 100644 --- a/chrome/browser/web_resource/web_resource_service.cc +++ b/chrome/browser/web_resource/web_resource_service.cc @@ -218,7 +218,9 @@ WebResourceService::WebResourceService( web_resource_update_scheduled_(false) { DCHECK(prefs); DCHECK(profile); - prefs_->RegisterStringPref(last_update_time_pref_name, "0"); + prefs_->RegisterStringPref(last_update_time_pref_name, + "0", + PrefService::UNSYNCABLE_PREF); resource_dispatcher_host_ = g_browser_process->resource_dispatcher_host(); web_resource_fetcher_.reset(new WebResourceFetcher(this)); } diff --git a/chrome/chrome_browser.gypi b/chrome/chrome_browser.gypi index 6b5f1fa..556d94a 100644 --- a/chrome/chrome_browser.gypi +++ b/chrome/chrome_browser.gypi @@ -1595,6 +1595,8 @@ 'browser/prefs/pref_change_registrar.h', 'browser/prefs/pref_member.cc', 'browser/prefs/pref_member.h', + 'browser/prefs/pref_model_associator.cc', + 'browser/prefs/pref_model_associator.h', 'browser/prefs/pref_notifier.h', 'browser/prefs/pref_notifier_impl.cc', 'browser/prefs/pref_notifier_impl.h', @@ -1939,6 +1941,8 @@ 'browser/sync/glue/foreign_session_tracker.h', 'browser/sync/glue/frontend_data_type_controller.cc', 'browser/sync/glue/frontend_data_type_controller.h', + 'browser/sync/glue/generic_change_processor.cc', + 'browser/sync/glue/generic_change_processor.h', 'browser/sync/glue/history_model_worker.cc', 'browser/sync/glue/history_model_worker.h', 'browser/sync/glue/http_bridge.cc', @@ -1954,12 +1958,8 @@ 'browser/sync/glue/password_model_associator.h', 'browser/sync/glue/password_model_worker.cc', 'browser/sync/glue/password_model_worker.h', - 'browser/sync/glue/preference_change_processor.cc', - 'browser/sync/glue/preference_change_processor.h', 'browser/sync/glue/preference_data_type_controller.cc', 'browser/sync/glue/preference_data_type_controller.h', - 'browser/sync/glue/preference_model_associator.cc', - 'browser/sync/glue/preference_model_associator.h', 'browser/sync/glue/session_change_processor.cc', 'browser/sync/glue/session_change_processor.h', 'browser/sync/glue/session_data_type_controller.cc', @@ -1968,7 +1968,6 @@ 'browser/sync/glue/session_model_associator.h', 'browser/sync/glue/sync_backend_host.cc', 'browser/sync/glue/sync_backend_host.h', - 'browser/sync/glue/synchronized_preferences.h', 'browser/sync/glue/theme_change_processor.cc', 'browser/sync/glue/theme_change_processor.h', 'browser/sync/glue/theme_data_type_controller.cc', @@ -1997,6 +1996,8 @@ 'browser/sync/profile_sync_service_observer.h', 'browser/sync/signin_manager.cc', 'browser/sync/signin_manager.h', + 'browser/sync/syncable_service.cc', + 'browser/sync/syncable_service.h', 'browser/sync/sync_setup_flow.cc', 'browser/sync/sync_setup_flow.h', 'browser/sync/sync_setup_flow_handler.h', diff --git a/chrome/chrome_tests.gypi b/chrome/chrome_tests.gypi index 56d4aef..1aa37a0 100644 --- a/chrome/chrome_tests.gypi +++ b/chrome/chrome_tests.gypi @@ -1460,6 +1460,7 @@ 'browser/prefs/overlay_persistent_pref_store_unittest.cc', 'browser/prefs/pref_change_registrar_unittest.cc', 'browser/prefs/pref_member_unittest.cc', + 'browser/prefs/pref_model_associator_unittest.cc', 'browser/prefs/pref_notifier_impl_unittest.cc', 'browser/prefs/pref_service_unittest.cc', 'browser/prefs/pref_set_observer_unittest.cc', @@ -1547,7 +1548,6 @@ 'browser/sync/glue/non_frontend_data_type_controller_mock.h', 'browser/sync/glue/non_frontend_data_type_controller_unittest.cc', 'browser/sync/glue/preference_data_type_controller_unittest.cc', - 'browser/sync/glue/preference_model_associator_unittest.cc', 'browser/sync/glue/session_model_associator_unittest.cc', 'browser/sync/glue/sync_backend_host_mock.cc', 'browser/sync/glue/sync_backend_host_mock.h', @@ -1573,6 +1573,8 @@ 'browser/sync/sync_setup_wizard_unittest.cc', 'browser/sync/sync_ui_util_mac_unittest.mm', 'browser/sync/sync_ui_util_unittest.cc', + 'browser/sync/syncable_service_mock.cc', + 'browser/sync/syncable_service_mock.h', 'browser/sync/test_profile_sync_service.cc', 'browser/sync/test_profile_sync_service.h', 'browser/sync/util/cryptographer_unittest.cc', diff --git a/content/browser/host_zoom_map.cc b/content/browser/host_zoom_map.cc index 98ebc1c..441473c 100644 --- a/content/browser/host_zoom_map.cc +++ b/content/browser/host_zoom_map.cc @@ -72,8 +72,11 @@ void HostZoomMap::Load() { // static void HostZoomMap::RegisterUserPrefs(PrefService* prefs) { - prefs->RegisterDoublePref(prefs::kDefaultZoomLevel, 0.0); - prefs->RegisterDictionaryPref(prefs::kPerHostZoomLevels); + prefs->RegisterDoublePref(prefs::kDefaultZoomLevel, + 0.0, + PrefService::UNSYNCABLE_PREF); + prefs->RegisterDictionaryPref(prefs::kPerHostZoomLevels, + PrefService::UNSYNCABLE_PREF); } double HostZoomMap::GetZoomLevel(const GURL& url) const { |