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 97 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, ",");
       if (end_pos == ext.size() &&

[Nico, 2015/07/08 21:58:23]

I was about to say that EqualsCase...() already does an early check for size, so
you could delete this, but it's actually required to make the StringPiece()
below not point at uninitialized memory if ext is long. A bit subtle.

[brettw, 2015/07/08 22:35:17]

Yeah, I added a comment for clarity.

-          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 291 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