Remove unnecessary state for tracking whitespace collapsing in pre's

third_party/WebKit/Source/core/layout/line/BreakingContextInlineHeaders.h

 /*
  * Copyright (C) 2000 Lars Knoll (knoll@kde.org)
  * Copyright (C) 2003, 2004, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All right reserved.
  * Copyright (C) 2010 Google Inc. All rights reserved.
  * Copyright (C) 2013 Adobe Systems Incorporated.
  *
  * 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
  * version 2 of the License, or (at your option) any later version.
@@ skipping 54 matching lines @@
         , m_lineInfo(inLineInfo)
         , m_layoutTextInfo(inLayoutTextInfo)
         , m_lastFloatFromPreviousLine(inLastFloatFromPreviousLine)
         , m_width(lineWidth)
         , m_currWS(NORMAL)
         , m_lastWS(NORMAL)
         , m_preservesNewline(false)
         , m_atStart(true)
         , m_ignoringSpaces(false)
         , m_currentCharacterIsSpace(false)
-        , m_currentCharacterShouldCollapseIfPreWap(false)
         , m_appliedStartWidth(appliedStartWidth)
         , m_includeEndWidth(true)
         , m_autoWrap(false)
         , m_autoWrapWasEverTrueOnLine(false)
         , m_floatsFitOnLine(true)
         , m_collapseWhiteSpace(false)
         , m_startingNewParagraph(m_lineInfo.previousLineBrokeCleanly())
         , m_allowImagesToBreak(!block.document().inQuirksMode() || !block.isTableCell() || !m_blockStyle->logicalWidth().isIntrinsicOrAuto())
         , m_atEnd(false)
         , m_lineMidpointState(resolver.midpointState())
     {
         m_lineInfo.setPreviousLineBrokeCleanly(false);
     }
 
     LayoutObject* currentObject() { return m_current.object(); }
     InlineIterator lineBreak() { return m_lineBreak; }
     bool atEnd() { return m_atEnd; }
 
     void initializeForCurrentObject();
 
     void increment();
 
     void handleBR(EClear&);
     void handleOutOfFlowPositioned(Vector<LineLayoutBox>& positionedObjects);
     void handleFloat();
     void handleEmptyInline();
     void handleReplaced();
     bool handleText(WordMeasurements&, bool& hyphenated);
-    void prepareForNextCharacter(const LineLayoutText&, bool& prohibitBreakInside, bool previousCharacterIsSpace, bool previousCharacterShouldCollapseIfPreWap);
+    void prepareForNextCharacter(const LineLayoutText&, bool& prohibitBreakInside, bool previousCharacterIsSpace);
     bool canBreakAtWhitespace(bool breakWords, WordMeasurement&, bool stoppedIgnoringSpaces, bool& hyphenated, float charWidth, float& hyphenWidth, bool betweenWords, bool midWordBreak, bool breakAll, bool previousCharacterIsSpace, float lastWidthMeasurement, const LineLayoutText&, const Font&, bool applyWordSpacing, float wordSpacing);
     bool trailingSpaceExceedsAvailableWidth(bool midWordBreak, const LineLayoutText&, WordMeasurement&, bool applyWordSpacing, bool wordSpacing, const Font&);
     WordMeasurement& calculateWordWidth(WordMeasurements&, LineLayoutText&, unsigned lastSpace, float& lastWidthMeasurement, float wordSpacingForWordMeasurement, const Font&, float wordTrailingSpaceWidth, UChar);
     void stopIgnoringSpaces(unsigned& lastSpace);
     void commitAndUpdateLineBreakIfNeeded();
     InlineIterator handleEndOfLine();
 
     void clearLineBreakIfFitsOnLine()
     {
         if (m_width.fitsOnLine() || m_lastWS == NOWRAP)
@@ skipping 24 matching lines @@
 
     LineWidth m_width;
 
     EWhiteSpace m_currWS;
     EWhiteSpace m_lastWS;
 
     bool m_preservesNewline;
     bool m_atStart;
     bool m_ignoringSpaces;
     bool m_currentCharacterIsSpace;
-    bool m_currentCharacterShouldCollapseIfPreWap;
     bool m_appliedStartWidth;
     bool m_includeEndWidth;
     bool m_autoWrap;
     bool m_autoWrapWasEverTrueOnLine;
     bool m_floatsFitOnLine;
     bool m_collapseWhiteSpace;
     bool m_startingNewParagraph;
     bool m_allowImagesToBreak;
     bool m_atEnd;
 
@@ skipping 106 matching lines @@
     m_currWS = m_current.object().isLayoutInline() ? m_currentStyle->whiteSpace() : m_current.object().parent().style()->whiteSpace();
     m_lastWS = m_lastObject.isLayoutInline() ? m_lastObject.style()->whiteSpace() : m_lastObject.parent().style()->whiteSpace();
 
     bool isSVGText = m_current.object().isSVGInlineText();
     m_autoWrap = !isSVGText && ComputedStyle::autoWrap(m_currWS);
     m_autoWrapWasEverTrueOnLine = m_autoWrapWasEverTrueOnLine || m_autoWrap;
 
     m_preservesNewline = !isSVGText && ComputedStyle::preserveNewline(m_currWS);
 
     m_collapseWhiteSpace = ComputedStyle::collapseWhiteSpace(m_currWS);
+
+    // Ensure the whitespace in constructions like '<span style="white-space: pre-wrap">text <span><span> text</span>'
+    // does not collapse.
+    if (m_collapseWhiteSpace && !ComputedStyle::collapseWhiteSpace(m_lastWS))
+        m_currentCharacterIsSpace = false;
 }
 
 inline void BreakingContext::increment()
 {
-    // Clear out our character space bool, since inline <pre>s don't collapse whitespace
-    // with adjacent inline normal/nowrap spans.
-    if (!m_collapseWhiteSpace)
-        m_currentCharacterIsSpace = false;
-
     m_current.moveToStartOf(m_nextObject);
 
     // When the line box tree is created, this position in the line will be snapped to
     // LayoutUnit's, and those measurements will be used by the paint code.  Do the
     // equivalent snapping here, to get consistent line measurements.
     m_width.snapUncommittedWidth();
 
     m_atStart = false;
 }
 
@@ skipping 152 matching lines @@
             m_lineInfo.setEmpty(false, m_block, &m_width);
         if (m_ignoringSpaces) {
             // If we are in a run of ignored spaces then ensure we get a linebox if lineboxes are eventually
             // created for the line...
             m_trailingObjects.clear();
             ensureLineBoxInsideIgnoredSpaces(&m_lineMidpointState, m_current.object());
         } else if (m_blockStyle->collapseWhiteSpace() && m_resolver.position().object() == m_current.object()
             && shouldSkipWhitespaceAfterStartObject(m_block, m_current.object(), m_lineMidpointState)) {
             // If this object is at the start of the line, we need to behave like list markers and
             // start ignoring spaces.
-            m_currentCharacterShouldCollapseIfPreWap = m_currentCharacterIsSpace = true;
+            m_currentCharacterIsSpace = true;
             m_ignoringSpaces = true;
         } else {
             // If we are after a trailing space but aren't ignoring spaces yet then ensure we get a linebox
             // if we encounter collapsible whitepace.
             m_trailingObjects.appendObjectIfNeeded(m_current.object());
         }
     }
 
     m_width.addUncommittedWidth((inlineLogicalWidthFromAncestorsIfNeeded(m_current.object()) + borderPaddingMarginStart(flowBox) + borderPaddingMarginEnd(flowBox)).toFloat());
 }
@@ skipping 11 matching lines @@
         && (!m_current.object().isRubyRun() || toLayoutRubyRun(m_current.object())->canBreakBefore(m_layoutTextInfo.m_lineBreakIterator))) {
         m_width.commit();
         m_lineBreak.moveToStartOf(m_current.object());
     }
 
     if (m_ignoringSpaces)
         m_lineMidpointState.stopIgnoringSpaces(InlineIterator(0, m_current.object(), 0));
 
     m_lineInfo.setEmpty(false, m_block, &m_width);
     m_ignoringSpaces = false;
-    m_currentCharacterShouldCollapseIfPreWap = m_currentCharacterIsSpace = false;
+    m_currentCharacterIsSpace = false;
     m_trailingObjects.clear();
 
     // Optimize for a common case. If we can't find whitespace after the list
     // item, then this is all moot.
     LayoutUnit replacedLogicalWidth = m_block.logicalWidthForChild(replacedBox) + m_block.marginStartForChild(replacedBox) + m_block.marginEndForChild(replacedBox) + inlineLogicalWidthFromAncestorsIfNeeded(m_current.object());
     if (m_current.object().isListMarker()) {
         if (m_blockStyle->collapseWhiteSpace() && shouldSkipWhitespaceAfterStartObject(m_block, m_current.object(), m_lineMidpointState)) {
             // Like with inline flows, we start ignoring spaces to make sure that any
             // additional spaces we see will be discarded.
-            m_currentCharacterShouldCollapseIfPreWap = m_currentCharacterIsSpace = true;
+            m_currentCharacterIsSpace = true;
             m_ignoringSpaces = true;
         }
         if (LineLayoutListMarker(m_current.object()).isInside())
             m_width.addUncommittedWidth(replacedLogicalWidth.toFloat());
     } else {
         m_width.addUncommittedWidth(replacedLogicalWidth.toFloat());
     }
     if (m_current.object().isRubyRun())
         m_width.applyOverhang(LineLayoutRubyRun(m_current.object()), m_lastObject, m_nextObject);
     // Update prior line break context characters, using U+FFFD (OBJECT REPLACEMENT CHARACTER) for replaced element.
@@ skipping 96 matching lines @@
     // Non-zero only when kerning is enabled, in which case we measure
     // words with their trailing space, then subtract its width.
     float wordTrailingSpaceWidth = (font.fontDescription().typesettingFeatures() & Kerning) ?
         font.width(constructTextRun(font, &spaceCharacter, 1, style, style.direction())) + wordSpacing
         : 0;
 
     UChar lastCharacter = m_layoutTextInfo.m_lineBreakIterator.lastCharacter();
     UChar secondToLastCharacter = m_layoutTextInfo.m_lineBreakIterator.secondToLastCharacter();
     for (; m_current.offset() < layoutText.textLength(); m_current.fastIncrementInTextNode()) {
         bool previousCharacterIsSpace = m_currentCharacterIsSpace;
-        bool previousCharacterShouldCollapseIfPreWap = m_currentCharacterShouldCollapseIfPreWap;
         UChar c = m_current.current();
-        m_currentCharacterShouldCollapseIfPreWap = m_currentCharacterIsSpace = c == spaceCharacter || c == tabulationCharacter || (!m_preservesNewline && (c == newlineCharacter));
+        m_currentCharacterIsSpace = c == spaceCharacter || c == tabulationCharacter || (!m_preservesNewline && (c == newlineCharacter));
 
         if (!m_collapseWhiteSpace || !m_currentCharacterIsSpace)
             m_lineInfo.setEmpty(false, m_block, &m_width);
 
         if (c == softHyphenCharacter && m_autoWrap && !hyphenWidth) {
             hyphenWidth = layoutText.hyphenWidth(font, textDirectionFromUnicode(m_resolver.position().direction()));
             m_width.addUncommittedWidth(hyphenWidth);
         }
 
         bool applyWordSpacing = false;
@@ skipping 14 matching lines @@
         // If we're in the middle of a word or at the start of a new one and can't break there, then continue to the next character.
         if (!betweenWords && !midWordBreak) {
             if (m_ignoringSpaces) {
                 // Stop ignoring spaces and begin at this
                 // new point.
                 lastSpaceWordSpacing = applyWordSpacing ? wordSpacing : 0;
                 wordSpacingForWordMeasurement = (applyWordSpacing && wordMeasurements.last().width) ? wordSpacing : 0;
                 stopIgnoringSpaces(lastSpace);
             }
 
-            prepareForNextCharacter(layoutText, prohibitBreakInside, previousCharacterIsSpace, previousCharacterShouldCollapseIfPreWap);
+            prepareForNextCharacter(layoutText, prohibitBreakInside, previousCharacterIsSpace);
             m_atStart = false;
             nextCharacter(c, lastCharacter, secondToLastCharacter);
             continue;
         }
 
         // If we're collapsing space and we're at a collapsible space such as a space or tab, continue to the next character.
         if (m_ignoringSpaces && m_currentCharacterIsSpace) {
             lastSpaceWordSpacing = 0;
             // Just keep ignoring these spaces.
             nextCharacter(c, lastCharacter, secondToLastCharacter);
@@ skipping 79 matching lines @@
             if (m_currentCharacterIsSpace && previousCharacterIsSpace) {
                 m_ignoringSpaces = true;
 
                 // We just entered a mode where we are ignoring spaces. Create a midpoint to terminate the run
                 // before the second space.
                 m_lineMidpointState.startIgnoringSpaces(m_startOfIgnoredSpaces);
                 m_trailingObjects.updateMidpointsForTrailingObjects(m_lineMidpointState, InlineIterator(), TrailingObjects::DoNotCollapseFirstSpace);
             }
         }
 
-        prepareForNextCharacter(layoutText, prohibitBreakInside, previousCharacterIsSpace, previousCharacterShouldCollapseIfPreWap);
+        prepareForNextCharacter(layoutText, prohibitBreakInside, previousCharacterIsSpace);
         m_atStart = false;
         nextCharacter(c, lastCharacter, secondToLastCharacter);
     }
 
     m_layoutTextInfo.m_lineBreakIterator.setPriorContext(lastCharacter, secondToLastCharacter);
 
     wordMeasurements.grow(wordMeasurements.size() + 1);
     WordMeasurement& wordMeasurement = wordMeasurements.last();
     wordMeasurement.layoutText = layoutText;
 
@@ skipping 23 matching lines @@
             return true;
         }
         if (!hyphenated && m_lineBreak.previousInSameNode() == softHyphenCharacter) {
             hyphenated = true;
             m_atEnd = true;
         }
     }
     return false;
 }
 
-inline void BreakingContext::prepareForNextCharacter(const LineLayoutText& layoutText, bool& prohibitBreakInside, bool previousCharacterIsSpace, bool previousCharacterShouldCollapseIfPreWap)
+inline void BreakingContext::prepareForNextCharacter(const LineLayoutText& layoutText, bool& prohibitBreakInside, bool previousCharacterIsSpace)
 {
     if (layoutText.isSVGInlineText() && m_current.offset()) {
         // Force creation of new InlineBoxes for each absolute positioned character (those that start new text chunks).
         if (LineLayoutSVGInlineText(layoutText).characterStartsNewTextChunk(m_current.offset()))
             m_lineMidpointState.ensureCharacterGetsLineBox(m_current);
     }
     if (prohibitBreakInside) {
         m_current.setNextBreakablePosition(layoutText.textLength());
         prohibitBreakInside = false;
     }
     if (m_currentCharacterIsSpace && !previousCharacterIsSpace) {
         m_startOfIgnoredSpaces.setObject(m_current.object());
         m_startOfIgnoredSpaces.setOffset(m_current.offset());
     }
-    if (!m_currentCharacterIsSpace && previousCharacterShouldCollapseIfPreWap) {
+    if (!m_currentCharacterIsSpace && previousCharacterIsSpace) {
         if (m_autoWrap && m_currentStyle->breakOnlyAfterWhiteSpace())
             m_lineBreak.moveTo(m_current.object(), m_current.offset(), m_current.nextBreakablePosition());
     }
     if (m_collapseWhiteSpace && m_currentCharacterIsSpace && !m_ignoringSpaces)
         m_trailingObjects.setTrailingWhitespace(LineLayoutText(m_current.object()));
     else if (!m_currentStyle->collapseWhiteSpace() || !m_currentCharacterIsSpace)
         m_trailingObjects.clear();
 }
 
 
@@ skipping 157 matching lines @@
 
     if (style.textIndentType() == TextIndentHanging)
         shouldIndentText = shouldIndentText == IndentText ? DoNotIndentText : IndentText;
 
     return shouldIndentText;
 }
 
 }
 
 #endif // BreakingContextInlineHeaders_h