Allow API functions and events to have entries in _api_features.json

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 "chrome/common/extensions/api/extension_api.h"
 
 #include <string>
 #include <vector>
 
 #include "base/file_util.h"
 #include "base/files/file_path.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/path_service.h"
 #include "base/stringprintf.h"
 #include "base/values.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/extensions/extension.h"
+#include "chrome/common/extensions/extension_manifest_constants.h"
 #include "chrome/common/extensions/extension_unittest.h"
 #include "chrome/common/extensions/features/api_feature.h"
 #include "chrome/common/extensions/features/base_feature_provider.h"
 #include "chrome/common/extensions/features/simple_feature.h"
 #include "chrome/common/extensions/manifest.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace extensions {
 namespace {
 
@@ skipping 54 matching lines @@
     EXPECT_EQ(test_data[i].expected_feature_name, feature_name) << i;
   }
 }
 
 TEST_F(ExtensionAPITest, IsPrivileged) {
   scoped_ptr<ExtensionAPI> extension_api(
       ExtensionAPI::CreateWithDefaultConfiguration());
 
   EXPECT_FALSE(extension_api->IsPrivileged("runtime.connect"));
   EXPECT_FALSE(extension_api->IsPrivileged("runtime.onConnect"));
-
-  // Properties are not supported yet.
-  EXPECT_TRUE(extension_api->IsPrivileged("runtime.lastError"));
+  EXPECT_FALSE(extension_api->IsPrivileged("runtime.lastError"));
 
   // Default unknown names to privileged for paranoia's sake.
   EXPECT_TRUE(extension_api->IsPrivileged(std::string()));
   EXPECT_TRUE(extension_api->IsPrivileged("<unknown-namespace>"));
   EXPECT_TRUE(extension_api->IsPrivileged("extension.<unknown-member>"));
 
   // Exists, but privileged.
   EXPECT_TRUE(extension_api->IsPrivileged("extension.getViews"));
   EXPECT_TRUE(extension_api->IsPrivileged("history.search"));
 
@@ skipping 110 matching lines @@
     }
 
     EXPECT_EQ(test_data[i].expect_is_available,
               api.IsAvailable(test_data[i].api_full_name,
                               NULL,
                               test_data[i].context,
                               test_data[i].url).is_available()) << i;
   }
 }
 
+TEST(ExtensionAPI, IsAnyFeatureAvailableToContext) {
+  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::UNBLESSED_EXTENSION_CONTEXT, GURL() },
+    { "test2", true, Feature::CONTENT_SCRIPT_CONTEXT, GURL() },
+    { "test2", true, Feature::WEB_PAGE_CONTEXT, GURL("http://google.com") },
+    { "test2.foo", false, Feature::WEB_PAGE_CONTEXT,
+        GURL("http://google.com") },
+    { "test3", true, Feature::CONTENT_SCRIPT_CONTEXT, GURL() },
+    { "test3", true, Feature::WEB_PAGE_CONTEXT, GURL("http://foo.com") },
+    { "test4.foo", true, Feature::CONTENT_SCRIPT_CONTEXT, GURL() },
+    { "test7", false, Feature::WEB_PAGE_CONTEXT, GURL("http://google.com") },
+    { "test7", true, Feature::WEB_PAGE_CONTEXT, GURL("http://foo.com") },
+    { "test7", false, Feature::WEB_PAGE_CONTEXT, GURL("http://bar.com") }
+  };
+
+  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("api_features.json");
+
+  std::string api_features_str;
+  ASSERT_TRUE(file_util::ReadFileToString(
+      api_features_path, &api_features_str)) << "api_features.json";
+
+  scoped_ptr<base::DictionaryValue> value(static_cast<DictionaryValue*>(
+      base::JSONReader::Read(api_features_str)));
+  BaseFeatureProvider api_feature_provider(*value, CreateAPIFeature);
+
+  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.RegisterSchema(iter.key(), "");
+    }
+
+    EXPECT_EQ(test_data[i].expect_is_available,
+              api.IsAnyFeatureAvailableToContext(test_data[i].api_full_name,
+                                                 test_data[i].context,
+                                                 test_data[i].url)) << i;
+  }
+}
+
 TEST_F(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"));
   EXPECT_EQ(NULL, apis->GetSchema("foo"));
   EXPECT_EQ(NULL, apis->GetSchema("foo"));
 
@@ skipping 46 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->IsAvailable("runtime",
+                                          extension.get(),
+                                          Feature::CONTENT_SCRIPT_CONTEXT,
+                                          GURL()).is_available());
+  EXPECT_FALSE(extension_api->IsAvailable("runtime.sendNativeMessage",
+                                          extension.get(),
+                                          Feature::CONTENT_SCRIPT_CONTEXT,
+                                          GURL()).is_available());
+  // "runtime" also has unprivileged parts.
+  EXPECT_TRUE(extension_api->IsAvailable("runtime.sendMessage",
+                                         extension.get(),
+                                         Feature::CONTENT_SCRIPT_CONTEXT,
+                                         GURL()).is_available());
+  EXPECT_TRUE(extension_api->IsAvailable("runtime.id",
+                                         extension.get(),
+                                         Feature::CONTENT_SCRIPT_CONTEXT,
+                                         GURL()).is_available());
+
   // "storage" is completely unprivileged.
   EXPECT_TRUE(extension_api->IsAvailable("storage",
                                          extension.get(),
                                          Feature::BLESSED_EXTENSION_CONTEXT,
                                          GURL()).is_available());
   EXPECT_TRUE(extension_api->IsAvailable("storage",
                                          extension.get(),
                                          Feature::UNBLESSED_EXTENSION_CONTEXT,
                                          GURL()).is_available());
   EXPECT_TRUE(extension_api->IsAvailable("storage",
@@ skipping 23 matching lines @@
   EXPECT_FALSE(extension_api->IsAvailable("history",
                                           extension.get(),
                                           Feature::UNBLESSED_EXTENSION_CONTEXT,
                                           GURL()).is_available());
   EXPECT_FALSE(extension_api->IsAvailable("history",
                                           extension.get(),
                                           Feature::CONTENT_SCRIPT_CONTEXT,
                                           GURL()).is_available());
 }
 
+scoped_refptr<Extension> CreateHostedApp() {
+  base::DictionaryValue values;
+  values.SetString(extension_manifest_keys::kName, "test");
+  values.SetString(extension_manifest_keys::kVersion, "0.1");
+  values.Set(extension_manifest_keys::kWebURLs, new base::ListValue());
+  values.SetString(extension_manifest_keys::kLaunchWebURL,
+                   "http://www.example.com");
+
+  std::string error;
+  scoped_refptr<Extension> extension(Extension::Create(
+      base::FilePath(), Manifest::INTERNAL, values, Extension::NO_FLAGS,
+      &error));
+  CHECK(extension.get());
+  return extension;
+}
+
+TEST_F(ExtensionAPITest, HostedAppPermissions) {
+  scoped_refptr<Extension> extension = CreateHostedApp();
+
+  scoped_ptr<ExtensionAPI> extension_api(
+      ExtensionAPI::CreateWithDefaultConfiguration());
+
+  // "runtime" 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());
+}
+
 TEST_F(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");
     scoped_ptr<ExtensionAPI> api(
         ExtensionAPI::CreateWithDefaultConfiguration());
     EXPECT_TRUE(api->IsAvailable("ttsEngine",
                                  extension.get(),
@@ skipping 210 matching lines @@
   GetDictionaryFromList(dict, "parameters", 0, &sub_dict);
   EXPECT_TRUE(sub_dict->GetString("$ref", &type));
   EXPECT_EQ("test.foo.TestType", type);
   GetDictionaryFromList(dict, "parameters", 1, &sub_dict);
   EXPECT_TRUE(sub_dict->GetString("$ref", &type));
   EXPECT_EQ("fully.qualified.Type", type);
 }
 
 }  // namespace
 }  // namespace extensions