Add a preference for why an extension is disabled.

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 703 matching lines @@
           DevToolsAgentHostRegistry::GetDevToolsAgentHost(
               host->render_view_host());
       int devtools_cookie =
           content::DevToolsManager::GetInstance()->DetachClientHost(agent);
       if (devtools_cookie >= 0)
         orphaned_dev_tools_[extension_id] = devtools_cookie;
     }
 
     path = current_extension->path();
     DisableExtension(extension_id);
+    extension_prefs_->SetDisableReason(extension_id,
+                                       ExtensionPrefs::DISABLE_RELOAD);
     disabled_extension_paths_[extension_id] = path;
   } else {
     path = unloaded_extension_paths_[extension_id];
   }
 
   // If we're reloading a component extension, use the component extension
   // loader's reloader.
   if (component_loader_->Exists(extension_id)) {
     component_loader_->Reload(extension_id);
     return;
@@ skipping 157 matching lines @@
   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);
+  extension_prefs_->SetDisableReason(extension_id,
+                                     ExtensionPrefs::DISABLE_UNKNOWN);
 
   const Extension* extension =
       GetExtensionByIdInternal(extension_id, false, true, false);
   // 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));
@@ skipping 14 matching lines @@
   if (!IsExtensionEnabled(extension_id))
     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_prefs_->SetDisableReason(extension_id,
+                                     ExtensionPrefs::DISABLE_USER_ACTION);

[Aaron Boodman, 2012/04/09 20:30:48]

I am not sure this is always a good assumption. Consider adding a disable_reason
param and checking the call sites.

[Yoyo Zhou, 2012/04/10 01:57:36]

No, it's probably not, since it's used in RELOAD for instance. =( I was afraid
I'd have to do this, as it's a lot of call sites (including tests).

I guess I will move the enum to Extension as well.

 
   extension = GetExtensionByIdInternal(extension_id, true, false, true);
   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
@@ skipping 1083 matching lines @@
     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) {
     disabled_extensions_.Insert(scoped_extension);
     SyncExtensionChangeIfNeeded(*extension);
+    content::NotificationService::current()->Notify(
+        chrome::NOTIFICATION_EXTENSION_UPDATE_DISABLED,
+        content::Source<Profile>(profile_),
+        content::Details<const Extension>(extension));
 
-    if (extension_prefs_->DidExtensionEscalatePermissions(extension->id())) {
-      content::NotificationService::current()->Notify(
-          chrome::NOTIFICATION_EXTENSION_UPDATE_DISABLED,
-          content::Source<Profile>(profile_),
-          content::Details<const Extension>(extension));
+    if (extension_prefs_->GetDisableReason(extension->id()) ==
+        ExtensionPrefs::DISABLE_PERMISSIONS_INCREASE) {
       extensions::AddExtensionDisabledError(this, extension);
     }
     // Although the extension is disabled, we technically did succeed in adding
     // it to the list of installed extensions.
     return true;
   }
 
   // All apps that are displayed in the launcher are ordered by their ordinals
   // so we must ensure they have valid ordinals.
   if (extension->ShouldDisplayInLauncher())
@@ skipping 54 matching lines @@
   // 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);
   bool is_extension_upgrade = old != NULL;
   bool is_privilege_increase = false;
+  bool previously_disabled = false;
+  ExtensionPrefs::DisableReason disable_reason =
+      extension_prefs_->GetDisableReason(extension->id());
 
   // 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());
     CHECK(granted_permissions.get());
 
@@ skipping 12 matching lines @@
     if (extension->location() != Extension::LOAD)
       CHECK(extension->version()->CompareTo(*(old->version())) >= 0);
 
     // Extensions get upgraded if the privileges are allowed to increase or
     // the privileges haven't increased.
     if (!is_privilege_increase) {
       SetBeingUpgraded(old, true);
       SetBeingUpgraded(extension, true);
     }
 
+    // If the extension was already disabled, suppress any alerts for becoming
+    // disabled on permissions increase.
+    previously_disabled = extension_prefs_->IsExtensionDisabled(old->id());
+    if (previously_disabled) {
+      ExtensionPrefs::DisableReason reason = extension_prefs_->GetDisableReason(
+          old->id());
+      if (reason == ExtensionPrefs::DISABLE_UNKNOWN) {
+        // Initialize the reason for legacy disabled extensions from whether the
+        // extension already exceeded granted permissions.
+        if (extension_prefs_->DidExtensionEscalatePermissions(old->id()))
+          disable_reason = ExtensionPrefs::DISABLE_PERMISSIONS_INCREASE;
+        else
+          disable_reason = ExtensionPrefs::DISABLE_USER_ACTION;
+      }
+    } else {
+      disable_reason = ExtensionPrefs::DISABLE_PERMISSIONS_INCREASE;
+    }
+
     // To upgrade an extension in place, unload the old one and
     // then load the new one.
     UnloadExtension(old->id(), extension_misc::UNLOAD_REASON_UPDATE);
     old = NULL;
   }
 
   // Extension has changed permissions significantly. Disable it. A
   // notification should be sent by the caller.
   if (is_privilege_increase) {
     if (!extension_prefs_->DidExtensionEscalatePermissions(extension->id())) {
       RecordPermissionMessagesHistogram(
           extension, "Extensions.Permissions_AutoDisable");
     }
     extension_prefs_->SetExtensionState(extension->id(), Extension::DISABLED);
     extension_prefs_->SetDidExtensionEscalatePermissions(extension, true);
+    extension_prefs_->SetDisableReason(extension->id(), disable_reason);
   }
 }
 
 void ExtensionService::UpdateActiveExtensionsInCrashReporter() {
   std::set<std::string> extension_ids;
   for (ExtensionSet::const_iterator iter = extensions_.begin();
        iter != extensions_.end(); ++iter) {
     const Extension* extension = *iter;
     if (!extension->is_theme() && extension->location() != Extension::COMPONENT)
       extension_ids.insert(extension->id());
@@ skipping 464 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 an
   // APIResourceController.
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   if (!api_resource_controller_) {
     api_resource_controller_ = new extensions::APIResourceController();
   }
   return api_resource_controller_;
 }