Move Requirements out of Extension Class

chrome/common/extensions/extension.cc

 // Copyright (c) 2013 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 "base/base64.h"
 #include "base/basictypes.h"
 #include "base/command_line.h"
 #include "base/file_util.h"
@@ skipping 202 matching lines @@
 const size_t Extension::kIdSize = 16;
 
 const char Extension::kMimeType[] = "application/x-chrome-extension";
 
 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
 //
 
 // static
 scoped_refptr<Extension> Extension::Create(const base::FilePath& path,
                                            Manifest::Location location,
                                            const DictionaryValue& value,
                                            int flags,
                                            std::string* utf8_error) {
@@ skipping 1475 matching lines @@
   }
 
   return true;
 }
 
 bool Extension::LoadSharedFeatures(string16* error) {
   if (!LoadDescription(error) ||
       !ManifestHandler::ParseExtension(this, error) ||
       !LoadNaClModules(error) ||
       !LoadSandboxedPages(error) ||
-      !LoadRequirements(error) ||
       !LoadOfflineEnabled(error))
     return false;
 
   return true;
 }
 
 bool Extension::LoadDescription(string16* error) {
   if (manifest_->HasKey(keys::kDescription) &&
       !manifest_->GetString(keys::kDescription, &description_)) {
     *error = ASCIIToUTF16(errors::kInvalidDescription);
@@ skipping 113 matching lines @@
   } else {
     sandboxed_pages_content_security_policy_ =
         kDefaultSandboxedPageContentSecurityPolicy;
     CHECK(ContentSecurityPolicyIsSandboxed(
         sandboxed_pages_content_security_policy_, GetType()));
   }
 
   return true;
 }
 
-bool Extension::LoadRequirements(string16* error) {
-  // Before parsing requirements from the manifest, automatically default the
-  // NPAPI plugin requirement based on whether it includes NPAPI plugins.
-  const ListValue* list_value = NULL;
-  requirements_.npapi =
-    manifest_->GetList(keys::kPlugins, &list_value) && !list_value->empty();
-
-  if (!manifest_->HasKey(keys::kRequirements))
-    return true;
-
-  const DictionaryValue* requirements_value = NULL;
-  if (!manifest_->GetDictionary(keys::kRequirements, &requirements_value)) {
-    *error = ASCIIToUTF16(errors::kInvalidRequirements);
-    return false;
-  }
-
-  for (DictionaryValue::Iterator it(*requirements_value); !it.IsAtEnd();
-       it.Advance()) {
-    const DictionaryValue* requirement_value;
-    if (!it.value().GetAsDictionary(&requirement_value)) {
-      *error = ErrorUtils::FormatErrorMessageUTF16(
-          errors::kInvalidRequirement, it.key());
-      return false;
-    }
-
-    if (it.key() == "plugins") {
-      for (DictionaryValue::Iterator plugin_it(*requirement_value);
-           !plugin_it.IsAtEnd(); plugin_it.Advance()) {
-        bool plugin_required = false;
-        if (!plugin_it.value().GetAsBoolean(&plugin_required)) {
-          *error = ErrorUtils::FormatErrorMessageUTF16(
-              errors::kInvalidRequirement, it.key());
-          return false;
-        }
-        if (plugin_it.key() == "npapi") {
-          requirements_.npapi = plugin_required;
-        } else {
-          *error = ErrorUtils::FormatErrorMessageUTF16(
-              errors::kInvalidRequirement, it.key());
-          return false;
-        }
-      }
-    } else if (it.key() == "3D") {
-      const ListValue* features = NULL;
-      if (!requirement_value->GetListWithoutPathExpansion("features",
-                                                          &features) ||
-          !features) {
-        *error = ErrorUtils::FormatErrorMessageUTF16(
-            errors::kInvalidRequirement, it.key());
-        return false;
-      }
-
-      for (base::ListValue::const_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 = ErrorUtils::FormatErrorMessageUTF16(
-                errors::kInvalidRequirement, it.key());
-            return false;
-          }
-        }
-      }
-    } else {
-      *error = ASCIIToUTF16(errors::kInvalidRequirements);
-      return false;
-    }
-  }
-  return true;
-}
-
 bool Extension::LoadOfflineEnabled(string16* error) {
   // Defaults to false, except for platform apps which are offline by default.
   if (!manifest_->HasKey(keys::kOfflineEnabled)) {
     offline_enabled_ = is_platform_app();
     return true;
   }
   if (!manifest_->GetBoolean(keys::kOfflineEnabled, &offline_enabled_)) {
     *error = ASCIIToUTF16(errors::kInvalidOfflineEnabled);
     return false;
   }
@@ skipping 505 matching lines @@
 
 UpdatedExtensionPermissionsInfo::UpdatedExtensionPermissionsInfo(
     const Extension* extension,
     const PermissionSet* permissions,
     Reason reason)
     : reason(reason),
       extension(extension),
       permissions(permissions) {}
 
 }   // namespace extensions