Disable an extension when it is upgraded to a version that requires more

chrome/browser/extensions/extension_prefs.cc

 // Copyright (c) 2009 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 "chrome/common/extensions/extension.h"
 
 namespace {
@@ skipping 281 matching lines @@
   ListValue* toolstrip_urls = prefs_->GetMutableList(kExtensionShelf);
   toolstrip_urls->Clear();
   for (size_t i = 0; i < urls.size(); ++i) {
     GURL url = urls[i];
     toolstrip_urls->Append(new StringValue(url.spec()));
   }
   prefs_->ScheduleSavePersistentPrefs();
 }
 
 void ExtensionPrefs::OnExtensionInstalled(Extension* extension) {
-  std::string id = extension->id();
+  const std::string& id = extension->id();
   UpdateExtensionPref(id, kPrefState,
                       Value::CreateIntegerValue(Extension::ENABLED));
   UpdateExtensionPref(id, kPrefLocation,
                       Value::CreateIntegerValue(extension->location()));
   FilePath::StringType path = MakePathRelative(install_directory_,
       extension->path(), NULL);
   UpdateExtensionPref(id, kPrefPath, Value::CreateStringValue(path));
   prefs_->SavePersistentPrefs();
 }
 
 void ExtensionPrefs::OnExtensionUninstalled(const Extension* extension,
                                             bool external_uninstall) {
   // For external extensions, we save a preference reminding ourself not to try
   // and install the extension anymore (except when |external_uninstall| is
   // true, which signifies that the registry key was deleted or the pref file
   // no longer lists the extension).
   if (!external_uninstall &&
       Extension::IsExternalLocation(extension->location())) {
     UpdateExtensionPref(extension->id(), kPrefState,
                         Value::CreateIntegerValue(Extension::KILLBIT));
     prefs_->ScheduleSavePersistentPrefs();
   } else {
     DeleteExtensionPrefs(extension->id());
   }
 }
 
+Extension::State ExtensionPrefs::GetExtensionState(
+    const std::string& extension_id) {
+  DictionaryValue* extension = GetExtensionPref(extension_id);
+
+  // If the extension doesn't have a pref, it's a --load-extension.
+  if (!extension)
+    return Extension::ENABLED;
+
+  int state = -1;
+  if (!extension->GetInteger(kPrefState, &state) ||
+      state < 0 || state >= Extension::NUM_STATES) {
+    LOG(ERROR) << "Bad or missing pref 'state' for extension '"
+               << extension_id << "'";
+    return Extension::ENABLED;
+  }
+  return static_cast<Extension::State>(state);
+}
+
+void ExtensionPrefs::SetExtensionState(Extension* extension,
+                                       Extension::State state) {
+  UpdateExtensionPref(extension->id(), kPrefState,
+                      Value::CreateIntegerValue(state));
+  prefs_->SavePersistentPrefs();
+}
+
 bool ExtensionPrefs::UpdateExtensionPref(const std::string& extension_id,
                                          const std::wstring& key,
                                          Value* data_value) {
   DictionaryValue* extension = GetOrCreateExtensionPref(extension_id);
   if (!extension->Set(key, data_value)) {
-    NOTREACHED() << L"Cannot modify key: '" << key.c_str()
+    NOTREACHED() << "Cannot modify key: '" << key.c_str()
                  << "' for extension: '" << extension_id.c_str() << "'";
     return false;
   }
   return true;
 }
 
 void ExtensionPrefs::DeleteExtensionPrefs(const std::string& extension_id) {
   std::wstring id = ASCIIToWide(extension_id);
   DictionaryValue* dict = prefs_->GetMutableDictionary(kExtensionsPref);
   if (dict->HasKey(id)) {
     dict->Remove(id, NULL);
     prefs_->ScheduleSavePersistentPrefs();
   }
 }
 
 DictionaryValue* ExtensionPrefs::GetOrCreateExtensionPref(
     const std::string& extension_id) {
   DictionaryValue* dict = prefs_->GetMutableDictionary(kExtensionsPref);
   DictionaryValue* extension = NULL;
   std::wstring id = ASCIIToWide(extension_id);
   if (!dict->GetDictionary(id, &extension)) {
     // Extension pref does not exist, create it.
     extension = new DictionaryValue();
     dict->Set(id, extension);
   }
   return extension;
 }
+
+DictionaryValue* ExtensionPrefs::GetExtensionPref(
+    const std::string& extension_id) {
+  const DictionaryValue* dict = prefs_->GetDictionary(kExtensionsPref);
+  DictionaryValue* extension = NULL;
+  std::wstring id = ASCIIToWide(extension_id);
+  dict->GetDictionary(id, &extension);
+  return extension;
+}