Remove GetContexts() from the public interface of extensions::Feature. It was

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 67 matching lines @@
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_data); ++i) {
     std::string feature_type;
     std::string feature_name;
     ExtensionAPI::SplitDependencyName(
         test_data[i].input, &feature_type, &feature_name);
     EXPECT_EQ(test_data[i].expected_feature_type, feature_type) << i;
     EXPECT_EQ(test_data[i].expected_feature_name, feature_name) << i;
   }
 }
 
-TEST(ExtensionAPITest, IsPrivileged) {
+TEST(ExtensionAPITest, IsAvailableInUntrustedContext) {
   scoped_ptr<ExtensionAPI> extension_api(
       ExtensionAPI::CreateWithDefaultConfiguration());
+  scoped_refptr<const Extension> extension =
+      ExtensionBuilder()
+          .SetManifest(DictionaryBuilder()
+                           .Set("name", "extension")
+                           .Set("version", "1")
+                           .Set("permissions", ListBuilder().Append("storage"))
+                           .Set("manifest_version", 2))
+          .Build();
 
-  EXPECT_FALSE(extension_api->IsPrivileged("runtime.connect"));
-  EXPECT_FALSE(extension_api->IsPrivileged("runtime.onConnect"));
-  EXPECT_FALSE(extension_api->IsPrivileged("runtime.lastError"));
+  EXPECT_TRUE(extension_api->IsAvailableInUntrustedContext("runtime.connect",
+                                                           extension.get()));
+  EXPECT_TRUE(extension_api->IsAvailableInUntrustedContext("runtime.onConnect",
+                                                           extension.get()));
+  EXPECT_TRUE(extension_api->IsAvailableInUntrustedContext("runtime.lastError",
+                                                           extension.get()));
 
   // Exists, but privileged.
-  EXPECT_TRUE(extension_api->IsPrivileged("extension.getViews"));
-  EXPECT_TRUE(extension_api->IsPrivileged("history.search"));
+  EXPECT_FALSE(extension_api->IsAvailableInUntrustedContext(
+      "extension.getViews", extension.get()));
+  EXPECT_FALSE(extension_api->IsAvailableInUntrustedContext("history.search",
+                                                            extension.get()));
 
   // Whole APIs that are unprivileged.
-  EXPECT_FALSE(extension_api->IsPrivileged("app.getDetails"));
-  EXPECT_FALSE(extension_api->IsPrivileged("app.isInstalled"));
-  EXPECT_FALSE(extension_api->IsPrivileged("storage.local"));
-  EXPECT_FALSE(extension_api->IsPrivileged("storage.local.onChanged"));
-  EXPECT_FALSE(extension_api->IsPrivileged("storage.local.set"));
-  EXPECT_FALSE(extension_api->IsPrivileged("storage.local.MAX_ITEMS"));
-  EXPECT_FALSE(extension_api->IsPrivileged("storage.set"));
+  EXPECT_TRUE(extension_api->IsAvailableInUntrustedContext("app.getDetails",
+                                                           extension.get()));
+  EXPECT_FALSE(extension_api->IsAvailableInUntrustedContext("app.isInstalled",
+                                                            extension.get()));
+  EXPECT_TRUE(extension_api->IsAvailableInUntrustedContext("storage.local",
+                                                           extension.get()));
+  EXPECT_TRUE(extension_api->IsAvailableInUntrustedContext(
+      "storage.local.onChanged", extension.get()));
+  EXPECT_TRUE(extension_api->IsAvailableInUntrustedContext("storage.local.set",
+                                                           extension.get()));
+  EXPECT_TRUE(extension_api->IsAvailableInUntrustedContext(
+      "storage.local.MAX_ITEMS", extension.get()));
+  EXPECT_TRUE(extension_api->IsAvailableInUntrustedContext("storage.set",
+                                                           extension.get()));
 }
 
-TEST(ExtensionAPITest, IsPrivilegedFeatures) {
+TEST(ExtensionAPITest, IsAvailableInUntrustedContextFeatures) {
   struct {
     std::string api_full_name;
-    bool expect_is_privilged;
-  } test_data[] = {
-    { "test1", false },
-    { "test1.foo", true },
-    { "test2", true },
-    { "test2.foo", false },
-    { "test2.bar", false },
-    { "test2.baz", true },
-    { "test3", false },
-    { "test3.foo", true },
-    { "test4", false }
-  };
+    bool expect_is_available;
+  } test_data[] = {{"test1", true},
+                   {"test1.foo", false},
+                   {"test2", false},
+                   {"test2.foo", true},
+                   {"test2.bar", true},
+                   {"test2.baz", false},
+                   {"test2.qux", false},
+                   {"test3", true},
+                   {"test3.foo", false},
+                   {"test4", true},
+                   {"test5", true}};
 
   base::FilePath api_features_path;
   PathService::Get(chrome::DIR_TEST_DATA, &api_features_path);
   api_features_path = api_features_path.AppendASCII("extensions")
       .AppendASCII("extension_api_unittest")
       .AppendASCII("privileged_api_features.json");
 
   std::string api_features_str;
   ASSERT_TRUE(base::ReadFileToString(
       api_features_path, &api_features_str)) << "privileged_api_features.json";
 
   scoped_ptr<base::DictionaryValue> value(static_cast<base::DictionaryValue*>(
       base::JSONReader::Read(api_features_str)));
   BaseFeatureProvider api_feature_provider(*value, CreateAPIFeature);
 
+  scoped_refptr<Extension> extension =
+      BuildExtension(ExtensionBuilder().Pass()).Build();
+
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_data); ++i) {
     ExtensionAPI api;
     api.RegisterDependencyProvider("api", &api_feature_provider);
-    EXPECT_EQ(test_data[i].expect_is_privilged,
-              api.IsPrivileged(test_data[i].api_full_name)) << i;
+    EXPECT_EQ(test_data[i].expect_is_available,
+              api.IsAvailableInUntrustedContext(test_data[i].api_full_name,
+                                                extension.get()))
+        << i;
   }
 }
 
 TEST(ExtensionAPITest, APIFeatures) {
   struct {
     std::string api_full_name;
     bool expect_is_available;
     Feature::Context context;
     GURL url;
   } test_data[] = {
@@ skipping 546 matching lines @@
     { bookmarks_create }
   };
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_data); ++i) {
     SimpleFeature* feature = test_data[i].feature;
     ASSERT_TRUE(feature) << i;
 
     EXPECT_TRUE(feature->whitelist()->empty());
     EXPECT_TRUE(feature->extension_types()->empty());
 
-    EXPECT_EQ(1u, feature->GetContexts()->size());
-    EXPECT_TRUE(feature->GetContexts()->count(
-        Feature::BLESSED_EXTENSION_CONTEXT));
-
     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.
   scoped_ptr<base::DictionaryValue> api_features1(new base::DictionaryValue());
@@ skipping 171 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