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/strings/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") },
+    { "parent1.child1", false, Feature::CONTENT_SCRIPT_CONTEXT, GURL() },
+    { "parent1.child1", true, Feature::WEB_PAGE_CONTEXT,
+        GURL("http://foo.com") },
+    { "parent1.child2", true, Feature::CONTENT_SCRIPT_CONTEXT, GURL() },
+    { "parent1.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() },
+    { "parent2.child3", false, Feature::CONTENT_SCRIPT_CONTEXT, GURL() },
+    { "parent2.child3", true, Feature::BLESSED_EXTENSION_CONTEXT, GURL() },
+    { "parent2.child3", false, Feature::UNBLESSED_EXTENSION_CONTEXT, GURL() },
+    { "parent2.child3.child.child", true, Feature::CONTENT_SCRIPT_CONTEXT,
+        GURL() },
+    { "parent2.child3.child.child", false, Feature::BLESSED_EXTENSION_CONTEXT,
+        GURL() },
+    { "parent2.child3.child.child", true, Feature::UNBLESSED_EXTENSION_CONTEXT,
+        GURL() },
+    { "parent3", true, Feature::CONTENT_SCRIPT_CONTEXT, GURL() },
+    { "parent3", false, Feature::BLESSED_EXTENSION_CONTEXT, GURL() },
+    { "parent3", false, Feature::UNBLESSED_EXTENSION_CONTEXT, GURL() },
+    { "parent3.noparent", true, Feature::CONTENT_SCRIPT_CONTEXT, GURL() },
+    { "parent3.noparent", true, Feature::BLESSED_EXTENSION_CONTEXT, GURL() },
+    { "parent3.noparent", true, Feature::UNBLESSED_EXTENSION_CONTEXT, GURL() },
+    { "parent3.noparent.child", true, Feature::CONTENT_SCRIPT_CONTEXT, GURL() },
+    { "parent3.noparent.child", true, Feature::BLESSED_EXTENSION_CONTEXT,
+        GURL() },
+    { "parent3.noparent.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");
-
   std::string error;
   scoped_refptr<Extension> extension(Extension::Create(
       base::FilePath(), Manifest::INTERNAL, values, Extension::NO_FLAGS,
       &error));
   CHECK(extension.get());
   return extension;
 }
 
+scoped_refptr<Extension> CreatePackagedAppWithPermissions(
+    const std::set<std::string>& permissions) {
+  base::DictionaryValue values;
+  values.SetString(extension_manifest_keys::kName, "test");
+  values.SetString(extension_manifest_keys::kVersion, "0.1");
+  values.SetString(extension_manifest_keys::kPlatformAppBackground,
+      "http://www.example.com");
+
+  base::DictionaryValue* app = new base::DictionaryValue();
+  base::DictionaryValue* background = new base::DictionaryValue();
+  base::ListValue* scripts = new base::ListValue();
+  scripts->Append(new base::StringValue("test.js"));
+  background->Set("scripts", scripts);
+  app->Set("background", background);
+  values.Set(extension_manifest_keys::kApp, app);
+  {
+    scoped_ptr<base::ListValue> permissions_list(new base::ListValue());
+    for (std::set<std::string>::const_iterator i = permissions.begin();
+        i != permissions.end(); ++i) {
+      permissions_list->Append(new base::StringValue(*i));
+    }
+    values.Set("permissions", permissions_list.release());
+  }
+
+  std::string error;
+  scoped_refptr<Extension> extension(Extension::Create(
+      base::FilePath(), Manifest::INTERNAL, values, Extension::NO_FLAGS,
+      &error));
+  CHECK(extension.get()) << error;
+  return extension;
+}
+
 TEST(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(ExtensionAPITest, AppAndFriendsAvailability) {
+
+  scoped_ptr<ExtensionAPI> extension_api(
+      ExtensionAPI::CreateWithDefaultConfiguration());
+
+  // Make sure chrome.app.runtime and chrome.app.window are available to apps,
+  // and chrome.app is not.
+  {
+    std::set<std::string> permissions;
+    permissions.insert("app.runtime");
+    permissions.insert("app.window");
+    scoped_refptr<Extension> extension =
+        CreatePackagedAppWithPermissions(permissions);
+    EXPECT_FALSE(extension_api->IsAvailable(
+        "app",
+        extension.get(),
+        Feature::BLESSED_EXTENSION_CONTEXT,
+        GURL("http://foo.com")).is_available());
+    EXPECT_TRUE(extension_api->IsAvailable(
+        "app.runtime",
+        extension.get(),
+        Feature::BLESSED_EXTENSION_CONTEXT,
+        GURL("http://foo.com")).is_available());
+    EXPECT_TRUE(extension_api->IsAvailable(
+        "app.window",
+        extension.get(),
+        Feature::BLESSED_EXTENSION_CONTEXT,
+        GURL("http://foo.com")).is_available());
+  }
+  // Make sure chrome.app.runtime and chrome.app.window are not available to
+  // extensions, and chrome.app is.
+  {
+    std::set<std::string> permissions;
+    scoped_refptr<Extension> extension =
+        CreateExtensionWithPermissions(permissions);
+    EXPECT_TRUE(extension_api->IsAvailable(
+        "app",
+        extension.get(),
+        Feature::BLESSED_EXTENSION_CONTEXT,
+        GURL("http://foo.com")).is_available());
+    EXPECT_FALSE(extension_api->IsAvailable(
+        "app.runtime",
+        extension.get(),
+        Feature::BLESSED_EXTENSION_CONTEXT,
+        GURL("http://foo.com")).is_available());
+    EXPECT_FALSE(extension_api->IsAvailable(
+        "app.window",
+        extension.get(),
+        Feature::BLESSED_EXTENSION_CONTEXT,
+        GURL("http://foo.com")).is_available());
+  }
+}
+
 TEST(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 120 matching lines @@
 
 TEST(ExtensionAPITest, FeaturesRequireContexts) {
   // TODO(cduvall): Make this check API featues.
   scoped_ptr<base::DictionaryValue> api_features1(new base::DictionaryValue());
   scoped_ptr<base::DictionaryValue> api_features2(new base::DictionaryValue());
   base::DictionaryValue* test1 = new base::DictionaryValue();
   base::DictionaryValue* test2 = new base::DictionaryValue();
   base::ListValue* contexts = new base::ListValue();
   contexts->Append(new base::StringValue("content_script"));
   test1->Set("contexts", contexts);
+  test1->SetString("channel", "stable");
+  test2->SetString("channel", "stable");
   api_features1->Set("test", test1);
   api_features2->Set("test", test2);
 
   struct {
     base::DictionaryValue* api_features;
     bool expect_success;
   } test_data[] = {
     { api_features1.get(), true },
     { api_features2.get(), false }
   };
@@ skipping 21 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