Explicitly register each key system.

content/renderer/media/crypto/key_systems_unittest.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <string>
 #include <vector>
 
 #include "content/renderer/media/crypto/key_systems.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/WebKit/public/platform/WebString.h"
@@ skipping 190 matching lines @@
   // Not yet out from behind the vendor prefix.
   EXPECT_FALSE(IsConcreteSupportedKeySystem("org.w3.clearkey"));
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
       "video/webm", no_codecs(), "org.w3.clearkey"));
 
   EXPECT_STREQ("ClearKey",
                KeySystemNameForUMA(WebString::fromUTF8(kClearKey)).c_str());
 
   EXPECT_TRUE(CanUseAesDecryptor(kClearKey));
 #if defined(ENABLE_PEPPER_CDMS)
-  EXPECT_TRUE(GetPepperType(kClearKey).empty());  // Does not use Pepper.
+  std::string type;
+  EXPECT_DCHECK_DEATH(type = GetPepperType(kClearKey),
+                      "webkit-org.w3.clearkey is not Pepper-based");
+  EXPECT_TRUE(type.empty());
 #endif
 }
 
 TEST_F(KeySystemsTest, ClearKey_Parent) {
   const char* const kClearKeyParent = "webkit-org.w3";
 
   // The parent should be supported but is not. See http://crbug.com/164303.
   EXPECT_FALSE(
       IsConcreteSupportedKeySystem(WebString::fromUTF8(kClearKeyParent)));
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
       "video/webm", no_codecs(), kClearKeyParent));
 
   // The parent is not supported for most things.
   EXPECT_STREQ("Unknown",
       KeySystemNameForUMA(WebString::fromUTF8(kClearKeyParent)).c_str());
-  EXPECT_FALSE(CanUseAesDecryptor(kClearKeyParent));
+  bool result = false;
+  EXPECT_DCHECK_DEATH(result = CanUseAesDecryptor(kClearKeyParent),
+                      "webkit-org.w3 is not a known concrete system");
+  EXPECT_FALSE(result);
 #if defined(ENABLE_PEPPER_CDMS)
   std::string type;
   EXPECT_DCHECK_DEATH(type = GetPepperType(kClearKeyParent),
-                      "webkit-org.w3 is not a concrete system");
+                      "webkit-org.w3 is not a known concrete system");
   EXPECT_TRUE(type.empty());
 #endif
 }
 
 TEST_F(KeySystemsTest, ClearKey_IsSupportedKeySystem_InvalidVariants) {
   // Case sensitive.
   EXPECT_FALSE(IsConcreteSupportedKeySystem("webkit-org.w3.ClEaRkEy"));
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
       "video/webm", no_codecs(), "webkit-org.w3.ClEaRkEy"));
 
@@ skipping 144 matching lines @@
   EXPECT_ECK(
       IsConcreteSupportedKeySystem(WebString::fromUTF8(kExternalClearKey)));
   EXPECT_ECK(IsSupportedKeySystemWithMediaMimeType(
       "video/webm", no_codecs(), kExternalClearKey));
 
   // External Clear Key does not have a UMA name because it is for testing.
   EXPECT_STREQ(
       "Unknown",
       KeySystemNameForUMA(WebString::fromUTF8(kExternalClearKey)).c_str());
 
+#if defined(ENABLE_PEPPER_CDMS)
   EXPECT_FALSE(CanUseAesDecryptor(kExternalClearKey));
-#if defined(ENABLE_PEPPER_CDMS)
   EXPECT_STREQ("application/x-ppapi-clearkey-cdm",
                GetPepperType(kExternalClearKey).c_str());
+#else
+  bool result = false;
+  EXPECT_DCHECK_DEATH(
+      result = CanUseAesDecryptor(kExternalClearKey),
+      "org.chromium.externalclearkey is not a known concrete system");
+  EXPECT_FALSE(result);
 #endif
 }
 
 TEST_F(KeySystemsTest, ExternalClearKey_Parent) {
   const char* const kExternalClearKeyParent = "org.chromium";
 
   // The parent should be supported but is not. See http://crbug.com/164303.
   EXPECT_FALSE(IsConcreteSupportedKeySystem(
       WebString::fromUTF8(kExternalClearKeyParent)));
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
       "video/webm", no_codecs(), kExternalClearKeyParent));
 
   // The parent is not supported for most things.
   EXPECT_STREQ("Unknown",
                KeySystemNameForUMA(
                    WebString::fromUTF8(kExternalClearKeyParent)).c_str());
-  EXPECT_FALSE(CanUseAesDecryptor(kExternalClearKeyParent));
+  bool result = false;
+  EXPECT_DCHECK_DEATH(result = CanUseAesDecryptor(kExternalClearKeyParent),
+                      "org.chromium is not a known concrete system");
+  EXPECT_FALSE(result);
 #if defined(ENABLE_PEPPER_CDMS)
   std::string type;
   EXPECT_DCHECK_DEATH(type = GetPepperType(kExternalClearKeyParent),
-                      "org.chromium is not a concrete system");
+                      "org.chromium is not a known concrete system");
   EXPECT_TRUE(type.empty());
 #endif
 }
 
 TEST_F(KeySystemsTest, ExternalClearKey_IsSupportedKeySystem_InvalidVariants) {
   // Case sensitive.
   EXPECT_FALSE(IsConcreteSupportedKeySystem("org.chromium.ExTeRnAlClEaRkEy"));
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
       "video/webm", no_codecs(),
       "org.chromium.ExTeRnAlClEaRkEy"));
@@ skipping 156 matching lines @@
 
 #if defined(WIDEVINE_CDM_AVAILABLE)
   const char* const kWidevineUmaName = "Widevine";
 #else
   const char* const kWidevineUmaName = "Unknown";
 #endif
   EXPECT_STREQ(
       kWidevineUmaName,
       KeySystemNameForUMA(WebString::fromUTF8(kWidevineAlpha)).c_str());
 
+#if defined(WIDEVINE_CDM_AVAILABLE)
   EXPECT_FALSE(CanUseAesDecryptor(kWidevineAlpha));
+#else
+  bool result = false;
+  EXPECT_DCHECK_DEATH(result = CanUseAesDecryptor(kWidevineAlpha),
+                      "com.widevine.alpha is not a known concrete system");
+  EXPECT_FALSE(result);
+#endif  // defined(WIDEVINE_CDM_AVAILABLE)
+
 #if defined(ENABLE_PEPPER_CDMS)
 #if defined(WIDEVINE_CDM_AVAILABLE)
   EXPECT_STREQ("application/x-ppapi-widevine-cdm",
                GetPepperType(kWidevineAlpha).c_str());
 #else
   std::string type;
   EXPECT_DCHECK_DEATH(type = GetPepperType(kWidevineAlpha),
-                      "com.widevine.alpha is not a concrete system");
+                      "com.widevine.alpha is not a known concrete system");
   EXPECT_TRUE(type.empty());
 #endif  // defined(WIDEVINE_CDM_AVAILABLE)
 #endif  // defined(ENABLE_PEPPER_CDMS)
 
 }
 
 TEST_F(KeySystemsTest, Widevine_Parent) {
   // The parent system is not a concrete system but is supported.
   EXPECT_FALSE(IsConcreteSupportedKeySystem(WebString::fromUTF8(kWidevine)));
   EXPECT_WV(IsSupportedKeySystemWithMediaMimeType(
       "video/webm", no_codecs(), kWidevine));
 
   // The parent is not supported for most things.
   EXPECT_STREQ("Unknown",
       KeySystemNameForUMA(WebString::fromUTF8(kWidevine)).c_str());
-  EXPECT_FALSE(CanUseAesDecryptor(kWidevine));
+  bool result = false;
+  EXPECT_DCHECK_DEATH(result = CanUseAesDecryptor(kWidevine),
+                      "com.widevine is not a known concrete system");
+  EXPECT_FALSE(result);
 #if defined(ENABLE_PEPPER_CDMS)
   std::string type;
   EXPECT_DCHECK_DEATH(type = GetPepperType(kWidevine),
-                      "com.widevine is not a concrete system");
+                      "com.widevine is not a known concrete system");
   EXPECT_TRUE(type.empty());
 #endif
 }
 
 TEST_F(KeySystemsTest, Widevine_IsSupportedKeySystem_InvalidVariants) {
   // Case sensitive.
   EXPECT_FALSE(IsConcreteSupportedKeySystem("com.widevine.AlPhA"));
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
       "video/webm", no_codecs(), "com.widevine.AlPhA"));
 
@@ skipping 160 matching lines @@
 
 #if defined(OS_ANDROID)
 TEST_F(KeySystemsTest, GetUUID_Widevine) {
 #if defined(WIDEVINE_CDM_AVAILABLE)
   std::vector<uint8> uuid = GetUUID(kWidevineAlpha);
   EXPECT_EQ(16u, uuid.size());
   EXPECT_EQ(0xED, uuid[15]);
 #else
   std::vector<uint8> uuid;
   EXPECT_DCHECK_DEATH(uuid = GetUUID(kWidevineAlpha),
-                      "com.widevine.alpha is not a concrete system");
+                      "com.widevine.alpha is not a known concrete system");
   EXPECT_TRUE(uuid.empty());
 #endif
 }
 
 TEST_F(KeySystemsTest, GetUUID_Unrecognized) {
   std::vector<uint8> uuid;
   EXPECT_DCHECK_DEATH(uuid = GetUUID(kWidevine),
-                      "com.widevine is not a concrete system");
+                      "com.widevine is not a known concrete system");
   EXPECT_TRUE(uuid.empty());
 
   EXPECT_TRUE(GetUUID(kClearKey).empty());
 
   EXPECT_DCHECK_DEATH(uuid = GetUUID(""), " is not a concrete system");
   EXPECT_TRUE(uuid.empty());
 }
 #endif  // defined(OS_ANDROID)
 
 }  // namespace content