Get rid of the extension's "Current Version" file.

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 {
 
 // Preferences keys
 
 // A preference that keeps track of per-extension settings. This is a dictionary
 // object read from the Preferences file, keyed off of extension id's.
 const wchar_t kExtensionsPref[] = L"extensions.settings";
 
 // Where an extension was installed from. (see Extension::Location)
 const wchar_t kPrefLocation[] = L"location";
 
 // Enabled, disabled, killed, etc. (see Extension::State)
 const wchar_t kPrefState[] = L"state";
 
 // The path to the current version's manifest file.
 const wchar_t kPrefPath[] = L"path";
 
+// The dictionary containing the extension's manifest.
+const wchar_t kPrefManifest[] = L"manifest";
+
+// The version number.
+const wchar_t kPrefVersion[] = L"manifest.version";
+
 // Indicates if an extension is blacklisted:
 const wchar_t kPrefBlacklist[] = L"blacklist";
 
 // A preference that tracks extension shelf configuration.  This is a list
 // object read from the Preferences file, containing a list of toolstrip URLs.
 const wchar_t kExtensionShelf[] = L"extensions.shelf";
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 InstalledExtensions::InstalledExtensions(ExtensionPrefs* prefs) {
   extension_data_.reset(prefs->CopyCurrentExtensions());
 }
 
 InstalledExtensions::~InstalledExtensions() {
 }
 
 void InstalledExtensions::VisitInstalledExtensions(
     InstalledExtensions::Callback *callback) {
+  scoped_ptr<InstalledExtensions::Callback> cleanup(callback);
   DictionaryValue::key_iterator extension_id = extension_data_->begin_keys();
   for (; extension_id != extension_data_->end_keys(); ++extension_id) {
     DictionaryValue* ext;
     if (!extension_data_->GetDictionary(*extension_id, &ext)) {
       LOG(WARNING) << "Invalid pref for extension " << *extension_id;
       NOTREACHED();
       continue;
     }
     if (ext->HasKey(kPrefBlacklist)) {
       bool is_blacklisted = false;
@@ skipping 11 matching lines @@
       LOG(WARNING) << "Missing path pref for extension " << *extension_id;
       NOTREACHED();
       continue;
     }
     int location_value;
     if (!ext->GetInteger(kPrefLocation, &location_value)) {
       LOG(WARNING) << "Missing location pref for extension " << *extension_id;
       NOTREACHED();
       continue;
     }
+    DictionaryValue* manifest = NULL;
+    if (!ext->GetDictionary(kPrefManifest, &manifest)) {
+      LOG(WARNING) << "Missing manifest for extension " << *extension_id;
+      // Just a warning for now.
+    }
+
     Extension::Location location =
         static_cast<Extension::Location>(location_value);
-    callback->Run(WideToASCII(*extension_id), FilePath(path), location);
+    callback->Run(manifest, WideToASCII(*extension_id), FilePath(path),
+                  location);
   }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 ExtensionPrefs::ExtensionPrefs(PrefService* prefs, const FilePath& root_dir)
     : prefs_(prefs),
       install_directory_(root_dir) {
   if (!prefs_->FindPreference(kExtensionsPref))
     prefs_->RegisterDictionaryPref(kExtensionsPref);
@@ skipping 203 matching lines @@
   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) {
   const std::string& id = extension->id();
-  UpdateExtensionPref(id, kPrefState,
-                      Value::CreateIntegerValue(Extension::ENABLED));
+  // Make sure we don't enable a disabled extension.
+  if (GetExtensionState(extension->id()) != Extension::DISABLED) {
+    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));
+  UpdateExtensionPref(id, kPrefManifest,
+                      extension->manifest_value()->DeepCopy());
   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 &&
@@ skipping 24 matching lines @@
   return static_cast<Extension::State>(state);
 }
 
 void ExtensionPrefs::SetExtensionState(Extension* extension,
                                        Extension::State state) {
   UpdateExtensionPref(extension->id(), kPrefState,
                       Value::CreateIntegerValue(state));
   prefs_->SavePersistentPrefs();
 }
 
+std::string ExtensionPrefs::GetVersionString(const std::string& extension_id) {
+  DictionaryValue* extension = GetExtensionPref(extension_id);
+  if (!extension)
+    return std::string();
+
+  std::string version;
+  if (!extension->GetString(kPrefVersion, &version)) {
+    LOG(ERROR) << "Bad or missing pref 'version' for extension '"
+               << extension_id << "'";
+  }
+
+  return version;
+}
+
+void ExtensionPrefs::MigrateToPrefs(Extension* extension) {
+  UpdateExtensionPref(extension->id(), kPrefManifest,
+                      extension->manifest_value()->DeepCopy());
+}
+
 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() << "Cannot modify key: '" << key.c_str()
                  << "' for extension: '" << extension_id.c_str() << "'";
     return false;
   }
   return true;
@@ skipping 22 matching lines @@
 }
 
 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;
 }