Remove corrupted values from obsolete geolocation preference.

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 <map>
 #include <string>
 #include <utility>
 
@@ skipping 574 matching lines @@
     const ContentSettingsPattern& primary_pattern,
     const ContentSettingsPattern& secondary_pattern,
     ContentSetting setting) {
   // Ensure that |lock_| is not held by this thread, since this function will
   // send out notifications (by |~DictionaryPrefUpdate|).
   AssertLockNotHeld();
 
   if (!prefs_)
     return;
 
+  // Ignor settings with wildcard patterns as they are not supported by the

[Bernhard Bauer, 2011/11/23 18:43:33]

Nit: "Ignore"

[markusheintz_, 2011/11/23 18:52:28]

Done.

+  // obsolete preference.
+  if (primary_pattern == ContentSettingsPattern::Wildcard() ||
+      secondary_pattern == ContentSettingsPattern::Wildcard()) {
+    return;
+  }
+
   const GURL requesting_origin(primary_pattern.ToString());
   const GURL embedding_origin(secondary_pattern.ToString());
   DCHECK(requesting_origin.is_valid() && embedding_origin.is_valid());
 
   DictionaryPrefUpdate update(prefs_, prefs::kGeolocationContentSettings);
   DictionaryValue* obsolete_geolocation_settings = update.Get();
   DictionaryValue* requesting_origin_settings_dictionary = NULL;
   obsolete_geolocation_settings->GetDictionaryWithoutPathExpansion(
       requesting_origin.spec(), &requesting_origin_settings_dictionary);
   if (setting == CONTENT_SETTING_DEFAULT) {
@@ skipping 314 matching lines @@
 
   if (!prefs_->HasPrefPath(prefs::kGeolocationContentSettings))
     return;
 
   DictionaryPrefUpdate update(prefs_,
                               prefs::kContentSettingsPatternPairs);
   DictionaryValue* pattern_pairs_settings = update.Get();
 
   const DictionaryValue* geolocation_settings =
       prefs_->GetDictionary(prefs::kGeolocationContentSettings);
+
+  std::vector<std::pair<std::string, std::string> > corrupted_keys;
   for (DictionaryValue::key_iterator i =
            geolocation_settings->begin_keys();
        i != geolocation_settings->end_keys();
        ++i) {
     const std::string& primary_key(*i);
     GURL primary_url(primary_key);
     DCHECK(primary_url.is_valid());
 
     DictionaryValue* requesting_origin_settings = NULL;
     bool found = geolocation_settings->GetDictionaryWithoutPathExpansion(
         primary_key, &requesting_origin_settings);
     DCHECK(found);
 
     for (DictionaryValue::key_iterator j =
              requesting_origin_settings->begin_keys();
          j != requesting_origin_settings->end_keys();
          ++j) {
       const std::string& secondary_key(*j);
       GURL secondary_url(secondary_key);
-      DCHECK(secondary_url.is_valid());
+      // Save corrupted keys to remove them later.
+      if (!secondary_url.is_valid()) {
+        corrupted_keys.push_back(std::make_pair(primary_key, secondary_key));
+        continue;
+      }
 
       base::Value* value = NULL;
       found = requesting_origin_settings->GetWithoutPathExpansion(
           secondary_key, &value);
       DCHECK(found);
 
       ContentSettingsPattern primary_pattern =
           ContentSettingsPattern::FromURLNoWildcard(primary_url);
       ContentSettingsPattern secondary_pattern =
           ContentSettingsPattern::FromURLNoWildcard(secondary_url);
       DCHECK(primary_pattern.IsValid() && secondary_pattern.IsValid());
 
       UpdatePatternPairsSettings(primary_pattern,
                                  secondary_pattern,
                                  CONTENT_SETTINGS_TYPE_GEOLOCATION,
                                  std::string(),
                                  value,
                                  pattern_pairs_settings);
     }
   }
+
+  // Remove corrupted keys.
+  DictionaryPrefUpdate update_geo_settings(
+      prefs_, prefs::kGeolocationContentSettings);
+  base::DictionaryValue* geo_dict = update_geo_settings.Get();
+  std::vector<std::pair<std::string, std::string> >::iterator key_pair;
+  for (key_pair = corrupted_keys.begin();
+       key_pair != corrupted_keys.end();
+       ++key_pair) {
+    base::DictionaryValue* dict;
+    bool found = geo_dict->GetDictionaryWithoutPathExpansion(
+        key_pair->first, &dict);
+    DCHECK(found);
+    DCHECK(dict->HasKey(key_pair->second));
+    dict->RemoveWithoutPathExpansion(key_pair->second, NULL);
+    if (dict->empty())

[Bernhard Bauer, 2011/11/23 18:43:33]

Removing empty dictionaries isn't necessary; the PrefService trims them
automatically when writing the preferences to disk.

[markusheintz_, 2011/11/23 18:52:28]

True! We recently talked about this.

+      geo_dict->RemoveWithoutPathExpansion(key_pair->first, NULL);
+  }
 }
 
 void PrefProvider::MigrateObsoleteNotificationsPrefs() {
   // Ensure that |lock_| is not held by this thread, since this function will
   // send out notifications (by |~DictionaryPrefUpdate|).
   AssertLockNotHeld();
 
   // The notifications settings in the preferences
   // prefs::kContentSettingsPatternPairs do not contain the latest
   // notifications settings. So all notification settings are cleared and
@@ skipping 100 matching lines @@
 
 void PrefProvider::AssertLockNotHeld() const {
 #if !defined(NDEBUG)
   // |Lock::Acquire()| will assert if the lock is held by this thread.
   lock_.Acquire();
   lock_.Release();
 #endif
 }
 
 }  // namespace content_settings