Support API aliases

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 21 matching lines @@
 
 namespace extensions {
 
 namespace {
 
 const char* const kTestFeatures[] = {
     "test1", "test2", "test3",   "test4",   "test5",
     "test6", "test7", "parent1", "parent2", "parent3",
 };
 
+const char* const kAliasTestApis[] = {"alias_api_source"};
+
 const char* const kSessionTypeTestFeatures[] = {
     "test1", "kiosk_only", "non_kiosk", "multiple_session_types"};
 
 struct FeatureSessionTypesTestData {
   std::string api_name;
   bool expect_available;
   FeatureSessionType current_session_type;
 };
 
 class TestExtensionAPI : public ExtensionAPI {
@@ skipping 33 matching lines @@
     ExtensionAPI* api;
     bool expect_populated;
   } test_data[] = {
     { shared_instance, true },
     { new_instance.get(), true },
     { &empty_instance, false }
   };
 
   for (size_t i = 0; i < arraysize(test_data); ++i) {
     EXPECT_EQ(test_data[i].expect_populated,
-              test_data[i].api->GetSchema("bookmarks.create") != NULL);
+              test_data[i].api->GetSchema("bookmarks.create") != nullptr);
   }
 }
 
 TEST(ExtensionAPITest, SplitDependencyName) {
   struct {
     std::string input;
     std::string expected_feature_type;
     std::string expected_feature_name;
   } test_data[] = {{"", "api", ""},  // assumes "api" when no type is present
                    {"foo", "api", "foo"},
@@ skipping 89 matching lines @@
   UnittestFeatureProvider api_feature_provider;
 
   for (size_t i = 0; i < arraysize(test_data); ++i) {
     TestExtensionAPI api;
     api.RegisterDependencyProvider("api", &api_feature_provider);
     for (const auto& key : kTestFeatures)
       api.add_fake_schema(key);
     ExtensionAPI::OverrideSharedInstanceForTest scope(&api);
 
     bool expected = test_data[i].expect_is_available;
-    Feature::Availability availability =
-        api.IsAvailable(test_data[i].api_full_name,
-                        NULL,
-                        test_data[i].context,
-                        test_data[i].url);
+    Feature::Availability availability = api.IsAvailable(
+        test_data[i].api_full_name, nullptr, test_data[i].context,
+        test_data[i].url, CheckAliasStatus::NOT_ALLOWED);
     EXPECT_EQ(expected, availability.is_available())
         << base::StringPrintf("Test %d: Feature '%s' was %s: %s",
                               static_cast<int>(i),
                               test_data[i].api_full_name.c_str(),
                               expected ? "not available" : "available",
                               availability.message().c_str());
   }
 }
 
+TEST(ExtensionAPITest, APIFeaturesAlias) {
+  UnittestFeatureProvider api_feature_provider;
+
+  TestExtensionAPI api;
+  api.RegisterDependencyProvider("api", &api_feature_provider);
+  for (const auto& key : kAliasTestApis)
+    api.add_fake_schema(key);
+  ExtensionAPI::OverrideSharedInstanceForTest scope(&api);
+
+  ASSERT_FALSE(api.IsAvailable("alias_api_source", nullptr,
+                               Feature::UNBLESSED_EXTENSION_CONTEXT, GURL(),
+                               CheckAliasStatus::NOT_ALLOWED)
+                   .is_available());
+  ASSERT_TRUE(api.IsAvailable("alias_api_source", nullptr,
+                              Feature::UNBLESSED_EXTENSION_CONTEXT, GURL(),
+                              CheckAliasStatus::ALLOWED)
+                  .is_available());
+  ASSERT_TRUE(api.IsAvailable("alias_api_source.bar", nullptr,
+                              Feature::UNBLESSED_EXTENSION_CONTEXT, GURL(),
+                              CheckAliasStatus::ALLOWED)
+                  .is_available());
+  ASSERT_FALSE(api.IsAvailable("alias_api_source.foo", nullptr,
+                               Feature::UNBLESSED_EXTENSION_CONTEXT, GURL(),
+                               CheckAliasStatus::ALLOWED)
+                   .is_available());
+
+  scoped_refptr<const Extension> extension =
+      ExtensionBuilder()
+          .SetManifest(DictionaryBuilder()
+                           .Set("name", "extension")
+                           .Set("version", "1")
+                           .Set("manifest_version", 2)
+                           .Build())
+          .Build();
+  Feature* test_feature = api_feature_provider.GetFeature("alias_api_source");
+  ASSERT_TRUE(test_feature);
+  ASSERT_FALSE(api.IsAnyFeatureAvailableToContext(
+      *test_feature, extension.get(), Feature::UNBLESSED_EXTENSION_CONTEXT,
+      GURL(), CheckAliasStatus::NOT_ALLOWED));
+  EXPECT_TRUE(api.IsAnyFeatureAvailableToContext(
+      *test_feature, extension.get(), Feature::UNBLESSED_EXTENSION_CONTEXT,
+      GURL(), CheckAliasStatus::ALLOWED));
+}
+
 TEST(ExtensionAPITest, IsAnyFeatureAvailableToContext) {
   scoped_refptr<const Extension> app =
       ExtensionBuilder()
           .SetManifest(
               DictionaryBuilder()
                   .Set("name", "app")
                   .Set("app",
                        DictionaryBuilder()
                            .Set("background",
                                 DictionaryBuilder()
@@ skipping 15 matching lines @@
                            .Build())
           .Build();
 
   struct {
     std::string api_full_name;
     bool expect_is_available;
     Feature::Context context;
     const Extension* extension;
     GURL url;
   } test_data[] = {
-    { "test1", false, Feature::WEB_PAGE_CONTEXT, NULL, GURL() },
-    { "test1", true, Feature::UNBLESSED_EXTENSION_CONTEXT, NULL, GURL() },
-    { "test1", false, Feature::UNBLESSED_EXTENSION_CONTEXT, app.get(), GURL() },
-    { "test1", true, Feature::UNBLESSED_EXTENSION_CONTEXT, extension.get(),
-        GURL() },
-    { "test2", true, Feature::CONTENT_SCRIPT_CONTEXT, NULL, GURL() },
-    { "test2", true, Feature::WEB_PAGE_CONTEXT, NULL,
-        GURL("http://google.com") },
-    { "test2.foo", false, Feature::WEB_PAGE_CONTEXT, NULL,
-        GURL("http://google.com") },
-    { "test3", true, Feature::CONTENT_SCRIPT_CONTEXT, NULL, GURL() },
-    { "test3", true, Feature::WEB_PAGE_CONTEXT, NULL, GURL("http://foo.com") },
-    { "test4.foo", true, Feature::CONTENT_SCRIPT_CONTEXT, NULL, GURL() },
-    { "test7", false, Feature::WEB_PAGE_CONTEXT, NULL,
-        GURL("http://google.com") },
-    { "test7", true, Feature::WEB_PAGE_CONTEXT, NULL, GURL("http://foo.com") },
-    { "test7", false, Feature::WEB_PAGE_CONTEXT, NULL, GURL("http://bar.com") }
-  };
+      {"test1", false, Feature::WEB_PAGE_CONTEXT, nullptr, GURL()},
+      {"test1", true, Feature::UNBLESSED_EXTENSION_CONTEXT, nullptr, GURL()},
+      {"test1", false, Feature::UNBLESSED_EXTENSION_CONTEXT, app.get(), GURL()},
+      {"test1", true, Feature::UNBLESSED_EXTENSION_CONTEXT, extension.get(),
+       GURL()},
+      {"test2", true, Feature::CONTENT_SCRIPT_CONTEXT, nullptr, GURL()},
+      {"test2", true, Feature::WEB_PAGE_CONTEXT, nullptr,
+       GURL("http://google.com")},
+      {"test2.foo", false, Feature::WEB_PAGE_CONTEXT, nullptr,
+       GURL("http://google.com")},
+      {"test3", true, Feature::CONTENT_SCRIPT_CONTEXT, nullptr, GURL()},
+      {"test3", true, Feature::WEB_PAGE_CONTEXT, nullptr,
+       GURL("http://foo.com")},
+      {"test4.foo", true, Feature::CONTENT_SCRIPT_CONTEXT, nullptr, GURL()},
+      {"test7", false, Feature::WEB_PAGE_CONTEXT, nullptr,
+       GURL("http://google.com")},
+      {"test7", true, Feature::WEB_PAGE_CONTEXT, nullptr,
+       GURL("http://foo.com")},
+      {"test7", false, Feature::WEB_PAGE_CONTEXT, nullptr,
+       GURL("http://bar.com")}};
 
   UnittestFeatureProvider api_feature_provider;
 
   for (size_t i = 0; i < arraysize(test_data); ++i) {
     TestExtensionAPI api;
     api.RegisterDependencyProvider("api", &api_feature_provider);
     for (const auto& key : kTestFeatures)
       api.add_fake_schema(key);
     ExtensionAPI::OverrideSharedInstanceForTest scope(&api);
 
     Feature* test_feature =
         api_feature_provider.GetFeature(test_data[i].api_full_name);
     ASSERT_TRUE(test_feature);
     EXPECT_EQ(test_data[i].expect_is_available,
-              api.IsAnyFeatureAvailableToContext(*test_feature,
-                                                 test_data[i].extension,
-                                                 test_data[i].context,
-                                                 test_data[i].url))
+              api.IsAnyFeatureAvailableToContext(
+                  *test_feature, test_data[i].extension, test_data[i].context,
+                  test_data[i].url, CheckAliasStatus::NOT_ALLOWED))
         << i;
   }
 }
 
 TEST(ExtensionAPITest, SessionTypeFeature) {
   const std::vector<FeatureSessionTypesTestData> kTestData(
       {{"kiosk_only", true, FeatureSessionType::KIOSK},
        {"kiosk_only", false, FeatureSessionType::REGULAR},
        {"kiosk_only", false, FeatureSessionType::UNKNOWN},
        {"non_kiosk", false, FeatureSessionType::KIOSK},
@@ skipping 12 matching lines @@
     TestExtensionAPI api;
     api.RegisterDependencyProvider("api", &api_feature_provider);
     for (const auto& key : kSessionTypeTestFeatures)
       api.add_fake_schema(key);
     ExtensionAPI::OverrideSharedInstanceForTest scope(&api);
 
     std::unique_ptr<base::AutoReset<FeatureSessionType>> current_session(
         ScopedCurrentFeatureSessionType(test.current_session_type));
     EXPECT_EQ(test.expect_available,
               api.IsAvailable(test.api_name, nullptr,
-                              Feature::BLESSED_EXTENSION_CONTEXT, GURL())
+                              Feature::BLESSED_EXTENSION_CONTEXT, GURL(),
+                              CheckAliasStatus::NOT_ALLOWED)
                   .is_available())
         << "Test case (" << test.api_name << ", "
         << static_cast<int>(test.current_session_type) << ").";
   }
 }
 
 TEST(ExtensionAPITest, LazyGetSchema) {
   std::unique_ptr<ExtensionAPI> apis(
       ExtensionAPI::CreateWithDefaultConfiguration());
 
-  EXPECT_EQ(NULL, apis->GetSchema(std::string()));
-  EXPECT_EQ(NULL, apis->GetSchema(std::string()));
-  EXPECT_EQ(NULL, apis->GetSchema("experimental"));
-  EXPECT_EQ(NULL, apis->GetSchema("experimental"));
-  EXPECT_EQ(NULL, apis->GetSchema("foo"));
-  EXPECT_EQ(NULL, apis->GetSchema("foo"));
+  EXPECT_EQ(nullptr, apis->GetSchema(std::string()));
+  EXPECT_EQ(nullptr, apis->GetSchema(std::string()));
+  EXPECT_EQ(nullptr, apis->GetSchema("experimental"));
+  EXPECT_EQ(nullptr, apis->GetSchema("experimental"));
+  EXPECT_EQ(nullptr, apis->GetSchema("foo"));
+  EXPECT_EQ(nullptr, apis->GetSchema("foo"));
 
   EXPECT_TRUE(apis->GetSchema("dns"));
   EXPECT_TRUE(apis->GetSchema("dns"));
   EXPECT_TRUE(apis->GetSchema("extension"));
   EXPECT_TRUE(apis->GetSchema("extension"));
   EXPECT_TRUE(apis->GetSchema("omnibox"));
   EXPECT_TRUE(apis->GetSchema("omnibox"));
   EXPECT_TRUE(apis->GetSchema("storage"));
   EXPECT_TRUE(apis->GetSchema("storage"));
 }
@@ skipping 39 matching lines @@
     extension = CreateExtensionWithPermissions(permissions);
   }
 
   std::unique_ptr<ExtensionAPI> extension_api(
       ExtensionAPI::CreateWithDefaultConfiguration());
 
   const FeatureProvider& api_features = *FeatureProvider::GetAPIFeatures();
 
   // "storage" is completely unprivileged.
   EXPECT_TRUE(extension_api->IsAnyFeatureAvailableToContext(
-      *api_features.GetFeature("storage"),
-      NULL,
-      Feature::BLESSED_EXTENSION_CONTEXT,
-      GURL()));
+      *api_features.GetFeature("storage"), nullptr,
+      Feature::BLESSED_EXTENSION_CONTEXT, GURL(),
+      CheckAliasStatus::NOT_ALLOWED));
   EXPECT_TRUE(extension_api->IsAnyFeatureAvailableToContext(
-      *api_features.GetFeature("storage"),
-      NULL,
-      Feature::UNBLESSED_EXTENSION_CONTEXT,
-      GURL()));
+      *api_features.GetFeature("storage"), nullptr,
+      Feature::UNBLESSED_EXTENSION_CONTEXT, GURL(),
+      CheckAliasStatus::NOT_ALLOWED));
   EXPECT_TRUE(extension_api->IsAnyFeatureAvailableToContext(
-      *api_features.GetFeature("storage"),
-      NULL,
-      Feature::CONTENT_SCRIPT_CONTEXT,
-      GURL()));
+      *api_features.GetFeature("storage"), nullptr,
+      Feature::CONTENT_SCRIPT_CONTEXT, GURL(), CheckAliasStatus::NOT_ALLOWED));
 
   // "extension" is partially unprivileged.
   EXPECT_TRUE(extension_api->IsAnyFeatureAvailableToContext(
-      *api_features.GetFeature("extension"),
-      NULL,
-      Feature::BLESSED_EXTENSION_CONTEXT,
-      GURL()));
+      *api_features.GetFeature("extension"), nullptr,
+      Feature::BLESSED_EXTENSION_CONTEXT, GURL(),
+      CheckAliasStatus::NOT_ALLOWED));
   EXPECT_TRUE(extension_api->IsAnyFeatureAvailableToContext(
-      *api_features.GetFeature("extension"),
-      NULL,
-      Feature::UNBLESSED_EXTENSION_CONTEXT,
-      GURL()));
+      *api_features.GetFeature("extension"), nullptr,
+      Feature::UNBLESSED_EXTENSION_CONTEXT, GURL(),
+      CheckAliasStatus::NOT_ALLOWED));
   EXPECT_TRUE(extension_api->IsAnyFeatureAvailableToContext(
-      *api_features.GetFeature("extension"),
-      NULL,
-      Feature::CONTENT_SCRIPT_CONTEXT,
-      GURL()));
+      *api_features.GetFeature("extension"), nullptr,
+      Feature::CONTENT_SCRIPT_CONTEXT, GURL(), CheckAliasStatus::NOT_ALLOWED));
   EXPECT_TRUE(extension_api->IsAnyFeatureAvailableToContext(
-      *api_features.GetFeature("extension.getURL"),
-      NULL,
-      Feature::CONTENT_SCRIPT_CONTEXT,
-      GURL()));
+      *api_features.GetFeature("extension.getURL"), nullptr,
+      Feature::CONTENT_SCRIPT_CONTEXT, GURL(), CheckAliasStatus::NOT_ALLOWED));
 
   // "history" is entirely privileged.
   EXPECT_TRUE(extension_api->IsAnyFeatureAvailableToContext(
-      *api_features.GetFeature("history"),
-      NULL,
-      Feature::BLESSED_EXTENSION_CONTEXT,
-      GURL()));
+      *api_features.GetFeature("history"), nullptr,
+      Feature::BLESSED_EXTENSION_CONTEXT, GURL(),
+      CheckAliasStatus::NOT_ALLOWED));
   EXPECT_FALSE(extension_api->IsAnyFeatureAvailableToContext(
-      *api_features.GetFeature("history"),
-      NULL,
-      Feature::UNBLESSED_EXTENSION_CONTEXT,
-      GURL()));
+      *api_features.GetFeature("history"), nullptr,
+      Feature::UNBLESSED_EXTENSION_CONTEXT, GURL(),
+      CheckAliasStatus::NOT_ALLOWED));
   EXPECT_FALSE(extension_api->IsAnyFeatureAvailableToContext(
-      *api_features.GetFeature("history"),
-      NULL,
-      Feature::CONTENT_SCRIPT_CONTEXT,
-      GURL()));
+      *api_features.GetFeature("history"), nullptr,
+      Feature::CONTENT_SCRIPT_CONTEXT, GURL(), CheckAliasStatus::NOT_ALLOWED));
 }
 
 scoped_refptr<Extension> CreateHostedApp() {
   base::DictionaryValue values;
   values.SetString(manifest_keys::kName, "test");
   values.SetString(manifest_keys::kVersion, "0.1");
   values.Set(manifest_keys::kWebURLs, new base::ListValue());
   values.SetString(manifest_keys::kLaunchWebURL,
                    "http://www.example.com");
   std::string error;
@@ skipping 36 matching lines @@
   return extension;
 }
 
 TEST(ExtensionAPITest, HostedAppPermissions) {
   scoped_refptr<Extension> extension = CreateHostedApp();
 
   std::unique_ptr<ExtensionAPI> extension_api(
       ExtensionAPI::CreateWithDefaultConfiguration());
 
   // "runtime" and "tabs" should not be available in hosted apps.
-  EXPECT_FALSE(extension_api->IsAvailable("runtime",
-                                          extension.get(),
-                                          Feature::BLESSED_EXTENSION_CONTEXT,
-                                          GURL()).is_available());
-  EXPECT_FALSE(extension_api->IsAvailable("runtime.id",
-                                          extension.get(),
-                                          Feature::BLESSED_EXTENSION_CONTEXT,
-                                          GURL()).is_available());
-  EXPECT_FALSE(extension_api->IsAvailable("runtime.sendMessage",
-                                          extension.get(),
-                                          Feature::BLESSED_EXTENSION_CONTEXT,
-                                          GURL()).is_available());
-  EXPECT_FALSE(extension_api->IsAvailable("runtime.sendNativeMessage",
-                                          extension.get(),
-                                          Feature::BLESSED_EXTENSION_CONTEXT,
-                                          GURL()).is_available());
-  EXPECT_FALSE(extension_api->IsAvailable("tabs.create",
-                                          extension.get(),
-                                          Feature::BLESSED_EXTENSION_CONTEXT,
-                                          GURL()).is_available());
+  EXPECT_FALSE(extension_api
+                   ->IsAvailable("runtime", extension.get(),
+                                 Feature::BLESSED_EXTENSION_CONTEXT, GURL(),
+                                 CheckAliasStatus::NOT_ALLOWED)
+                   .is_available());
+  EXPECT_FALSE(extension_api
+                   ->IsAvailable("runtime.id", extension.get(),
+                                 Feature::BLESSED_EXTENSION_CONTEXT, GURL(),
+                                 CheckAliasStatus::NOT_ALLOWED)
+                   .is_available());
+  EXPECT_FALSE(extension_api
+                   ->IsAvailable("runtime.sendMessage", extension.get(),
+                                 Feature::BLESSED_EXTENSION_CONTEXT, GURL(),
+                                 CheckAliasStatus::NOT_ALLOWED)
+                   .is_available());
+  EXPECT_FALSE(extension_api
+                   ->IsAvailable("runtime.sendNativeMessage", extension.get(),
+                                 Feature::BLESSED_EXTENSION_CONTEXT, GURL(),
+                                 CheckAliasStatus::NOT_ALLOWED)
+                   .is_available());
+  EXPECT_FALSE(extension_api
+                   ->IsAvailable("tabs.create", extension.get(),
+                                 Feature::BLESSED_EXTENSION_CONTEXT, GURL(),
+                                 CheckAliasStatus::NOT_ALLOWED)
+                   .is_available());
 }
 
 TEST(ExtensionAPITest, AppAndFriendsAvailability) {
   std::unique_ptr<ExtensionAPI> extension_api(
       ExtensionAPI::CreateWithDefaultConfiguration());
 
   // Make sure chrome.app.runtime and chrome.app.window are available to apps,
   // and chrome.app is not.
   {
     std::set<std::string> permissions;
     permissions.insert("app.runtime");
     permissions.insert("app.window");
     scoped_refptr<Extension> extension =
         CreatePackagedAppWithPermissions(permissions);
-    EXPECT_FALSE(extension_api->IsAvailable(
-        "app",
-        extension.get(),
-        Feature::BLESSED_EXTENSION_CONTEXT,
-        GURL("http://foo.com")).is_available());
-    EXPECT_TRUE(extension_api->IsAvailable(
-        "app.runtime",
-        extension.get(),
-        Feature::BLESSED_EXTENSION_CONTEXT,
-        GURL("http://foo.com")).is_available());
-    EXPECT_TRUE(extension_api->IsAvailable(
-        "app.window",
-        extension.get(),
-        Feature::BLESSED_EXTENSION_CONTEXT,
-        GURL("http://foo.com")).is_available());
+    EXPECT_FALSE(extension_api
+                     ->IsAvailable("app", extension.get(),
+                                   Feature::BLESSED_EXTENSION_CONTEXT,
+                                   GURL("http://foo.com"),
+                                   CheckAliasStatus::NOT_ALLOWED)
+                     .is_available());
+    EXPECT_TRUE(extension_api
+                    ->IsAvailable("app.runtime", extension.get(),
+                                  Feature::BLESSED_EXTENSION_CONTEXT,
+                                  GURL("http://foo.com"),
+                                  CheckAliasStatus::NOT_ALLOWED)
+                    .is_available());
+    EXPECT_TRUE(extension_api
+                    ->IsAvailable("app.window", extension.get(),
+                                  Feature::BLESSED_EXTENSION_CONTEXT,
+                                  GURL("http://foo.com"),
+                                  CheckAliasStatus::NOT_ALLOWED)
+                    .is_available());
   }
   // Make sure chrome.app.runtime and chrome.app.window are not available to
   // extensions, and chrome.app is.
   {
     std::set<std::string> permissions;
     scoped_refptr<Extension> extension =
         CreateExtensionWithPermissions(permissions);
-    EXPECT_TRUE(extension_api->IsAvailable(
-        "app",
-        extension.get(),
-        Feature::BLESSED_EXTENSION_CONTEXT,
-        GURL("http://foo.com")).is_available());
-    EXPECT_FALSE(extension_api->IsAvailable(
-        "app.runtime",
-        extension.get(),
-        Feature::BLESSED_EXTENSION_CONTEXT,
-        GURL("http://foo.com")).is_available());
-    EXPECT_FALSE(extension_api->IsAvailable(
-        "app.window",
-        extension.get(),
-        Feature::BLESSED_EXTENSION_CONTEXT,
-        GURL("http://foo.com")).is_available());
+    EXPECT_TRUE(extension_api
+                    ->IsAvailable("app", extension.get(),
+                                  Feature::BLESSED_EXTENSION_CONTEXT,
+                                  GURL("http://foo.com"),
+                                  CheckAliasStatus::NOT_ALLOWED)
+                    .is_available());
+    EXPECT_FALSE(extension_api
+                     ->IsAvailable("app.runtime", extension.get(),
+                                   Feature::BLESSED_EXTENSION_CONTEXT,
+                                   GURL("http://foo.com"),
+                                   CheckAliasStatus::NOT_ALLOWED)
+                     .is_available());
+    EXPECT_FALSE(extension_api
+                     ->IsAvailable("app.window", extension.get(),
+                                   Feature::BLESSED_EXTENSION_CONTEXT,
+                                   GURL("http://foo.com"),
+                                   CheckAliasStatus::NOT_ALLOWED)
+                     .is_available());
   }
 }
 
 TEST(ExtensionAPITest, ExtensionWithDependencies) {
   // Extension with the "ttsEngine" permission but not the "tts" permission; it
   // should not automatically get "tts" permission.
   {
     scoped_refptr<Extension> extension =
         CreateExtensionWithPermission("ttsEngine");
     std::unique_ptr<ExtensionAPI> api(
         ExtensionAPI::CreateWithDefaultConfiguration());
-    EXPECT_TRUE(api->IsAvailable("ttsEngine",
-                                 extension.get(),
-                                 Feature::BLESSED_EXTENSION_CONTEXT,
-                                 GURL()).is_available());
-    EXPECT_FALSE(api->IsAvailable("tts",
-                                  extension.get(),
-                                  Feature::BLESSED_EXTENSION_CONTEXT,
-                                  GURL()).is_available());
+    EXPECT_TRUE(api->IsAvailable("ttsEngine", extension.get(),
+                                 Feature::BLESSED_EXTENSION_CONTEXT, GURL(),
+                                 CheckAliasStatus::NOT_ALLOWED)
+                    .is_available());
+    EXPECT_FALSE(api->IsAvailable("tts", extension.get(),
+                                  Feature::BLESSED_EXTENSION_CONTEXT, GURL(),
+                                  CheckAliasStatus::NOT_ALLOWED)
+                     .is_available());
   }
 
   // Conversely, extension with the "tts" permission but not the "ttsEngine"
   // permission shouldn't get the "ttsEngine" permission.
   {
     scoped_refptr<Extension> extension =
         CreateExtensionWithPermission("tts");
     std::unique_ptr<ExtensionAPI> api(
         ExtensionAPI::CreateWithDefaultConfiguration());
-    EXPECT_FALSE(api->IsAvailable("ttsEngine",
-                                  extension.get(),
-                                  Feature::BLESSED_EXTENSION_CONTEXT,
-                                  GURL()).is_available());
-    EXPECT_TRUE(api->IsAvailable("tts",
-                                 extension.get(),
-                                 Feature::BLESSED_EXTENSION_CONTEXT,
-                                 GURL()).is_available());
+    EXPECT_FALSE(api->IsAvailable("ttsEngine", extension.get(),
+                                  Feature::BLESSED_EXTENSION_CONTEXT, GURL(),
+                                  CheckAliasStatus::NOT_ALLOWED)
+                     .is_available());
+    EXPECT_TRUE(api->IsAvailable("tts", extension.get(),
+                                 Feature::BLESSED_EXTENSION_CONTEXT, GURL(),
+                                 CheckAliasStatus::NOT_ALLOWED)
+                    .is_available());
   }
 }
 
 bool MatchesURL(
     ExtensionAPI* api, const std::string& api_name, const std::string& url) {
-  return api->IsAvailable(
-      api_name, NULL, Feature::WEB_PAGE_CONTEXT, GURL(url)).is_available();
+  return api
+      ->IsAvailable(api_name, nullptr, Feature::WEB_PAGE_CONTEXT, GURL(url),
+                    CheckAliasStatus::NOT_ALLOWED)
+      .is_available();
 }
 
 TEST(ExtensionAPITest, URLMatching) {
   std::unique_ptr<ExtensionAPI> api(
       ExtensionAPI::CreateWithDefaultConfiguration());
 
   // "app" API is available to all URLs that content scripts can be injected.
   EXPECT_TRUE(MatchesURL(api.get(), "app", "http://example.com/example.html"));
   EXPECT_TRUE(MatchesURL(api.get(), "app", "https://blah.net"));
   EXPECT_TRUE(MatchesURL(api.get(), "app", "file://somefile.html"));
@@ skipping 209 matching lines @@
     { "runtime.connectNative", false },
   };
 
   std::unique_ptr<ExtensionAPI> extension_api(
       ExtensionAPI::CreateWithDefaultConfiguration());
   scoped_refptr<Extension> extension =
       BuildExtension(ExtensionBuilder()).Build();
 
   for (size_t i = 0; i < arraysize(kTests); ++i) {
     EXPECT_EQ(kTests[i].expect_success,
-              extension_api->IsAvailable(kTests[i].permission_name,
-                                         extension.get(),
-                                         Feature::BLESSED_EXTENSION_CONTEXT,
-                                         GURL()).is_available())
+              extension_api
+                  ->IsAvailable(kTests[i].permission_name, extension.get(),
+                                Feature::BLESSED_EXTENSION_CONTEXT, GURL(),
+                                CheckAliasStatus::NOT_ALLOWED)
+                  .is_available())
         << "Permission being tested: " << kTests[i].permission_name;
   }
 }
 
 // Tests that permissions that require manifest keys are available when those
 // keys are present.
 TEST(ExtensionAPITest, ManifestKeys) {
   std::unique_ptr<ExtensionAPI> extension_api(
       ExtensionAPI::CreateWithDefaultConfiguration());
 
   scoped_refptr<Extension> extension =
       BuildExtension(ExtensionBuilder())
           .MergeManifest(DictionaryBuilder()
                              .Set("browser_action", DictionaryBuilder().Build())
                              .Build())
           .Build();
 
-  EXPECT_TRUE(extension_api->IsAvailable("browserAction",
-                                         extension.get(),
-                                         Feature::BLESSED_EXTENSION_CONTEXT,
-                                         GURL()).is_available());
-  EXPECT_FALSE(extension_api->IsAvailable("pageAction",
-                                          extension.get(),
-                                          Feature::BLESSED_EXTENSION_CONTEXT,
-                                          GURL()).is_available());
+  EXPECT_TRUE(extension_api
+                  ->IsAvailable("browserAction", extension.get(),
+                                Feature::BLESSED_EXTENSION_CONTEXT, GURL(),
+                                CheckAliasStatus::NOT_ALLOWED)
+                  .is_available());
+  EXPECT_FALSE(extension_api
+                   ->IsAvailable("pageAction", extension.get(),
+                                 Feature::BLESSED_EXTENSION_CONTEXT, GURL(),
+                                 CheckAliasStatus::NOT_ALLOWED)
+                   .is_available());
 }
 
 }  // namespace extensions