Use StringView for String::replace.

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 1506 matching lines @@
 
     for (i = 0; i != m_length; ++i) {
         UChar ch = characters16()[i];
         if (ch == oldC)
             ch = newC;
         data[i] = ch;
     }
     return newImpl.release();
 }
 
-PassRefPtr<StringImpl> StringImpl::replace(unsigned position, unsigned lengthToReplace, StringImpl* str)
+// TODO(esprehn): Passing a null replacement is the same as empty string for
+// this method but all others treat null as a no-op. We should choose one
+// behavior.
+PassRefPtr<StringImpl> StringImpl::replace(unsigned position, unsigned lengthToReplace, const StringView& string)
 {
     position = min(position, length());
     lengthToReplace = min(lengthToReplace, length() - position);
-    unsigned lengthToInsert = str ? str->length() : 0;
+    unsigned lengthToInsert = string.length();
     if (!lengthToReplace && !lengthToInsert)
         return this;
 
     RELEASE_ASSERT((length() - lengthToReplace) < (numeric_limits<unsigned>::max() - lengthToInsert));
 
-    if (is8Bit() && (!str || str->is8Bit())) {
+    if (is8Bit() && (string.isNull() || string.is8Bit())) {
         LChar* data;
         RefPtr<StringImpl> newImpl =
         createUninitialized(length() - lengthToReplace + lengthToInsert, data);
         memcpy(data, characters8(), position * sizeof(LChar));
-        if (str)
-            memcpy(data + position, str->characters8(), lengthToInsert * sizeof(LChar));
+        if (!string.isNull())
+            memcpy(data + position, string.characters8(), lengthToInsert * sizeof(LChar));
         memcpy(data + position + lengthToInsert, characters8() + position + lengthToReplace,
             (length() - position - lengthToReplace) * sizeof(LChar));
         return newImpl.release();
     }
     UChar* data;
     RefPtr<StringImpl> newImpl =
         createUninitialized(length() - lengthToReplace + lengthToInsert, data);
     if (is8Bit())
         for (unsigned i = 0; i < position; ++i)
             data[i] = characters8()[i];
     else
         memcpy(data, characters16(), position * sizeof(UChar));
-    if (str) {
-        if (str->is8Bit())
+    if (!string.isNull()) {
+        if (string.is8Bit())
             for (unsigned i = 0; i < lengthToInsert; ++i)
-                data[i + position] = str->characters8()[i];
+                data[i + position] = string.characters8()[i];
         else
-            memcpy(data + position, str->characters16(), lengthToInsert * sizeof(UChar));
+            memcpy(data + position, string.characters16(), lengthToInsert * sizeof(UChar));
     }
     if (is8Bit()) {
         for (unsigned i = 0; i < length() - position - lengthToReplace; ++i)
             data[i + position + lengthToInsert] = characters8()[i + position + lengthToReplace];
     } else {
         memcpy(data + position + lengthToInsert, characters16() + position + lengthToReplace,
             (length() - position - lengthToReplace) * sizeof(UChar));
     }
     return newImpl.release();
 }
 
-PassRefPtr<StringImpl> StringImpl::replace(UChar pattern, StringImpl* replacement)
+PassRefPtr<StringImpl> StringImpl::replace(UChar pattern, const StringView& replacement)
 {
-    if (!replacement)
+    if (replacement.isNull())
         return this;
-
-    if (replacement->is8Bit())
-        return replace(pattern, replacement->characters8(), replacement->length());
-
-    return replace(pattern, replacement->characters16(), replacement->length());
+    if (replacement.is8Bit())
+        return replace(pattern, replacement.characters8(), replacement.length());
+    return replace(pattern, replacement.characters16(), replacement.length());
 }
 
 PassRefPtr<StringImpl> StringImpl::replace(UChar pattern, const LChar* replacement, unsigned repStrLength)
 {
     ASSERT(replacement);
 
     size_t srcSegmentStart = 0;
     unsigned matchCount = 0;
 
     // Count the matches.
@@ skipping 135 matching lines @@
     }
 
     srcSegmentLength = m_length - srcSegmentStart;
     memcpy(data + dstOffset, characters16() + srcSegmentStart, srcSegmentLength * sizeof(UChar));
 
     ASSERT(dstOffset + srcSegmentLength == newImpl->length());
 
     return newImpl.release();
 }
 
-PassRefPtr<StringImpl> StringImpl::replace(StringImpl* pattern, StringImpl* replacement)
+PassRefPtr<StringImpl> StringImpl::replace(const StringView& pattern, const StringView& replacement)
 {
-    if (!pattern || !replacement)
+    if (pattern.isNull() || replacement.isNull())
         return this;
 
-    unsigned patternLength = pattern->length();
+    unsigned patternLength = pattern.length();
     if (!patternLength)
         return this;
 
-    unsigned repStrLength = replacement->length();
+    unsigned repStrLength = replacement.length();
     size_t srcSegmentStart = 0;
     unsigned matchCount = 0;
 
     // Count the matches.
     while ((srcSegmentStart = find(pattern, srcSegmentStart)) != kNotFound) {
         ++matchCount;
         srcSegmentStart += patternLength;
     }
 
     // If we have 0 matches, we don't have to do any more work
     if (!matchCount)
         return this;
 
     unsigned newSize = m_length - matchCount * patternLength;
     RELEASE_ASSERT(!repStrLength || matchCount <= numeric_limits<unsigned>::max() / repStrLength);
 
     RELEASE_ASSERT(newSize <= (numeric_limits<unsigned>::max() - matchCount * repStrLength));
 
     newSize += matchCount * repStrLength;
 
 
     // Construct the new data
     size_t srcSegmentEnd;
     unsigned srcSegmentLength;
     srcSegmentStart = 0;
     unsigned dstOffset = 0;
     bool srcIs8Bit = is8Bit();
-    bool replacementIs8Bit = replacement->is8Bit();
+    bool replacementIs8Bit = replacement.is8Bit();
 
     // There are 4 cases:
     // 1. This and replacement are both 8 bit.
     // 2. This and replacement are both 16 bit.
     // 3. This is 8 bit and replacement is 16 bit.
     // 4. This is 16 bit and replacement is 8 bit.
     if (srcIs8Bit && replacementIs8Bit) {
         // Case 1
         LChar* data;
         RefPtr<StringImpl> newImpl = createUninitialized(newSize, data);
         while ((srcSegmentEnd = find(pattern, srcSegmentStart)) != kNotFound) {
             srcSegmentLength = srcSegmentEnd - srcSegmentStart;
             memcpy(data + dstOffset, characters8() + srcSegmentStart, srcSegmentLength * sizeof(LChar));
             dstOffset += srcSegmentLength;
-            memcpy(data + dstOffset, replacement->characters8(), repStrLength * sizeof(LChar));
+            memcpy(data + dstOffset, replacement.characters8(), repStrLength * sizeof(LChar));
             dstOffset += repStrLength;
             srcSegmentStart = srcSegmentEnd + patternLength;
         }
 
         srcSegmentLength = m_length - srcSegmentStart;
         memcpy(data + dstOffset, characters8() + srcSegmentStart, srcSegmentLength * sizeof(LChar));
 
         ASSERT(dstOffset + srcSegmentLength == newImpl->length());
 
         return newImpl.release();
     }
 
     UChar* data;
     RefPtr<StringImpl> newImpl = createUninitialized(newSize, data);
     while ((srcSegmentEnd = find(pattern, srcSegmentStart)) != kNotFound) {
         srcSegmentLength = srcSegmentEnd - srcSegmentStart;
         if (srcIs8Bit) {
             // Case 3.
             for (unsigned i = 0; i < srcSegmentLength; ++i)
                 data[i + dstOffset] = characters8()[i + srcSegmentStart];
         } else {
             // Case 2 & 4.
             memcpy(data + dstOffset, characters16() + srcSegmentStart, srcSegmentLength * sizeof(UChar));
         }
         dstOffset += srcSegmentLength;
         if (replacementIs8Bit) {
             // Cases 2 & 3.
             for (unsigned i = 0; i < repStrLength; ++i)
-                data[i + dstOffset] = replacement->characters8()[i];
+                data[i + dstOffset] = replacement.characters8()[i];
         } else {
             // Case 4
-            memcpy(data + dstOffset, replacement->characters16(), repStrLength * sizeof(UChar));
+            memcpy(data + dstOffset, replacement.characters16(), repStrLength * sizeof(UChar));
         }
         dstOffset += repStrLength;
         srcSegmentStart = srcSegmentEnd + patternLength;
     }
 
     srcSegmentLength = m_length - srcSegmentStart;
     if (srcIs8Bit) {
         // Case 3.
         for (unsigned i = 0; i < srcSegmentLength; ++i)
             data[i + dstOffset] = characters8()[i + srcSegmentStart];
@@ skipping 171 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