Lazily load API schemas from resource files and convert all APIs to features

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/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 {
 
 SimpleFeature* CreateAPIFeature() {
   return new APIFeature();
 }
 
 TEST(ExtensionAPITest, Creation) {
   ExtensionAPI* shared_instance = ExtensionAPI::GetSharedInstance();
   EXPECT_EQ(shared_instance, ExtensionAPI::GetSharedInstance());
 
   scoped_ptr<ExtensionAPI> new_instance(
@@ skipping 44 matching lines @@
 }
 
 TEST(ExtensionAPITest, IsPrivileged) {
   scoped_ptr<ExtensionAPI> extension_api(
       ExtensionAPI::CreateWithDefaultConfiguration());
 
   EXPECT_FALSE(extension_api->IsPrivileged("runtime.connect"));
   EXPECT_FALSE(extension_api->IsPrivileged("runtime.onConnect"));
   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"));
 
   // 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"));
@@ skipping 32 matching lines @@
   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);
     EXPECT_EQ(test_data[i].expect_is_privilged,
               api.IsPrivileged(test_data[i].api_full_name)) << i;
   }
 }
 
-TEST(ExtensionAPI, APIFeatures) {
+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() },
     { "test1", true, Feature::CONTENT_SCRIPT_CONTEXT, GURL() },
@@ skipping 17 matching lines @@
     { "test5", true, Feature::WEB_PAGE_CONTEXT, GURL("http://foo.com") },
     { "test5", false, Feature::WEB_PAGE_CONTEXT, GURL("http://bar.com") },
     { "test5.blah", true, Feature::WEB_PAGE_CONTEXT, GURL("http://foo.com") },
     { "test5.blah", false, Feature::WEB_PAGE_CONTEXT, GURL("http://bar.com") },
     { "test6", false, Feature::BLESSED_EXTENSION_CONTEXT, GURL() },
     { "test6.foo", true, Feature::BLESSED_EXTENSION_CONTEXT, GURL() },
     { "test7", true, Feature::WEB_PAGE_CONTEXT, GURL("http://foo.com") },
     { "test7.foo", false, Feature::WEB_PAGE_CONTEXT, GURL("http://bar.com") },
     { "test7.foo", true, Feature::WEB_PAGE_CONTEXT, GURL("http://foo.com") },
     { "test7.bar", false, Feature::WEB_PAGE_CONTEXT, GURL("http://bar.com") },
-    { "test7.bar", false, Feature::WEB_PAGE_CONTEXT, GURL("http://foo.com") }
+    { "test7.bar", false, Feature::WEB_PAGE_CONTEXT, GURL("http://foo.com") },
+
+    // Test parent/child.
+    { "parent1", true, Feature::CONTENT_SCRIPT_CONTEXT, GURL() },
+    { "parent1", false, Feature::WEB_PAGE_CONTEXT, GURL("http://foo.com") },
+    { "child1", false, Feature::CONTENT_SCRIPT_CONTEXT, GURL() },
+    { "child1", true, Feature::WEB_PAGE_CONTEXT, GURL("http://foo.com") },
+    { "child2", true, Feature::CONTENT_SCRIPT_CONTEXT, GURL() },
+    { "child2", false, Feature::WEB_PAGE_CONTEXT, GURL("http://foo.com") },
+    { "parent2", true, Feature::CONTENT_SCRIPT_CONTEXT, GURL() },
+    { "parent2", true, Feature::BLESSED_EXTENSION_CONTEXT, GURL() },
+    { "parent2", true, Feature::UNBLESSED_EXTENSION_CONTEXT, GURL() },
+    { "child3", false, Feature::CONTENT_SCRIPT_CONTEXT, GURL() },
+    { "child3", true, Feature::BLESSED_EXTENSION_CONTEXT, GURL() },
+    { "child3", false, Feature::UNBLESSED_EXTENSION_CONTEXT, GURL() },
+    { "child.child", true, Feature::CONTENT_SCRIPT_CONTEXT, GURL() },
+    { "child.child", false, Feature::BLESSED_EXTENSION_CONTEXT, GURL() },
+    { "child.child", true, Feature::UNBLESSED_EXTENSION_CONTEXT, GURL() }
   };
 
   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(), "");
+        api.RegisterSchemaResource(iter.key(), 0);
     }
 
     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) {
+TEST(ExtensionAPITest, 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") },
@@ skipping 20 matching lines @@
   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(), "");
+        api.RegisterSchemaResource(iter.key(), 0);
     }
 
     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(ExtensionAPITest, LazyGetSchema) {
@@ skipping 57 matching lines @@
     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());
+  EXPECT_FALSE(extension_api->IsAnyFeatureAvailableToContext(
+      "runtime.getBackgroundPage",
+      Feature::CONTENT_SCRIPT_CONTEXT,
+      GURL()));
+  EXPECT_FALSE(extension_api->IsAnyFeatureAvailableToContext(
+      "runtime.sendNativeMessage",
+      Feature::CONTENT_SCRIPT_CONTEXT,
+      GURL()));
   // "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());
+  EXPECT_TRUE(extension_api->IsAnyFeatureAvailableToContext(
+      "runtime.sendMessage",
+      Feature::CONTENT_SCRIPT_CONTEXT,
+      GURL()));
+  EXPECT_TRUE(extension_api->IsAnyFeatureAvailableToContext(
+      "runtime.id",
+      Feature::CONTENT_SCRIPT_CONTEXT,
+      GURL()));
 
   // "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",
-                                         extension.get(),
-                                         Feature::CONTENT_SCRIPT_CONTEXT,
-                                         GURL()).is_available());
+  EXPECT_TRUE(extension_api->IsAnyFeatureAvailableToContext(
+      "storage",
+      Feature::BLESSED_EXTENSION_CONTEXT,
+      GURL()));
+  EXPECT_TRUE(extension_api->IsAnyFeatureAvailableToContext(
+      "storage",
+      Feature::UNBLESSED_EXTENSION_CONTEXT,
+      GURL()));
+  EXPECT_TRUE(extension_api->IsAnyFeatureAvailableToContext(
+      "storage",
+      Feature::CONTENT_SCRIPT_CONTEXT,
+      GURL()));
 
   // "extension" is partially unprivileged.
-  EXPECT_TRUE(extension_api->IsAvailable("extension",
-                                         extension.get(),
-                                         Feature::BLESSED_EXTENSION_CONTEXT,
-                                         GURL()).is_available());
-  EXPECT_TRUE(extension_api->IsAvailable("extension",
-                                         extension.get(),
-                                         Feature::UNBLESSED_EXTENSION_CONTEXT,
-                                         GURL()).is_available());
-  EXPECT_TRUE(extension_api->IsAvailable("extension",
-                                         extension.get(),
-                                         Feature::CONTENT_SCRIPT_CONTEXT,
-                                         GURL()).is_available());
+  EXPECT_TRUE(extension_api->IsAnyFeatureAvailableToContext(
+      "extension",
+      Feature::BLESSED_EXTENSION_CONTEXT,
+      GURL()));
+  EXPECT_TRUE(extension_api->IsAnyFeatureAvailableToContext(
+      "extension",
+      Feature::UNBLESSED_EXTENSION_CONTEXT,
+      GURL()));
+  EXPECT_TRUE(extension_api->IsAnyFeatureAvailableToContext(
+      "extension",
+      Feature::CONTENT_SCRIPT_CONTEXT,
+      GURL()));
 
   // "history" is entirely privileged.
-  EXPECT_TRUE(extension_api->IsAvailable("history",
-                                         extension.get(),
-                                         Feature::BLESSED_EXTENSION_CONTEXT,
-                                         GURL()).is_available());
-  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());
+  EXPECT_TRUE(extension_api->IsAnyFeatureAvailableToContext(
+      "history",
+      Feature::BLESSED_EXTENSION_CONTEXT,
+      GURL()));
+  EXPECT_FALSE(extension_api->IsAnyFeatureAvailableToContext(
+      "history",
+      Feature::UNBLESSED_EXTENSION_CONTEXT,
+      GURL()));
+  EXPECT_FALSE(extension_api->IsAnyFeatureAvailableToContext(
+      "history",
+      Feature::CONTENT_SCRIPT_CONTEXT,
+      GURL()));
 }
 
 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");
 
@@ skipping 204 matching lines @@
   PathService::Get(chrome::DIR_TEST_DATA, &manifest_path);
   manifest_path = manifest_path.AppendASCII("extensions")
       .AppendASCII("extension_api_unittest")
       .AppendASCII("types_have_namespace.json");
 
   std::string manifest_str;
   ASSERT_TRUE(file_util::ReadFileToString(manifest_path, &manifest_str))
       << "Failed to load: " << manifest_path.value();
 
   ExtensionAPI api;
-  api.RegisterSchema("test.foo", manifest_str);
+  api.RegisterSchemaResource("test.foo", 0);
+  api.LoadSchema("test.foo", manifest_str);
 
   const base::DictionaryValue* schema = api.GetSchema("test.foo");
 
   const base::DictionaryValue* dict;
   const base::DictionaryValue* sub_dict;
   std::string type;
 
   GetDictionaryFromList(schema, "types", 0, &dict);
   EXPECT_TRUE(dict->GetString("id", &type));
   EXPECT_EQ("test.foo.TestType", type);
@@ skipping 26 matching lines @@
 
   GetDictionaryFromList(schema, "events", 0, &dict);
   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