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"
 
 #include "widevine_cdm_version.h"  // In SHARED_INTERMEDIATE_DIR.
 
-// Death tests are not always available. When they are, they use NDEBUG for
-// the DCHECK variant, which is not sufficient when defined(DCHECK_ALWAYS_ON).
-// EXPECT_DCHECK_DEATH handles all these cases. The test will execute correctly
-// except in the case that death tests are not available but DCHECKs are on.
+// Death tests are not always available, including on Android.
+// EXPECT_DEBUG_DEATH_PORTABLE executes tests correctly except in the case that
+// death tests are not available and NDEBUG is not defined.
 #if defined(GTEST_HAS_DEATH_TEST) && !defined(OS_ANDROID)
-#if defined(DCHECK_ALWAYS_ON)
-#define EXPECT_DCHECK_DEATH(statement, regex) \
-  EXPECT_DEATH(statement, regex)
+#define EXPECT_DEBUG_DEATH_PORTABLE(statement, regex) \
+  EXPECT_DEBUG_DEATH(statement, regex)
 #else
-#define EXPECT_DCHECK_DEATH(statement, regex) \
-  EXPECT_DEBUG_DEATH(statement, regex)
-#endif  // defined(DCHECK_ALWAYS_ON)
-#else  // defined(GTEST_HAS_DEATH_TEST)
-#if defined(NDEBUG) && !defined(DCHECK_ALWAYS_ON)
-#define EXPECT_DCHECK_DEATH(statement, regex) \
+#if defined(NDEBUG)
+#define EXPECT_DEBUG_DEATH_PORTABLE(statement, regex) \
   do { statement; } while (false)
 #else
 #include "base/logging.h"
-#define EXPECT_DCHECK_DEATH(statement, regex) \
+#define EXPECT_DEBUG_DEATH_PORTABLE(statement, regex) \
   LOG(WARNING) << "Death tests are not supported on this platform.\n" \
                << "Statement '" #statement "' cannot be verified.";
-#endif  // defined(NDEBUG) && defined(DCHECK_ALWAYS_ON)
+#endif  // defined(NDEBUG)
 #endif  // defined(GTEST_HAS_DEATH_TEST) && !defined(OS_ANDROID)
 
 #if defined(WIDEVINE_CDM_AVAILABLE) && \
     defined(OS_LINUX) && !defined(OS_CHROMEOS)
 #include <gnu/libc-version.h>
 #endif
 
 using WebKit::WebString;
 
 #if defined(USE_PROPRIETARY_CODECS)
@@ skipping 155 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_DEBUG_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_DEBUG_DEATH_PORTABLE(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");
+  EXPECT_DEBUG_DEATH(type = GetPepperType(kClearKeyParent),
+                     "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_DEBUG_DEATH_PORTABLE(
+      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_DEBUG_DEATH_PORTABLE(
+      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");
+  EXPECT_DEBUG_DEATH(type = GetPepperType(kExternalClearKeyParent),
+                     "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_DEBUG_DEATH_PORTABLE(
+      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");
+  EXPECT_DEBUG_DEATH(type = GetPepperType(kWidevineAlpha),
+                     "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_DEBUG_DEATH_PORTABLE(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");
+  EXPECT_DEBUG_DEATH(type = GetPepperType(kWidevine),
+                     "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 159 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");
+  EXPECT_DEBUG_DEATH_PORTABLE(
+      uuid = GetUUID(kWidevineAlpha),
+      "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");
+  EXPECT_DEBUG_DEATH_PORTABLE(uuid = GetUUID(kWidevine),
+                              "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_DEBUG_DEATH_PORTABLE(uuid = GetUUID(""), " is not a concrete system");
   EXPECT_TRUE(uuid.empty());
 }
 #endif  // defined(OS_ANDROID)
 
 }  // namespace content