Conditionally build support for Pepper-based CDMs.

webkit/media/crypto/key_systems_unittest.cc

 // Copyright (c) 2012 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 "testing/gtest/include/gtest/gtest.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/WebString.h"
 #include "webkit/media/crypto/key_systems.h"
@@ skipping 156 matching lines @@
   // Not yet out from behind the vendor prefix.
   EXPECT_FALSE(IsSupportedKeySystem("org.w3.clearkey"));
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
       "video/webm", no_codecs(), "org.w3.clearkey"));
 
   EXPECT_STREQ("ClearKey", KeySystemNameForUMA(std::string(kClearKey)).c_str());
   EXPECT_STREQ("ClearKey",
                KeySystemNameForUMA(WebString::fromUTF8(kClearKey)).c_str());
 
   EXPECT_TRUE(CanUseAesDecryptor(kClearKey));
-  EXPECT_TRUE(GetPluginType(kClearKey).empty());  // Does not use plugin.
+#if defined(ENABLE_PEPPER_CDMS)
+  EXPECT_TRUE(GetPepperType(kClearKey).empty());  // Does not use Pepper.
+#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(IsSupportedKeySystem(WebString::fromUTF8(kClearKeyParent)));
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
       "video/webm", no_codecs(), kClearKeyParent));
 
   // The parent is not supported for most things.
   EXPECT_STREQ("Unknown",
                KeySystemNameForUMA(std::string(kClearKeyParent)).c_str());
   EXPECT_STREQ("Unknown",
       KeySystemNameForUMA(WebString::fromUTF8(kClearKeyParent)).c_str());
   EXPECT_FALSE(CanUseAesDecryptor(kClearKeyParent));
-  EXPECT_TRUE(GetPluginType(kClearKeyParent).empty());
+#if defined(ENABLE_PEPPER_CDMS)
+  EXPECT_TRUE(GetPepperType(kClearKeyParent).empty());
+#endif
 }
 
 TEST_F(KeySystemsTest, ClearKey_IsSupportedKeySystem_InvalidVariants) {
   // Case sensitive.
   EXPECT_FALSE(IsSupportedKeySystem("webkit-org.w3.ClEaRkEy"));
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
       "video/webm", no_codecs(), "webkit-org.w3.ClEaRkEy"));
 
   // TLDs are not allowed.
   EXPECT_FALSE(IsSupportedKeySystem("webkit-org."));
@@ skipping 145 matching lines @@
 
   // External Clear Key does not have a UMA name because it is for testing.
   EXPECT_STREQ(
       "Unknown",
       KeySystemNameForUMA(std::string(kExternalClearKey)).c_str());
   EXPECT_STREQ(
       "Unknown",
       KeySystemNameForUMA(WebString::fromUTF8(kExternalClearKey)).c_str());
 
   EXPECT_FALSE(CanUseAesDecryptor(kExternalClearKey));
+#if defined(ENABLE_PEPPER_CDMS)
   EXPECT_STREQ("application/x-ppapi-clearkey-cdm",
-               GetPluginType(kExternalClearKey).c_str());
+               GetPepperType(kExternalClearKey).c_str());
+#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(
       IsSupportedKeySystem(WebString::fromUTF8(kExternalClearKeyParent)));
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
       "video/webm", no_codecs(), kExternalClearKeyParent));
 
   // The parent is not supported for most things.
   EXPECT_STREQ(
       "Unknown",
       KeySystemNameForUMA(std::string(kExternalClearKeyParent)).c_str());
   EXPECT_STREQ("Unknown",
                KeySystemNameForUMA(
                    WebString::fromUTF8(kExternalClearKeyParent)).c_str());
   EXPECT_FALSE(CanUseAesDecryptor(kExternalClearKeyParent));
-  EXPECT_TRUE(GetPluginType(kExternalClearKeyParent).empty());
+#if defined(ENABLE_PEPPER_CDMS)
+  EXPECT_TRUE(GetPepperType(kExternalClearKeyParent).empty());
+#endif
 }
 
 TEST_F(KeySystemsTest, ExternalClearKey_IsSupportedKeySystem_InvalidVariants) {
   // Case sensitive.
   EXPECT_FALSE(IsSupportedKeySystem("org.chromium.ExTeRnAlClEaRkEy"));
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
       "video/webm", no_codecs(),
       "org.chromium.ExTeRnAlClEaRkEy"));
 
   // TLDs are not allowed.
@@ skipping 150 matching lines @@
   const char* const kWidevineUmaName = "Unknown";
 #endif
   EXPECT_STREQ(
       kWidevineUmaName,
       KeySystemNameForUMA(std::string(kWidevineAlpha)).c_str());
   EXPECT_STREQ(
       kWidevineUmaName,
       KeySystemNameForUMA(WebString::fromUTF8(kWidevineAlpha)).c_str());
 
   EXPECT_FALSE(CanUseAesDecryptor(kWidevineAlpha));
+#if defined(ENABLE_PEPPER_CDMS)
 #if defined(WIDEVINE_CDM_AVAILABLE)
   EXPECT_STREQ("application/x-ppapi-widevine-cdm",
-               GetPluginType(kWidevineAlpha).c_str());
+               GetPepperType(kWidevineAlpha).c_str());
 #else
-  EXPECT_TRUE(GetPluginType(kWidevineAlpha).empty());
-#endif
+  EXPECT_TRUE(GetPepperType(kWidevineAlpha).empty());
+#endif  // defined(WIDEVINE_CDM_AVAILABLE)
+#endif  // defined(ENABLE_PEPPER_CDMS)
+
 }
 
 TEST_F(KeySystemsTest, Widevine_Parent) {
   const char* const kWidevineParent = kWidevine;
 
   EXPECT_WV(IsSupportedKeySystem(WebString::fromUTF8(kWidevineParent)));
   EXPECT_WV(IsSupportedKeySystemWithMediaMimeType(
       "video/webm", no_codecs(), kWidevineParent));
 
   // The parent is not supported for most things.
   EXPECT_STREQ("Unknown",
                KeySystemNameForUMA(std::string(kWidevineParent)).c_str());
   EXPECT_STREQ("Unknown",
       KeySystemNameForUMA(WebString::fromUTF8(kWidevineParent)).c_str());
   EXPECT_FALSE(CanUseAesDecryptor(kWidevineParent));
-  EXPECT_TRUE(GetPluginType(kWidevineParent).empty());
+#if defined(ENABLE_PEPPER_CDMS)
+  EXPECT_TRUE(GetPepperType(kWidevineParent).empty());
+#endif
 }
 
 TEST_F(KeySystemsTest, Widevine_IsSupportedKeySystem_InvalidVariants) {
   // Case sensitive.
   EXPECT_FALSE(IsSupportedKeySystem("com.widevine.AlPhA"));
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
       "video/webm", no_codecs(), "com.widevine.AlPhA"));
 
   // TLDs are not allowed.
   EXPECT_FALSE(IsSupportedKeySystem("com."));
@@ skipping 150 matching lines @@
       "audio/mp4", avc1_codec(), kWidevineAlpha));
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
       "audio/mp4", avc1_and_aac_codecs(), kWidevineAlpha));
 
   // Non-MP4 codec.
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
       "audio/mp4", vorbis_codec(), kWidevineAlpha));
 }
 
 }  // namespace webkit_media