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");

[acolwell GONE FROM CHROMIUM, 2014/06/02 21:22:42]

nit: Why is this called aac_codec_? mp4a.40 does not refer to AAC. You must have
mp4a.40.2 or mp4a.40.5 to represent AAC. Please change the string to one of
these if you are actually trying to test AAC. Otherwise use a different name.

[amogh.bihani, 2014/06/03 13:26:12]

Yes, this is non-compliant, this is just to keep the variable name in sync with
the other variable names, like avc1_codec_.

In one of the messages in this patch[1], ddorwin@ had told me to add these
extended tests in another CL.
" I see how this makes sense. Maybe we should (in a separate CL) merge
extended codecs since they are more relevant now."

Since we have do not have 'mp4a' in kProprietaryAudioCodecsExpression in
mime_util, these tests were failing. I added '.40' so that the tests may pass. I
shall clean this up in the next CL. :)

Or should I name it 'mpeg_audio_codec_' here itself?

---------
[1] https://codereview.chromium.org/254983006/#msg5

[acolwell GONE FROM CHROMIUM, 2014/06/09 23:50:31]

It doesn't make sense to keep the variable names consistant if the names don't
actually point to data that makes sense with those names.
If I understand you correctly, mp4a.40.2 should also pass the tests. I'm
suggesting that you use mp4a.40.2 instead because that actually refers to AAC
content which would make the variable name and the actual data you are putting
in that variable consistent.

 
     avc1_and_aac_codecs_.push_back("avc1");
-    avc1_and_aac_codecs_.push_back("mp4a");
+    avc1_and_aac_codecs_.push_back("mp4a.40");

[acolwell GONE FROM CHROMIUM, 2014/06/02 21:22:42]

ditto.

+
+    avc3_and_aac_codecs_.push_back("avc3");
+    avc3_and_aac_codecs_.push_back("mp4a.40");

[acolwell GONE FROM CHROMIUM, 2014/06/02 21:22:42]

ditto.

 
     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_; }
@@ skipping 10 matching lines @@
   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& 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 90 matching lines @@
   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 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.
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
       "video/mp4", avc2_codec(), 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));
@@ skipping 104 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.
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
       "video/mp4", avc2_codec(), 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.
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
       "audio/mp4", vorbis_codec(), kExternalClearKey));
 }
 
 //
 // Widevine
 //
 
@@ skipping 94 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.
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
       "video/mp4", avc2_codec(), 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.
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
       "audio/mp4", vorbis_codec(), kWidevineAlpha));
 }
 
 IN_PROC_BROWSER_TEST_F(EncryptedMediaIsTypeSupportedWidevineTest,
                        Widevine_HR_Basic) {
   // HR support cannot be detected in tests, so this is expected to fail
   // everywhere.
@@ skipping 69 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