Delay determination of why a synced disabled extension was 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 1528 matching lines @@
 
   // Extension from sync was uninstalled by the user as external extensions.
   // Honor user choice and skip installation/enabling.
   if (IsExternalExtensionUninstalled(id)) {
     LOG(WARNING) << "Extension with id " << id
                  << " from sync was uninstalled as external extension";
     return true;
   }
 
   // Set user settings.
+  // If the extension has been disabled from sync, it may not have
+  // been installed yet, so we don't know if the disable reason was a
+  // permissions increase.  That will be updated once InitializePermissions
+  // is called for it.
   if (extension_sync_data.enabled())
     EnableExtension(id);
   else
-    DisableExtension(id, Extension::DISABLE_USER_ACTION);
+    DisableExtension(id, Extension::DISABLE_UNKNOWN_FROM_SYNC);
 
   // We need to cache some version information here because setting the
   // incognito flag invalidates the |extension| pointer (it reloads the
   // extension).
   bool extension_installed = (extension != NULL);
   int result = extension ?
       extension->version()->CompareTo(extension_sync_data.version()) : 0;
   SetIsIncognitoEnabled(id, extension_sync_data.incognito_enabled());
   extension = NULL;  // No longer safe to use.
 
@@ skipping 526 matching lines @@
   MaybeWipeout(extension);
 
   if (extension_prefs_->IsExtensionDisabled(extension->id())) {
     disabled_extensions_.Insert(extension);
     SyncExtensionChangeIfNeeded(*extension);
     content::NotificationService::current()->Notify(
         chrome::NOTIFICATION_EXTENSION_UPDATE_DISABLED,
         content::Source<Profile>(profile_),
         content::Details<const Extension>(extension));
 
-    if (extension_prefs_->GetDisableReasons(extension->id()) &
+    // Show the extension disabled error if a permissions increase was the
+    // only reason it was disabled.
+    if (extension_prefs_->GetDisableReasons(extension->id()) ==
         Extension::DISABLE_PERMISSIONS_INCREASE) {
       extensions::AddExtensionDisabledError(this, extension);
     }
     return;
   }
 
   // All apps that are displayed in the launcher are ordered by their ordinals
   // so we must ensure they have valid ordinals.
   if (extension->RequiresSortOrdinal()) {
     extension_prefs_->extension_sorting()->EnsureValidOrdinals(
@@ skipping 119 matching lines @@
     // 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) {
-      int reasons = extension_prefs_->GetDisableReasons(old->id());
-      if (reasons == Extension::DISABLE_NONE) {
-        // Initialize the reason for legacy disabled extensions from whether the
-        // extension already exceeded granted permissions.
-        if (extension_prefs_->DidExtensionEscalatePermissions(old->id()))
-          disable_reasons = Extension::DISABLE_PERMISSIONS_INCREASE;
-        else
-          disable_reasons = Extension::DISABLE_USER_ACTION;
-      }
-    } else {
-      disable_reasons = Extension::DISABLE_PERMISSIONS_INCREASE;
+    // Legacy disabled extensions do not have a disable reason. Infer that if
+    // there was no permission increase, it was likely disabled by the user.
+    if (previously_disabled && disable_reasons == Extension::DISABLE_NONE &&
+        !extension_prefs_->DidExtensionEscalatePermissions(old->id())) {
+      disable_reasons |= Extension::DISABLE_USER_ACTION;
     }
+    // Extensions that came to us disabled from sync need a similar inference,
+    // except based on the new version's permissions.
+    if (previously_disabled &&
+        disable_reasons == Extension::DISABLE_UNKNOWN_FROM_SYNC) {
+      // Remove the DISABLE_UNKNOWN_FROM_SYNC reason.
+      extension_prefs_->ClearDisableReasons(extension->id());
+      if (!is_privilege_increase)
+        disable_reasons |= Extension::DISABLE_USER_ACTION;
+    }
+    disable_reasons &= ~Extension::DISABLE_UNKNOWN_FROM_SYNC;
 
     // 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) {
+    disable_reasons |= Extension::DISABLE_PERMISSIONS_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_->AddDisableReason(
         extension->id(),
         static_cast<Extension::DisableReason>(disable_reasons));
   }
@@ skipping 757 matching lines @@
         extension_id, kOnUpdateAvailableEvent);
   } else {
     // Delay installation if the extension is not idle.
     return !IsExtensionIdle(extension_id);
   }
 }
 
 void ExtensionService::OnBlacklistUpdated() {
   CheckManagementPolicy();
 }