[Extensions] Use compiled feature files

tools/json_schema_compiler/test/features_generation_unittest.cc

 // Copyright 2016 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/features/api_feature.h"
 #include "extensions/common/features/complex_feature.h"
 #include "extensions/common/features/feature.h"
 #include "extensions/common/features/simple_feature.h"
 #include "testing/gtest/include/gtest/gtest.h"
-#include "tools/json_schema_compiler/test/features_test.h"
+#include "tools/json_schema_compiler/test/features_compiler_test.h"
 
 namespace extensions {
 
 namespace {
 
 template <typename T>
 void ExpectVectorsEqual(std::vector<T> expected,
                         std::vector<T> actual,
                         const std::string& name) {
   std::sort(expected.begin(), expected.end());
@@ skipping 61 matching lines @@
             feature->component_extensions_auto_granted())
       << name;
   EXPECT_EQ(command_line_switch, feature->command_line_switch()) << name;
   ASSERT_EQ(channel.get() != nullptr, feature->has_channel()) << name;
   if (channel)
     EXPECT_EQ(*channel, feature->channel()) << name;
   EXPECT_EQ(internal, feature->IsInternal()) << name;
 }
 
 TEST(FeaturesGenerationTest, FeaturesTest) {
-  TestAPIFeatureProvider provider;
+  CompilerTestFeatureProvider provider;
 
   auto GetAPIFeature = [&provider](const std::string& name) {
     Feature* feature = provider.GetFeature(name);
     // Shame we can't test this more safely, but if our feature is declared as
     // the wrong class, things should blow up in a spectacular fashion.
     return static_cast<APIFeature*>(feature);
   };
 
   // Check some simple features for accuracy.
   {
@@ skipping 15 matching lines @@
     comparator.component_extensions_auto_granted = false;
     comparator.CompareFeature(feature);
   }
   {
     APIFeature* feature = GetAPIFeature("gamma");
     FeatureComparator comparator("gamma");
     comparator.channel.reset(
         new version_info::Channel(version_info::Channel::BETA));
     comparator.platforms = {Feature::WIN_PLATFORM, Feature::MACOSX_PLATFORM};
     comparator.contexts = {Feature::BLESSED_EXTENSION_CONTEXT};
+    comparator.dependencies = {"permission:gamma"};
     comparator.extension_types = {Manifest::TYPE_EXTENSION};
     comparator.internal = true;
     comparator.CompareFeature(feature);
 
     // A child feature should inherit all fields from its parent, except in the
     // case that it specifies its own value. Thus, we reuse |comparator|.
     feature = GetAPIFeature("gamma.child");
     comparator.name = "gamma.child";
-    comparator.dependencies = {"permission:gamma.child"};
     comparator.whitelist = {"ccc"};
     comparator.platforms = {Feature::LINUX_PLATFORM};
+    comparator.dependencies.clear();
     comparator.CompareFeature(feature);
   }
   {
     // Features that specify 'noparent' should not inherit features from any
     // other feature.
     APIFeature* feature = GetAPIFeature("gamma.unparented");
     FeatureComparator comparator("gamma.unparented");
     comparator.blacklist = {"ddd"};
     comparator.contexts = {Feature::UNBLESSED_EXTENSION_CONTEXT};
     comparator.CompareFeature(feature);
   }
   {
+    ComplexFeature* complex_feature = static_cast<ComplexFeature*>(
+        provider.GetFeature("gamma.complex_unparented"));
+    FeatureComparator comparator("gamma.complex_unparented");
+    comparator.contexts = {Feature::UNBLESSED_EXTENSION_CONTEXT};
+    comparator.channel.reset(
+        new version_info::Channel(version_info::Channel::STABLE));
+    // We cheat and have both children exactly the same for ease of comparing;
+    // complex features are tested more thoroughly below.
+    for (const auto& feature : complex_feature->features_)
+      comparator.CompareFeature(static_cast<SimpleFeature*>(feature.get()));
+  }
+  {
     APIFeature* feature = GetAPIFeature("delta");
     FeatureComparator comparator("delta");
     comparator.contexts = {Feature::BLESSED_EXTENSION_CONTEXT,
                            Feature::WEBUI_CONTEXT};
     comparator.matches.AddPattern(
         URLPattern(URLPattern::SCHEME_ALL, "*://example.com/*"));
     comparator.CompareFeature(feature);
   }
   {
     // Omega is imported from a second .json file.
@@ skipping 56 matching lines @@
           new version_info::Channel(version_info::Channel::BETA));
       comparator.contexts = {Feature::BLESSED_EXTENSION_CONTEXT};
       comparator.extension_types = {Manifest::TYPE_EXTENSION};
       comparator.whitelist = {"aaa"};
       comparator.CompareFeature(other_parent);
     }
   }
 }
 
 }  // namespace extensions