Migrate geolocation settings 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 20 matching lines @@
 namespace {
 
 // The preference keys where resource identifiers are stored for
 // ContentSettingsType values that support resource identifiers.
 const char* kResourceTypeNames[] = {
   NULL,
   NULL,
   NULL,
   "per_plugin",
   NULL,
-  NULL,  // Not used for Geolocation
+  NULL,
   NULL,  // Not used for Notifications
 };
 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,    // 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",
+  "geolocation",
   // TODO(markusheintz): Refactoring in progress. Content settings exceptions
-  // for notifications and geolocation will be added next.
-  "geolocation",  // Only used for default Geolocation settings
+  // for notifications added next.
   "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) {
       default_settings->SetInteger(kTypeNames[i],
                                    kDefaultSettings[i]);
     }
   }
 }
 
+void CopyKeys(DictionaryValue* source,

[Bernhard Bauer, 2011/08/03 15:22:50]

Not used?

[markusheintz_, 2011/08/04 12:45:56]

Sorry. Removed!

+              DictionaryValue* target,
+              const char** keys_to_copy,
+              size_t size) {
+  for (DictionaryValue::key_iterator i(source->begin_keys());
+       i != source->end_keys(); ++i) {
+    const std::string& key(*i);
+    for (size_t i = 0; i < size; ++i) {
+      if ((keys_to_copy[i] != NULL) && (keys_to_copy[i] == key)) {
+        Value* value;
+        bool found = source->GetWithoutPathExpansion(
+            key, &value);
+        DCHECK(found);
+        target->SetWithoutPathExpansion(key, value->DeepCopy());
+        break;
+      }
+    }
+  }
+}
+
 ContentSetting ValueToContentSetting(Value* value) {
   int int_value;
   value->GetAsInteger(&int_value);
   return IntToContentSetting(int_value);
 }
 
 ContentSettingsType StringToContentSettingsType(
     const std::string& content_type_str) {
   for (size_t type = 0; type < arraysize(kTypeNames); ++type) {
     if ((kTypeNames[type] != NULL) && (kTypeNames[type] == content_type_str))
@@ skipping 254 matching lines @@
 // static
 void PrefProvider::RegisterUserPrefs(PrefService* prefs) {
   prefs->RegisterIntegerPref(
       prefs::kContentSettingsVersion,
       ContentSettingsPattern::kContentSettingsPatternVersion,
       PrefService::UNSYNCABLE_PREF);
   prefs->RegisterDictionaryPref(prefs::kContentSettingsPatternPairs,
                                 PrefService::SYNCABLE_PREF);
 
   // Obsolete prefs, for migration:
+  prefs->RegisterDictionaryPref(prefs::kGeolocationContentSettings,
+                                PrefService::SYNCABLE_PREF);
   prefs->RegisterDictionaryPref(prefs::kContentSettingsPatterns,
                                 PrefService::SYNCABLE_PREF);
   prefs->RegisterListPref(prefs::kPopupWhitelistedHosts,
                           PrefService::UNSYNCABLE_PREF);
   prefs->RegisterDictionaryPref(prefs::kPerHostContentSettings,
                                 PrefService::UNSYNCABLE_PREF);
 }
 
 PrefProvider::PrefProvider(PrefService* prefs,
                            bool incognito)
   : prefs_(prefs),
     is_incognito_(incognito),
     updating_preferences_(false) {
   DCHECK(prefs_);
   if (!is_incognito_) {
     // Migrate obsolete preferences.
     MigrateObsoletePerhostPref();
     MigrateObsoletePopupsPref();
     MigrateObsoleteContentSettingsPatternPref();
+    MigrateObsoleteGeolocationPref();
   }
 
   // Verify preferences version.
   if (!prefs_->HasPrefPath(prefs::kContentSettingsVersion)) {
     prefs_->SetInteger(prefs::kContentSettingsVersion,
                       ContentSettingsPattern::kContentSettingsPatternVersion);
   }
   if (prefs_->GetInteger(prefs::kContentSettingsVersion) >
       ContentSettingsPattern::kContentSettingsPatternVersion) {
     return;
   }
 
   // Read content settings exceptions.
   ReadContentSettingsFromPref(false);
 
   if (!is_incognito_) {
     UMA_HISTOGRAM_COUNTS("ContentSettings.NumberOfExceptions",
                          value_map_.size());
   }
 
   pref_change_registrar_.Init(prefs_);
   pref_change_registrar_.Add(prefs::kContentSettingsPatterns, this);
   pref_change_registrar_.Add(prefs::kContentSettingsPatternPairs, this);
+  pref_change_registrar_.Add(prefs::kGeolocationContentSettings, this);
 }
 
 ContentSetting PrefProvider::GetContentSetting(
     const GURL& primary_url,
     const GURL& secondary_url,
     ContentSettingsType content_type,
     const ResourceIdentifier& resource_identifier) const {
   // For a |PrefProvider| used in a |HostContentSettingsMap| of a non incognito
   // profile, this will always return NULL.
   // TODO(markusheintz): I don't like this. I'd like to have an
@@ skipping 46 matching lines @@
 }
 
 void PrefProvider::SetContentSetting(
     const ContentSettingsPattern& primary_pattern,
     const ContentSettingsPattern& secondary_pattern,
     ContentSettingsType content_type,
     const ResourceIdentifier& resource_identifier,
     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);
 
   // Update in memory value map.
   OriginIdentifierValueMap* map_to_modify = &incognito_value_map_;
   if (!is_incognito_)
     map_to_modify = &value_map_;
 
   {
     base::AutoLock auto_lock(lock_);
     if (setting == CONTENT_SETTING_DEFAULT) {
       map_to_modify->DeleteValue(
@@ skipping 65 matching lines @@
     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::kContentSettingsPatternPairs) {
-      SyncObsoletePref();
+      SyncObsoletePatternPref();
+      SyncObsoleteGeolocationPref();
       ReadContentSettingsFromPref(true);
     } else if (*name == prefs::kContentSettingsPatterns) {
       AutoReset<bool> auto_reset(&updating_preferences_, true);
       MigrateObsoleteContentSettingsPatternPref();
       ReadContentSettingsFromPref(true);
+    } else if (*name == prefs::kGeolocationContentSettings) {
+      AutoReset<bool> auto_reset(&updating_preferences_, true);
+      MigrateObsoleteGeolocationPref();
+      ReadContentSettingsFromPref(true);
     } else {
       NOTREACHED() << "Unexpected preference observed";
       return;
     }
 
     NotifyObservers(ContentSettingsPattern(),
                     ContentSettingsPattern(),
                     CONTENT_SETTINGS_TYPE_DEFAULT,
                     std::string());
   } else {
@@ skipping 13 matching lines @@
     const ContentSettingsPattern& secondary_pattern,
     ContentSettingsType content_type,
     const ResourceIdentifier& resource_identifier,
     ContentSetting setting) {
   AutoReset<bool> auto_reset(&updating_preferences_, true);
   UpdatePatternPairsPref(primary_pattern,
                          secondary_pattern,
                          content_type,
                          resource_identifier,
                          setting);
-  UpdatePatternsPref(primary_pattern,
-                     secondary_pattern,
-                     content_type,
-                     resource_identifier,
-                     setting);
+  if (content_type != CONTENT_SETTINGS_TYPE_GEOLOCATION &&
+      content_type != CONTENT_SETTINGS_TYPE_NOTIFICATIONS) {
+    UpdateObsoletePatternsPref(primary_pattern,
+                               secondary_pattern,
+                               content_type,
+                               resource_identifier,
+                               setting);
+  }
+  if (content_type == CONTENT_SETTINGS_TYPE_GEOLOCATION) {
+    SyncObsoleteGeolocationPref();
+  }
 }
 
 void PrefProvider::ReadContentSettingsFromPref(bool overwrite) {
   base::AutoLock auto_lock(lock_);
 
   const DictionaryValue* all_settings_dictionary =
       prefs_->GetDictionary(prefs::kContentSettingsPatternPairs);
 
   if (overwrite)
     value_map_.clear();
@@ skipping 74 matching lines @@
                                 content_type,
                                 ResourceIdentifier(""),
                                 Value::CreateIntegerValue(setting));
           }
         }
       }
     }
   }
 }
 
-void PrefProvider::UpdatePatternsPref(
+void PrefProvider::UpdateObsoletePatternsPref(
       const ContentSettingsPattern& primary_pattern,
       const ContentSettingsPattern& secondary_pattern,
       ContentSettingsType content_type,
       const ResourceIdentifier& resource_identifier,
       ContentSetting setting) {
   DictionaryPrefUpdate update(prefs_,
                               prefs::kContentSettingsPatterns);
   DictionaryValue* all_settings_dictionary = update.Get();
 
   // Get settings dictionary for |primary_pattern|.
@@ skipping 294 matching lines @@
       std::string new_pattern_str = CreatePatternString(
           primary_pattern, ContentSettingsPattern::Wildcard());
 
       // Existing values are overwritten.
       exceptions_dictionary->SetWithoutPathExpansion(
           new_pattern_str, dictionary->DeepCopy());
     }
   }
 }
 
-void PrefProvider::SyncObsoletePref() {
+void PrefProvider::SyncObsoletePatternPref() {
   AutoReset<bool> auto_reset(&updating_preferences_, true);
   if (prefs_->HasPrefPath(prefs::kContentSettingsPatternPairs) &&
       !is_incognito_) {
     const DictionaryValue* pattern_pairs_dictionary =
       prefs_->GetDictionary(prefs::kContentSettingsPatternPairs);
 
     DictionaryPrefUpdate update(prefs_, prefs::kContentSettingsPatterns);
     DictionaryValue* obsolete_settings_dictionary = update.Get();
 
     for (DictionaryValue::key_iterator i =
              pattern_pairs_dictionary->begin_keys();
          i != pattern_pairs_dictionary->end_keys();
          ++i) {
       const std::string& key(*i);
       // Validate pattern string and skip it if it is invalid.
       std::pair<ContentSettingsPattern, ContentSettingsPattern> pattern_pair =
           ParsePatternString(key);
       if (!pattern_pair.first.IsValid() || !pattern_pair.second.IsValid()) {
         LOG(DFATAL) << "Invalid pattern strings: " << key;
         continue;
       }
 
-      // Copy dictionary
-      DictionaryValue* dictionary = NULL;
+      DictionaryValue* settings_dictionary = NULL;
       bool found = pattern_pairs_dictionary->GetDictionaryWithoutPathExpansion(
-          key, &dictionary);
+          key, &settings_dictionary);
       DCHECK(found);
-      std::string new_key = pattern_pair.first.ToString();
-      // Existing values are overwritten.
-      obsolete_settings_dictionary->SetWithoutPathExpansion(
-          new_key, dictionary->DeepCopy());
+      scoped_ptr<DictionaryValue> settings_dictionary_copy(
+          new DictionaryValue());
+      for (DictionaryValue::key_iterator i(settings_dictionary->begin_keys());
+           i != settings_dictionary->end_keys();
+           ++i) {
+        const std::string& type_name(*i);
+        // Copy only the content settings types that were stored in the obsolete
+        // preference.
+        for (size_t i = 0; i <= CONTENT_SETTINGS_TYPE_POPUPS; ++i) {

[Bernhard Bauer, 2011/08/03 15:22:50]

Can you start the iteration at CONTENT_SETTINGS_TYPE_COOKIES?

Also, if you move this loop to the top level, you don't need to loop over
|settings_dictionary| anymore (just look up |kTypeNames[i]| in there).

[markusheintz_, 2011/08/04 12:45:56]

s/0/CONTENT_SETTINGS_TYPE_COOKIES/ and changed the loops like you suggested.

+          if ((kTypeNames[i] != NULL) && (kTypeNames[i] == type_name)) {

[Bernhard Bauer, 2011/08/03 15:22:50]

kTypeNames[i] should never be NULL.

[markusheintz_, 2011/08/04 12:45:56]

I replaced the (kTypeNames[i] != NULL)with a DCHECK(kTypeNames[i]) in the
modified code.

+            Value* value;

[Bernhard Bauer, 2011/08/03 15:22:50]

Initialize to NULL please.

[markusheintz_, 2011/08/04 12:45:56]

Done.

+            bool found = settings_dictionary->GetWithoutPathExpansion(
+                type_name, &value);
+            DCHECK(found);
+            settings_dictionary_copy->SetWithoutPathExpansion(
+                type_name, value->DeepCopy());
+            break;
+          }
+        }
+      }
+
+      // Ignore empty dictionaryies.
+      if (!settings_dictionary_copy->empty()) {
+        std::string new_key = pattern_pair.first.ToString();
+        // Existing values are overwritten.
+        obsolete_settings_dictionary->SetWithoutPathExpansion(
+            new_key, settings_dictionary_copy.release());
+      }
     }
   }
 }
 
+void PrefProvider::MigrateObsoleteGeolocationPref() {
+  if (!prefs_->HasPrefPath(prefs::kGeolocationContentSettings))
+    return;
+
+  const DictionaryValue* geolocation_settings_dictionary =
+      prefs_->GetDictionary(prefs::kGeolocationContentSettings);
+  for (DictionaryValue::key_iterator i =
+           geolocation_settings_dictionary->begin_keys();
+       i != geolocation_settings_dictionary->end_keys();
+       ++i) {
+    const std::string& primary_key(*i);
+    GURL primary_url(primary_key);
+    DCHECK(primary_url.is_valid());
+
+    DictionaryValue* requesting_origin_settings_dictionary = NULL;
+    bool found =
+        geolocation_settings_dictionary->GetDictionaryWithoutPathExpansion(

[Bernhard Bauer, 2011/08/03 15:22:50]

Maybe this is an indication to use a shorter variable name? For example, the
|_dictionary| part is implied by the type of the variable.

[markusheintz_, 2011/08/04 12:45:56]

I removed the trailing |_dictionary| from the names.

+            primary_key, &requesting_origin_settings_dictionary);
+    DCHECK(found);
+
+    for (DictionaryValue::key_iterator j =
+             requesting_origin_settings_dictionary->begin_keys();
+         j != requesting_origin_settings_dictionary->end_keys();
+         ++j) {
+      const std::string& secondary_key(*j);
+      GURL secondary_url(secondary_key);
+      DCHECK(secondary_url.is_valid());
+
+      int setting_value;
+      found =
+          requesting_origin_settings_dictionary->GetIntegerWithoutPathExpansion(
+              secondary_key, &setting_value);
+      DCHECK(found);
+
+      ContentSettingsPattern primary_pattern =
+          ContentSettingsPattern::FromURLNoWildcard(primary_url);
+      ContentSettingsPattern secondary_pattern =
+          ContentSettingsPattern::FromURLNoWildcard(secondary_url);
+      DCHECK(primary_pattern.IsValid() && secondary_pattern.IsValid());
+
+      SetContentSetting(primary_pattern,
+                        secondary_pattern,
+                        CONTENT_SETTINGS_TYPE_GEOLOCATION,
+                        std::string(),
+                        IntToContentSetting(setting_value));
+    }
+  }
+}
+
+void PrefProvider::SyncObsoleteGeolocationPref() {
+  DCHECK(prefs_);
+  DCHECK(prefs_->HasPrefPath(prefs::kContentSettingsPatternPairs));
+
+  scoped_ptr<DictionaryValue> obsolete_geolocation_settings(
+      new DictionaryValue());
+
+  const DictionaryValue* all_settings_dictionary =
+      prefs_->GetDictionary(prefs::kContentSettingsPatternPairs);
+  for (DictionaryValue::key_iterator i = all_settings_dictionary->begin_keys();
+       i != all_settings_dictionary->end_keys();
+       ++i) {
+    const std::string& key(*i);
+    std::pair<ContentSettingsPattern, ContentSettingsPattern> pattern_pair =
+        ParsePatternString(key);
+    DCHECK(pattern_pair.first.IsValid() && pattern_pair.second.IsValid());
+
+    DictionaryValue* settings_dictionary;

[Bernhard Bauer, 2011/08/03 15:22:50]

Initialize with NULL please.

[markusheintz_, 2011/08/04 12:45:56]

Done.

+    bool found = all_settings_dictionary->GetDictionaryWithoutPathExpansion(
+          key, &settings_dictionary);
+    DCHECK(found);
+
+    if (settings_dictionary->HasKey(
+            kTypeNames[CONTENT_SETTINGS_TYPE_GEOLOCATION])) {
+      const GURL primary_url(pattern_pair.first.ToString());
+      const GURL secondary_url(pattern_pair.second.ToString());
+      DCHECK(primary_url.is_valid() && secondary_url.is_valid());
+
+      int setting_value;
+      settings_dictionary->GetInteger(
+          kTypeNames[CONTENT_SETTINGS_TYPE_GEOLOCATION], &setting_value);
+
+      // Add to obsolete pref.
+      DictionaryValue* one_origin_settings;

[Bernhard Bauer, 2011/08/03 15:22:50]

Initialize with NULL please (not as important here, but coverity might still
complain otherwise).

[markusheintz_, 2011/08/04 12:45:56]

Done.

+      bool found =
+          obsolete_geolocation_settings->GetDictionaryWithoutPathExpansion(
+              primary_url.spec(), &one_origin_settings);
+      if (!found) {
+        one_origin_settings = new DictionaryValue();
+        obsolete_geolocation_settings->SetWithoutPathExpansion(
+            primary_url.spec(), one_origin_settings);
+      }
+
+      one_origin_settings->SetWithoutPathExpansion(
+          secondary_url.spec(), Value::CreateIntegerValue(setting_value));
+    }
+  }
+
+  prefs_->Set(prefs::kGeolocationContentSettings,

[Bernhard Bauer, 2011/08/03 15:22:50]

Is there a reason you're not using a DictionaryPrefUpdate?

[markusheintz_, 2011/08/04 12:45:56]

I just found that shorter.

[Bernhard Bauer, 2011/08/05 10:08:46]

OTOH, it makes a |DeepCopy| of the dictionary.

+              *obsolete_geolocation_settings);
+}
+
 }  // namespace content_settings