Update from https://crrev.com/316786

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("css"), "text/css", true },
-    { FILE_PATH_LITERAL("pjp"), "image/jpeg", true },
-    { FILE_PATH_LITERAL("pjpeg"), "image/jpeg", true },
+    {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)
-    { FILE_PATH_LITERAL("m3u8"), "application/x-mpegurl", true },
+    {FILE_PATH_LITERAL("m3u8"), "application/x-mpegurl", true},
 #endif
-    { FILE_PATH_LITERAL("not an extension / for sure"), "", false },
+    {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);
     EXPECT_EQ(tests[i].valid, rv);
     if (rv)
       EXPECT_EQ(tests[i].mime_type, mime_type);
   }
 }
 
 TEST(MimeUtilTest, FileTest) {
   const struct {
     const base::FilePath::CharType* file_path;
     const char* const mime_type;
     bool valid;
   } tests[] = {
-    { FILE_PATH_LITERAL("c:\\foo\\bar.css"), "text/css", true },
-    { FILE_PATH_LITERAL("c:\\blah"), "", false },
-    { FILE_PATH_LITERAL("/usr/local/bin/mplayer"), "", false },
-    { FILE_PATH_LITERAL("/home/foo/bar.css"), "text/css", true },
-    { FILE_PATH_LITERAL("/blah."), "", false },
-    { FILE_PATH_LITERAL("c:\\blah."), "", false },
+      {FILE_PATH_LITERAL("c:\\foo\\bar.css"), "text/css", true},
+      {FILE_PATH_LITERAL("c:\\foo\\bar.CSS"), "text/css", true},
+      {FILE_PATH_LITERAL("c:\\blah"), "", false},
+      {FILE_PATH_LITERAL("/usr/local/bin/mplayer"), "", false},
+      {FILE_PATH_LITERAL("/home/foo/bar.css"), "text/css", true},
+      {FILE_PATH_LITERAL("/blah."), "", false},
+      {FILE_PATH_LITERAL("c:\\blah."), "", false},
   };
 
   std::string mime_type;
   bool rv;
 
   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) {
   EXPECT_FALSE(IsUnsupportedTextMimeType("text/banana"));
   EXPECT_TRUE(IsUnsupportedTextMimeType("text/vcard"));
 
   EXPECT_TRUE(IsSupportedImageMimeType("image/jpeg"));
+  EXPECT_TRUE(IsSupportedImageMimeType("Image/JPEG"));
   EXPECT_FALSE(IsSupportedImageMimeType("image/lolcat"));
+  EXPECT_FALSE(IsSupportedImageMimeType("Image/LolCat"));
   EXPECT_TRUE(IsSupportedNonImageMimeType("text/html"));
   EXPECT_TRUE(IsSupportedNonImageMimeType("text/css"));
   EXPECT_TRUE(IsSupportedNonImageMimeType("text/"));
   EXPECT_TRUE(IsSupportedNonImageMimeType("text/banana"));
+  EXPECT_TRUE(IsSupportedNonImageMimeType("Text/Banana"));
   EXPECT_FALSE(IsSupportedNonImageMimeType("text/vcard"));
   EXPECT_FALSE(IsSupportedNonImageMimeType("application/virus"));
+  EXPECT_FALSE(IsSupportedNonImageMimeType("Application/VIRUS"));
   EXPECT_TRUE(IsSupportedNonImageMimeType("application/x-x509-user-cert"));
   EXPECT_TRUE(IsSupportedNonImageMimeType("application/json"));
   EXPECT_TRUE(IsSupportedNonImageMimeType("application/+json"));
   EXPECT_TRUE(IsSupportedNonImageMimeType("application/x-suggestions+json"));
   EXPECT_TRUE(IsSupportedNonImageMimeType("application/x-s+json;x=2"));
 #if defined(OS_ANDROID)
   EXPECT_TRUE(IsSupportedNonImageMimeType("application/x-x509-ca-cert"));
   EXPECT_TRUE(IsSupportedNonImageMimeType("application/x-pkcs12"));
   EXPECT_TRUE(IsSupportedMediaMimeType("application/vnd.apple.mpegurl"));
   EXPECT_TRUE(IsSupportedMediaMimeType("application/x-mpegurl"));
+  EXPECT_TRUE(IsSupportedMediaMimeType("Application/X-MPEGURL"));
 #endif
 
   EXPECT_TRUE(IsSupportedMimeType("image/jpeg"));
   EXPECT_FALSE(IsSupportedMimeType("image/lolcat"));
+  EXPECT_FALSE(IsSupportedMimeType("Image/LOLCAT"));
   EXPECT_TRUE(IsSupportedMimeType("text/html"));
   EXPECT_TRUE(IsSupportedMimeType("text/banana"));
+  EXPECT_TRUE(IsSupportedMimeType("Text/BANANA"));
   EXPECT_FALSE(IsSupportedMimeType("text/vcard"));
   EXPECT_FALSE(IsSupportedMimeType("application/virus"));
   EXPECT_FALSE(IsSupportedMimeType("application/x-json"));
+  EXPECT_FALSE(IsSupportedMimeType("Application/X-JSON"));
   EXPECT_FALSE(IsSupportedNonImageMimeType("application/vnd.doc;x=y+json"));
+  EXPECT_FALSE(IsSupportedNonImageMimeType("Application/VND.DOC;X=Y+JSON"));
 }
 
 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",
                                    "application/html+xml"));
   EXPECT_TRUE(MatchesMimeType("application/*+xml", "application/+xml"));
   EXPECT_TRUE(MatchesMimeType("application/*+json",
                                    "application/x-myformat+json"));
   EXPECT_TRUE(MatchesMimeType("aaa*aaa", "aaaaaa"));
   EXPECT_TRUE(MatchesMimeType("*", std::string()));
   EXPECT_FALSE(MatchesMimeType("video/", "video/x-mpeg"));
+  EXPECT_FALSE(MatchesMimeType("VIDEO/", "Video/X-MPEG"));
   EXPECT_FALSE(MatchesMimeType(std::string(), "video/x-mpeg"));
   EXPECT_FALSE(MatchesMimeType(std::string(), std::string()));
   EXPECT_FALSE(MatchesMimeType("video/x-mpeg", std::string()));
   EXPECT_FALSE(MatchesMimeType("application/*+xml", "application/xml"));
   EXPECT_FALSE(MatchesMimeType("application/*+xml",
                                     "application/html+xmlz"));
   EXPECT_FALSE(MatchesMimeType("application/*+xml",
                                     "applcation/html+xml"));
   EXPECT_FALSE(MatchesMimeType("aaa*aaa", "aaaaa"));
 
   EXPECT_TRUE(MatchesMimeType("*", "video/x-mpeg;param=val"));
+  EXPECT_TRUE(MatchesMimeType("*", "Video/X-MPEG;PARAM=VAL"));
   EXPECT_TRUE(MatchesMimeType("video/*", "video/x-mpeg;param=val"));
   EXPECT_FALSE(MatchesMimeType("video/*;param=val", "video/mpeg"));
+  EXPECT_FALSE(MatchesMimeType("Video/*;PARAM=VAL", "VIDEO/Mpeg"));
   EXPECT_FALSE(MatchesMimeType("video/*;param=val", "video/mpeg;param=other"));
   EXPECT_TRUE(MatchesMimeType("video/*;param=val", "video/mpeg;param=val"));
+  EXPECT_TRUE(MatchesMimeType("Video/*;PARAM=Val", "VIDEO/Mpeg;Param=Val"));
+  EXPECT_FALSE(MatchesMimeType("Video/*;PARAM=VAL", "VIDEO/Mpeg;Param=Val"));
   EXPECT_TRUE(MatchesMimeType("video/x-mpeg", "video/x-mpeg;param=val"));
   EXPECT_TRUE(MatchesMimeType("video/x-mpeg;param=val",
                               "video/x-mpeg;param=val"));
   EXPECT_FALSE(MatchesMimeType("video/x-mpeg;param2=val2",
                                "video/x-mpeg;param=val"));
   EXPECT_FALSE(MatchesMimeType("video/x-mpeg;param2=val2",
                                "video/x-mpeg;param2=val"));
   EXPECT_TRUE(MatchesMimeType("video/x-mpeg;param=val",
                               "video/x-mpeg;param=val;param2=val2"));
-  EXPECT_TRUE(MatchesMimeType("video/x-mpeg;param=val;param2=val2",
-                              "video/x-mpeg;param=val;param2=val2"));
+  EXPECT_TRUE(MatchesMimeType("Video/X-Mpeg;Param=Val",
+                              "VIDEO/X-MPEG;PARAM=Val;PARAM2=val2"));
+  EXPECT_TRUE(MatchesMimeType("Video/X-Mpeg;Param=VAL",
+                              "VIDEO/X-MPEG;PARAM=VAL;PARAM2=val2"));
+  EXPECT_FALSE(MatchesMimeType("Video/X-Mpeg;Param=val",
+                               "VIDEO/X-MPEG;PARAM=VAL;PARAM2=val2"));
+  EXPECT_FALSE(MatchesMimeType("video/x-mpeg;param=VAL;param2=val2",
+                               "video/x-mpeg;param=val;param2=val2"));
   EXPECT_TRUE(MatchesMimeType("video/x-mpeg;param2=val2;param=val",
                               "video/x-mpeg;param=val;param2=val2"));
   EXPECT_FALSE(MatchesMimeType("video/x-mpeg;param3=val3;param=val",
                                "video/x-mpeg;param=val;param2=val2"));
   EXPECT_TRUE(MatchesMimeType("video/x-mpeg;param=val ;param2=val2 ",
                               "video/x-mpeg;param=val;param2=val2"));
 
   EXPECT_TRUE(MatchesMimeType("*/*;param=val", "video/x-mpeg;param=val"));
   EXPECT_FALSE(MatchesMimeType("*/*;param=val", "video/x-mpeg;param=val2"));
 
@@ skipping 223 matching lines @@
 #endif
     }
     ASSERT_TRUE(found) << "Must find at least the contained result within "
                        << tests[i].mime_type;
   }
 }
 
 TEST(MimeUtilTest, TestGetCertificateMimeTypeForMimeType) {
   EXPECT_EQ(CERTIFICATE_MIME_TYPE_X509_USER_CERT,
             GetCertificateMimeTypeForMimeType("application/x-x509-user-cert"));
+  EXPECT_EQ(CERTIFICATE_MIME_TYPE_X509_USER_CERT,
+            GetCertificateMimeTypeForMimeType("Application/X-X509-USER-CERT"));
 #if defined(OS_ANDROID)
   // Only Android supports CA Certs and PKCS12 archives.
   EXPECT_EQ(CERTIFICATE_MIME_TYPE_X509_CA_CERT,
             GetCertificateMimeTypeForMimeType("application/x-x509-ca-cert"));
   EXPECT_EQ(CERTIFICATE_MIME_TYPE_PKCS12_ARCHIVE,
             GetCertificateMimeTypeForMimeType("application/x-pkcs12"));
 #else
   EXPECT_EQ(CERTIFICATE_MIME_TYPE_UNKNOWN,
             GetCertificateMimeTypeForMimeType("application/x-x509-ca-cert"));
   EXPECT_EQ(CERTIFICATE_MIME_TYPE_UNKNOWN,
@@ skipping 14 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