Moved media mime type and codec checks to media/base/mime_util.*

net/base/mime_util_unittest.cc

 // Copyright (c) 2012 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 "base/basictypes.h"
 #include "base/strings/string_split.h"
 #include "base/strings/utf_string_conversions.h"
 #include "net/base/mime_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
-#if defined(OS_ANDROID)
-#include "base/android/build_info.h"
-#endif
-
 namespace net {
 
 TEST(MimeUtilTest, ExtensionTest) {
   const struct {
     const base::FilePath::CharType* extension;
     const char* const mime_type;
     bool valid;
   } tests[] = {
     {FILE_PATH_LITERAL("png"), "image/png", true},
     {FILE_PATH_LITERAL("PNG"), "image/png", true},
     {FILE_PATH_LITERAL("css"), "text/css", true},
     {FILE_PATH_LITERAL("pjp"), "image/jpeg", true},
     {FILE_PATH_LITERAL("pjpeg"), "image/jpeg", true},
 #if defined(OS_ANDROID)

[ddorwin, 2015/05/08 16:29:19]

#include "build/build_config.h"

[servolk, 2015/05/08 17:33:05]

Done.

     {FILE_PATH_LITERAL("m3u8"), "application/x-mpegurl", true},
 #endif
     {FILE_PATH_LITERAL("not an extension / for sure"), "", false},
   };
 
   std::string mime_type;
   bool rv;
 
   for (size_t i = 0; i < arraysize(tests); ++i) {
     rv = GetMimeTypeFromExtension(tests[i].extension, &mime_type);
@@ skipping 23 matching lines @@
 
   for (size_t i = 0; i < arraysize(tests); ++i) {
     rv = GetMimeTypeFromFile(base::FilePath(tests[i].file_path),
                                   &mime_type);
     EXPECT_EQ(tests[i].valid, rv);
     if (rv)
       EXPECT_EQ(tests[i].mime_type, mime_type);
   }
 }
 
-TEST(MimeUtilTest, LookupTypes) {
-#if defined(OS_ANDROID)
-  EXPECT_TRUE(IsSupportedMediaMimeType("application/vnd.apple.mpegurl"));
-  EXPECT_TRUE(IsSupportedMediaMimeType("application/x-mpegurl"));
-  EXPECT_TRUE(IsSupportedMediaMimeType("Application/X-MPEGURL"));
-#endif
-}
-
-TEST(MimeUtilTest, StrictMediaMimeType) {
-  EXPECT_TRUE(IsStrictMediaMimeType("video/webm"));
-  EXPECT_TRUE(IsStrictMediaMimeType("Video/WEBM"));
-  EXPECT_TRUE(IsStrictMediaMimeType("audio/webm"));
-
-  EXPECT_TRUE(IsStrictMediaMimeType("audio/wav"));
-  EXPECT_TRUE(IsStrictMediaMimeType("audio/x-wav"));
-
-  EXPECT_TRUE(IsStrictMediaMimeType("video/ogg"));
-  EXPECT_TRUE(IsStrictMediaMimeType("audio/ogg"));
-  EXPECT_TRUE(IsStrictMediaMimeType("application/ogg"));
-
-  EXPECT_TRUE(IsStrictMediaMimeType("audio/mpeg"));
-  EXPECT_TRUE(IsStrictMediaMimeType("audio/mp3"));
-  EXPECT_TRUE(IsStrictMediaMimeType("audio/x-mp3"));
-
-  EXPECT_TRUE(IsStrictMediaMimeType("video/mp4"));
-  EXPECT_TRUE(IsStrictMediaMimeType("video/x-m4v"));
-  EXPECT_TRUE(IsStrictMediaMimeType("audio/mp4"));
-  EXPECT_TRUE(IsStrictMediaMimeType("audio/x-m4a"));
-
-  EXPECT_TRUE(IsStrictMediaMimeType("application/x-mpegurl"));
-  EXPECT_TRUE(IsStrictMediaMimeType("application/vnd.apple.mpegurl"));
-
-  EXPECT_FALSE(IsStrictMediaMimeType("video/unknown"));
-  EXPECT_FALSE(IsStrictMediaMimeType("Video/UNKNOWN"));
-  EXPECT_FALSE(IsStrictMediaMimeType("audio/unknown"));
-  EXPECT_FALSE(IsStrictMediaMimeType("application/unknown"));
-  EXPECT_FALSE(IsStrictMediaMimeType("unknown/unknown"));
-}
-
 TEST(MimeUtilTest, MatchesMimeType) {
   // MIME types are case insensitive.
   EXPECT_TRUE(MatchesMimeType("VIDEO/*", "video/x-mpeg"));
   EXPECT_TRUE(MatchesMimeType("video/*", "VIDEO/X-MPEG"));
 
   EXPECT_TRUE(MatchesMimeType("*", "video/x-mpeg"));
   EXPECT_TRUE(MatchesMimeType("video/*", "video/x-mpeg"));
   EXPECT_TRUE(MatchesMimeType("video/*", "video/*"));
   EXPECT_TRUE(MatchesMimeType("video/x-mpeg", "video/x-mpeg"));
   EXPECT_TRUE(MatchesMimeType("application/*+xml",
@@ skipping 59 matching lines @@
   EXPECT_FALSE(MatchesMimeType("video/*", "*/*"));
   EXPECT_FALSE(MatchesMimeType("video/*;param=val", "video/*"));
   EXPECT_TRUE(MatchesMimeType("video/*;param=val", "video/*;param=val"));
   EXPECT_FALSE(MatchesMimeType("video/*;param=val", "video/*;param=val2"));
 
   EXPECT_TRUE(MatchesMimeType("ab*cd", "abxxxcd"));
   EXPECT_TRUE(MatchesMimeType("ab*cd", "abx/xcd"));
   EXPECT_TRUE(MatchesMimeType("ab/*cd", "ab/xxxcd"));
 }
 
-TEST(MimeUtilTest, CommonMediaMimeType) {
-#if defined(OS_ANDROID)
-  bool HLSSupported;
-  if (base::android::BuildInfo::GetInstance()->sdk_int() < 14)
-    HLSSupported = false;
-  else
-    HLSSupported = true;
-#endif
-
-  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)
-  EXPECT_FALSE(IsSupportedMediaMimeType("video/ogg"));
-  EXPECT_EQ(HLSSupported, IsSupportedMediaMimeType("application/x-mpegurl"));
-  EXPECT_EQ(HLSSupported,
-            IsSupportedMediaMimeType("application/vnd.apple.mpegurl"));
-#else
-  EXPECT_TRUE(IsSupportedMediaMimeType("video/ogg"));
-  EXPECT_FALSE(IsSupportedMediaMimeType("application/x-mpegurl"));
-  EXPECT_FALSE(IsSupportedMediaMimeType("application/vnd.apple.mpegurl"));
-#endif  // OS_ANDROID
-
-#if defined(USE_PROPRIETARY_CODECS)
-  EXPECT_TRUE(IsSupportedMediaMimeType("audio/mp4"));
-  EXPECT_TRUE(IsSupportedMediaMimeType("audio/x-m4a"));
-  EXPECT_TRUE(IsSupportedMediaMimeType("video/mp4"));
-  EXPECT_TRUE(IsSupportedMediaMimeType("video/x-m4v"));
-
-  EXPECT_TRUE(IsSupportedMediaMimeType("audio/mp3"));
-  EXPECT_TRUE(IsSupportedMediaMimeType("audio/x-mp3"));
-  EXPECT_TRUE(IsSupportedMediaMimeType("audio/mpeg"));
-  EXPECT_TRUE(IsSupportedMediaMimeType("audio/aac"));
-
-#if defined(ENABLE_MPEG2TS_STREAM_PARSER)
-  EXPECT_TRUE(IsSupportedMediaMimeType("video/mp2t"));
-#else
-  EXPECT_FALSE(IsSupportedMediaMimeType("video/mp2t"));
-#endif
-#else
-  EXPECT_FALSE(IsSupportedMediaMimeType("audio/mp4"));
-  EXPECT_FALSE(IsSupportedMediaMimeType("audio/x-m4a"));
-  EXPECT_FALSE(IsSupportedMediaMimeType("video/mp4"));
-  EXPECT_FALSE(IsSupportedMediaMimeType("video/x-m4v"));
-
-  EXPECT_FALSE(IsSupportedMediaMimeType("audio/mp3"));
-  EXPECT_FALSE(IsSupportedMediaMimeType("audio/x-mp3"));
-  EXPECT_FALSE(IsSupportedMediaMimeType("audio/mpeg"));
-  EXPECT_FALSE(IsSupportedMediaMimeType("audio/aac"));
-#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) {
-  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);
-    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);
-  ASSERT_EQ(2u, codecs_out.size());
-  EXPECT_EQ("avc1.42E01E", codecs_out[0]);
-  EXPECT_EQ("mp4a.40.2", codecs_out[1]);
-}
-
 TEST(MimeUtilTest, TestParseMimeTypeWithoutParameter) {
   std::string nonAscii("application/nonutf8");
   EXPECT_TRUE(ParseMimeTypeWithoutParameter(nonAscii, NULL, NULL));
 #if defined(OS_WIN)
   nonAscii.append(base::WideToUTF8(L"\u2603"));
 #else
   nonAscii.append("\u2603");  // unicode snowman
 #endif
   EXPECT_FALSE(ParseMimeTypeWithoutParameter(nonAscii, NULL, NULL));
 
@@ skipping 116 matching lines @@
   std::string post_data;
   AddMultipartValueForUpload("value name", "value", "boundary",
                              "content type", &post_data);
   AddMultipartValueForUpload("value name", "value", "boundary",
                              "", &post_data);
   AddMultipartFinalDelimiterForUpload("boundary", &post_data);
   EXPECT_STREQ(ref_output, post_data.c_str());
 }
 
 }  // namespace net