Update from https://crrev.com/316786

net/base/mime_util.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 <algorithm>
 #include <iterator>
 #include <map>
 #include <string>
 
 #include "base/containers/hash_tables.h"
@@ skipping 124 matching lines @@
                      bool* is_ambiguous) const;
 
   // Returns true if |codec| is supported by the platform.
   // Note: This method will return false if the platform supports proprietary
   // codecs but |allow_proprietary_codecs_| is set to false.
   bool IsCodecSupported(Codec codec) const;
 
   // Returns true if |codec| refers to a proprietary codec.
   bool IsCodecProprietary(Codec codec) const;
 
-  // Returns true and sets |*default_codec| if |mime_type| has a
-  // default codec associated with it.
-  // Returns false otherwise and the value of |*default_codec| is undefined.
-  bool GetDefaultCodec(const std::string& mime_type,
-                       Codec* default_codec) const;
+  // Returns true and sets |*default_codec| if |mime_type| has a  default codec
+  // associated with it. Returns false otherwise and the value of
+  // |*default_codec| is undefined.
+  bool GetDefaultCodecLowerCase(const std::string& mime_type_lower_case,
+                                Codec* default_codec) const;
 
-  // Returns true if |mime_type| has a default codec associated with it
-  // and IsCodecSupported() returns true for that particular codec.
-  bool IsDefaultCodecSupported(const std::string& mime_type) const;
+  // Returns true if |mime_type_lower_case| has a default codec associated with
+  // it and IsCodecSupported() returns true for that particular codec.
+  bool IsDefaultCodecSupportedLowerCase(
+      const std::string& mime_type_lower_case) const;
 
   MimeMappings image_map_;
   MimeMappings media_map_;
   MimeMappings non_image_map_;
   MimeMappings unsupported_text_map_;
   MimeMappings javascript_map_;
 
   // A map of mime_types and hash map of the supported codecs for the mime_type.
   StrictMappings strict_format_map_;
 
@@ skipping 305 matching lines @@
     case MimeUtil::MPEG2_AAC_MAIN:
     case MimeUtil::MPEG2_AAC_SSR:
       // MPEG-2 variants of AAC are not supported on Android.
       return false;
 
     case MimeUtil::VP9:
       // VP9 is supported only in KitKat+ (API Level 19).
       return base::android::BuildInfo::GetInstance()->sdk_int() >= 19;
 
     case MimeUtil::OPUS:
-      // TODO(vigneshv): Change this similar to the VP9 check once Opus is
-      // supported on Android (http://crbug.com/318436).
-      return false;
+      // Opus is supported only in Lollipop+ (API Level 21).
+      return base::android::BuildInfo::GetInstance()->sdk_int() >= 21;
 
     case MimeUtil::THEORA:
       return false;
   }
 
   return false;
 }
 
 static bool IsMimeTypeSupportedOnAndroid(const std::string& mimeType) {
   // HLS codecs are supported in ICS and above (API level 14)
@@ skipping 29 matching lines @@
 //   avc1.6400xx - H.264 High
 static const char kMP4AudioCodecsExpression[] =
     "mp4a.66,mp4a.67,mp4a.68,mp4a.69,mp4a.6B,mp4a.40.2,mp4a.40.02,mp4a.40.5,"
     "mp4a.40.05,mp4a.40.29";
 static const char kMP4VideoCodecsExpression[] =
     "avc1.42E00A,avc1.4D400A,avc1.64000A,"
     "mp4a.66,mp4a.67,mp4a.68,mp4a.69,mp4a.6B,mp4a.40.2,mp4a.40.02,mp4a.40.5,"
     "mp4a.40.05,mp4a.40.29";
 
 static const MediaFormatStrict format_codec_mappings[] = {
-  { "video/webm", "opus,vorbis,vp8,vp8.0,vp9,vp9.0" },
-  { "audio/webm", "opus,vorbis" },
-  { "audio/wav", "1" },
-  { "audio/x-wav", "1" },
-  { "video/ogg", "opus,theora,vorbis" },
-  { "audio/ogg", "opus,vorbis" },
-  { "application/ogg", "opus,theora,vorbis" },
-  { "audio/mpeg", "mp3" },
-  { "audio/mp3", "" },
-  { "audio/x-mp3", "" },
-  { "audio/mp4", kMP4AudioCodecsExpression },
-  { "audio/x-m4a", kMP4AudioCodecsExpression },
-  { "video/mp4", kMP4VideoCodecsExpression },
-  { "video/x-m4v", kMP4VideoCodecsExpression },
-  { "application/x-mpegurl", kMP4VideoCodecsExpression },
-  { "application/vnd.apple.mpegurl", kMP4VideoCodecsExpression }
-};
+    {"video/webm", "opus,vorbis,vp8,vp8.0,vp9,vp9.0"},
+    {"audio/webm", "opus,vorbis"},
+    {"audio/wav", "1"},
+    {"audio/x-wav", "1"},
+// Android does not support Opus in Ogg container.
+#if defined(OS_ANDROID)
+    {"video/ogg", "theora,vorbis"},
+    {"audio/ogg", "vorbis"},
+    {"application/ogg", "theora,vorbis"},
+#else
+    {"video/ogg", "opus,theora,vorbis"},
+    {"audio/ogg", "opus,vorbis"},
+    {"application/ogg", "opus,theora,vorbis"},
+#endif
+    {"audio/mpeg", "mp3"},
+    {"audio/mp3", ""},
+    {"audio/x-mp3", ""},
+    {"audio/mp4", kMP4AudioCodecsExpression},
+    {"audio/x-m4a", kMP4AudioCodecsExpression},
+    {"video/mp4", kMP4VideoCodecsExpression},
+    {"video/x-m4v", kMP4VideoCodecsExpression},
+    {"application/x-mpegurl", kMP4VideoCodecsExpression},
+    {"application/vnd.apple.mpegurl", kMP4VideoCodecsExpression}};
 
 struct CodecIDMappings {
   const char* const codec_id;
   MimeUtil::Codec codec;
 };
 
 // List of codec IDs that provide enough information to determine the
 // codec and profile being requested.
 //
 // The "mp4a" strings come from RFC 6381.
@@ skipping 124 matching lines @@
       CHECK(StringToCodec(mime_type_codecs[j], &codec, &is_ambiguous));
       DCHECK(!is_ambiguous);
       codecs.insert(codec);
     }
 
     strict_format_map_[format_codec_mappings[i].mime_type] = codecs;
   }
 }
 
 bool MimeUtil::IsSupportedImageMimeType(const std::string& mime_type) const {
-  return image_map_.find(mime_type) != image_map_.end();
+  return image_map_.find(base::StringToLowerASCII(mime_type)) !=
+         image_map_.end();
 }
 
 bool MimeUtil::IsSupportedMediaMimeType(const std::string& mime_type) const {
-  return media_map_.find(mime_type) != media_map_.end();
+  return media_map_.find(base::StringToLowerASCII(mime_type)) !=
+         media_map_.end();
 }
 
 bool MimeUtil::IsSupportedNonImageMimeType(const std::string& mime_type) const {
-  return non_image_map_.find(mime_type) != non_image_map_.end() ||
-      (mime_type.compare(0, 5, "text/") == 0 &&
-       !IsUnsupportedTextMimeType(mime_type)) ||
-      (mime_type.compare(0, 12, "application/") == 0 &&
-       MatchesMimeType("application/*+json", mime_type));
+  return non_image_map_.find(base::StringToLowerASCII(mime_type)) !=
+             non_image_map_.end() ||
+         (StartsWithASCII(mime_type, "text/", false /* case insensitive */) &&
+          !IsUnsupportedTextMimeType(mime_type)) ||
+         (StartsWithASCII(mime_type, "application/", false) &&
+          MatchesMimeType("application/*+json", mime_type));
 }
 
 bool MimeUtil::IsUnsupportedTextMimeType(const std::string& mime_type) const {
-  return unsupported_text_map_.find(mime_type) != unsupported_text_map_.end();
+  return unsupported_text_map_.find(base::StringToLowerASCII(mime_type)) !=
+         unsupported_text_map_.end();
 }
 
 bool MimeUtil::IsSupportedJavascriptMimeType(
     const std::string& mime_type) const {
   return javascript_map_.find(mime_type) != javascript_map_.end();
 }
 
 // Mirrors WebViewImpl::CanShowMIMEType()
 bool MimeUtil::IsSupportedMimeType(const std::string& mime_type) const {
-  return (mime_type.compare(0, 6, "image/") == 0 &&
+  return (StartsWithASCII(mime_type, "image/", false) &&
           IsSupportedImageMimeType(mime_type)) ||
          IsSupportedNonImageMimeType(mime_type);
 }
 
 // Tests for MIME parameter equality. Each parameter in the |mime_type_pattern|
 // must be matched by a parameter in the |mime_type|. If there are no
 // parameters in the pattern, the match is a success.
+//
+// According rfc2045 keys of parameters are case-insensitive, while values may
+// or may not be case-sensitive, but they are usually case-sensitive. So, this
+// function matches values in *case-sensitive* manner, however note that this
+// may produce some false negatives.
 bool MatchesMimeTypeParameters(const std::string& mime_type_pattern,
                                const std::string& mime_type) {
+  typedef std::map<std::string, std::string> StringPairMap;
+
   const std::string::size_type semicolon = mime_type_pattern.find(';');
   const std::string::size_type test_semicolon = mime_type.find(';');
   if (semicolon != std::string::npos) {
     if (test_semicolon == std::string::npos)
       return false;
 
-    std::vector<std::string> pattern_parameters;
-    base::SplitString(mime_type_pattern.substr(semicolon + 1),
-                      ';', &pattern_parameters);
+    base::StringPairs pattern_parameters;
+    base::SplitStringIntoKeyValuePairs(mime_type_pattern.substr(semicolon + 1),
+                                       '=', ';', &pattern_parameters);
+    base::StringPairs test_parameters;
+    base::SplitStringIntoKeyValuePairs(mime_type.substr(test_semicolon + 1),
+                                       '=', ';', &test_parameters);
 
-    std::vector<std::string> test_parameters;
-    base::SplitString(mime_type.substr(test_semicolon + 1),
-                      ';', &test_parameters);
+    // Put the parameters to maps with the keys converted to lower case.
+    StringPairMap pattern_parameter_map;
+    for (const auto& pair : pattern_parameters) {
+      pattern_parameter_map[base::StringToLowerASCII(pair.first)] = pair.second;
+    }
 
-    sort(pattern_parameters.begin(), pattern_parameters.end());
-    sort(test_parameters.begin(), test_parameters.end());
-    std::vector<std::string> difference =
-      base::STLSetDifference<std::vector<std::string> >(pattern_parameters,
-                                                        test_parameters);
-    return difference.size() == 0;
+    StringPairMap test_parameter_map;
+    for (const auto& pair : test_parameters) {
+      test_parameter_map[base::StringToLowerASCII(pair.first)] = pair.second;
+    }
+
+    if (pattern_parameter_map.size() > test_parameter_map.size())
+      return false;
+
+    for (const auto& parameter_pair : pattern_parameter_map) {
+      const auto& test_parameter_pair_it =
+          test_parameter_map.find(parameter_pair.first);
+      if (test_parameter_pair_it == test_parameter_map.end())
+        return false;
+      if (parameter_pair.second != test_parameter_pair_it->second)
+        return false;
+    }
   }
+
   return true;
 }
 
 // This comparison handles absolute maching and also basic
 // wildcards.  The plugin mime types could be:
 //      application/x-foo
 //      application/*
 //      application/*+xml
 //      *
 // Also tests mime parameters -- all parameters in the pattern must be present
 // in the tested type for a match to succeed.
 bool MimeUtil::MatchesMimeType(const std::string& mime_type_pattern,
                                const std::string& mime_type) const {
-  // Verify caller is passing lowercase strings.
-  DCHECK_EQ(base::StringToLowerASCII(mime_type_pattern), mime_type_pattern);
-  DCHECK_EQ(base::StringToLowerASCII(mime_type), mime_type);
-
   if (mime_type_pattern.empty())
     return false;
 
   std::string::size_type semicolon = mime_type_pattern.find(';');
   const std::string base_pattern(mime_type_pattern.substr(0, semicolon));
   semicolon = mime_type.find(';');
   const std::string base_type(mime_type.substr(0, semicolon));
 
   if (base_pattern == "*" || base_pattern == "*/*")
     return MatchesMimeTypeParameters(mime_type_pattern, mime_type);
 
   const std::string::size_type star = base_pattern.find('*');
   if (star == std::string::npos) {
-    if (base_pattern == base_type)
+    if (base_pattern.size() == base_type.size() &&
+        base::strncasecmp(base_pattern.c_str(), base_type.c_str(),
+                          base_pattern.size()) == 0) {
       return MatchesMimeTypeParameters(mime_type_pattern, mime_type);
-    else
+    } else {
       return false;
+    }
   }
 
   // Test length to prevent overlap between |left| and |right|.
   if (base_type.length() < base_pattern.length() - 1)
     return false;
 
   const std::string left(base_pattern.substr(0, star));
   const std::string right(base_pattern.substr(star + 1));
 
-  if (base_type.find(left) != 0)
+  if (!StartsWithASCII(base_type, left, false))
     return false;
 
-  if (!right.empty() &&
-      base_type.rfind(right) != base_type.length() - right.length())
+  if (!right.empty() && !EndsWith(base_type, right, false))
     return false;
 
   return MatchesMimeTypeParameters(mime_type_pattern, mime_type);
 }
 
 // See http://www.iana.org/assignments/media-types/media-types.xhtml
 static const char* const legal_top_level_types[] = {
   "application",
   "audio",
   "example",
@@ skipping 60 matching lines @@
   for (std::vector<std::string>::iterator it = codecs_out->begin();
        it != codecs_out->end();
        ++it) {
     size_t found = it->find_first_of('.');
     if (found != std::string::npos)
       it->resize(found);
   }
 }
 
 bool MimeUtil::IsStrictMediaMimeType(const std::string& mime_type) const {
-  return strict_format_map_.find(mime_type) != strict_format_map_.end();
+  return strict_format_map_.find(base::StringToLowerASCII(mime_type)) !=
+         strict_format_map_.end();
 }
 
 SupportsType MimeUtil::IsSupportedStrictMediaMimeType(
     const std::string& mime_type,
     const std::vector<std::string>& codecs) const {
+  const std::string mime_type_lower_case = base::StringToLowerASCII(mime_type);
   StrictMappings::const_iterator it_strict_map =
-      strict_format_map_.find(mime_type);
+      strict_format_map_.find(mime_type_lower_case);
   if (it_strict_map == strict_format_map_.end())
     return codecs.empty() ? MayBeSupported : IsNotSupported;
 
   if (it_strict_map->second.empty()) {
     // We get here if the mimetype does not expect a codecs parameter.
-    return (codecs.empty() && IsDefaultCodecSupported(mime_type)) ?
-        IsSupported : IsNotSupported;
+    return (codecs.empty() &&
+            IsDefaultCodecSupportedLowerCase(mime_type_lower_case))
+               ? IsSupported
+               : IsNotSupported;
   }
 
   if (codecs.empty()) {
     // We get here if the mimetype expects to get a codecs parameter,
-    // but didn't get one. If |mime_type| does not have a default codec
-    // the best we can do is say "maybe" because we don't have enough
+    // but didn't get one. If |mime_type_lower_case| does not have a default
+    // codec the best we can do is say "maybe" because we don't have enough
     // information.
     Codec default_codec = INVALID_CODEC;
-    if (!GetDefaultCodec(mime_type, &default_codec))
+    if (!GetDefaultCodecLowerCase(mime_type_lower_case, &default_codec))
       return MayBeSupported;
 
     return IsCodecSupported(default_codec) ? IsSupported : IsNotSupported;
   }
 
   return AreSupportedCodecs(it_strict_map->second, codecs);
 }
 
 void MimeUtil::RemoveProprietaryMediaTypesAndCodecsForTests() {
   for (size_t i = 0; i < arraysize(proprietary_media_types); ++i) {
@@ skipping 135 matching lines @@
     case OPUS:
     case VP8:
     case VP9:
     case THEORA:
       return false;
   }
 
   return true;
 }
 
-bool MimeUtil::GetDefaultCodec(const std::string& mime_type,
-                               Codec* default_codec) const {
-  if (mime_type == "audio/mpeg" ||
-      mime_type == "audio/mp3" ||
-      mime_type == "audio/x-mp3") {
+bool MimeUtil::GetDefaultCodecLowerCase(const std::string& mime_type_lower_case,
+                                        Codec* default_codec) const {
+  if (mime_type_lower_case == "audio/mpeg" ||
+      mime_type_lower_case == "audio/mp3" ||
+      mime_type_lower_case == "audio/x-mp3") {
     *default_codec = MimeUtil::MP3;
     return true;
   }
 
   return false;
 }
 
-
-bool MimeUtil::IsDefaultCodecSupported(const std::string& mime_type) const {
+bool MimeUtil::IsDefaultCodecSupportedLowerCase(
+    const std::string& mime_type_lower_case) const {
   Codec default_codec = Codec::INVALID_CODEC;
-  if (!GetDefaultCodec(mime_type, &default_codec))
+  if (!GetDefaultCodecLowerCase(mime_type_lower_case, &default_codec))
     return false;
   return IsCodecSupported(default_codec);
 }
 
 //----------------------------------------------------------------------------
 // Wrappers for the singleton
 //----------------------------------------------------------------------------
 
 bool GetMimeTypeFromExtension(const base::FilePath::StringType& ext,
                               std::string* mime_type) {
@@ skipping 203 matching lines @@
 // vector.
 template<class T>
 void HashSetToVector(base::hash_set<T>* source, std::vector<T>* target) {
   size_t old_target_size = target->size();
   target->resize(old_target_size + source->size());
   size_t i = 0;
   for (typename base::hash_set<T>::iterator iter = source->begin();
        iter != source->end(); ++iter, ++i)
     (*target)[old_target_size + i] = *iter;
 }
-}
+
+}  // namespace
 
 void GetExtensionsForMimeType(
     const std::string& unsafe_mime_type,
     std::vector<base::FilePath::StringType>* extensions) {
   if (unsafe_mime_type == "*/*" || unsafe_mime_type == "*")
     return;
 
   const std::string mime_type = base::StringToLowerASCII(unsafe_mime_type);
   base::hash_set<base::FilePath::StringType> unique_extensions;
 
-  if (EndsWith(mime_type, "/*", true)) {
+  if (EndsWith(mime_type, "/*", false)) {
     std::string leading_mime_type = mime_type.substr(0, mime_type.length() - 1);
 
     // Find the matching StandardType from within kStandardTypes, or fall
     // through to the last (default) StandardType.
     const StandardType* type = NULL;
     for (size_t i = 0; i < arraysize(kStandardTypes); ++i) {
       type = &(kStandardTypes[i]);
       if (type->leading_mime_type &&
           leading_mime_type == type->leading_mime_type)
         break;
@@ skipping 25 matching lines @@
 
 void RemoveProprietaryMediaTypesAndCodecsForTests() {
   g_mime_util.Get().RemoveProprietaryMediaTypesAndCodecsForTests();
 }
 
 CertificateMimeType GetCertificateMimeTypeForMimeType(
     const std::string& mime_type) {
   // Don't create a map, there is only one entry in the table,
   // except on Android.
   for (size_t i = 0; i < arraysize(supported_certificate_types); ++i) {
-    if (mime_type == net::supported_certificate_types[i].mime_type)
+    if (base::strcasecmp(mime_type.c_str(),
+                         net::supported_certificate_types[i].mime_type) == 0) {
       return net::supported_certificate_types[i].cert_type;
+    }
   }
   return CERTIFICATE_MIME_TYPE_UNKNOWN;
 }
 
 bool IsSupportedCertificateMimeType(const std::string& mime_type) {
   CertificateMimeType file_type =
       GetCertificateMimeTypeForMimeType(mime_type);
   return file_type != CERTIFICATE_MIME_TYPE_UNKNOWN;
 }
 
@@ skipping 16 matching lines @@
   post_data->append("\r\n" + value + "\r\n");
 }
 
 void AddMultipartFinalDelimiterForUpload(const std::string& mime_boundary,
                                          std::string* post_data) {
   DCHECK(post_data);
   post_data->append("--" + mime_boundary + "--\r\n");
 }
 
 }  // namespace net