content/renderer/media/crypto/key_systems_unittest.cc

   1 // Copyright 2013 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 "content/public/common/content_client.h"
   9 #include "content/public/renderer/content_renderer_client.h"
  10 #include "content/public/renderer/key_system_info.h"
  11 #include "content/renderer/media/crypto/key_systems.h"
  12 #include "content/test/test_content_client.h"
  13 #include "testing/gtest/include/gtest/gtest.h"
  14 #include "third_party/WebKit/public/platform/WebString.h"
  15
  16 #include "widevine_cdm_version.h"  // In SHARED_INTERMEDIATE_DIR.
  17
  18 // Death tests are not always available, including on Android.
  19 // EXPECT_DEBUG_DEATH_PORTABLE executes tests correctly except in the case that
  20 // death tests are not available and NDEBUG is not defined.
  21 #if defined(GTEST_HAS_DEATH_TEST) && !defined(OS_ANDROID)
  22 #define EXPECT_DEBUG_DEATH_PORTABLE(statement, regex) \
  23   EXPECT_DEBUG_DEATH(statement, regex)
  24 #else
  25 #if defined(NDEBUG)
  26 #define EXPECT_DEBUG_DEATH_PORTABLE(statement, regex) \
  27   do { statement; } while (false)
  28 #else
  29 #include "base/logging.h"
  30 #define EXPECT_DEBUG_DEATH_PORTABLE(statement, regex) \
  31   LOG(WARNING) << "Death tests are not supported on this platform.\n" \
  32                << "Statement '" #statement "' cannot be verified.";
  33 #endif  // defined(NDEBUG)
  34 #endif  // defined(GTEST_HAS_DEATH_TEST) && !defined(OS_ANDROID)
  35
  36 namespace content {
  37
  38 using blink::WebString;
  39
  40 // These are the (fake) key systems that are registered for these tests.
  41 // kUsesAes uses the AesDecryptor like Clear Key.
  42 // kExternal uses an external CDM, such as Pepper-based or Android platform CDM.
  43 const char kUsesAes[] = "org.example.clear";
  44 const char kUsesAesParent[] = "org.example";  // Not registered.
  45 const char kExternal[] = "com.example.test";
  46 const char kExternalParent[] = "com.example";
  47
  48 const char kClearKey[] = "org.w3.clearkey";
  49 const char kPrefixedClearKey[] = "webkit-org.w3.clearkey";
  50 const char kExternalClearKey[] = "org.chromium.externalclearkey";
  51
  52 const char kAudioWebM[] = "audio/webm";
  53 const char kVideoWebM[] = "video/webm";
  54 const char kAudioFoo[] = "audio/foo";
  55 const char kVideoFoo[] = "video/foo";
  56
  57 // Pick some arbitrary bit fields as long as they are not in conflict with the
  58 // real ones.
  59 enum TestCodec {
  60   TEST_CODEC_FOO_AUDIO = 1 << 10,  // An audio codec for foo container.
  61   TEST_CODEC_FOO_AUDIO_ALL = TEST_CODEC_FOO_AUDIO,
  62   TEST_CODEC_FOO_VIDEO = 1 << 11,  // A video codec for foo container.
  63   TEST_CODEC_FOO_VIDEO_ALL = TEST_CODEC_FOO_VIDEO,
  64   TEST_CODEC_FOO_ALL = TEST_CODEC_FOO_AUDIO_ALL | TEST_CODEC_FOO_VIDEO_ALL
  65 };
  66
  67 COMPILE_ASSERT((TEST_CODEC_FOO_ALL & EME_CODEC_ALL) == EME_CODEC_NONE,
  68                 test_codec_masks_should_only_use_invalid_codec_masks);
  69
  70 // Adds test container and codec masks.
  71 // This function must be called after SetContentClient() is called.
  72 // More details: AddXxxMask() will create KeySystems if it hasn't been created.
  73 // During KeySystems's construction GetContentClient() will be used to add key
  74 // systems. In test code, the content client is set by SetContentClient().
  75 // Therefore, SetContentClient() must be called before this function to avoid
  76 // access violation.
  77 static void AddContainerAndCodecMasksForTest() {
  78   // Since KeySystems is a singleton. Make sure we only add test container and
  79   // codec masks once per process.
  80   static bool is_test_masks_added = false;
  81
  82   if (is_test_masks_added)
  83     return;
  84
  85   AddContainerMask("audio/foo", TEST_CODEC_FOO_AUDIO_ALL);
  86   AddContainerMask("video/foo", TEST_CODEC_FOO_ALL);
  87   AddCodecMask("fooaudio", TEST_CODEC_FOO_AUDIO);
  88   AddCodecMask("foovideo", TEST_CODEC_FOO_VIDEO);
  89
  90   is_test_masks_added = true;
  91 }
  92
  93 class TestContentRendererClient : public ContentRendererClient {
  94   virtual void AddKeySystems(
  95       std::vector<content::KeySystemInfo>* key_systems) OVERRIDE;
  96 };
  97
  98 void TestContentRendererClient::AddKeySystems(
  99     std::vector<content::KeySystemInfo>* key_systems) {
 100   KeySystemInfo aes(kUsesAes);
 101   aes.supported_codecs = EME_CODEC_WEBM_ALL;
 102   aes.supported_codecs |= TEST_CODEC_FOO_ALL;
 103   aes.use_aes_decryptor = true;
 104   key_systems->push_back(aes);
 105
 106   KeySystemInfo ext(kExternal);
 107   ext.supported_codecs = EME_CODEC_WEBM_ALL;
 108   ext.supported_codecs |= TEST_CODEC_FOO_ALL;
 109   ext.parent_key_system = kExternalParent;
 110 #if defined(ENABLE_PEPPER_CDMS)
 111   ext.pepper_type = "application/x-ppapi-external-cdm";
 112 #endif  // defined(ENABLE_PEPPER_CDMS)
 113   key_systems->push_back(ext);
 114 }
 115
 116 class KeySystemsTest : public testing::Test {
 117  protected:
 118   KeySystemsTest() {
 119     vp8_codec_.push_back("vp8");
 120
 121     vp80_codec_.push_back("vp8.0");
 122
 123     vp9_codec_.push_back("vp9");
 124
 125     vp90_codec_.push_back("vp9.0");
 126
 127     vorbis_codec_.push_back("vorbis");
 128
 129     vp8_and_vorbis_codecs_.push_back("vp8");
 130     vp8_and_vorbis_codecs_.push_back("vorbis");
 131
 132     vp9_and_vorbis_codecs_.push_back("vp9");
 133     vp9_and_vorbis_codecs_.push_back("vorbis");
 134
 135     foovideo_codec_.push_back("foovideo");
 136
 137     foovideo_extended_codec_.push_back("foovideo.4D400C");
 138
 139     foovideo_dot_codec_.push_back("foovideo.");
 140
 141     fooaudio_codec_.push_back("fooaudio");
 142
 143     foovideo_and_fooaudio_codecs_.push_back("foovideo");
 144     foovideo_and_fooaudio_codecs_.push_back("fooaudio");
 145
 146     unknown_codec_.push_back("unknown");
 147
 148     mixed_codecs_.push_back("vorbis");
 149     mixed_codecs_.push_back("foovideo");
 150
 151     // KeySystems requires a valid ContentRendererClient and thus ContentClient.
 152     // The TestContentClient is not available inside Death Tests on some
 153     // platforms (see below). Therefore, always provide a TestContentClient.
 154     // Explanation: When Death Tests fork, there is a valid ContentClient.
 155     // However, when they launch a new process instead of forking, the global
 156     // variable is not copied and for some reason TestContentClientInitializer
 157     // does not get created to set the global variable in the new process.
 158     SetContentClient(&test_content_client_);
 159     SetRendererClientForTesting(&content_renderer_client_);
 160   }
 161
 162   virtual void SetUp() OVERRIDE {
 163     AddContainerAndCodecMasksForTest();
 164   }
 165
 166   virtual ~KeySystemsTest() {
 167     // Clear the use of content_client_, which was set in SetUp().
 168     SetContentClient(NULL);
 169   }
 170
 171   typedef std::vector<std::string> CodecVector;
 172
 173   const CodecVector& no_codecs() const { return no_codecs_; }
 174
 175   const CodecVector& vp8_codec() const { return vp8_codec_; }
 176   const CodecVector& vp80_codec() const { return vp80_codec_; }
 177   const CodecVector& vp9_codec() const { return vp9_codec_; }
 178   const CodecVector& vp90_codec() const { return vp90_codec_; }
 179
 180   const CodecVector& vorbis_codec() const { return vorbis_codec_; }
 181
 182   const CodecVector& vp8_and_vorbis_codecs() const {
 183     return vp8_and_vorbis_codecs_;
 184   }
 185   const CodecVector& vp9_and_vorbis_codecs() const {
 186     return vp9_and_vorbis_codecs_;
 187   }
 188
 189   const CodecVector& foovideo_codec() const { return foovideo_codec_; }
 190   const CodecVector& foovideo_extended_codec() const {
 191     return foovideo_extended_codec_;
 192   }
 193   const CodecVector& foovideo_dot_codec() const { return foovideo_dot_codec_; }
 194   const CodecVector& fooaudio_codec() const { return fooaudio_codec_; }
 195   const CodecVector& foovideo_and_fooaudio_codecs() const {
 196     return foovideo_and_fooaudio_codecs_;
 197   }
 198
 199   const CodecVector& unknown_codec() const { return unknown_codec_; }
 200
 201   const CodecVector& mixed_codecs() const { return mixed_codecs_; }
 202
 203  private:
 204   const CodecVector no_codecs_;
 205   CodecVector vp8_codec_;
 206   CodecVector vp80_codec_;
 207   CodecVector vp9_codec_;
 208   CodecVector vp90_codec_;
 209   CodecVector vorbis_codec_;
 210   CodecVector vp8_and_vorbis_codecs_;
 211   CodecVector vp9_and_vorbis_codecs_;
 212
 213   CodecVector foovideo_codec_;
 214   CodecVector foovideo_extended_codec_;
 215   CodecVector foovideo_dot_codec_;
 216   CodecVector fooaudio_codec_;
 217   CodecVector foovideo_and_fooaudio_codecs_;
 218
 219   CodecVector unknown_codec_;
 220
 221   CodecVector mixed_codecs_;
 222
 223   TestContentClient test_content_client_;
 224   TestContentRendererClient content_renderer_client_;
 225 };
 226
 227 // TODO(ddorwin): Consider moving GetPepperType() calls out to their own test.
 228
 229 TEST_F(KeySystemsTest, EmptyKeySystem) {
 230   EXPECT_FALSE(IsConcreteSupportedKeySystem(std::string()));
 231   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
 232       kVideoWebM, no_codecs(), std::string()));
 233   EXPECT_EQ("Unknown", KeySystemNameForUMA(std::string()));
 234 }
 235
 236 // Clear Key is the only key system registered in content.
 237 TEST_F(KeySystemsTest, ClearKey) {
 238   EXPECT_TRUE(IsConcreteSupportedKeySystem(kClearKey));
 239   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
 240       kVideoWebM, no_codecs(), kClearKey));
 241
 242   EXPECT_EQ("ClearKey", KeySystemNameForUMA(kClearKey));
 243
 244   // Prefixed Clear Key is not supported internally.
 245   EXPECT_FALSE(IsConcreteSupportedKeySystem(kPrefixedClearKey));
 246   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
 247       kVideoWebM, no_codecs(), kPrefixedClearKey));
 248   EXPECT_EQ("Unknown", KeySystemNameForUMA(kPrefixedClearKey));
 249 }
 250
 251 // The key system is not registered and therefore is unrecognized.
 252 TEST_F(KeySystemsTest, Basic_UnrecognizedKeySystem) {
 253   static const char* const kUnrecognized = "org.example.unrecognized";
 254
 255   EXPECT_FALSE(IsConcreteSupportedKeySystem(kUnrecognized));
 256   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
 257       kVideoWebM, no_codecs(), kUnrecognized));
 258
 259   EXPECT_EQ("Unknown", KeySystemNameForUMA(kUnrecognized));
 260
 261   bool can_use = false;
 262   EXPECT_DEBUG_DEATH_PORTABLE(
 263       can_use = CanUseAesDecryptor(kUnrecognized),
 264       "org.example.unrecognized is not a known concrete system");
 265   EXPECT_FALSE(can_use);
 266
 267 #if defined(ENABLE_PEPPER_CDMS)
 268   std::string type;
 269   EXPECT_DEBUG_DEATH(type = GetPepperType(kUnrecognized),
 270                      "org.example.unrecognized is not a known concrete system");
 271   EXPECT_TRUE(type.empty());
 272 #endif
 273 }
 274
 275 TEST_F(KeySystemsTest, Basic_UsesAesDecryptor) {
 276   EXPECT_TRUE(IsConcreteSupportedKeySystem(kUsesAes));
 277   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
 278       kVideoWebM, no_codecs(), kUsesAes));
 279
 280   // No UMA value for this test key system.
 281   EXPECT_EQ("Unknown", KeySystemNameForUMA(kUsesAes));
 282
 283   EXPECT_TRUE(CanUseAesDecryptor(kUsesAes));
 284 #if defined(ENABLE_PEPPER_CDMS)
 285   std::string type;
 286   EXPECT_DEBUG_DEATH(type = GetPepperType(kUsesAes),
 287                      "org.example.clear is not Pepper-based");
 288   EXPECT_TRUE(type.empty());
 289 #endif
 290 }
 291
 292 TEST_F(KeySystemsTest,
 293        IsSupportedKeySystemWithMediaMimeType_UsesAesDecryptor_TypesContainer1) {
 294   // Valid video types.
 295   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
 296       kVideoWebM, vp8_codec(), kUsesAes));
 297   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
 298       kVideoWebM, vp80_codec(), kUsesAes));
 299   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
 300       kVideoWebM, vp8_and_vorbis_codecs(), kUsesAes));
 301   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
 302       kVideoWebM, vp9_codec(), kUsesAes));
 303   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
 304       kVideoWebM, vp90_codec(), kUsesAes));
 305   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
 306       kVideoWebM, vp9_and_vorbis_codecs(), kUsesAes));
 307   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
 308       kVideoWebM, vorbis_codec(), kUsesAes));
 309
 310   // Non-Webm codecs.
 311   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
 312       kVideoWebM, foovideo_codec(), kUsesAes));
 313   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
 314       kVideoWebM, unknown_codec(), kUsesAes));
 315   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
 316       kVideoWebM, mixed_codecs(), kUsesAes));
 317
 318   // Valid audio types.
 319   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
 320       kAudioWebM, no_codecs(), kUsesAes));
 321   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
 322       kAudioWebM, vorbis_codec(), kUsesAes));
 323
 324   // Non-audio codecs.
 325   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
 326       kAudioWebM, vp8_codec(), kUsesAes));
 327   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
 328       kAudioWebM, vp8_and_vorbis_codecs(), kUsesAes));
 329   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
 330       kAudioWebM, vp9_codec(), kUsesAes));
 331   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
 332       kAudioWebM, vp9_and_vorbis_codecs(), kUsesAes));
 333
 334   // Non-Webm codec.
 335   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
 336       kAudioWebM, fooaudio_codec(), kUsesAes));
 337 }
 338
 339 // No parent is registered for UsesAes.
 340 TEST_F(KeySystemsTest, Parent_NoParentRegistered) {
 341   EXPECT_FALSE(IsConcreteSupportedKeySystem(kUsesAesParent));
 342   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
 343       kVideoWebM, no_codecs(), kUsesAesParent));
 344
 345   // The parent is not supported for most things.
 346   EXPECT_EQ("Unknown", KeySystemNameForUMA(kUsesAesParent));
 347   bool result = false;
 348   EXPECT_DEBUG_DEATH_PORTABLE(result = CanUseAesDecryptor(kUsesAesParent),
 349                               "org.example is not a known concrete system");
 350   EXPECT_FALSE(result);
 351 #if defined(ENABLE_PEPPER_CDMS)
 352   std::string type;
 353   EXPECT_DEBUG_DEATH(type = GetPepperType(kUsesAesParent),
 354                      "org.example is not a known concrete system");
 355   EXPECT_TRUE(type.empty());
 356 #endif
 357 }
 358
 359 TEST_F(KeySystemsTest, IsSupportedKeySystem_InvalidVariants) {
 360   // Case sensitive.
 361   EXPECT_FALSE(IsConcreteSupportedKeySystem("org.example.ClEaR"));
 362   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
 363       kVideoWebM, no_codecs(), "org.example.ClEaR"));
 364
 365   // TLDs are not allowed.
 366   EXPECT_FALSE(IsConcreteSupportedKeySystem("org."));
 367   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
 368       kVideoWebM, no_codecs(), "org."));
 369   EXPECT_FALSE(IsConcreteSupportedKeySystem("com"));
 370   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
 371       kVideoWebM, no_codecs(), "com"));
 372
 373   // Extra period.
 374   EXPECT_FALSE(IsConcreteSupportedKeySystem("org.example."));
 375   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
 376       kVideoWebM, no_codecs(), "org.example."));
 377
 378   // Incomplete.
 379   EXPECT_FALSE(IsConcreteSupportedKeySystem("org.example.clea"));
 380   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
 381       kVideoWebM, no_codecs(), "org.example.clea"));
 382
 383   // Extra character.
 384   EXPECT_FALSE(IsConcreteSupportedKeySystem("org.example.clearz"));
 385   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
 386       kVideoWebM, no_codecs(), "org.example.clearz"));
 387
 388   // There are no child key systems for UsesAes.
 389   EXPECT_FALSE(IsConcreteSupportedKeySystem("org.example.clear.foo"));
 390   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
 391       kVideoWebM, no_codecs(), "org.example.clear.foo"));
 392 }
 393
 394 TEST_F(KeySystemsTest, IsSupportedKeySystemWithMediaMimeType_NoType) {
 395   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
 396       std::string(), no_codecs(), kUsesAes));
 397   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
 398       std::string(), no_codecs(), kUsesAesParent));
 399
 400   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
 401       std::string(), no_codecs(), "org.example.foo"));
 402   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
 403       std::string(), no_codecs(), "org.example.clear.foo"));
 404 }
 405
 406 // Tests the second registered container type.
 407 // TODO(ddorwin): Combined with TypesContainer1 in a future CL.
 408 TEST_F(KeySystemsTest,
 409        IsSupportedKeySystemWithMediaMimeType_UsesAesDecryptor_TypesContainer2) {
 410   // Valid video types.
 411   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
 412       kVideoFoo, no_codecs(), kUsesAes));
 413   // The parent should be supported but is not. See http://crbug.com/164303.
 414   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
 415       kVideoFoo, no_codecs(), kUsesAesParent));
 416   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
 417       kVideoFoo, foovideo_codec(), kUsesAes));
 418   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
 419       kVideoFoo, foovideo_and_fooaudio_codecs(), kUsesAes));
 420   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
 421       kVideoFoo, fooaudio_codec(), kUsesAes));
 422
 423   // Extended codecs fail because this is handled by SimpleWebMimeRegistryImpl.
 424   // They should really pass canPlayType().
 425   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
 426       kVideoFoo, foovideo_extended_codec(), kUsesAes));
 427
 428   // Invalid codec format.
 429   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
 430       kVideoFoo, foovideo_dot_codec(), kUsesAes));
 431
 432   // Non-container2 codec.
 433   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
 434       kVideoFoo, vp8_codec(), kUsesAes));
 435   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
 436       kVideoFoo, unknown_codec(), kUsesAes));
 437   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
 438       kVideoFoo, mixed_codecs(), kUsesAes));
 439
 440   // Valid audio types.
 441   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
 442       kAudioFoo, no_codecs(), kUsesAes));
 443   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
 444       kAudioFoo, fooaudio_codec(), kUsesAes));
 445
 446   // Non-audio codecs.
 447   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
 448       kAudioFoo, foovideo_codec(), kUsesAes));
 449   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
 450       kAudioFoo, foovideo_and_fooaudio_codecs(), kUsesAes));
 451
 452   // Non-container2 codec.
 453   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
 454       kAudioFoo, vorbis_codec(), kUsesAes));
 455 }
 456
 457 //
 458 // Non-AesDecryptor-based key system.
 459 //
 460
 461 TEST_F(KeySystemsTest, Basic_ExternalDecryptor) {
 462   EXPECT_TRUE(IsConcreteSupportedKeySystem(kExternal));
 463   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
 464       kVideoWebM, no_codecs(), kExternal));
 465
 466   EXPECT_FALSE(CanUseAesDecryptor(kExternal));
 467 #if defined(ENABLE_PEPPER_CDMS)
 468   EXPECT_EQ("application/x-ppapi-external-cdm", GetPepperType(kExternal));
 469 #endif  // defined(ENABLE_PEPPER_CDMS)
 470
 471 }
 472
 473 TEST_F(KeySystemsTest, Parent_ParentRegistered) {
 474   // The parent system is not a concrete system but is supported.
 475   EXPECT_FALSE(IsConcreteSupportedKeySystem(kExternalParent));
 476   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
 477       kVideoWebM, no_codecs(), kExternalParent));
 478
 479   // The parent is not supported for most things.
 480   EXPECT_EQ("Unknown", KeySystemNameForUMA(kExternalParent));
 481   bool result = false;
 482   EXPECT_DEBUG_DEATH_PORTABLE(result = CanUseAesDecryptor(kExternalParent),
 483                               "com.example is not a known concrete system");
 484   EXPECT_FALSE(result);
 485 #if defined(ENABLE_PEPPER_CDMS)
 486   std::string type;
 487   EXPECT_DEBUG_DEATH(type = GetPepperType(kExternalParent),
 488                      "com.example is not a known concrete system");
 489   EXPECT_TRUE(type.empty());
 490 #endif
 491 }
 492
 493 TEST_F(
 494     KeySystemsTest,
 495     IsSupportedKeySystemWithMediaMimeType_ExternalDecryptor_TypesContainer1) {
 496   // Valid video types.
 497   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
 498       kVideoWebM, no_codecs(), kExternal));
 499   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
 500       kVideoWebM, vp8_codec(), kExternal));
 501   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
 502       kVideoWebM, vp80_codec(), kExternal));
 503   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
 504       kVideoWebM, vp8_and_vorbis_codecs(), kExternal));
 505   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
 506       kVideoWebM, vp9_codec(), kExternal));
 507   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
 508       kVideoWebM, vp90_codec(), kExternal));
 509   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
 510       kVideoWebM, vp9_and_vorbis_codecs(), kExternal));
 511   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
 512       kVideoWebM, vorbis_codec(), kExternal));
 513
 514   // Valid video types - parent key system.
 515   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
 516       kVideoWebM, no_codecs(), kExternalParent));
 517   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
 518       kVideoWebM, vp8_codec(), kExternalParent));
 519   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
 520       kVideoWebM, vp80_codec(), kExternalParent));
 521   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
 522       kVideoWebM, vp8_and_vorbis_codecs(), kExternalParent));
 523   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
 524       kVideoWebM, vp9_codec(), kExternalParent));
 525   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
 526       kVideoWebM, vp90_codec(), kExternalParent));
 527   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
 528       kVideoWebM, vp9_and_vorbis_codecs(), kExternalParent));
 529   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
 530       kVideoWebM, vorbis_codec(), kExternalParent));
 531
 532   // Non-Webm codecs.
 533   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
 534       kVideoWebM, foovideo_codec(), kExternal));
 535   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
 536       kVideoWebM, unknown_codec(), kExternal));
 537   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
 538       kVideoWebM, mixed_codecs(), kExternal));
 539
 540   // Valid audio types.
 541   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
 542       kAudioWebM, no_codecs(), kExternal));
 543   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
 544       kAudioWebM, vorbis_codec(), kExternal));
 545
 546   // Valid audio types - parent key system.
 547   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
 548       kAudioWebM, no_codecs(), kExternalParent));
 549   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
 550       kAudioWebM, vorbis_codec(), kExternalParent));
 551
 552   // Non-audio codecs.
 553   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
 554       kAudioWebM, vp8_codec(), kExternal));
 555   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
 556       kAudioWebM, vp8_and_vorbis_codecs(), kExternal));
 557   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
 558       kAudioWebM, vp9_codec(), kExternal));
 559   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
 560       kAudioWebM, vp9_and_vorbis_codecs(), kExternal));
 561
 562   // Non-Webm codec.
 563   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
 564       kAudioWebM, fooaudio_codec(), kExternal));
 565 }
 566
 567 TEST_F(
 568     KeySystemsTest,
 569     IsSupportedKeySystemWithMediaMimeType_ExternalDecryptor_TypesContainer2) {
 570   // Valid video types.
 571   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
 572       kVideoFoo, no_codecs(), kExternal));
 573   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
 574       kVideoFoo, foovideo_codec(), kExternal));
 575   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
 576       kVideoFoo, foovideo_and_fooaudio_codecs(), kExternal));
 577   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
 578       kVideoFoo, fooaudio_codec(), kExternal));
 579
 580   // Valid video types - parent key system.
 581   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
 582       kVideoFoo, no_codecs(), kExternalParent));
 583   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
 584       kVideoFoo, foovideo_codec(), kExternalParent));
 585   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
 586       kVideoFoo, foovideo_and_fooaudio_codecs(), kExternalParent));
 587   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
 588       kVideoFoo, fooaudio_codec(), kExternalParent));
 589
 590   // Extended codecs fail because this is handled by SimpleWebMimeRegistryImpl.
 591   // They should really pass canPlayType().
 592   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
 593       kVideoFoo, foovideo_extended_codec(), kExternal));
 594
 595   // Invalid codec format.
 596   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
 597       kVideoFoo, foovideo_dot_codec(), kExternal));
 598
 599   // Non-container2 codecs.
 600   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
 601       kVideoFoo, vp8_codec(), kExternal));
 602   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
 603       kVideoFoo, unknown_codec(), kExternal));
 604   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
 605       kVideoFoo, mixed_codecs(), kExternal));
 606
 607   // Valid audio types.
 608   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
 609       kAudioFoo, no_codecs(), kExternal));
 610   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
 611       kAudioFoo, fooaudio_codec(), kExternal));
 612
 613   // Valid audio types - parent key system.
 614   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
 615       kAudioFoo, no_codecs(), kExternalParent));
 616   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
 617       kAudioFoo, fooaudio_codec(), kExternalParent));
 618
 619   // Non-audio codecs.
 620   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
 621       kAudioFoo, foovideo_codec(), kExternal));
 622   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
 623       kAudioFoo, foovideo_and_fooaudio_codecs(), kExternal));
 624
 625   // Non-container2 codec.
 626   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
 627       kAudioFoo, vorbis_codec(), kExternal));
 628 }
 629
 630 TEST_F(KeySystemsTest, KeySystemNameForUMA) {
 631   EXPECT_EQ("ClearKey", KeySystemNameForUMA(kClearKey));
 632   // Prefixed is not supported internally.
 633   EXPECT_EQ("Unknown", KeySystemNameForUMA(kPrefixedClearKey));
 634
 635   // External Clear Key never has a UMA name.
 636   EXPECT_EQ("Unknown", KeySystemNameForUMA(kExternalClearKey));
 637
 638 #if defined(WIDEVINE_CDM_AVAILABLE)
 639   const char* const kTestWidevineUmaName = "Widevine";
 640 #else
 641   const char* const kTestWidevineUmaName = "Unknown";
 642 #endif
 643   EXPECT_EQ(kTestWidevineUmaName, KeySystemNameForUMA("com.widevine.alpha"));
 644 }
 645
 646 }  // namespace content