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

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"
@@ skipping 100 matching lines @@
   CrxInstaller::Start(extension_path, install_directory_, Extension::INTERNAL,
                       "",   // no expected id
                       false,  // don't delete crx when complete
                       backend_loop_,
                       this,
                       NULL);  // no client (silent install)
 }
 
 void ExtensionsService::UpdateExtension(const std::string& id,
                                         const FilePath& extension_path) {
-  if (!GetExtensionById(id)) {
+  if (!GetExtensionByIdInternal(id, true, true)) {
     LOG(WARNING) << "Will not update extension " << id << " because it is not "
                  << "installed";
     return;
   }
 
   CrxInstaller::Start(extension_path, install_directory_, Extension::INTERNAL,
                       id,
                       true,  // delete crx when complete
                       backend_loop_,
                       this,
                       NULL);  // no client (silent install)
 }
 
 void ExtensionsService::ReloadExtension(const std::string& extension_id) {
   Extension* extension = GetExtensionById(extension_id);
   FilePath extension_path = extension->path();
 
   UnloadExtension(extension_id);
   LoadExtension(extension_path);
 }
 
 void ExtensionsService::UninstallExtension(const std::string& extension_id,
                                            bool external_uninstall) {
-  Extension* extension = GetExtensionById(extension_id);
+  Extension* extension = GetExtensionByIdInternal(extension_id, true, true);
 
   // Callers should not send us nonexistant extensions.
   DCHECK(extension);
 
   extension_prefs_->OnExtensionUninstalled(extension, external_uninstall);
 
   // Tell the backend to start deleting installed extensions on the file thread.
   if (Extension::LOAD != extension->location()) {
     backend_loop_->PostTask(FROM_HERE, NewRunnableFunction(
       &extension_file_util::UninstallExtension, extension_id,
       install_directory_));
   }
 
   UnloadExtension(extension_id);
 }
 
+void ExtensionsService::EnableExtension(const std::string& extension_id) {
+  Extension* extension = GetExtensionByIdInternal(extension_id, false, true);
+  if (!extension) {
+    NOTREACHED() << "Trying to enable an extension that isn't disabled.";
+    return;
+  }
+
+  // Move it over to the enabled list.
+  extension_prefs_->SetExtensionState(extension, Extension::ENABLED);
+  extensions_.push_back(extension);
+  ExtensionList::iterator iter = std::find(disabled_extensions_.begin(),
+                                           disabled_extensions_.end(),
+                                           extension);
+  disabled_extensions_.erase(iter);
+
+  ExtensionList extensions;
+  extensions.push_back(extension);
+  NotificationService::current()->Notify(
+      NotificationType::EXTENSIONS_LOADED,
+      Source<ExtensionsService>(this),
+      Details<ExtensionList>(&extensions));
+}
+
 void ExtensionsService::LoadExtension(const FilePath& extension_path) {
   backend_loop_->PostTask(FROM_HERE, NewRunnableMethod(backend_.get(),
       &ExtensionsServiceBackend::LoadSingleExtension,
       extension_path, scoped_refptr<ExtensionsService>(this)));
 }
 
 void ExtensionsService::LoadAllExtensions() {
   // Load the previously installed extensions.
   backend_loop_->PostTask(FROM_HERE, NewRunnableMethod(backend_.get(),
       &ExtensionsServiceBackend::LoadInstalledExtensions,
@@ skipping 34 matching lines @@
   // later?
   std::set<std::string> killed_extensions;
   extension_prefs_->GetKilledExtensionIds(&killed_extensions);
   backend_loop_->PostTask(FROM_HERE, NewRunnableMethod(backend_.get(),
       &ExtensionsServiceBackend::CheckForExternalUpdates,
       killed_extensions,
       scoped_refptr<ExtensionsService>(this)));
 }
 
 void ExtensionsService::UnloadExtension(const std::string& extension_id) {
-  Extension* extension = NULL;
-  ExtensionList::iterator iter;
-  for (iter = extensions_.begin(); iter != extensions_.end(); ++iter) {
-    if ((*iter)->id() == extension_id) {
-      extension = *iter;
-      break;
-    }
+  scoped_ptr<Extension> extension(
+      GetExtensionByIdInternal(extension_id, true, true));
+
+  // Callers should not send us nonexistant extensions.
+  CHECK(extension.get());
+
+  ExtensionList::iterator iter = std::find(disabled_extensions_.begin(),
+                                           disabled_extensions_.end(),
+                                           extension.get());
+  if (iter != disabled_extensions_.end()) {
+    // It's disabled, so don't send the unload notification.
+    disabled_extensions_.erase(iter);
+    return;
   }
 
-  // Callers should not send us nonexistant extensions.
-  CHECK(extension);
+  iter = std::find(extensions_.begin(), extensions_.end(), extension.get());
 
   // Remove the extension from our list.
   extensions_.erase(iter);
 
   // Tell other services the extension is gone.
   NotificationService::current()->Notify(NotificationType::EXTENSION_UNLOADED,
                                          Source<ExtensionsService>(this),
-                                         Details<Extension>(extension));
-
-  delete extension;
+                                         Details<Extension>(extension.get()));
 }
 
 void ExtensionsService::UnloadAllExtensions() {
   ExtensionList::iterator iter;
   for (iter = extensions_.begin(); iter != extensions_.end(); ++iter)
     delete *iter;
   extensions_.clear();
 
   // TODO(erikkay) should there be a notification for this?  We can't use
   // EXTENSION_UNLOADED since that implies that the extension has been disabled
@@ skipping 23 matching lines @@
 
 void ExtensionsService::OnExtensionsLoaded(ExtensionList* new_extensions) {
   scoped_ptr<ExtensionList> cleanup(new_extensions);
 
   // Filter out any extensions that shouldn't be loaded. If extensions are
   // enabled, load everything. Otherwise load only:
   // - themes
   // - --load-extension
   // - externally installed extensions
   ExtensionList enabled_extensions;
+  ExtensionList disabled_extensions;
   for (ExtensionList::iterator iter = new_extensions->begin();
        iter != new_extensions->end(); ++iter) {
+    // Extensions that get enabled get added to extensions_ and deleted later.
+    // Anything skipped must be deleted now so we don't leak.
+    scoped_ptr<Extension> extension(*iter);
     if (extensions_enabled() ||
-        (*iter)->IsTheme() ||
-        (*iter)->location() == Extension::LOAD ||
-        Extension::IsExternalLocation((*iter)->location())) {
-      Extension* old = GetExtensionById((*iter)->id());
+        extension->IsTheme() ||
+        extension->location() == Extension::LOAD ||
+        Extension::IsExternalLocation(extension->location())) {
+      Extension* old = GetExtensionById(extension->id());
       if (old) {
-        if ((*iter)->version()->CompareTo(*(old->version())) > 0) {
+        if (extension->version()->CompareTo(*(old->version())) > 0) {
+          bool higher_permissions =
+              (extension->GetPermissionClass() > old->GetPermissionClass());
+
           // To upgrade an extension in place, unload the old one and
           // then load the new one.
-          // TODO(erikkay) issue 12399
           UnloadExtension(old->id());
+          old = NULL;
+
+          if (higher_permissions) {
+            // Extension was upgraded to a high permission class. Disable it and
+            // notify the user.
+            extension_prefs_->SetExtensionState(extension.get(),
+                                                Extension::DISABLED);
+            NotificationService::current()->Notify(
+                NotificationType::EXTENSION_UPDATE_DISABLED,
+                Source<ExtensionsService>(this),
+                Details<Extension>(extension.get()));
+          }
         } else {
           // We already have the extension of the same or older version.
           LOG(WARNING) << "Duplicate extension load attempt: " << (*iter)->id();
-          delete *iter;
           continue;
         }
       }
-      enabled_extensions.push_back(*iter);
-      extensions_.push_back(*iter);
-    } else {
-      // Extensions that get enabled get added to extensions_ and deleted later.
-      // Anything skipped must be deleted now so we don't leak.
-      delete *iter;
+
+      switch (extension_prefs_->GetExtensionState(extension->id())) {
+        case Extension::ENABLED:
+          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;
+      }
     }
   }
 
   if (enabled_extensions.size()) {
     NotificationService::current()->Notify(
         NotificationType::EXTENSIONS_LOADED,
         Source<ExtensionsService>(this),
         Details<ExtensionList>(&enabled_extensions));
     for (ExtensionList::iterator iter = enabled_extensions.begin();
          iter != enabled_extensions.end(); ++iter) {
@@ skipping 23 matching lines @@
         Source<ExtensionsService>(this),
         Details<Extension>(extension));
   }
 
   // Also load the extension.
   ExtensionList* list = new ExtensionList;
   list->push_back(extension);
   OnExtensionsLoaded(list);
 }
 
-
 void ExtensionsService::OnExtensionOverinstallAttempted(const std::string& id) {
   Extension* extension = GetExtensionById(id);
   if (extension && extension->IsTheme()) {
     NotificationService::current()->Notify(
         NotificationType::THEME_INSTALLED,
         Source<ExtensionsService>(this),
         Details<Extension>(extension));
   }
 }
 
-Extension* ExtensionsService::GetExtensionById(const std::string& id) {
+Extension* ExtensionsService::GetExtensionByIdInternal(const std::string& id,
+                                                       bool include_enabled,
+                                                       bool include_disabled) {
   std::string lowercase_id = StringToLowerASCII(id);
-  for (ExtensionList::const_iterator iter = extensions_.begin();
-      iter != extensions_.end(); ++iter) {
-    if ((*iter)->id() == lowercase_id)
-      return *iter;
+  if (include_enabled) {
+    for (ExtensionList::const_iterator iter = extensions_.begin();
+        iter != extensions_.end(); ++iter) {
+      if ((*iter)->id() == lowercase_id)
+        return *iter;
+    }
+  }
+  if (include_disabled) {
+    for (ExtensionList::const_iterator iter = disabled_extensions_.begin();
+        iter != disabled_extensions_.end(); ++iter) {
+      if ((*iter)->id() == lowercase_id)
+        return *iter;
+    }
   }
   return NULL;
 }
 
 Extension* ExtensionsService::GetExtensionByURL(const GURL& url) {
   std::string host = url.host();
   return GetExtensionById(host);
 }
 
 void ExtensionsService::ClearProvidersForTesting() {
@@ skipping 228 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));
 }