Fix mime type mappings when the unified media pipeline is enabled.

media/base/mime_util_unittest.cc

 // Copyright 2015 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 "base/macros.h"
 #include "base/strings/string_split.h"
 #include "build/build_config.h"
 #include "media/base/mime_util.h"
+#include "media/base/mime_util_internal.h"
 #include "media/media_features.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace media {
 
+const bool kTestStates[] = {true, false};
+
 TEST(MimeUtilTest, CommonMediaMimeType) {
   EXPECT_TRUE(IsSupportedMediaMimeType("audio/webm"));
   EXPECT_TRUE(IsSupportedMediaMimeType("video/webm"));
 
   EXPECT_TRUE(IsSupportedMediaMimeType("audio/wav"));
   EXPECT_TRUE(IsSupportedMediaMimeType("audio/x-wav"));
 
   EXPECT_TRUE(IsSupportedMediaMimeType("audio/ogg"));
   EXPECT_TRUE(IsSupportedMediaMimeType("application/ogg"));
 #if defined(OS_ANDROID)
@@ skipping 78 matching lines @@
   }
 
   // Test without stripping the codec type.
   std::vector<std::string> codecs_out;
   ParseCodecString("avc1.42E01E, mp4a.40.2", &codecs_out, false);
   ASSERT_EQ(2u, codecs_out.size());
   EXPECT_EQ("avc1.42E01E", codecs_out[0]);
   EXPECT_EQ("mp4a.40.2", codecs_out[1]);
 }
 
+#if defined(OS_ANDROID)
+namespace internal {
+
+TEST(MimeUtilInternalTest, EncryptedCodecsFailWithoutPlatformSupport) {

[ddorwin, 2016/02/17 21:18:40]

These test names should include/refer to IsCodecSupportedOnAndroidForTests. i.e.
IsCodecSupportedOnAndroidForTests_EncryptedCodecsFailWithoutPlatformSupport,
though that is too long. Maybe drop "ForTests".

[DaleCurtis, 2016/02/18 03:58:10]

Done.

+  MimeUtil mime_util;
+  PlatformCodecInfo info;
+  info.has_platform_decoder = false;
+
+  const bool kTestStates[] = {true, false};

[ddorwin, 2016/02/17 21:18:40]

remove

[DaleCurtis, 2016/02/18 03:58:10]

Done.

+  for (bool has_unified_media_pipeline : kTestStates) {
+    info.has_unified_media_pipeline = has_unified_media_pipeline;
+    for (bool has_opus : kTestStates) {
+      info.has_opus = has_opus;
+      for (bool has_vp8 : kTestStates) {
+        info.has_vp8 = has_vp8;
+        for (bool has_vp9 : kTestStates) {
+          info.has_vp9 = has_vp9;
+          mime_util.SetPlatformCodecInfoForTests(info);
+          for (int codec = MimeUtil::INVALID_CODEC;
+               codec <= MimeUtil::LAST_CODEC; ++codec) {
+            ASSERT_FALSE(mime_util.IsCodecSupportedOnAndroidForTests(

[ddorwin, 2016/02/17 21:18:39]

EXPECT_ throughout. We want to run all cases even if one fails, right?

[DaleCurtis, 2016/02/18 03:58:10]

Done, but can be obnoxious in local runs if you fail 2^5 test cases :)

+                static_cast<MimeUtil::Codec>(codec), "", true));

[ddorwin, 2016/02/17 21:18:40]

It's interesting that the function allows an empty mime type string. Should that
be DCHECKed (and "foo" used here)?

[DaleCurtis, 2016/02/18 03:58:10]

I don't think it should since only one portion of the code actually cares about
this and that's verified below in the ogg / opus test.

[ddorwin, 2016/02/18 20:37:44]

Right, but isn't it a bug if the caller does not pass a valid string?

+          }
+        }
+      }
+    }
+  }
+}
+
+TEST(MimeUtilInternalTest, EncryptedCodecBehavior) {
+  MimeUtil mime_util;
+  PlatformCodecInfo info = {0};
+  info.has_platform_decoder = true;  // False is tested above.
+  for (bool has_unified_media_pipeline : kTestStates) {
+    info.has_unified_media_pipeline = has_unified_media_pipeline;
+    for (bool has_opus : kTestStates) {
+      info.has_opus = has_opus;
+      for (bool has_vp8 : kTestStates) {
+        info.has_vp8 = has_vp8;
+        for (bool has_vp9 : kTestStates) {
+          info.has_vp9 = has_vp9;
+          mime_util.SetPlatformCodecInfoForTests(info);
+          for (int codec = MimeUtil::INVALID_CODEC;
+               codec <= MimeUtil::LAST_CODEC; ++codec) {
+            const MimeUtil::Codec codec_type =

[ddorwin, 2016/02/17 21:18:40]

nit: codec type sounds like there are types of codecs. Perhaps
s/codec/codec_number/ or s/codec_type/codec_value/.

[DaleCurtis, 2016/02/18 03:58:10]

New format removes this.

+                static_cast<MimeUtil::Codec>(codec);
+            switch (codec_type) {
+              case MimeUtil::AC3:
+              case MimeUtil::EAC3:
+              case MimeUtil::INVALID_CODEC:
+              case MimeUtil::MPEG2_AAC_LC:
+              case MimeUtil::MPEG2_AAC_MAIN:
+              case MimeUtil::MPEG2_AAC_SSR:
+              case MimeUtil::THEORA:
+                ASSERT_FALSE(mime_util.IsCodecSupportedOnAndroidForTests(

[ddorwin, 2016/02/17 21:18:40]

If one of these fails, it's going to be difficult to know which combination
failed. Perhaps we should add "<< PrintInfo(info)" and implement the print
function.

[DaleCurtis, 2016/02/18 03:58:09]

Done.

+                    codec_type, "", true));
+                break;
+
+              case MimeUtil::H264_BASELINE:
+              case MimeUtil::H264_MAIN:
+              case MimeUtil::H264_HIGH:
+              case MimeUtil::PCM:
+              case MimeUtil::MP3:
+              case MimeUtil::MPEG4_AAC_LC:
+              case MimeUtil::MPEG4_AAC_SBR_v1:
+              case MimeUtil::MPEG4_AAC_SBR_PS_v2:
+              case MimeUtil::VORBIS:
+                ASSERT_TRUE(mime_util.IsCodecSupportedOnAndroidForTests(
+                    codec_type, "", true));
+                break;
+
+              case MimeUtil::OPUS:
+                ASSERT_EQ(info.has_opus,
+                          mime_util.IsCodecSupportedOnAndroidForTests(
+                              codec_type, "", true));
+                break;
+
+              case MimeUtil::VP8:
+                ASSERT_EQ(info.has_vp8,
+                          mime_util.IsCodecSupportedOnAndroidForTests(
+                              codec_type, "", true));
+                break;
+
+              case MimeUtil::VP9:
+                ASSERT_EQ(info.has_vp9,
+                          mime_util.IsCodecSupportedOnAndroidForTests(
+                              codec_type, "", true));
+                break;
+
+              case MimeUtil::HEVC_MAIN:
+                break;

[ddorwin, 2016/02/17 21:18:39]

? Can we check the ifdef? We should at least call for this type to make sure it
doesn't DCHECK or crash.

If !BUILDFLAG(ENABLE_HEVC_DEMUXING), it will always be false - that's something
we can check. If we wanted to, we could check the Android version in the other
case too.

Another option would be to handle this similar to VP9. However, I'm not sure we
want to do that since it is not used in most cases.

[DaleCurtis, 2016/02/18 03:58:10]

Done.

+            }
+          }
+        }
+      }
+    }
+  }
+}
+
+TEST(MimeUtilInternalTest, ClearCodecBehaviorWithStandardPipeline) {

[ddorwin, 2016/02/17 21:18:40]

s/Standard/Android/?

[DaleCurtis, 2016/02/18 03:58:09]

Done.

+  MimeUtil mime_util;
+  PlatformCodecInfo info = {0};

[ddorwin, 2016/02/17 21:18:40]

has_unified_media_pipeline is never set to false (per the test).

[ddorwin, 2016/02/17 21:18:40]

has_platform_decoder and has_vp8 are not set. (Currently, their value is
non-deterministic.)

[DaleCurtis, 2016/02/18 03:58:10]

= {0} zero-initializes the structure, but that's removed now and the default
values are false.

[ddorwin, 2016/02/18 20:37:44]

Oops, I missed that.

+  for (bool has_opus : kTestStates) {
+    info.has_opus = has_opus;
+    for (bool has_vp9 : kTestStates) {
+      info.has_vp9 = has_vp9;
+      mime_util.SetPlatformCodecInfoForTests(info);
+      for (int codec = MimeUtil::INVALID_CODEC; codec <= MimeUtil::LAST_CODEC;
+           ++codec) {
+        const MimeUtil::Codec codec_type = static_cast<MimeUtil::Codec>(codec);
+        switch (codec_type) {
+          case MimeUtil::AC3:
+          case MimeUtil::EAC3:
+          case MimeUtil::INVALID_CODEC:
+          case MimeUtil::MPEG2_AAC_LC:
+          case MimeUtil::MPEG2_AAC_MAIN:
+          case MimeUtil::MPEG2_AAC_SSR:
+          case MimeUtil::THEORA:
+            ASSERT_FALSE(mime_util.IsCodecSupportedOnAndroidForTests(
+                codec_type, "", false));
+            break;
+
+          case MimeUtil::H264_BASELINE:
+          case MimeUtil::H264_MAIN:
+          case MimeUtil::H264_HIGH:
+          case MimeUtil::PCM:
+          case MimeUtil::MP3:
+          case MimeUtil::MPEG4_AAC_LC:
+          case MimeUtil::MPEG4_AAC_SBR_v1:
+          case MimeUtil::MPEG4_AAC_SBR_PS_v2:
+          case MimeUtil::VORBIS:
+          case MimeUtil::VP8:
+            ASSERT_TRUE(mime_util.IsCodecSupportedOnAndroidForTests(codec_type,
+                                                                    "", false));
+            break;
+
+          case MimeUtil::OPUS:
+            ASSERT_EQ(info.has_opus,
+                      mime_util.IsCodecSupportedOnAndroidForTests(codec_type,
+                                                                  "", false));
+            break;
+
+          case MimeUtil::VP9:
+            ASSERT_EQ(info.has_vp9, mime_util.IsCodecSupportedOnAndroidForTests(
+                                        codec_type, "", false));
+            break;
+
+          case MimeUtil::HEVC_MAIN:
+            break;

[ddorwin, 2016/02/17 21:18:40]

ditto

[DaleCurtis, 2016/02/18 03:58:10]

Done.

+        }
+      }
+    }
+  }
+}
+
+TEST(MimeUtilInternalTest, ClearCodecBehaviorWithUnifiedPipeline) {
+  MimeUtil mime_util;
+  PlatformCodecInfo info = {0};

[ddorwin, 2016/02/17 21:18:40]

Why aren't has_<codec> looped through?

[DaleCurtis, 2016/02/18 03:58:09]

Done.

+  info.has_unified_media_pipeline = true;
+  for (bool has_platform_decoder : kTestStates) {
+    info.has_platform_decoder = has_platform_decoder;
+    mime_util.SetPlatformCodecInfoForTests(info);
+
+    for (int codec = MimeUtil::INVALID_CODEC; codec <= MimeUtil::LAST_CODEC;
+         ++codec) {
+      const MimeUtil::Codec codec_type = static_cast<MimeUtil::Codec>(codec);
+      switch (codec_type) {
+        case MimeUtil::AC3:
+        case MimeUtil::EAC3:
+        case MimeUtil::INVALID_CODEC:
+        case MimeUtil::THEORA:
+          ASSERT_FALSE(mime_util.IsCodecSupportedOnAndroidForTests(codec_type,
+                                                                   "", false));
+          break;
+
+        case MimeUtil::PCM:
+        case MimeUtil::MPEG2_AAC_LC:
+        case MimeUtil::MPEG2_AAC_MAIN:
+        case MimeUtil::MPEG2_AAC_SSR:
+        case MimeUtil::MP3:
+        case MimeUtil::MPEG4_AAC_LC:
+        case MimeUtil::MPEG4_AAC_SBR_v1:
+        case MimeUtil::MPEG4_AAC_SBR_PS_v2:
+        case MimeUtil::OPUS:
+        case MimeUtil::VORBIS:
+        case MimeUtil::VP8:
+        case MimeUtil::VP9:
+          ASSERT_TRUE(mime_util.IsCodecSupportedOnAndroidForTests(codec_type,
+                                                                  "", false));
+          break;
+
+        case MimeUtil::H264_BASELINE:
+        case MimeUtil::H264_MAIN:
+        case MimeUtil::H264_HIGH:
+          ASSERT_EQ(info.has_platform_decoder,
+                    mime_util.IsCodecSupportedOnAndroidForTests(codec_type, "",
+                                                                false));
+          break;
+
+        case MimeUtil::HEVC_MAIN:
+          break;

[ddorwin, 2016/02/17 21:18:40]

ditto, though this also requires has_platform_decoder

[DaleCurtis, 2016/02/18 03:58:10]

Done.

+      }
+    }
+  }
+}
+
+TEST(MimeUtilInternalTest, OpusOggSupport) {
+  MimeUtil mime_util;
+  PlatformCodecInfo info;
+  info.has_platform_decoder = false;

[ddorwin, 2016/02/17 21:18:40]

Should this matter? Can we loop through it?

[DaleCurtis, 2016/02/18 03:58:10]

Done.

+  info.has_opus = true;

[ddorwin, 2016/02/17 21:18:40]

Might as well loop throught his too?

[DaleCurtis, 2016/02/18 03:58:10]

Done.

+
+  const bool kTestStates[] = {true, false};

[ddorwin, 2016/02/17 21:18:40]

remove

[DaleCurtis, 2016/02/18 03:58:09]

Done.

+  for (bool has_unified_media_pipeline : kTestStates) {
+    info.has_unified_media_pipeline = has_unified_media_pipeline;
+    mime_util.SetPlatformCodecInfoForTests(info);
+    ASSERT_EQ(info.has_unified_media_pipeline,
+              mime_util.IsCodecSupportedOnAndroidForTests(MimeUtil::OPUS,
+                                                          "audio/ogg", false));
+  }
+}
+
+}  // namespace internal
+#endif

[ddorwin, 2016/02/17 21:18:40]

This is a long block. Add // defined(OS_ANDROID)?

[DaleCurtis, 2016/02/18 03:58:10]

Done.

+
 }  // namespace media