Changeset 182325 in webkit

Timestamp:

Apr 3, 2015, 11:27:55 AM (10 years ago)

Author:

Alan Bujtas

Message:

Simple line layout: Use pre-computed simple line runs to produce innerText content.
​https://bugs.webkit.org/show_bug.cgi?id=143351

Reviewed by Antti Koivisto.

This is in preparation to cover <br> with simple line layout.
Runs provide line layout information that can be used to cover hard line break cases.
(similar to TextIterator::handleTextBox())

Covered by existing tests.

• editing/TextIterator.cpp:

(WebCore::TextIterator::handleTextNode):
(WebCore::TextIterator::emitCharacter):
(WebCore::TextIterator::emitText):

• editing/TextIterator.h:
• rendering/SimpleLineLayoutResolver.h:

(WebCore::SimpleLineLayout::RunResolver::Run::isEndOfLine):

Location:

trunk/Source/WebCore

Files:

• ChangeLog (modified) (1 diff)
• editing/TextIterator.cpp (modified) (5 diffs)
• editing/TextIterator.h (modified) (1 diff)
• rendering/SimpleLineLayoutResolver.h (modified) (2 diffs)

trunk/Source/WebCore/ChangeLog

@@ +1 @@
+2015-04-03  Zalan Bujtas  <zalan@apple.com>
+
+        Simple line layout: Use pre-computed simple line runs to produce innerText content.
+        https://bugs.webkit.org/show_bug.cgi?id=143351
+
+        Reviewed by Antti Koivisto.
+
+        This is in preparation to cover <br> with simple line layout.
+        Runs provide line layout information that can be used to cover hard line break cases.
+        (similar to TextIterator::handleTextBox())
+
+        Covered by existing tests.
+
+        * editing/TextIterator.cpp:
+        (WebCore::TextIterator::handleTextNode):
+        (WebCore::TextIterator::emitCharacter):
+        (WebCore::TextIterator::emitText):
+        * editing/TextIterator.h:
+        * rendering/SimpleLineLayoutResolver.h:
+        (WebCore::SimpleLineLayout::RunResolver::Run::isEndOfLine):
+
 2015-04-03  Antti Koivisto  <antti@apple.com>
 

trunk/Source/WebCore/editing/TextIterator.cpp

@@ -45 +45 @@
 #include "RenderTextFragment.h"
 #include "ShadowRoot.h"
+#include "SimpleLineLayout.h"
+#include "SimpleLineLayoutResolver.h"
 #include "TextBoundaries.h"
 #include "TextBreakIterator.h"
@@ -508 +510 @@
 
     auto& renderer = *textNode.renderer();
-        
+    const auto* previousTextNode = m_lastTextNode;
     m_lastTextNode = &textNode;
     String rendererText = renderer.text();
@@ -542 +544 @@
     }
 
-    if (renderer.simpleLineLayout()) {
+    if (const auto* layout = renderer.simpleLineLayout()) {
         if (renderer.style().visibility() != VISIBLE && !(m_behavior & TextIteratorIgnoresStyleVisibility))
             return true;
-        // This code aims to produce same results as handleTextBox() below so test results don't change. It does not make much logical sense.
-        unsigned end = (m_node == m_endContainer) ? static_cast<unsigned>(m_endOffset) : rendererText.length();
-        unsigned runEnd = m_offset;
-        unsigned runStart = m_offset;
-        while (runEnd < end && (renderer.style().isCollapsibleWhiteSpace(rendererText[runEnd]) || rendererText[runEnd] == '\t'))
-            ++runEnd;
-        bool addSpaceForPrevious = m_lastTextNodeEndedWithCollapsedSpace && m_lastCharacter && !renderer.style().isCollapsibleWhiteSpace(m_lastCharacter);
-        if (runEnd > runStart || addSpaceForPrevious) {
-            if (runEnd == rendererText.length()) {
-                m_lastTextNodeEndedWithCollapsedSpace = true;
-                return true;
-            }
-            bool addSpaceForCurrent = runStart || (m_lastCharacter && !renderer.style().isCollapsibleWhiteSpace(m_lastCharacter));
-            if (addSpaceForCurrent || addSpaceForPrevious) {
-                emitCharacter(' ', textNode, nullptr, runStart, runEnd);
-                m_offset = runEnd;
+        // Use the simple layout runs to iterate over the text content.
+        ASSERT(renderer.parent() && is<RenderBlockFlow>(renderer.parent()));
+        const auto& blockFlow = downcast<RenderBlockFlow>(*renderer.parent());
+        SimpleLineLayout::RunResolver runResolver(blockFlow, *layout);
+        auto range = runResolver.rangeForRenderer(renderer);
+        unsigned endPosition = (m_node == m_endContainer) ? static_cast<unsigned>(m_endOffset) : rendererText.length();
+        // Simple line layout run positions are all absolute to the parent flow.
+        // Offsetting is required when multiple renderers are present.
+        if (previousTextNode && previousTextNode != &textNode) {
+            const RenderObject& previousRenderer = *previousTextNode->renderer();
+            if (previousRenderer.parent() != &blockFlow)
+                m_previousTextLengthInFlow = 0;
+            else
+                m_previousTextLengthInFlow += previousTextNode->renderer()->text()->length();
+        }
+        // Skip to m_offset position.
+        auto it = range.begin();
+        auto end = range.end();
+        while (it != end && (*it).end() <= (static_cast<unsigned>(m_offset) + m_previousTextLengthInFlow))
+            ++it;
+        if (it == end) {
+            // Collapsed trailing whitespace.
+            m_offset = endPosition;
+            m_lastTextNodeEndedWithCollapsedSpace = true;
+            return true;
+        }
+        if (m_nextRunNeedsWhitespace) {
+            emitCharacter(' ', textNode, nullptr, m_offset, m_offset + 1);
+            return false;
+        }
+        const auto run = *it;
+        ASSERT(run.end() - run.start() <= rendererText.length());
+        // contentStart skips leading whitespace.
+        unsigned contentStart = std::max<unsigned>(m_offset, run.start() - m_previousTextLengthInFlow);
+        unsigned contentEnd = std::min(endPosition, run.end() - m_previousTextLengthInFlow);
+        // Check if whitespace adjustment is needed when crossing renderer boundary.
+        if (previousTextNode && previousTextNode != &textNode) {
+            bool lastCharacterIsNotWhitespace = m_lastCharacter && !renderer.style().isCollapsibleWhiteSpace(m_lastCharacter);
+            bool addTrailingWhitespaceForPrevious = m_lastTextNodeEndedWithCollapsedSpace && lastCharacterIsNotWhitespace;
+            bool leadingWhitespaceIsNeededForCurrent = contentStart > static_cast<unsigned>(m_offset) && lastCharacterIsNotWhitespace;
+            if (addTrailingWhitespaceForPrevious || leadingWhitespaceIsNeededForCurrent) {
+                emitCharacter(' ', textNode, nullptr, m_offset, m_offset + 1);
                 return false;
             }
-            runStart = runEnd;
-        }
-        while (runEnd < end && !renderer.style().isCollapsibleWhiteSpace(rendererText[runEnd]))
-            ++runEnd;
-        if (runStart < end)
-            emitText(textNode, renderer, runStart, runEnd);
-        m_offset = runEnd;
-        return runEnd == end;
+        }
+        // \n \t single whitespace characters need replacing so that the new line/tab character won't show up.
+        unsigned stopPosition = contentStart;
+        while (stopPosition < contentEnd) {
+            if (rendererText[stopPosition] == '\n' || rendererText[stopPosition] == '\t') {
+                emitText(textNode, renderer, contentStart, stopPosition);
+                m_offset = stopPosition + 1;
+                m_nextRunNeedsWhitespace = true;
+                return false;
+            }
+            ++stopPosition;
+        }
+        emitText(textNode, renderer, contentStart, contentEnd);
+        // When line ending with collapsed whitespace is present, we need to carry over one whitespace: foo\nbar -> foo bar (otherwise we would end up with foobar).
+        m_nextRunNeedsWhitespace = run.isEndOfLine() && contentEnd < endPosition && renderer.style().isCollapsibleWhiteSpace(rendererText[contentEnd]);
+        m_offset = contentEnd;
+        return static_cast<unsigned>(m_offset) == endPosition;
     }
 
@@ -1066 +1103 @@
     m_lastCharacter = character;
     m_lastTextNodeEndedWithCollapsedSpace = false;
+    m_nextRunNeedsWhitespace = false;
 }
 
@@ -1090 +1128 @@
 
     m_lastTextNodeEndedWithCollapsedSpace = false;
+    m_nextRunNeedsWhitespace = false;
     m_hasEmitted = true;
 }

trunk/Source/WebCore/editing/TextIterator.h

@@ -164 +164 @@
     UChar m_lastCharacter;
 
+    // Used to do simple line layout run logic.
+    bool m_nextRunNeedsWhitespace { false };
+    unsigned m_previousTextLengthInFlow { 0 };
     // Used when text boxes are out of order (Hebrew/Arabic with embedded LTR text)
     Vector<InlineTextBox*> m_sortedTextBoxes;

trunk/Source/WebCore/rendering/SimpleLineLayoutResolver.h

@@ -64 +64 @@
         FloatPoint baseline() const;
         StringView text() const;
+        bool isEndOfLine() const;
 
         unsigned lineIndex() const;
@@ -159 +160 @@
 }
 
+inline bool RunResolver::Run::isEndOfLine() const
+{
+    return m_iterator.simpleRun().isEndOfLine;
+}
+
 inline unsigned RunResolver::Run::lineIndex() const
 {