Refactor the various ways to control what users can do to extensions.

chrome/browser/extensions/extension_management_api.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_management_api.h"
 
 #include <map>
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/json/json_writer.h"
 #include "base/metrics/histogram.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "chrome/browser/extensions/extension_event_names.h"
 #include "chrome/browser/extensions/extension_event_router.h"
 #include "chrome/browser/extensions/extension_management_api_constants.h"
 #include "chrome/browser/extensions/extension_service.h"
+#include "chrome/browser/extensions/extension_system.h"
 #include "chrome/browser/extensions/extension_uninstall_dialog.h"
+#include "chrome/browser/extensions/management_policy.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/extensions/application_launch.h"
 #include "chrome/browser/ui/webui/extensions/extension_icon_source.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_utility_messages.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_constants.h"
 #include "chrome/common/extensions/extension_error_utils.h"
 #include "chrome/common/extensions/extension_icon_set.h"
 #include "chrome/common/extensions/url_pattern.h"
@@ skipping 34 matching lines @@
 ExtensionService* AsyncExtensionManagementFunction::service() {
   return profile()->GetExtensionService();
 }
 
 static DictionaryValue* CreateExtensionInfo(const Extension& extension,
                                             ExtensionService* service) {
   DictionaryValue* info = new DictionaryValue();
   bool enabled = service->IsExtensionEnabled(extension.id());
   extension.GetBasicInfo(enabled, info);
 
+  const extensions::ManagementPolicy* policy = ExtensionSystem::Get(
+      service->profile())->management_policy();
+  info->SetBoolean(keys::kMayDisableKey,
+                   policy->UserMayModifySettings(&extension, NULL));
+
   info->SetBoolean(keys::kIsAppKey, extension.is_app());
 
   if (!enabled) {
-    bool permissions_escalated = service->extension_prefs()->
-        DidExtensionEscalatePermissions(extension.id());
+    ExtensionPrefs* prefs = service->extension_prefs();
+    bool permissions_escalated =
+        prefs->DidExtensionEscalatePermissions(extension.id());
     const char* reason = permissions_escalated ?
         keys::kDisabledReasonPermissionsIncrease : keys::kDisabledReasonUnknown;
     info->SetString(keys::kDisabledReasonKey, reason);
   }
 
   if (!extension.update_url().is_empty())
     info->SetString(keys::kUpdateUrlKey,
                     extension.update_url().possibly_invalid_spec());
   if (extension.is_app())
     info->SetString(keys::kAppLaunchUrlKey,
@@ skipping 86 matching lines @@
   return true;
 }
 
 bool GetPermissionWarningsByIdFunction::RunImpl() {
   std::string ext_id;
   EXTENSION_FUNCTION_VALIDATE(args_->GetString(0, &ext_id));
 
   const Extension* extension = service()->GetExtensionById(ext_id, true);
   if (!extension) {
     error_ = ExtensionErrorUtils::FormatErrorMessage(keys::kNoExtensionError,
-                                                       ext_id);
+                                                     ext_id);
     return false;
   }
 
   ExtensionPermissionMessages warnings = extension->GetPermissionMessages();
   ListValue* result = new ListValue();
   for (ExtensionPermissionMessages::const_iterator i = warnings.begin();
        i < warnings.end(); ++i)
     result->Append(Value::CreateStringValue(i->message()));
   result_.reset(result);
   return true;
 }
 
 namespace {
 
 // This class helps GetPermissionWarningsByManifestFunction manage
 // sending manifest JSON strings to the utility process for parsing.
 class SafeManifestJSONParser : public UtilityProcessHostClient {
  public:
   SafeManifestJSONParser(GetPermissionWarningsByManifestFunction* client,
-                 const std::string& manifest)
+                         const std::string& manifest)
       : client_(client),
         manifest_(manifest) {}
 
   void Start() {
     CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
     BrowserThread::PostTask(
         BrowserThread::IO,
         FROM_HERE,
         base::Bind(&SafeManifestJSONParser::StartWorkOnIOThread, this));
   }
@@ skipping 157 matching lines @@
   EXTENSION_FUNCTION_VALIDATE(args_->GetString(0, &extension_id_));
   EXTENSION_FUNCTION_VALIDATE(args_->GetBoolean(1, &enable));
 
   const Extension* extension = service()->GetExtensionById(extension_id_, true);
   if (!extension) {
     error_ = ExtensionErrorUtils::FormatErrorMessage(
         keys::kNoExtensionError, extension_id_);
     return false;
   }
 
-  if (!Extension::UserMayDisable(extension->location())) {
+  const extensions::ManagementPolicy* policy = ExtensionSystem::Get(
+      profile())->management_policy();
+  if (!policy->UserMayModifySettings(extension, NULL)) {
     error_ = ExtensionErrorUtils::FormatErrorMessage(
-        keys::kUserCantDisableError, extension_id_);
+        keys::kUserCantModifyError, extension_id_);
     return false;
   }
 
   bool currently_enabled = service()->IsExtensionEnabled(extension_id_);
 
   if (!currently_enabled && enable) {
     ExtensionPrefs* prefs = service()->extension_prefs();
     if (prefs->DidExtensionEscalatePermissions(extension_id_)) {
       if (!user_gesture()) {
         error_ = keys::kGestureNeededForEscalationError;
@@ skipping 50 matching lines @@
     }
   }
 
   const Extension* extension = service()->GetExtensionById(extension_id_, true);
   if (!extension) {
     error_ = ExtensionErrorUtils::FormatErrorMessage(
         keys::kNoExtensionError, extension_id_);
     return false;
   }
 
-  ExtensionPrefs* prefs = service()->extension_prefs();
-
-  if (!Extension::UserMayDisable(
-      prefs->GetInstalledExtensionInfo(extension_id_)->extension_location)) {
+  if (!ExtensionSystem::Get(
+      profile())->management_policy()->UserMayModifySettings(extension, NULL)) {
     error_ = ExtensionErrorUtils::FormatErrorMessage(
-        keys::kUserCantDisableError, extension_id_);
+        keys::kUserCantModifyError, extension_id_);
     return false;
   }
 
   if (auto_confirm_for_test == DO_NOT_SKIP) {
     if (show_confirm_dialog) {
       AddRef(); // Balanced in ExtensionUninstallAccepted/Canceled
       extension_uninstall_dialog_.reset(ExtensionUninstallDialog::Create(
           profile_, this));
       extension_uninstall_dialog_->ConfirmUninstall(extension);
     } else {
@@ skipping 102 matching lines @@
     ExtensionService* service = profile->GetExtensionService();
     args.Append(CreateExtensionInfo(*extension, service));
   }
 
   std::string args_json;
   base::JSONWriter::Write(&args, &args_json);
 
   profile->GetExtensionEventRouter()->DispatchEventToRenderers(
       event_name, args_json, NULL, GURL());
 }