WTF::notFound looks too much like a local variable.

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 489 matching lines @@
 WTF_EXPORT bool equalIgnoringNullity(StringImpl*, StringImpl*);
 
 template<typename CharacterType>
 inline size_t find(const CharacterType* characters, unsigned length, CharacterType matchCharacter, unsigned index = 0)
 {
     while (index < length) {
         if (characters[index] == matchCharacter)
             return index;
         ++index;
     }
-    return notFound;
+    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 notFound;
+        return kNotFound;
     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 notFound;
+    return kNotFound;
 }
 
 inline size_t find(const UChar* characters, unsigned length, CharacterMatchFunctionPtr matchFunction, unsigned index = 0)
 {
     while (index < length) {
         if (matchFunction(characters[index]))
             return index;
         ++index;
     }
-    return notFound;
+    return kNotFound;
 }
 
 template<typename CharacterType>
 inline size_t findNextLineStart(const CharacterType* characters, unsigned length, unsigned index = 0)
 {
     while (index < length) {
         CharacterType c = characters[index++];
         if ((c != '\n') && (c != '\r'))
             continue;
 
@@ skipping 10 matching lines @@
             if (c2 != '\n')
                 return index; // Case 2: just \r.
 
             // Case 1: \r\n.
             // But, there's only a start of a new line if there are more
             // characters beyond the \r\n.
             if (++index < length)
                 return index;
         }
     }
-    return notFound;
+    return kNotFound;
 }
 
 template<typename CharacterType>
 inline size_t reverseFindLineTerminator(const CharacterType* characters, unsigned length, unsigned index = UINT_MAX)
 {
     if (!length)
-        return notFound;
+        return kNotFound;
     if (index >= length)
         index = length - 1;
     CharacterType c = characters[index];
     while ((c != '\n') && (c != '\r')) {
         if (!index--)
-            return notFound;
+            return kNotFound;
         c = characters[index];
     }
     return index;
 }
 
 template<typename CharacterType>
 inline size_t reverseFind(const CharacterType* characters, unsigned length, CharacterType matchCharacter, unsigned index = UINT_MAX)
 {
     if (!length)
-        return notFound;
+        return kNotFound;
     if (index >= length)
         index = length - 1;
     while (characters[index] != matchCharacter) {
         if (!index--)
-            return notFound;
+            return kNotFound;
     }
     return index;
 }
 
 ALWAYS_INLINE size_t reverseFind(const UChar* characters, unsigned length, LChar matchCharacter, unsigned index = UINT_MAX)
 {
     return reverseFind(characters, length, static_cast<UChar>(matchCharacter), index);
 }
 
 inline size_t reverseFind(const LChar* characters, unsigned length, UChar matchCharacter, unsigned index = UINT_MAX)
 {
     if (matchCharacter & ~0xFF)
-        return notFound;
+        return kNotFound;
     return reverseFind(characters, length, static_cast<LChar>(matchCharacter), index);
 }
 
 inline size_t StringImpl::find(LChar character, unsigned start)
 {
     if (is8Bit())
         return WTF::find(characters8(), m_length, character, start);
     return WTF::find(characters16(), m_length, character, start);
 }
 
@@ skipping 113 matching lines @@
 }
 
 using WTF::StringImpl;
 using WTF::equal;
 using WTF::equalNonNull;
 using WTF::TextCaseSensitivity;
 using WTF::TextCaseSensitive;
 using WTF::TextCaseInsensitive;
 
 #endif