[Extensions] Add a SimpleFeature::Validate function

chrome/common/extensions/api/common_extension_api_unittest.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 "extensions/common/extension_api.h"
 
 #include <stddef.h>
 
 #include <memory>
 #include <string>
@@ skipping 658 matching lines @@
     EXPECT_TRUE(feature->whitelist()->empty());
     EXPECT_TRUE(feature->extension_types()->empty());
 
     EXPECT_EQ(SimpleFeature::UNSPECIFIED_LOCATION, feature->location());
     EXPECT_TRUE(feature->platforms()->empty());
     EXPECT_EQ(0, feature->min_manifest_version());
     EXPECT_EQ(0, feature->max_manifest_version());
   }
 }
 
-TEST(ExtensionAPITest, FeaturesRequireContexts) {
-  // TODO(cduvall): Make this check API featues.
-  std::unique_ptr<base::DictionaryValue> api_features1(
+TEST(ExtensionAPITest, JSONFeatureProviderDoesNotStoreInvalidFeatures) {
+  base::DictionaryValue features;
+  std::unique_ptr<base::DictionaryValue> feature_value(
       new base::DictionaryValue());
-  std::unique_ptr<base::DictionaryValue> api_features2(
-      new base::DictionaryValue());
-  base::DictionaryValue* test1 = new base::DictionaryValue();
-  base::DictionaryValue* test2 = new base::DictionaryValue();
-  base::ListValue* contexts = new base::ListValue();
-  contexts->AppendString("content_script");
-  test1->Set("contexts", contexts);
-  test1->SetString("channel", "stable");
-  test2->SetString("channel", "stable");
-  api_features1->Set("test", test1);
-  api_features2->Set("test", test2);
-
-  struct {
-    base::DictionaryValue* api_features;
-    bool expect_success;
-  } test_data[] = {
-    { api_features1.get(), true },
-    { api_features2.get(), false }
-  };
-
-  for (size_t i = 0; i < arraysize(test_data); ++i) {
-    JSONFeatureProvider api_feature_provider(*test_data[i].api_features,
-                                             CreateAPIFeature);
-    Feature* feature = api_feature_provider.GetFeature("test");
-    EXPECT_EQ(test_data[i].expect_success, feature != NULL) << i;
-  }
+  // This feature is invalid (it needs an extension context), so the
+  // JSONFeatureProvider should not store it.
+  feature_value->SetString("channel", "stable");
+  features.Set("test", std::move(feature_value));
+  JSONFeatureProvider api_feature_provider(features, CreateAPIFeature);
+  EXPECT_FALSE(api_feature_provider.GetFeature("test"));
 }
 
 static void GetDictionaryFromList(const base::DictionaryValue* schema,
                                   const std::string& list_name,
                                   const int list_index,
                                   const base::DictionaryValue** out) {
   const base::ListValue* list;
   EXPECT_TRUE(schema->GetList(list_name, &list));
   EXPECT_TRUE(list->GetDictionary(list_index, out));
 }
@@ skipping 136 matching lines @@
                                          extension.get(),
                                          Feature::BLESSED_EXTENSION_CONTEXT,
                                          GURL()).is_available());
   EXPECT_FALSE(extension_api->IsAvailable("pageAction",
                                           extension.get(),
                                           Feature::BLESSED_EXTENSION_CONTEXT,
                                           GURL()).is_available());
 }
 
 }  // namespace extensions