topcoderKai
diff --git a/‎Source/JavaScriptCore/ChangeLog
+19 b/‎Source/JavaScriptCore/ChangeLog
+19
diff --git a/‎Source/JavaScriptCore/inspector/agents/InspectorDebuggerAgent.cpp
+1-1 b/‎Source/JavaScriptCore/inspector/agents/InspectorDebuggerAgent.cpp
+1-1
diff --git a/‎Source/JavaScriptCore/runtime/JSString.cpp
+10-11 b/‎Source/JavaScriptCore/runtime/JSString.cpp
+10-11
diff --git a/‎Source/JavaScriptCore/runtime/StringPrototype.cpp
+10-10 b/‎Source/JavaScriptCore/runtime/StringPrototype.cpp
+10-10
diff --git a/‎Source/JavaScriptCore/yarr/RegularExpression.h
+3-5 b/‎Source/JavaScriptCore/yarr/RegularExpression.h
+3-5
diff --git a/‎Source/WTF/ChangeLog
+62 b/‎Source/WTF/ChangeLog
+62
diff --git a/‎Source/WTF/wtf/text/ASCIIFastPath.h
+2 b/‎Source/WTF/wtf/text/ASCIIFastPath.h
+2
@@ -1,3 +1,22 @@
+2017-11-23  Darin Adler  <[email protected]>
+
+        Reduce WTF::String operations that do unnecessary Unicode operations instead of ASCII
+        https://bugs.webkit.org/show_bug.cgi?id=179907
+
+        Reviewed by Sam Weinig.
+
+        * inspector/agents/InspectorDebuggerAgent.cpp:
+        (Inspector::matches): Removed explicit TextCaseSensitive because RegularExpression now
+        defaults to that.
+
+        * runtime/StringPrototype.cpp:
+        (JSC::stringIncludesImpl): Use String::find since there is no overload of
+        String::contains that takes a start offset now that we removed the one that took a
+        caseSensitive boolean. We can add one later if we like, but this should do for now.
+
+        * yarr/RegularExpression.h: Moved the TextCaseSensitivity enumeration here from
+        the StringImpl.h header because it is only used here.
+
 2017-11-22  Simon Fraser  <[email protected]>
 
         Followup after r225084: if anyone called GenericTypedArrayView() it didn't compile,
 
@@ -335,7 +335,7 @@ static Ref<InspectorObject> buildObjectForBreakpointCookie(const String& url, in
 static bool matches(const String& url, const String& pattern, bool isRegex)
 {
     if (isRegex) {
-        JSC::Yarr::RegularExpression regex(pattern, TextCaseSensitive);
+        JSC::Yarr::RegularExpression regex(pattern);
         return regex.match(url) != -1;
     }
     return url == pattern;
 
@@ -117,8 +117,7 @@ static const unsigned maxLengthForOnStackResolve = 2048;
 void JSRopeString::resolveRopeInternal8(LChar* buffer) const
 {
     if (isSubstring()) {
-        StringImpl::copyChars(
-            buffer, substringBase()->m_value.characters8() + substringOffset(), length());
+        StringImpl::copyCharacters(buffer, substringBase()->m_value.characters8() + substringOffset(), length());
         return;
     }
 
@@ -138,7 +137,7 @@ void JSRopeString::resolveRopeInternal8NoSubstring(LChar* buffer) const
     for (size_t i = 0; i < s_maxInternalRopeLength && fiber(i); ++i) {
         const StringImpl& fiberString = *fiber(i)->m_value.impl();
         unsigned length = fiberString.length();
-        StringImpl::copyChars(position, fiberString.characters8(), length);
+        StringImpl::copyCharacters(position, fiberString.characters8(), length);
         position += length;
     }
     ASSERT((buffer + length()) == position);
@@ -147,7 +146,7 @@ void JSRopeString::resolveRopeInternal8NoSubstring(LChar* buffer) const
 void JSRopeString::resolveRopeInternal16(UChar* buffer) const
 {
     if (isSubstring()) {
-        StringImpl::copyChars(
+        StringImpl::copyCharacters(
             buffer, substringBase()->m_value.characters16() + substringOffset(), length());
         return;
     }
@@ -169,9 +168,9 @@ void JSRopeString::resolveRopeInternal16NoSubstring(UChar* buffer) const
         const StringImpl& fiberString = *fiber(i)->m_value.impl();
         unsigned length = fiberString.length();
         if (fiberString.is8Bit())
-            StringImpl::copyChars(position, fiberString.characters8(), length);
+            StringImpl::copyCharacters(position, fiberString.characters8(), length);
         else
-            StringImpl::copyChars(position, fiberString.characters16(), length);
+            StringImpl::copyCharacters(position, fiberString.characters16(), length);
         position += length;
     }
     ASSERT((buffer + length()) == position);
@@ -335,7 +334,7 @@ void JSRopeString::resolveRopeSlowCase8(LChar* buffer) const
 
         unsigned length = currentFiber->length();
         position -= length;
-        StringImpl::copyChars(position, characters, length);
+        StringImpl::copyCharacters(position, characters, length);
     }
 
     ASSERT(buffer == position);
@@ -363,9 +362,9 @@ void JSRopeString::resolveRopeSlowCase(UChar* buffer) const
                 unsigned length = currentFiberAsRope->length();
                 position -= length;
                 if (string->is8Bit())
-                    StringImpl::copyChars(position, string->characters8() + offset, length);
+                    StringImpl::copyCharacters(position, string->characters8() + offset, length);
                 else
-                    StringImpl::copyChars(position, string->characters16() + offset, length);
+                    StringImpl::copyCharacters(position, string->characters16() + offset, length);
                 continue;
             }
             for (size_t i = 0; i < s_maxInternalRopeLength && currentFiberAsRope->fiber(i); ++i)
@@ -377,9 +376,9 @@ void JSRopeString::resolveRopeSlowCase(UChar* buffer) const
         unsigned length = string->length();
         position -= length;
         if (string->is8Bit())
-            StringImpl::copyChars(position, string->characters8(), length);
+            StringImpl::copyCharacters(position, string->characters8(), length);
         else
-            StringImpl::copyChars(position, string->characters16(), length);
+            StringImpl::copyCharacters(position, string->characters16(), length);
     }
 
     ASSERT(buffer == position);
 
@@ -341,7 +341,7 @@ static ALWAYS_INLINE JSValue jsSpliceSubstrings(ExecState* exec, JSString* sourc
         int bufferPos = 0;
         for (int i = 0; i < rangeCount; i++) {
             if (int srcLen = substringRanges[i].length) {
-                StringImpl::copyChars(buffer + bufferPos, sourceData + substringRanges[i].position, srcLen);
+                StringImpl::copyCharacters(buffer + bufferPos, sourceData + substringRanges[i].position, srcLen);
                 bufferPos += srcLen;
             }
         }
@@ -360,7 +360,7 @@ static ALWAYS_INLINE JSValue jsSpliceSubstrings(ExecState* exec, JSString* sourc
     int bufferPos = 0;
     for (int i = 0; i < rangeCount; i++) {
         if (int srcLen = substringRanges[i].length) {
-            StringImpl::copyChars(buffer + bufferPos, sourceData + substringRanges[i].position, srcLen);
+            StringImpl::copyCharacters(buffer + bufferPos, sourceData + substringRanges[i].position, srcLen);
             bufferPos += srcLen;
         }
     }
@@ -413,13 +413,13 @@ static ALWAYS_INLINE JSValue jsSpliceSubstringsWithSeparators(ExecState* exec, J
         for (int i = 0; i < maxCount; i++) {
             if (i < rangeCount) {
                 if (int srcLen = substringRanges[i].length) {
-                    StringImpl::copyChars(buffer + bufferPos, sourceData + substringRanges[i].position, srcLen);
+                    StringImpl::copyCharacters(buffer + bufferPos, sourceData + substringRanges[i].position, srcLen);
                     bufferPos += srcLen;
                 }
             }
             if (i < separatorCount) {
                 if (int sepLen = separators[i].length()) {
-                    StringImpl::copyChars(buffer + bufferPos, separators[i].characters8(), sepLen);
+                    StringImpl::copyCharacters(buffer + bufferPos, separators[i].characters8(), sepLen);
                     bufferPos += sepLen;
                 }
             }
@@ -440,18 +440,18 @@ static ALWAYS_INLINE JSValue jsSpliceSubstringsWithSeparators(ExecState* exec, J
         if (i < rangeCount) {
             if (int srcLen = substringRanges[i].length) {
                 if (source.is8Bit())
-                    StringImpl::copyChars(buffer + bufferPos, source.characters8() + substringRanges[i].position, srcLen);
+                    StringImpl::copyCharacters(buffer + bufferPos, source.characters8() + substringRanges[i].position, srcLen);
                 else
-                    StringImpl::copyChars(buffer + bufferPos, source.characters16() + substringRanges[i].position, srcLen);
+                    StringImpl::copyCharacters(buffer + bufferPos, source.characters16() + substringRanges[i].position, srcLen);
                 bufferPos += srcLen;
             }
         }
         if (i < separatorCount) {
             if (int sepLen = separators[i].length()) {
                 if (separators[i].is8Bit())
-                    StringImpl::copyChars(buffer + bufferPos, separators[i].characters8(), sepLen);
+                    StringImpl::copyCharacters(buffer + bufferPos, separators[i].characters8(), sepLen);
                 else
-                    StringImpl::copyChars(buffer + bufferPos, separators[i].characters16(), sepLen);
+                    StringImpl::copyCharacters(buffer + bufferPos, separators[i].characters16(), sepLen);
                 bufferPos += sepLen;
             }
         }
@@ -1799,7 +1799,7 @@ static EncodedJSValue JSC_HOST_CALL stringIncludesImpl(VM& vm, ExecState* exec,
         RETURN_IF_EXCEPTION(scope, encodedJSValue());
     }
 
-    return JSValue::encode(jsBoolean(stringToSearchIn.contains(searchString, true, start)));
+    return JSValue::encode(jsBoolean(stringToSearchIn.find(searchString, start) != notFound));
 }
 
 EncodedJSValue JSC_HOST_CALL stringProtoFuncIncludes(ExecState* exec)
@@ -1900,7 +1900,7 @@ static JSValue normalize(ExecState* exec, const UChar* source, size_t sourceLeng
 
     if (U_FAILURE(status) && status != U_BUFFER_OVERFLOW_ERROR) {
         // The behavior is not specified when normalize fails.
-        // Now we throw a type erorr since it seems that the contents of the string are invalid.
+        // Now we throw a type error since it seems that the contents of the string are invalid.
         return throwTypeError(exec, scope);
     }
 
 
@@ -29,15 +29,13 @@
 
 namespace JSC { namespace Yarr {
 
-enum MultilineMode {
-    MultilineDisabled,
-    MultilineEnabled
-};
+enum MultilineMode { MultilineDisabled, MultilineEnabled };
+enum TextCaseSensitivity { TextCaseSensitive, TextCaseInsensitive };
 
 class JS_EXPORT_PRIVATE RegularExpression {
     WTF_MAKE_FAST_ALLOCATED;
 public:
-    RegularExpression(const String&, TextCaseSensitivity, MultilineMode = MultilineDisabled);
+    explicit RegularExpression(const String&, TextCaseSensitivity = TextCaseSensitive, MultilineMode = MultilineDisabled);
     ~RegularExpression();
 
     RegularExpression(const RegularExpression&);
 
@@ -1,3 +1,65 @@
+2017-11-23  Darin Adler  <[email protected]>
+
+        Reduce WTF::String operations that do unnecessary Unicode operations instead of ASCII
+        https://bugs.webkit.org/show_bug.cgi?id=179907
+
+        Reviewed by Sam Weinig.
+
+        * wtf/text/ASCIIFastPath.h: Moved the using for charactersAreAllASCII here since
+        the function is defined here.
+
+        * wtf/text/AtomicString.h: Removed overloads of contains, find, startsWith, and
+        endsWith that take a boolean indicating whether they should be "case sensitive".
+        When false, this was doing Unicode case folding, and no callers needed that.
+        Also tweaked formatting and argument names.
+
+        * wtf/text/IntegerToStringConversion.h: Added an include of LChar.h since this file
+        uses that. Also tweaked formatting a bit.
+
+        * wtf/text/StringImpl.cpp:
+        (WTF::StringImpl::containsOnlyWhitespace): Deleted. Despite its name sounding like
+        it used the full Unicode whitespace definition, this actually checked isASCIISpace.
+        Callers now all use isAllSpecialCharacters instead with the whitespace definition
+        that is appropriate to each call site.
+        (WTF::latin1CaseFoldTable): Deleted.
+        (WTF::equalCompatibilityCaseless): Deleted.
+        (WTF::StringImpl::findIgnoringCase): Deleted.
+        (WTF::findIgnoringCaseInner): Deleted.
+        (WTF::reverseFindIgnoringCaseInner): Deleted.
+        (WTF::StringImpl::reverseFindIgnoringCase): Deleted.
+        (WTF::equalInner): Removed boolean caseSensitive argument.
+        (WTF::StringImpl::startsWith): Ditto.
+        (WTF::StringImpl::endsWith): Ditto.
+
+        * wtf/text/StringImpl.h: Moved TextCaseSensitivity out into a different header.
+        Moved ASCIIFastPath.h include here from WTFString.h. Moved isAllSpecialCharacters
+        free function here from WTFString.h. Moved lots of function bodies out of class
+        definitions to make the class definitions easier to read. Sorted things a bit.
+        Tweaked formatting. Marked constructor that takes one argument explicit. Added
+        an isEmpty function like the one in String. Renamed copyChars to copyCharacters.
+        Added isAllASCII, isAllLatin1 and isAllSpecialCharacters functions. Removed
+        boolean caseSensitive arguments from various functions. Removed findIgnoringCase
+        and reverseFindIgnoringCase. Added a FIXME to codePointCompare about the way it
+        treats null and empty strings as equal. Changed length argument in remove to
+        unsigned to match other lengths.
+
+        * wtf/text/WTFString.cpp:
+        (WTF::String::removeInternal): Changed length argument to be unsigned.
+        (WTF::createWithFormatAndArguments): Use emptyString.
+        (WTF::String::isSafeToSendToAnotherThread const): Rewrote to be easier to read.
+
+        * wtf/text/WTFString.h: Moved ASCIIFastPath.h to StringImpl.h. Moved lots of
+        function bodies out of class definitions to make the class definitions easier
+        to read, made others one-liners. Removed the String::at function but kept the
+        String::characterAt function; the two were identical. Removed boolean
+        caseSensitive arguments from various functions. Removed findIgnoringCase and
+        reverseFindIgnoringCase. Renamed containsOnlyASCII to isAllASCII and
+        containsOnlyLatin1 to isAllLatin1 to match the naming of isAllSpecialCharacters.
+        Moved the inline implementations of functions that are defined above further
+        down, after things like the ASCIILiteral class and various functions.
+
+        * wtf/text/icu/UTextProviderLatin1.cpp: Updated name of copyChars.
+
 2017-11-22  Stephan Szabo  <[email protected]>
 
         tuple related items are used in WTF without including tuple
 
@@ -194,4 +194,6 @@ inline void copyLCharsFromUCharSource(LChar* destination, const UChar* source, s
 
 } // namespace WTF
 
+using WTF::charactersAreAllASCII;
+
 #endif // ASCIIFastPath_h
Original file line number	Diff line number	Diff line change
`@@ -335,7 +335,7 @@ static Ref<InspectorObject> buildObjectForBreakpointCookie(const String& url, in`
`335`	`335`	`static bool matches(const String& url, const String& pattern, bool isRegex)`
`336`	`336`	`{`
`337`	`337`	`if (isRegex) {`
`338`		`- JSC::Yarr::RegularExpression regex(pattern, TextCaseSensitive);`
	`338`	`+ JSC::Yarr::RegularExpression regex(pattern);`
`339`	`339`	`return regex.match(url) != -1;`
`340`	`340`	`}`
`341`	`341`	`return url == pattern;`
Original file line number	Diff line number	Diff line change
`@@ -341,7 +341,7 @@ static ALWAYS_INLINE JSValue jsSpliceSubstrings(ExecState* exec, JSString* sourc`
`341`	`341`	`int bufferPos = 0;`
`342`	`342`	`for (int i = 0; i < rangeCount; i++) {`
`343`	`343`	`if (int srcLen = substringRanges[i].length) {`
`344`		`- StringImpl::copyChars(buffer + bufferPos, sourceData + substringRanges[i].position, srcLen);`
	`344`	`+ StringImpl::copyCharacters(buffer + bufferPos, sourceData + substringRanges[i].position, srcLen);`
`345`	`345`	`bufferPos += srcLen;`
`346`	`346`	`}`
`347`	`347`	`}`
`@@ -360,7 +360,7 @@ static ALWAYS_INLINE JSValue jsSpliceSubstrings(ExecState* exec, JSString* sourc`
`360`	`360`	`int bufferPos = 0;`
`361`	`361`	`for (int i = 0; i < rangeCount; i++) {`
`362`	`362`	`if (int srcLen = substringRanges[i].length) {`
`363`		`- StringImpl::copyChars(buffer + bufferPos, sourceData + substringRanges[i].position, srcLen);`
	`363`	`+ StringImpl::copyCharacters(buffer + bufferPos, sourceData + substringRanges[i].position, srcLen);`
`364`	`364`	`bufferPos += srcLen;`
`365`	`365`	`}`
`366`	`366`	`}`
`@@ -413,13 +413,13 @@ static ALWAYS_INLINE JSValue jsSpliceSubstringsWithSeparators(ExecState* exec, J`
`413`	`413`	`for (int i = 0; i < maxCount; i++) {`
`414`	`414`	`if (i < rangeCount) {`
`415`	`415`	`if (int srcLen = substringRanges[i].length) {`
`416`		`- StringImpl::copyChars(buffer + bufferPos, sourceData + substringRanges[i].position, srcLen);`
	`416`	`+ StringImpl::copyCharacters(buffer + bufferPos, sourceData + substringRanges[i].position, srcLen);`
`417`	`417`	`bufferPos += srcLen;`
`418`	`418`	`}`
`419`	`419`	`}`
`420`	`420`	`if (i < separatorCount) {`
`421`	`421`	`if (int sepLen = separators[i].length()) {`
`422`		`- StringImpl::copyChars(buffer + bufferPos, separators[i].characters8(), sepLen);`
	`422`	`+ StringImpl::copyCharacters(buffer + bufferPos, separators[i].characters8(), sepLen);`
`423`	`423`	`bufferPos += sepLen;`
`424`	`424`	`}`
`425`	`425`	`}`
`@@ -440,18 +440,18 @@ static ALWAYS_INLINE JSValue jsSpliceSubstringsWithSeparators(ExecState* exec, J`
`440`	`440`	`if (i < rangeCount) {`
`441`	`441`	`if (int srcLen = substringRanges[i].length) {`
`442`	`442`	`if (source.is8Bit())`
`443`		`- StringImpl::copyChars(buffer + bufferPos, source.characters8() + substringRanges[i].position, srcLen);`
	`443`	`+ StringImpl::copyCharacters(buffer + bufferPos, source.characters8() + substringRanges[i].position, srcLen);`
`444`	`444`	`else`
`445`		`- StringImpl::copyChars(buffer + bufferPos, source.characters16() + substringRanges[i].position, srcLen);`
	`445`	`+ StringImpl::copyCharacters(buffer + bufferPos, source.characters16() + substringRanges[i].position, srcLen);`
`446`	`446`	`bufferPos += srcLen;`
`447`	`447`	`}`
`448`	`448`	`}`
`449`	`449`	`if (i < separatorCount) {`
`450`	`450`	`if (int sepLen = separators[i].length()) {`
`451`	`451`	`if (separators[i].is8Bit())`
`452`		`- StringImpl::copyChars(buffer + bufferPos, separators[i].characters8(), sepLen);`
	`452`	`+ StringImpl::copyCharacters(buffer + bufferPos, separators[i].characters8(), sepLen);`
`453`	`453`	`else`
`454`		`- StringImpl::copyChars(buffer + bufferPos, separators[i].characters16(), sepLen);`
	`454`	`+ StringImpl::copyCharacters(buffer + bufferPos, separators[i].characters16(), sepLen);`
`455`	`455`	`bufferPos += sepLen;`
`456`	`456`	`}`
`457`	`457`	`}`
`@@ -1799,7 +1799,7 @@ static EncodedJSValue JSC_HOST_CALL stringIncludesImpl(VM& vm, ExecState* exec,`
`1799`	`1799`	`RETURN_IF_EXCEPTION(scope, encodedJSValue());`
`1800`	`1800`	`}`
`1801`	`1801`
`1802`		`- return JSValue::encode(jsBoolean(stringToSearchIn.contains(searchString, true, start)));`
	`1802`	`+ return JSValue::encode(jsBoolean(stringToSearchIn.find(searchString, start) != notFound));`
`1803`	`1803`	`}`
`1804`	`1804`
`1805`	`1805`	`EncodedJSValue JSC_HOST_CALL stringProtoFuncIncludes(ExecState* exec)`
`@@ -1900,7 +1900,7 @@ static JSValue normalize(ExecState* exec, const UChar* source, size_t sourceLeng`
`1900`	`1900`
`1901`	`1901`	`if (U_FAILURE(status) && status != U_BUFFER_OVERFLOW_ERROR) {`
`1902`	`1902`	`// The behavior is not specified when normalize fails.`
`1903`		`- // Now we throw a type erorr since it seems that the contents of the string are invalid.`
	`1903`	`+ // Now we throw a type error since it seems that the contents of the string are invalid.`
`1904`	`1904`	`return throwTypeError(exec, scope);`
`1905`	`1905`	`}`
`1906`	`1906`