Encrypted Media: Handle blink::WebString in WebMediaPlayer*.

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/public/common/content_client.h"
 #include "content/public/renderer/content_renderer_client.h"
 #include "content/public/renderer/key_system_info.h"
@@ skipping 41 matching lines @@
 static const char kWebMAudioCodecs[] = "vorbis";
 static const char kWebMVideoCodecs[] = "vorbis,vp8,vp8.0";
 
 static const char kAudioFoo[] = "audio/foo";
 static const char kVideoFoo[] = "video/foo";
 static const char kFooAudioCodecs[] = "fooaudio";
 static const char kFooVideoCodecs[] = "fooaudio,foovideo";
 
 namespace content {
 
-// Helper functions that handle the WebString conversion to simplify tests.
-static std::string KeySystemNameForUMAUTF8(const std::string& key_system) {
-  return KeySystemNameForUMA(WebString::fromUTF8(key_system));
-}
-
-static bool IsConcreteSupportedKeySystemUTF8(const std::string& key_system) {
-  return IsConcreteSupportedKeySystem(WebString::fromUTF8(key_system));
-}
-
 class TestContentRendererClient : public ContentRendererClient {
   virtual void AddKeySystems(
       std::vector<content::KeySystemInfo>* key_systems) OVERRIDE;
 };
 
 void TestContentRendererClient::AddKeySystems(
     std::vector<content::KeySystemInfo>* key_systems) {
 #if defined(OS_ANDROID)
   static const uint8 kExternalUuid[16] = {
       0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF,
@@ skipping 118 matching lines @@
 
   CodecVector mixed_codecs_;
 
   TestContentClient test_content_client_;
   TestContentRendererClient content_renderer_client_;
 };
 
 // TODO(ddorwin): Consider moving GetUUID() into these tests or moving
 // GetPepperType() calls out to their own test.
 
+TEST_F(KeySystemsTest, EmptyKeySystem) {
+  EXPECT_FALSE(IsConcreteSupportedKeySystem(std::string()));
+  EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
+      kVideoWebM, no_codecs(), std::string()));
+  EXPECT_EQ("Unknown", KeySystemNameForUMA(std::string()));
+}
+
 // Clear Key is the only key system registered in content.
 TEST_F(KeySystemsTest, ClearKey) {
-  EXPECT_TRUE(IsConcreteSupportedKeySystemUTF8(kPrefixedClearKey));
+  EXPECT_TRUE(IsConcreteSupportedKeySystem(kPrefixedClearKey));
   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
       kVideoWebM, no_codecs(), kPrefixedClearKey));
 
-  EXPECT_EQ("ClearKey", KeySystemNameForUMAUTF8(kPrefixedClearKey));
+  EXPECT_EQ("ClearKey", KeySystemNameForUMA(kPrefixedClearKey));
 
   // Not yet out from behind the vendor prefix.
   EXPECT_FALSE(IsConcreteSupportedKeySystem(kUnprefixedClearKey));
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
       kVideoWebM, no_codecs(), kUnprefixedClearKey));
-  EXPECT_EQ("Unknown", KeySystemNameForUMAUTF8(kUnprefixedClearKey));
+  EXPECT_EQ("Unknown", KeySystemNameForUMA(kUnprefixedClearKey));
 }
 
 // The key system is not registered and therefore is unrecognized.
 TEST_F(KeySystemsTest, Basic_UnrecognizedKeySystem) {
   static const char* const kUnrecognized = "org.example.unrecognized";
 
-  EXPECT_FALSE(IsConcreteSupportedKeySystemUTF8(kUnrecognized));
+  EXPECT_FALSE(IsConcreteSupportedKeySystem(kUnrecognized));
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
       kVideoWebM, no_codecs(), kUnrecognized));
 
-  EXPECT_EQ("Unknown", KeySystemNameForUMAUTF8(kUnrecognized));
+  EXPECT_EQ("Unknown", KeySystemNameForUMA(kUnrecognized));
 
   bool can_use = false;
   EXPECT_DEBUG_DEATH_PORTABLE(
       can_use = CanUseAesDecryptor(kUnrecognized),
       "org.example.unrecognized is not a known concrete system");
   EXPECT_FALSE(can_use);
 
 #if defined(ENABLE_PEPPER_CDMS)
   std::string type;
   EXPECT_DEBUG_DEATH(type = GetPepperType(kUnrecognized),
                      "org.example.unrecognized is not a known concrete system");
   EXPECT_TRUE(type.empty());
 #endif
 }
 
 TEST_F(KeySystemsTest, Basic_UsesAesDecryptor) {
-  EXPECT_TRUE(IsConcreteSupportedKeySystemUTF8(kUsesAes));
+  EXPECT_TRUE(IsConcreteSupportedKeySystem(kUsesAes));
   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
       kVideoWebM, no_codecs(), kUsesAes));
 
   // No UMA value for this test key system.
-  EXPECT_EQ("Unknown", KeySystemNameForUMAUTF8(kUsesAes));
+  EXPECT_EQ("Unknown", KeySystemNameForUMA(kUsesAes));
 
   EXPECT_TRUE(CanUseAesDecryptor(kUsesAes));
 #if defined(ENABLE_PEPPER_CDMS)
   std::string type;
   EXPECT_DEBUG_DEATH(type = GetPepperType(kUsesAes),
                      "org.example.clear is not Pepper-based");
   EXPECT_TRUE(type.empty());
 #endif
 }
 
@@ skipping 29 matching lines @@
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
       kAudioWebM, vp8_and_vorbis_codecs(), kUsesAes));
 
   // Non-Webm codec.
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
       kAudioWebM, fooaudio_codec(), kUsesAes));
 }
 
 // No parent is registered for UsesAes.
 TEST_F(KeySystemsTest, Parent_NoParentRegistered) {
-  EXPECT_FALSE(IsConcreteSupportedKeySystemUTF8(kUsesAesParent));
+  EXPECT_FALSE(IsConcreteSupportedKeySystem(kUsesAesParent));
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
       kVideoWebM, no_codecs(), kUsesAesParent));
 
   // The parent is not supported for most things.
-  EXPECT_EQ("Unknown", KeySystemNameForUMAUTF8(kUsesAesParent));
+  EXPECT_EQ("Unknown", KeySystemNameForUMA(kUsesAesParent));
   bool result = false;
   EXPECT_DEBUG_DEATH_PORTABLE(result = CanUseAesDecryptor(kUsesAesParent),
                               "org.example is not a known concrete system");
   EXPECT_FALSE(result);
 #if defined(ENABLE_PEPPER_CDMS)
   std::string type;
   EXPECT_DEBUG_DEATH(type = GetPepperType(kUsesAesParent),
                      "org.example is not a known concrete system");
   EXPECT_TRUE(type.empty());
 #endif
 }
 
 TEST_F(KeySystemsTest, IsSupportedKeySystem_InvalidVariants) {
   // Case sensitive.
-  EXPECT_FALSE(IsConcreteSupportedKeySystemUTF8("org.example.ClEaR"));
+  EXPECT_FALSE(IsConcreteSupportedKeySystem("org.example.ClEaR"));
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
       kVideoWebM, no_codecs(), "org.example.ClEaR"));
 
   // TLDs are not allowed.
   EXPECT_FALSE(IsConcreteSupportedKeySystem("org."));
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
       kVideoWebM, no_codecs(), "org."));
   EXPECT_FALSE(IsConcreteSupportedKeySystem("com"));
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
       kVideoWebM, no_codecs(), "com"));
@@ skipping 80 matching lines @@
   // Non-container2 codec.
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
       kAudioFoo, vorbis_codec(), kUsesAes));
 }
 
 //
 // Non-AesDecryptor-based key system.
 //
 
 TEST_F(KeySystemsTest, Basic_ExternalDecryptor) {
-  EXPECT_TRUE(IsConcreteSupportedKeySystemUTF8(kExternal));
+  EXPECT_TRUE(IsConcreteSupportedKeySystem(kExternal));
   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
       kVideoWebM, no_codecs(), kExternal));
 
   EXPECT_FALSE(CanUseAesDecryptor(kExternal));
 #if defined(ENABLE_PEPPER_CDMS)
   EXPECT_EQ("application/x-ppapi-external-cdm", GetPepperType(kExternal));
 #endif  // defined(ENABLE_PEPPER_CDMS)
 
 }
 
 TEST_F(KeySystemsTest, Parent_ParentRegistered) {
   // The parent system is not a concrete system but is supported.
-  EXPECT_FALSE(IsConcreteSupportedKeySystemUTF8(kExternalParent));
+  EXPECT_FALSE(IsConcreteSupportedKeySystem(kExternalParent));
   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
       kVideoWebM, no_codecs(), kExternalParent));
 
   // The parent is not supported for most things.
-  EXPECT_EQ("Unknown", KeySystemNameForUMAUTF8(kExternalParent));
+  EXPECT_EQ("Unknown", KeySystemNameForUMA(kExternalParent));
   bool result = false;
   EXPECT_DEBUG_DEATH_PORTABLE(result = CanUseAesDecryptor(kExternalParent),
                               "com.example is not a known concrete system");
   EXPECT_FALSE(result);
 #if defined(ENABLE_PEPPER_CDMS)
   std::string type;
   EXPECT_DEBUG_DEATH(type = GetPepperType(kExternalParent),
                      "com.example is not a known concrete system");
   EXPECT_TRUE(type.empty());
 #endif
@@ skipping 136 matching lines @@
   EXPECT_DEBUG_DEATH_PORTABLE(uuid = GetUUID(kExternalParent),
                               "com.example is not a known concrete system");
   EXPECT_TRUE(uuid.empty());
 
   EXPECT_DEBUG_DEATH_PORTABLE(uuid = GetUUID(""), " is not a concrete system");
   EXPECT_TRUE(uuid.empty());
 }
 #endif  // defined(OS_ANDROID)
 
 TEST_F(KeySystemsTest, KeySystemNameForUMA) {
-  EXPECT_EQ("ClearKey", KeySystemNameForUMAUTF8(kPrefixedClearKey));
+  EXPECT_EQ("ClearKey", KeySystemNameForUMA(kPrefixedClearKey));
   // Unprefixed is not yet supported.
-  EXPECT_EQ("Unknown", KeySystemNameForUMAUTF8(kUnprefixedClearKey));
+  EXPECT_EQ("Unknown", KeySystemNameForUMA(kUnprefixedClearKey));
 
   // External Clear Key never has a UMA name.
-  EXPECT_EQ("Unknown", KeySystemNameForUMAUTF8(kExternalClearKey));
+  EXPECT_EQ("Unknown", KeySystemNameForUMA(kExternalClearKey));
 
 #if defined(WIDEVINE_CDM_AVAILABLE)
   const char* const kTestWidevineUmaName = "Widevine";
 #else
   const char* const kTestWidevineUmaName = "Unknown";
 #endif
   EXPECT_EQ(kTestWidevineUmaName,
-            KeySystemNameForUMAUTF8("com.widevine.alpha"));
+            KeySystemNameForUMA("com.widevine.alpha"));
 }
 
 }  // namespace content