Encrypted Media: Confine UUID code to MediaDrmBridge.

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 48 matching lines @@
 
 namespace content {
 
 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,
-      0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF };
-#endif
-
   KeySystemInfo aes(kUsesAes);
 
   aes.supported_types.push_back(std::make_pair(kAudioWebM, kWebMAudioCodecs));
   aes.supported_types.push_back(std::make_pair(kVideoWebM, kWebMVideoCodecs));
 
   aes.supported_types.push_back(std::make_pair(kAudioFoo, kFooAudioCodecs));
   aes.supported_types.push_back(std::make_pair(kVideoFoo, kFooVideoCodecs));
 
   aes.use_aes_decryptor = true;
 
   key_systems->push_back(aes);
 
   KeySystemInfo ext(kExternal);
 
   ext.supported_types.push_back(std::make_pair(kAudioWebM, kWebMAudioCodecs));
   ext.supported_types.push_back(std::make_pair(kVideoWebM, kWebMVideoCodecs));
 
   ext.supported_types.push_back(std::make_pair(kAudioFoo, kFooAudioCodecs));
   ext.supported_types.push_back(std::make_pair(kVideoFoo, kFooVideoCodecs));
 
   ext.parent_key_system = kExternalParent;
 
 #if defined(ENABLE_PEPPER_CDMS)
   ext.pepper_type = "application/x-ppapi-external-cdm";
-#elif defined(OS_ANDROID)
-  ext.uuid.assign(kExternalUuid, kExternalUuid + arraysize(kExternalUuid));
 #endif  // defined(ENABLE_PEPPER_CDMS)
 
   key_systems->push_back(ext);
 }
 
 class KeySystemsTest : public testing::Test {
  protected:
   KeySystemsTest() {
     vp8_codec_.push_back("vp8");
 
@@ skipping 76 matching lines @@
   CodecVector foovideo_and_fooaudio_codecs_;
 
   CodecVector unknown_codec_;
 
   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.
+// TODO(ddorwin): Consider 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) {
@@ skipping 356 matching lines @@
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
       kAudioFoo, foovideo_codec(), kExternal));
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
       kAudioFoo, foovideo_and_fooaudio_codecs(), kExternal));
 
   // Non-container2 codec.
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
       kAudioFoo, vorbis_codec(), kExternal));
 }
 
-#if defined(OS_ANDROID)
-TEST_F(KeySystemsTest, GetUUID_RegisteredExternalDecryptor) {
-  std::vector<uint8> uuid = GetUUID(kExternal);
-  EXPECT_EQ(16u, uuid.size());
-  EXPECT_EQ(0xef, uuid[15]);
-}
-
-TEST_F(KeySystemsTest, GetUUID_RegisteredAesDecryptor) {
-  EXPECT_TRUE(GetUUID(kUsesAes).empty());
-}
-
-TEST_F(KeySystemsTest, GetUUID_Unrecognized) {
-  std::vector<uint8> uuid;
-  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", KeySystemNameForUMA(kClearKey));
   // Prefixed is not supported internally.
   EXPECT_EQ("Unknown", KeySystemNameForUMA(kPrefixedClearKey));
 
   // External Clear Key never has a UMA name.
   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, KeySystemNameForUMA("com.widevine.alpha"));
 }
 
 }  // namespace content