Unknown options in extension manifest file are silently ignored

chrome/common/extensions/manifest.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/manifest.h"
 
 #include "base/basictypes.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/string_split.h"
 #include "chrome/common/extensions/extension_constants.h"
 #include "chrome/common/extensions/extension_error_utils.h"
 #include "chrome/common/extensions/manifest_feature_provider.h"
 
 namespace errors = extension_manifest_errors;
 namespace keys = extension_manifest_keys;
 
 namespace extensions {
 
 Manifest::Manifest(Extension::Location location,
                    scoped_ptr<DictionaryValue> value)
     : location_(location), value_(value.Pass()) {
 }
 
 Manifest::~Manifest() {
 }
 
-bool Manifest::ValidateManifest(string16* error) const {
+bool Manifest::ValidateManifest(string16* error) {
   for (DictionaryValue::key_iterator key = value_->begin_keys();
        key != value_->end_keys(); ++key) {
     scoped_ptr<Feature> feature =
         ManifestFeatureProvider::GetDefaultInstance()->GetFeature(*key);
     if (!feature.get()) {
       // When validating the extension manifests, we ignore keys that are not
       // recognized for forward compatibility.
       // TODO(aa): Consider having an error here in the case of strict error
       // checking to let developers know when they screw up.
+      unrecognized_keys_.push_back(&(*key));
       continue;
     }
 
     Feature::Availability result = feature->IsAvailable(
         extension_id_, GetType(), Feature::ConvertLocation(location_),
         GetManifestVersion());
     if (result != Feature::IS_AVAILABLE) {
       *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
           errors::kFeatureNotAllowed,
           *key,
@@ skipping 37 matching lines @@
 bool Manifest::GetDictionary(
     const std::string& path, DictionaryValue** out_value) const {
   return CanAccessPath(path) && value_->GetDictionary(path, out_value);
 }
 
 bool Manifest::GetList(
     const std::string& path, ListValue** out_value) const {
   return CanAccessPath(path) && value_->GetList(path, out_value);
 }
 
+bool Manifest::HasUnrecognizedKeys(
+    const std::vector<const std::string*>** unrecognized_keys) const {
+  if (!unrecognized_keys_.empty()) {
+    *unrecognized_keys = &unrecognized_keys_;
+    return true;
+  }
+
+  return false;
+}
+
 Manifest* Manifest::DeepCopy() const {
   Manifest* manifest = new Manifest(
       location_, scoped_ptr<DictionaryValue>(value_->DeepCopy()));
   manifest->set_extension_id(extension_id_);
   return manifest;
 }
 
 bool Manifest::Equals(const Manifest* other) const {
   return other && value_->Equals(other->value());
 }
@@ skipping 49 matching lines @@
       ManifestFeatureProvider::GetDefaultInstance()->GetFeature(key);
   if (!feature.get())
     return false;
 
   return Feature::IS_AVAILABLE == feature->IsAvailable(
       extension_id_, GetType(), Feature::ConvertLocation(location_),
       GetManifestVersion());
 }
 
 }  // namespace extensions