Use StringView for String::reverseFind.

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

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2001 Dirk Mueller ( mueller@kde.org )
  * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2013 Apple Inc. All rights reserved.
  * Copyright (C) 2006 Andrew Wellington (proton@wiretapped.net)
  *
  * 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
@@ skipping 1299 matching lines @@
 }
 
 size_t StringImpl::reverseFind(UChar c, unsigned index)
 {
     if (is8Bit())
         return WTF::reverseFind(characters8(), m_length, c, index);
     return WTF::reverseFind(characters16(), m_length, c, index);
 }
 
 template <typename SearchCharacterType, typename MatchCharacterType>
-ALWAYS_INLINE static size_t reverseFindInner(const SearchCharacterType* searchCharacters, const MatchCharacterType* matchCharacters, unsigned index, unsigned length, unsigned matchLength)
+ALWAYS_INLINE static size_t reverseFindInternal(const SearchCharacterType* searchCharacters, const MatchCharacterType* matchCharacters, unsigned index, unsigned length, unsigned matchLength)
 {
     // Optimization: keep a running hash of the strings,
     // only call equal if the hashes match.
 
     // delta is the number of additional times to test; delta == 0 means test only once.
     unsigned delta = min(index, length - matchLength);
 
     unsigned searchHash = 0;
     unsigned matchHash = 0;
     for (unsigned i = 0; i < matchLength; ++i) {
         searchHash += searchCharacters[delta + i];
         matchHash += matchCharacters[i];
     }
 
     // keep looping until we match
     while (searchHash != matchHash || !equal(searchCharacters + delta, matchCharacters, matchLength)) {
         if (!delta)
             return kNotFound;
         --delta;
         searchHash -= searchCharacters[delta + matchLength];
         searchHash += searchCharacters[delta];
     }
     return delta;
 }
 
-size_t StringImpl::reverseFind(StringImpl* matchString, unsigned index)
+size_t StringImpl::reverseFind(const StringView& matchString, unsigned index)
 {
-    // Check for null or empty string to match against
-    if (!matchString)
+    if (UNLIKELY(matchString.isNull()))
         return kNotFound;
-    unsigned matchLength = matchString->length();
+
+    unsigned matchLength = matchString.length();
     unsigned ourLength = length();
     if (!matchLength)
         return min(index, ourLength);
 
     // Optimization 1: fast case for strings of length 1.
     if (matchLength == 1) {
         if (is8Bit())
-            return WTF::reverseFind(characters8(), ourLength, (*matchString)[0], index);
-        return WTF::reverseFind(characters16(), ourLength, (*matchString)[0], index);
+            return WTF::reverseFind(characters8(), ourLength, matchString[0], index);
+        return WTF::reverseFind(characters16(), ourLength, matchString[0], index);
     }
 
     // Check index & matchLength are in range.
     if (matchLength > ourLength)
         return kNotFound;
 
     if (is8Bit()) {
-        if (matchString->is8Bit())
-            return reverseFindInner(characters8(), matchString->characters8(), index, ourLength, matchLength);
-        return reverseFindInner(characters8(), matchString->characters16(), index, ourLength, matchLength);
+        if (matchString.is8Bit())
+            return reverseFindInternal(characters8(), matchString.characters8(), index, ourLength, matchLength);
+        return reverseFindInternal(characters8(), matchString.characters16(), index, ourLength, matchLength);
     }
-
-    if (matchString->is8Bit())
-        return reverseFindInner(characters16(), matchString->characters8(), index, ourLength, matchLength);
-
-    return reverseFindInner(characters16(), matchString->characters16(), index, ourLength, matchLength);
+    if (matchString.is8Bit())
+        return reverseFindInternal(characters16(), matchString.characters8(), index, ourLength, matchLength);
+    return reverseFindInternal(characters16(), matchString.characters16(), index, ourLength, matchLength);
 }
 
 bool StringImpl::startsWith(UChar character) const
 {
     return m_length && (*this)[0] == character;
 }
 
 bool StringImpl::startsWith(const StringView& prefix) const
 {
     if (prefix.length() > length())
@@ skipping 626 matching lines @@
         } else if (localeIdMatchesLang(localeIdentifier, "lt")) {
             // TODO(rob.buis) implement upper-casing rules for lt
             // like in StringImpl::upper(locale).
         }
     }
 
     return toUpper(c);
 }
 
 } // namespace WTF