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

chrome/browser/extensions/extensions_service.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/extensions_service.h"
 
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/string_util.h"
 #include "base/values.h"
 #include "chrome/browser/extensions/crx_installer.h"
 #include "chrome/browser/extensions/extension_browser_event_router.h"
 #include "chrome/browser/extensions/extension_file_util.h"
 #include "chrome/browser/extensions/extension_updater.h"
 #include "chrome/browser/extensions/external_extension_provider.h"
 #include "chrome/browser/extensions/external_pref_extension_provider.h"
 #include "chrome/browser/profile.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_error_reporter.h"
 #include "chrome/common/notification_service.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/pref_service.h"
 #include "chrome/common/url_constants.h"
 
 #if defined(OS_WIN)
 #include "chrome/browser/extensions/external_registry_extension_provider_win.h"
 #endif
 
+namespace {
+
+// Helper class to collect the IDs of every extension listed in the prefs.
+class InstalledExtensionSet {
+ public:
+  InstalledExtensionSet(InstalledExtensions* installed) {
+    scoped_ptr<InstalledExtensions> cleanup(installed);
+    installed->VisitInstalledExtensions(
+        NewCallback(this, &InstalledExtensionSet::ExtensionVisited));
+  }
+
+  const std::set<std::string>& extensions() { return extensions_; }
+
+ private:
+  void ExtensionVisited(
+      DictionaryValue* manifest, const std::string& id,
+      const FilePath& path, Extension::Location location) {
+    extensions_.insert(id);
+  }
+
+  std::set<std::string> extensions_;
+};
+
+} // namespace
+
 // ExtensionsService.
 
 const char* ExtensionsService::kInstallDirectoryName = "Extensions";
 const char* ExtensionsService::kCurrentVersionFileName = "Current Version";
 
 const char* ExtensionsService::kGalleryDownloadURLPrefix =
     "https://dl-ssl.google.com/chrome/";
 const char* ExtensionsService::kGalleryURLPrefix =
     "https://tools.google.com/chrome/";
 
@@ skipping 235 matching lines @@
   // EXTENSION_UNLOADED since that implies that the extension has been disabled
   // or uninstalled, and UnloadAll is just part of shutdown.
 }
 
 void ExtensionsService::ReloadExtensions() {
   UnloadAllExtensions();
   LoadAllExtensions();
 }
 
 void ExtensionsService::GarbageCollectExtensions() {
+  InstalledExtensionSet installed(
+      new InstalledExtensions(extension_prefs_.get()));
   backend_loop_->PostTask(FROM_HERE, NewRunnableFunction(
-      &extension_file_util::GarbageCollectExtensions, install_directory_));
+      &extension_file_util::GarbageCollectExtensions, install_directory_,
+      installed.extensions()));
 }
 
 void ExtensionsService::OnLoadedInstalledExtensions() {
   ready_ = true;
   if (updater_.get()) {
     updater_->Start();
   }
   NotificationService::current()->Notify(
       NotificationType::EXTENSIONS_READY,
       Source<ExtensionsService>(this),
@@ skipping 42 matching lines @@
           }
         } else {
           // We already have the extension of the same or older version.
           LOG(WARNING) << "Duplicate extension load attempt: " << (*iter)->id();
           continue;
         }
       }
 
       switch (extension_prefs_->GetExtensionState(extension->id())) {
         case Extension::ENABLED:
+          if (extension->location() != Extension::LOAD)
+            extension_prefs_->MigrateToPrefs(extension.get());
           enabled_extensions.push_back(extension.get());
           extensions_.push_back(extension.release());
           break;
         case Extension::DISABLED:
           disabled_extensions.push_back(extension.get());
           disabled_extensions_.push_back(extension.release());
           break;
         default:
           break;
       }
@@ skipping 11 matching lines @@
         NotificationService::current()->Notify(
             NotificationType::THEME_INSTALLED,
             Source<ExtensionsService>(this),
             Details<Extension>(*iter));
       }
     }
   }
 }
 
 void ExtensionsService::OnExtensionInstalled(Extension* extension) {
-  // Make sure we don't enable a disabled extension.
-  if (extension_prefs_->GetExtensionState(extension->id()) !=
-      Extension::DISABLED) {
-    extension_prefs_->OnExtensionInstalled(extension);
-  }
+  extension_prefs_->OnExtensionInstalled(extension);
 
   // If the extension is a theme, tell the profile (and therefore ThemeProvider)
   // to apply it.
   if (extension->IsTheme()) {
     NotificationService::current()->Notify(
         NotificationType::THEME_INSTALLED,
         Source<ExtensionsService>(this),
         Details<Extension>(extension));
   } else {
     NotificationService::current()->Notify(
@@ skipping 113 matching lines @@
 }
 
 void ExtensionsServiceBackend::LoadInstalledExtensions(
     scoped_refptr<ExtensionsService> frontend,
     InstalledExtensions* installed) {
   scoped_ptr<InstalledExtensions> cleanup(installed);
   frontend_ = frontend;
   alert_on_error_ = false;
 
   // Call LoadInstalledExtension for each extension |installed| knows about.
-  scoped_ptr<InstalledExtensions::Callback> callback(
+  installed->VisitInstalledExtensions(
       NewCallback(this, &ExtensionsServiceBackend::LoadInstalledExtension));
-  installed->VisitInstalledExtensions(callback.get());
 
   frontend_loop_->PostTask(FROM_HERE, NewRunnableMethod(
       frontend_, &ExtensionsService::OnLoadedInstalledExtensions));
 }
 
 void ExtensionsServiceBackend::LoadSingleExtension(
     const FilePath& path_in, scoped_refptr<ExtensionsService> frontend) {
   frontend_ = frontend;
 
   // Explicit UI loads are always noisy.
@@ skipping 16 matching lines @@
     return;
   }
 
   extension->set_location(Extension::LOAD);
   ExtensionList* extensions = new ExtensionList;
   extensions->push_back(extension);
   ReportExtensionsLoaded(extensions);
 }
 
 void ExtensionsServiceBackend::LoadInstalledExtension(
-    const std::string& id, const FilePath& path, Extension::Location location) {
+    DictionaryValue* manifest, const std::string& id,
+    const FilePath& path, Extension::Location location) {
   if (CheckExternalUninstall(id, location)) {
     frontend_loop_->PostTask(FROM_HERE, NewRunnableMethod(
         frontend_,
         &ExtensionsService::UninstallExtension,
         id, true));
 
     // No error needs to be reported. The extension effectively doesn't exist.
     return;
   }
 
   std::string error;
-  Extension* extension = extension_file_util::LoadExtension(
-      path,
-      true,  // Require id
-      &error);
+  Extension* extension = NULL;
+  if (manifest) {
+    scoped_ptr<Extension> tmp(new Extension(path));
+    if (tmp->InitFromValue(*manifest, true, &error) &&
+        extension_file_util::ValidateExtension(tmp.get(), &error)) {
+      extension = tmp.release();
+    }
+  } else {
+    // TODO(mpcomplete): obsolete. remove after migration period.
+    // http://code.google.com/p/chromium/issues/detail?id=19733
+    extension = extension_file_util::LoadExtension(path,
+                                                   true,  // Require id
+                                                   &error);
+  }
 
   if (!extension) {
     ReportExtensionLoadError(path, error);
     return;
   }
 
   // TODO(erikkay) now we only report a single extension loaded at a time.
   // Perhaps we should change the notifications to remove ExtensionList.
   extension->set_location(location);
   ExtensionList* extensions = new ExtensionList;
@@ skipping 88 matching lines @@
       linked_ptr<ExternalExtensionProvider>(test_provider);
 }
 
 void ExtensionsServiceBackend::OnExternalExtensionFound(
     const std::string& id, const Version* version, const FilePath& path,
     Extension::Location location) {
   frontend_loop_->PostTask(FROM_HERE, NewRunnableMethod(frontend_,
       &ExtensionsService::OnExternalExtensionFound, id, version->GetString(),
       path, location));
 }