Fix default value of ExtensionManagement::IndividualSettings

chrome/browser/extensions/extension_management.cc

 // Copyright 2014 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/extensions/extension_management.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/logging.h"
 #include "base/prefs/pref_service.h"
@@ skipping 27 matching lines @@
 
 // Parse the individual settings for |settings|. |dict| is the a
 // sub-dictionary in extension management preference and |scope| represents
 // the applicable range of the settings, a single extension, a group of
 // extensions or default settings.
 // Note that in case of parsing errors, |settings| will NOT be left untouched.
 bool ParseIndividualSettings(
     const base::DictionaryValue* dict,
     Scope scope,
     ExtensionManagement::IndividualSettings* settings) {
-  settings->Reset();
-
   std::string installation_mode;
   if (dict->GetStringWithoutPathExpansion(schema_constants::kInstallationMode,
                                           &installation_mode)) {
     if (installation_mode == schema_constants::kAllowed) {
       settings->installation_mode = ExtensionManagement::INSTALLATION_ALLOWED;
     } else if (installation_mode == schema_constants::kBlocked) {
       settings->installation_mode = ExtensionManagement::INSTALLATION_BLOCKED;
     } else if (installation_mode == schema_constants::kForceInstalled) {
       settings->installation_mode = ExtensionManagement::INSTALLATION_FORCED;
     } else if (installation_mode == schema_constants::kNormalInstalled) {
@@ skipping 24 matching lines @@
       LOG(WARNING) << kMalformedPreferenceWarning;
       return false;
     }
   }
 
   return true;
 }
 
 }  // namespace
 
+ExtensionManagement::IndividualSettings::IndividualSettings() {
+  Reset();
+}
+
+ExtensionManagement::IndividualSettings::~IndividualSettings() {
+}
+
 void ExtensionManagement::IndividualSettings::Reset() {
   installation_mode = ExtensionManagement::INSTALLATION_ALLOWED;
   update_url.clear();
 }
 
 ExtensionManagement::GlobalSettings::GlobalSettings() {
   Reset();
 }
 
 ExtensionManagement::GlobalSettings::~GlobalSettings() {
@@ skipping 223 matching lines @@
   if (dict_pref) {
     // Parse new extension management preference.
     for (base::DictionaryValue::Iterator iter(*dict_pref); !iter.IsAtEnd();
          iter.Advance()) {
       if (iter.key() == schema_constants::kWildcard)
         continue;
       if (!iter.value().GetAsDictionary(&subdict)) {
         LOG(WARNING) << kMalformedPreferenceWarning;
         continue;
       }
-      if (StartsWithASCII(
-              iter.key(), schema_constants::kUpdateUrlPrefix, true))
+      if (StartsWithASCII(iter.key(), schema_constants::kUpdateUrlPrefix, true))
         continue;
       const std::string& extension_id = iter.key();
       if (!crx_file::id_util::IdIsValid(extension_id)) {
         LOG(WARNING) << kMalformedPreferenceWarning;
         continue;
       }
-      IndividualSettings by_id;
-      if (ParseIndividualSettings(subdict, SCOPE_INDIVIDUAL, &by_id)) {
-        *AccessById(extension_id) = by_id;
-      } else {
+      IndividualSettings *by_id = AccessById(extension_id);

[Joao da Silva, 2014/09/24 11:22:51]

* next to type:

IndividualSettings* by_id = ..

[binjin, 2014/09/24 17:47:40]

Done.

+      if (!ParseIndividualSettings(subdict, SCOPE_INDIVIDUAL, by_id)) {
+        settings_by_id_.erase(settings_by_id_.find(extension_id));
         LOG(WARNING) << "Malformed Extension Management settings for "
-                     << iter.key() << ".";
+                     << extension_id << ".";
       }
     }
   }
 }
 
 const base::Value* ExtensionManagement::LoadPreference(
     const char* pref_name,
     bool force_managed,
     base::Value::Type expected_type) {
   const PrefService::Preference* pref =
@@ skipping 57 matching lines @@
 }
 
 void ExtensionManagementFactory::RegisterProfilePrefs(
     user_prefs::PrefRegistrySyncable* user_prefs) {
   user_prefs->RegisterDictionaryPref(
       pref_names::kExtensionManagement,
       user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
 }
 
 }  // namespace extensions