Enforce the 'requirements' field in manifests.

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/admin_policy.h"
@@ skipping 45 matching lines @@
 const char kPrefAppNotificationDisbaled[] = "app_notif_disabled";
 
 // Indicates whether the user has acknowledged various types of extensions.
 const char kPrefExternalAcknowledged[] = "ack_external";
 const char kPrefBlacklistAcknowledged[] = "ack_blacklist";
 const char kPrefOrphanAcknowledged[] = "ack_orphan";
 
 // Indicates whether to show an install warning when the user enables.
 const char kExtensionDidEscalatePermissions[] = "install_warning_on_enable";
 
+// Any errors that arose from unmet requirements.
+const char kUnsupportedRequirements[] = "unsupported_requirements";
+
 // Indicates whether the extension was updated while it was disabled.
 const char kPrefDisableReason[] = "disable_reason";
 
 // A preference that tracks browser action toolbar configuration. This is a list
 // object stored in the Preferences file. The extensions are stored by ID.
 const char kExtensionToolbar[] = "extensions.toolbar";
 
 // The key for a serialized Time value indicating the start of the day (from the
 // server's perspective) an extension last included a "ping" parameter during
 // its update check.
@@ skipping 356 matching lines @@
   const DictionaryValue* ext = GetExtensionPref(extension_id);
   const ListValue* out = NULL;
   if (!ext || !ext->GetList(pref_key, &out))
     return false;
   if (out_value)
     *out_value = out;
 
   return true;
 }
 
+bool ExtensionPrefs::ReadExtensionPrefStringList(
+    const std::string& extension_id, const std::string& pref_key,
+    std::vector<std::string>* out_value) const {
+  const ListValue* value_list = NULL;
+  if (!ReadExtensionPrefList(extension_id, kUnsupportedRequirements,
+                             &value_list))

[Aaron Boodman, 2012/08/06 20:36:07]

Needs curlies.

[eaugusti, 2012/08/17 23:25:01]

Done.

+    return false;
+
+  for (size_t i = 0; i < value_list->GetSize(); ++i) {
+    std::string value;
+    if (value_list->GetString(i, &value))
+      out_value->push_back(value);
+  }
+
+  return true;
+}
+
 bool ExtensionPrefs::ReadExtensionPrefString(
     const std::string& extension_id, const std::string& pref_key,
     std::string* out_value) const {
   const DictionaryValue* ext = GetExtensionPref(extension_id);
 
   if (!ext || !ext->GetString(pref_key, out_value))
     return false;
 
   return true;
 }
@@ skipping 165 matching lines @@
   UpdateExtensionPref(extension_id, kPrefAppNotificationClientId,
                       Value::CreateStringValue(oauth_client_id));
 }
 
 bool ExtensionPrefs::IsAppNotificationDisabled(
     const std::string& extension_id) const {
   return ReadExtensionPrefBoolean(extension_id, kPrefAppNotificationDisbaled);
 }
 
 void ExtensionPrefs::SetAppNotificationDisabled(
-   const std::string& extension_id, bool value) {
+    const std::string& extension_id, bool value) {
   DCHECK(Extension::IdIsValid(extension_id));
   UpdateExtensionPref(extension_id, kPrefAppNotificationDisbaled,
                       Value::CreateBooleanValue(value));
 }
 
 std::string ExtensionPrefs::GetDebugPolicyProviderName() const {
 #ifdef NDEBUG
   NOTREACHED();
   return std::string();
 #else
   return "admin policy black/white/forcelist, via the ExtensionPrefs";
 #endif
 }
 
 bool ExtensionPrefs::UserMayLoad(const Extension* extension,
                                  string16* error) const {
 

[Aaron Boodman, 2012/08/06 20:36:07]

stray edit

[eaugusti, 2012/08/17 23:25:01]

Done.

   const base::ListValue* blacklist =
       prefs_->GetList(prefs::kExtensionInstallDenyList);
   const base::ListValue* whitelist =
       prefs_->GetList(prefs::kExtensionInstallAllowList);
   return admin_policy::UserMayLoad(blacklist, whitelist, extension,
                                                error);
 }
 
 bool ExtensionPrefs::UserMayModifySettings(const Extension* extension,
                                            string16* error) const {
@@ skipping 15 matching lines @@
   return ReadExtensionPrefBoolean(extension_id,
                                   kExtensionDidEscalatePermissions);
 }
 
 void ExtensionPrefs::SetDidExtensionEscalatePermissions(
     const Extension* extension, bool did_escalate) {
   UpdateExtensionPref(extension->id(), kExtensionDidEscalatePermissions,
                       Value::CreateBooleanValue(did_escalate));
 }
 
+bool ExtensionPrefs::HasUnsupportedRequirements(
+    const std::string& extension_id) {
+  const ListValue* requirement_errors = NULL;
+  return ReadExtensionPrefList(extension_id,
+                               kUnsupportedRequirements,
+                               &requirement_errors);
+}
+
+void ExtensionPrefs::ClearUnsupportedRequirements(
+    const std::string& extension_id) {
+  UpdateExtensionPref(extension_id, kUnsupportedRequirements, NULL);
+}
+
+void ExtensionPrefs::SetUnsupportedRequirements(
+    const std::string& extension_id,
+    std::vector<std::string> requirement_errors) {
+  UpdateExtensionPrefList(extension_id,
+                          kUnsupportedRequirements,
+                          requirement_errors);
+}
+
+std::vector<std::string> ExtensionPrefs::GetUnsupportedRequirements(
+    const std::string& extension_id) {
+  std::vector<std::string> errors;
+  ReadExtensionPrefStringList(extension_id, kUnsupportedRequirements, &errors);
+  return errors;
+}
+
 Extension::DisableReason ExtensionPrefs::GetDisableReason(
     const std::string& extension_id) {
   int value = -1;
   if (ReadExtensionPrefInteger(extension_id, kPrefDisableReason, &value) &&
       value >= 0 && value < Extension::DISABLE_LAST) {
     return static_cast<Extension::DisableReason>(value);
   }
   return Extension::DISABLE_UNKNOWN;
 }
 
@@ skipping 136 matching lines @@
 void ExtensionPrefs::SetActiveBit(const std::string& extension_id,
                                   bool active) {
   UpdateExtensionPref(extension_id, kActiveBit,
                       Value::CreateBooleanValue(active));
 }
 
 void ExtensionPrefs::MigratePermissions(const ExtensionIdSet& extension_ids) {
   PermissionsInfo* info = PermissionsInfo::GetInstance();
   for (ExtensionIdSet::const_iterator ext_id =
        extension_ids.begin(); ext_id != extension_ids.end(); ++ext_id) {
 

[Aaron Boodman, 2012/08/06 20:36:07]

stray edit

[eaugusti, 2012/08/17 23:25:01]

Done.

     // An extension's granted permissions need to be migrated if the
     // full_access bit is present. This bit was always present in the previous
     // scheme and is never present now.
     bool full_access;
     const DictionaryValue* ext = GetExtensionPref(*ext_id);
     if (!ext || !ext->GetBoolean(kPrefOldGrantedFullAccess, &full_access))
       continue;
 
     // Remove the full access bit (empty list will get trimmed).
     UpdateExtensionPref(
@@ skipping 519 matching lines @@
     NOTREACHED() << "Invalid extension_id " << extension_id;
     return;
   }
   ScopedExtensionPrefUpdate update(prefs_, extension_id);
   if (data_value)
     update->Set(key, data_value);
   else
     update->Remove(key, NULL);
 }
 
+void ExtensionPrefs::UpdateExtensionPrefList(
+    const std::string& extension_id, const std::string& key,
+    const std::vector<std::string>& data_value) {
+  ListValue* data_list = new ListValue();
+  std::vector<std::string>::const_iterator it;
+  for (it = data_value.begin(); it != data_value.end(); ++it)
+    data_list->Append(Value::CreateStringValue(*it));
+  UpdateExtensionPref(extension_id, key, data_list);
+}
+
 void ExtensionPrefs::DeleteExtensionPrefs(const std::string& extension_id) {
   extension_pref_value_map_->UnregisterExtension(extension_id);
   content_settings_store_->UnregisterExtension(extension_id);
   DictionaryPrefUpdate update(prefs_, kExtensionsPref);
   DictionaryValue* dict = update.Get();
   dict->Remove(extension_id, NULL);
 }
 
 const DictionaryValue* ExtensionPrefs::GetExtensionPref(
     const std::string& extension_id) const {
@@ skipping 548 matching lines @@
                            0,  // default value
                            PrefService::UNSYNCABLE_PREF);
   prefs->RegisterInt64Pref(prefs::kNextExtensionsUpdateCheck,
                            0,  // default value
                            PrefService::UNSYNCABLE_PREF);
   prefs->RegisterListPref(prefs::kExtensionAllowedInstallSites,
                           PrefService::UNSYNCABLE_PREF);
 }
 
 }  // namespace extensions