Pass a Feature* to IsAnyFeatureAvailableToContext instead of a string name.

chrome/common/extensions/api/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 <string>
 #include <vector>
 
 #include "base/file_util.h"
@@ skipping 298 matching lines @@
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_data); ++i) {
     ExtensionAPI api;
     api.RegisterDependencyProvider("api", &api_feature_provider);
     for (base::DictionaryValue::Iterator iter(*value); !iter.IsAtEnd();
          iter.Advance()) {
       if (iter.key().find(".") == std::string::npos)
         api.RegisterSchemaResource(iter.key(), 0);
     }
 
+    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_data[i].api_full_name,
+              api.IsAnyFeatureAvailableToContext(*test_feature,
                                                  test_data[i].extension,
                                                  test_data[i].context,
-                                                 test_data[i].url)) << i;
+                                                 test_data[i].url))
+        << i;
   }
 }
 
 TEST(ExtensionAPITest, LazyGetSchema) {
   scoped_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"));
@@ skipping 49 matching lines @@
   {
     std::set<std::string> permissions;
     permissions.insert("storage");
     permissions.insert("history");
     extension = CreateExtensionWithPermissions(permissions);
   }
 
   scoped_ptr<ExtensionAPI> extension_api(
       ExtensionAPI::CreateWithDefaultConfiguration());
 
-  // "runtime" has privileged parts that should not be accessed by content
-  // scripts.
-  EXPECT_FALSE(extension_api->IsAnyFeatureAvailableToContext(
-      "runtime.getBackgroundPage",

[not at google - send to devlin, 2013/12/18 01:55:14]

what happened to these?

[Jeffrey Yasskin, 2013/12/18 02:14:59]

runtime.getBackgroundPage isn't a feature, so it was exercising the logic in
IsAvailable that looks for subfeatures using concatenation, but looks for the
current feature by chaining up to the parent. This doesn't make a whole lot of
sense, so I didn't bother to keep it working when I switched the production code
to use Feature& everywhere. The fact that the production code *could* use
Feature& everywhere means this sort of edge case actually never happens, so we
don't need to test it. The rest of the "partially unprivileged" case is handled
by the "extension" test.

[not at google - send to devlin, 2013/12/18 02:18:10]

sgtm.

-      NULL,
-      Feature::CONTENT_SCRIPT_CONTEXT,
-      GURL()));
-  EXPECT_FALSE(extension_api->IsAnyFeatureAvailableToContext(
-      "runtime.sendNativeMessage",
-      NULL,
-      Feature::CONTENT_SCRIPT_CONTEXT,
-      GURL()));
-  // "runtime" also has unprivileged parts.
-  EXPECT_TRUE(extension_api->IsAnyFeatureAvailableToContext(
-      "runtime.sendMessage",
-      NULL,
-      Feature::CONTENT_SCRIPT_CONTEXT,
-      GURL()));
-  EXPECT_TRUE(extension_api->IsAnyFeatureAvailableToContext(
-      "runtime.id",
-      NULL,
-      Feature::CONTENT_SCRIPT_CONTEXT,
-      GURL()));
+  const FeatureProvider& api_features = *FeatureProvider::GetAPIFeatures();
 
   // "storage" is completely unprivileged.
   EXPECT_TRUE(extension_api->IsAnyFeatureAvailableToContext(
-      "storage",
+      *api_features.GetFeature("storage"),
       NULL,
       Feature::BLESSED_EXTENSION_CONTEXT,
       GURL()));
   EXPECT_TRUE(extension_api->IsAnyFeatureAvailableToContext(
-      "storage",
+      *api_features.GetFeature("storage"),
       NULL,
       Feature::UNBLESSED_EXTENSION_CONTEXT,
       GURL()));
   EXPECT_TRUE(extension_api->IsAnyFeatureAvailableToContext(
-      "storage",
+      *api_features.GetFeature("storage"),
       NULL,
       Feature::CONTENT_SCRIPT_CONTEXT,
       GURL()));
 
   // "extension" is partially unprivileged.
   EXPECT_TRUE(extension_api->IsAnyFeatureAvailableToContext(
-      "extension",
+      *api_features.GetFeature("extension"),
       NULL,
       Feature::BLESSED_EXTENSION_CONTEXT,
       GURL()));
   EXPECT_TRUE(extension_api->IsAnyFeatureAvailableToContext(
-      "extension",
+      *api_features.GetFeature("extension"),
       NULL,
       Feature::UNBLESSED_EXTENSION_CONTEXT,
       GURL()));
   EXPECT_TRUE(extension_api->IsAnyFeatureAvailableToContext(
-      "extension",
+      *api_features.GetFeature("extension"),
+      NULL,
+      Feature::CONTENT_SCRIPT_CONTEXT,
+      GURL()));
+  EXPECT_TRUE(extension_api->IsAnyFeatureAvailableToContext(
+      *api_features.GetFeature("extension.getURL"),
       NULL,
       Feature::CONTENT_SCRIPT_CONTEXT,
       GURL()));
 
   // "history" is entirely privileged.
   EXPECT_TRUE(extension_api->IsAnyFeatureAvailableToContext(
-      "history",
+      *api_features.GetFeature("history"),
       NULL,
       Feature::BLESSED_EXTENSION_CONTEXT,
       GURL()));
   EXPECT_FALSE(extension_api->IsAnyFeatureAvailableToContext(
-      "history",
+      *api_features.GetFeature("history"),
       NULL,
       Feature::UNBLESSED_EXTENSION_CONTEXT,
       GURL()));
   EXPECT_FALSE(extension_api->IsAnyFeatureAvailableToContext(
-      "history",
+      *api_features.GetFeature("history"),
       NULL,
       Feature::CONTENT_SCRIPT_CONTEXT,
       GURL()));
 }
 
 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());
@@ skipping 429 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