Enforce the 'requirements' field in manifests.

chrome/common/extensions/extension.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/common/extensions/extension.h"
 
 #include <ostream>
 
 #include "base/base64.h"
 #include "base/basictypes.h"
@@ skipping 247 matching lines @@
 
 const int Extension::kPageActionIconMaxSize = 19;
 const int Extension::kBrowserActionIconMaxSize = 19;
 
 const int Extension::kValidWebExtentSchemes =
     URLPattern::SCHEME_HTTP | URLPattern::SCHEME_HTTPS;
 
 const int Extension::kValidHostPermissionSchemes =
     UserScript::kValidUserScriptSchemes | URLPattern::SCHEME_CHROMEUI;
 
+Extension::Requirements::Requirements()
+    : webgl(false),
+      css3d(false),
+      npapi(false) {
+}
+
+Extension::Requirements::~Requirements() {}
+
 Extension::InputComponentInfo::InputComponentInfo()
     : type(INPUT_COMPONENT_TYPE_NONE),
       shortcut_alt(false),
       shortcut_ctrl(false),
       shortcut_shift(false) {
 }
 
 Extension::InputComponentInfo::~InputComponentInfo() {}
 
 Extension::TtsVoice::TtsVoice() {}
@@ skipping 975 matching lines @@
     string16* error) {
   if (!LoadDescription(error) ||
       !LoadHomepageURL(error) ||
       !LoadUpdateURL(error) ||
       !LoadIcons(error) ||
       !LoadCommands(error) ||
       !LoadPlugins(error) ||
       !LoadNaClModules(error) ||
       !LoadWebAccessibleResources(error) ||
       !LoadSandboxedPages(error) ||
-      !CheckRequirements(error) ||
+      !LoadRequirements(error) ||
       !LoadDefaultLocale(error) ||
       !LoadOfflineEnabled(error) ||
       !LoadOptionsPage(error) ||
       // LoadBackgroundScripts() must be called before LoadBackgroundPage().
       !LoadBackgroundScripts(error) ||
       !LoadBackgroundPage(api_permissions, error) ||
       !LoadBackgroundPersistent(api_permissions, error) ||
       !LoadBackgroundAllowJSAccess(api_permissions, error) ||
       !LoadWebIntentServices(error) ||
       !LoadOAuth2Info(error))
@@ skipping 343 matching lines @@
   } else {
     sandboxed_pages_content_security_policy_ =
         kDefaultSandboxedPageContentSecurityPolicy;
     CHECK(ContentSecurityPolicyIsSandboxed(
         sandboxed_pages_content_security_policy_, GetType()));
   }
 
   return true;
 }
 
+bool Extension::LoadRequirements(string16* error) {
+  // If the extension has plugins, then |requirements_.npapi| defaults to true.
+  if (plugins_.size() > 0)
+    requirements_.npapi = true;
+
+  if (!manifest_->HasKey(keys::kRequirements))
+    return true;
+
+  DictionaryValue* requirements_value = NULL;
+  if (!manifest_->GetDictionary(keys::kRequirements, &requirements_value)) {
+    *error = ASCIIToUTF16(errors::kInvalidRequirements);
+    return false;
+  }
+
+  for (DictionaryValue::key_iterator it = requirements_value->begin_keys();
+       it != requirements_value->end_keys(); ++it) {
+    DictionaryValue* requirement_value;
+    if (!requirements_value->GetDictionaryWithoutPathExpansion(
+        *it, &requirement_value)) {
+      *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
+          errors::kInvalidRequirement, *it);
+      return false;
+    }
+
+    if (*it == "plugins") {
+      for (DictionaryValue::key_iterator plugin_it =
+              requirement_value->begin_keys();
+           plugin_it != requirement_value->end_keys(); ++plugin_it) {
+        bool plugin_required = false;
+        if (!requirement_value->GetBoolean(*plugin_it, &plugin_required)) {
+          *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
+              errors::kInvalidRequirement, *it);
+          return false;
+        }
+        if (*plugin_it == "npapi") {
+          requirements_.npapi = plugin_required;
+        } else {
+          *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
+              errors::kInvalidRequirement, *it);
+          return false;
+        }
+      }
+    } else if (*it == "3D") {
+      ListValue* features = NULL;
+      if (!requirement_value->GetListWithoutPathExpansion("features",
+                                                          &features) ||
+          !features) {
+        *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
+            errors::kInvalidRequirement, *it);
+        return false;
+      }
+
+      for (base::ListValue::iterator feature_it = features->begin();
+           feature_it != features->end();
+           ++feature_it) {
+        std::string feature;
+        if ((*feature_it)->GetAsString(&feature)) {
+          if (feature == "webgl") {
+            requirements_.webgl = true;
+          } else if (feature == "css3d") {
+            requirements_.css3d = true;
+          } else {
+            *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
+                errors::kInvalidRequirement, *it);
+            return false;
+          }
+        }
+      }
+    } else {
+      *error = ASCIIToUTF16(errors::kInvalidRequirements);
+      return false;
+    }
+  }
+  return true;
+}
+
 bool Extension::LoadDefaultLocale(string16* error) {
   if (!manifest_->HasKey(keys::kDefaultLocale))
     return true;
   if (!manifest_->GetString(keys::kDefaultLocale, &default_locale_) ||
       !l10n_util::IsValidLocaleSyntax(default_locale_)) {
     *error = ASCIIToUTF16(errors::kInvalidDefaultLocale);
     return false;
   }
   return true;
 }
@@ skipping 2164 matching lines @@
   if (current_version.CompareTo(minimum_version) < 0) {
     *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
         errors::kChromeVersionTooLow,
         l10n_util::GetStringUTF8(IDS_PRODUCT_NAME),
         minimum_version_string);
     return false;
   }
   return true;
 }
 
-// These are not actually persisted (they're only used by the store), but
-// still validated.
-bool Extension::CheckRequirements(string16* error) const {
-  if (!manifest_->HasKey(keys::kRequirements))
-    return true;
-  DictionaryValue* requirements_value = NULL;
-  if (!manifest_->GetDictionary(keys::kRequirements, &requirements_value)) {
-    *error = ASCIIToUTF16(errors::kInvalidRequirements);
-    return false;
-  }
-
-  for (DictionaryValue::key_iterator it = requirements_value->begin_keys();
-       it != requirements_value->end_keys(); ++it) {
-    DictionaryValue* requirement_value;
-    if (!requirements_value->GetDictionaryWithoutPathExpansion(
-        *it, &requirement_value)) {
-      *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
-          errors::kInvalidRequirement, *it);
-      return false;
-    }
-  }
-  return true;
-}
-
 bool Extension::CheckPlatformAppFeatures(std::string* utf8_error) const {
   if (!is_platform_app())
     return true;
 
   if (!has_background_page()) {
     *utf8_error = errors::kBackgroundRequiredForPlatformApps;
     return false;
   }
 
   return true;
@@ skipping 60 matching lines @@
 
 UpdatedExtensionPermissionsInfo::UpdatedExtensionPermissionsInfo(
     const Extension* extension,
     const PermissionSet* permissions,
     Reason reason)
     : reason(reason),
       extension(extension),
       permissions(permissions) {}
 
 }   // namespace extensions