First part to fix Bug 50726 "Save extension list and "winning" prefs from extensions"

chrome/browser/extensions/extension_prefs.cc

 // Copyright (c) 2010 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_util.h"
 #include "base/string_number_conversions.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/common/extensions/extension.h"
@@ skipping 23 matching lines @@
 // Indicates if an extension is blacklisted:
 const char kPrefBlacklist[] = "blacklist";
 
 // Indicates whether to show an install warning when the user enables.
 const char kExtensionDidEscalatePermissions[] = "install_warning_on_enable";
 
 // A preference that tracks browser action toolbar configuration. This is a list
 // object stored in the Preferences file. The extensions are stored by ID.
 const char kExtensionToolbar[] = "extensions.toolbar";
 
+// An ordered list of extension IDs that determines which extension overwrites
+// the values of other extensions. The last extension wins.
+// The ExtensionPrefStore reads and writes this list to respect the precedences.
+const char kExtensionsPrecedence[] = "extensions.precedence";
+
 // The key for a serialized Time value indicating the start of the day (from the
 // server's perspective) an extension last included a "ping" parameter during
 // its update check.
 const char kLastPingDay[] = "lastpingday";
 
 // Path for settings specific to blacklist update.
 const char kExtensionsBlacklistUpdate[] = "extensions.blacklistupdate";
 
 // Path and sub-keys for the idle install info dictionary preference.
 const char kIdleInstallInfo[] = "idle_install_info";
@@ skipping 148 matching lines @@
   const DictionaryValue* extensions = prefs_->GetDictionary(kExtensionsPref);
   if (extensions) {
     DictionaryValue* copy =
         static_cast<DictionaryValue*>(extensions->DeepCopy());
     MakePathsAbsolute(copy);
     return copy;
   }
   return new DictionaryValue;
 }
 
+void ExtensionPrefs::PersistExtensionPrecedences(
+      const std::vector<std::string>& precedence) {
+  ListValue* stored_precedence =
+      pref_service()->GetMutableList(kExtensionsPrecedence);
+
+  stored_precedence->Clear();
+
+  std::vector<std::string>::const_iterator i;
+  for (i = precedence.begin(); i != precedence.end(); ++i)
+    stored_precedence->Append(Value::CreateStringValue(*i));
+  pref_service()->ScheduleSavePersistentPrefs();
+}
+
+void ExtensionPrefs::GetExtensionPrecedences(
+      std::vector<std::string>* precedence) const {
+  precedence->clear();
+
+  const ListValue* stored_precedence =
+      pref_service()->GetList(kExtensionsPrecedence);
+  if (stored_precedence) {
+    precedence->reserve(stored_precedence->GetSize());
+    for (ListValue::const_iterator i = stored_precedence->begin();
+         i != stored_precedence->end(); ++i) {
+      std::string ext_id;
+      if (!(*i)->GetAsString(&ext_id)) {
+        LOG(WARNING) << "Invalid entry in " << kExtensionsPrecedence;
+        continue;
+      }
+      precedence->push_back(ext_id);
+    }
+  }
+}
+
 bool ExtensionPrefs::ReadBooleanFromPref(
     DictionaryValue* ext, const std::string& pref_key) {
   if (!ext->HasKey(pref_key)) return false;
   bool bool_value = false;
   if (!ext->GetBoolean(pref_key, &bool_value)) {
     NOTREACHED() << "Failed to fetch " << pref_key << " flag.";
     // In case we could not fetch the flag, we treat it as false.
     return false;
   }
   return bool_value;
@@ skipping 676 matching lines @@
 // static
 void ExtensionPrefs::RegisterUserPrefs(PrefService* prefs) {
   prefs->RegisterDictionaryPref(kExtensionsPref);
   prefs->RegisterListPref(kExtensionToolbar);
   prefs->RegisterIntegerPref(prefs::kExtensionToolbarSize, -1);
   prefs->RegisterDictionaryPref(kExtensionsBlacklistUpdate);
   prefs->RegisterListPref(prefs::kExtensionInstallAllowList);
   prefs->RegisterListPref(prefs::kExtensionInstallDenyList);
   prefs->RegisterListPref(prefs::kExtensionInstallForceList);
   prefs->RegisterStringPref(kWebStoreLogin, std::string() /* default_value */);
+  prefs->RegisterListPref(kExtensionsPrecedence);
 }