Various MimeUtil cleanups.

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 "base/strings/stringprintf.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"
 
 #if defined(OS_ANDROID)
 #include "base/android/build_info.h"
 #endif
 
 namespace media {
 namespace internal {
 
-// MIME type for use with IsCodecSupportedOnPlatform() test; type is ignored in
+// MIME type for use with IsCodecSupportedOnAndroid() test; type is ignored in
 // all cases except for when paired with the Opus codec.
 const char kTestMimeType[] = "foo/foo";
 
 // Helper method for creating a multi-value vector of |kTestStates| if
 // |test_all_values| is true or if false, a single value vector containing
 // |single_value|.
 static std::vector<bool> CreateTestVector(bool test_all_values,
                                           bool single_value) {
   const bool kTestStates[] = {true, false};
   if (test_all_values)
     return std::vector<bool>(kTestStates, kTestStates + arraysize(kTestStates));
   return std::vector<bool>(1, single_value);
 }
 
-// Helper method for running IsCodecSupportedOnPlatform() tests that will
+// Helper method for running IsCodecSupportedOnAndroid() tests that will
 // iterate over all possible field values for a MimeUtil::PlatformInfo struct.
 //
 // To request a field be varied, set its value to true in the |states_to_vary|
 // struct.  If false, the only value tested will be the field value from
 // |test_states|.
 //
 // |test_func| should have the signature <void(const MimeUtil::PlatformInfo&,
 // MimeUtil::Codec)>.
 template <typename TestCallback>
 static void RunCodecSupportTest(const MimeUtil::PlatformInfo& states_to_vary,
@@ skipping 123 matching lines @@
 #endif  // USE_PROPRIETARY_CODECS
   EXPECT_FALSE(IsSupportedMediaMimeType("video/mp3"));
 
   EXPECT_FALSE(IsSupportedMediaMimeType("video/unknown"));
   EXPECT_FALSE(IsSupportedMediaMimeType("audio/unknown"));
   EXPECT_FALSE(IsSupportedMediaMimeType("unknown/unknown"));
 }
 
 // Note: codecs should only be a list of 2 or fewer; hence the restriction of
 // results' length to 2.
-TEST(MimeUtilTest, ParseCodecString) {
+TEST(MimeUtilTest, SplitCodecsToVector) {
   const struct {
     const char* const original;
     size_t expected_size;
     const char* const results[2];
   } tests[] = {
     { "\"bogus\"",                  1, { "bogus" }            },
     { "0",                          1, { "0" }                },
     { "avc1.42E01E, mp4a.40.2",     2, { "avc1",   "mp4a" }   },
     { "\"mp4v.20.240, mp4a.40.2\"", 2, { "mp4v",   "mp4a" }   },
     { "mp4v.20.8, samr",            2, { "mp4v",   "samr" }   },
     { "\"theora, vorbis\"",         2, { "theora", "vorbis" } },
     { "",                           0, { }                    },
     { "\"\"",                       0, { }                    },
     { "\"   \"",                    0, { }                    },
     { ",",                          2, { "", "" }             },
   };
 
   for (size_t i = 0; i < arraysize(tests); ++i) {
     std::vector<std::string> codecs_out;
-    ParseCodecString(tests[i].original, &codecs_out, true);
+    SplitCodecsToVector(tests[i].original, &codecs_out, true);
     ASSERT_EQ(tests[i].expected_size, codecs_out.size());
     for (size_t j = 0; j < tests[i].expected_size; ++j)
       EXPECT_EQ(tests[i].results[j], codecs_out[j]);
   }
 
   // Test without stripping the codec type.
   std::vector<std::string> codecs_out;
-  ParseCodecString("avc1.42E01E, mp4a.40.2", &codecs_out, false);
+  SplitCodecsToVector("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]);
 }
 
-TEST(IsCodecSupportedOnPlatformTest,
-     EncryptedCodecsFailWithoutPlatformSupport) {
+TEST(IsCodecSupportedOnAndroidTest, EncryptedCodecsFailWithoutPlatformSupport) {
   // Vary all parameters except |has_platform_decoders|.
   MimeUtil::PlatformInfo states_to_vary = VaryAllFields();
   states_to_vary.has_platform_decoders = false;
 
   // Disable platform decoders.
   MimeUtil::PlatformInfo test_states;
   test_states.has_platform_decoders = false;
 
   // Every codec should fail since platform support is missing and we've
   // requested encrypted codecs.
   RunCodecSupportTest(
       states_to_vary, test_states,
       [](const MimeUtil::PlatformInfo& info, MimeUtil::Codec codec) {
-        EXPECT_FALSE(MimeUtil::IsCodecSupportedOnPlatform(codec, kTestMimeType,
-                                                          true, info));
+        EXPECT_FALSE(MimeUtil::IsCodecSupportedOnAndroid(codec, kTestMimeType,
+                                                         true, info));
       });
 }
 
-TEST(IsCodecSupportedOnPlatformTest, EncryptedCodecBehavior) {
+TEST(IsCodecSupportedOnAndroidTest, EncryptedCodecBehavior) {
   // Vary all parameters except |has_platform_decoders|.
   MimeUtil::PlatformInfo states_to_vary = VaryAllFields();
   states_to_vary.has_platform_decoders = false;
 
   // Enable platform decoders.
   MimeUtil::PlatformInfo test_states;
   test_states.has_platform_decoders = true;
 
   RunCodecSupportTest(
       states_to_vary, test_states,
       [](const MimeUtil::PlatformInfo& info, MimeUtil::Codec codec) {
-        const bool result = MimeUtil::IsCodecSupportedOnPlatform(
+        const bool result = MimeUtil::IsCodecSupportedOnAndroid(
             codec, kTestMimeType, true, info);
         switch (codec) {
           // These codecs are never supported by the Android platform.
           case MimeUtil::INVALID_CODEC:
           case MimeUtil::AC3:
           case MimeUtil::EAC3:
           case MimeUtil::MPEG2_AAC:
           case MimeUtil::THEORA:
             EXPECT_FALSE(result);
             break;
@@ skipping 22 matching lines @@
             EXPECT_EQ(info.has_platform_vp9_decoder, result);
             break;
 
           case MimeUtil::HEVC:
             EXPECT_EQ(HasHevcSupport(), result);
             break;
         }
       });
 }
 
-TEST(IsCodecSupportedOnPlatformTest, ClearCodecBehavior) {
+TEST(IsCodecSupportedOnAndroidTest, ClearCodecBehavior) {
   MimeUtil::PlatformInfo states_to_vary = VaryAllFields();
 
   MimeUtil::PlatformInfo test_states;
 
   RunCodecSupportTest(
       states_to_vary, test_states,
       [](const MimeUtil::PlatformInfo& info, MimeUtil::Codec codec) {
-        const bool result = MimeUtil::IsCodecSupportedOnPlatform(
+        const bool result = MimeUtil::IsCodecSupportedOnAndroid(
             codec, kTestMimeType, false, info);
         switch (codec) {
           // These codecs are never supported by the Android platform.
           case MimeUtil::INVALID_CODEC:
           case MimeUtil::AC3:
           case MimeUtil::EAC3:
           case MimeUtil::THEORA:
             EXPECT_FALSE(result);
             break;
 
@@ skipping 15 matching lines @@
             EXPECT_EQ(info.has_platform_decoders, result);
             break;
 
           case MimeUtil::HEVC:
             EXPECT_EQ(HasHevcSupport() && info.has_platform_decoders, result);
             break;
         }
       });
 }
 
-TEST(IsCodecSupportedOnPlatformTest, OpusOggSupport) {
+TEST(IsCodecSupportedOnAndroidTest, OpusOggSupport) {
   // Vary all parameters; thus use default initial state.
   MimeUtil::PlatformInfo states_to_vary = VaryAllFields();
   MimeUtil::PlatformInfo test_states;
 
   RunCodecSupportTest(
       states_to_vary, test_states,
       [](const MimeUtil::PlatformInfo& info, MimeUtil::Codec codec) {
-        EXPECT_TRUE(MimeUtil::IsCodecSupportedOnPlatform(
+        EXPECT_TRUE(MimeUtil::IsCodecSupportedOnAndroid(
             MimeUtil::OPUS, "audio/ogg", false, info));
       });
 }
 
-TEST(IsCodecSupportedOnPlatformTest, HLSDoesNotSupportMPEG2AAC) {
+TEST(IsCodecSupportedOnAndroidTest, HLSDoesNotSupportMPEG2AAC) {
   // Vary all parameters; thus use default initial state.
   MimeUtil::PlatformInfo states_to_vary = VaryAllFields();
   MimeUtil::PlatformInfo test_states;
 
   RunCodecSupportTest(
       states_to_vary, test_states,
       [](const MimeUtil::PlatformInfo& info, MimeUtil::Codec codec) {
-        EXPECT_FALSE(MimeUtil::IsCodecSupportedOnPlatform(
+        EXPECT_FALSE(MimeUtil::IsCodecSupportedOnAndroid(
             MimeUtil::MPEG2_AAC, "application/x-mpegurl", false, info));
-        EXPECT_FALSE(MimeUtil::IsCodecSupportedOnPlatform(
+        EXPECT_FALSE(MimeUtil::IsCodecSupportedOnAndroid(
             MimeUtil::MPEG2_AAC, "application/vnd.apple.mpegurl", false, info));
-        EXPECT_FALSE(MimeUtil::IsCodecSupportedOnPlatform(
+        EXPECT_FALSE(MimeUtil::IsCodecSupportedOnAndroid(
             MimeUtil::MPEG2_AAC, "audio/mpegurl", false, info));
-        EXPECT_FALSE(MimeUtil::IsCodecSupportedOnPlatform(
+        EXPECT_FALSE(MimeUtil::IsCodecSupportedOnAndroid(
             MimeUtil::MPEG2_AAC, "audio/x-mpegurl", false, info));
       });
 }
 
 }  // namespace internal
 }  // namespace media