Rename LayoutStyle to papayawhip

Source/core/layout/LayoutText.cpp

 /*
  * (C) 1999 Lars Knoll (knoll@kde.org)
  * (C) 2000 Dirk Mueller (mueller@kde.org)
  * Copyright (C) 2004, 2005, 2006, 2007 Apple Inc. All rights reserved.
  * Copyright (C) 2006 Andrew Wellington (proton@wiretapped.net)
  * Copyright (C) 2006 Graham Dennis (graham.dennis@gmail.com)
  *
  * 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
@@ skipping 165 matching lines @@
 bool LayoutText::isTextFragment() const
 {
     return false;
 }
 
 bool LayoutText::isWordBreak() const
 {
     return false;
 }
 
-void LayoutText::styleDidChange(StyleDifference diff, const LayoutStyle* oldStyle)
+void LayoutText::styleDidChange(StyleDifference diff, const ComputedStyle* oldStyle)
 {
     // There is no need to ever schedule paint invalidations from a style change of a text run, since
     // we already did this for the parent of the text run.
     // We do have to schedule layouts, though, since a style change can force us to
     // need to relayout.
     if (diff.needsFullLayout()) {
         setNeedsLayoutAndPrefWidthsRecalc();
         m_knownToHaveNoOverflowAndNoFallbackFonts = false;
     }
 
-    const LayoutStyle& newStyle = styleRef();
+    const ComputedStyle& newStyle = styleRef();
     ETextTransform oldTransform = oldStyle ? oldStyle->textTransform() : TTNONE;
     ETextSecurity oldSecurity = oldStyle ? oldStyle->textSecurity() : TSNONE;
     if (oldTransform != newStyle.textTransform() || oldSecurity != newStyle.textSecurity())
         transformText();
 
     // This is an optimization that kicks off font load before layout.
     // In order to make it fast, we only check if the first character of the
     // text is included in the unicode ranges of the fonts.
     if (!text().containsOnlyWhitespace())
         newStyle.font().willUseFontData(text().characterStartingAt(0));
@@ skipping 449 matching lines @@
 
     float rootLeft = box->root().logicalLeft();
     float rootRight = box->root().logicalRight();
 
     // FIXME: should we use the width of the root inline box or the
     // width of the containing block for this?
     if (extraWidthToEndOfLine)
         *extraWidthToEndOfLine = (box->root().logicalWidth() + rootLeft) - (left + 1);
 
     LayoutBlock* cb = containingBlock();
-    const LayoutStyle& cbStyle = cb->styleRef();
+    const ComputedStyle& cbStyle = cb->styleRef();
 
     float leftEdge;
     float rightEdge;
     leftEdge = std::min<float>(0, rootLeft);
     rightEdge = std::max<float>(cb->logicalWidth().toFloat(), rootRight);
 
     bool rightAligned = false;
     switch (cbStyle.textAlign()) {
     case RIGHT:
     case WEBKIT_RIGHT:
@@ skipping 38 matching lines @@
             return combineText->combinedTextWidth(f);
     }
 
     if (f.isFixedPitch() && f.fontDescription().variant() == FontVariantNormal && m_isAllASCII && (!glyphOverflow || !glyphOverflow->computeBounds)) {
         bool missingGlyph = false;
         float monospaceCharacterWidth = f.spaceWidth();
         float w = 0;
         bool isSpace;
         ASSERT(m_text);
         StringImpl& text = *m_text.impl();
-        const LayoutStyle& layoutStyle = styleRef();
+        const ComputedStyle& computedStyle = styleRef();
         for (int i = start; i < start + len; i++) {
             char c = text[i];
             // If glyph is not present in primary font then we cannot calculate width based on primary
             // font property, we need to call "width" method of Font Object.
             if (!f.primaryFontHasGlyphForCharacter(text[i])) {
                 missingGlyph = true;
                 break;
             }
             if (c <= space) {
                 if (c == space || c == newlineCharacter) {
                     w += monospaceCharacterWidth;
                     isSpace = true;
                 } else if (c == characterTabulation) {
-                    if (layoutStyle.collapseWhiteSpace()) {
+                    if (computedStyle.collapseWhiteSpace()) {
                         w += monospaceCharacterWidth;
                         isSpace = true;
                     } else {
-                        w += f.tabWidth(layoutStyle.tabSize(), xPos + w);
+                        w += f.tabWidth(computedStyle.tabSize(), xPos + w);
                         isSpace = false;
                     }
                 } else {
                     isSpace = false;
                 }
             } else {
                 w += monospaceCharacterWidth;
                 isSpace = false;
             }
             if (isSpace && i > start)
@@ skipping 133 matching lines @@
     GlyphOverflow glyphOverflow;
     computePreferredLogicalWidths(leadWidth, fallbackFonts, glyphOverflow);
 
     // We shouldn't change our mind once we "know".
     ASSERT(!m_knownToHaveNoOverflowAndNoFallbackFonts || (fallbackFonts.isEmpty() && glyphOverflow.isZero()));
     m_knownToHaveNoOverflowAndNoFallbackFonts = fallbackFonts.isEmpty() && glyphOverflow.isZero();
 }
 
 static inline float hyphenWidth(LayoutText* renderer, const Font& font, TextDirection direction)
 {
-    const LayoutStyle& style = renderer->styleRef();
+    const ComputedStyle& style = renderer->styleRef();
     return font.width(constructTextRun(renderer, font, style.hyphenString().string(), style, direction));
 }
 
 void LayoutText::computePreferredLogicalWidths(float leadWidth, HashSet<const SimpleFontData*>& fallbackFonts, GlyphOverflow& glyphOverflow)
 {
     ASSERT(m_hasTab || preferredLogicalWidthsDirty() || !m_knownToHaveNoOverflowAndNoFallbackFonts);
 
     m_minWidth = 0;
     m_maxWidth = 0;
     m_firstLineMinWidth = 0;
     m_lastLineLineMinWidth = 0;
 
     if (isBR())
         return;
 
     float currMinWidth = 0;
     float currMaxWidth = 0;
     m_hasBreakableChar = false;
     m_hasBreak = false;
     m_hasTab = false;
     m_hasBreakableStart = false;
     m_hasBreakableEnd = false;
     m_hasEndWhiteSpace = false;
 
-    const LayoutStyle& styleToUse = styleRef();
+    const ComputedStyle& styleToUse = styleRef();
     const Font& f = styleToUse.font(); // FIXME: This ignores first-line.
     float wordSpacing = styleToUse.wordSpacing();
     int len = textLength();
     LazyLineBreakIterator breakIterator(m_text, styleToUse.locale());
     bool needsWordSpacing = false;
     bool ignoringSpaces = false;
     bool isSpace = false;
     bool firstWord = true;
     bool firstLine = true;
     int nextBreakable = -1;
@@ skipping 410 matching lines @@
             prev = (*previousString)[previousString->length() - 1];
     }
     return prev;
 }
 
 void LayoutText::addLayerHitTestRects(LayerHitTestRects&, const DeprecatedPaintLayer* currentLayer, const LayoutPoint& layerOffset, const LayoutRect& containerRect) const
 {
     // Text nodes aren't event targets, so don't descend any further.
 }
 
-void applyTextTransform(const LayoutStyle* style, String& text, UChar previousCharacter)
+void applyTextTransform(const ComputedStyle* style, String& text, UChar previousCharacter)
 {
     if (!style)
         return;
 
     switch (style->textTransform()) {
     case TTNONE:
         break;
     case CAPITALIZE:
         makeCapitalized(&text, previousCharacter);
         break;
@@ skipping 533 matching lines @@
 }
 
 void LayoutText::invalidateDisplayItemClients(const LayoutBoxModelObject& paintInvalidationContainer) const
 {
     LayoutObject::invalidateDisplayItemClients(paintInvalidationContainer);
     for (InlineTextBox* box = firstTextBox(); box; box = box->nextTextBox())
         paintInvalidationContainer.invalidateDisplayItemClientOnBacking(*box);
 }
 
 } // namespace blink