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

chrome/browser/extensions/extension_pref_store.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_pref_store.h"
 
+#include <limits>
+
 #include "base/logging.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
+#include "chrome/browser/extensions/extensions_service.h"
+#include "chrome/browser/extensions/extension_prefs.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/profile.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/notification_service.h"
 
 ExtensionPrefStore::ExtensionPrefStore(Profile* profile,
                                        PrefNotifier::PrefStoreType type)
     : prefs_(new DictionaryValue()),
       profile_(profile),
       type_(type) {
   RegisterObservers();
 }
 
 ExtensionPrefStore::~ExtensionPrefStore() {
   STLDeleteElements(&extension_stack_);
   notification_registrar_.RemoveAll();
 }
 
 void ExtensionPrefStore::InstallExtensionPref(const Extension* extension,
                                               const char* new_pref_path,
                                               Value* new_pref_value) {
+  if (extension_stack_.empty())
+    LazyInit();
+
   ExtensionStack::iterator i;
   for (i = extension_stack_.begin(); i != extension_stack_.end(); ++i) {
-    if ((*i)->extension == extension)
+    if ((*i)->extension_id == extension->id())
       break;
   }
 
   // If this extension is not already in the stack, add it. Otherwise, update
   // or add the value of this preference, but don't change the extension's
   // position in the stack. We store the extension even if this preference
   // isn't registered with our PrefService, so that the ordering of extensions
   // is consistent among all local-state and user ExtensionPrefStores.
   PrefService* pref_service = GetPrefService();
   // The pref_service may be NULL in unit testing.
   bool is_registered_pref = (pref_service == NULL ||
       pref_service->FindPreference(new_pref_path) != NULL);
   PrefValueMap* pref_values;
   if (i == extension_stack_.end()) {
     pref_values = new PrefValueMap();
     if (is_registered_pref)
       (*pref_values)[new_pref_path] = new_pref_value;
 
-    ExtensionPrefs* extension_prefs = new ExtensionPrefs(extension,
+    ExtensionPrefs* extension_prefs = new ExtensionPrefs(extension->id(),
                                                          pref_values);
     extension_stack_.push_front(extension_prefs);
+    AddPrecedence(extension->id());
+
   } else if (is_registered_pref) {
     pref_values = (*i)->pref_values;
     delete (*pref_values)[new_pref_path];
     (*pref_values)[new_pref_path] = new_pref_value;
   }
 
   // Apply the preference to our local |prefs_| store.
   UpdateOnePref(new_pref_path);
 }
 
 void ExtensionPrefStore::UninstallExtension(const Extension* extension) {
   // Remove this extension from the stack.
   for (ExtensionStack::iterator i = extension_stack_.begin();
       i != extension_stack_.end(); ++i) {
-    if ((*i)->extension == extension) {
+    if ((*i)->extension_id == extension->id()) {
       scoped_ptr<ExtensionPrefs> to_be_deleted(*i);
       extension_stack_.erase(i);
+      RemovePrecedence(to_be_deleted->extension_id);
       UpdatePrefs(to_be_deleted->pref_values);
       return;
     }
   }
 }
 
 void ExtensionPrefStore::GetExtensionIDs(std::vector<std::string>* result) {
   for (ExtensionStack::iterator i = extension_stack_.begin();
       i != extension_stack_.end(); ++i) {
-    (*result).push_back((*i)->extension->id());
+    (*result).push_back((*i)->extension_id);
   }
 }
 
 // This could be sped up by keeping track of which extension currently controls
 // a given preference, among other optimizations. But probably fewer than 10
 // installed extensions will be trying to control any preferences, so stick
 // with this simpler algorithm until it causes a problem.
 void ExtensionPrefStore::UpdateOnePref(const char* path) {
   PrefService* pref_service = GetPrefService();
 
@@ skipping 91 matching lines @@
       if (profile_ == NULL || profile_ == extension_profile)
         UninstallExtension(extension);
       break;
     }
     default: {
       NOTREACHED();
     }
   }
 }
 
-ExtensionPrefStore::ExtensionPrefs::ExtensionPrefs(const Extension* extension,
-    PrefValueMap* values) : extension(extension), pref_values(values) {}
+void ExtensionPrefStore::AddPrecedence(const std::string& extension_id) {
+  std::vector<std::string> precedence;
+  GetExtensionPrecedences(&precedence);
+
+  bool already_present =
+      find(precedence.begin(), precedence.end(), extension_id) !=
+      precedence.end();
+  DCHECK(!already_present) << "Precedence for extension " << extension_id
+                           << " was already registered";
+
+  precedence.push_back(extension_id);
+  PersistExtensionPrecedences(precedence);
+}
+
+void ExtensionPrefStore::RemovePrecedence(const std::string& extension_id) {
+  std::vector<std::string> precedence;
+  GetExtensionPrecedences(&precedence);
+  std::vector<std::string>::iterator i =
+      find(precedence.begin(), precedence.end(), extension_id);
+  if (i != precedence.end())
+    precedence.erase(i);
+  PersistExtensionPrecedences(precedence);
+}
+
+void ExtensionPrefStore::LazyInit() {
+  DCHECK(extension_stack_.empty())
+      << "LazyInit called even though extension_stack_ is already initialized";
+
+  std::vector<std::string> precedence;
+  GetExtensionPrecedences(&precedence);
+  std::vector<std::string>::const_iterator i;
+  for (i = precedence.begin(); i != precedence.end(); ++i) {
+    ExtensionPrefs* extension_prefs =
+        new ExtensionPrefs(*i, new PrefValueMap());
+    extension_stack_.push_front(extension_prefs);
+  }
+}
+
+void ExtensionPrefStore::PersistExtensionPrecedences(
+    const std::vector<std::string>& precedence) {
+  DCHECK(profile_);
+  DCHECK(profile_->GetExtensionsService());
+  DCHECK(profile_->GetExtensionsService()->extension_prefs());
+  ::ExtensionPrefs* extension_prefs =
+      profile_->GetExtensionsService()->extension_prefs();
+  extension_prefs->PersistExtensionPrecedences(precedence);
+}
+
+void ExtensionPrefStore::GetExtensionPrecedences(
+    std::vector<std::string>* precedence) const {
+  DCHECK(profile_);
+  DCHECK(profile_->GetExtensionsService());
+  DCHECK(profile_->GetExtensionsService()->extension_prefs());
+  ::ExtensionPrefs* extension_prefs =
+      profile_->GetExtensionsService()->extension_prefs();
+  extension_prefs->GetExtensionPrecedences(precedence);
+}
+
+ExtensionPrefStore::ExtensionPrefs::ExtensionPrefs(
+    const std::string& extension_id, PrefValueMap* values)
+    : extension_id(extension_id), pref_values(values) {}
 
 ExtensionPrefStore::ExtensionPrefs::~ExtensionPrefs() {
   STLDeleteValues(pref_values);
   delete pref_values;
 }