Convert tabs, windows, and extension APIs to feature system.

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_path.h"
@@ skipping 81 matching lines @@
   }
 }
 
 TEST(ExtensionAPI, IsPrivileged) {
   scoped_ptr<ExtensionAPI> extension_api(
       ExtensionAPI::CreateWithDefaultConfiguration());
 
   EXPECT_FALSE(extension_api->IsPrivileged("extension.connect"));
   EXPECT_FALSE(extension_api->IsPrivileged("extension.onConnect"));
 
-  // Properties are not supported yet.
-  EXPECT_TRUE(extension_api->IsPrivileged("extension.lastError"));
+  // Properties are not supported yet, but the default for this module is
+  // unprivileged, so that's what we see.
+  EXPECT_FALSE(extension_api->IsPrivileged("extension.lastError"));
 
-  // Default unknown names to privileged for paranoia's sake.
+  // Default unknown modules to privileged for paranoia's sake.
   EXPECT_TRUE(extension_api->IsPrivileged(""));
   EXPECT_TRUE(extension_api->IsPrivileged("<unknown-namespace>"));
-  EXPECT_TRUE(extension_api->IsPrivileged("extension.<unknown-member>"));
+
+  // Default unknown names within a module to the parent's value.
+  EXPECT_FALSE(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"));
   EXPECT_FALSE(extension_api->IsPrivileged("storage.local.MAX_ITEMS"));
   EXPECT_FALSE(extension_api->IsPrivileged("storage.set"));
 }
 
 TEST(ExtensionAPI, IsPrivilegedFeatures) {
   struct {
     std::string filename;
     std::string api_full_name;
     bool expect_is_privilged;
     Feature::Context test2_contexts;
   } test_data[] = {
     { "is_privileged_features_1.json", "test", false,
       Feature::UNSPECIFIED_CONTEXT },
     { "is_privileged_features_2.json", "test", true,
       Feature::UNSPECIFIED_CONTEXT },
     { "is_privileged_features_3.json", "test", false,
       Feature::UNSPECIFIED_CONTEXT },
-    { "is_privileged_features_4.json", "test.bar", false,
+    { "is_privileged_features_5.json", "test.bar", true,
+      Feature::BLESSED_EXTENSION_CONTEXT },
+    // These are privileged because a child always depends on its parent. So
+    // even if the child is more permissive than its parent, it still ends up
+    // having the same requirements.
+    { "is_privileged_features_4.json", "test.bar", true,
       Feature::UNSPECIFIED_CONTEXT },
     { "is_privileged_features_5.json", "test.bar", true,
-      Feature::BLESSED_EXTENSION_CONTEXT },
-    { "is_privileged_features_5.json", "test.bar", false,
       Feature::UNBLESSED_EXTENSION_CONTEXT }
   };
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_data); ++i) {
     FilePath manifest_path;
     PathService::Get(chrome::DIR_TEST_DATA, &manifest_path);
     manifest_path = manifest_path.AppendASCII("extensions")
         .AppendASCII("extension_api_unittest")
         .AppendASCII(test_data[i].filename);
 
@@ skipping 191 matching lines @@
   scoped_ptr<ExtensionAPI> api(ExtensionAPI::CreateWithDefaultConfiguration());
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_data); ++i) {
     std::string child_name;
     std::string api_name = api->GetAPINameFromFullName(test_data[i].input,
                                                        &child_name);
     EXPECT_EQ(test_data[i].api_name, api_name) << test_data[i].input;
     EXPECT_EQ(test_data[i].child_name, child_name) << test_data[i].input;
   }
 }
 
-TEST(ExtensionAPI, DefaultConfigurationFeatures) {
-  scoped_ptr<ExtensionAPI> api(ExtensionAPI::CreateWithDefaultConfiguration());
-
-  Feature* bookmarks = api->GetFeature("bookmarks");
-  Feature* bookmarks_create = api->GetFeature("bookmarks.create");
-
-  struct {
-    Feature* feature;
-    // TODO(aa): More stuff to test over time.
-  } test_data[] = {
-    { bookmarks },
-    { bookmarks_create }
-  };
-
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_data); ++i) {
-    Feature* feature = test_data[i].feature;
-    ASSERT_TRUE(feature) << i;
-
-    EXPECT_TRUE(feature->whitelist()->empty());
-    EXPECT_TRUE(feature->extension_types()->empty());
-
-    EXPECT_EQ(1u, feature->contexts()->size());
-    EXPECT_TRUE(feature->contexts()->count(
-        Feature::BLESSED_EXTENSION_CONTEXT));
-
-    EXPECT_EQ(Feature::UNSPECIFIED_LOCATION, feature->location());
-    EXPECT_EQ(Feature::UNSPECIFIED_PLATFORM, feature->platform());
-    EXPECT_EQ(0, feature->min_manifest_version());
-    EXPECT_EQ(0, feature->max_manifest_version());
-  }
-}
-
-TEST(ExtensionAPI, FeaturesRequireContexts) {
-  scoped_ptr<ListValue> schema1(new ListValue());
-  DictionaryValue* feature_definition = new DictionaryValue();
-  schema1->Append(feature_definition);
-  feature_definition->SetString("namespace", "test");
-  feature_definition->SetBoolean("uses_feature_system", true);
-
-  scoped_ptr<ListValue> schema2(schema1->DeepCopy());
-
-  ListValue* contexts = new ListValue();
-  contexts->Append(Value::CreateStringValue("content_script"));
-  feature_definition->Set("contexts", contexts);
-
-  struct {
-    ListValue* schema;
-    bool expect_success;
-  } test_data[] = {
-    { 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;
-  }
-}
-
 }  // namespace
 }  // namespace extensions