Add more management policy checking after extension installed

chrome/browser/extensions/extension_service.cc

Index: chrome/browser/extensions/extension_service.cc
diff --git a/chrome/browser/extensions/extension_service.cc b/chrome/browser/extensions/extension_service.cc
index 572812606be8ee8921c0cbc8297a0d67d55d5ee9..4fec391f79bec6a2bf0279bfca6382f6b9e36145 100644
--- a/chrome/browser/extensions/extension_service.cc
+++ b/chrome/browser/extensions/extension_service.cc
@@ -1567,7 +1567,8 @@ void ExtensionService::OnExtensionInstalled(
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   const std::string& id = extension->id();
-  bool initial_enable = ShouldEnableOnInstall(extension);
+  Extension::DisableReason disable_reason =
+      GetDisableReasonOnInstalled(extension);
   std::string install_parameter;
   const extensions::PendingExtensionInfo* pending_extension_info =
       pending_extension_manager()->GetById(id);
@@ -1600,21 +1601,19 @@ void ExtensionService::OnExtensionInstalled(
     // extension; if we're here, that means the user is manually
     // installing the extension.
     if (extension_prefs_->IsExternalExtensionUninstalled(id)) {
-      initial_enable = true;
+      disable_reason = Extension::DISABLE_NONE;
     }
   }
 
   // Unsupported requirements overrides the management policy.
   if (install_flags & extensions::kInstallFlagHasRequirementErrors) {
-    initial_enable = false;
-    extension_prefs_->AddDisableReason(
-        id, Extension::DISABLE_UNSUPPORTED_REQUIREMENT);
+    disable_reason = Extension::DISABLE_UNSUPPORTED_REQUIREMENT;
   // If the extension was disabled because of unsupported requirements but
   // now supports all requirements after an update and there are not other
   // disable reasons, enable it.
   } else if (extension_prefs_->GetDisableReasons(id) ==
       Extension::DISABLE_UNSUPPORTED_REQUIREMENT) {
-    initial_enable = true;
+    disable_reason = Extension::DISABLE_NONE;
     extension_prefs_->ClearDisableReasons(id);
   }
 
@@ -1650,8 +1649,12 @@ void ExtensionService::OnExtensionInstalled(
     }
   }
 
+  if (disable_reason != Extension::DISABLE_NONE)
+    extension_prefs_->AddDisableReason(id, disable_reason);
+
   const Extension::State initial_state =
-      initial_enable ? Extension::ENABLED : Extension::DISABLED;
+      disable_reason == Extension::DISABLE_NONE ? Extension::ENABLED
+                                                : Extension::DISABLED;
   if (ShouldDelayExtensionUpdate(
           id,
           !!(install_flags & extensions::kInstallFlagInstallImmediately))) {
@@ -2148,14 +2151,34 @@ void ExtensionService::Observe(int type,
   }
 }
 
-bool ExtensionService::ShouldEnableOnInstall(const Extension* extension) {
+Extension::DisableReason ExtensionService::GetDisableReasonOnInstalled(
+    const Extension* extension) {
+  Extension::DisableReason disable_reason;
+  // Extensions disabled by management policy should always be disabled, even
+  // if it's force-installed.
+  if (system_->management_policy()->MustRemainDisabled(
+          extension, &disable_reason, nullptr)) {
+    // A specified reason is required to disable the extension.
+    DCHECK(disable_reason != Extension::DISABLE_NONE);
+    return disable_reason;
+  }
+
   // Extensions installed by policy can't be disabled. So even if a previous
   // installation disabled the extension, make sure it is now enabled.
-  if (system_->management_policy()->MustRemainEnabled(extension, NULL))
-    return true;
+  if (system_->management_policy()->MustRemainEnabled(extension, nullptr))
+    return Extension::DISABLE_NONE;
 
-  if (extension_prefs_->IsExtensionDisabled(extension->id()))
-    return false;
+  // An already disabled extension should inherit the disable reasons and
+  // remain disabled.
+  if (extension_prefs_->IsExtensionDisabled(extension->id())) {
+    disable_reason = static_cast<Extension::DisableReason>(

[not at google - send to devlin, 2014/11/14 17:20:43]

Damn, ok, this static_cast<> isn't actually right. Sorry for not noticing that.
It's possible that you will get undefined results if there are multiple disable
reasons, trying to cast it to a single one. It looks like this function actually
needs to return a bitmask.

Annoyingly, it looks like that will also require adding an AddDisableReasons
method to ExtensionPrefs which takes a bitmask (the interface on ExtensionPrefs
is pretty odd really).

[binjin, 2014/11/14 18:21:58]

Done.

+        extension_prefs_->GetDisableReasons(extension->id()));
+    // If an extension was disabled without specified reason, presume it's
+    // disabled by user.
+    return disable_reason == Extension::DISABLE_NONE
+               ? Extension::DISABLE_USER_ACTION
+               : disable_reason;
+  }
 
   if (FeatureSwitch::prompt_for_external_extensions()->IsEnabled()) {
     // External extensions are initially disabled. We prompt the user before
@@ -2164,11 +2187,11 @@ bool ExtensionService::ShouldEnableOnInstall(const Extension* extension) {
     if (extension->GetType() != Manifest::TYPE_HOSTED_APP &&
         Manifest::IsExternalLocation(extension->location()) &&
         !extension_prefs_->IsExternalExtensionAcknowledged(extension->id())) {
-      return false;
+      return Extension::DISABLE_EXTERNAL_EXTENSION;
     }
   }
 
-  return true;
+  return Extension::DISABLE_NONE;
 }
 
 bool ExtensionService::ShouldDelayExtensionUpdate(