Lazily load extension API schemas

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"
@@ skipping 145 matching lines @@
         << test_data[i].filename;
 
     ExtensionAPI api;
     api.RegisterSchema("test", manifest_str);
 
     TestFeatureProvider test2_provider(test_data[i].test2_contexts);
     if (test_data[i].test2_contexts != Feature::UNSPECIFIED_CONTEXT) {
       api.RegisterDependencyProvider("test2", &test2_provider);
     }
 
-    api.LoadAllSchemas();
     EXPECT_EQ(test_data[i].expect_is_privilged,
               api.IsPrivileged(test_data[i].api_full_name)) << i;
   }
 }
 
 TEST(ExtensionAPI, LazyGetSchema) {
   scoped_ptr<ExtensionAPI> apis(ExtensionAPI::CreateWithDefaultConfiguration());
 
   EXPECT_EQ(NULL, apis->GetSchema(""));
   EXPECT_EQ(NULL, apis->GetSchema(""));
@@ skipping 51 matching lines @@
   {
     std::set<std::string> permissions;
     permissions.insert("storage");
     permissions.insert("history");
     extension = CreateExtensionWithPermissions(permissions);
   }
 
   scoped_ptr<ExtensionAPI> extension_api(
       ExtensionAPI::CreateWithDefaultConfiguration());
 
-  std::set<std::string> privileged_apis = extension_api->GetAPIsForContext(
-      Feature::BLESSED_EXTENSION_CONTEXT, extension.get(), GURL());
-
-  std::set<std::string> unprivileged_apis = extension_api->GetAPIsForContext(
-      Feature::UNBLESSED_EXTENSION_CONTEXT, extension.get(), GURL());
-
-  std::set<std::string> content_script_apis = extension_api->GetAPIsForContext(
-      Feature::CONTENT_SCRIPT_CONTEXT, extension.get(), GURL());
-
   // "storage" is completely unprivileged.
-  EXPECT_EQ(1u, privileged_apis.count("storage"));
-  EXPECT_EQ(1u, unprivileged_apis.count("storage"));
-  EXPECT_EQ(1u, content_script_apis.count("storage"));
+  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());
 
   // "extension" is partially unprivileged.
-  EXPECT_EQ(1u, privileged_apis.count("extension"));
-  EXPECT_EQ(1u, unprivileged_apis.count("extension"));
-  EXPECT_EQ(1u, content_script_apis.count("extension"));
+  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());
 
   // "history" is entirely privileged.
-  EXPECT_EQ(1u, privileged_apis.count("history"));
-  EXPECT_EQ(0u, unprivileged_apis.count("history"));
-  EXPECT_EQ(0u, content_script_apis.count("history"));
+  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());
 }
 
 TEST(ExtensionAPI, ExtensionWithDependencies) {
   // Extension with the "ttsEngine" permission but not the "tts" permission; it
-  // must load TTS.
+  // should not automatically get "tts" permission.
   {
     scoped_refptr<Extension> extension =
         CreateExtensionWithPermission("ttsEngine");
     scoped_ptr<ExtensionAPI> api(
         ExtensionAPI::CreateWithDefaultConfiguration());
-    std::set<std::string> apis = api->GetAPIsForContext(
-        Feature::BLESSED_EXTENSION_CONTEXT, extension.get(), GURL());
-    EXPECT_EQ(1u, apis.count("ttsEngine"));
-    EXPECT_EQ(1u, apis.count("tts"));
+    EXPECT_TRUE(api->IsAvailable("ttsEngine",
+                                 extension.get(),
+                                 Feature::BLESSED_EXTENSION_CONTEXT,
+                                 GURL()).is_available());
+    EXPECT_FALSE(api->IsAvailable("tts",
+                                  extension.get(),
+                                  Feature::BLESSED_EXTENSION_CONTEXT,
+                                  GURL()).is_available());
   }
 
   // Conversely, extension with the "tts" permission but not the "ttsEngine"
   // permission shouldn't get the "ttsEngine" permission.
   {
     scoped_refptr<Extension> extension =
         CreateExtensionWithPermission("tts");
     scoped_ptr<ExtensionAPI> api(
         ExtensionAPI::CreateWithDefaultConfiguration());
-    std::set<std::string> apis = api->GetAPIsForContext(
-        Feature::BLESSED_EXTENSION_CONTEXT, extension.get(), GURL());
-    EXPECT_EQ(0u, apis.count("ttsEngine"));
-    EXPECT_EQ(1u, apis.count("tts"));
+    EXPECT_FALSE(api->IsAvailable("ttsEngine",
+                                  extension.get(),
+                                  Feature::BLESSED_EXTENSION_CONTEXT,
+                                  GURL()).is_available());
+    EXPECT_TRUE(api->IsAvailable("tts",
+                                 extension.get(),
+                                 Feature::BLESSED_EXTENSION_CONTEXT,
+                                 GURL()).is_available());
   }
 }
 
 bool MatchesURL(
     ExtensionAPI* api, const std::string& api_name, const std::string& url) {
-  std::set<std::string> apis =
-      api->GetAPIsForContext(Feature::WEB_PAGE_CONTEXT, NULL, GURL(url));
-  return apis.count(api_name);
+  return api->IsAvailable(
+      api_name, NULL, Feature::WEB_PAGE_CONTEXT, GURL(url)).is_available();
 }
 
 TEST(ExtensionAPI, URLMatching) {
   scoped_ptr<ExtensionAPI> api(ExtensionAPI::CreateWithDefaultConfiguration());
 
   // "app" API is available to all URLs that content scripts can be injected.
   EXPECT_TRUE(MatchesURL(api.get(), "app", "http://example.com/example.html"));
   EXPECT_TRUE(MatchesURL(api.get(), "app", "https://blah.net"));
   EXPECT_TRUE(MatchesURL(api.get(), "app", "file://somefile.html"));
 
@@ skipping 97 matching lines @@
     { schema1.get(), true },
     { schema2.get(), false }
   };
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_data); ++i) {
     std::string schema_source;
     base::JSONWriter::Write(test_data[i].schema, &schema_source);
 
     ExtensionAPI api;
     api.RegisterSchema("test", base::StringPiece(schema_source));
-    api.LoadAllSchemas();
 
     Feature* feature = api.GetFeature("test");
     EXPECT_EQ(test_data[i].expect_success, feature != NULL) << i;
   }
 }
 
 static void GetDictionaryFromList(const base::DictionaryValue* schema,
                                   const std::string& list_name,
                                   const int list_index,
                                   const base::DictionaryValue** out) {
   const base::ListValue* list;
   EXPECT_TRUE(schema->GetList(list_name, &list));
   EXPECT_TRUE(list->GetDictionary(list_index, out));
 }
 
 TEST(ExtensionAPI, TypesHaveNamespace) {
   base::FilePath manifest_path;
   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.LoadAllSchemas();
 
   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 28 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