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 900
