Changeset 181268 in webkit

Timestamp:

Mar 9, 2015 10:09:52 AM (9 years ago)

Author:

Alan Bujtas

Message:

Simple line layout: Merge TextFragmentIterator::findNextBreakablePosition() and TextFragmentIterator::findNextNonWhitespacePosition().
​https://bugs.webkit.org/show_bug.cgi?id=142344

Reviewed by Antti Koivisto.

This patch merges findNextBreakablePosition() and findNextNonWhitespacePosition() so that
the segment looping and position handling logic are no longer duplicated. It also unifies
the static next*() functions' signature.

No change in functionality.

• rendering/SimpleLineLayoutTextFragmentIterator.cpp:

(WebCore::SimpleLineLayout::TextFragmentIterator::nextTextFragment):
(WebCore::SimpleLineLayout::nextBreakablePosition):
(WebCore::SimpleLineLayout::nextNonWhitespacePosition):
(WebCore::SimpleLineLayout::TextFragmentIterator::skipToNextPosition):
(WebCore::SimpleLineLayout::TextFragmentIterator::findNextBreakablePosition): Deleted.
(WebCore::SimpleLineLayout::findNextNonWhitespace): Deleted.
(WebCore::SimpleLineLayout::TextFragmentIterator::findNextNonWhitespacePosition): Deleted.

• rendering/SimpleLineLayoutTextFragmentIterator.h:

Location:

trunk/Source/WebCore

Files:

• ChangeLog (modified) (1 diff)
• rendering/SimpleLineLayoutTextFragmentIterator.cpp (modified) (3 diffs)
• rendering/SimpleLineLayoutTextFragmentIterator.h (modified) (1 diff)

trunk/Source/WebCore/ChangeLog

@@ +1 @@
+2015-03-09  Zalan Bujtas  <zalan@apple.com>
+
+        Simple line layout: Merge TextFragmentIterator::findNextBreakablePosition() and TextFragmentIterator::findNextNonWhitespacePosition().
+        https://bugs.webkit.org/show_bug.cgi?id=142344
+
+        Reviewed by Antti Koivisto.
+
+        This patch merges findNextBreakablePosition() and findNextNonWhitespacePosition() so that
+        the segment looping and position handling logic are no longer duplicated. It also unifies
+        the static next*() functions' signature.
+
+        No change in functionality.
+
+        * rendering/SimpleLineLayoutTextFragmentIterator.cpp:
+        (WebCore::SimpleLineLayout::TextFragmentIterator::nextTextFragment):
+        (WebCore::SimpleLineLayout::nextBreakablePosition):
+        (WebCore::SimpleLineLayout::nextNonWhitespacePosition):
+        (WebCore::SimpleLineLayout::TextFragmentIterator::skipToNextPosition):
+        (WebCore::SimpleLineLayout::TextFragmentIterator::findNextBreakablePosition): Deleted.
+        (WebCore::SimpleLineLayout::findNextNonWhitespace): Deleted.
+        (WebCore::SimpleLineLayout::TextFragmentIterator::findNextNonWhitespacePosition): Deleted.
+        * rendering/SimpleLineLayoutTextFragmentIterator.h:
+
 2015-03-09  Xabier Rodriguez Calvar <calvaris@igalia.com> and Youenn Fablet  <youenn.fablet@crf.canon.fr>
 

trunk/Source/WebCore/rendering/SimpleLineLayoutTextFragmentIterator.cpp

@@ -69 +69 @@
         return fragment;
     }
-    unsigned spaceCount = 0;
     unsigned startPosition = m_position;
-    unsigned endPosition = findNextNonWhitespacePosition(startPosition, spaceCount);
+    unsigned endPosition = skipToNextPosition(PositionType::NonWhitespace, startPosition);
     ASSERT(startPosition <= endPosition);
     if (endPosition > startPosition) {
@@ -77 +76 @@
         bool isCollapsed = multipleWhitespace && m_style.collapseWhitespace;
         bool isBreakable = !isCollapsed && multipleWhitespace;
-        float width = 0;
-        if (isCollapsed)
-            width = m_style.spaceWidth;
-        else {
-            unsigned length = endPosition - startPosition;
-            width = length == spaceCount ? length * m_style.spaceWidth : textWidth(startPosition, endPosition, xPosition);
-        }
+        float width = isCollapsed ? m_style.spaceWidth : textWidth(startPosition, endPosition, xPosition);
         m_position = endPosition;
         return TextFragment(startPosition, endPosition, width, TextFragment::Whitespace, isCollapsed, isBreakable);
     }
-    endPosition = findNextBreakablePosition(startPosition + 1);
+    endPosition = skipToNextPosition(PositionType::Breakable, startPosition + 1);
     m_position = endPosition;
     return TextFragment(startPosition, endPosition, textWidth(startPosition, endPosition, xPosition), TextFragment::NonWhitespace, false, m_style.breakWordOnOverflow);
@@ -115 +108 @@
 
 template <typename CharacterType>
-static unsigned nextBreakablePosition(LazyLineBreakIterator& lineBreakIterator, const FlowContents::Segment& segment, unsigned position)
+static unsigned nextBreakablePosition(LazyLineBreakIterator& lineBreakIterator, const FlowContents::Segment& segment, unsigned startPosition)
 {
-    const auto* characters = segment.text.characters<CharacterType>();
-    unsigned segmentLength = segment.end - segment.start;
-    unsigned segmentPosition = position - segment.start;
-    return nextBreakablePositionNonLoosely<CharacterType, NBSPBehavior::IgnoreNBSP>(lineBreakIterator, characters, segmentLength, segmentPosition);
+    return nextBreakablePositionNonLoosely<CharacterType, NBSPBehavior::IgnoreNBSP>(lineBreakIterator, segment.text.characters<CharacterType>(), segment.end - segment.start, startPosition);
 }
 
-unsigned TextFragmentIterator::findNextBreakablePosition(unsigned position) const
+template <typename CharacterType>
+static unsigned nextNonWhitespacePosition(const FlowContents::Segment& segment, unsigned startPosition, const TextFragmentIterator::Style& style)
 {
-    while (!isEnd(position)) {
-        auto& segment = m_flowContents.segmentForPosition(position);
-        if (segment.text.impl() != m_lineBreakIterator.string().impl()) {
-            UChar lastCharacter = segment.start > 0 ? characterAt(segment.start - 1) : 0;
-            UChar secondToLastCharacter = segment.start > 1 ? characterAt(segment.start - 2) : 0;
-            m_lineBreakIterator.setPriorContext(lastCharacter, secondToLastCharacter);
-            m_lineBreakIterator.resetStringAndReleaseIterator(segment.text, m_style.locale, LineBreakIteratorModeUAX14);
-        }
-
-        unsigned breakable = segment.text.is8Bit() ? nextBreakablePosition<LChar>(m_lineBreakIterator, segment, position) : nextBreakablePosition<UChar>(m_lineBreakIterator, segment, position);
-        position = segment.start + breakable;
-        if (position < segment.end)
-            break;
+    const auto* text = segment.text.characters<CharacterType>();
+    unsigned position = startPosition;
+    for (; position < segment.end; ++position) {
+        auto character = text[position];
+        bool isWhitespace = character == ' ' || character == '\t' || (!style.preserveNewline && character == '\n');
+        if (!isWhitespace)
+            return position;
     }
     return position;
 }
 
-template <typename CharacterType>
-static bool findNextNonWhitespace(const FlowContents::Segment& segment, const TextFragmentIterator::Style& style, unsigned& position, unsigned& spaceCount)
+unsigned TextFragmentIterator::skipToNextPosition(PositionType positionType, unsigned startPosition) const
 {
-    const auto* text = segment.text.characters<CharacterType>();
-    for (; position < segment.end; ++position) {
-        auto character = text[position - segment.start];
-        bool isSpace = character == ' ';
-        bool isWhitespace = isSpace || character == '\t' || (!style.preserveNewline && character == '\n');
-        if (!isWhitespace)
-            return true;
-        if (isSpace)
-            ++spaceCount;
-    }
-    return false;
-}
+    if (isEnd(startPosition))
+        return startPosition;
 
-unsigned TextFragmentIterator::findNextNonWhitespacePosition(unsigned position, unsigned& spaceCount) const
-{
-    FlowContents::Iterator it(m_flowContents, m_flowContents.segmentIndexForPosition(position));
+    unsigned currentPosition = startPosition;
+    FlowContents::Iterator it(m_flowContents, m_flowContents.segmentIndexForPosition(currentPosition));
     for (auto end = m_flowContents.end(); it != end; ++it) {
-        bool foundNonWhitespace = (*it).text.is8Bit() ? findNextNonWhitespace<LChar>(*it, m_style, position, spaceCount) : findNextNonWhitespace<UChar>(*it, m_style, position, spaceCount);
-        if (foundNonWhitespace)
+        auto& segment = *it;
+        unsigned currentPositonRelativeToSegment = currentPosition - segment.start;
+        unsigned nextPositionRelativeToSegment = 0;
+        if (positionType == NonWhitespace) {
+            nextPositionRelativeToSegment = segment.text.is8Bit() ? nextNonWhitespacePosition<LChar>(segment, currentPositonRelativeToSegment, m_style) :
+                nextNonWhitespacePosition<UChar>(segment, currentPositonRelativeToSegment, m_style);
+        } else if (positionType == Breakable) {
+            if (segment.text.impl() != m_lineBreakIterator.string().impl()) {
+                UChar lastCharacter = segment.start > 0 ? characterAt(segment.start - 1) : 0;
+                UChar secondToLastCharacter = segment.start > 1 ? characterAt(segment.start - 2) : 0;
+                m_lineBreakIterator.setPriorContext(lastCharacter, secondToLastCharacter);
+                m_lineBreakIterator.resetStringAndReleaseIterator(segment.text, m_style.locale, LineBreakIteratorModeUAX14);
+            }
+            nextPositionRelativeToSegment = segment.text.is8Bit() ? nextBreakablePosition<LChar>(m_lineBreakIterator, segment, currentPositonRelativeToSegment) :
+                nextBreakablePosition<UChar>(m_lineBreakIterator, segment, currentPositonRelativeToSegment);
+        } else
+            ASSERT_NOT_REACHED();
+        currentPosition = segment.start + nextPositionRelativeToSegment;
+        if (currentPosition < segment.end)
             break;
     }
-    return position;
+    return currentPosition;
 }
 

trunk/Source/WebCore/rendering/SimpleLineLayoutTextFragmentIterator.h

@@ -93 +93 @@
 
 private:
-    unsigned findNextNonWhitespacePosition(unsigned position, unsigned& spaceCount) const;
-    unsigned findNextBreakablePosition(unsigned position) const;
+    enum PositionType { Breakable, NonWhitespace };
+    unsigned skipToNextPosition(PositionType, unsigned startPosition) const;
     UChar characterAt(unsigned position) const;
     bool isLineBreak(unsigned position) const;