Optimize whitespace skipping in the CSSParser.

Optimize whitespace skipping in the CSSParser.

The code was using nextInputChar() which would make a function call,
check the length, call StringImpl operator[] which would check is8Bit()
then branch looking for a NUL to do replacement, then always call the
UChar version of isHTMLSpace, then call consume() which would again call
nextInputChar() doing a check on length, String operator[], another
branch only to discard the return value entirely, and finally call
advance() to move the offset forward.

We can do much better than this by introducing
CSSTokenizerInputStream::advanceUntilNonWhitespace which doesn't do
replacement (since it doesn't matter for whitespace), doesn't do
repeated length checks, and specializes on the character type so we
can use isHTMLSpace<LChar> when possible.

This yields a 15% performance improvement when parsing long runs of
whitespace like you might find in a stylesheet when tested using
inline style with this simple benchmark:

// 32 spaces before the value.
for (var i = 0; i < 99999; ++i)
    span.style.color = "                                red";

This will benefit any site that has a bunch of whitespace in the
stylesheets. Many web components applications (ex. Polymer Shop)
have lots of it.

BUG=605792
Committed: https://crrev.com/d04741aea9777fd9b26c98508c262f9c404584de
Cr-Commit-Position: refs/heads/master@{#402116}

[esprehn, 2016-06-25 03:58:20]

Description was changed from

==========
Optimize whitespace skipping in the CSSParser.

The code was using nextInputChar() which would make a function call,
check the length, call StringImpl operator[] which would check is8Bit()
then branch looking for a NUL to do replacement, then always call the
UChar version of isHTMLSpace, then call consume() which would again call
nextInputChar() doing a check on length, String operator[], another
branch only to discard the return value entirely, and finally call
advance() to move the offset forward.

We can do much better than this by introducing
CSSTokenizerInputStream::advanceUntilNonWhitespace which doesn't do
replacement (since it doesn't matter for whitespace), doesn't do
repeated length checks, and specializes on the character type so we
can use isHTMLSpace<LChar> when possible.

This yields a 15% performance improvement when parsing long runs of
whitespace like you might find in a stylesheet when tested using
inline style:

// 32 spaces before the value.
span.style.color = "                                red";

BUG=605792
==========

to

==========
Optimize whitespace skipping in the CSSParser.

The code was using nextInputChar() which would make a function call,
check the length, call StringImpl operator[] which would check is8Bit()
then branch looking for a NUL to do replacement, then always call the
UChar version of isHTMLSpace, then call consume() which would again call
nextInputChar() doing a check on length, String operator[], another
branch only to discard the return value entirely, and finally call
advance() to move the offset forward.

We can do much better than this by introducing
CSSTokenizerInputStream::advanceUntilNonWhitespace which doesn't do
replacement (since it doesn't matter for whitespace), doesn't do
repeated length checks, and specializes on the character type so we
can use isHTMLSpace<LChar> when possible.

This yields a 15% performance improvement when parsing long runs of
whitespace like you might find in a stylesheet when tested using
inline style with this simple benchmark:

// 32 spaces before the value.
for (var i = 0; i < 99999; ++i)
    span.style.color = "                                red";

This will benefit any site that has a bunch of whitespace in the
stylesheets. Many web components applications (ex. Polymer Shop)
have lots of it.

BUG=605792
==========

[esprehn, 2016-06-25 03:58:25]

The CQ bit was checked by esprehn@chromium.org to run a CQ dry run

[commit-bot: I haz the power, 2016-06-25 03:58:31]

Dry run: CQ is trying da patch. Follow status at
 
https://chromium-cq-status.appspot.com/v2/patch-status/codereview.chromium.or...

[esprehn, 2016-06-25 04:15:26]

esprehn@chromium.org changed reviewers:
+ meade@chromium.org, timloh@chromium.org

[commit-bot: I haz the power, 2016-06-25 06:02:22]

The CQ bit was unchecked by commit-bot@chromium.org

[commit-bot: I haz the power, 2016-06-25 06:02:23]

Dry run: This issue passed the CQ dry run.

[Timothy Loh, 2016-06-27 00:15:18]

lgtm

[esprehn, 2016-06-27 00:56:45]

The CQ bit was checked by esprehn@chromium.org

[commit-bot: I haz the power, 2016-06-27 00:56:55]

CQ is trying da patch. Follow status at
 
https://chromium-cq-status.appspot.com/v2/patch-status/codereview.chromium.or...

[commit-bot: I haz the power, 2016-06-27 02:52:11]

The CQ bit was unchecked by commit-bot@chromium.org

[commit-bot: I haz the power, 2016-06-27 02:52:15]

Failed to apply patch for
third_party/WebKit/Source/core/css/parser/CSSTokenizerInputStream.h:
While running git apply --index -3 -p1;
  error: patch failed:
third_party/WebKit/Source/core/css/parser/CSSTokenizerInputStream.h:44
  Falling back to three-way merge...
  Applied patch to
'third_party/WebKit/Source/core/css/parser/CSSTokenizerInputStream.h' with
conflicts.
  U third_party/WebKit/Source/core/css/parser/CSSTokenizerInputStream.h

Patch:       third_party/WebKit/Source/core/css/parser/CSSTokenizerInputStream.h
Index: third_party/WebKit/Source/core/css/parser/CSSTokenizerInputStream.h
diff --git a/third_party/WebKit/Source/core/css/parser/CSSTokenizerInputStream.h
b/third_party/WebKit/Source/core/css/parser/CSSTokenizerInputStream.h
index
be79cc381a17d249434763cc40b42e0eaa80b9c0..1160a4b8ae91aaf42fe4e4eb90cb222606c9282a
100644
--- a/third_party/WebKit/Source/core/css/parser/CSSTokenizerInputStream.h
+++ b/third_party/WebKit/Source/core/css/parser/CSSTokenizerInputStream.h
@@ -44,6 +44,8 @@ public:
         return offset;
     }
 
+    void advanceUntilNonWhitespace();
+
     unsigned offset() const { return std::min(m_offset, m_stringLength); }
     StringView rangeAt(unsigned start, unsigned length) const;

[esprehn, 2016-06-27 03:51:45]

The CQ bit was checked by esprehn@chromium.org

[esprehn, 2016-06-27 03:51:45]

The patchset sent to the CQ was uploaded after l-g-t-m from timloh@chromium.org
Link to the patchset: https://codereview.chromium.org/2099683003/#ps20001
(title: "rebase.")

[commit-bot: I haz the power, 2016-06-27 03:51:55]

CQ is trying da patch. Follow status at
 
https://chromium-cq-status.appspot.com/v2/patch-status/codereview.chromium.or...

[commit-bot: I haz the power, 2016-06-27 05:04:50]

Committed patchset #2 (id:20001)

[commit-bot: I haz the power, 2016-06-27 05:07:28]

Description was changed from

==========
Optimize whitespace skipping in the CSSParser.

The code was using nextInputChar() which would make a function call,
check the length, call StringImpl operator[] which would check is8Bit()
then branch looking for a NUL to do replacement, then always call the
UChar version of isHTMLSpace, then call consume() which would again call
nextInputChar() doing a check on length, String operator[], another
branch only to discard the return value entirely, and finally call
advance() to move the offset forward.

We can do much better than this by introducing
CSSTokenizerInputStream::advanceUntilNonWhitespace which doesn't do
replacement (since it doesn't matter for whitespace), doesn't do
repeated length checks, and specializes on the character type so we
can use isHTMLSpace<LChar> when possible.

This yields a 15% performance improvement when parsing long runs of
whitespace like you might find in a stylesheet when tested using
inline style with this simple benchmark:

// 32 spaces before the value.
for (var i = 0; i < 99999; ++i)
    span.style.color = "                                red";

This will benefit any site that has a bunch of whitespace in the
stylesheets. Many web components applications (ex. Polymer Shop)
have lots of it.

BUG=605792
==========

to

==========
Optimize whitespace skipping in the CSSParser.

The code was using nextInputChar() which would make a function call,
check the length, call StringImpl operator[] which would check is8Bit()
then branch looking for a NUL to do replacement, then always call the
UChar version of isHTMLSpace, then call consume() which would again call
nextInputChar() doing a check on length, String operator[], another
branch only to discard the return value entirely, and finally call
advance() to move the offset forward.

We can do much better than this by introducing
CSSTokenizerInputStream::advanceUntilNonWhitespace which doesn't do
replacement (since it doesn't matter for whitespace), doesn't do
repeated length checks, and specializes on the character type so we
can use isHTMLSpace<LChar> when possible.

This yields a 15% performance improvement when parsing long runs of
whitespace like you might find in a stylesheet when tested using
inline style with this simple benchmark:

// 32 spaces before the value.
for (var i = 0; i < 99999; ++i)
    span.style.color = "                                red";

This will benefit any site that has a bunch of whitespace in the
stylesheets. Many web components applications (ex. Polymer Shop)
have lots of it.

BUG=605792

Committed: https://crrev.com/d04741aea9777fd9b26c98508c262f9c404584de
Cr-Commit-Position: refs/heads/master@{#402116}
==========

[commit-bot: I haz the power, 2016-06-27 05:07:29]

Patchset 2 (id:??) landed as
https://crrev.com/d04741aea9777fd9b26c98508c262f9c404584de
Cr-Commit-Position: refs/heads/master@{#402116}