Add EME support for new VP9 codec string in WebM.

chrome/browser/media/encrypted_media_supported_types_browsertest.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 <stddef.h>
 
 #include <string>
 #include <vector>
 
 #include "base/base_switches.h"
@@ skipping 101 matching lines @@
     video_webm_codecs_.push_back("vp8.0");
     video_webm_codecs_.push_back("vp9");
     video_webm_codecs_.push_back("vp9.0");
 
     audio_mp4_codecs_.push_back("mp4a.40.2");
 
     video_mp4_codecs_.push_back("avc1.42001E");  // Baseline profile.
     video_mp4_codecs_.push_back("avc1.4D000C");  // Main profile.
     video_mp4_codecs_.push_back("avc3.64001F");  // High profile.
 
-    video_mp4_codecs_.push_back("vp09.00.10.08");
-
     video_mp4_hi10p_codecs_.push_back("avc1.6E001E");  // Hi10P profile
 
 #if BUILDFLAG(ENABLE_HEVC_DEMUXING)
     video_mp4_codecs_.push_back("hvc1.1.6.L93.B0");
     video_mp4_codecs_.push_back("hev1.1.6.L93.B0");
 #else
     invalid_codecs_.push_back("hvc1.1.6.L93.B0");
     invalid_codecs_.push_back("hev1.1.6.L93.B0");
 #endif
 
+    // Codecs allowed by both MP4 and WebM (with given command line flags).
+    video_common_codecs_.push_back("vp09.00.10.08");
+
     // Extended codecs are used, so make sure generic ones fail. These will be
     // tested against all initDataTypes as they should always fail to be
     // supported.
     invalid_codecs_.push_back("avc1");
     invalid_codecs_.push_back("avc1.");
     invalid_codecs_.push_back("avc3");
 
     // Other invalid codecs.
     invalid_codecs_.push_back("vp8.1");
     invalid_codecs_.push_back("mp4a");
     invalid_codecs_.push_back("avc2");
     invalid_codecs_.push_back("foo");
 
     // We only support proper long-form HEVC codec ids.
     invalid_codecs_.push_back("hev1");
     invalid_codecs_.push_back("hev1.");
     invalid_codecs_.push_back("hvc1");
     invalid_codecs_.push_back("hvc1.");
   }
 
   void SetUpCommandLine(base::CommandLine* command_line) override {
     InProcessBrowserTest::SetUpCommandLine(command_line);
     command_line->AppendSwitch(switches::kEnableVp9InMp4);
+    command_line->AppendSwitch(switches::kEnableNewVp9CodecString);
   }
 
   typedef std::vector<std::string> CodecVector;
 
   const CodecVector& no_codecs() const { return no_codecs_; }
+  const CodecVector& video_common_codecs() const {
+    return video_common_codecs_;
+  }
   const CodecVector& audio_webm_codecs() const { return audio_webm_codecs_; }
   const CodecVector& video_webm_codecs() const { return video_webm_codecs_; }
   const CodecVector& audio_mp4_codecs() const { return audio_mp4_codecs_; }
   const CodecVector& video_mp4_codecs() const { return video_mp4_codecs_; }
   const CodecVector& video_mp4_hi10p_codecs() const {
     return video_mp4_hi10p_codecs_;
   }
   const CodecVector& invalid_codecs() const { return invalid_codecs_; }
 
 #if BUILDFLAG(ENABLE_PEPPER_CDMS)
@@ skipping 90 matching lines @@
                           command);
   }
 
  private:
   const CodecVector no_codecs_;
   CodecVector audio_webm_codecs_;
   CodecVector video_webm_codecs_;
   CodecVector audio_mp4_codecs_;
   CodecVector video_mp4_codecs_;
   CodecVector video_mp4_hi10p_codecs_;
+  CodecVector video_common_codecs_;
   CodecVector invalid_codecs_;
 };
 
 // For ClearKey, nothing additional is required.
 class EncryptedMediaSupportedTypesClearKeyTest
     : public EncryptedMediaSupportedTypesTest {
 };
 
 // For ExternalClearKey tests, ensure that the ClearKey adapter is loaded.
 class EncryptedMediaSupportedTypesExternalClearKeyTest
@@ skipping 115 matching lines @@
 
   // There are no child key systems for Clear Key.
   EXPECT_UNKNOWN_KEYSYSTEM(AreCodecsSupportedByKeySystem(
       kVideoWebMMimeType, video_webm_codecs(), "org.w3.clearkey.foo"));
 }
 
 IN_PROC_BROWSER_TEST_F(EncryptedMediaSupportedTypesClearKeyTest, Video_WebM) {
   // Valid video types.
   EXPECT_SUCCESS(AreCodecsSupportedByKeySystem(
       kVideoWebMMimeType, video_webm_codecs(), kClearKey));
+  EXPECT_SUCCESS(AreCodecsSupportedByKeySystem(
+      kVideoWebMMimeType, video_common_codecs(), kClearKey));
 
   // Non-video WebM codecs.
   EXPECT_NO_MATCH(AreCodecsSupportedByKeySystem(
       kVideoWebMMimeType, audio_webm_codecs(), kClearKey));
 
   // Invalid or non-Webm video codecs.
   EXPECT_NO_MATCH(AreCodecsSupportedByKeySystem(
       kVideoWebMMimeType, invalid_codecs(), kClearKey));
   EXPECT_NO_MATCH(AreCodecsSupportedByKeySystem(
       kVideoWebMMimeType, audio_mp4_codecs(), kClearKey));
@@ skipping 16 matching lines @@
   EXPECT_NO_MATCH(AreCodecsSupportedByKeySystem(
       kAudioWebMMimeType, audio_mp4_codecs(), kClearKey));
   EXPECT_NO_MATCH(AreCodecsSupportedByKeySystem(
       kAudioWebMMimeType, video_mp4_codecs(), kClearKey));
 }
 
 IN_PROC_BROWSER_TEST_F(EncryptedMediaSupportedTypesClearKeyTest, Video_MP4) {
   // Valid video types.
   EXPECT_PROPRIETARY(AreCodecsSupportedByKeySystem(
       kVideoMP4MimeType, video_mp4_codecs(), kClearKey));
+  EXPECT_SUCCESS(AreCodecsSupportedByKeySystem(
+      kVideoWebMMimeType, video_common_codecs(), kClearKey));
 
   // High 10-bit Profile is supported when using ClearKey if
   // it is supported for clear content on this platform.
 #if !defined(MEDIA_DISABLE_FFMPEG) && !defined(OS_ANDROID)
   EXPECT_PROPRIETARY(AreCodecsSupportedByKeySystem(
       kVideoMP4MimeType, video_mp4_hi10p_codecs(), kClearKey));
 #else
   EXPECT_NO_MATCh(AreCodecsSupportedByKeySystem(
       kVideoMP4MimeType, video_mp4_hi10p_codecs(), kClearKey));
 #endif
@@ skipping 88 matching lines @@
   EXPECT_UNKNOWN_KEYSYSTEM(
       AreCodecsSupportedByKeySystem(kVideoWebMMimeType, video_webm_codecs(),
                                     "org.chromium.externalclearkey.foo"));
 }
 
 IN_PROC_BROWSER_TEST_F(EncryptedMediaSupportedTypesExternalClearKeyTest,
                        Video_WebM) {
   // Valid video types.
   EXPECT_ECK(AreCodecsSupportedByKeySystem(
       kVideoWebMMimeType, video_webm_codecs(), kExternalClearKey));
+  EXPECT_ECK(AreCodecsSupportedByKeySystem(
+      kVideoWebMMimeType, video_common_codecs(), kExternalClearKey));
 
   // Non-video WebM codecs.
   EXPECT_ECK_NO_MATCH(AreCodecsSupportedByKeySystem(
       kVideoWebMMimeType, audio_webm_codecs(), kExternalClearKey));
 
   // Invalid or non-Webm codecs.
   EXPECT_ECK_NO_MATCH(AreCodecsSupportedByKeySystem(
       kVideoWebMMimeType, invalid_codecs(), kExternalClearKey));
   EXPECT_ECK_NO_MATCH(AreCodecsSupportedByKeySystem(
       kVideoWebMMimeType, audio_mp4_codecs(), kExternalClearKey));
@@ skipping 18 matching lines @@
       kAudioWebMMimeType, audio_mp4_codecs(), kExternalClearKey));
   EXPECT_ECK_NO_MATCH(AreCodecsSupportedByKeySystem(
       kAudioWebMMimeType, video_mp4_codecs(), kExternalClearKey));
 }
 
 IN_PROC_BROWSER_TEST_F(EncryptedMediaSupportedTypesExternalClearKeyTest,
                        Video_MP4) {
   // Valid video types.
   EXPECT_ECK_PROPRIETARY(AreCodecsSupportedByKeySystem(
       kVideoMP4MimeType, video_mp4_codecs(), kExternalClearKey));
+  EXPECT_ECK(AreCodecsSupportedByKeySystem(
+      kVideoWebMMimeType, video_common_codecs(), kExternalClearKey));
 
   // High 10-bit Profile is not supported when using ExternalClearKey.
   EXPECT_ECK_NO_MATCH(AreCodecsSupportedByKeySystem(
       kVideoMP4MimeType, video_mp4_hi10p_codecs(), kExternalClearKey));
 
   // Non-video MP4 codecs.
   EXPECT_ECK_NO_MATCH(AreCodecsSupportedByKeySystem(
       kVideoMP4MimeType, audio_mp4_codecs(), kExternalClearKey));
 
   // Invalid or non-MP4 codecs.
@@ skipping 42 matching lines @@
 
 IN_PROC_BROWSER_TEST_F(EncryptedMediaSupportedTypesWidevineTest, Basic) {
   EXPECT_WV_SUCCESS(AreCodecsSupportedByKeySystem(
       kVideoWebMMimeType, video_webm_codecs(), kWidevine));
   EXPECT_WV_SUCCESS(AreCodecsSupportedByKeySystem(
       kAudioWebMMimeType, audio_webm_codecs(), kWidevine));
   EXPECT_WV_PROPRIETARY(AreCodecsSupportedByKeySystem(
       kVideoMP4MimeType, video_mp4_codecs(), kWidevine));
   EXPECT_WV_PROPRIETARY(AreCodecsSupportedByKeySystem(
       kAudioMP4MimeType, audio_mp4_codecs(), kWidevine));
+  EXPECT_WV_PROPRIETARY(AreCodecsSupportedByKeySystem(
+      kAudioMP4MimeType, video_common_codecs(), kWidevine));
 }
 
 IN_PROC_BROWSER_TEST_F(EncryptedMediaSupportedTypesWidevineTest, NoCodecs) {
   EXPECT_WV_NO_MATCH(AreCodecsSupportedByKeySystem(kVideoWebMMimeType,
                                                    no_codecs(), kWidevine));
   EXPECT_WV_NO_MATCH(AreCodecsSupportedByKeySystem(kAudioWebMMimeType,
                                                    no_codecs(), kWidevine));
   EXPECT_WV_NO_MATCH(
       AreCodecsSupportedByKeySystem(kVideoMP4MimeType, no_codecs(), kWidevine));
   EXPECT_WV_NO_MATCH(
       AreCodecsSupportedByKeySystem(kAudioMP4MimeType, no_codecs(), kWidevine));
 }
 
 IN_PROC_BROWSER_TEST_F(EncryptedMediaSupportedTypesWidevineTest, Video_WebM) {
   // Valid video types.
   EXPECT_WV_SUCCESS(AreCodecsSupportedByKeySystem(
       kVideoWebMMimeType, video_webm_codecs(), kWidevine));
+  EXPECT_WV_SUCCESS(AreCodecsSupportedByKeySystem(
+      kVideoWebMMimeType, video_common_codecs(), kWidevine));
 
   // Non-video WebM codecs.
   EXPECT_WV_NO_MATCH(AreCodecsSupportedByKeySystem(
       kVideoWebMMimeType, audio_webm_codecs(), kWidevine));
 
   // Invalid or non-Webm codecs.
   EXPECT_WV_NO_MATCH(AreCodecsSupportedByKeySystem(
       kVideoWebMMimeType, invalid_codecs(), kWidevine));
   EXPECT_WV_NO_MATCH(AreCodecsSupportedByKeySystem(
       kVideoWebMMimeType, audio_mp4_codecs(), kWidevine));
@@ skipping 16 matching lines @@
   EXPECT_WV_NO_MATCH(AreCodecsSupportedByKeySystem(
       kAudioWebMMimeType, audio_mp4_codecs(), kWidevine));
   EXPECT_WV_NO_MATCH(AreCodecsSupportedByKeySystem(
       kAudioWebMMimeType, video_mp4_codecs(), kWidevine));
 }
 
 IN_PROC_BROWSER_TEST_F(EncryptedMediaSupportedTypesWidevineTest, Video_MP4) {
   // Valid video types.
   EXPECT_WV_PROPRIETARY(AreCodecsSupportedByKeySystem(
       kVideoMP4MimeType, video_mp4_codecs(), kWidevine));
+  EXPECT_WV_SUCCESS(AreCodecsSupportedByKeySystem(
+      kVideoWebMMimeType, video_common_codecs(), kWidevine));
 
   // High 10-bit Profile is not supported when using Widevine.
   EXPECT_WV_NO_MATCH(AreCodecsSupportedByKeySystem(
       kVideoMP4MimeType, video_mp4_hi10p_codecs(), kWidevine));
 
   // Non-video MP4 codecs.
   EXPECT_WV_NO_MATCH(AreCodecsSupportedByKeySystem(
       kVideoMP4MimeType, audio_mp4_codecs(), kWidevine));
 
   // Invalid or non-MP4 codecs.
@@ skipping 66 matching lines @@
       kVideoWebMMimeType, video_webm_codecs(), kWidevine));
 
   // Clear Key should still be registered.
   EXPECT_SUCCESS(AreCodecsSupportedByKeySystem(kVideoWebMMimeType,
                                                video_webm_codecs(), kClearKey));
 }
 #endif  // !defined(WIDEVINE_CDM_AVAILABLE)
 #endif  // BUILDFLAG(ENABLE_PEPPER_CDMS)
 
 }  // namespace chrome