Replace base::str[n]casecmp with helper functions.

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 98 matching lines @@
   { "application/x-mpegurl", "m3u8" },
 };
 
 const char* FindMimeType(const MimeInfo* mappings,
                          size_t mappings_len,
                          const std::string& ext) {
   for (size_t i = 0; i < mappings_len; ++i) {
     const char* extensions = mappings[i].extensions;
     for (;;) {
       size_t end_pos = strcspn(extensions, ",");
+      // The length check is required to prevent the StringPiece below from
+      // including uninitialized memory if ext is longer than extensions.
       if (end_pos == ext.size() &&
-          base::strncasecmp(extensions, ext.data(), ext.size()) == 0)
+          base::EqualsCaseInsensitiveASCII(
+              base::StringPiece(extensions, ext.size()), ext))
         return mappings[i].mime_type;
       extensions += end_pos;
       if (!*extensions)
         break;
       extensions += 1;  // skip over comma
     }
   }
   return NULL;
 }
 
@@ skipping 130 matching lines @@
   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.size() == base_type.size() &&
-        base::strncasecmp(base_pattern.data(), base_type.data(),
-                          base_pattern.size()) == 0) {
+    if (base::EqualsCaseInsensitiveASCII(base_pattern, base_type))
       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;
 
   base::StringPiece base_pattern_piece(base_pattern);
   base::StringPiece left(base_pattern_piece.substr(0, star));
   base::StringPiece right(base_pattern_piece.substr(star + 1));
 
@@ skipping 292 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