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

net/base/mime_sniffer.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.
 
 // Detecting mime types is a tricky business because we need to balance
 // compatibility concerns with security issues.  Here is a survey of how other
 // browsers behave and then a description of how we intend to behave.
 //
 // HTML payload, no Content-Type header:
 // * IE 7: Render as HTML
@@ skipping 327 matching lines @@
   // content might not actually have a null terminator.  In that case, we
   // pretend the length is content_size.
   const char* end = static_cast<const char*>(memchr(content, '\0', size));
   const size_t content_strlen =
       (end != NULL) ? static_cast<size_t>(end - content) : size;
 
   bool match = false;
   if (magic_entry.is_string) {
     if (content_strlen >= len) {
       // String comparisons are case-insensitive
-      match = (base::strncasecmp(magic_entry.magic, content, len) == 0);
+      match = base::EqualsCaseInsensitiveASCII(magic_entry.magic,
+                                               base::StringPiece(content, len));

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

This previously only compared the first len bytes of both strings – is this
intentionally not a prefix change on the rhs?

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

len is actually the length of magic so it should be the same. I made the comment
clearer and added a DCHECK here that it's the case.

     }
   } else {
     if (size >= len) {
       if (!magic_entry.mask) {
         match = MagicCmp(magic_entry.magic, content, len);
       } else {
         match = MagicMaskCmp(magic_entry.magic, content, len, magic_entry.mask);
       }
     }
   }
@@ skipping 96 matching lines @@
                             NULL, &office_version))
     return false;
 
   OfficeDocType type = DOC_TYPE_NONE;
   for (size_t i = 0; i < arraysize(kOfficeExtensionTypes); ++i) {
     std::string url_path = url.path();
 
     if (url_path.length() < kOfficeExtensionTypes[i].extension_len)
       continue;
 
-    const char* extension =
-        &url_path[url_path.length() - kOfficeExtensionTypes[i].extension_len];
-
-    if (0 == base::strncasecmp(extension, kOfficeExtensionTypes[i].extension,
-                               kOfficeExtensionTypes[i].extension_len)) {
+    base::StringPiece extension = base::StringPiece(url_path).substr(
+        url_path.length() - kOfficeExtensionTypes[i].extension_len);
+    if (base::EqualsCaseInsensitiveASCII(
+            extension,
+            base::StringPiece(kOfficeExtensionTypes[i].extension,
+                              kOfficeExtensionTypes[i].extension_len))) {
       type = kOfficeExtensionTypes[i].doc_type;
       break;
     }
   }
 
   if (type == DOC_TYPE_NONE)
     return false;
 
   if (office_version == "CFB") {
     switch (type) {
@@ skipping 121 matching lines @@
   if (!counter) {
     counter = UMASnifferHistogramGet("mime_sniffer.kMagicXML2",
                                      arraysize(kMagicXML));
   }
   const int kMaxTagIterations = 5;
   for (int i = 0; i < kMaxTagIterations && pos < end; ++i) {
     pos = reinterpret_cast<const char*>(memchr(pos, '<', end - pos));
     if (!pos)
       return false;
 
-    if ((pos + sizeof("<?xml") - 1 <= end) &&
-        (base::strncasecmp(pos, "<?xml", sizeof("<?xml") - 1) == 0)) {
+    static const char kXmlPrefix[] = "<?xml";
+    static const size_t kXmlPrefixLength = arraysize(kXmlPrefix) - 1;
+    static const char kDocTypePrefix[] = "<!DOCTYPE";
+    static const size_t kDocTypePrefixLength = arraysize(kDocTypePrefix) - 1;
+
+    if ((pos + kXmlPrefixLength <= end) &&
+        base::EqualsCaseInsensitiveASCII(
+            base::StringPiece(pos, kXmlPrefixLength),
+            base::StringPiece(kXmlPrefix, kXmlPrefixLength))) {
       // Skip XML declarations.
       ++pos;
       continue;
-    } else if ((pos + sizeof("<!DOCTYPE") - 1 <= end) &&
-               (base::strncasecmp(pos, "<!DOCTYPE", sizeof("<!DOCTYPE") - 1) ==
-                0)) {
+    } else if ((pos + kDocTypePrefixLength - 1 <= end) &&
+               base::EqualsCaseInsensitiveASCII(
+                   base::StringPiece(pos, kDocTypePrefixLength),
+                   base::StringPiece(kDocTypePrefix, kDocTypePrefixLength))) {
       // Skip DOCTYPE declarations.
       ++pos;
       continue;
     }
 
     if (CheckForMagicNumbers(pos, end - pos,
                              kMagicXML, arraysize(kMagicXML),
                              counter, result))
       return true;
 
@@ skipping 324 matching lines @@
       ~(1u << '\t' | 1u << '\n' | 1u << '\r' | 1u << '\f' | 1u << '\x1b');
   for (size_t i = 0; i < size; ++i) {
     uint8_t byte = static_cast<uint8_t>(content[i]);
     if (byte < 0x20 && (kBinaryBits & (1u << byte)))
       return true;
   }
   return false;
 }
 
 }  // namespace net