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