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

chrome/browser/extensions/extension_prefs.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_prefs.h"
 
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/extensions/api/alarms/alarm_manager.h"
 #include "chrome/browser/extensions/api/omnibox/omnibox_api.h"
 #include "chrome/browser/extensions/extension_pref_store.h"
 #include "chrome/browser/extensions/extension_sorting.h"
 #include "chrome/browser/prefs/pref_notifier.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/prefs/scoped_user_pref_update.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/extensions/extension_switch_utils.h"
 #include "chrome/common/extensions/manifest.h"
 #include "chrome/common/extensions/url_pattern.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
 #include "content/public/browser/notification_service.h"
+#include "grit/generated_resources.h"
+#include "ui/base/l10n/l10n_util.h"
 
 using extensions::Extension;
 using extensions::ExtensionInfo;
 
 namespace {
 
 // Additional preferences keys
 
 // Where an extension was installed from. (see Extension::Location)
 const char kPrefLocation[] = "location";
@@ skipping 527 matching lines @@
     ListValue* scope_values = new ListValue();
     for (ExtensionOAuth2Scopes::iterator i = scopes.begin();
          i != scopes.end(); ++i) {
       scope_values->Append(Value::CreateStringValue(*i));
     }
     std::string scope_pref = JoinPrefs(pref_key, kPrefScopes);
     UpdateExtensionPref(extension_id, scope_pref, scope_values);
   }
 }
 
+bool ExtensionPrefs::ManagementPolicyImpl(const Extension* extension,
+                                          string16* error,
+                                          bool modifiable_value) const {
+  // An extension that is required (by admin policy, for example) cannot be
+  // modified.
+  bool modifiable = !Extension::IsRequired(extension->location());
+  // Some callers equate "no restriction" to true, others to false.
+  if (modifiable)
+    return modifiable_value;
+
+  if (error) {
+    *error = l10n_util::GetStringFUTF16(
+        IDS_EXTENSION_CANT_MODIFY_POLICY_REQUIRED,
+        UTF8ToUTF16(extension->name()));
+  }
+  return !modifiable_value;
+}
+
 // static
 bool ExtensionPrefs::IsBlacklistBitSet(DictionaryValue* ext) {
   return ReadBooleanFromPref(ext, kPrefBlacklist);
 }
 
 bool ExtensionPrefs::IsExtensionBlacklisted(const std::string& extension_id) {
   return ReadExtensionPrefBoolean(extension_id, kPrefBlacklist);
 }
 
 bool ExtensionPrefs::IsExtensionOrphaned(const std::string& extension_id) {
@@ skipping 71 matching lines @@
   return ReadExtensionPrefBoolean(extension_id, kPrefAppNotificationDisbaled);
 }
 
 void ExtensionPrefs::SetAppNotificationDisabled(
    const std::string& extension_id, bool value) {
   DCHECK(Extension::IdIsValid(extension_id));
   UpdateExtensionPref(extension_id, kPrefAppNotificationDisbaled,
                       Value::CreateBooleanValue(value));
 }
 
-bool ExtensionPrefs::IsExtensionAllowedByPolicy(
-    const std::string& extension_id,
-    Extension::Location location) const {
-  base::StringValue id_value(extension_id);
+std::string ExtensionPrefs::GetPolicyProviderName() const {
+  return "admin policy black/whitelist, via the ExtensionPrefs";
+}
 
-  if (location == Extension::COMPONENT ||
-      location == Extension::EXTERNAL_POLICY_DOWNLOAD) {
+bool ExtensionPrefs::UserMayLoad(const extensions::Extension* extension,
+                                 string16* error) const {
+  base::StringValue id_value(extension->id());
+
+  if (extensions::Extension::IsRequired(extension->location()))
     return true;
-  }
 
   const base::ListValue* blacklist =
       prefs_->GetList(prefs::kExtensionInstallDenyList);
   if (!blacklist || blacklist->empty())
     return true;
 
   // Check the whitelist first.
   const base::ListValue* whitelist =
       prefs_->GetList(prefs::kExtensionInstallAllowList);
   if (whitelist && whitelist->Find(id_value) != whitelist->end())
     return true;
 
   // Then check the blacklist (the admin blacklist, not the Google blacklist).
-  return blacklist->Find(id_value) == blacklist->end() &&
-         !ExtensionsBlacklistedByDefault();
+  bool result = blacklist->Find(id_value) == blacklist->end() &&
+      !ExtensionsBlacklistedByDefault();
+  if (error && !result) {
+    *error = l10n_util::GetStringFUTF16(
+          IDS_EXTENSION_CANT_INSTALL_POLICY_BLACKLIST,
+          UTF8ToUTF16(extension->name()),
+          UTF8ToUTF16(extension->id()));
+  }
+  return result;
+}
+
+bool ExtensionPrefs::UserMayModifySettings(const Extension* extension,
+                                           string16* error) const {
+  return ManagementPolicyImpl(extension, error, true);
+}
+
+bool ExtensionPrefs::MustRemainEnabled(const Extension* extension,
+                                       string16* error) const {
+  return ManagementPolicyImpl(extension, error, false);
 }
 
 bool ExtensionPrefs::ExtensionsBlacklistedByDefault() const {
   const base::ListValue* blacklist =
       prefs_->GetList(prefs::kExtensionInstallDenyList);
   base::StringValue wildcard("*");
   return blacklist && blacklist->Find(wildcard) != blacklist->end();
 }
 
 bool ExtensionPrefs::DidExtensionEscalatePermissions(
@@ skipping 1216 matching lines @@
   prefs->RegisterStringPref(prefs::kExtensionBlacklistUpdateVersion,
                             "0",  // default value
                             PrefService::UNSYNCABLE_PREF);
   prefs->RegisterInt64Pref(prefs::kLastExtensionsUpdateCheck,
                            0,  // default value
                            PrefService::UNSYNCABLE_PREF);
   prefs->RegisterInt64Pref(prefs::kNextExtensionsUpdateCheck,
                            0,  // default value
                            PrefService::UNSYNCABLE_PREF);
 }