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