media/blink/key_system_config_selector_unittest.cc

   1 // Copyright 2015 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 <string>
   6 #include <vector>
   7
   8 #include "base/bind.h"
   9 #include "base/message_loop/message_loop.h"
  10 #include "base/run_loop.h"
  11 #include "media/base/eme_constants.h"
  12 #include "media/base/key_systems.h"
  13 #include "media/base/media_permission.h"
  14 #include "media/blink/key_system_config_selector.h"
  15 #include "testing/gtest/include/gtest/gtest.h"
  16 #include "third_party/WebKit/public/platform/WebEncryptedMediaTypes.h"
  17 #include "third_party/WebKit/public/platform/WebMediaKeySystemConfiguration.h"
  18 #include "third_party/WebKit/public/platform/WebSecurityOrigin.h"
  19 #include "third_party/WebKit/public/platform/WebString.h"
  20 #include "url/gurl.h"
  21
  22 namespace media {
  23
  24 namespace {
  25
  26 const char kSupported[] = "supported";
  27 const char kRecommendIdentifier[] = "recommend_identifier";
  28 const char kRequireIdentifier[] = "require_identifier";
  29 const char kUnsupported[] = "unsupported";
  30
  31 // TODO(sandersd): Audio and video variants (doesn't matter for now because the
  32 // checks are in KeySystems).
  33 const char kSupportedContainer[] = "video/webm";
  34 const char kUnsupportedContainer[] = "video/foo";
  35
  36 // TODO(sandersd): Extended codec variants (requires proprietary codec support).
  37 const char kSupportedCodec[] = "vp8";
  38 const char kUnsupportedCodec[] = "foo";
  39 const char kUnsupportedCodecs[] = "vp8,foo";
  40 const char kSupportedCodecs[] = "vp8,vp8";
  41
  42 const char kDefaultSecurityOrigin[] = "https://example.com/";
  43
  44 class FakeKeySystems : public KeySystems {
  45  public:
  46   ~FakeKeySystems() override {
  47   }
  48
  49   bool IsSupportedKeySystem(const std::string& key_system) const override {
  50     if (key_system == kSupported)
  51       return true;
  52     return false;
  53   }
  54
  55   // TODO(sandersd): Move implementation into KeySystemConfigSelector?
  56   bool IsSupportedInitDataType(const std::string& key_system,
  57                                EmeInitDataType init_data_type) const override {
  58     switch (init_data_type) {
  59       case EmeInitDataType::UNKNOWN:
  60         return false;
  61       case EmeInitDataType::WEBM:
  62         return (init_data_types & kInitDataTypeMaskWebM) != 0;
  63       case EmeInitDataType::CENC:
  64         return (init_data_types & kInitDataTypeMaskCenc) != 0;
  65       case EmeInitDataType::KEYIDS:
  66         return (init_data_types & kInitDataTypeMaskKeyIds) != 0;
  67     }
  68     NOTREACHED();
  69     return false;
  70   }
  71
  72   bool IsSupportedCodecCombination(
  73       const std::string& key_system,
  74       EmeMediaType media_type,
  75       const std::string& container_mime_type,
  76       const std::vector<std::string>& codecs) const override {
  77     if (container_mime_type == kUnsupportedContainer)
  78       return false;
  79     DCHECK_EQ(kSupportedContainer, container_mime_type);
  80     for (const std::string& codec : codecs) {
  81       if (codec == kUnsupportedCodec)
  82         return false;
  83       DCHECK_EQ(kSupportedCodec, codec);
  84     }
  85     return true;
  86   }
  87
  88   EmeConfigRule GetRobustnessConfigRule(
  89       const std::string& key_system,
  90       EmeMediaType media_type,
  91       const std::string& requested_robustness) const override {
  92     if (requested_robustness == kUnsupported)
  93       return EmeConfigRule::NOT_SUPPORTED;
  94     if (requested_robustness == kRequireIdentifier)
  95       return EmeConfigRule::IDENTIFIER_REQUIRED;
  96     if (requested_robustness == kRecommendIdentifier)
  97       return EmeConfigRule::IDENTIFIER_RECOMMENDED;
  98     if (requested_robustness == kSupported)
  99       return EmeConfigRule::SUPPORTED;
 100     NOTREACHED();
 101     return EmeConfigRule::NOT_SUPPORTED;
 102   }
 103
 104   EmeSessionTypeSupport GetPersistentLicenseSessionSupport(
 105       const std::string& key_system) const override {
 106     return persistent_license;
 107   }
 108
 109   EmeSessionTypeSupport GetPersistentReleaseMessageSessionSupport(
 110       const std::string& key_system) const override {
 111     return persistent_release_message;
 112   }
 113
 114   EmeFeatureSupport GetPersistentStateSupport(
 115       const std::string& key_system) const override {
 116     return persistent_state;
 117   }
 118
 119   EmeFeatureSupport GetDistinctiveIdentifierSupport(
 120       const std::string& key_system) const override {
 121     return distinctive_identifier;
 122   }
 123
 124   InitDataTypeMask init_data_types = kInitDataTypeMaskNone;
 125
 126   // INVALID so that they must be set in any test that needs them.
 127   EmeSessionTypeSupport persistent_license = EmeSessionTypeSupport::INVALID;
 128   EmeSessionTypeSupport persistent_release_message =
 129       EmeSessionTypeSupport::INVALID;
 130
 131   // Every test implicitly requires these, so they must be set. They are set to
 132   // values that are likely to cause tests to fail if they are accidentally
 133   // depended on. Test cases explicitly depending on them should set them, as
 134   // the default values may be changed.
 135   EmeFeatureSupport persistent_state = EmeFeatureSupport::NOT_SUPPORTED;
 136   EmeFeatureSupport distinctive_identifier = EmeFeatureSupport::REQUESTABLE;
 137 };
 138
 139 class FakeMediaPermission : public MediaPermission {
 140  public:
 141   void HasPermission(Type type,
 142                      const GURL& security_origin,
 143                      const PermissionStatusCB& permission_status_cb) override {
 144     permission_status_cb.Run(is_granted);
 145   }
 146
 147   void RequestPermission(
 148       Type type,
 149       const GURL& security_origin,
 150       const PermissionStatusCB& permission_status_cb) override {
 151     requests++;
 152     permission_status_cb.Run(is_granted);
 153   }
 154
 155   int requests = 0;
 156   bool is_granted = false;
 157 };
 158
 159 }  // namespace
 160
 161 class KeySystemConfigSelectorTest : public testing::Test {
 162  public:
 163   KeySystemConfigSelectorTest()
 164       : key_systems_(new FakeKeySystems()),
 165         media_permission_(new FakeMediaPermission()) {}
 166
 167   void SelectConfig() {
 168     media_permission_->requests = 0;
 169     succeeded_count_ = 0;
 170     not_supported_count_ = 0;
 171     KeySystemConfigSelector(key_systems_.get(), media_permission_.get())
 172         .SelectConfig(key_system_, configs_, security_origin_,
 173                       base::Bind(&KeySystemConfigSelectorTest::OnSucceeded,
 174                                  base::Unretained(this)),
 175                       base::Bind(&KeySystemConfigSelectorTest::OnNotSupported,
 176                                  base::Unretained(this)));
 177   }
 178
 179   bool SelectConfigReturnsConfig() {
 180     SelectConfig();
 181     EXPECT_EQ(0, media_permission_->requests);
 182     EXPECT_EQ(1, succeeded_count_);
 183     EXPECT_EQ(0, not_supported_count_);
 184     return (succeeded_count_ != 0);
 185   }
 186
 187   bool SelectConfigReturnsError() {
 188     SelectConfig();
 189     EXPECT_EQ(0, media_permission_->requests);
 190     EXPECT_EQ(0, succeeded_count_);
 191     EXPECT_EQ(1, not_supported_count_);
 192     return (not_supported_count_ != 0);
 193   }
 194
 195   bool SelectConfigRequestsPermissionAndReturnsConfig() {
 196     SelectConfig();
 197     EXPECT_EQ(1, media_permission_->requests);
 198     EXPECT_EQ(1, succeeded_count_);
 199     EXPECT_EQ(0, not_supported_count_);
 200     return (media_permission_->requests != 0 && succeeded_count_ != 0);
 201   }
 202
 203   bool SelectConfigRequestsPermissionAndReturnsError() {
 204     SelectConfig();
 205     EXPECT_EQ(1, media_permission_->requests);
 206     EXPECT_EQ(0, succeeded_count_);
 207     EXPECT_EQ(1, not_supported_count_);
 208     return (media_permission_->requests != 0 && not_supported_count_ != 0);
 209   }
 210
 211   void OnSucceeded(const blink::WebMediaKeySystemConfiguration& result) {
 212     succeeded_count_++;
 213     config_ = result;
 214   }
 215
 216   void OnNotSupported(const blink::WebString&) { not_supported_count_++; }
 217
 218   scoped_ptr<FakeKeySystems> key_systems_;
 219   scoped_ptr<FakeMediaPermission> media_permission_;
 220
 221   // Held values for the call to SelectConfig().
 222   blink::WebString key_system_ = blink::WebString::fromUTF8(kSupported);
 223   std::vector<blink::WebMediaKeySystemConfiguration> configs_;
 224   blink::WebSecurityOrigin security_origin_ =
 225       blink::WebSecurityOrigin::createFromString(kDefaultSecurityOrigin);
 226
 227   // Holds the last successful accumulated configuration.
 228   blink::WebMediaKeySystemConfiguration config_;
 229
 230   int succeeded_count_;
 231   int not_supported_count_;
 232
 233   DISALLOW_COPY_AND_ASSIGN(KeySystemConfigSelectorTest);
 234 };
 235
 236 // --- Basics ---
 237
 238 TEST_F(KeySystemConfigSelectorTest, NoConfigs) {
 239   ASSERT_TRUE(SelectConfigReturnsError());
 240 }
 241
 242 // Most of the tests below assume that an empty config is valid.
 243 TEST_F(KeySystemConfigSelectorTest, EmptyConfig) {
 244   configs_.push_back(blink::WebMediaKeySystemConfiguration());
 245
 246   ASSERT_TRUE(SelectConfigReturnsConfig());
 247   EXPECT_TRUE(config_.label.isNull());
 248   EXPECT_TRUE(config_.initDataTypes.isEmpty());
 249   EXPECT_TRUE(config_.audioCapabilities.isEmpty());
 250   EXPECT_TRUE(config_.videoCapabilities.isEmpty());
 251   EXPECT_EQ(blink::WebMediaKeySystemConfiguration::Requirement::NotAllowed,
 252             config_.distinctiveIdentifier);
 253   EXPECT_EQ(blink::WebMediaKeySystemConfiguration::Requirement::NotAllowed,
 254             config_.persistentState);
 255   ASSERT_EQ(1u, config_.sessionTypes.size());
 256   EXPECT_EQ(blink::WebEncryptedMediaSessionType::Temporary,
 257             config_.sessionTypes[0]);
 258 }
 259
 260 TEST_F(KeySystemConfigSelectorTest, Label) {
 261   blink::WebMediaKeySystemConfiguration config;
 262   config.label = "foo";
 263   configs_.push_back(config);
 264
 265   ASSERT_TRUE(SelectConfigReturnsConfig());
 266   EXPECT_EQ("foo", config_.label);
 267 }
 268
 269 // --- keySystem ---
 270 // Empty is not tested because the empty check is in Blink.
 271
 272 TEST_F(KeySystemConfigSelectorTest, KeySystem_NonAscii) {
 273   key_system_ = "\xde\xad\xbe\xef";
 274   configs_.push_back(blink::WebMediaKeySystemConfiguration());
 275   ASSERT_TRUE(SelectConfigReturnsError());
 276 }
 277
 278 TEST_F(KeySystemConfigSelectorTest, KeySystem_Unsupported) {
 279   key_system_ = kUnsupported;
 280   configs_.push_back(blink::WebMediaKeySystemConfiguration());
 281   ASSERT_TRUE(SelectConfigReturnsError());
 282 }
 283
 284 // --- initDataTypes ---
 285
 286 TEST_F(KeySystemConfigSelectorTest, InitDataTypes_Empty) {
 287   blink::WebMediaKeySystemConfiguration config;
 288   config.hasInitDataTypes = true;
 289   configs_.push_back(config);
 290
 291   ASSERT_TRUE(SelectConfigReturnsError());
 292 }
 293
 294 TEST_F(KeySystemConfigSelectorTest, InitDataTypes_NoneSupported) {
 295   key_systems_->init_data_types = kInitDataTypeMaskWebM;
 296
 297   std::vector<blink::WebEncryptedMediaInitDataType> init_data_types;
 298   init_data_types.push_back(blink::WebEncryptedMediaInitDataType::Unknown);
 299   init_data_types.push_back(blink::WebEncryptedMediaInitDataType::Cenc);
 300
 301   blink::WebMediaKeySystemConfiguration config;
 302   config.hasInitDataTypes = true;
 303   config.initDataTypes = init_data_types;
 304   configs_.push_back(config);
 305
 306   ASSERT_TRUE(SelectConfigReturnsError());
 307 }
 308
 309 TEST_F(KeySystemConfigSelectorTest, InitDataTypes_SubsetSupported) {
 310   key_systems_->init_data_types = kInitDataTypeMaskWebM;
 311
 312   std::vector<blink::WebEncryptedMediaInitDataType> init_data_types;
 313   init_data_types.push_back(blink::WebEncryptedMediaInitDataType::Unknown);
 314   init_data_types.push_back(blink::WebEncryptedMediaInitDataType::Cenc);
 315   init_data_types.push_back(blink::WebEncryptedMediaInitDataType::Webm);
 316
 317   blink::WebMediaKeySystemConfiguration config;
 318   config.hasInitDataTypes = true;
 319   config.initDataTypes = init_data_types;
 320   configs_.push_back(config);
 321
 322   ASSERT_TRUE(SelectConfigReturnsConfig());
 323   ASSERT_EQ(1u, config_.initDataTypes.size());
 324   EXPECT_EQ(blink::WebEncryptedMediaInitDataType::Webm,
 325             config_.initDataTypes[0]);
 326 }
 327
 328 // --- distinctiveIdentifier ---
 329
 330 TEST_F(KeySystemConfigSelectorTest, DistinctiveIdentifier_Default) {
 331   key_systems_->distinctive_identifier = EmeFeatureSupport::REQUESTABLE;
 332
 333   blink::WebMediaKeySystemConfiguration config;
 334   config.distinctiveIdentifier =
 335       blink::WebMediaKeySystemConfiguration::Requirement::Optional;
 336   configs_.push_back(config);
 337
 338   ASSERT_TRUE(SelectConfigReturnsConfig());
 339   EXPECT_EQ(blink::WebMediaKeySystemConfiguration::Requirement::NotAllowed,
 340             config_.distinctiveIdentifier);
 341 }
 342
 343 TEST_F(KeySystemConfigSelectorTest, DistinctiveIdentifier_Forced) {
 344   media_permission_->is_granted = true;
 345   key_systems_->distinctive_identifier = EmeFeatureSupport::ALWAYS_ENABLED;
 346
 347   blink::WebMediaKeySystemConfiguration config;
 348   config.distinctiveIdentifier =
 349       blink::WebMediaKeySystemConfiguration::Requirement::Optional;
 350   configs_.push_back(config);
 351
 352   ASSERT_TRUE(SelectConfigRequestsPermissionAndReturnsConfig());
 353   EXPECT_EQ(blink::WebMediaKeySystemConfiguration::Requirement::Required,
 354             config_.distinctiveIdentifier);
 355 }
 356
 357 TEST_F(KeySystemConfigSelectorTest, DistinctiveIdentifier_Blocked) {
 358   key_systems_->distinctive_identifier = EmeFeatureSupport::NOT_SUPPORTED;
 359
 360   blink::WebMediaKeySystemConfiguration config;
 361   config.distinctiveIdentifier =
 362       blink::WebMediaKeySystemConfiguration::Requirement::Required;
 363   configs_.push_back(config);
 364
 365   ASSERT_TRUE(SelectConfigReturnsError());
 366 }
 367
 368 TEST_F(KeySystemConfigSelectorTest, DistinctiveIdentifier_RequestsPermission) {
 369   media_permission_->is_granted = true;
 370   key_systems_->distinctive_identifier = EmeFeatureSupport::REQUESTABLE;
 371
 372   blink::WebMediaKeySystemConfiguration config;
 373   config.distinctiveIdentifier =
 374       blink::WebMediaKeySystemConfiguration::Requirement::Required;
 375   configs_.push_back(config);
 376
 377   ASSERT_TRUE(SelectConfigRequestsPermissionAndReturnsConfig());
 378   EXPECT_EQ(blink::WebMediaKeySystemConfiguration::Requirement::Required,
 379             config_.distinctiveIdentifier);
 380 }
 381
 382 TEST_F(KeySystemConfigSelectorTest, DistinctiveIdentifier_RespectsPermission) {
 383   media_permission_->is_granted = false;
 384   key_systems_->distinctive_identifier = EmeFeatureSupport::REQUESTABLE;
 385
 386   blink::WebMediaKeySystemConfiguration config;
 387   config.distinctiveIdentifier =
 388       blink::WebMediaKeySystemConfiguration::Requirement::Required;
 389   configs_.push_back(config);
 390
 391   ASSERT_TRUE(SelectConfigRequestsPermissionAndReturnsError());
 392 }
 393
 394 // --- persistentState ---
 395
 396 TEST_F(KeySystemConfigSelectorTest, PersistentState_Default) {
 397   key_systems_->persistent_state = EmeFeatureSupport::REQUESTABLE;
 398
 399   blink::WebMediaKeySystemConfiguration config;
 400   config.persistentState =
 401       blink::WebMediaKeySystemConfiguration::Requirement::Optional;
 402   configs_.push_back(config);
 403
 404   ASSERT_TRUE(SelectConfigReturnsConfig());
 405   EXPECT_EQ(blink::WebMediaKeySystemConfiguration::Requirement::NotAllowed,
 406             config_.persistentState);
 407 }
 408
 409 TEST_F(KeySystemConfigSelectorTest, PersistentState_Forced) {
 410   key_systems_->persistent_state = EmeFeatureSupport::ALWAYS_ENABLED;
 411
 412   blink::WebMediaKeySystemConfiguration config;
 413   config.persistentState =
 414       blink::WebMediaKeySystemConfiguration::Requirement::Optional;
 415   configs_.push_back(config);
 416
 417   ASSERT_TRUE(SelectConfigReturnsConfig());
 418   EXPECT_EQ(blink::WebMediaKeySystemConfiguration::Requirement::Required,
 419             config_.persistentState);
 420 }
 421
 422 TEST_F(KeySystemConfigSelectorTest, PersistentState_Blocked) {
 423   key_systems_->persistent_state = EmeFeatureSupport::ALWAYS_ENABLED;
 424
 425   blink::WebMediaKeySystemConfiguration config;
 426   config.persistentState =
 427       blink::WebMediaKeySystemConfiguration::Requirement::NotAllowed;
 428   configs_.push_back(config);
 429
 430   ASSERT_TRUE(SelectConfigReturnsError());
 431 }
 432
 433 // --- sessionTypes ---
 434
 435 TEST_F(KeySystemConfigSelectorTest, SessionTypes_Empty) {
 436   blink::WebMediaKeySystemConfiguration config;
 437   config.hasSessionTypes = true;
 438   configs_.push_back(config);
 439
 440   ASSERT_TRUE(SelectConfigReturnsConfig());
 441   EXPECT_TRUE(config_.sessionTypes.isEmpty());
 442 }
 443
 444 TEST_F(KeySystemConfigSelectorTest, SessionTypes_SubsetSupported) {
 445   // Allow persistent state, as it would be required to be successful.
 446   key_systems_->persistent_state = EmeFeatureSupport::REQUESTABLE;
 447   key_systems_->persistent_license = EmeSessionTypeSupport::NOT_SUPPORTED;
 448
 449   std::vector<blink::WebEncryptedMediaSessionType> session_types;
 450   session_types.push_back(blink::WebEncryptedMediaSessionType::Temporary);
 451   session_types.push_back(
 452       blink::WebEncryptedMediaSessionType::PersistentLicense);
 453
 454   blink::WebMediaKeySystemConfiguration config;
 455   config.hasSessionTypes = true;
 456   config.sessionTypes = session_types;
 457   configs_.push_back(config);
 458
 459   ASSERT_TRUE(SelectConfigReturnsError());
 460 }
 461
 462 TEST_F(KeySystemConfigSelectorTest, SessionTypes_AllSupported) {
 463   // Allow persistent state, and expect it to be required.
 464   key_systems_->persistent_state = EmeFeatureSupport::REQUESTABLE;
 465   key_systems_->persistent_license = EmeSessionTypeSupport::SUPPORTED;
 466
 467   std::vector<blink::WebEncryptedMediaSessionType> session_types;
 468   session_types.push_back(blink::WebEncryptedMediaSessionType::Temporary);
 469   session_types.push_back(
 470       blink::WebEncryptedMediaSessionType::PersistentLicense);
 471
 472   blink::WebMediaKeySystemConfiguration config;
 473   config.persistentState =
 474       blink::WebMediaKeySystemConfiguration::Requirement::Optional;
 475   config.hasSessionTypes = true;
 476   config.sessionTypes = session_types;
 477   configs_.push_back(config);
 478
 479   ASSERT_TRUE(SelectConfigReturnsConfig());
 480   EXPECT_EQ(blink::WebMediaKeySystemConfiguration::Requirement::Required,
 481             config_.persistentState);
 482   ASSERT_EQ(2u, config_.sessionTypes.size());
 483   EXPECT_EQ(blink::WebEncryptedMediaSessionType::Temporary,
 484             config_.sessionTypes[0]);
 485   EXPECT_EQ(blink::WebEncryptedMediaSessionType::PersistentLicense,
 486             config_.sessionTypes[1]);
 487 }
 488
 489 TEST_F(KeySystemConfigSelectorTest, SessionTypes_PermissionCanBeRequired) {
 490   media_permission_->is_granted = true;
 491   key_systems_->distinctive_identifier = EmeFeatureSupport::REQUESTABLE;
 492   key_systems_->persistent_state = EmeFeatureSupport::REQUESTABLE;
 493   key_systems_->persistent_license =
 494       EmeSessionTypeSupport::SUPPORTED_WITH_IDENTIFIER;
 495
 496   std::vector<blink::WebEncryptedMediaSessionType> session_types;
 497   session_types.push_back(
 498       blink::WebEncryptedMediaSessionType::PersistentLicense);
 499
 500   blink::WebMediaKeySystemConfiguration config;
 501   config.distinctiveIdentifier =
 502       blink::WebMediaKeySystemConfiguration::Requirement::Optional;
 503   config.persistentState =
 504       blink::WebMediaKeySystemConfiguration::Requirement::Optional;
 505   config.hasSessionTypes = true;
 506   config.sessionTypes = session_types;
 507   configs_.push_back(config);
 508
 509   ASSERT_TRUE(SelectConfigRequestsPermissionAndReturnsConfig());
 510   EXPECT_EQ(blink::WebMediaKeySystemConfiguration::Requirement::Required,
 511             config_.distinctiveIdentifier);
 512 }
 513
 514 // --- videoCapabilities ---
 515
 516 TEST_F(KeySystemConfigSelectorTest, VideoCapabilities_Empty) {
 517   blink::WebMediaKeySystemConfiguration config;
 518   config.hasVideoCapabilities = true;
 519   configs_.push_back(config);
 520
 521   ASSERT_TRUE(SelectConfigReturnsError());
 522 }
 523
 524 TEST_F(KeySystemConfigSelectorTest, VideoCapabilities_NoneSupported) {
 525   std::vector<blink::WebMediaKeySystemMediaCapability> video_capabilities(2);
 526   video_capabilities[0].contentType = "a";
 527   video_capabilities[0].mimeType = kUnsupportedContainer;
 528   video_capabilities[1].contentType = "b";
 529   video_capabilities[1].mimeType = kSupportedContainer;
 530   video_capabilities[1].codecs = kUnsupportedCodec;
 531
 532   blink::WebMediaKeySystemConfiguration config;
 533   config.hasVideoCapabilities = true;
 534   config.videoCapabilities = video_capabilities;
 535   configs_.push_back(config);
 536
 537   ASSERT_TRUE(SelectConfigReturnsError());
 538 }
 539
 540 TEST_F(KeySystemConfigSelectorTest, VideoCapabilities_SubsetSupported) {
 541   std::vector<blink::WebMediaKeySystemMediaCapability> video_capabilities(2);
 542   video_capabilities[0].contentType = "a";
 543   video_capabilities[0].mimeType = kUnsupportedContainer;
 544   video_capabilities[1].contentType = "b";
 545   video_capabilities[1].mimeType = kSupportedContainer;
 546
 547   blink::WebMediaKeySystemConfiguration config;
 548   config.hasVideoCapabilities = true;
 549   config.videoCapabilities = video_capabilities;
 550   configs_.push_back(config);
 551
 552   ASSERT_TRUE(SelectConfigReturnsConfig());
 553   ASSERT_EQ(1u, config_.videoCapabilities.size());
 554   EXPECT_EQ("b", config_.videoCapabilities[0].contentType);
 555   EXPECT_EQ(kSupportedContainer, config_.videoCapabilities[0].mimeType);
 556 }
 557
 558 TEST_F(KeySystemConfigSelectorTest, VideoCapabilities_AllSupported) {
 559   std::vector<blink::WebMediaKeySystemMediaCapability> video_capabilities(2);
 560   video_capabilities[0].contentType = "a";
 561   video_capabilities[0].mimeType = kSupportedContainer;
 562   video_capabilities[1].contentType = "b";
 563   video_capabilities[1].mimeType = kSupportedContainer;
 564   video_capabilities[1].codecs = kSupportedCodecs;
 565
 566   blink::WebMediaKeySystemConfiguration config;
 567   config.hasVideoCapabilities = true;
 568   config.videoCapabilities = video_capabilities;
 569   configs_.push_back(config);
 570
 571   ASSERT_TRUE(SelectConfigReturnsConfig());
 572   ASSERT_EQ(2u, config_.videoCapabilities.size());
 573   EXPECT_EQ("a", config_.videoCapabilities[0].contentType);
 574   EXPECT_EQ("b", config_.videoCapabilities[1].contentType);
 575 }
 576
 577 TEST_F(KeySystemConfigSelectorTest,
 578        VideoCapabilities_Codecs_SubsetSupported) {
 579   std::vector<blink::WebMediaKeySystemMediaCapability> video_capabilities(1);
 580   video_capabilities[0].contentType = "a";
 581   video_capabilities[0].mimeType = kSupportedContainer;
 582   video_capabilities[0].codecs = kUnsupportedCodecs;
 583
 584   blink::WebMediaKeySystemConfiguration config;
 585   config.hasVideoCapabilities = true;
 586   config.videoCapabilities = video_capabilities;
 587   configs_.push_back(config);
 588
 589   ASSERT_TRUE(SelectConfigReturnsError());
 590 }
 591
 592 TEST_F(KeySystemConfigSelectorTest, VideoCapabilities_Codecs_AllSupported) {
 593   std::vector<blink::WebMediaKeySystemMediaCapability> video_capabilities(1);
 594   video_capabilities[0].contentType = "a";
 595   video_capabilities[0].mimeType = kSupportedContainer;
 596   video_capabilities[0].codecs = kSupportedCodecs;
 597
 598   blink::WebMediaKeySystemConfiguration config;
 599   config.hasVideoCapabilities = true;
 600   config.videoCapabilities = video_capabilities;
 601   configs_.push_back(config);
 602
 603   ASSERT_TRUE(SelectConfigReturnsConfig());
 604   ASSERT_EQ(1u, config_.videoCapabilities.size());
 605   EXPECT_EQ(kSupportedCodecs, config_.videoCapabilities[0].codecs);
 606 }
 607
 608 TEST_F(KeySystemConfigSelectorTest, VideoCapabilities_Robustness_Supported) {
 609   std::vector<blink::WebMediaKeySystemMediaCapability> video_capabilities(1);
 610   video_capabilities[0].contentType = "a";
 611   video_capabilities[0].mimeType = kSupportedContainer;
 612   video_capabilities[0].robustness = kSupported;
 613
 614   blink::WebMediaKeySystemConfiguration config;
 615   config.hasVideoCapabilities = true;
 616   config.videoCapabilities = video_capabilities;
 617   configs_.push_back(config);
 618
 619   ASSERT_TRUE(SelectConfigReturnsConfig());
 620   ASSERT_EQ(1u, config_.videoCapabilities.size());
 621   EXPECT_EQ(kSupported, config_.videoCapabilities[0].robustness);
 622 }
 623
 624 TEST_F(KeySystemConfigSelectorTest, VideoCapabilities_Robustness_Unsupported) {
 625   std::vector<blink::WebMediaKeySystemMediaCapability> video_capabilities(1);
 626   video_capabilities[0].contentType = "a";
 627   video_capabilities[0].mimeType = kSupportedContainer;
 628   video_capabilities[0].robustness = kUnsupported;
 629
 630   blink::WebMediaKeySystemConfiguration config;
 631   config.hasVideoCapabilities = true;
 632   config.videoCapabilities = video_capabilities;
 633   configs_.push_back(config);
 634
 635   ASSERT_TRUE(SelectConfigReturnsError());
 636 }
 637
 638 TEST_F(KeySystemConfigSelectorTest,
 639        VideoCapabilities_Robustness_PermissionCanBeRequired) {
 640   media_permission_->is_granted = true;
 641   key_systems_->distinctive_identifier = EmeFeatureSupport::REQUESTABLE;
 642
 643   std::vector<blink::WebMediaKeySystemMediaCapability> video_capabilities(1);
 644   video_capabilities[0].contentType = "a";
 645   video_capabilities[0].mimeType = kSupportedContainer;
 646   video_capabilities[0].robustness = kRequireIdentifier;
 647
 648   blink::WebMediaKeySystemConfiguration config;
 649   config.hasVideoCapabilities = true;
 650   config.videoCapabilities = video_capabilities;
 651   configs_.push_back(config);
 652
 653   ASSERT_TRUE(SelectConfigRequestsPermissionAndReturnsConfig());
 654   EXPECT_EQ(blink::WebMediaKeySystemConfiguration::Requirement::Required,
 655             config_.distinctiveIdentifier);
 656 }
 657
 658 TEST_F(KeySystemConfigSelectorTest,
 659        VideoCapabilities_Robustness_PermissionCanBeRecommended) {
 660   media_permission_->is_granted = false;
 661   key_systems_->distinctive_identifier = EmeFeatureSupport::REQUESTABLE;
 662
 663   std::vector<blink::WebMediaKeySystemMediaCapability> video_capabilities(1);
 664   video_capabilities[0].contentType = "a";
 665   video_capabilities[0].mimeType = kSupportedContainer;
 666   video_capabilities[0].robustness = kRecommendIdentifier;
 667
 668   blink::WebMediaKeySystemConfiguration config;
 669   config.hasVideoCapabilities = true;
 670   config.videoCapabilities = video_capabilities;
 671   configs_.push_back(config);
 672
 673   ASSERT_TRUE(SelectConfigRequestsPermissionAndReturnsConfig());
 674   EXPECT_EQ(blink::WebMediaKeySystemConfiguration::Requirement::NotAllowed,
 675             config_.distinctiveIdentifier);
 676 }
 677
 678 // --- audioCapabilities ---
 679 // These are handled by the same code as |videoCapabilities|, so only minimal
 680 // additional testing is done.
 681
 682 TEST_F(KeySystemConfigSelectorTest, AudioCapabilities_SubsetSupported) {
 683   std::vector<blink::WebMediaKeySystemMediaCapability> audio_capabilities(2);
 684   audio_capabilities[0].contentType = "a";
 685   audio_capabilities[0].mimeType = kUnsupportedContainer;
 686   audio_capabilities[1].contentType = "b";
 687   audio_capabilities[1].mimeType = kSupportedContainer;
 688
 689   blink::WebMediaKeySystemConfiguration config;
 690   config.hasAudioCapabilities = true;
 691   config.audioCapabilities = audio_capabilities;
 692   configs_.push_back(config);
 693
 694   ASSERT_TRUE(SelectConfigReturnsConfig());
 695   ASSERT_EQ(1u, config_.audioCapabilities.size());
 696   EXPECT_EQ("b", config_.audioCapabilities[0].contentType);
 697   EXPECT_EQ(kSupportedContainer, config_.audioCapabilities[0].mimeType);
 698 }
 699
 700 // --- Multiple configurations ---
 701
 702 TEST_F(KeySystemConfigSelectorTest, Configurations_AllSupported) {
 703   blink::WebMediaKeySystemConfiguration config;
 704   config.label = "a";
 705   configs_.push_back(config);
 706   config.label = "b";
 707   configs_.push_back(config);
 708
 709   ASSERT_TRUE(SelectConfigReturnsConfig());
 710   ASSERT_EQ("a", config_.label);
 711 }
 712
 713 TEST_F(KeySystemConfigSelectorTest, Configurations_SubsetSupported) {
 714   blink::WebMediaKeySystemConfiguration config1;
 715   config1.label = "a";
 716   config1.hasInitDataTypes = true;
 717   configs_.push_back(config1);
 718
 719   blink::WebMediaKeySystemConfiguration config2;
 720   config2.label = "b";
 721   configs_.push_back(config2);
 722
 723   ASSERT_TRUE(SelectConfigReturnsConfig());
 724   ASSERT_EQ("b", config_.label);
 725 }
 726
 727 TEST_F(KeySystemConfigSelectorTest,
 728        Configurations_FirstRequiresPermission_Allowed) {
 729   media_permission_->is_granted = true;
 730   key_systems_->distinctive_identifier = EmeFeatureSupport::REQUESTABLE;
 731
 732   blink::WebMediaKeySystemConfiguration config1;
 733   config1.label = "a";
 734   config1.distinctiveIdentifier =
 735       blink::WebMediaKeySystemConfiguration::Requirement::Required;
 736   configs_.push_back(config1);
 737
 738   blink::WebMediaKeySystemConfiguration config2;
 739   config2.label = "b";
 740   configs_.push_back(config2);
 741
 742   ASSERT_TRUE(SelectConfigRequestsPermissionAndReturnsConfig());
 743   ASSERT_EQ("a", config_.label);
 744 }
 745
 746 TEST_F(KeySystemConfigSelectorTest,
 747        Configurations_FirstRequiresPermission_Rejected) {
 748   media_permission_->is_granted = false;
 749   key_systems_->distinctive_identifier = EmeFeatureSupport::REQUESTABLE;
 750
 751   blink::WebMediaKeySystemConfiguration config1;
 752   config1.label = "a";
 753   config1.distinctiveIdentifier =
 754       blink::WebMediaKeySystemConfiguration::Requirement::Required;
 755   configs_.push_back(config1);
 756
 757   blink::WebMediaKeySystemConfiguration config2;
 758   config2.label = "b";
 759   configs_.push_back(config2);
 760
 761   ASSERT_TRUE(SelectConfigRequestsPermissionAndReturnsConfig());
 762   ASSERT_EQ("b", config_.label);
 763 }
 764
 765 }  // namespace media