| OLD | NEW |
|---|
| (Empty) |
| 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 "chrome/common/extensions/features/feature.h" | |
| 6 | |
| 7 #include "testing/gtest/include/gtest/gtest.h" | |
| 8 | |
| 9 using chrome::VersionInfo; | |
| 10 using extensions::Extension; | |
| 11 using extensions::Feature; | |
| 12 | |
| 13 namespace { | |
| 14 | |
| 15 struct IsAvailableTestData { | |
| 16 std::string extension_id; | |
| 17 Extension::Type extension_type; | |
| 18 Feature::Location location; | |
| 19 Feature::Platform platform; | |
| 20 int manifest_version; | |
| 21 Feature::AvailabilityResult expected_result; | |
| 22 }; | |
| 23 | |
| 24 class ExtensionFeatureTest : public testing::Test { | |
| 25 protected: | |
| 26 ExtensionFeatureTest() | |
| 27 : current_channel_(VersionInfo::CHANNEL_UNKNOWN) {} | |
| 28 virtual ~ExtensionFeatureTest() {} | |
| 29 | |
| 30 private: | |
| 31 Feature::ScopedCurrentChannel current_channel_; | |
| 32 }; | |
| 33 | |
| 34 TEST_F(ExtensionFeatureTest, IsAvailableNullCase) { | |
| 35 const IsAvailableTestData tests[] = { | |
| 36 { "", Extension::TYPE_UNKNOWN, | |
| 37 Feature::UNSPECIFIED_LOCATION, Feature::UNSPECIFIED_PLATFORM, -1, | |
| 38 Feature::IS_AVAILABLE }, | |
| 39 { "random-extension", Extension::TYPE_UNKNOWN, | |
| 40 Feature::UNSPECIFIED_LOCATION, Feature::UNSPECIFIED_PLATFORM, -1, | |
| 41 Feature::IS_AVAILABLE }, | |
| 42 { "", Extension::TYPE_LEGACY_PACKAGED_APP, | |
| 43 Feature::UNSPECIFIED_LOCATION, Feature::UNSPECIFIED_PLATFORM, -1, | |
| 44 Feature::IS_AVAILABLE }, | |
| 45 { "", Extension::TYPE_UNKNOWN, | |
| 46 Feature::UNSPECIFIED_LOCATION, Feature::UNSPECIFIED_PLATFORM, -1, | |
| 47 Feature::IS_AVAILABLE }, | |
| 48 { "", Extension::TYPE_UNKNOWN, | |
| 49 Feature::COMPONENT_LOCATION, Feature::UNSPECIFIED_PLATFORM, -1, | |
| 50 Feature::IS_AVAILABLE }, | |
| 51 { "", Extension::TYPE_UNKNOWN, | |
| 52 Feature::UNSPECIFIED_LOCATION, Feature::CHROMEOS_PLATFORM, -1, | |
| 53 Feature::IS_AVAILABLE }, | |
| 54 { "", Extension::TYPE_UNKNOWN, | |
| 55 Feature::UNSPECIFIED_LOCATION, Feature::UNSPECIFIED_PLATFORM, 25, | |
| 56 Feature::IS_AVAILABLE } | |
| 57 }; | |
| 58 | |
| 59 Feature feature; | |
| 60 for (size_t i = 0; i < arraysize(tests); ++i) { | |
| 61 const IsAvailableTestData& test = tests[i]; | |
| 62 EXPECT_EQ(test.expected_result, | |
| 63 feature.IsAvailableToManifest(test.extension_id, | |
| 64 test.extension_type, | |
| 65 test.location, | |
| 66 test.manifest_version, | |
| 67 test.platform).result()); | |
| 68 } | |
| 69 } | |
| 70 | |
| 71 TEST_F(ExtensionFeatureTest, Whitelist) { | |
| 72 Feature feature; | |
| 73 feature.whitelist()->insert("foo"); | |
| 74 feature.whitelist()->insert("bar"); | |
| 75 | |
| 76 EXPECT_EQ(Feature::IS_AVAILABLE, feature.IsAvailableToManifest( | |
| 77 "foo", Extension::TYPE_UNKNOWN, Feature::UNSPECIFIED_LOCATION, -1, | |
| 78 Feature::UNSPECIFIED_PLATFORM).result()); | |
| 79 EXPECT_EQ(Feature::IS_AVAILABLE, feature.IsAvailableToManifest( | |
| 80 "bar", Extension::TYPE_UNKNOWN, Feature::UNSPECIFIED_LOCATION, -1, | |
| 81 Feature::UNSPECIFIED_PLATFORM).result()); | |
| 82 | |
| 83 EXPECT_EQ(Feature::NOT_FOUND_IN_WHITELIST, feature.IsAvailableToManifest( | |
| 84 "baz", Extension::TYPE_UNKNOWN, Feature::UNSPECIFIED_LOCATION, -1, | |
| 85 Feature::UNSPECIFIED_PLATFORM).result()); | |
| 86 EXPECT_EQ(Feature::NOT_FOUND_IN_WHITELIST, feature.IsAvailableToManifest( | |
| 87 "", Extension::TYPE_UNKNOWN, Feature::UNSPECIFIED_LOCATION, -1, | |
| 88 Feature::UNSPECIFIED_PLATFORM).result()); | |
| 89 | |
| 90 feature.extension_types()->insert(Extension::TYPE_LEGACY_PACKAGED_APP); | |
| 91 EXPECT_EQ(Feature::NOT_FOUND_IN_WHITELIST, feature.IsAvailableToManifest( | |
| 92 "baz", Extension::TYPE_LEGACY_PACKAGED_APP, | |
| 93 Feature::UNSPECIFIED_LOCATION, -1, | |
| 94 Feature::UNSPECIFIED_PLATFORM).result()); | |
| 95 } | |
| 96 | |
| 97 TEST_F(ExtensionFeatureTest, PackageType) { | |
| 98 Feature feature; | |
| 99 feature.extension_types()->insert(Extension::TYPE_EXTENSION); | |
| 100 feature.extension_types()->insert(Extension::TYPE_LEGACY_PACKAGED_APP); | |
| 101 | |
| 102 EXPECT_EQ(Feature::IS_AVAILABLE, feature.IsAvailableToManifest( | |
| 103 "", Extension::TYPE_EXTENSION, Feature::UNSPECIFIED_LOCATION, -1, | |
| 104 Feature::UNSPECIFIED_PLATFORM).result()); | |
| 105 EXPECT_EQ(Feature::IS_AVAILABLE, feature.IsAvailableToManifest( | |
| 106 "", Extension::TYPE_LEGACY_PACKAGED_APP, Feature::UNSPECIFIED_LOCATION, | |
| 107 -1, Feature::UNSPECIFIED_PLATFORM).result()); | |
| 108 | |
| 109 EXPECT_EQ(Feature::INVALID_TYPE, feature.IsAvailableToManifest( | |
| 110 "", Extension::TYPE_UNKNOWN, Feature::UNSPECIFIED_LOCATION, -1, | |
| 111 Feature::UNSPECIFIED_PLATFORM).result()); | |
| 112 EXPECT_EQ(Feature::INVALID_TYPE, feature.IsAvailableToManifest( | |
| 113 "", Extension::TYPE_THEME, Feature::UNSPECIFIED_LOCATION, -1, | |
| 114 Feature::UNSPECIFIED_PLATFORM).result()); | |
| 115 } | |
| 116 | |
| 117 TEST_F(ExtensionFeatureTest, Context) { | |
| 118 Feature feature; | |
| 119 feature.contexts()->insert(Feature::BLESSED_EXTENSION_CONTEXT); | |
| 120 feature.extension_types()->insert(Extension::TYPE_LEGACY_PACKAGED_APP); | |
| 121 feature.set_platform(Feature::CHROMEOS_PLATFORM); | |
| 122 feature.set_min_manifest_version(21); | |
| 123 feature.set_max_manifest_version(25); | |
| 124 | |
| 125 DictionaryValue manifest; | |
| 126 manifest.SetString("name", "test"); | |
| 127 manifest.SetString("version", "1"); | |
| 128 manifest.SetInteger("manifest_version", 21); | |
| 129 manifest.SetString("app.launch.local_path", "foo.html"); | |
| 130 | |
| 131 std::string error; | |
| 132 scoped_refptr<const Extension> extension(Extension::Create( | |
| 133 FilePath(), Extension::INTERNAL, manifest, Extension::NO_FLAGS, &error)); | |
| 134 EXPECT_EQ("", error); | |
| 135 ASSERT_TRUE(extension.get()); | |
| 136 | |
| 137 feature.whitelist()->insert("monkey"); | |
| 138 EXPECT_EQ(Feature::NOT_FOUND_IN_WHITELIST, feature.IsAvailableToContext( | |
| 139 extension.get(), Feature::BLESSED_EXTENSION_CONTEXT, | |
| 140 Feature::CHROMEOS_PLATFORM).result()); | |
| 141 feature.whitelist()->clear(); | |
| 142 | |
| 143 feature.extension_types()->clear(); | |
| 144 feature.extension_types()->insert(Extension::TYPE_THEME); | |
| 145 EXPECT_EQ(Feature::INVALID_TYPE, feature.IsAvailableToContext( | |
| 146 extension.get(), Feature::BLESSED_EXTENSION_CONTEXT, | |
| 147 Feature::CHROMEOS_PLATFORM).result()); | |
| 148 feature.extension_types()->clear(); | |
| 149 feature.extension_types()->insert(Extension::TYPE_LEGACY_PACKAGED_APP); | |
| 150 | |
| 151 feature.contexts()->clear(); | |
| 152 feature.contexts()->insert(Feature::UNBLESSED_EXTENSION_CONTEXT); | |
| 153 EXPECT_EQ(Feature::INVALID_CONTEXT, feature.IsAvailableToContext( | |
| 154 extension.get(), Feature::BLESSED_EXTENSION_CONTEXT, | |
| 155 Feature::CHROMEOS_PLATFORM).result()); | |
| 156 feature.contexts()->clear(); | |
| 157 feature.contexts()->insert(Feature::BLESSED_EXTENSION_CONTEXT); | |
| 158 | |
| 159 feature.set_location(Feature::COMPONENT_LOCATION); | |
| 160 EXPECT_EQ(Feature::INVALID_LOCATION, feature.IsAvailableToContext( | |
| 161 extension.get(), Feature::BLESSED_EXTENSION_CONTEXT, | |
| 162 Feature::CHROMEOS_PLATFORM).result()); | |
| 163 feature.set_location(Feature::UNSPECIFIED_LOCATION); | |
| 164 | |
| 165 EXPECT_EQ(Feature::INVALID_PLATFORM, feature.IsAvailableToContext( | |
| 166 extension.get(), Feature::BLESSED_EXTENSION_CONTEXT, | |
| 167 Feature::UNSPECIFIED_PLATFORM).result()); | |
| 168 | |
| 169 feature.set_min_manifest_version(22); | |
| 170 EXPECT_EQ(Feature::INVALID_MIN_MANIFEST_VERSION, feature.IsAvailableToContext( | |
| 171 extension.get(), Feature::BLESSED_EXTENSION_CONTEXT, | |
| 172 Feature::CHROMEOS_PLATFORM).result()); | |
| 173 feature.set_min_manifest_version(21); | |
| 174 | |
| 175 feature.set_max_manifest_version(18); | |
| 176 EXPECT_EQ(Feature::INVALID_MAX_MANIFEST_VERSION, feature.IsAvailableToContext( | |
| 177 extension.get(), Feature::BLESSED_EXTENSION_CONTEXT, | |
| 178 Feature::CHROMEOS_PLATFORM).result()); | |
| 179 feature.set_max_manifest_version(25); | |
| 180 } | |
| 181 | |
| 182 TEST_F(ExtensionFeatureTest, Location) { | |
| 183 Feature feature; | |
| 184 | |
| 185 // If the feature specifies "component" as its location, then only component | |
| 186 // extensions can access it. | |
| 187 feature.set_location(Feature::COMPONENT_LOCATION); | |
| 188 EXPECT_EQ(Feature::IS_AVAILABLE, feature.IsAvailableToManifest( | |
| 189 "", Extension::TYPE_UNKNOWN, Feature::COMPONENT_LOCATION, -1, | |
| 190 Feature::UNSPECIFIED_PLATFORM).result()); | |
| 191 EXPECT_EQ(Feature::INVALID_LOCATION, feature.IsAvailableToManifest( | |
| 192 "", Extension::TYPE_UNKNOWN, Feature::UNSPECIFIED_LOCATION, -1, | |
| 193 Feature::UNSPECIFIED_PLATFORM).result()); | |
| 194 | |
| 195 // But component extensions can access anything else, whatever their location. | |
| 196 feature.set_location(Feature::UNSPECIFIED_LOCATION); | |
| 197 EXPECT_EQ(Feature::IS_AVAILABLE, feature.IsAvailableToManifest( | |
| 198 "", Extension::TYPE_UNKNOWN, Feature::COMPONENT_LOCATION, -1, | |
| 199 Feature::UNSPECIFIED_PLATFORM).result()); | |
| 200 } | |
| 201 | |
| 202 TEST_F(ExtensionFeatureTest, Platform) { | |
| 203 Feature feature; | |
| 204 feature.set_platform(Feature::CHROMEOS_PLATFORM); | |
| 205 EXPECT_EQ(Feature::IS_AVAILABLE, feature.IsAvailableToManifest( | |
| 206 "", Extension::TYPE_UNKNOWN, Feature::UNSPECIFIED_LOCATION, -1, | |
| 207 Feature::CHROMEOS_PLATFORM).result()); | |
| 208 EXPECT_EQ(Feature::INVALID_PLATFORM, feature.IsAvailableToManifest( | |
| 209 "", Extension::TYPE_UNKNOWN, Feature::UNSPECIFIED_LOCATION, -1, | |
| 210 Feature::UNSPECIFIED_PLATFORM).result()); | |
| 211 } | |
| 212 | |
| 213 TEST_F(ExtensionFeatureTest, Version) { | |
| 214 Feature feature; | |
| 215 feature.set_min_manifest_version(5); | |
| 216 | |
| 217 EXPECT_EQ(Feature::INVALID_MIN_MANIFEST_VERSION, | |
| 218 feature.IsAvailableToManifest( | |
| 219 "", Extension::TYPE_UNKNOWN, Feature::UNSPECIFIED_LOCATION, | |
| 220 0, Feature::UNSPECIFIED_PLATFORM).result()); | |
| 221 EXPECT_EQ(Feature::INVALID_MIN_MANIFEST_VERSION, | |
| 222 feature.IsAvailableToManifest( | |
| 223 "", Extension::TYPE_UNKNOWN, Feature::UNSPECIFIED_LOCATION, | |
| 224 4, Feature::UNSPECIFIED_PLATFORM).result()); | |
| 225 | |
| 226 EXPECT_EQ(Feature::IS_AVAILABLE, feature.IsAvailableToManifest( | |
| 227 "", Extension::TYPE_UNKNOWN, Feature::UNSPECIFIED_LOCATION, | |
| 228 5, Feature::UNSPECIFIED_PLATFORM).result()); | |
| 229 EXPECT_EQ(Feature::IS_AVAILABLE, feature.IsAvailableToManifest( | |
| 230 "", Extension::TYPE_UNKNOWN, Feature::UNSPECIFIED_LOCATION, | |
| 231 10, Feature::UNSPECIFIED_PLATFORM).result()); | |
| 232 | |
| 233 feature.set_max_manifest_version(8); | |
| 234 | |
| 235 EXPECT_EQ(Feature::INVALID_MAX_MANIFEST_VERSION, | |
| 236 feature.IsAvailableToManifest( | |
| 237 "", Extension::TYPE_UNKNOWN, Feature::UNSPECIFIED_LOCATION, | |
| 238 10, Feature::UNSPECIFIED_PLATFORM).result()); | |
| 239 EXPECT_EQ(Feature::IS_AVAILABLE, | |
| 240 feature.IsAvailableToManifest( | |
| 241 "", Extension::TYPE_UNKNOWN, Feature::UNSPECIFIED_LOCATION, | |
| 242 8, Feature::UNSPECIFIED_PLATFORM).result()); | |
| 243 EXPECT_EQ(Feature::IS_AVAILABLE, feature.IsAvailableToManifest( | |
| 244 "", Extension::TYPE_UNKNOWN, Feature::UNSPECIFIED_LOCATION, | |
| 245 7, Feature::UNSPECIFIED_PLATFORM).result()); | |
| 246 } | |
| 247 | |
| 248 TEST_F(ExtensionFeatureTest, ParseNull) { | |
| 249 scoped_ptr<DictionaryValue> value(new DictionaryValue()); | |
| 250 scoped_ptr<Feature> feature(new Feature()); | |
| 251 feature->Parse(value.get()); | |
| 252 EXPECT_TRUE(feature->whitelist()->empty()); | |
| 253 EXPECT_TRUE(feature->extension_types()->empty()); | |
| 254 EXPECT_TRUE(feature->contexts()->empty()); | |
| 255 EXPECT_EQ(Feature::UNSPECIFIED_LOCATION, feature->location()); | |
| 256 EXPECT_EQ(Feature::UNSPECIFIED_PLATFORM, feature->platform()); | |
| 257 EXPECT_EQ(0, feature->min_manifest_version()); | |
| 258 EXPECT_EQ(0, feature->max_manifest_version()); | |
| 259 } | |
| 260 | |
| 261 TEST_F(ExtensionFeatureTest, ParseWhitelist) { | |
| 262 scoped_ptr<DictionaryValue> value(new DictionaryValue()); | |
| 263 ListValue* whitelist = new ListValue(); | |
| 264 whitelist->Append(Value::CreateStringValue("foo")); | |
| 265 whitelist->Append(Value::CreateStringValue("bar")); | |
| 266 value->Set("whitelist", whitelist); | |
| 267 scoped_ptr<Feature> feature(new Feature()); | |
| 268 feature->Parse(value.get()); | |
| 269 EXPECT_EQ(2u, feature->whitelist()->size()); | |
| 270 EXPECT_TRUE(feature->whitelist()->count("foo")); | |
| 271 EXPECT_TRUE(feature->whitelist()->count("bar")); | |
| 272 } | |
| 273 | |
| 274 TEST_F(ExtensionFeatureTest, ParsePackageTypes) { | |
| 275 scoped_ptr<DictionaryValue> value(new DictionaryValue()); | |
| 276 ListValue* extension_types = new ListValue(); | |
| 277 extension_types->Append(Value::CreateStringValue("extension")); | |
| 278 extension_types->Append(Value::CreateStringValue("theme")); | |
| 279 extension_types->Append(Value::CreateStringValue("packaged_app")); | |
| 280 extension_types->Append(Value::CreateStringValue("hosted_app")); | |
| 281 extension_types->Append(Value::CreateStringValue("platform_app")); | |
| 282 value->Set("extension_types", extension_types); | |
| 283 scoped_ptr<Feature> feature(new Feature()); | |
| 284 feature->Parse(value.get()); | |
| 285 EXPECT_EQ(5u, feature->extension_types()->size()); | |
| 286 EXPECT_TRUE(feature->extension_types()->count(Extension::TYPE_EXTENSION)); | |
| 287 EXPECT_TRUE(feature->extension_types()->count(Extension::TYPE_THEME)); | |
| 288 EXPECT_TRUE(feature->extension_types()->count( | |
| 289 Extension::TYPE_LEGACY_PACKAGED_APP)); | |
| 290 EXPECT_TRUE(feature->extension_types()->count(Extension::TYPE_HOSTED_APP)); | |
| 291 EXPECT_TRUE(feature->extension_types()->count(Extension::TYPE_PLATFORM_APP)); | |
| 292 | |
| 293 value->SetString("extension_types", "all"); | |
| 294 scoped_ptr<Feature> feature2(new Feature()); | |
| 295 feature2->Parse(value.get()); | |
| 296 EXPECT_EQ(*(feature->extension_types()), *(feature2->extension_types())); | |
| 297 } | |
| 298 | |
| 299 TEST_F(ExtensionFeatureTest, ParseContexts) { | |
| 300 scoped_ptr<DictionaryValue> value(new DictionaryValue()); | |
| 301 ListValue* contexts = new ListValue(); | |
| 302 contexts->Append(Value::CreateStringValue("blessed_extension")); | |
| 303 contexts->Append(Value::CreateStringValue("unblessed_extension")); | |
| 304 contexts->Append(Value::CreateStringValue("content_script")); | |
| 305 contexts->Append(Value::CreateStringValue("web_page")); | |
| 306 value->Set("contexts", contexts); | |
| 307 scoped_ptr<Feature> feature(new Feature()); | |
| 308 feature->Parse(value.get()); | |
| 309 EXPECT_EQ(4u, feature->contexts()->size()); | |
| 310 EXPECT_TRUE(feature->contexts()->count(Feature::BLESSED_EXTENSION_CONTEXT)); | |
| 311 EXPECT_TRUE(feature->contexts()->count(Feature::UNBLESSED_EXTENSION_CONTEXT)); | |
| 312 EXPECT_TRUE(feature->contexts()->count(Feature::CONTENT_SCRIPT_CONTEXT)); | |
| 313 EXPECT_TRUE(feature->contexts()->count(Feature::WEB_PAGE_CONTEXT)); | |
| 314 | |
| 315 value->SetString("contexts", "all"); | |
| 316 scoped_ptr<Feature> feature2(new Feature()); | |
| 317 feature2->Parse(value.get()); | |
| 318 EXPECT_EQ(*(feature->contexts()), *(feature2->contexts())); | |
| 319 } | |
| 320 | |
| 321 TEST_F(ExtensionFeatureTest, ParseLocation) { | |
| 322 scoped_ptr<DictionaryValue> value(new DictionaryValue()); | |
| 323 value->SetString("location", "component"); | |
| 324 scoped_ptr<Feature> feature(new Feature()); | |
| 325 feature->Parse(value.get()); | |
| 326 EXPECT_EQ(Feature::COMPONENT_LOCATION, feature->location()); | |
| 327 } | |
| 328 | |
| 329 TEST_F(ExtensionFeatureTest, ParsePlatform) { | |
| 330 scoped_ptr<DictionaryValue> value(new DictionaryValue()); | |
| 331 value->SetString("platform", "chromeos"); | |
| 332 scoped_ptr<Feature> feature(new Feature()); | |
| 333 feature->Parse(value.get()); | |
| 334 EXPECT_EQ(Feature::CHROMEOS_PLATFORM, feature->platform()); | |
| 335 } | |
| 336 | |
| 337 TEST_F(ExtensionFeatureTest, ManifestVersion) { | |
| 338 scoped_ptr<DictionaryValue> value(new DictionaryValue()); | |
| 339 value->SetInteger("min_manifest_version", 1); | |
| 340 value->SetInteger("max_manifest_version", 5); | |
| 341 scoped_ptr<Feature> feature(new Feature()); | |
| 342 feature->Parse(value.get()); | |
| 343 EXPECT_EQ(1, feature->min_manifest_version()); | |
| 344 EXPECT_EQ(5, feature->max_manifest_version()); | |
| 345 } | |
| 346 | |
| 347 TEST_F(ExtensionFeatureTest, Inheritance) { | |
| 348 Feature feature; | |
| 349 feature.whitelist()->insert("foo"); | |
| 350 feature.extension_types()->insert(Extension::TYPE_THEME); | |
| 351 feature.contexts()->insert(Feature::BLESSED_EXTENSION_CONTEXT); | |
| 352 feature.set_location(Feature::COMPONENT_LOCATION); | |
| 353 feature.set_platform(Feature::CHROMEOS_PLATFORM); | |
| 354 feature.set_min_manifest_version(1); | |
| 355 feature.set_max_manifest_version(2); | |
| 356 | |
| 357 Feature feature2 = feature; | |
| 358 EXPECT_TRUE(feature2.Equals(feature)); | |
| 359 | |
| 360 DictionaryValue definition; | |
| 361 feature2.Parse(&definition); | |
| 362 EXPECT_TRUE(feature2.Equals(feature)); | |
| 363 | |
| 364 ListValue* whitelist = new ListValue(); | |
| 365 ListValue* extension_types = new ListValue(); | |
| 366 ListValue* contexts = new ListValue(); | |
| 367 whitelist->Append(Value::CreateStringValue("bar")); | |
| 368 extension_types->Append(Value::CreateStringValue("extension")); | |
| 369 contexts->Append(Value::CreateStringValue("unblessed_extension")); | |
| 370 definition.Set("whitelist", whitelist); | |
| 371 definition.Set("extension_types", extension_types); | |
| 372 definition.Set("contexts", contexts); | |
| 373 // Can't test location or platform because we only have one value so far. | |
| 374 definition.Set("min_manifest_version", Value::CreateIntegerValue(2)); | |
| 375 definition.Set("max_manifest_version", Value::CreateIntegerValue(3)); | |
| 376 | |
| 377 feature2.Parse(&definition); | |
| 378 EXPECT_FALSE(feature2.Equals(feature)); | |
| 379 EXPECT_EQ(1u, feature2.whitelist()->size()); | |
| 380 EXPECT_EQ(1u, feature2.extension_types()->size()); | |
| 381 EXPECT_EQ(1u, feature2.contexts()->size()); | |
| 382 EXPECT_EQ(1u, feature2.whitelist()->count("bar")); | |
| 383 EXPECT_EQ(1u, feature2.extension_types()->count(Extension::TYPE_EXTENSION)); | |
| 384 EXPECT_EQ(1u, | |
| 385 feature2.contexts()->count(Feature::UNBLESSED_EXTENSION_CONTEXT)); | |
| 386 EXPECT_EQ(2, feature2.min_manifest_version()); | |
| 387 EXPECT_EQ(3, feature2.max_manifest_version()); | |
| 388 } | |
| 389 | |
| 390 TEST_F(ExtensionFeatureTest, Equals) { | |
| 391 Feature feature; | |
| 392 feature.whitelist()->insert("foo"); | |
| 393 feature.extension_types()->insert(Extension::TYPE_THEME); | |
| 394 feature.contexts()->insert(Feature::UNBLESSED_EXTENSION_CONTEXT); | |
| 395 feature.set_location(Feature::COMPONENT_LOCATION); | |
| 396 feature.set_platform(Feature::CHROMEOS_PLATFORM); | |
| 397 feature.set_min_manifest_version(18); | |
| 398 feature.set_max_manifest_version(25); | |
| 399 | |
| 400 Feature feature2(feature); | |
| 401 EXPECT_TRUE(feature2.Equals(feature)); | |
| 402 | |
| 403 feature2.whitelist()->clear(); | |
| 404 EXPECT_FALSE(feature2.Equals(feature)); | |
| 405 | |
| 406 feature2 = feature; | |
| 407 feature2.extension_types()->clear(); | |
| 408 EXPECT_FALSE(feature2.Equals(feature)); | |
| 409 | |
| 410 feature2 = feature; | |
| 411 feature2.contexts()->clear(); | |
| 412 EXPECT_FALSE(feature2.Equals(feature)); | |
| 413 | |
| 414 feature2 = feature; | |
| 415 feature2.set_location(Feature::UNSPECIFIED_LOCATION); | |
| 416 EXPECT_FALSE(feature2.Equals(feature)); | |
| 417 | |
| 418 feature2 = feature; | |
| 419 feature2.set_platform(Feature::UNSPECIFIED_PLATFORM); | |
| 420 EXPECT_FALSE(feature2.Equals(feature)); | |
| 421 | |
| 422 feature2 = feature; | |
| 423 feature2.set_min_manifest_version(0); | |
| 424 EXPECT_FALSE(feature2.Equals(feature)); | |
| 425 | |
| 426 feature2 = feature; | |
| 427 feature2.set_max_manifest_version(0); | |
| 428 EXPECT_FALSE(feature2.Equals(feature)); | |
| 429 } | |
| 430 | |
| 431 Feature::AvailabilityResult IsAvailableInChannel( | |
| 432 const std::string& channel, VersionInfo::Channel channel_for_testing) { | |
| 433 Feature::ScopedCurrentChannel current_channel(channel_for_testing); | |
| 434 | |
| 435 Feature feature; | |
| 436 if (!channel.empty()) { | |
| 437 DictionaryValue feature_value; | |
| 438 feature_value.SetString("channel", channel); | |
| 439 feature.Parse(&feature_value); | |
| 440 } | |
| 441 | |
| 442 return feature.IsAvailableToManifest( | |
| 443 "random-extension", | |
| 444 Extension::TYPE_UNKNOWN, | |
| 445 Feature::UNSPECIFIED_LOCATION, | |
| 446 -1).result(); | |
| 447 } | |
| 448 | |
| 449 TEST_F(ExtensionFeatureTest, SupportedChannel) { | |
| 450 // stable supported. | |
| 451 EXPECT_EQ(Feature::IS_AVAILABLE, | |
| 452 IsAvailableInChannel("stable", VersionInfo::CHANNEL_UNKNOWN)); | |
| 453 EXPECT_EQ(Feature::IS_AVAILABLE, | |
| 454 IsAvailableInChannel("stable", VersionInfo::CHANNEL_CANARY)); | |
| 455 EXPECT_EQ(Feature::IS_AVAILABLE, | |
| 456 IsAvailableInChannel("stable", VersionInfo::CHANNEL_DEV)); | |
| 457 EXPECT_EQ(Feature::IS_AVAILABLE, | |
| 458 IsAvailableInChannel("stable", VersionInfo::CHANNEL_BETA)); | |
| 459 EXPECT_EQ(Feature::IS_AVAILABLE, | |
| 460 IsAvailableInChannel("stable", VersionInfo::CHANNEL_STABLE)); | |
| 461 | |
| 462 // beta supported. | |
| 463 EXPECT_EQ(Feature::IS_AVAILABLE, | |
| 464 IsAvailableInChannel("beta", VersionInfo::CHANNEL_UNKNOWN)); | |
| 465 EXPECT_EQ(Feature::IS_AVAILABLE, | |
| 466 IsAvailableInChannel("beta", VersionInfo::CHANNEL_CANARY)); | |
| 467 EXPECT_EQ(Feature::IS_AVAILABLE, | |
| 468 IsAvailableInChannel("beta", VersionInfo::CHANNEL_DEV)); | |
| 469 EXPECT_EQ(Feature::IS_AVAILABLE, | |
| 470 IsAvailableInChannel("beta", VersionInfo::CHANNEL_BETA)); | |
| 471 EXPECT_EQ(Feature::UNSUPPORTED_CHANNEL, | |
| 472 IsAvailableInChannel("beta", VersionInfo::CHANNEL_STABLE)); | |
| 473 | |
| 474 // dev supported. | |
| 475 EXPECT_EQ(Feature::IS_AVAILABLE, | |
| 476 IsAvailableInChannel("dev", VersionInfo::CHANNEL_UNKNOWN)); | |
| 477 EXPECT_EQ(Feature::IS_AVAILABLE, | |
| 478 IsAvailableInChannel("dev", VersionInfo::CHANNEL_CANARY)); | |
| 479 EXPECT_EQ(Feature::IS_AVAILABLE, | |
| 480 IsAvailableInChannel("dev", VersionInfo::CHANNEL_DEV)); | |
| 481 EXPECT_EQ(Feature::UNSUPPORTED_CHANNEL, | |
| 482 IsAvailableInChannel("dev", VersionInfo::CHANNEL_BETA)); | |
| 483 EXPECT_EQ(Feature::UNSUPPORTED_CHANNEL, | |
| 484 IsAvailableInChannel("dev", VersionInfo::CHANNEL_STABLE)); | |
| 485 | |
| 486 // canary supported. | |
| 487 EXPECT_EQ(Feature::IS_AVAILABLE, | |
| 488 IsAvailableInChannel("canary", VersionInfo::CHANNEL_UNKNOWN)); | |
| 489 EXPECT_EQ(Feature::IS_AVAILABLE, | |
| 490 IsAvailableInChannel("canary", VersionInfo::CHANNEL_CANARY)); | |
| 491 EXPECT_EQ(Feature::UNSUPPORTED_CHANNEL, | |
| 492 IsAvailableInChannel("canary", VersionInfo::CHANNEL_DEV)); | |
| 493 EXPECT_EQ(Feature::UNSUPPORTED_CHANNEL, | |
| 494 IsAvailableInChannel("canary", VersionInfo::CHANNEL_BETA)); | |
| 495 EXPECT_EQ(Feature::UNSUPPORTED_CHANNEL, | |
| 496 IsAvailableInChannel("canary", VersionInfo::CHANNEL_STABLE)); | |
| 497 | |
| 498 // trunk supported. | |
| 499 EXPECT_EQ(Feature::IS_AVAILABLE, | |
| 500 IsAvailableInChannel("trunk", VersionInfo::CHANNEL_UNKNOWN)); | |
| 501 EXPECT_EQ(Feature::UNSUPPORTED_CHANNEL, | |
| 502 IsAvailableInChannel("trunk", VersionInfo::CHANNEL_CANARY)); | |
| 503 EXPECT_EQ(Feature::UNSUPPORTED_CHANNEL, | |
| 504 IsAvailableInChannel("trunk", VersionInfo::CHANNEL_DEV)); | |
| 505 EXPECT_EQ(Feature::UNSUPPORTED_CHANNEL, | |
| 506 IsAvailableInChannel("trunk", VersionInfo::CHANNEL_BETA)); | |
| 507 EXPECT_EQ(Feature::UNSUPPORTED_CHANNEL, | |
| 508 IsAvailableInChannel("trunk", VersionInfo::CHANNEL_STABLE)); | |
| 509 | |
| 510 // Default supported channel (trunk). | |
| 511 EXPECT_EQ(Feature::IS_AVAILABLE, | |
| 512 IsAvailableInChannel("", VersionInfo::CHANNEL_UNKNOWN)); | |
| 513 EXPECT_EQ(Feature::UNSUPPORTED_CHANNEL, | |
| 514 IsAvailableInChannel("", VersionInfo::CHANNEL_CANARY)); | |
| 515 EXPECT_EQ(Feature::UNSUPPORTED_CHANNEL, | |
| 516 IsAvailableInChannel("", VersionInfo::CHANNEL_DEV)); | |
| 517 EXPECT_EQ(Feature::UNSUPPORTED_CHANNEL, | |
| 518 IsAvailableInChannel("", VersionInfo::CHANNEL_BETA)); | |
| 519 EXPECT_EQ(Feature::UNSUPPORTED_CHANNEL, | |
| 520 IsAvailableInChannel("", VersionInfo::CHANNEL_STABLE)); | |
| 521 } | |
| 522 | |
| 523 } // namespace | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 11316164:
Implement ComplexFeature to support permission features with multiple rules. (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src