Encrypted Media: Add VP9 support to IsTypeSupported().

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 102 matching lines @@
   key_systems->push_back(ext);
 }
 
 class KeySystemsTest : public testing::Test {
  protected:
   KeySystemsTest() {
     vp8_codec_.push_back("vp8");
 
     vp80_codec_.push_back("vp8.0");
 
+    vp9_codec_.push_back("vp9");
+
+    vp90_codec_.push_back("vp9.0");
+
     vorbis_codec_.push_back("vorbis");
 
     vp8_and_vorbis_codecs_.push_back("vp8");
     vp8_and_vorbis_codecs_.push_back("vorbis");
 
+    vp9_and_vorbis_codecs_.push_back("vp9");
+    vp9_and_vorbis_codecs_.push_back("vorbis");
+
     foovideo_codec_.push_back("foovideo");
 
     foovideo_extended_codec_.push_back("foovideo.4D400C");
 
     foovideo_dot_codec_.push_back("foovideo.");
 
     fooaudio_codec_.push_back("fooaudio");
 
     foovideo_and_fooaudio_codecs_.push_back("foovideo");
     foovideo_and_fooaudio_codecs_.push_back("fooaudio");
@@ skipping 22 matching lines @@
     // Clear the use of content_client_, which was set in SetUp().
     SetContentClient(NULL);
   }
 
   typedef std::vector<std::string> CodecVector;
 
   const CodecVector& no_codecs() const { return no_codecs_; }
 
   const CodecVector& vp8_codec() const { return vp8_codec_; }
   const CodecVector& vp80_codec() const { return vp80_codec_; }
+  const CodecVector& vp9_codec() const { return vp9_codec_; }
+  const CodecVector& vp90_codec() const { return vp90_codec_; }
+
   const CodecVector& vorbis_codec() const { return vorbis_codec_; }
+
   const CodecVector& vp8_and_vorbis_codecs() const {
     return vp8_and_vorbis_codecs_;
   }
+  const CodecVector& vp9_and_vorbis_codecs() const {
+    return vp9_and_vorbis_codecs_;
+  }
 
   const CodecVector& foovideo_codec() const { return foovideo_codec_; }
   const CodecVector& foovideo_extended_codec() const {
     return foovideo_extended_codec_;
   }
   const CodecVector& foovideo_dot_codec() const { return foovideo_dot_codec_; }
   const CodecVector& fooaudio_codec() const { return fooaudio_codec_; }
   const CodecVector& foovideo_and_fooaudio_codecs() const {
     return foovideo_and_fooaudio_codecs_;
   }
 
   const CodecVector& unknown_codec() const { return unknown_codec_; }
 
   const CodecVector& mixed_codecs() const { return mixed_codecs_; }
 
  private:
   const CodecVector no_codecs_;
-
   CodecVector vp8_codec_;
   CodecVector vp80_codec_;
+  CodecVector vp9_codec_;
+  CodecVector vp90_codec_;
   CodecVector vorbis_codec_;
   CodecVector vp8_and_vorbis_codecs_;
+  CodecVector vp9_and_vorbis_codecs_;
 
   CodecVector foovideo_codec_;
   CodecVector foovideo_extended_codec_;
   CodecVector foovideo_dot_codec_;
   CodecVector fooaudio_codec_;
   CodecVector foovideo_and_fooaudio_codecs_;
 
   CodecVector unknown_codec_;
 
   CodecVector mixed_codecs_;
@@ skipping 70 matching lines @@
 TEST_F(KeySystemsTest,
        IsSupportedKeySystemWithMediaMimeType_UsesAesDecryptor_TypesContainer1) {
   // Valid video types.
   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
       kVideoWebM, vp8_codec(), kUsesAes));
   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
       kVideoWebM, vp80_codec(), kUsesAes));
   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
       kVideoWebM, vp8_and_vorbis_codecs(), kUsesAes));
   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
+      kVideoWebM, vp9_codec(), kUsesAes));
+  EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
+      kVideoWebM, vp90_codec(), kUsesAes));
+  EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
+      kVideoWebM, vp9_and_vorbis_codecs(), kUsesAes));
+  EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
       kVideoWebM, vorbis_codec(), kUsesAes));
 
   // Non-Webm codecs.
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
       kVideoWebM, foovideo_codec(), kUsesAes));
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
       kVideoWebM, unknown_codec(), kUsesAes));
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
       kVideoWebM, mixed_codecs(), kUsesAes));
 
   // Valid audio types.
   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
       kAudioWebM, no_codecs(), kUsesAes));
   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
       kAudioWebM, vorbis_codec(), kUsesAes));
 
   // Non-audio codecs.
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
       kAudioWebM, vp8_codec(), kUsesAes));
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
       kAudioWebM, vp8_and_vorbis_codecs(), kUsesAes));
+  EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
+      kAudioWebM, vp9_codec(), kUsesAes));
+  EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
+      kAudioWebM, vp9_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(IsConcreteSupportedKeySystem(kUsesAesParent));
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
@@ skipping 153 matching lines @@
   // Valid video types.
   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
       kVideoWebM, no_codecs(), kExternal));
   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
       kVideoWebM, vp8_codec(), kExternal));
   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
       kVideoWebM, vp80_codec(), kExternal));
   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
       kVideoWebM, vp8_and_vorbis_codecs(), kExternal));
   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
+      kVideoWebM, vp9_codec(), kExternal));
+  EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
+      kVideoWebM, vp90_codec(), kExternal));
+  EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
+      kVideoWebM, vp9_and_vorbis_codecs(), kExternal));
+    EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(

[ddorwin, 2014/04/24 23:00:23]

indentation

[xhwang, 2014/04/25 16:49:08]

Done.

       kVideoWebM, vorbis_codec(), kExternal));
 
   // Valid video types - parent key system.
   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
       kVideoWebM, no_codecs(), kExternalParent));
   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
       kVideoWebM, vp8_codec(), kExternalParent));
   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
       kVideoWebM, vp80_codec(), kExternalParent));
   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
       kVideoWebM, vp8_and_vorbis_codecs(), kExternalParent));
   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
+      kVideoWebM, vp9_codec(), kExternalParent));
+  EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
+      kVideoWebM, vp90_codec(), kExternalParent));
+  EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
+      kVideoWebM, vp9_and_vorbis_codecs(), kExternalParent));
+  EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
       kVideoWebM, vorbis_codec(), kExternalParent));
 
   // Non-Webm codecs.
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
       kVideoWebM, foovideo_codec(), kExternal));
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
       kVideoWebM, unknown_codec(), kExternal));
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
       kVideoWebM, mixed_codecs(), kExternal));
 
   // Valid audio types.
   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
       kAudioWebM, no_codecs(), kExternal));
   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
       kAudioWebM, vorbis_codec(), kExternal));
 
   // Valid audio types - parent key system.
   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
       kAudioWebM, no_codecs(), kExternalParent));
   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
       kAudioWebM, vorbis_codec(), kExternalParent));
 
   // Non-audio codecs.
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
       kAudioWebM, vp8_codec(), kExternal));
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
       kAudioWebM, vp8_and_vorbis_codecs(), kExternal));
+  EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
+      kAudioWebM, vp9_codec(), kExternal));
+  EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
+      kAudioWebM, vp9_and_vorbis_codecs(), kExternal));
 
   // Non-Webm codec.
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
       kAudioWebM, fooaudio_codec(), kExternal));
 }
 
 TEST_F(
     KeySystemsTest,
     IsSupportedKeySystemWithMediaMimeType_ExternalDecryptor_TypesContainer2) {
   // Valid video types.
@@ skipping 66 matching lines @@
 
 #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