Add management policy function allowing extensions to be disabled.

chrome/browser/extensions/extension_service.cc

 // Copyright (c) 2013 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 <iterator>
 #include <set>
 
@@ skipping 101 matching lines @@
 #endif
 
 using content::BrowserContext;
 using content::BrowserThread;
 using content::DevToolsAgentHost;
 using extensions::CrxInstaller;
 using extensions::Extension;
 using extensions::ExtensionIdSet;
 using extensions::ExtensionInfo;
 using extensions::FeatureSwitch;
+using extensions::ManagementPolicy;
 using extensions::Manifest;
 using extensions::PermissionMessage;
 using extensions::PermissionMessages;
 using extensions::PermissionSet;
 using extensions::SharedModuleInfo;
 using extensions::UnloadedExtensionInfo;
 
 namespace errors = extensions::manifest_errors;
 
 namespace {
@@ skipping 752 matching lines @@
     const std::string& extension_id) const {
   return IsExtensionEnabled(extension_id) &&
       !GetTerminatedExtension(extension_id);
 }
 
 void ExtensionService::EnableExtension(const std::string& extension_id) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (IsExtensionEnabled(extension_id))
     return;
+  const Extension* extension = disabled_extensions_.GetByID(extension_id);
+
+  ManagementPolicy* policy = system_->management_policy();
+  if (extension && policy->MustRemainDisabled(extension, NULL, NULL))

[miket_OOO, 2013/11/04 23:18:10]

I can't tell for sure whether this is always called at profile load time, but if
not, any chance you want an UMA metric to see whether anyone's repeatedly trying
to enable this in a surprising fashion?

[asargent_no_longer_on_chrome, 2013/11/05 00:20:44]

The InstalledLoader should catch cases during init, but this function can be
called from all kinds of places, and it would be interesting if we hit this case
very often, so a histogram is a good idea. 

done

+    return;
 
   extension_prefs_->SetExtensionState(extension_id, Extension::ENABLED);
   extension_prefs_->ClearDisableReasons(extension_id);
 
-  const Extension* extension = disabled_extensions_.GetByID(extension_id);
   // This can happen if sync enables an extension that is not
   // installed yet.
   if (!extension)
     return;
 
+

[miket_OOO, 2013/11/04 23:18:10]

WHA?!

[asargent_no_longer_on_chrome, 2013/11/05 00:20:44]

oops, fixed.

   if (IsUnacknowledgedExternalExtension(extension)) {
     UMA_HISTOGRAM_ENUMERATION("Extensions.ExternalExtensionEvent",
                               EXTERNAL_EXTENSION_REENABLED,
                               EXTERNAL_EXTENSION_BUCKET_BOUNDARY);
     if (extensions::ManifestURL::UpdatesFromGallery(extension)) {
       UMA_HISTOGRAM_ENUMERATION("Extensions.ExternalExtensionEventWebstore",
                                 EXTERNAL_EXTENSION_REENABLED,
                                 EXTERNAL_EXTENSION_BUCKET_BOUNDARY);
     } else {
       UMA_HISTOGRAM_ENUMERATION("Extensions.ExternalExtensionEventNonWebstore",
@@ skipping 284 matching lines @@
         BrowserThread::GetBlockingPool()->GetNamedSequenceToken(token),
         base::SequencedWorkerPool::SKIP_ON_SHUTDOWN);
   return file_task_runner_.get();
 }
 
 extensions::ExtensionUpdater* ExtensionService::updater() {
   return updater_.get();
 }
 
 void ExtensionService::CheckManagementPolicy() {
-  std::vector<std::string> to_be_removed;
+  std::vector<std::string> to_unload;
+  std::map<std::string, Extension::DisableReason> to_disable;
 
-  // Loop through extensions list, unload installed extensions.
+  // Loop through the extensions list, finding extensions we need to unload or
+  // disable.
   for (ExtensionSet::const_iterator iter = extensions_.begin();
        iter != extensions_.end(); ++iter) {
     const Extension* extension = (iter->get());
     if (!system_->management_policy()->UserMayLoad(extension, NULL))
-      to_be_removed.push_back(extension->id());
+      to_unload.push_back(extension->id());
+    Extension::DisableReason disable_reason = Extension::DISABLE_NONE;
+    if (!system_->management_policy()->MustRemainDisabled(
+            extension, &disable_reason, NULL))
+      to_disable[extension->id()] = disable_reason;

[miket_OOO, 2013/11/04 23:18:10]

Check logic.

[asargent_no_longer_on_chrome, 2013/11/05 00:20:44]

Good catch. The "!" was a typo.

Fixed.

   }
 
-  // UnloadExtension will change the extensions_ list. So, we should
-  // call it outside the iterator loop.
-  for (size_t i = 0; i < to_be_removed.size(); ++i)
-    UnloadExtension(to_be_removed[i], UnloadedExtensionInfo::REASON_DISABLE);
+  for (size_t i = 0; i < to_unload.size(); ++i)
+    UnloadExtension(to_unload[i], UnloadedExtensionInfo::REASON_DISABLE);
+
+  for (std::map<std::string, Extension::DisableReason>::const_iterator i =
+           to_disable.begin(); i != to_disable.end(); ++i)
+    DisableExtension(i->first, i->second);
 }
 
 void ExtensionService::CheckForUpdatesSoon() {
   if (updater()) {
     if (AreAllExternalProvidersReady()) {
       updater()->CheckSoon();
     } else {
       // Sync can start updating before all the external providers are ready
       // during startup. Start the update as soon as those providers are ready,
       // but not before.
@@ skipping 1531 matching lines @@
 }
 
 void ExtensionService::AddUpdateObserver(extensions::UpdateObserver* observer) {
   update_observers_.AddObserver(observer);
 }
 
 void ExtensionService::RemoveUpdateObserver(
     extensions::UpdateObserver* observer) {
   update_observers_.RemoveObserver(observer);
 }