Simplify the handling of crashed extensions.

chrome/browser/extensions/extension_service.cc

 // Copyright (c) 2012 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_service.h"
 
 #include <algorithm>
 #include <set>
 
 #include "base/basictypes.h"
@@ skipping 382 matching lines @@
       tracker_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // Figure out if extension installation should be enabled.
   if (command_line->HasSwitch(switches::kDisableExtensions)) {
     extensions_enabled_ = false;
   } else if (profile->GetPrefs()->GetBoolean(prefs::kDisableExtensions)) {
     extensions_enabled_ = false;
   }
 
-  registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_PROCESS_TERMINATED,
-                 content::NotificationService::AllBrowserContextsAndSources());
   registrar_.Add(this, content::NOTIFICATION_RENDERER_PROCESS_CREATED,
                  content::NotificationService::AllBrowserContextsAndSources());
   registrar_.Add(this, content::NOTIFICATION_RENDERER_PROCESS_TERMINATED,
                  content::NotificationService::AllBrowserContextsAndSources());
   pref_change_registrar_.Init(profile->GetPrefs());
   pref_change_registrar_.Add(prefs::kExtensionInstallAllowList, this);
   pref_change_registrar_.Add(prefs::kExtensionInstallDenyList, this);
 
   // Set up the ExtensionUpdater
   if (autoupdate_enabled) {
@@ skipping 37 matching lines @@
 }
 
 const ExtensionSet* ExtensionService::extensions() const {
   return &extensions_;
 }
 
 const ExtensionSet* ExtensionService::disabled_extensions() const {
   return &disabled_extensions_;
 }
 
-const ExtensionSet* ExtensionService::terminated_extensions() const {
-  return &terminated_extensions_;
-}
-
 const ExtensionSet* ExtensionService::GenerateInstalledExtensionsSet() const {
   ExtensionSet* installed_extensions = new ExtensionSet();
   installed_extensions->InsertAll(extensions_);
   installed_extensions->InsertAll(disabled_extensions_);
-  installed_extensions->InsertAll(terminated_extensions_);
   return installed_extensions;
 }
 
 PendingExtensionManager* ExtensionService::pending_extension_manager() {
   return &pending_extension_manager_;
 }
 
 ExtensionService::~ExtensionService() {
   // No need to unload extensions here because they are profile-scoped, and the
   // profile is in the process of being deleted.
@@ skipping 76 matching lines @@
 
 #if defined(OS_CHROMEOS) && defined(USE_VIRTUAL_KEYBOARD)
   ExtensionInputUiEventRouter::GetInstance()->Init();
 #endif
 
   event_routers_initialized_ = true;
 }
 
 const Extension* ExtensionService::GetExtensionById(
     const std::string& id, bool include_disabled) const {
-  return GetExtensionByIdInternal(id, true, include_disabled, false);
+  return GetExtensionByIdInternal(id, true, include_disabled);
 }
 
 void ExtensionService::Init() {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   DCHECK(!ready_);  // Can't redo init.
   DCHECK_EQ(extensions_.size(), 0u);
 
   component_loader_->LoadAll();
   extensions::InstalledLoader(this).LoadAllExtensions();
@@ skipping 23 matching lines @@
     const std::string& id,
     const FilePath& extension_path,
     const GURL& download_url,
     CrxInstaller** out_crx_installer) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   PendingExtensionInfo pending_extension_info;
   bool is_pending_extension = pending_extension_manager_.GetById(
       id, &pending_extension_info);
 
-  const Extension* extension =
-      GetExtensionByIdInternal(id, true, true, false);
+  const Extension* extension = GetExtensionByIdInternal(id, true, true);
   if (!is_pending_extension && !extension) {
     LOG(WARNING) << "Will not update extension " << id
                  << " because it is not installed or pending";
     // Delete extension_path since we're not creating a CrxInstaller
     // that would do it for us.
     if (!BrowserThread::PostTask(
             BrowserThread::FILE, FROM_HERE,
             base::Bind(
                 &extension_file_util::DeleteFile, extension_path, false)))
       NOTREACHED();
@@ skipping 188 matching lines @@
 
   if (extension->is_hosted_app() &&
       !profile_->GetExtensionSpecialStoragePolicy()->
           IsStorageProtected(launch_web_url_origin)) {
     ExtensionDataDeleter::StartDeleting(
         profile_, extension_id, launch_web_url_origin, is_storage_isolated);
   }
   ExtensionDataDeleter::StartDeleting(
       profile_, extension_id, extension->url(), is_storage_isolated);
 
-  UntrackTerminatedExtension(extension_id);
-
   // Notify interested parties that we've uninstalled this extension.
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_EXTENSION_UNINSTALLED,
       content::Source<Profile>(profile_),
       content::Details<const std::string>(&extension_id));
 
   if (sync_bundle && sync_bundle->HasExtensionId(extension_id)) {
     sync_bundle->sync_processor->ProcessSyncChanges(
         FROM_HERE, SyncChangeList(1, sync_change));
     sync_bundle->synced_extensions.erase(extension_id);
@@ skipping 15 matching lines @@
   // Therefore, we clear warnings of this type for all extensions.
   std::set<ExtensionWarningSet::WarningType> warnings;
   extension_warnings_.GetWarningsAffectingExtension(extension_id, &warnings);
   extension_warnings_.ClearWarnings(warnings);
 
   return true;
 }
 
 bool ExtensionService::IsExtensionEnabled(
     const std::string& extension_id) const {
-  if (extensions_.Contains(extension_id) ||
-      terminated_extensions_.Contains(extension_id))
+  if (extensions_.Contains(extension_id))
     return true;
 
   if (disabled_extensions_.Contains(extension_id))
     return false;
 
   // If the extension hasn't been loaded yet, check the prefs for it. Assume
   // enabled unless otherwise noted.
   return !extension_prefs_->IsExtensionDisabled(extension_id) &&
       !extension_prefs_->IsExternalExtensionUninstalled(extension_id);
 }
 
 bool ExtensionService::IsExternalExtensionUninstalled(
     const std::string& extension_id) const {
   return extension_prefs_->IsExternalExtensionUninstalled(extension_id);
 }
 
 void ExtensionService::EnableExtension(const std::string& extension_id) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (IsExtensionEnabled(extension_id))
     return;
 
   extension_prefs_->SetExtensionState(extension_id, Extension::ENABLED);
 
   const Extension* extension =
-      GetExtensionByIdInternal(extension_id, false, true, false);
+      GetExtensionByIdInternal(extension_id, false, true);
   // This can happen if sync enables an extension that is not
   // installed yet.
   if (!extension)
     return;
 
   // Move it over to the enabled list.
   extensions_.Insert(make_scoped_refptr(extension));
   disabled_extensions_.Remove(extension->id());
 
   // Make sure any browser action contained within it is not hidden.
@@ skipping 12 matching lines @@
     return;
 
   const Extension* extension = GetInstalledExtension(extension_id);
   // |extension| can be NULL if sync disables an extension that is not
   // installed yet.
   if (extension && !Extension::UserMayDisable(extension->location()))
     return;
 
   extension_prefs_->SetExtensionState(extension_id, Extension::DISABLED);
 
-  extension = GetExtensionByIdInternal(extension_id, true, false, true);
+  extension = GetExtensionByIdInternal(extension_id, true, false);
   if (!extension)
     return;
 
   // Move it over to the disabled list.
   disabled_extensions_.Insert(make_scoped_refptr(extension));
   if (extensions_.Contains(extension->id()))
     extensions_.Remove(extension->id());
-  else
-    terminated_extensions_.Remove(extension->id());
 
   NotifyExtensionUnloaded(extension, extension_misc::UNLOAD_REASON_DISABLE);
 
   SyncExtensionChangeIfNeeded(*extension);
 
   // Deactivating one extension might have solved the problems of others.
   // Therefore, we clear warnings of this type for all extensions.
   std::set<ExtensionWarningSet::WarningType> warnings;
   extension_warnings_.GetWarningsAffectingExtension(extension_id, &warnings);
   extension_warnings_.ClearWarnings(warnings);
@@ skipping 522 matching lines @@
           GetPageOrdinal(extension.id())));
     }
   }
 }
 
 std::vector<ExtensionSyncData> ExtensionService::GetSyncDataList(
     const SyncBundle& bundle) const {
   std::vector<ExtensionSyncData> extension_sync_list;
   GetSyncDataListHelper(extensions_, bundle, &extension_sync_list);
   GetSyncDataListHelper(disabled_extensions_, bundle, &extension_sync_list);
-  GetSyncDataListHelper(terminated_extensions_, bundle, &extension_sync_list);
 
   for (std::map<std::string, ExtensionSyncData>::const_iterator i =
            bundle.pending_sync_data.begin();
        i != bundle.pending_sync_data.end();
        ++i) {
     extension_sync_list.push_back(i->second);
   }
 
   return extension_sync_list;
 }
@@ skipping 418 matching lines @@
 void ExtensionService::HandleExtensionAlertDetails(Browser* browser) {
   DCHECK(browser);
   browser->ShowExtensionsTab();
 }
 
 void ExtensionService::UnloadExtension(
     const std::string& extension_id,
     extension_misc::UnloadedExtensionReason reason) {
   // Make sure the extension gets deleted after we return from this function.
   scoped_refptr<const Extension> extension(
-      GetExtensionByIdInternal(extension_id, true, true, false));
+      GetExtensionByIdInternal(extension_id, true, true));
 
   // This method can be called via PostTask, so the extension may have been
   // unloaded by the time this runs.
   if (!extension) {
     // In case the extension may have crashed/uninstalled. Allow the profile to
     // clean up its RequestContexts.
     profile_->UnregisterExtensionWithRequestContexts(extension_id, reason);
     return;
   }
 
@@ skipping 27 matching lines @@
 
   NotifyExtensionUnloaded(extension.get(), reason);
 }
 
 void ExtensionService::UnloadAllExtensions() {
   profile_->GetExtensionSpecialStoragePolicy()->
       RevokeRightsForAllExtensions();
 
   extensions_.Clear();
   disabled_extensions_.Clear();
-  terminated_extensions_.Clear();
   extension_runtime_data_.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
   // or uninstalled, and UnloadAll is just part of shutdown.
 }
 
 void ExtensionService::ReloadExtensions() {
   UnloadAllExtensions();
   component_loader_->LoadAll();
@@ skipping 50 matching lines @@
       !extension->is_theme() &&
       extension->location() != Extension::COMPONENT &&
       !Extension::IsExternalLocation(extension->location()))
     return;
 
   SetBeingUpgraded(extension, false);
 
   // The extension is now loaded, remove its data from unloaded extension map.
   unloaded_extension_paths_.erase(extension->id());
 
-  // If a terminated extension is loaded, remove it from the terminated list.
-  UntrackTerminatedExtension(extension->id());
-
   // If the extension was disabled for a reload, then enable it.
   if (disabled_extension_paths_.erase(extension->id()) > 0)
     EnableExtension(extension->id());
 
   // Check if the extension's privileges have changed and disable the
   // extension if necessary.
   InitializePermissions(extension);
 
   bool disabled = extension_prefs_->IsExtensionDisabled(extension->id());
   if (disabled) {
@@ skipping 58 matching lines @@
   // maintain backwards compatibility while still having "omnibox" in the
   // manifest. If a user installs the extension on Chrome 9, the browser
   // will record the permissions it recognized, not including "omnibox."
   // When upgrading to Chrome 10, "omnibox" will be recognized and Chrome
   // will disable the extension and prompt the user to approve the increase
   // in privileges. The extension could then release a new version that
   // removes the "omnibox" permission. When the user upgrades, Chrome will
   // still remember that "omnibox" had been granted, so that if the
   // extension once again includes "omnibox" in an upgrade, the extension
   // can upgrade without requiring this user's approval.
-  const Extension* old = GetExtensionByIdInternal(extension->id(),
-                                                  true, true, false);
+  const Extension* old = GetExtensionByIdInternal(extension->id(), true, true);
   bool is_extension_upgrade = old != NULL;
   bool is_privilege_increase = false;
 
   // We only need to compare the granted permissions to the current permissions
   // if the extension is not allowed to silently increase its permissions.
   if (!extension->CanSilentlyIncreasePermissions()) {
     // Add all the recognized permissions if the granted permissions list
     // hasn't been initialized yet.
     scoped_refptr<ExtensionPermissionSet> granted_permissions =
         extension_prefs_->GetGrantedPermissions(extension->id());
@@ skipping 93 matching lines @@
   } else {
     // We explicitly want to re-enable an uninstalled external
     // extension; if we're here, that means the user is manually
     // installing the extension.
     if (IsExternalExtensionUninstalled(id)) {
       initial_enable = true;
     }
   }
 
   // Do not record the install histograms for upgrades.
-  if (!GetExtensionByIdInternal(extension->id(), true, true, false)) {
+  if (!GetExtensionByIdInternal(extension->id(), true, true)) {
     UMA_HISTOGRAM_ENUMERATION("Extensions.InstallType",
                               extension->GetType(), 100);
     RecordPermissionMessagesHistogram(
         extension, "Extensions.Permissions_Install");
   }
 
   extension_prefs_->OnExtensionInstalled(
       extension,
       initial_enable ? Extension::ENABLED : Extension::DISABLED,
       from_webstore,
@@ skipping 22 matching lines @@
   // TODO(benwells): Remove before launching platform apps.
   if (extension->is_platform_app()) {
       StartInstallApplicationShortcut(extension);
   }
 
   // Transfer ownership of |extension| to AddExtension.
   AddExtension(scoped_extension);
 }
 
 const Extension* ExtensionService::GetExtensionByIdInternal(
-    const std::string& id, bool include_enabled, bool include_disabled,
-    bool include_terminated) const {
+    const std::string& id, bool include_enabled, bool include_disabled) const {
   std::string lowercase_id = StringToLowerASCII(id);
   if (include_enabled) {
     const Extension* extension = extensions_.GetByID(lowercase_id);
     if (extension)
       return extension;
   }
   if (include_disabled) {
     const Extension* extension = disabled_extensions_.GetByID(lowercase_id);
     if (extension)
       return extension;
   }
-  if (include_terminated) {
-    const Extension* extension = terminated_extensions_.GetByID(lowercase_id);
-    if (extension)
-      return extension;
-  }
   return NULL;
 }
 
-void ExtensionService::TrackTerminatedExtension(const Extension* extension) {
-  if (!terminated_extensions_.Contains(extension->id()))
-    terminated_extensions_.Insert(make_scoped_refptr(extension));
-
-  UnloadExtension(extension->id(), extension_misc::UNLOAD_REASON_TERMINATE);
-}
-
-void ExtensionService::UntrackTerminatedExtension(const std::string& id) {
-  std::string lowercase_id = StringToLowerASCII(id);
-  terminated_extensions_.Remove(lowercase_id);
-}
-
-const Extension* ExtensionService::GetTerminatedExtension(
-    const std::string& id) const {
-  return GetExtensionByIdInternal(id, false, false, true);
-}
-
 const Extension* ExtensionService::GetInstalledExtension(
     const std::string& id) const {
-  return GetExtensionByIdInternal(id, true, true, true);
+  return GetExtensionByIdInternal(id, true, true);
 }
 
 const Extension* ExtensionService::GetWebStoreApp() {
   return GetExtensionById(extension_misc::kWebStoreAppId, false);
 }
 
 bool ExtensionService::ExtensionBindingsAllowed(const GURL& url) {
   // Allow bindings for all packaged extensions and component hosted apps.
   const Extension* extension = extensions_.GetExtensionOrAppByURL(
       ExtensionURLInfo(url));
@@ skipping 94 matching lines @@
       host->render_view_host());
   content::DevToolsManager::GetInstance()->AttachClientHost(iter->second,
                                                             agent);
   orphaned_dev_tools_.erase(iter);
 }
 
 void ExtensionService::Observe(int type,
                                const content::NotificationSource& source,
                                const content::NotificationDetails& details) {
   switch (type) {
-    case chrome::NOTIFICATION_EXTENSION_PROCESS_TERMINATED: {
-      if (profile_ !=
-          content::Source<Profile>(source).ptr()->GetOriginalProfile()) {
-        break;
-      }
-
-      ExtensionHost* host = content::Details<ExtensionHost>(details).ptr();
-
-      // Mark the extension as terminated and Unload it. We want it to
-      // be in a consistent state: either fully working or not loaded
-      // at all, but never half-crashed.  We do it in a PostTask so
-      // that other handlers of this notification will still have
-      // access to the Extension and ExtensionHost.
-      MessageLoop::current()->PostTask(
-          FROM_HERE,
-          base::Bind(
-              &ExtensionService::TrackTerminatedExtension,
-              AsWeakPtr(),
-              host->extension()));
-      break;
-    }
     case content::NOTIFICATION_RENDERER_PROCESS_CREATED: {
       content::RenderProcessHost* process =
           content::Source<content::RenderProcessHost>(source).ptr();
       Profile* host_profile =
           Profile::FromBrowserContext(process->GetBrowserContext());
       if (!profile_->IsSameProfile(host_profile->GetOriginalProfile()))
           break;
 
       // Valid extension function names, used to setup bindings in renderer.
       std::vector<std::string> function_names;
@@ skipping 239 matching lines @@
   //
   // To coexist with certain unit tests that don't have an IO thread message
   // loop available at ExtensionService shutdown, we lazy-initialize this
   // object so that those cases neither create nor destroy a SocketController.
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   if (!socket_controller_) {
     socket_controller_ = new extensions::SocketController();
   }
   return socket_controller_;
 }