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/profiles/profile.h"
 #include "chrome/browser/ui/browser.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 22 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);
 
+  info->SetBoolean(keys::kMayDisableKey,

[Pam (message me for reviews), 2012/05/22 12:51:07]

It's part of the ExtensionInfo returned by the API. It was originally set here,
then it moved into Extension::GetBasicInfo(), and now it has to move back out
since an
extension doesn't know about ManagementPolicy.

[Aaron Boodman, 2012/05/22 15:56:11]

No what I meant was: is there a client that needs to know whether an extension
may be disabled?

Also, as to wrapping, I meant that wrapping at the arrow (either before or
after) looks strange to me, and I'd prefer wrapping at the open paren or storing
a pointer if possible.

That said, looking at this code, you use this pattern everywhere, and the lesser
of two evils is probably to just do it all on one virtual line, wrapped *after*
the arrow (sorry).

[Pam (message me for reviews), 2012/05/23 15:00:58]

Sorry, I could have been clearer. It's a documented field in the ExtensionInfo
object returned by the public chrome.management.get() extension API.
In some places there wasn't a good open paren to wrap at (wrapping between empty
() looks ludicrous to me), but I'll change them to store pointers.

+    ExtensionSystem::Get(service->profile())->management_policy()
+        ->UserMayModifyStatus(&extension, NULL));
+
   info->SetBoolean(keys::kIsAppKey, extension.is_app());
 
   if (!enabled) {
     bool permissions_escalated = service->extension_prefs()->
         DidExtensionEscalatePermissions(extension.id());
     const char* reason = permissions_escalated ?
         keys::kDisabledReasonPermissionsIncrease : keys::kDisabledReasonUnknown;
     info->SetString(keys::kDisabledReasonKey, reason);
   }
 
@@ skipping 287 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())) {
+  if (!ExtensionSystem::Get(profile())->management_policy()
+      ->UserMayModifyStatus(extension, NULL)) {
     error_ = ExtensionErrorUtils::FormatErrorMessage(
-        keys::kUserCantDisableError, extension_id_);
+        keys::kUserCantModifyError, extension_id_);

[Pam (message me for reviews), 2012/05/22 12:51:07]

Excellent, I'd love to consolidate them.

     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 32 matching lines @@
 bool UninstallFunction::RunImpl() {
   std::string extension_id;
   EXTENSION_FUNCTION_VALIDATE(args_->GetString(0, &extension_id));
 
   if (!service()->GetExtensionById(extension_id, true)) {
     error_ = ExtensionErrorUtils::FormatErrorMessage(
         keys::kNoExtensionError, extension_id);
     return false;
   }
 
-  ExtensionPrefs* prefs = service()->extension_prefs();
-
-  if (!Extension::UserMayDisable(
-      prefs->GetInstalledExtensionInfo(extension_id)->extension_location)) {
+  const Extension* extension = service()->GetExtensionById(extension_id, true);
+  if (!ExtensionSystem::Get(profile())->management_policy()
+      ->UserMayModifyStatus(extension, NULL)) {
     error_ = ExtensionErrorUtils::FormatErrorMessage(
-        keys::kUserCantDisableError, extension_id);
+        keys::kUserCantModifyError, extension_id);
     return false;
   }
 
   service()->UninstallExtension(extension_id, false /* external_uninstall */,
                                 NULL);
   return true;
 }
 
 ExtensionManagementEventRouter::ExtensionManagementEventRouter(Profile* profile)
     : profile_(profile) {}
@@ skipping 59 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());
 }