chrome/common/extensions/api/extension_api_unittest.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "extensions/common/extension_api.h"
   6
   7 #include <string>
   8 #include <vector>
   9
  10 #include "base/file_util.h"
  11 #include "base/files/file_path.h"
  12 #include "base/json/json_reader.h"
  13 #include "base/json/json_writer.h"
  14 #include "base/memory/ref_counted.h"
  15 #include "base/memory/scoped_ptr.h"
  16 #include "base/path_service.h"
  17 #include "base/strings/stringprintf.h"
  18 #include "base/values.h"
  19 #include "chrome/common/chrome_paths.h"
  20 #include "extensions/common/extension.h"
  21 #include "extensions/common/extension_builder.h"
  22 #include "extensions/common/features/api_feature.h"
  23 #include "extensions/common/features/base_feature_provider.h"
  24 #include "extensions/common/features/simple_feature.h"
  25 #include "extensions/common/manifest.h"
  26 #include "extensions/common/manifest_constants.h"
  27 #include "extensions/common/test_util.h"
  28 #include "extensions/common/value_builder.h"
  29 #include "testing/gtest/include/gtest/gtest.h"
  30
  31 namespace extensions {
  32
  33 using test_util::BuildExtension;
  34
  35 SimpleFeature* CreateAPIFeature() {
  36   return new APIFeature();
  37 }
  38
  39 TEST(ExtensionAPITest, Creation) {
  40   ExtensionAPI* shared_instance = ExtensionAPI::GetSharedInstance();
  41   EXPECT_EQ(shared_instance, ExtensionAPI::GetSharedInstance());
  42
  43   scoped_ptr<ExtensionAPI> new_instance(
  44       ExtensionAPI::CreateWithDefaultConfiguration());
  45   EXPECT_NE(new_instance.get(),
  46             scoped_ptr<ExtensionAPI>(
  47                 ExtensionAPI::CreateWithDefaultConfiguration()).get());
  48
  49   ExtensionAPI empty_instance;
  50
  51   struct {
  52     ExtensionAPI* api;
  53     bool expect_populated;
  54   } test_data[] = {
  55     { shared_instance, true },
  56     { new_instance.get(), true },
  57     { &empty_instance, false }
  58   };
  59
  60   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_data); ++i) {
  61     EXPECT_EQ(test_data[i].expect_populated,
  62               test_data[i].api->GetSchema("bookmarks.create") != NULL);
  63   }
  64 }
  65
  66 TEST(ExtensionAPITest, SplitDependencyName) {
  67   struct {
  68     std::string input;
  69     std::string expected_feature_type;
  70     std::string expected_feature_name;
  71   } test_data[] = {
  72     { "", "api", "" },  // assumes "api" when no type is present
  73     { "foo", "api", "foo" },
  74     { "foo:", "foo", "" },
  75     { ":foo", "", "foo" },
  76     { "foo:bar", "foo", "bar" },
  77     { "foo:bar.baz", "foo", "bar.baz" }
  78   };
  79
  80   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_data); ++i) {
  81     std::string feature_type;
  82     std::string feature_name;
  83     ExtensionAPI::SplitDependencyName(test_data[i].input, &feature_type,
  84                                       &feature_name);
  85     EXPECT_EQ(test_data[i].expected_feature_type, feature_type) << i;
  86     EXPECT_EQ(test_data[i].expected_feature_name, feature_name) << i;
  87   }
  88 }
  89
  90 TEST(ExtensionAPITest, IsPrivileged) {
  91   scoped_ptr<ExtensionAPI> extension_api(
  92       ExtensionAPI::CreateWithDefaultConfiguration());
  93
  94   EXPECT_FALSE(extension_api->IsPrivileged("runtime.connect"));
  95   EXPECT_FALSE(extension_api->IsPrivileged("runtime.onConnect"));
  96   EXPECT_FALSE(extension_api->IsPrivileged("runtime.lastError"));
  97
  98   // Exists, but privileged.
  99   EXPECT_TRUE(extension_api->IsPrivileged("extension.getViews"));
 100   EXPECT_TRUE(extension_api->IsPrivileged("history.search"));
 101
 102   // Whole APIs that are unprivileged.
 103   EXPECT_FALSE(extension_api->IsPrivileged("app.getDetails"));
 104   EXPECT_FALSE(extension_api->IsPrivileged("app.isInstalled"));
 105   EXPECT_FALSE(extension_api->IsPrivileged("storage.local"));
 106   EXPECT_FALSE(extension_api->IsPrivileged("storage.local.onChanged"));
 107   EXPECT_FALSE(extension_api->IsPrivileged("storage.local.set"));
 108   EXPECT_FALSE(extension_api->IsPrivileged("storage.local.MAX_ITEMS"));
 109   EXPECT_FALSE(extension_api->IsPrivileged("storage.set"));
 110 }
 111
 112 TEST(ExtensionAPITest, IsPrivilegedFeatures) {
 113   struct {
 114     std::string api_full_name;
 115     bool expect_is_privilged;
 116   } test_data[] = {
 117     { "test1", false },
 118     { "test1.foo", true },
 119     { "test2", true },
 120     { "test2.foo", false },
 121     { "test2.bar", false },
 122     { "test2.baz", true },
 123     { "test3", false },
 124     { "test3.foo", true },
 125     { "test4", false }
 126   };
 127
 128   base::FilePath api_features_path;
 129   PathService::Get(chrome::DIR_TEST_DATA, &api_features_path);
 130   api_features_path = api_features_path.AppendASCII("extensions")
 131       .AppendASCII("extension_api_unittest")
 132       .AppendASCII("privileged_api_features.json");
 133
 134   std::string api_features_str;
 135   ASSERT_TRUE(base::ReadFileToString(
 136       api_features_path, &api_features_str)) << "privileged_api_features.json";
 137
 138   scoped_ptr<base::DictionaryValue> value(static_cast<base::DictionaryValue*>(
 139       base::JSONReader::Read(api_features_str)));
 140   BaseFeatureProvider api_feature_provider(*value, CreateAPIFeature);
 141
 142   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_data); ++i) {
 143     ExtensionAPI api;
 144     api.RegisterDependencyProvider("api", &api_feature_provider);
 145     EXPECT_EQ(test_data[i].expect_is_privilged,
 146               api.IsPrivileged(test_data[i].api_full_name)) << i;
 147   }
 148 }
 149
 150 TEST(ExtensionAPITest, APIFeatures) {
 151   struct {
 152     std::string api_full_name;
 153     bool expect_is_available;
 154     Feature::Context context;
 155     GURL url;
 156   } test_data[] = {
 157     { "test1", false, Feature::WEB_PAGE_CONTEXT, GURL() },
 158     { "test1", true, Feature::BLESSED_EXTENSION_CONTEXT, GURL() },
 159     { "test1", true, Feature::UNBLESSED_EXTENSION_CONTEXT, GURL() },
 160     { "test1", true, Feature::CONTENT_SCRIPT_CONTEXT, GURL() },
 161     { "test2", true, Feature::WEB_PAGE_CONTEXT, GURL("http://google.com") },
 162     { "test2", false, Feature::BLESSED_EXTENSION_CONTEXT,
 163         GURL("http://google.com") },
 164     { "test2.foo", false, Feature::WEB_PAGE_CONTEXT,
 165         GURL("http://google.com") },
 166     { "test2.foo", true, Feature::CONTENT_SCRIPT_CONTEXT, GURL() },
 167     { "test3", false, Feature::WEB_PAGE_CONTEXT, GURL("http://google.com") },
 168     { "test3.foo", true, Feature::WEB_PAGE_CONTEXT, GURL("http://google.com") },
 169     { "test3.foo", true, Feature::BLESSED_EXTENSION_CONTEXT,
 170         GURL("http://bad.com") },
 171     { "test4", true, Feature::BLESSED_EXTENSION_CONTEXT,
 172         GURL("http://bad.com") },
 173     { "test4.foo", false, Feature::BLESSED_EXTENSION_CONTEXT,
 174         GURL("http://bad.com") },
 175     { "test4.foo", false, Feature::UNBLESSED_EXTENSION_CONTEXT,
 176         GURL("http://bad.com") },
 177     { "test4.foo.foo", true, Feature::CONTENT_SCRIPT_CONTEXT, GURL() },
 178     { "test5", true, Feature::WEB_PAGE_CONTEXT, GURL("http://foo.com") },
 179     { "test5", false, Feature::WEB_PAGE_CONTEXT, GURL("http://bar.com") },
 180     { "test5.blah", true, Feature::WEB_PAGE_CONTEXT, GURL("http://foo.com") },
 181     { "test5.blah", false, Feature::WEB_PAGE_CONTEXT, GURL("http://bar.com") },
 182     { "test6", false, Feature::BLESSED_EXTENSION_CONTEXT, GURL() },
 183     { "test6.foo", true, Feature::BLESSED_EXTENSION_CONTEXT, GURL() },
 184     { "test7", true, Feature::WEB_PAGE_CONTEXT, GURL("http://foo.com") },
 185     { "test7.foo", false, Feature::WEB_PAGE_CONTEXT, GURL("http://bar.com") },
 186     { "test7.foo", true, Feature::WEB_PAGE_CONTEXT, GURL("http://foo.com") },
 187     { "test7.bar", false, Feature::WEB_PAGE_CONTEXT, GURL("http://bar.com") },
 188     { "test7.bar", false, Feature::WEB_PAGE_CONTEXT, GURL("http://foo.com") },
 189
 190     // Test parent/child.
 191     { "parent1", true, Feature::CONTENT_SCRIPT_CONTEXT, GURL() },
 192     { "parent1", false, Feature::WEB_PAGE_CONTEXT, GURL("http://foo.com") },
 193     { "parent1.child1", false, Feature::CONTENT_SCRIPT_CONTEXT, GURL() },
 194     { "parent1.child1", true, Feature::WEB_PAGE_CONTEXT,
 195         GURL("http://foo.com") },
 196     { "parent1.child2", true, Feature::CONTENT_SCRIPT_CONTEXT, GURL() },
 197     { "parent1.child2", false, Feature::WEB_PAGE_CONTEXT,
 198         GURL("http://foo.com") },
 199     { "parent2", true, Feature::CONTENT_SCRIPT_CONTEXT, GURL() },
 200     { "parent2", true, Feature::BLESSED_EXTENSION_CONTEXT, GURL() },
 201     { "parent2", true, Feature::UNBLESSED_EXTENSION_CONTEXT, GURL() },
 202     { "parent2.child3", false, Feature::CONTENT_SCRIPT_CONTEXT, GURL() },
 203     { "parent2.child3", true, Feature::BLESSED_EXTENSION_CONTEXT, GURL() },
 204     { "parent2.child3", false, Feature::UNBLESSED_EXTENSION_CONTEXT, GURL() },
 205     { "parent2.child3.child.child", true, Feature::CONTENT_SCRIPT_CONTEXT,
 206         GURL() },
 207     { "parent2.child3.child.child", false, Feature::BLESSED_EXTENSION_CONTEXT,
 208         GURL() },
 209     { "parent2.child3.child.child", true, Feature::UNBLESSED_EXTENSION_CONTEXT,
 210         GURL() },
 211     { "parent3", true, Feature::CONTENT_SCRIPT_CONTEXT, GURL() },
 212     { "parent3", false, Feature::BLESSED_EXTENSION_CONTEXT, GURL() },
 213     { "parent3", false, Feature::UNBLESSED_EXTENSION_CONTEXT, GURL() },
 214     { "parent3.noparent", true, Feature::CONTENT_SCRIPT_CONTEXT, GURL() },
 215     { "parent3.noparent", true, Feature::BLESSED_EXTENSION_CONTEXT, GURL() },
 216     { "parent3.noparent", true, Feature::UNBLESSED_EXTENSION_CONTEXT, GURL() },
 217     { "parent3.noparent.child", true, Feature::CONTENT_SCRIPT_CONTEXT, GURL() },
 218     { "parent3.noparent.child", true, Feature::BLESSED_EXTENSION_CONTEXT,
 219         GURL() },
 220     { "parent3.noparent.child", true, Feature::UNBLESSED_EXTENSION_CONTEXT,
 221         GURL() }
 222   };
 223
 224   base::FilePath api_features_path;
 225   PathService::Get(chrome::DIR_TEST_DATA, &api_features_path);
 226   api_features_path = api_features_path.AppendASCII("extensions")
 227       .AppendASCII("extension_api_unittest")
 228       .AppendASCII("api_features.json");
 229
 230   std::string api_features_str;
 231   ASSERT_TRUE(base::ReadFileToString(
 232       api_features_path, &api_features_str)) << "api_features.json";
 233
 234   scoped_ptr<base::DictionaryValue> value(static_cast<base::DictionaryValue*>(
 235       base::JSONReader::Read(api_features_str)));
 236   BaseFeatureProvider api_feature_provider(*value, CreateAPIFeature);
 237
 238   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_data); ++i) {
 239     ExtensionAPI api;
 240     api.RegisterDependencyProvider("api", &api_feature_provider);
 241     for (base::DictionaryValue::Iterator iter(*value); !iter.IsAtEnd();
 242          iter.Advance()) {
 243       if (iter.key().find(".") == std::string::npos)
 244         api.RegisterSchemaResource(iter.key(), 0);
 245     }
 246
 247     EXPECT_EQ(test_data[i].expect_is_available,
 248               api.IsAvailable(test_data[i].api_full_name,
 249                               NULL,
 250                               test_data[i].context,
 251                               test_data[i].url).is_available()) << i;
 252   }
 253 }
 254
 255 TEST(ExtensionAPITest, IsAnyFeatureAvailableToContext) {
 256   scoped_refptr<const Extension> app = ExtensionBuilder()
 257     .SetManifest(DictionaryBuilder()
 258       .Set("name", "app")
 259       .Set("app", DictionaryBuilder()
 260         .Set("background", DictionaryBuilder()
 261           .Set("scripts", ListBuilder().Append("background.js"))))
 262       .Set("version", "1")
 263       .Set("manifest_version", 2)).Build();
 264   scoped_refptr<const Extension> extension = ExtensionBuilder()
 265     .SetManifest(DictionaryBuilder()
 266       .Set("name", "extension")
 267       .Set("version", "1")
 268       .Set("manifest_version", 2)).Build();
 269
 270   struct {
 271     std::string api_full_name;
 272     bool expect_is_available;
 273     Feature::Context context;
 274     const Extension* extension;
 275     GURL url;
 276   } test_data[] = {
 277     { "test1", false, Feature::WEB_PAGE_CONTEXT, NULL, GURL() },
 278     { "test1", true, Feature::UNBLESSED_EXTENSION_CONTEXT, NULL, GURL() },
 279     { "test1", false, Feature::UNBLESSED_EXTENSION_CONTEXT, app.get(), GURL() },
 280     { "test1", true, Feature::UNBLESSED_EXTENSION_CONTEXT, extension.get(),
 281         GURL() },
 282     { "test2", true, Feature::CONTENT_SCRIPT_CONTEXT, NULL, GURL() },
 283     { "test2", true, Feature::WEB_PAGE_CONTEXT, NULL,
 284         GURL("http://google.com") },
 285     { "test2.foo", false, Feature::WEB_PAGE_CONTEXT, NULL,
 286         GURL("http://google.com") },
 287     { "test3", true, Feature::CONTENT_SCRIPT_CONTEXT, NULL, GURL() },
 288     { "test3", true, Feature::WEB_PAGE_CONTEXT, NULL, GURL("http://foo.com") },
 289     { "test4.foo", true, Feature::CONTENT_SCRIPT_CONTEXT, NULL, GURL() },
 290     { "test7", false, Feature::WEB_PAGE_CONTEXT, NULL,
 291         GURL("http://google.com") },
 292     { "test7", true, Feature::WEB_PAGE_CONTEXT, NULL, GURL("http://foo.com") },
 293     { "test7", false, Feature::WEB_PAGE_CONTEXT, NULL, GURL("http://bar.com") }
 294   };
 295
 296   base::FilePath api_features_path;
 297   PathService::Get(chrome::DIR_TEST_DATA, &api_features_path);
 298   api_features_path = api_features_path.AppendASCII("extensions")
 299       .AppendASCII("extension_api_unittest")
 300       .AppendASCII("api_features.json");
 301
 302   std::string api_features_str;
 303   ASSERT_TRUE(base::ReadFileToString(
 304       api_features_path, &api_features_str)) << "api_features.json";
 305
 306   scoped_ptr<base::DictionaryValue> value(static_cast<base::DictionaryValue*>(
 307       base::JSONReader::Read(api_features_str)));
 308   BaseFeatureProvider api_feature_provider(*value, CreateAPIFeature);
 309
 310   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_data); ++i) {
 311     ExtensionAPI api;
 312     api.RegisterDependencyProvider("api", &api_feature_provider);
 313     for (base::DictionaryValue::Iterator iter(*value); !iter.IsAtEnd();
 314          iter.Advance()) {
 315       if (iter.key().find(".") == std::string::npos)
 316         api.RegisterSchemaResource(iter.key(), 0);
 317     }
 318
 319     Feature* test_feature =
 320         api_feature_provider.GetFeature(test_data[i].api_full_name);
 321     ASSERT_TRUE(test_feature);
 322     EXPECT_EQ(test_data[i].expect_is_available,
 323               api.IsAnyFeatureAvailableToContext(*test_feature,
 324                                                  test_data[i].extension,
 325                                                  test_data[i].context,
 326                                                  test_data[i].url))
 327         << i;
 328   }
 329 }
 330
 331 TEST(ExtensionAPITest, LazyGetSchema) {
 332   scoped_ptr<ExtensionAPI> apis(ExtensionAPI::CreateWithDefaultConfiguration());
 333
 334   EXPECT_EQ(NULL, apis->GetSchema(std::string()));
 335   EXPECT_EQ(NULL, apis->GetSchema(std::string()));
 336   EXPECT_EQ(NULL, apis->GetSchema("experimental"));
 337   EXPECT_EQ(NULL, apis->GetSchema("experimental"));
 338   EXPECT_EQ(NULL, apis->GetSchema("foo"));
 339   EXPECT_EQ(NULL, apis->GetSchema("foo"));
 340
 341   EXPECT_TRUE(apis->GetSchema("dns"));
 342   EXPECT_TRUE(apis->GetSchema("dns"));
 343   EXPECT_TRUE(apis->GetSchema("extension"));
 344   EXPECT_TRUE(apis->GetSchema("extension"));
 345   EXPECT_TRUE(apis->GetSchema("infobars"));
 346   EXPECT_TRUE(apis->GetSchema("infobars"));
 347   EXPECT_TRUE(apis->GetSchema("omnibox"));
 348   EXPECT_TRUE(apis->GetSchema("omnibox"));
 349   EXPECT_TRUE(apis->GetSchema("storage"));
 350   EXPECT_TRUE(apis->GetSchema("storage"));
 351 }
 352
 353 scoped_refptr<Extension> CreateExtensionWithPermissions(
 354     const std::set<std::string>& permissions) {
 355   base::DictionaryValue manifest;
 356   manifest.SetString("name", "extension");
 357   manifest.SetString("version", "1.0");
 358   manifest.SetInteger("manifest_version", 2);
 359   {
 360     scoped_ptr<base::ListValue> permissions_list(new base::ListValue());
 361     for (std::set<std::string>::const_iterator i = permissions.begin();
 362         i != permissions.end(); ++i) {
 363       permissions_list->Append(new base::StringValue(*i));
 364     }
 365     manifest.Set("permissions", permissions_list.release());
 366   }
 367
 368   std::string error;
 369   scoped_refptr<Extension> extension(Extension::Create(
 370       base::FilePath(), Manifest::UNPACKED,
 371       manifest, Extension::NO_FLAGS, &error));
 372   CHECK(extension.get());
 373   CHECK(error.empty());
 374
 375   return extension;
 376 }
 377
 378 scoped_refptr<Extension> CreateExtensionWithPermission(
 379     const std::string& permission) {
 380   std::set<std::string> permissions;
 381   permissions.insert(permission);
 382   return CreateExtensionWithPermissions(permissions);
 383 }
 384
 385 TEST(ExtensionAPITest, ExtensionWithUnprivilegedAPIs) {
 386   scoped_refptr<Extension> extension;
 387   {
 388     std::set<std::string> permissions;
 389     permissions.insert("storage");
 390     permissions.insert("history");
 391     extension = CreateExtensionWithPermissions(permissions);
 392   }
 393
 394   scoped_ptr<ExtensionAPI> extension_api(
 395       ExtensionAPI::CreateWithDefaultConfiguration());
 396
 397   const FeatureProvider& api_features = *FeatureProvider::GetAPIFeatures();
 398
 399   // "storage" is completely unprivileged.
 400   EXPECT_TRUE(extension_api->IsAnyFeatureAvailableToContext(
 401       *api_features.GetFeature("storage"),
 402       NULL,
 403       Feature::BLESSED_EXTENSION_CONTEXT,
 404       GURL()));
 405   EXPECT_TRUE(extension_api->IsAnyFeatureAvailableToContext(
 406       *api_features.GetFeature("storage"),
 407       NULL,
 408       Feature::UNBLESSED_EXTENSION_CONTEXT,
 409       GURL()));
 410   EXPECT_TRUE(extension_api->IsAnyFeatureAvailableToContext(
 411       *api_features.GetFeature("storage"),
 412       NULL,
 413       Feature::CONTENT_SCRIPT_CONTEXT,
 414       GURL()));
 415
 416   // "extension" is partially unprivileged.
 417   EXPECT_TRUE(extension_api->IsAnyFeatureAvailableToContext(
 418       *api_features.GetFeature("extension"),
 419       NULL,
 420       Feature::BLESSED_EXTENSION_CONTEXT,
 421       GURL()));
 422   EXPECT_TRUE(extension_api->IsAnyFeatureAvailableToContext(
 423       *api_features.GetFeature("extension"),
 424       NULL,
 425       Feature::UNBLESSED_EXTENSION_CONTEXT,
 426       GURL()));
 427   EXPECT_TRUE(extension_api->IsAnyFeatureAvailableToContext(
 428       *api_features.GetFeature("extension"),
 429       NULL,
 430       Feature::CONTENT_SCRIPT_CONTEXT,
 431       GURL()));
 432   EXPECT_TRUE(extension_api->IsAnyFeatureAvailableToContext(
 433       *api_features.GetFeature("extension.getURL"),
 434       NULL,
 435       Feature::CONTENT_SCRIPT_CONTEXT,
 436       GURL()));
 437
 438   // "history" is entirely privileged.
 439   EXPECT_TRUE(extension_api->IsAnyFeatureAvailableToContext(
 440       *api_features.GetFeature("history"),
 441       NULL,
 442       Feature::BLESSED_EXTENSION_CONTEXT,
 443       GURL()));
 444   EXPECT_FALSE(extension_api->IsAnyFeatureAvailableToContext(
 445       *api_features.GetFeature("history"),
 446       NULL,
 447       Feature::UNBLESSED_EXTENSION_CONTEXT,
 448       GURL()));
 449   EXPECT_FALSE(extension_api->IsAnyFeatureAvailableToContext(
 450       *api_features.GetFeature("history"),
 451       NULL,
 452       Feature::CONTENT_SCRIPT_CONTEXT,
 453       GURL()));
 454 }
 455
 456 scoped_refptr<Extension> CreateHostedApp() {
 457   base::DictionaryValue values;
 458   values.SetString(manifest_keys::kName, "test");
 459   values.SetString(manifest_keys::kVersion, "0.1");
 460   values.Set(manifest_keys::kWebURLs, new base::ListValue());
 461   values.SetString(manifest_keys::kLaunchWebURL,
 462                    "http://www.example.com");
 463   std::string error;
 464   scoped_refptr<Extension> extension(Extension::Create(
 465       base::FilePath(), Manifest::INTERNAL, values, Extension::NO_FLAGS,
 466       &error));
 467   CHECK(extension.get());
 468   return extension;
 469 }
 470
 471 scoped_refptr<Extension> CreatePackagedAppWithPermissions(
 472     const std::set<std::string>& permissions) {
 473   base::DictionaryValue values;
 474   values.SetString(manifest_keys::kName, "test");
 475   values.SetString(manifest_keys::kVersion, "0.1");
 476   values.SetString(manifest_keys::kPlatformAppBackground,
 477       "http://www.example.com");
 478
 479   base::DictionaryValue* app = new base::DictionaryValue();
 480   base::DictionaryValue* background = new base::DictionaryValue();
 481   base::ListValue* scripts = new base::ListValue();
 482   scripts->Append(new base::StringValue("test.js"));
 483   background->Set("scripts", scripts);
 484   app->Set("background", background);
 485   values.Set(manifest_keys::kApp, app);
 486   {
 487     scoped_ptr<base::ListValue> permissions_list(new base::ListValue());
 488     for (std::set<std::string>::const_iterator i = permissions.begin();
 489         i != permissions.end(); ++i) {
 490       permissions_list->Append(new base::StringValue(*i));
 491     }
 492     values.Set("permissions", permissions_list.release());
 493   }
 494
 495   std::string error;
 496   scoped_refptr<Extension> extension(Extension::Create(
 497       base::FilePath(), Manifest::INTERNAL, values, Extension::NO_FLAGS,
 498       &error));
 499   CHECK(extension.get()) << error;
 500   return extension;
 501 }
 502
 503 TEST(ExtensionAPITest, HostedAppPermissions) {
 504   scoped_refptr<Extension> extension = CreateHostedApp();
 505
 506   scoped_ptr<ExtensionAPI> extension_api(
 507       ExtensionAPI::CreateWithDefaultConfiguration());
 508
 509   // "runtime" and "tabs" should not be available in hosted apps.
 510   EXPECT_FALSE(extension_api->IsAvailable("runtime",
 511                                           extension.get(),
 512                                           Feature::BLESSED_EXTENSION_CONTEXT,
 513                                           GURL()).is_available());
 514   EXPECT_FALSE(extension_api->IsAvailable("runtime.id",
 515                                           extension.get(),
 516                                           Feature::BLESSED_EXTENSION_CONTEXT,
 517                                           GURL()).is_available());
 518   EXPECT_FALSE(extension_api->IsAvailable("runtime.sendMessage",
 519                                           extension.get(),
 520                                           Feature::BLESSED_EXTENSION_CONTEXT,
 521                                           GURL()).is_available());
 522   EXPECT_FALSE(extension_api->IsAvailable("runtime.sendNativeMessage",
 523                                           extension.get(),
 524                                           Feature::BLESSED_EXTENSION_CONTEXT,
 525                                           GURL()).is_available());
 526   EXPECT_FALSE(extension_api->IsAvailable("tabs.create",
 527                                           extension.get(),
 528                                           Feature::BLESSED_EXTENSION_CONTEXT,
 529                                           GURL()).is_available());
 530 }
 531
 532 TEST(ExtensionAPITest, AppAndFriendsAvailability) {
 533
 534   scoped_ptr<ExtensionAPI> extension_api(
 535       ExtensionAPI::CreateWithDefaultConfiguration());
 536
 537   // Make sure chrome.app.runtime and chrome.app.window are available to apps,
 538   // and chrome.app is not.
 539   {
 540     std::set<std::string> permissions;
 541     permissions.insert("app.runtime");
 542     permissions.insert("app.window");
 543     scoped_refptr<Extension> extension =
 544         CreatePackagedAppWithPermissions(permissions);
 545     EXPECT_FALSE(extension_api->IsAvailable(
 546         "app",
 547         extension.get(),
 548         Feature::BLESSED_EXTENSION_CONTEXT,
 549         GURL("http://foo.com")).is_available());
 550     EXPECT_TRUE(extension_api->IsAvailable(
 551         "app.runtime",
 552         extension.get(),
 553         Feature::BLESSED_EXTENSION_CONTEXT,
 554         GURL("http://foo.com")).is_available());
 555     EXPECT_TRUE(extension_api->IsAvailable(
 556         "app.window",
 557         extension.get(),
 558         Feature::BLESSED_EXTENSION_CONTEXT,
 559         GURL("http://foo.com")).is_available());
 560   }
 561   // Make sure chrome.app.runtime and chrome.app.window are not available to
 562   // extensions, and chrome.app is.
 563   {
 564     std::set<std::string> permissions;
 565     scoped_refptr<Extension> extension =
 566         CreateExtensionWithPermissions(permissions);
 567     EXPECT_TRUE(extension_api->IsAvailable(
 568         "app",
 569         extension.get(),
 570         Feature::BLESSED_EXTENSION_CONTEXT,
 571         GURL("http://foo.com")).is_available());
 572     EXPECT_FALSE(extension_api->IsAvailable(
 573         "app.runtime",
 574         extension.get(),
 575         Feature::BLESSED_EXTENSION_CONTEXT,
 576         GURL("http://foo.com")).is_available());
 577     EXPECT_FALSE(extension_api->IsAvailable(
 578         "app.window",
 579         extension.get(),
 580         Feature::BLESSED_EXTENSION_CONTEXT,
 581         GURL("http://foo.com")).is_available());
 582   }
 583 }
 584
 585 TEST(ExtensionAPITest, ExtensionWithDependencies) {
 586   // Extension with the "ttsEngine" permission but not the "tts" permission; it
 587   // should not automatically get "tts" permission.
 588   {
 589     scoped_refptr<Extension> extension =
 590         CreateExtensionWithPermission("ttsEngine");
 591     scoped_ptr<ExtensionAPI> api(
 592         ExtensionAPI::CreateWithDefaultConfiguration());
 593     EXPECT_TRUE(api->IsAvailable("ttsEngine",
 594                                  extension.get(),
 595                                  Feature::BLESSED_EXTENSION_CONTEXT,
 596                                  GURL()).is_available());
 597     EXPECT_FALSE(api->IsAvailable("tts",
 598                                   extension.get(),
 599                                   Feature::BLESSED_EXTENSION_CONTEXT,
 600                                   GURL()).is_available());
 601   }
 602
 603   // Conversely, extension with the "tts" permission but not the "ttsEngine"
 604   // permission shouldn't get the "ttsEngine" permission.
 605   {
 606     scoped_refptr<Extension> extension =
 607         CreateExtensionWithPermission("tts");
 608     scoped_ptr<ExtensionAPI> api(
 609         ExtensionAPI::CreateWithDefaultConfiguration());
 610     EXPECT_FALSE(api->IsAvailable("ttsEngine",
 611                                   extension.get(),
 612                                   Feature::BLESSED_EXTENSION_CONTEXT,
 613                                   GURL()).is_available());
 614     EXPECT_TRUE(api->IsAvailable("tts",
 615                                  extension.get(),
 616                                  Feature::BLESSED_EXTENSION_CONTEXT,
 617                                  GURL()).is_available());
 618   }
 619 }
 620
 621 bool MatchesURL(
 622     ExtensionAPI* api, const std::string& api_name, const std::string& url) {
 623   return api->IsAvailable(
 624       api_name, NULL, Feature::WEB_PAGE_CONTEXT, GURL(url)).is_available();
 625 }
 626
 627 TEST(ExtensionAPITest, URLMatching) {
 628   scoped_ptr<ExtensionAPI> api(ExtensionAPI::CreateWithDefaultConfiguration());
 629
 630   // "app" API is available to all URLs that content scripts can be injected.
 631   EXPECT_TRUE(MatchesURL(api.get(), "app", "http://example.com/example.html"));
 632   EXPECT_TRUE(MatchesURL(api.get(), "app", "https://blah.net"));
 633   EXPECT_TRUE(MatchesURL(api.get(), "app", "file://somefile.html"));
 634
 635   // But not internal URLs.
 636   EXPECT_FALSE(MatchesURL(api.get(), "app", "about:flags"));
 637   EXPECT_FALSE(MatchesURL(api.get(), "app", "chrome://flags"));
 638
 639   // "app" should be available to chrome-extension URLs.
 640   EXPECT_TRUE(MatchesURL(api.get(), "app",
 641                           "chrome-extension://fakeextension"));
 642
 643   // "storage" API (for example) isn't available to any URLs.
 644   EXPECT_FALSE(MatchesURL(api.get(), "storage",
 645                           "http://example.com/example.html"));
 646   EXPECT_FALSE(MatchesURL(api.get(), "storage", "https://blah.net"));
 647   EXPECT_FALSE(MatchesURL(api.get(), "storage", "file://somefile.html"));
 648   EXPECT_FALSE(MatchesURL(api.get(), "storage", "about:flags"));
 649   EXPECT_FALSE(MatchesURL(api.get(), "storage", "chrome://flags"));
 650   EXPECT_FALSE(MatchesURL(api.get(), "storage",
 651                           "chrome-extension://fakeextension"));
 652 }
 653
 654 TEST(ExtensionAPITest, GetAPINameFromFullName) {
 655   struct {
 656     std::string input;
 657     std::string api_name;
 658     std::string child_name;
 659   } test_data[] = {
 660     { "", "", "" },
 661     { "unknown", "", "" },
 662     { "bookmarks", "bookmarks", "" },
 663     { "bookmarks.", "bookmarks", "" },
 664     { ".bookmarks", "", "" },
 665     { "bookmarks.create", "bookmarks", "create" },
 666     { "bookmarks.create.", "bookmarks", "create." },
 667     { "bookmarks.create.monkey", "bookmarks", "create.monkey" },
 668     { "bookmarkManagerPrivate", "bookmarkManagerPrivate", "" },
 669     { "bookmarkManagerPrivate.copy", "bookmarkManagerPrivate", "copy" }
 670   };
 671
 672   scoped_ptr<ExtensionAPI> api(ExtensionAPI::CreateWithDefaultConfiguration());
 673   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_data); ++i) {
 674     std::string child_name;
 675     std::string api_name = api->GetAPINameFromFullName(test_data[i].input,
 676                                                        &child_name);
 677     EXPECT_EQ(test_data[i].api_name, api_name) << test_data[i].input;
 678     EXPECT_EQ(test_data[i].child_name, child_name) << test_data[i].input;
 679   }
 680 }
 681
 682 TEST(ExtensionAPITest, DefaultConfigurationFeatures) {
 683   scoped_ptr<ExtensionAPI> api(ExtensionAPI::CreateWithDefaultConfiguration());
 684
 685   SimpleFeature* bookmarks = static_cast<SimpleFeature*>(
 686       api->GetFeatureDependency("api:bookmarks"));
 687   SimpleFeature* bookmarks_create = static_cast<SimpleFeature*>(
 688       api->GetFeatureDependency("api:bookmarks.create"));
 689
 690   struct {
 691     SimpleFeature* feature;
 692     // TODO(aa): More stuff to test over time.
 693   } test_data[] = {
 694     { bookmarks },
 695     { bookmarks_create }
 696   };
 697
 698   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_data); ++i) {
 699     SimpleFeature* feature = test_data[i].feature;
 700     ASSERT_TRUE(feature) << i;
 701
 702     EXPECT_TRUE(feature->whitelist()->empty());
 703     EXPECT_TRUE(feature->extension_types()->empty());
 704
 705     EXPECT_EQ(1u, feature->GetContexts()->size());
 706     EXPECT_TRUE(feature->GetContexts()->count(
 707         Feature::BLESSED_EXTENSION_CONTEXT));
 708
 709     EXPECT_EQ(SimpleFeature::UNSPECIFIED_LOCATION, feature->location());
 710     EXPECT_TRUE(feature->platforms()->empty());
 711     EXPECT_EQ(0, feature->min_manifest_version());
 712     EXPECT_EQ(0, feature->max_manifest_version());
 713   }
 714 }
 715
 716 TEST(ExtensionAPITest, FeaturesRequireContexts) {
 717   // TODO(cduvall): Make this check API featues.
 718   scoped_ptr<base::DictionaryValue> api_features1(new base::DictionaryValue());
 719   scoped_ptr<base::DictionaryValue> api_features2(new base::DictionaryValue());
 720   base::DictionaryValue* test1 = new base::DictionaryValue();
 721   base::DictionaryValue* test2 = new base::DictionaryValue();
 722   base::ListValue* contexts = new base::ListValue();
 723   contexts->Append(new base::StringValue("content_script"));
 724   test1->Set("contexts", contexts);
 725   test1->SetString("channel", "stable");
 726   test2->SetString("channel", "stable");
 727   api_features1->Set("test", test1);
 728   api_features2->Set("test", test2);
 729
 730   struct {
 731     base::DictionaryValue* api_features;
 732     bool expect_success;
 733   } test_data[] = {
 734     { api_features1.get(), true },
 735     { api_features2.get(), false }
 736   };
 737
 738
 739   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_data); ++i) {
 740     BaseFeatureProvider api_feature_provider(*test_data[i].api_features,
 741                                              CreateAPIFeature);
 742     Feature* feature = api_feature_provider.GetFeature("test");
 743     EXPECT_EQ(test_data[i].expect_success, feature != NULL) << i;
 744   }
 745 }
 746
 747 static void GetDictionaryFromList(const base::DictionaryValue* schema,
 748                                   const std::string& list_name,
 749                                   const int list_index,
 750                                   const base::DictionaryValue** out) {
 751   const base::ListValue* list;
 752   EXPECT_TRUE(schema->GetList(list_name, &list));
 753   EXPECT_TRUE(list->GetDictionary(list_index, out));
 754 }
 755
 756 TEST(ExtensionAPITest, TypesHaveNamespace) {
 757   base::FilePath manifest_path;
 758   PathService::Get(chrome::DIR_TEST_DATA, &manifest_path);
 759   manifest_path = manifest_path.AppendASCII("extensions")
 760       .AppendASCII("extension_api_unittest")
 761       .AppendASCII("types_have_namespace.json");
 762
 763   std::string manifest_str;
 764   ASSERT_TRUE(base::ReadFileToString(manifest_path, &manifest_str))
 765       << "Failed to load: " << manifest_path.value();
 766
 767   ExtensionAPI api;
 768   api.RegisterSchemaResource("test.foo", 0);
 769   api.LoadSchema("test.foo", manifest_str);
 770
 771   const base::DictionaryValue* schema = api.GetSchema("test.foo");
 772
 773   const base::DictionaryValue* dict;
 774   const base::DictionaryValue* sub_dict;
 775   std::string type;
 776
 777   GetDictionaryFromList(schema, "types", 0, &dict);
 778   EXPECT_TRUE(dict->GetString("id", &type));
 779   EXPECT_EQ("test.foo.TestType", type);
 780   EXPECT_TRUE(dict->GetString("customBindings", &type));
 781   EXPECT_EQ("test.foo.TestType", type);
 782   EXPECT_TRUE(dict->GetDictionary("properties", &sub_dict));
 783   const base::DictionaryValue* property;
 784   EXPECT_TRUE(sub_dict->GetDictionary("foo", &property));
 785   EXPECT_TRUE(property->GetString("$ref", &type));
 786   EXPECT_EQ("test.foo.OtherType", type);
 787   EXPECT_TRUE(sub_dict->GetDictionary("bar", &property));
 788   EXPECT_TRUE(property->GetString("$ref", &type));
 789   EXPECT_EQ("fully.qualified.Type", type);
 790
 791   GetDictionaryFromList(schema, "functions", 0, &dict);
 792   GetDictionaryFromList(dict, "parameters", 0, &sub_dict);
 793   EXPECT_TRUE(sub_dict->GetString("$ref", &type));
 794   EXPECT_EQ("test.foo.TestType", type);
 795   EXPECT_TRUE(dict->GetDictionary("returns", &sub_dict));
 796   EXPECT_TRUE(sub_dict->GetString("$ref", &type));
 797   EXPECT_EQ("fully.qualified.Type", type);
 798
 799   GetDictionaryFromList(schema, "functions", 1, &dict);
 800   GetDictionaryFromList(dict, "parameters", 0, &sub_dict);
 801   EXPECT_TRUE(sub_dict->GetString("$ref", &type));
 802   EXPECT_EQ("fully.qualified.Type", type);
 803   EXPECT_TRUE(dict->GetDictionary("returns", &sub_dict));
 804   EXPECT_TRUE(sub_dict->GetString("$ref", &type));
 805   EXPECT_EQ("test.foo.TestType", type);
 806
 807   GetDictionaryFromList(schema, "events", 0, &dict);
 808   GetDictionaryFromList(dict, "parameters", 0, &sub_dict);
 809   EXPECT_TRUE(sub_dict->GetString("$ref", &type));
 810   EXPECT_EQ("test.foo.TestType", type);
 811   GetDictionaryFromList(dict, "parameters", 1, &sub_dict);
 812   EXPECT_TRUE(sub_dict->GetString("$ref", &type));
 813   EXPECT_EQ("fully.qualified.Type", type);
 814 }
 815
 816 // Tests API availability with an empty manifest.
 817 TEST(ExtensionAPITest, NoPermissions) {
 818   const struct {
 819     const char* permission_name;
 820     bool expect_success;
 821   } kTests[] = {
 822     // Test default module/package permission.
 823     { "extension",      true },
 824     { "i18n",           true },
 825     { "permissions",    true },
 826     { "runtime",        true },
 827     { "test",           true },
 828     // These require manifest keys.
 829     { "browserAction",  false },
 830     { "pageAction",     false },
 831     { "pageActions",    false },
 832     // Some negative tests.
 833     { "bookmarks",      false },
 834     { "cookies",        false },
 835     { "history",        false },
 836     // Make sure we find the module name after stripping '.'
 837     { "runtime.abcd.onStartup",  true },
 838     // Test Tabs/Windows functions.
 839     { "tabs.create",      true },
 840     { "tabs.duplicate",   true },
 841     { "tabs.onRemoved",   true },
 842     { "tabs.remove",      true },
 843     { "tabs.update",      true },
 844     { "tabs.getSelected", true },
 845     { "tabs.onUpdated",   true },
 846     { "windows.get",      true },
 847     { "windows.create",   true },
 848     { "windows.remove",   true },
 849     { "windows.update",   true },
 850     // Test some whitelisted functions. These require no permissions.
 851     { "app.getDetails",           true },
 852     { "app.getDetailsForFrame",   true },
 853     { "app.getIsInstalled",       true },
 854     { "app.installState",         true },
 855     { "app.runningState",         true },
 856     { "management.getPermissionWarningsByManifest", true },
 857     { "management.uninstallSelf", true },
 858     // But other functions in those modules do.
 859     { "management.getPermissionWarningsById", false },
 860   };
 861
 862   scoped_ptr<ExtensionAPI> extension_api(
 863       ExtensionAPI::CreateWithDefaultConfiguration());
 864   scoped_refptr<Extension> extension =
 865       BuildExtension(ExtensionBuilder().Pass()).Build();
 866
 867   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kTests); ++i) {
 868     EXPECT_EQ(kTests[i].expect_success,
 869               extension_api->IsAvailable(kTests[i].permission_name,
 870                                          extension.get(),
 871                                          Feature::BLESSED_EXTENSION_CONTEXT,
 872                                          GURL()).is_available())
 873         << "Permission being tested: " << kTests[i].permission_name;
 874   }
 875 }
 876
 877 // Tests that permissions that require manifest keys are available when those
 878 // keys are present.
 879 TEST(ExtensionAPITest, ManifestKeys) {
 880   scoped_ptr<ExtensionAPI> extension_api(
 881       ExtensionAPI::CreateWithDefaultConfiguration());
 882
 883   scoped_refptr<Extension> extension =
 884       BuildExtension(ExtensionBuilder().Pass())
 885       .MergeManifest(DictionaryBuilder().Set("browser_action",
 886                                              DictionaryBuilder().Pass()))
 887       .Build();
 888
 889   EXPECT_TRUE(extension_api->IsAvailable("browserAction",
 890                                          extension.get(),
 891                                          Feature::BLESSED_EXTENSION_CONTEXT,
 892                                          GURL()).is_available());
 893   EXPECT_FALSE(extension_api->IsAvailable("pageAction",
 894                                           extension.get(),
 895                                           Feature::BLESSED_EXTENSION_CONTEXT,
 896                                           GURL()).is_available());
 897 }
 898
 899 }  // namespace extensions