Proper initialization for known_disabled.

chrome/browser/extensions/extension_prefs.cc

 // Copyright (c) 2012 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_prefs.h"
 
 #include <iterator>
 
 #include "base/command_line.h"
 #include "base/prefs/pref_notifier.h"
@@ skipping 1182 matching lines @@
     const std::string& id) const {
   return DoesExtensionHaveState(id, Extension::EXTERNAL_EXTENSION_UNINSTALLED);
 }
 
 bool ExtensionPrefs::IsExtensionDisabled(
     const std::string& id) const {
   return DoesExtensionHaveState(id, Extension::DISABLED);
 }
 
 ExtensionIdList ExtensionPrefs::GetToolbarOrder() {
-  return GetExtensionPrefAsContainer<ExtensionIdList>(prefs::kExtensionToolbar);
+  ExtensionIdList id_list_out;
+  GetUserExtensionPrefIntoContainer(prefs::kExtensionToolbar, &id_list_out);
+  return id_list_out;
 }
 
 void ExtensionPrefs::SetToolbarOrder(const ExtensionIdList& extension_ids) {
   SetExtensionPrefFromContainer(prefs::kExtensionToolbar, extension_ids);
 }
 
-ExtensionIdSet ExtensionPrefs::GetKnownDisabled() {
-  return GetExtensionPrefAsContainer<ExtensionIdSet>(
-      prefs::kExtensionKnownDisabled);
+bool ExtensionPrefs::GetKnownDisabled(ExtensionIdSet* id_set_out) {
+  return GetUserExtensionPrefIntoContainer(prefs::kExtensionKnownDisabled,
+                                           id_set_out);
 }
 
 void ExtensionPrefs::SetKnownDisabled(const ExtensionIdSet& extension_ids) {
   SetExtensionPrefFromContainer(prefs::kExtensionKnownDisabled, extension_ids);
 }
 
 void ExtensionPrefs::OnExtensionInstalled(
     const Extension* extension,
     Extension::State initial_state,
     bool blacklisted_for_malware,
@@ skipping 639 matching lines @@
       0,
       user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
 #endif
   registry->RegisterDictionaryPref(
       kInstallSignature,
       user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
 
 }
 
 template <class ExtensionIdContainer>
-ExtensionIdContainer ExtensionPrefs::GetExtensionPrefAsContainer(
-    const char* pref) {
-  ExtensionIdContainer extension_ids;
-  const ListValue* list_of_values = prefs_->GetList(pref);
-  if (!list_of_values)
-    return extension_ids;
+bool ExtensionPrefs::GetUserExtensionPrefIntoContainer(
+    const char* pref,
+    ExtensionIdContainer* id_container_out) {
+  DCHECK(id_container_out->empty());
+
+  const Value* user_pref_value = prefs_->GetUserPrefValue(pref);
+  const ListValue* user_pref_as_list;
+  if (!user_pref_value || !user_pref_value->GetAsList(&user_pref_as_list))
+    return false;
 
   std::insert_iterator<ExtensionIdContainer> insert_iterator(
-      extension_ids, extension_ids.end());
+      *id_container_out, id_container_out->end());
   std::string extension_id;
-  for (size_t i = 0; i < list_of_values->GetSize(); ++i) {
-    if (list_of_values->GetString(i, &extension_id))
-      insert_iterator = extension_id;
+  for (base::ListValue::const_iterator value_it = user_pref_as_list->begin();
+       value_it != user_pref_as_list->end(); ++value_it) {
+    if (!(*value_it)->GetAsString(&extension_id)) {
+      NOTREACHED();
+      continue;
+    }
+    insert_iterator = extension_id;
   }
-  return extension_ids;
+  return true;
 }
 
 template <class ExtensionIdContainer>
 void ExtensionPrefs::SetExtensionPrefFromContainer(
     const char* pref,
     const ExtensionIdContainer& strings) {
   ListPrefUpdate update(prefs_, pref);
   ListValue* list_of_values = update.Get();
   list_of_values->Clear();
   for (typename ExtensionIdContainer::const_iterator iter = strings.begin();
@@ skipping 90 matching lines @@
     is_enabled = initial_state == Extension::ENABLED;
   }
 
   extension_pref_value_map_->RegisterExtension(extension_id, install_time,
                                                is_enabled);
   content_settings_store_->RegisterExtension(extension_id, install_time,
                                              is_enabled);
 }
 
 }  // namespace extensions