Encrypted Media: Add VP9 support to IsTypeSupported().

BUG=361318
TEST=Add VP9 to unittests.

Review URL: https://codereview.chromium.org/252513005

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@267047 0039d316-1c4b-4281-b951-d872f2087c98

chrome/browser/media/encrypted_media_istypesupported_browsertest.cc

@@ -21,6 +21,10 @@
 
 #include "widevine_cdm_version.h"  // In SHARED_INTERMEDIATE_DIR.
 
+#if defined(OS_ANDROID)
+#error This file needs to be updated to run on Android.
+#endif
+
 #if defined(USE_PROPRIETARY_CODECS)
 #define EXPECT_PROPRIETARY EXPECT_TRUE
 #else
@@ -86,6 +90,8 @@ const char kWidevineAlphaHr[] = "com.widevine.alpha.hr";
 const char kWidevineAlphaHrNonCompositing[] =
     "com.widevine.alpha.hrnoncompositing";
 
+// TODO(xhwang): Simplify this test! See http://crbug.com/367158
+
 class EncryptedMediaIsTypeSupportedTest : public InProcessBrowserTest {
  protected:
   EncryptedMediaIsTypeSupportedTest()
@@ -94,11 +100,18 @@ class EncryptedMediaIsTypeSupportedTest : public InProcessBrowserTest {
 
     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");
+
     avc1_codec_.push_back("avc1");
 
     avc1_extended_codec_.push_back("avc1.4D400C");
@@ -127,10 +140,15 @@ class EncryptedMediaIsTypeSupportedTest : public InProcessBrowserTest {
   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& avc1_codec() const { return avc1_codec_; }
   const CodecVector& avc1_extended_codec() const {
     return avc1_extended_codec_;
@@ -244,8 +262,11 @@ class EncryptedMediaIsTypeSupportedTest : public InProcessBrowserTest {
   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 avc1_codec_;
   CodecVector avc1_extended_codec_;
   CodecVector avc1_dot_codec_;
@@ -422,6 +443,12 @@ IN_PROC_BROWSER_TEST_F(EncryptedMediaIsTypeSupportedTest,
       "video/webm", vp80_codec(), kPrefixedClearKey));
   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
       "video/webm", vp8_and_vorbis_codecs(), kPrefixedClearKey));
+  EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
+      "video/webm", vp9_codec(), kPrefixedClearKey));
+  EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
+      "video/webm", vp90_codec(), kPrefixedClearKey));
+  EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
+      "video/webm", vp9_and_vorbis_codecs(), kPrefixedClearKey));
   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
       "video/webm", vorbis_codec(), kPrefixedClearKey));
 
@@ -444,6 +471,10 @@ IN_PROC_BROWSER_TEST_F(EncryptedMediaIsTypeSupportedTest,
       "audio/webm", vp8_codec(), kPrefixedClearKey));
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
       "audio/webm", vp8_and_vorbis_codecs(), kPrefixedClearKey));
+  EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
+      "audio/webm", vp9_codec(), kPrefixedClearKey));
+  EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
+      "audio/webm", vp9_and_vorbis_codecs(), kPrefixedClearKey));
 
   // Non-Webm codec.
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
@@ -597,6 +628,12 @@ IN_PROC_BROWSER_TEST_F(
       "video/webm", vp80_codec(), kExternalClearKey));
   EXPECT_ECK(IsSupportedKeySystemWithMediaMimeType(
       "video/webm", vp8_and_vorbis_codecs(), kExternalClearKey));
+  EXPECT_ECK(IsSupportedKeySystemWithMediaMimeType(
+      "video/webm", vp9_codec(), kExternalClearKey));
+  EXPECT_ECK(IsSupportedKeySystemWithMediaMimeType(
+      "video/webm", vp90_codec(), kExternalClearKey));
+  EXPECT_ECK(IsSupportedKeySystemWithMediaMimeType(
+      "video/webm", vp9_and_vorbis_codecs(), kExternalClearKey));
   EXPECT_ECK(IsSupportedKeySystemWithMediaMimeType(
       "video/webm", vorbis_codec(), kExternalClearKey));
 
@@ -619,6 +656,10 @@ IN_PROC_BROWSER_TEST_F(
       "audio/webm", vp8_codec(), kExternalClearKey));
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
       "audio/webm", vp8_and_vorbis_codecs(), kExternalClearKey));
+  EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
+      "audio/webm", vp9_codec(), kExternalClearKey));
+  EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
+      "audio/webm", vp9_and_vorbis_codecs(), kExternalClearKey));
 
   // Non-Webm codec.
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
@@ -757,6 +798,9 @@ IN_PROC_BROWSER_TEST_F(EncryptedMediaIsTypeSupportedWidevineTest,
       std::string(), no_codecs(), "com.widevine.alpha.foo"));
 }
 
+// TODO(xhwang): Add VP9 Widevine tests after VP9 is supported by Widevine CDM.
+// See http://crbug.com/361318
+
 IN_PROC_BROWSER_TEST_F(EncryptedMediaIsTypeSupportedWidevineTest,
                        IsSupportedKeySystemWithMediaMimeType_Widevine_WebM) {
   // Valid video types.

chrome/browser/media/encrypted_media_message_filter_android.cc

@@ -35,6 +35,7 @@ struct CodecInfo {
 const CodecInfo kCodecsToQuery[] = {
   {content::EME_CODEC_WEBM_VORBIS, CODEC_AUDIO, "vorbis", "video/webm"},
   {content::EME_CODEC_WEBM_VP8, CODEC_VIDEO, "vp8", "video/webm"},
+  {content::EME_CODEC_WEBM_VP9, CODEC_VIDEO, "vp9", "video/webm"},
 #if defined(USE_PROPRIETARY_CODECS)
   {content::EME_CODEC_MP4_AAC, CODEC_AUDIO, "mp4a", "video/mp4"},
   {content::EME_CODEC_MP4_AVC1, CODEC_VIDEO, "avc1", "video/mp4"}

chrome/common/chrome_content_client.cc

@@ -279,6 +279,8 @@ void ComputeBuiltInPlugins(std::vector<content::PepperPluginInfo>* plugins) {
       std::vector<std::string> codecs;
       codecs.push_back(kCdmSupportedCodecVorbis);
       codecs.push_back(kCdmSupportedCodecVp8);
+      // TODO(xhwang): Add VP9 when it's supported by Widevine CDM.
+      // See http://crbug.com/361318
 #if defined(USE_PROPRIETARY_CODECS)
 // TODO(ddorwin): Rename these macros to reflect their real meaning: whether the
 // CDM Chrome was built [and shipped] with support these types.

chrome/renderer/media/chrome_key_systems.cc

@@ -220,6 +220,8 @@ static void AddPepperBasedWidevine(
       supported_codecs |= content::EME_CODEC_WEBM_VORBIS;
     if (codecs[i] == kCdmSupportedCodecVp8)
       supported_codecs |= content::EME_CODEC_WEBM_VP8;
+    if (codecs[i] == kCdmSupportedCodecVp9)
+      supported_codecs |= content::EME_CODEC_WEBM_VP9;
 #if defined(USE_PROPRIETARY_CODECS)
     if (codecs[i] == kCdmSupportedCodecAac)
       supported_codecs |= content::EME_CODEC_MP4_AAC;

content/public/common/eme_codec.h

@@ -15,12 +15,13 @@ enum EmeCodec {
   EME_CODEC_WEBM_VORBIS = 1 << 0,
   EME_CODEC_WEBM_AUDIO_ALL = EME_CODEC_WEBM_VORBIS,
   EME_CODEC_WEBM_VP8 = 1 << 1,
-  EME_CODEC_WEBM_VIDEO_ALL = EME_CODEC_WEBM_VP8,
+  EME_CODEC_WEBM_VP9 = 1 << 2,
+  EME_CODEC_WEBM_VIDEO_ALL = (EME_CODEC_WEBM_VP8 | EME_CODEC_WEBM_VP9),
   EME_CODEC_WEBM_ALL = (EME_CODEC_WEBM_AUDIO_ALL | EME_CODEC_WEBM_VIDEO_ALL),
 #if defined(USE_PROPRIETARY_CODECS)
-  EME_CODEC_MP4_AAC = 1 << 2,
+  EME_CODEC_MP4_AAC = 1 << 3,
   EME_CODEC_MP4_AUDIO_ALL = EME_CODEC_MP4_AAC,
-  EME_CODEC_MP4_AVC1 = 1 << 3,
+  EME_CODEC_MP4_AVC1 = 1 << 4,
   EME_CODEC_MP4_VIDEO_ALL = EME_CODEC_MP4_AVC1,
   EME_CODEC_MP4_ALL = (EME_CODEC_MP4_AUDIO_ALL | EME_CODEC_MP4_VIDEO_ALL),
   EME_CODEC_ALL = (EME_CODEC_WEBM_ALL | EME_CODEC_MP4_ALL),

content/renderer/media/crypto/key_systems.cc

@@ -50,6 +50,8 @@ CodecMask kCodecMasks[] = {
     {"vorbis", EME_CODEC_WEBM_VORBIS},
     {"vp8", EME_CODEC_WEBM_VP8},
     {"vp8.0", EME_CODEC_WEBM_VP8},
+    {"vp9", EME_CODEC_WEBM_VP9},
+    {"vp9.0", EME_CODEC_WEBM_VP9},
 #if defined(USE_PROPRIETARY_CODECS)
     {"mp4a", EME_CODEC_MP4_AAC},
     {"avc1", EME_CODEC_MP4_AVC1},
@@ -60,11 +62,18 @@ CodecMask kCodecMasks[] = {
 static void AddClearKey(std::vector<KeySystemInfo>* concrete_key_systems) {
   KeySystemInfo info(kClearKeyKeySystem);
 
-  // On Android, Vorbis, VP8, AAC and AVC1 are supported in all MediaCodec
-  // implementations:
+  // On Android, Vorbis, VP8, AAC and AVC1 are supported in MediaCodec:
   // http://developer.android.com/guide/appendix/media-formats.html
+  // VP9 support is device dependent.
 
   info.supported_codecs = EME_CODEC_WEBM_ALL;
+
+#if defined(OS_ANDROID)
+  // Temporarily disable VP9 support for Android.
+  // TODO(xhwang): Use mime_util.h to query VP9 support on Android.
+  info.supported_codecs &= ~EME_CODEC_WEBM_VP9;
+#endif  // defined(OS_ANDROID)
+
 #if defined(USE_PROPRIETARY_CODECS)
   info.supported_codecs |= EME_CODEC_MP4_ALL;
 #endif  // defined(USE_PROPRIETARY_CODECS)

content/renderer/media/crypto/key_systems_unittest.cc

@@ -120,11 +120,18 @@ class KeySystemsTest : public testing::Test {
 
     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");
@@ -167,10 +174,17 @@ class KeySystemsTest : public testing::Test {
 
   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 {
@@ -188,11 +202,13 @@ class KeySystemsTest : public testing::Test {
 
  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_;
@@ -282,6 +298,12 @@ TEST_F(KeySystemsTest,
       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));
 
@@ -304,6 +326,10 @@ TEST_F(KeySystemsTest,
       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(
@@ -476,6 +502,12 @@ TEST_F(
       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(
       kVideoWebM, vorbis_codec(), kExternal));
 
@@ -488,6 +520,12 @@ TEST_F(
       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));
 
@@ -516,6 +554,10 @@ TEST_F(
       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(

third_party/widevine/cdm/widevine_cdm_common.h

@@ -51,6 +51,7 @@ const char kCdmSupportedCodecsParamName[] = "codecs";
 const char kCdmSupportedCodecsValueDelimiter = ',';
 const char kCdmSupportedCodecVorbis[] = "vorbis";
 const char kCdmSupportedCodecVp8[] = "vp8";
+const char kCdmSupportedCodecVp9[] = "vp9.0";
 #if defined(USE_PROPRIETARY_CODECS)
 const char kCdmSupportedCodecAac[] = "aac";
 const char kCdmSupportedCodecAvc1[] = "avc1";