Fix: Adding list of supported codecs for MP4 containers

chrome/browser/media/encrypted_media_istypesupported_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 <string>
 #include <vector>
 
 #include "base/base_switches.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
@@ skipping 104 matching lines @@
     avc1_codec_.push_back("avc1");
 
     avc1_extended_codec_.push_back("avc1.4D400C");
 
     avc1_dot_codec_.push_back("avc1.");
 
     avc2_codec_.push_back("avc2");
 
     avc3_codec_.push_back("avc3");
 
-    avc3_extended_codec_.push_back("avc3.64001f");
+    avc3_extended_codec_.push_back("avc3.64001F");
 
-    aac_codec_.push_back("mp4a");
+    aac_codec_.push_back("mp4a.40.2");
+
+    mp4a_invalid_no_extension_.push_back("mp4a");
 
     avc1_and_aac_codecs_.push_back("avc1");
-    avc1_and_aac_codecs_.push_back("mp4a");
+    avc1_and_aac_codecs_.push_back("mp4a.40.2");
+
+    avc3_and_aac_codecs_.push_back("avc3");
+    avc3_and_aac_codecs_.push_back("mp4a.40.2");
 
     unknown_codec_.push_back("foo");
 
     mixed_codecs_.push_back("vorbis");
     mixed_codecs_.push_back("avc1");
+
+    vp8_invalid_extension_codec_.push_back("vp8.1");
   }
 
   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& avc1_codec() const { return avc1_codec_; }
   const CodecVector& avc1_extended_codec() const {
     return avc1_extended_codec_;
   }
   const CodecVector& avc1_dot_codec() const { return avc1_dot_codec_; }
   const CodecVector& avc2_codec() const { return avc2_codec_; }
   const CodecVector& avc3_codec() const { return avc3_codec_; }
   const CodecVector& avc3_extended_codec() const {
     return avc3_extended_codec_;
   }
   const CodecVector& aac_codec() const { return aac_codec_; }
+  const CodecVector& mp4a_invalid_no_extension() const {
+    return mp4a_invalid_no_extension_;
+  }
   const CodecVector& avc1_and_aac_codecs() const {
     return avc1_and_aac_codecs_;
   }
+  const CodecVector& avc3_and_aac_codecs() const {
+    return avc3_and_aac_codecs_;
+  }
   const CodecVector& unknown_codec() const { return unknown_codec_; }
   const CodecVector& mixed_codecs() const { return mixed_codecs_; }
+  const CodecVector& vp8_invalid_extension_codec() const {
+    return vp8_invalid_extension_codec_;
+  }
 
   // Update the command line to load |adapter_name| for
   // |pepper_type_for_key_system|.
   void RegisterPepperCdm(CommandLine* command_line,
                          const std::string& adapter_name,
                          const std::string& pepper_type_for_key_system,
                          bool expect_adapter_exists = true) {
     DCHECK(!is_pepper_cdm_registered_)
         << "RegisterPepperCdm() can only be called once.";
     is_pepper_cdm_registered_ = true;
@@ skipping 89 matching lines @@
   CodecVector vorbis_codec_;
   CodecVector vp8_and_vorbis_codecs_;
   CodecVector vp9_and_vorbis_codecs_;
   CodecVector avc1_codec_;
   CodecVector avc1_extended_codec_;
   CodecVector avc1_dot_codec_;
   CodecVector avc2_codec_;
   CodecVector avc3_codec_;
   CodecVector avc3_extended_codec_;
   CodecVector aac_codec_;
+  CodecVector mp4a_invalid_no_extension_;
   CodecVector avc1_and_aac_codecs_;
+  CodecVector avc3_and_aac_codecs_;
   CodecVector unknown_codec_;
   CodecVector mixed_codecs_;
+  CodecVector vp8_invalid_extension_codec_;
   bool is_test_page_loaded_;
   bool is_pepper_cdm_registered_;
 };
 
 // For ExternalClearKey tests, ensure that the ClearKey adapter is loaded.
 class EncryptedMediaIsTypeSupportedExternalClearKeyTest
     : public EncryptedMediaIsTypeSupportedTest {
 #if defined(ENABLE_PEPPER_CDMS)
  protected:
   virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
@@ skipping 159 matching lines @@
       "video/webm", vp90_codec(), kPrefixedClearKey));
   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
       "video/webm", vp9_and_vorbis_codecs(), kPrefixedClearKey));
   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
       "video/webm", vorbis_codec(), kPrefixedClearKey));
 
   // Non-Webm codecs.
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
       "video/webm", avc1_codec(), kPrefixedClearKey));
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
+      "video/webm", avc3_codec(), kPrefixedClearKey));
+  EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
       "video/webm", unknown_codec(), kPrefixedClearKey));
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
       "video/webm", mixed_codecs(), kPrefixedClearKey));
+  EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
+      "video/webm", vp8_invalid_extension_codec(), kPrefixedClearKey));
 
   // Valid audio types.
   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
       "audio/webm", no_codecs(), kPrefixedClearKey));
   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
       "audio/webm", vorbis_codec(), kPrefixedClearKey));
 
   // Non-audio codecs.
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
       "audio/webm", vp8_codec(), kPrefixedClearKey));
@@ skipping 17 matching lines @@
   // The parent should be supported but is not. See http://crbug.com/164303.
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
       "video/mp4", no_codecs(), kPrefixedClearKeyParent));
   EXPECT_PROPRIETARY(IsSupportedKeySystemWithMediaMimeType(
       "video/mp4", avc1_codec(), kPrefixedClearKey));
   EXPECT_PROPRIETARY(IsSupportedKeySystemWithMediaMimeType(
       "video/mp4", avc1_and_aac_codecs(), kPrefixedClearKey));
   EXPECT_PROPRIETARY(IsSupportedKeySystemWithMediaMimeType(
       "video/mp4", avc3_codec(), kPrefixedClearKey));
   EXPECT_PROPRIETARY(IsSupportedKeySystemWithMediaMimeType(
+      "video/mp4", avc3_and_aac_codecs(), kPrefixedClearKey));
+  EXPECT_PROPRIETARY(IsSupportedKeySystemWithMediaMimeType(
       "video/mp4", aac_codec(), kPrefixedClearKey));
 
   // Extended codecs.
   EXPECT_PROPRIETARY(IsSupportedKeySystemWithMediaMimeType(
       "video/mp4", avc1_extended_codec(), kPrefixedClearKey));
   EXPECT_PROPRIETARY(IsSupportedKeySystemWithMediaMimeType(
       "video/mp4", avc3_extended_codec(), kPrefixedClearKey));
 
-  // Invalid codec format, but canPlayType() strips away the period.
-  EXPECT_PROPRIETARY(IsSupportedKeySystemWithMediaMimeType(
+  // Invalid codec format: profile parameter must be present after the period.
+  EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
       "video/mp4", avc1_dot_codec(), kPrefixedClearKey));
 
-  // Non-MP4 codecs.
+  // Invalid or Non-MP4 codecs.
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
       "video/mp4", avc2_codec(), kPrefixedClearKey));
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
+      "video/mp4", mp4a_invalid_no_extension(), kPrefixedClearKey));
+  EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
       "video/mp4", vp8_codec(), kPrefixedClearKey));
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
       "video/mp4", unknown_codec(), kPrefixedClearKey));
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
       "video/mp4", mixed_codecs(), kPrefixedClearKey));
+  EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
+      "video/mp4", vp8_invalid_extension_codec(), kPrefixedClearKey));
 
   // Valid audio types.
   EXPECT_PROPRIETARY(IsSupportedKeySystemWithMediaMimeType(
       "audio/mp4", no_codecs(), kPrefixedClearKey));
   EXPECT_PROPRIETARY(IsSupportedKeySystemWithMediaMimeType(
       "audio/mp4", aac_codec(), kPrefixedClearKey));
 
   // Non-audio codecs.
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
       "audio/mp4", avc1_codec(), kPrefixedClearKey));
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
       "audio/mp4", avc1_and_aac_codecs(), kPrefixedClearKey));
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
       "audio/mp4", avc3_codec(), kPrefixedClearKey));
 
-  // Non-MP4 codec.
+  // Invalid or Non-MP4 codec.
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
       "audio/mp4", vorbis_codec(), kPrefixedClearKey));
+  EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
+      "audio/mp4", mp4a_invalid_no_extension(), kPrefixedClearKey));
 }
 
 //
 // External Clear Key
 //
 
 // When defined(ENABLE_PEPPER_CDMS), this also tests the Pepper CDM check.
 IN_PROC_BROWSER_TEST_F(EncryptedMediaIsTypeSupportedExternalClearKeyTest,
                        ExternalClearKey_Basic) {
   EXPECT_ECK(IsConcreteSupportedKeySystem(kExternalClearKey));
@@ skipping 86 matching lines @@
       "video/webm", vp90_codec(), kExternalClearKey));
   EXPECT_ECK(IsSupportedKeySystemWithMediaMimeType(
       "video/webm", vp9_and_vorbis_codecs(), kExternalClearKey));
   EXPECT_ECK(IsSupportedKeySystemWithMediaMimeType(
       "video/webm", vorbis_codec(), kExternalClearKey));
 
   // Non-Webm codecs.
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
       "video/webm", avc1_codec(), kExternalClearKey));
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
+      "video/webm", avc3_codec(), kExternalClearKey));
+  EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
       "video/webm", unknown_codec(), kExternalClearKey));
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
       "video/webm", mixed_codecs(), kExternalClearKey));
+  EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
+      "video/webm", vp8_invalid_extension_codec(), kExternalClearKey));
 
   // Valid audio types.
   EXPECT_ECK(IsSupportedKeySystemWithMediaMimeType(
       "audio/webm", no_codecs(), kExternalClearKey));
   EXPECT_ECK(IsSupportedKeySystemWithMediaMimeType(
       "audio/webm", vorbis_codec(), kExternalClearKey));
 
   // Non-audio codecs.
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
       "audio/webm", vp8_codec(), kExternalClearKey));
@@ skipping 18 matching lines @@
   // The parent should be supported but is not. See http://crbug.com/164303.
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
       "video/mp4", no_codecs(), "org.chromium"));
   EXPECT_ECKPROPRIETARY(IsSupportedKeySystemWithMediaMimeType(
       "video/mp4", avc1_codec(), kExternalClearKey));
   EXPECT_ECKPROPRIETARY(IsSupportedKeySystemWithMediaMimeType(
       "video/mp4", avc1_and_aac_codecs(), kExternalClearKey));
   EXPECT_ECKPROPRIETARY(IsSupportedKeySystemWithMediaMimeType(
       "video/mp4", avc3_codec(), kExternalClearKey));
   EXPECT_ECKPROPRIETARY(IsSupportedKeySystemWithMediaMimeType(
+      "video/mp4", avc3_and_aac_codecs(), kExternalClearKey));
+  EXPECT_ECKPROPRIETARY(IsSupportedKeySystemWithMediaMimeType(
       "video/mp4", aac_codec(), kExternalClearKey));
 
   // Extended codecs.
   EXPECT_ECKPROPRIETARY(IsSupportedKeySystemWithMediaMimeType(
       "video/mp4", avc1_extended_codec(), kExternalClearKey));
   EXPECT_ECKPROPRIETARY(IsSupportedKeySystemWithMediaMimeType(
       "video/mp4", avc3_extended_codec(), kExternalClearKey));
 
-  // Invalid codec format, but canPlayType() strips away the period.
-  EXPECT_ECKPROPRIETARY(IsSupportedKeySystemWithMediaMimeType(
+  // Invalid codec format: profile parameter must be present after the period.
+  EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
       "video/mp4", avc1_dot_codec(), kExternalClearKey));
 
-  // Non-MP4 codecs.
+  // Invalid or Non-MP4 codecs.
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
       "video/mp4", avc2_codec(), kExternalClearKey));
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
+      "video/mp4", mp4a_invalid_no_extension(), kExternalClearKey));
+  EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
       "video/mp4", vp8_codec(), kExternalClearKey));
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
       "video/mp4", unknown_codec(), kExternalClearKey));
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
       "video/mp4", mixed_codecs(), kExternalClearKey));
+  EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
+      "video/mp4", vp8_invalid_extension_codec(), kExternalClearKey));
 
   // Valid audio types.
   EXPECT_ECKPROPRIETARY(IsSupportedKeySystemWithMediaMimeType(
       "audio/mp4", no_codecs(), kExternalClearKey));
   EXPECT_ECKPROPRIETARY(IsSupportedKeySystemWithMediaMimeType(
       "audio/mp4", aac_codec(), kExternalClearKey));
 
   // Non-audio codecs.
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
       "audio/mp4", avc1_codec(), kExternalClearKey));
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
       "audio/mp4", avc1_and_aac_codecs(), kExternalClearKey));
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
       "audio/mp4", avc3_codec(), kExternalClearKey));
+  EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
+      "audio/mp4", avc3_and_aac_codecs(), kExternalClearKey));
 
-  // Non-MP4 codec.
+  // Invalid or Non-MP4 codec.
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
       "audio/mp4", vorbis_codec(), kExternalClearKey));
+  EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
+      "audio/mp4", mp4a_invalid_no_extension(), kExternalClearKey));
 }
 
 //
 // Widevine
 //
 
 IN_PROC_BROWSER_TEST_F(EncryptedMediaIsTypeSupportedWidevineTest,
                        Widevine_Basic) {
 #if defined(WIDEVINE_CDM_AVAILABLE) && defined(WIDEVINE_CDM_IS_COMPONENT)
   EXPECT_TRUE(IsConcreteSupportedKeySystem(kWidevineAlpha));
@@ skipping 90 matching lines @@
       "video/webm", vp80_codec(), kWidevine));
   EXPECT_WV(IsSupportedKeySystemWithMediaMimeType(
       "video/webm", vp8_and_vorbis_codecs(), kWidevine));
   EXPECT_WV(IsSupportedKeySystemWithMediaMimeType(
       "video/webm", vorbis_codec(), kWidevine));
 
   // Non-Webm codecs.
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
       "video/webm", avc1_codec(), kWidevineAlpha));
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
+      "video/webm", avc3_codec(), kWidevineAlpha));
+  EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
       "video/webm", unknown_codec(), kWidevineAlpha));
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
       "video/webm", mixed_codecs(), kWidevineAlpha));
+  EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
+      "video/webm", vp8_invalid_extension_codec(), kWidevineAlpha));
 
   // Valid audio types.
   EXPECT_WV(IsSupportedKeySystemWithMediaMimeType(
       "audio/webm", no_codecs(), kWidevineAlpha));
   EXPECT_WV(IsSupportedKeySystemWithMediaMimeType(
       "audio/webm", vorbis_codec(), kWidevineAlpha));
 
   // Valid audio types - parent key system.
   EXPECT_WV(IsSupportedKeySystemWithMediaMimeType(
       "audio/webm", no_codecs(), kWidevine));
@@ skipping 16 matching lines @@
   // Valid video types.
   EXPECT_WVMP4(IsSupportedKeySystemWithMediaMimeType(
       "video/mp4", no_codecs(), kWidevineAlpha));
   EXPECT_WVAVC1(IsSupportedKeySystemWithMediaMimeType(
       "video/mp4", avc1_codec(), kWidevineAlpha));
   EXPECT_WVAVC1AAC(IsSupportedKeySystemWithMediaMimeType(
       "video/mp4", avc1_and_aac_codecs(), kWidevineAlpha));
   EXPECT_WVAVC1(IsSupportedKeySystemWithMediaMimeType(
       "video/mp4", avc3_codec(), kWidevineAlpha));
   EXPECT_WVAVC1AAC(IsSupportedKeySystemWithMediaMimeType(
+      "video/mp4", avc3_and_aac_codecs(), kWidevineAlpha));
+  EXPECT_WVAVC1AAC(IsSupportedKeySystemWithMediaMimeType(
       "video/mp4", aac_codec(), kWidevineAlpha));
 
   // Valid video types - parent key system.
   EXPECT_WVMP4(IsSupportedKeySystemWithMediaMimeType(
       "video/mp4", no_codecs(), kWidevine));
   EXPECT_WVAVC1(IsSupportedKeySystemWithMediaMimeType(
       "video/mp4", avc1_codec(), kWidevine));
   EXPECT_WVAVC1AAC(IsSupportedKeySystemWithMediaMimeType(
       "video/mp4", avc1_and_aac_codecs(), kWidevine));
+  EXPECT_WVAVC1(IsSupportedKeySystemWithMediaMimeType(
+      "video/mp4", avc3_codec(), kWidevine));
+  EXPECT_WVAVC1AAC(IsSupportedKeySystemWithMediaMimeType(
+      "video/mp4", avc3_and_aac_codecs(), kWidevine));
   EXPECT_WVAVC1AAC(IsSupportedKeySystemWithMediaMimeType(
       "video/mp4", aac_codec(), kWidevine));
 
   // Extended codecs.
   EXPECT_WVAVC1(IsSupportedKeySystemWithMediaMimeType(
       "video/mp4", avc1_extended_codec(), kWidevineAlpha));
   EXPECT_WVAVC1(IsSupportedKeySystemWithMediaMimeType(
       "video/mp4", avc3_extended_codec(), kWidevineAlpha));
 
-  // Invalid codec format, but canPlayType() strips away the period.
-  EXPECT_WVAVC1(IsSupportedKeySystemWithMediaMimeType(
+  // Invalid codec format: profile paramter must be present after the period.
+  EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
       "video/mp4", avc1_dot_codec(), kWidevineAlpha));
 
-  // Non-MP4 codecs.
+  // Invalid or Non-MP4 codecs.
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
       "video/mp4", avc2_codec(), kWidevineAlpha));
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
+      "video/mp4", mp4a_invalid_no_extension(), kWidevineAlpha));
+  EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
       "video/mp4", vp8_codec(), kWidevineAlpha));
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
       "video/mp4", unknown_codec(), kWidevineAlpha));
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
       "video/mp4", mixed_codecs(), kWidevineAlpha));
+  EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
+      "video/mp4", vp8_invalid_extension_codec(), kWidevineAlpha));
 
   // Valid audio types.
   EXPECT_WVMP4(IsSupportedKeySystemWithMediaMimeType(
       "audio/mp4", no_codecs(), kWidevineAlpha));
   EXPECT_WVAAC(IsSupportedKeySystemWithMediaMimeType(
       "audio/mp4", aac_codec(), kWidevineAlpha));
 
   // Valid audio types - parent key system.
   EXPECT_WVMP4(IsSupportedKeySystemWithMediaMimeType(
       "audio/mp4", no_codecs(), kWidevine));
   EXPECT_WVAAC(IsSupportedKeySystemWithMediaMimeType(
       "audio/mp4", aac_codec(), kWidevine));
 
   // Non-audio codecs.
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
       "audio/mp4", avc1_codec(), kWidevineAlpha));
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
       "audio/mp4", avc1_and_aac_codecs(), kWidevineAlpha));
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
       "audio/mp4", avc3_codec(), kWidevineAlpha));
+  EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
+      "audio/mp4", avc3_and_aac_codecs(), kWidevineAlpha));
 
-  // Non-MP4 codec.
+  // Invalid or Non-MP4 codec.
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
       "audio/mp4", vorbis_codec(), kWidevineAlpha));
+  EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
+      "audio/mp4", mp4a_invalid_no_extension(), kWidevineAlpha));
 }
 
 IN_PROC_BROWSER_TEST_F(EncryptedMediaIsTypeSupportedWidevineTest,
                        Widevine_HR_Basic) {
   // HR support cannot be detected in tests, so this is expected to fail
   // everywhere.
   EXPECT_FALSE(IsConcreteSupportedKeySystem(kWidevineAlphaHr));
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
       "video/webm", no_codecs(), kWidevineAlphaHr));
 }
@@ skipping 65 matching lines @@
     EncryptedMediaIsTypeSupportedWidevineCDMRegisteredWithWrongPathTest,
     PepperCDMsRegisteredButAdapterNotPresent) {
   EXPECT_FALSE(IsConcreteSupportedKeySystem(kWidevineAlpha));
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
       "video/webm", no_codecs(), kWidevineAlpha));
 }
 #endif  // !defined(WIDEVINE_CDM_AVAILABLE) || defined(WIDEVINE_CDM_IS_COMPONENT)
 #endif  // defined(ENABLE_PEPPER_CDMS)
 
 }  // namespace chrome