Re-land 125247: Better error messages when using unsupported manifest features.

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"
@@ skipping 10 matching lines @@
                    scoped_ptr<DictionaryValue> value)
     : location_(location), value_(value.Pass()) {
 }
 
 Manifest::~Manifest() {
 }
 
 bool Manifest::ValidateManifest(string16* error) const {
   for (DictionaryValue::key_iterator key = value_->begin_keys();
        key != value_->end_keys(); ++key) {
-    bool was_known = false;
-    if (!CanAccessKey(*key, &was_known)) {
+    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.
-      if (!was_known) {
-        // TODO(aa): Consider having an error here in the case of strict error
-        // checking to let developers know when they screw up.
-        continue;
-      }
+      // TODO(aa): Consider having an error here in the case of strict error
+      // checking to let developers know when they screw up.
+      continue;
+    }
 
+    Feature::Availability result = feature->IsAvailable(
+        extension_id_, GetType(), Feature::ConvertLocation(location_),
+        GetManifestVersion());
+    if (result != Feature::IS_AVAILABLE) {
       *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
-          errors::kFeatureNotAllowed, *key);
+          errors::kFeatureNotAllowed,
+          *key,
+          feature->GetErrorMessage(result));
       return false;
     }
   }
 
   return true;
 }
 
 bool Manifest::HasKey(const std::string& key) const {
-  return CanAccessKey(key, NULL) && value_->HasKey(key);
+  return CanAccessKey(key) && value_->HasKey(key);
 }
 
 bool Manifest::Get(
     const std::string& path, Value** out_value) const {
   return CanAccessPath(path) && value_->Get(path, out_value);
 }
 
 bool Manifest::GetBoolean(
     const std::string& path, bool* out_value) const {
   return CanAccessPath(path) && value_->GetBoolean(path, out_value);
@@ skipping 71 matching lines @@
   return GetType() == Extension::TYPE_PACKAGED_APP;
 }
 
 bool Manifest::IsHostedApp() const {
   return GetType() == Extension::TYPE_HOSTED_APP;
 }
 
 bool Manifest::CanAccessPath(const std::string& path) const {
   std::vector<std::string> components;
   base::SplitString(path, '.', &components);
-  return CanAccessKey(components[0], NULL);
+  return CanAccessKey(components[0]);
 }
 
-bool Manifest::CanAccessKey(const std::string& key, bool *was_known) const {
+bool Manifest::CanAccessKey(const std::string& key) const {
   scoped_ptr<Feature> feature =
       ManifestFeatureProvider::GetDefaultInstance()->GetFeature(key);
   if (!feature.get())
     return false;
 
-  if (was_known)
-    *was_known = true;
-
-  return feature->IsAvailable(extension_id_,
-                              GetType(),
-                              Feature::ConvertLocation(location_),
-                              GetManifestVersion());
+  return Feature::IS_AVAILABLE == feature->IsAvailable(
+      extension_id_, GetType(), Feature::ConvertLocation(location_),
+      GetManifestVersion());
 }
 
 }  // namespace extensions