Reland: Switch WTF::find on LChar to use memchr.

third_party/WebKit/Source/wtf/text/StringImpl.h

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  * Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2013 Apple Inc. All rights reserved.
  * Copyright (C) 2009 Google Inc. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
@@ skipping 13 matching lines @@
 #define StringImpl_h
 
 #include "wtf/ASCIICType.h"
 #include "wtf/Forward.h"
 #include "wtf/HashMap.h"
 #include "wtf/StringHasher.h"
 #include "wtf/Vector.h"
 #include "wtf/WTFExport.h"
 #include "wtf/text/Unicode.h"
 #include <limits.h>
+#include <string.h>
 
 #if OS(MACOSX)
 typedef const struct __CFString * CFStringRef;
 #endif
 
 #ifdef __OBJC__
 @class NSString;
 #endif
 
 namespace WTF {
@@ skipping 475 matching lines @@
 inline bool equalIgnoringASCIICase(const StringImpl* a, const char* b, unsigned length) { return equalIgnoringASCIICase(a, reinterpret_cast<const LChar*>(b), length); }
 inline bool equalIgnoringASCIICase(const StringImpl* a, const LChar* b)
 {
     size_t length = b ? strlen(reinterpret_cast<const char*>(b)) : 0;
     return equalIgnoringASCIICase(a, b, length);
 }
 inline bool equalIgnoringASCIICase(const StringImpl* a, const char* b) { return equalIgnoringASCIICase(a, reinterpret_cast<const LChar*>(b)); }
 
 WTF_EXPORT int codePointCompareIgnoringASCIICase(const StringImpl*, const LChar*);
 
-template<typename CharacterType>
-inline size_t find(const CharacterType* characters, unsigned length, CharacterType matchCharacter, unsigned index = 0)
+inline size_t find(const LChar* characters, unsigned length, LChar matchCharacter, unsigned index = 0)
+{
+    // Some clients rely on being able to pass index >= length.

[Nico, 2016/06/10 19:09:14]

should the clients be fixed instead?

[jbroman, 2016/06/10 19:15:13]

In my ideal world (in which nobody passes out-of-range indexes), yes. But I fear
such sites are subtle and hard to find, except when MSAN happens to find them.

The particular one that was reported was in ContentType::parameter, where
start+1 and start+2 are passed without bounds checking. It's fixable there, but
I suspect other sites also rely on it, and there are many to inspect.

I don't think it's worth doing as part of this wild goose chase, since it's not
super harmful (at least, now that I know that such sites exist).

+    if (index >= length)
+        return kNotFound;
+    const LChar* found = static_cast<const LChar*>(
+        memchr(characters + index, matchCharacter, length - index));
+    return found ? found - characters : kNotFound;
+}
+
+inline size_t find(const UChar* characters, unsigned length, UChar matchCharacter, unsigned index = 0)
 {
     while (index < length) {
         if (characters[index] == matchCharacter)
             return index;
         ++index;
     }
     return kNotFound;
 }
 
 ALWAYS_INLINE size_t find(const UChar* characters, unsigned length, LChar matchCharacter, unsigned index = 0)
 {
     return find(characters, length, static_cast<UChar>(matchCharacter), index);
 }
 
 inline size_t find(const LChar* characters, unsigned length, UChar matchCharacter, unsigned index = 0)
 {
     if (matchCharacter & ~0xFF)
         return kNotFound;
     return find(characters, length, static_cast<LChar>(matchCharacter), index);
 }
 
+template <typename CharacterType>
+inline size_t find(const CharacterType* characters, unsigned length, char matchCharacter, unsigned index = 0)
+{
+    return find(characters, length, static_cast<LChar>(matchCharacter), index);
+}
+
 inline size_t find(const LChar* characters, unsigned length, CharacterMatchFunctionPtr matchFunction, unsigned index = 0)
 {
     while (index < length) {
         if (matchFunction(characters[index]))
             return index;
         ++index;
     }
     return kNotFound;
 }
 
@@ skipping 208 matching lines @@
 
 using WTF::StringImpl;
 using WTF::equal;
 using WTF::equalNonNull;
 using WTF::TextCaseSensitivity;
 using WTF::TextCaseSensitive;
 using WTF::TextCaseASCIIInsensitive;
 using WTF::TextCaseInsensitive;
 
 #endif