Convert EventRouter to use ProcessMap::GetMostLikelyContextType rather than

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/files/file_path.h"
@@ skipping 67 matching lines @@
   for (size_t i = 0; i < arraysize(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, 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_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_FALSE(extension_api->IsAvailableInUntrustedContext(
-      "extension.getViews", extension.get()));
-  EXPECT_FALSE(extension_api->IsAvailableInUntrustedContext("history.search",
-                                                            extension.get()));
-
-  // Whole APIs that are unprivileged.
-  EXPECT_TRUE(
-      extension_api->IsAvailableInUntrustedContext("app", extension.get()));
-  EXPECT_TRUE(extension_api->IsAvailableInUntrustedContext("app.getDetails",
-                                                           extension.get()));
-  // There is no feature "app.isInstalled" (it's "app.getIsInstalled") but
-  // this should be available nonetheless.
-  EXPECT_TRUE(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()));
-
-  // APIs which override unprivileged APIs.
-  EXPECT_FALSE(extension_api->IsAvailableInUntrustedContext("app.runtime",
-                                                            extension.get()));
-  EXPECT_FALSE(extension_api->IsAvailableInUntrustedContext("app.window",
-                                                            extension.get()));
-}
-
-TEST(ExtensionAPITest, IsAvailableInUntrustedContextFeatures) {
-  struct {
-    std::string api_full_name;
-    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(test_data); ++i) {
-    ExtensionAPI api;
-    api.RegisterDependencyProvider("api", &api_feature_provider);
-    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[] = {
     { "test1", false, Feature::WEB_PAGE_CONTEXT, GURL() },
     { "test1", true, Feature::BLESSED_EXTENSION_CONTEXT, GURL() },
     { "test1", true, Feature::UNBLESSED_EXTENSION_CONTEXT, GURL() },
@@ skipping 733 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