Support API aliases

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_compiler_test.h"
@@ skipping 35 matching lines @@
   std::vector<Feature::Context> contexts;
   std::vector<Feature::Platform> platforms;
   URLPatternSet matches;
   SimpleFeature::Location location;
   int min_manifest_version;
   int max_manifest_version;
   bool component_extensions_auto_granted;
   std::string command_line_switch;
   std::unique_ptr<version_info::Channel> channel;
   bool internal;
+  std::string alias;
+  std::string source;
 };
 
 FeatureComparator::FeatureComparator(const std::string& name)
     : name(name),
       location(kDefaultLocation),
       min_manifest_version(kDefaultMinVersion),
       max_manifest_version(kDefaultMaxVersion),
       component_extensions_auto_granted(kDefaultAutoGrant),
       internal(kDefaultInternal) {}
 
@@ skipping 13 matching lines @@
   EXPECT_EQ(min_manifest_version, feature->min_manifest_version()) << name;
   EXPECT_EQ(max_manifest_version, feature->max_manifest_version()) << name;
   EXPECT_EQ(component_extensions_auto_granted,
             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;
+  EXPECT_EQ(alias, feature->alias()) << name;
+  EXPECT_EQ(source, feature->source()) << name;
 }
 
 TEST(FeaturesGenerationTest, FeaturesTest) {
   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);
@@ skipping 156 matching lines @@
       // Finally, check the branch of the complex feature.
       FeatureComparator comparator("complex");
       comparator.channel.reset(
           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);
     }
   }
+
+  // Test API aliases.
+  {
+    APIFeature* feature = GetAPIFeature("alias");
+    FeatureComparator comparator("alias");
+    comparator.contexts = {Feature::BLESSED_EXTENSION_CONTEXT};
+    comparator.channel.reset(
+        new version_info::Channel(version_info::Channel::STABLE));
+    comparator.source = "alias_source";
+    comparator.CompareFeature(feature);
+  }
+  {
+    APIFeature* feature = GetAPIFeature("alias_source");
+    FeatureComparator comparator("alias_source");
+    comparator.contexts = {Feature::BLESSED_EXTENSION_CONTEXT};
+    comparator.channel.reset(
+        new version_info::Channel(version_info::Channel::STABLE));
+    comparator.alias = "alias";
+    comparator.CompareFeature(feature);
+  }
+  {
+    Feature* feature = GetAPIFeature("complex_alias");
+    ASSERT_EQ("", feature->alias());
+    ASSERT_EQ("complex_alias_source", feature->source());
+  }
+  {
+    Feature* feature = GetAPIFeature("complex_alias_source");
+    ASSERT_EQ("complex_alias", feature->alias());
+    ASSERT_EQ("", feature->source());
+  }
+  {
+    Feature* feature = GetAPIFeature("parent_source");
+    ASSERT_EQ("parent_source_alias", feature->alias());
+    ASSERT_EQ("", feature->source());
+  }
+  {
+    Feature* feature = GetAPIFeature("parent_source.child");
+    ASSERT_EQ("parent_source_alias", feature->alias());
+    ASSERT_EQ("", feature->source());
+  }
+  {
+    Feature* feature = GetAPIFeature("parent_source.child_source");
+    ASSERT_EQ("parent_source_child_alias", feature->alias());
+    ASSERT_EQ("", feature->source());
+  }
+  {
+    Feature* feature = GetAPIFeature("alias_parent");
+    ASSERT_EQ("", feature->alias());
+    ASSERT_EQ("", feature->source());
+  }
+  {
+    Feature* feature = GetAPIFeature("alias_parent.child");
+    ASSERT_EQ("", feature->alias());
+    ASSERT_EQ("child_source", feature->source());
+  }
 }
 
 }  // namespace extensions