Rename LayoutStyle to papayawhip

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 101 matching lines @@
     InlineBidiResolver& m_resolver;
 
     InlineIterator m_current;
     InlineIterator m_lineBreak;
     InlineIterator m_startOfIgnoredSpaces;
 
     LayoutBlockFlow* m_block;
     LayoutObject* m_lastObject;
     LayoutObject* m_nextObject;
 
-    const LayoutStyle* m_currentStyle;
-    const LayoutStyle* m_blockStyle;
+    const ComputedStyle* m_currentStyle;
+    const ComputedStyle* m_blockStyle;
 
     LineInfo& m_lineInfo;
 
     LayoutTextInfo& m_renderTextInfo;
 
     FloatingObject* m_lastFloatFromPreviousLine;
 
     LineWidth m_width;
 
     EWhiteSpace m_currWS;
@@ skipping 12 matching lines @@
     bool m_collapseWhiteSpace;
     bool m_startingNewParagraph;
     bool m_allowImagesToBreak;
     bool m_atEnd;
 
     LineMidpointState& m_lineMidpointState;
 
     TrailingObjects m_trailingObjects;
 };
 
-inline bool shouldCollapseWhiteSpace(const LayoutStyle& style, const LineInfo& lineInfo, WhitespacePosition whitespacePosition)
+inline bool shouldCollapseWhiteSpace(const ComputedStyle& style, const LineInfo& lineInfo, WhitespacePosition whitespacePosition)
 {
     // CSS2 16.6.1
     // If a space (U+0020) at the beginning of a line has 'white-space' set to 'normal', 'nowrap', or 'pre-line', it is removed.
     // If a space (U+0020) at the end of a line has 'white-space' set to 'normal', 'nowrap', or 'pre-line', it is also removed.
     // If spaces (U+0020) or tabs (U+0009) at the end of a line have 'white-space' set to 'pre-wrap', UAs may visually collapse them.
     return style.collapseWhiteSpace()
         || (whitespacePosition == TrailingWhitespace && style.whiteSpace() == PRE_WRAP && (!lineInfo.isEmpty() || !lineInfo.previousLineBrokeCleanly()));
 }
 
 inline bool requiresLineBoxForContent(LayoutInline* flow, const LineInfo& lineInfo)
@@ skipping 74 matching lines @@
 inline void BreakingContext::initializeForCurrentObject()
 {
     m_currentStyle = m_current.object()->style();
     m_nextObject = bidiNextSkippingEmptyInlines(m_block, m_current.object());
     if (m_nextObject && m_nextObject->parent() && !m_nextObject->parent()->isDescendantOf(m_current.object()->parent()))
         m_includeEndWidth = true;
 
     m_currWS = m_current.object()->isReplaced() ? m_current.object()->parent()->style()->whiteSpace() : m_currentStyle->whiteSpace();
     m_lastWS = m_lastObject->isReplaced() ? m_lastObject->parent()->style()->whiteSpace() : m_lastObject->style()->whiteSpace();
 
-    m_autoWrap = LayoutStyle::autoWrap(m_currWS);
+    m_autoWrap = ComputedStyle::autoWrap(m_currWS);
     m_autoWrapWasEverTrueOnLine = m_autoWrapWasEverTrueOnLine || m_autoWrap;
 
-    m_preservesNewline = m_current.object()->isSVGInlineText() ? false : LayoutStyle::preserveNewline(m_currWS);
+    m_preservesNewline = m_current.object()->isSVGInlineText() ? false : ComputedStyle::preserveNewline(m_currWS);
 
-    m_collapseWhiteSpace = LayoutStyle::collapseWhiteSpace(m_currWS);
+    m_collapseWhiteSpace = ComputedStyle::collapseWhiteSpace(m_currWS);
 }
 
 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);
@@ skipping 172 matching lines @@
 }
 
 inline void BreakingContext::handleReplaced()
 {
     LayoutBox* replacedBox = toLayoutBox(m_current.object());
 
     if (m_atStart)
         m_width.updateAvailableWidth(replacedBox->logicalHeight());
 
     // Break on replaced elements if either has normal white-space.
-    if ((m_autoWrap || LayoutStyle::autoWrap(m_lastWS)) && (!m_current.object()->isImage() || m_allowImagesToBreak)) {
+    if ((m_autoWrap || ComputedStyle::autoWrap(m_lastWS)) && (!m_current.object()->isImage() || m_allowImagesToBreak)) {
         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;
@@ skipping 30 matching lines @@
 {
     for (size_t i = 0; i < wordMeasurements.size(); ++i) {
         if (wordMeasurements[i].width > 0)
             return wordMeasurements[i].width;
     }
     return 0;
 }
 
 inline float measureHyphenWidth(LayoutText* renderer, const Font& font, TextDirection textDirection)
 {
-    const LayoutStyle& style = renderer->styleRef();
+    const ComputedStyle& style = renderer->styleRef();
     return font.width(constructTextRun(renderer, font,
         style.hyphenString().string(), style, style.direction()));
 }
 
 ALWAYS_INLINE TextDirection textDirectionFromUnicode(WTF::Unicode::Direction direction)
 {
     return direction == WTF::Unicode::RightToLeft
         || direction == WTF::Unicode::RightToLeftArabic ? RTL : LTR;
 }
 
@@ skipping 14 matching lines @@
 {
     if (!m_current.offset())
         m_appliedStartWidth = false;
 
     LayoutText* renderText = toLayoutText(m_current.object());
 
     bool isSVGText = renderText->isSVGInlineText();
 
     // If we have left a no-wrap inline and entered an autowrap inline while ignoring spaces
     // then we need to mark the start of the autowrap inline as a potential linebreak now.
-    if (m_autoWrap && !LayoutStyle::autoWrap(m_lastWS) && m_ignoringSpaces) {
+    if (m_autoWrap && !ComputedStyle::autoWrap(m_lastWS) && m_ignoringSpaces) {
         m_width.commit();
         m_lineBreak.moveToStartOf(m_current.object());
     }
 
-    const LayoutStyle& style = renderText->styleRef(m_lineInfo.isFirstLine());
+    const ComputedStyle& style = renderText->styleRef(m_lineInfo.isFirstLine());
     const Font& font = style.font();
     bool isFixedPitch = font.isFixedPitch();
 
     unsigned lastSpace = m_current.offset();
     float wordSpacing = m_currentStyle->wordSpacing();
     float lastSpaceWordSpacing = 0;
     float wordSpacingForWordMeasurement = 0;
 
     float wrapW = m_width.uncommittedWidth() + inlineLogicalWidth(m_current.object(), !m_appliedStartWidth, true);
     float charWidth = 0;
@@ skipping 325 matching lines @@
 
     if (!m_current.object()->isFloatingOrOutOfFlowPositioned()) {
         m_lastObject = m_current.object();
         if (m_lastObject->isReplaced() && m_autoWrap && (!m_lastObject->isImage() || m_allowImagesToBreak) && (!m_lastObject->isListMarker() || toLayoutListMarker(m_lastObject)->isInside())) {
             m_width.commit();
             m_lineBreak.moveToStartOf(m_nextObject);
         }
     }
 }
 
-inline IndentTextOrNot requiresIndent(bool isFirstLine, bool isAfterHardLineBreak, const LayoutStyle& style)
+inline IndentTextOrNot requiresIndent(bool isFirstLine, bool isAfterHardLineBreak, const ComputedStyle& style)
 {
     IndentTextOrNot shouldIndentText = DoNotIndentText;
     if (isFirstLine || (isAfterHardLineBreak && style.textIndentLine()) == TextIndentEachLine)
         shouldIndentText = IndentText;
 
     if (style.textIndentType() == TextIndentHanging)
         shouldIndentText = shouldIndentText == IndentText ? DoNotIndentText : IndentText;
 
     return shouldIndentText;
 }
 
 }
 
 #endif // BreakingContextInlineHeaders_h