Allow extension overinstall

chrome/browser/extensions/extensions_service.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/extensions_service.h"
 
 #include "base/basictypes.h"
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/histogram.h"
@@ skipping 39 matching lines @@
 #if defined(OS_WIN)
 #include "chrome/browser/extensions/external_registry_extension_provider_win.h"
 #endif
 
 using base::Time;
 
 namespace errors = extension_manifest_errors;
 
 namespace {
 
-// Helper class to collect the IDs of every extension listed in the prefs.
-class InstalledExtensionSet {
- public:
-  explicit InstalledExtensionSet(ExtensionPrefs* prefs) {
-    scoped_ptr<ExtensionPrefs::ExtensionsInfo> info(
-        prefs->GetInstalledExtensionsInfo());
-
-    for (size_t i = 0; i < info->size(); ++i) {
-      std::string version;
-      const DictionaryValue* manifest = info->at(i)->extension_manifest.get();
-      if (!manifest ||
-          !manifest->GetString(extension_manifest_keys::kVersion, &version)) {
-        // Without a version, the extension is invalid. Ignoring it here will
-        // cause it to get garbage collected.
-        continue;
-      }
-      extensions_.insert(info->at(i)->extension_id);
-      versions_[info->at(i)->extension_id] = version;
-    }
-  }
-
-  const std::set<std::string>& extensions() { return extensions_; }
-  const std::map<std::string, std::string>& versions() { return versions_; }
-
- private:
-  std::set<std::string> extensions_;
-  std::map<std::string, std::string> versions_;
-};
-
 static bool ShouldReloadExtensionManifest(const ExtensionInfo& info) {
   // Always reload LOAD extension manifests, because they can change on disk
   // independent of the manifest in our prefs.
   if (info.extension_location == Extension::LOAD)
     return true;
 
   // Otherwise, reload the manifest it needs to be relocalized.
   return extension_l10n_util::ShouldRelocalizeManifest(info);
 }
 
@@ skipping 259 matching lines @@
   UnloadExtension(extension_id);
 
   extension_prefs_->OnExtensionUninstalled(extension_id_copy, location,
                                            external_uninstall);
 
   // Tell the backend to start deleting installed extensions on the file thread.
   if (Extension::LOAD != location) {
     ChromeThread::PostTask(
       ChromeThread::FILE, FROM_HERE,
       NewRunnableFunction(
-          &extension_file_util::UninstallExtension, extension_id_copy,
-          install_directory_));
+          &extension_file_util::UninstallExtension,
+          install_directory_,
+          extension_id_copy));
   }
 
   ClearExtensionData(extension_url);
 }
 
 void ExtensionsService::ClearExtensionData(const GURL& extension_url) {
   scoped_refptr<ExtensionDataDeleter> deleter(
       new ExtensionDataDeleter(profile_, extension_url));
   deleter->StartDeleting();
 }
@@ skipping 379 matching lines @@
 
 void ExtensionsService::ReloadExtensions() {
   UnloadAllExtensions();
   LoadAllExtensions();
 }
 
 void ExtensionsService::GarbageCollectExtensions() {
   if (extension_prefs_->pref_service()->read_only())
     return;
 
-  InstalledExtensionSet installed(extension_prefs_.get());
+  scoped_ptr<ExtensionPrefs::ExtensionsInfo> info(
+      extension_prefs_->GetInstalledExtensionsInfo());
+
+  std::map<std::string, FilePath> extension_paths;
+  for (size_t i = 0; i < info->size(); ++i)
+    extension_paths[info->at(i)->extension_id] = info->at(i)->extension_path;
+
   ChromeThread::PostTask(
       ChromeThread::FILE, FROM_HERE,
       NewRunnableFunction(
           &extension_file_util::GarbageCollectExtensions, install_directory_,
-          installed.extensions(), installed.versions()));
+          extension_paths));
 }
 
 void ExtensionsService::OnLoadedInstalledExtensions() {
   ready_ = true;
   if (updater_.get()) {
     updater_->Start();
   }
   NotificationService::current()->Notify(
       NotificationType::EXTENSIONS_READY,
       Source<Profile>(profile_),
       NotificationService::NoDetails());
 }
 
 void ExtensionsService::OnExtensionLoaded(Extension* extension,
                                           bool allow_privilege_increase) {
   // Ensure extension is deleted unless we transfer ownership.
   scoped_ptr<Extension> scoped_extension(extension);
 
   // The extension is now loaded, remove its data from unloaded extension map.
   unloaded_extension_paths_.erase(extension->id());
 
   // TODO(aa): Need to re-evaluate this branch. Does this still make sense now
   // that extensions are enabled by default?
   if (extensions_enabled() ||
       extension->IsTheme() ||
       extension->location() == Extension::LOAD ||
       Extension::IsExternalLocation(extension->location())) {
     Extension* old = GetExtensionByIdInternal(extension->id(), true, true);
     if (old) {
-      if (extension->version()->CompareTo(*(old->version())) > 0) {
-        bool allow_silent_upgrade =
-            allow_privilege_increase || !Extension::IsPrivilegeIncrease(
-                old, extension);
+      // CrxInstaller should have guaranteed that we aren't downgrading.
+      CHECK(extension->version()->CompareTo(*(old->version())) >= 0);
 
-        // Extensions get upgraded if silent upgrades are allowed, otherwise
-        // they get disabled.
-        if (allow_silent_upgrade) {
-          old->set_being_upgraded(true);
-          extension->set_being_upgraded(true);
-        }
+      bool allow_silent_upgrade =
+          allow_privilege_increase || !Extension::IsPrivilegeIncrease(
+              old, extension);
 
-        // To upgrade an extension in place, unload the old one and
-        // then load the new one.
-        UnloadExtension(old->id());
-        old = NULL;
+      // Extensions get upgraded if silent upgrades are allowed, otherwise
+      // they get disabled.
+      if (allow_silent_upgrade) {
+        old->set_being_upgraded(true);
+        extension->set_being_upgraded(true);
+      }
 
-        if (!allow_silent_upgrade) {
-          // Extension has changed permissions significantly. Disable it. We
-          // send a notification below.
-          extension_prefs_->SetExtensionState(extension, Extension::DISABLED);
-          extension_prefs_->SetDidExtensionEscalatePermissions(extension, true);
-        }
-      } else {
-        // We already have the extension of the same or older version.
-        std::string error_message("Duplicate extension load attempt: ");
-        error_message += extension->id();
-        LOG(WARNING) << error_message;
-        ReportExtensionLoadError(extension->path(),
-                                 error_message,
-                                 NotificationType::EXTENSION_OVERINSTALL_ERROR,
-                                 false);
-        return;
+      // To upgrade an extension in place, unload the old one and
+      // then load the new one.
+      UnloadExtension(old->id());
+      old = NULL;
+
+      if (!allow_silent_upgrade) {
+        // Extension has changed permissions significantly. Disable it. We
+        // send a notification below.
+        extension_prefs_->SetExtensionState(extension, Extension::DISABLED);
+        extension_prefs_->SetDidExtensionEscalatePermissions(extension, true);
       }
     }
 
     switch (extension_prefs_->GetExtensionState(extension->id())) {
       case Extension::ENABLED:
         extensions_.push_back(scoped_extension.release());
 
         NotifyExtensionLoaded(extension);
 
         ExtensionDOMUI::RegisterChromeURLOverrides(profile_,
@@ skipping 63 matching lines @@
 
   // Also load the extension.
   OnExtensionLoaded(extension, allow_privilege_increase);
 
   // Erase any pending extension.
   if (it != pending_extensions_.end()) {
     pending_extensions_.erase(it);
   }
 }
 
-void ExtensionsService::OnExtensionOverinstallAttempted(const std::string& id) {
-  Extension* extension = GetExtensionById(id, false);
-  if (extension && extension->IsTheme()) {
-    NotificationService::current()->Notify(
-        NotificationType::THEME_INSTALLED,
-        Source<Profile>(profile_),
-        Details<Extension>(extension));
-  } else {
-    NotificationService::current()->Notify(
-      NotificationType::NO_THEME_DETECTED,
-      Source<Profile>(profile_),
-      NotificationService::NoDetails());
-  }
-}
-
 Extension* ExtensionsService::GetExtensionByIdInternal(const std::string& id,
                                                        bool include_enabled,
                                                        bool include_disabled) {
   std::string lowercase_id = StringToLowerASCII(id);
   if (include_enabled) {
     for (ExtensionList::const_iterator iter = extensions_.begin();
         iter != extensions_.end(); ++iter) {
       if ((*iter)->id() == lowercase_id)
         return *iter;
     }
@@ skipping 299 matching lines @@
   // Finish installing on UI thread.
   ChromeThread::PostTask(
       ChromeThread::UI, FROM_HERE,
       NewRunnableMethod(
           frontend_,
           &ExtensionsService::ContinueLoadAllExtensions,
           extensions_to_reload,
           start_time,
           true));
 }