Migrate default geolocation content setting to host content settings map.

chrome/browser/content_settings/content_settings_pref_provider.cc

 // 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/content_settings/content_settings_pref_provider.h"
 
 #include <list>
 #include <string>
 #include <utility>
 #include <vector>
@@ skipping 33 matching lines @@
 COMPILE_ASSERT(arraysize(kResourceTypeNames) == CONTENT_SETTINGS_NUM_TYPES,
                resource_type_names_incorrect_size);
 
 // The default setting for each content type.
 const ContentSetting kDefaultSettings[] = {
   CONTENT_SETTING_ALLOW,  // CONTENT_SETTINGS_TYPE_COOKIES
   CONTENT_SETTING_ALLOW,  // CONTENT_SETTINGS_TYPE_IMAGES
   CONTENT_SETTING_ALLOW,  // CONTENT_SETTINGS_TYPE_JAVASCRIPT
   CONTENT_SETTING_ALLOW,  // CONTENT_SETTINGS_TYPE_PLUGINS
   CONTENT_SETTING_BLOCK,  // CONTENT_SETTINGS_TYPE_POPUPS
-  CONTENT_SETTING_ASK,    // Not used for Geolocation
+  CONTENT_SETTING_ASK,    // CONTENT_SETTINGS_TYPE_GEOLOCATION
   CONTENT_SETTING_ASK,    // CONTENT_SETTINGS_TYPE_NOTIFICATIONS
 };
 COMPILE_ASSERT(arraysize(kDefaultSettings) == CONTENT_SETTINGS_NUM_TYPES,
                default_settings_incorrect_size);
 
 // The names of the ContentSettingsType values, for use with dictionary prefs.
 const char* kTypeNames[] = {
   "cookies",
   "images",
   "javascript",
   "plugins",
   "popups",
-  NULL,  // Not used for Geolocation
   // TODO(markusheintz): Refactoring in progress. Content settings exceptions
-  // for notifications will be added next.
+  // for notifications and geolocation will be added next.
+  "geolocation",  // Only used for default Geolocation settings
   "notifications",  // Only used for default Notifications settings.
 };
 COMPILE_ASSERT(arraysize(kTypeNames) == CONTENT_SETTINGS_NUM_TYPES,
                type_names_incorrect_size);
 
 void SetDefaultContentSettings(DictionaryValue* default_settings) {
   default_settings->Clear();
 
   for (int i = 0; i < CONTENT_SETTINGS_NUM_TYPES; ++i) {
     if (kTypeNames[i] != NULL) {
@@ skipping 68 matching lines @@
 
 namespace content_settings {
 
 PrefDefaultProvider::PrefDefaultProvider(PrefService* prefs,
                                          bool incognito)
     : prefs_(prefs),
       is_incognito_(incognito),
       updating_preferences_(false) {
   DCHECK(prefs_);
   MigrateObsoleteNotificationPref();
+  MigrateObsoleteGeolocationPref();
 
   // Read global defaults.
   DCHECK_EQ(arraysize(kTypeNames),
             static_cast<size_t>(CONTENT_SETTINGS_NUM_TYPES));
   ReadDefaultSettings(true);
   if (default_content_settings_.settings[CONTENT_SETTINGS_TYPE_COOKIES] ==
       CONTENT_SETTING_BLOCK) {
     UserMetrics::RecordAction(
         UserMetricsAction("CookieBlockingEnabledPerDefault"));
   } else {
     UserMetrics::RecordAction(
         UserMetricsAction("CookieBlockingDisabledPerDefault"));
   }
 
   pref_change_registrar_.Init(prefs_);
   pref_change_registrar_.Add(prefs::kDefaultContentSettings, this);
+  pref_change_registrar_.Add(prefs::kGeolocationDefaultContentSetting, this);
 }
 
 PrefDefaultProvider::~PrefDefaultProvider() {
   DCHECK(!prefs_);
 }
 
 ContentSetting PrefDefaultProvider::ProvideDefaultSetting(
     ContentSettingsType content_type) const {
   base::AutoLock lock(lock_);
   return default_content_settings_.settings[content_type];
 }
 
 void PrefDefaultProvider::UpdateDefaultSetting(
     ContentSettingsType content_type,
     ContentSetting setting) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(prefs_);
-  DCHECK(kTypeNames[content_type] != NULL);  // Don't call this for Geolocation.
+  DCHECK(kTypeNames[content_type] != NULL);
 
   // The default settings may not be directly modified for OTR sessions.
   // Instead, they are synced to the main profile's setting.
   if (is_incognito_)
     return;
 
   std::string dictionary_path(kTypeNames[content_type]);
   {
     AutoReset<bool> auto_reset(&updating_preferences_, true);
     base::AutoLock lock(lock_);
     DictionaryPrefUpdate update(prefs_, prefs::kDefaultContentSettings);
     DictionaryValue* default_settings_dictionary = update.Get();
     if ((setting == CONTENT_SETTING_DEFAULT) ||
         (setting == kDefaultSettings[content_type])) {
       default_content_settings_.settings[content_type] =
           kDefaultSettings[content_type];
       default_settings_dictionary->RemoveWithoutPathExpansion(dictionary_path,
                                                               NULL);
     } else {
       default_content_settings_.settings[content_type] = setting;
       default_settings_dictionary->SetWithoutPathExpansion(
           dictionary_path, Value::CreateIntegerValue(setting));
     }
+
+    // Keep the obsolete pref in sync as long as backwards compatibility is
+    // required. This is required to keep sync working correctly.
+    if (content_type == CONTENT_SETTINGS_TYPE_GEOLOCATION) {
+       prefs_->SetInteger(prefs::kGeolocationDefaultContentSetting,
+                          setting == CONTENT_SETTING_DEFAULT ?
+                              kDefaultSettings[content_type] : setting);
+    }
   }
 
   NotifyObservers(ContentSettingsPattern(),
                   ContentSettingsPattern(),
                   content_type,
                   std::string());
 }
 
 bool PrefDefaultProvider::DefaultSettingIsManaged(
     ContentSettingsType content_type) const {
   return false;
 }
 
 void PrefDefaultProvider::Observe(int type,
                                   const NotificationSource& source,
                                   const NotificationDetails& details) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (type == chrome::NOTIFICATION_PREF_CHANGED) {
     DCHECK_EQ(prefs_, Source<PrefService>(source).ptr());
     if (updating_preferences_)
       return;
 
     std::string* name = Details<std::string>(details).ptr();
     if (*name == prefs::kDefaultContentSettings) {
       ReadDefaultSettings(true);
+    } else if (*name == prefs::kGeolocationDefaultContentSetting) {
+      MigrateObsoleteGeolocationPref();
+      // Return and don't send a notifications. Migrating the obsolete
+      // geolocation pref will change the prefs::kDefaultContentSettings and
+      // cause the notification to be fired.
+      return;
     } else {
       NOTREACHED() << "Unexpected preference observed";
       return;
     }
 
     NotifyObservers(ContentSettingsPattern(),
                     ContentSettingsPattern(),
                     CONTENT_SETTINGS_TYPE_DEFAULT,
                     std::string());
   } else {
@@ skipping 65 matching lines @@
 
 void PrefDefaultProvider::MigrateObsoleteNotificationPref() {
   if (prefs_->HasPrefPath(prefs::kDesktopNotificationDefaultContentSetting)) {
     ContentSetting setting = IntToContentSetting(
         prefs_->GetInteger(prefs::kDesktopNotificationDefaultContentSetting));
     UpdateDefaultSetting(CONTENT_SETTINGS_TYPE_NOTIFICATIONS, setting);
     prefs_->ClearPref(prefs::kDesktopNotificationDefaultContentSetting);
   }
 }
 
+void PrefDefaultProvider::MigrateObsoleteGeolocationPref() {
+  if (prefs_->HasPrefPath(prefs::kGeolocationDefaultContentSetting)) {
+    ContentSetting setting = IntToContentSetting(
+        prefs_->GetInteger(prefs::kGeolocationDefaultContentSetting));
+    UpdateDefaultSetting(CONTENT_SETTINGS_TYPE_GEOLOCATION, setting);
+    // Do not clear the old preference yet as long as we need to maintain
+    // backward compatibility.
+  }
+}
+
 // static
 void PrefDefaultProvider::RegisterUserPrefs(PrefService* prefs) {
   // The registration of the preference prefs::kDefaultContentSettings should
   // also include the default values for default content settings. This allows
   // functional tests to get default content settings by reading the preference
   // prefs::kDefaultContentSettings via pyauto.
   // TODO(markusheintz): Write pyauto hooks for the content settings map as
   // content settings should be read from the host content settings map.
   DictionaryValue* default_content_settings = new DictionaryValue();
   SetDefaultContentSettings(default_content_settings);
   prefs->RegisterDictionaryPref(prefs::kDefaultContentSettings,
                                 default_content_settings,
                                 PrefService::SYNCABLE_PREF);
 
   // Obsolete prefs, for migrations:
   prefs->RegisterIntegerPref(
       prefs::kDesktopNotificationDefaultContentSetting,
       kDefaultSettings[CONTENT_SETTINGS_TYPE_NOTIFICATIONS],
       PrefService::SYNCABLE_PREF);
+  prefs->RegisterIntegerPref(
+      prefs::kGeolocationDefaultContentSetting,
+      kDefaultSettings[CONTENT_SETTINGS_TYPE_GEOLOCATION],
+      PrefService::UNSYNCABLE_PREF);
 }
 
 // ////////////////////////////////////////////////////////////////////////////
 // PrefProvider:
 //
 
 // static
 void PrefProvider::RegisterUserPrefs(PrefService* prefs) {
   prefs->RegisterIntegerPref(
       prefs::kContentSettingsVersion,
@@ skipping 24 matching lines @@
     MigrateObsoleteContentSettingsPatternPref();
   }
 
   // Verify preferences version.
   if (!prefs_->HasPrefPath(prefs::kContentSettingsVersion)) {
     prefs_->SetInteger(prefs::kContentSettingsVersion,
                       ContentSettingsPattern::kContentSettingsPatternVersion);
   }
   if (prefs_->GetInteger(prefs::kContentSettingsVersion) >
       ContentSettingsPattern::kContentSettingsPatternVersion) {
-    LOG(ERROR) << "Unknown content settings version in preferences.";
     return;
   }
 
   // Read content settings exceptions.
   ReadContentSettingsFromPref(false);
 
   if (!is_incognito_) {
     UMA_HISTOGRAM_COUNTS("ContentSettings.NumberOfExceptions",
                          value_map_.size());
   }
@@ skipping 625 matching lines @@
       DCHECK(found);
       std::string new_key = pattern_pair.first.ToString();
       // Existing values are overwritten.
       obsolete_settings_dictionary->SetWithoutPathExpansion(
           new_key, dictionary->DeepCopy());
     }
   }
 }
 
 }  // namespace content_settings