Added Protector backup for Preferences.

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 "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/extensions/extension_pref_store.h"
@@ skipping 681 matching lines @@
         if (!IsBlacklistBitSet(ext)) {
           // This extension is not in blacklist. And it was not blacklisted
           // before.
           continue;
         } else {
           if (ext->size() == 1) {
             // We should remove the entry if the only flag here is blacklist.
             remove_pref_ids.push_back(id);
           } else {
             // Remove the blacklist bit.
-            ext->Remove(kPrefBlacklist, NULL);
+            UpdateExtensionPref(id, kPrefBlacklist, NULL);
           }
         }
       } else {
         if (!IsBlacklistBitSet(ext)) {
           // Only set the blacklist if it was not set.
-          ext->SetBoolean(kPrefBlacklist, true);
+          UpdateExtensionPref(id, kPrefBlacklist,
+                              Value::CreateBooleanValue(true));
         }
         // Keep the record if this extension is already processed.
         used_id_set.insert(id);
       }
     }
   }
 
   // Iterate the leftovers to set blacklist in pref
   std::set<std::string>::const_iterator set_itr = blacklist_set.begin();
   for (; set_itr != blacklist_set.end(); ++set_itr) {
@@ skipping 817 matching lines @@
   CHECK(out);
 
   scoped_ptr<ExtensionsInfo> extensions_info(GetInstalledExtensionsInfo());
 
   for (size_t i = 0; i < extensions_info->size(); ++i) {
     ExtensionInfo* info = extensions_info->at(i).get();
     out->push_back(info->extension_id);
   }
 }
 
+// static
+ExtensionPrefs::ExtensionIdSet ExtensionPrefs::GetExtensionsFrom(
+    const base::DictionaryValue* extension_prefs) {
+  ExtensionIdSet result;
+  for (base::DictionaryValue::key_iterator it = extension_prefs->begin_keys();
+       it != extension_prefs->end_keys(); ++it) {
+    DictionaryValue* ext;
+    if (!extension_prefs->GetDictionaryWithoutPathExpansion(*it, &ext)) {
+      NOTREACHED() << "Invalid pref for extension " << *it;
+      continue;
+    }
+    if (!IsBlacklistBitSet(ext))
+      result.push_back(*it);
+  }
+  return result;
+}
+
 void ExtensionPrefs::FixMissingPrefs(const ExtensionIdSet& extension_ids) {
   // Fix old entries that did not get an installation time entry when they
   // were installed or don't have a preferences field.
   for (ExtensionIdSet::const_iterator ext_id = extension_ids.begin();
        ext_id != extension_ids.end(); ++ext_id) {
     if (GetInstallTime(*ext_id) == base::Time()) {
       LOG(INFO) << "Could not parse installation time of extension "
                 << *ext_id << ". It was probably installed before setting "
                 << kPrefInstallTime << " was introduced. Updating "
                 << kPrefInstallTime << " to the current time.";
@@ skipping 203 matching lines @@
   prefs->RegisterListPref(prefs::kExtensionInstallAllowList,
                           PrefService::UNSYNCABLE_PREF);
   prefs->RegisterListPref(prefs::kExtensionInstallDenyList,
                           PrefService::UNSYNCABLE_PREF);
   prefs->RegisterListPref(prefs::kExtensionInstallForceList,
                           PrefService::UNSYNCABLE_PREF);
   prefs->RegisterStringPref(kWebStoreLogin,
                             std::string() /* default_value */,
                             PrefService::UNSYNCABLE_PREF);
 }