Rename LayoutStyle to papayawhip

Source/core/layout/LayoutBlockFlow.cpp

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 757 matching lines @@
         }
     }
 
     // Similar to how we apply clearance. Go ahead and boost height() to be the place where we're going to position the child.
     setLogicalHeight(logicalHeight() + (result - oldTop));
 
     // Return the final adjusted logical top.
     return result;
 }
 
-static inline LayoutUnit calculateMinimumPageHeight(const LayoutStyle& style, RootInlineBox* lastLine, LayoutUnit lineTop, LayoutUnit lineBottom)
+static inline LayoutUnit calculateMinimumPageHeight(const ComputedStyle& style, RootInlineBox* lastLine, LayoutUnit lineTop, LayoutUnit lineBottom)
 {
     // We may require a certain minimum number of lines per page in order to satisfy
     // orphans and widows, and that may affect the minimum page height.
     unsigned lineCount = std::max<unsigned>(style.hasAutoOrphans() ? 1 : style.orphans(), style.widows());
     if (lineCount > 1) {
         RootInlineBox* line = lastLine;
         for (unsigned i = 1; i < lineCount && line->prevRootBox(); i++)
             line = line->prevRootBox();
 
         // FIXME: Paginating using line overflow isn't all fine. See FIXME in
@@ skipping 293 matching lines @@
 // Our MarginInfo state used when laying out block children.
 MarginInfo::MarginInfo(LayoutBlockFlow* blockFlow, LayoutUnit beforeBorderPadding, LayoutUnit afterBorderPadding)
     : m_canCollapseMarginAfterWithLastChild(true)
     , m_atBeforeSideOfBlock(true)
     , m_atAfterSideOfBlock(false)
     , m_hasMarginBeforeQuirk(false)
     , m_hasMarginAfterQuirk(false)
     , m_determinedMarginBeforeQuirk(false)
     , m_discardMargin(false)
 {
-    const LayoutStyle& blockStyle = blockFlow->styleRef();
+    const ComputedStyle& blockStyle = blockFlow->styleRef();
     ASSERT(blockFlow->isLayoutView() || blockFlow->parent());
     m_canCollapseWithChildren = !blockFlow->createsNewFormattingContext() && !blockFlow->isLayoutFlowThread() && !blockFlow->isLayoutView();
 
     m_canCollapseMarginBeforeWithChildren = m_canCollapseWithChildren && !beforeBorderPadding && blockStyle.marginBeforeCollapse() != MSEPARATE;
 
     // If any height other than auto is specified in CSS, then we don't collapse our bottom
     // margins with our children's margins. To do otherwise would be to risk odd visual
     // effects when the children overflow out of the parent block and yet still collapse
     // with it. We also don't collapse if we have any bottom border/padding.
     m_canCollapseMarginAfterWithChildren = m_canCollapseWithChildren && !afterBorderPadding
@@ skipping 591 matching lines @@
             return;
         m_rareData = adoptPtr(new LayoutBlockFlowRareData(this));
     }
     m_rareData->m_margins.setPositiveMarginAfter(pos);
     m_rareData->m_margins.setNegativeMarginAfter(neg);
 }
 
 bool LayoutBlockFlow::mustSeparateMarginBeforeForChild(const LayoutBox& child) const
 {
     ASSERT(!child.selfNeedsLayout());
-    const LayoutStyle& childStyle = child.styleRef();
+    const ComputedStyle& childStyle = child.styleRef();
     if (!child.isWritingModeRoot())
         return childStyle.marginBeforeCollapse() == MSEPARATE;
     if (child.isHorizontalWritingMode() == isHorizontalWritingMode())
         return childStyle.marginAfterCollapse() == MSEPARATE;
 
     // FIXME: See |mustDiscardMarginBeforeForChild| above.
     return false;
 }
 
 bool LayoutBlockFlow::mustSeparateMarginAfterForChild(const LayoutBox& child) const
 {
     ASSERT(!child.selfNeedsLayout());
-    const LayoutStyle& childStyle = child.styleRef();
+    const ComputedStyle& childStyle = child.styleRef();
     if (!child.isWritingModeRoot())
         return childStyle.marginAfterCollapse() == MSEPARATE;
     if (child.isHorizontalWritingMode() == isHorizontalWritingMode())
         return childStyle.marginBeforeCollapse() == MSEPARATE;
 
     // FIXME: See |mustDiscardMarginBeforeForChild| above.
     return false;
 }
 
 LayoutUnit LayoutBlockFlow::applyBeforeBreak(LayoutBox& child, LayoutUnit logicalOffset)
@@ skipping 196 matching lines @@
         ASSERT_NOT_REACHED();
     }
     return result;
 }
 
 void LayoutBlockFlow::createFloatingObjects()
 {
     m_floatingObjects = adoptPtr(new FloatingObjects(this, isHorizontalWritingMode()));
 }
 
-void LayoutBlockFlow::styleWillChange(StyleDifference diff, const LayoutStyle& newStyle)
+void LayoutBlockFlow::styleWillChange(StyleDifference diff, const ComputedStyle& newStyle)
 {
-    const LayoutStyle* oldStyle = style();
+    const ComputedStyle* oldStyle = style();
     s_canPropagateFloatIntoSibling = oldStyle ? !isFloatingOrOutOfFlowPositioned() && !avoidsFloats() : false;
     if (oldStyle && parent() && diff.needsFullLayout() && oldStyle->position() != newStyle.position()
         && containsFloats() && !isFloating() && !isOutOfFlowPositioned() && newStyle.hasOutOfFlowPosition())
             markAllDescendantsWithFloatsForLayout();
 
     LayoutBlock::styleWillChange(diff, newStyle);
 }
 
-void LayoutBlockFlow::styleDidChange(StyleDifference diff, const LayoutStyle* oldStyle)
+void LayoutBlockFlow::styleDidChange(StyleDifference diff, const ComputedStyle* oldStyle)
 {
     LayoutBlock::styleDidChange(diff, oldStyle);
 
     // After our style changed, if we lose our ability to propagate floats into next sibling
     // blocks, then we need to find the top most parent containing that overhanging float and
     // then mark its descendants with floats for layout and clear all floats from its next
     // sibling blocks that exist in our floating objects list. See bug 56299 and 62875.
     bool canPropagateFloatIntoSibling = !isFloatingOrOutOfFlowPositioned() && !avoidsFloats();
     if (diff.needsFullLayout() && s_canPropagateFloatIntoSibling && !canPropagateFloatIntoSibling && hasOverhangingFloats()) {
         LayoutBlockFlow* parentBlockFlow = this;
@@ skipping 1078 matching lines @@
         cb = cb->containingBlock();
     }
     return logicalRight;
 }
 
 RootInlineBox* LayoutBlockFlow::createRootInlineBox()
 {
     return new RootInlineBox(*this);
 }
 
-bool LayoutBlockFlow::isPagedOverflow(const LayoutStyle& style)
+bool LayoutBlockFlow::isPagedOverflow(const ComputedStyle& style)
 {
     return style.isOverflowPaged() && node() != document().viewportDefiningElement();
 }
 
-LayoutBlockFlow::FlowThreadType LayoutBlockFlow::flowThreadType(const LayoutStyle& style)
+LayoutBlockFlow::FlowThreadType LayoutBlockFlow::flowThreadType(const ComputedStyle& style)
 {
     if (isPagedOverflow(style))
         return PagedFlowThread;
     if (style.specifiesColumns())
         return MultiColumnFlowThread;
     return NoFlowThread;
 }
 
 LayoutMultiColumnFlowThread* LayoutBlockFlow::createMultiColumnFlowThread(FlowThreadType type)
 {
     switch (type) {
     case MultiColumnFlowThread:
         return LayoutMultiColumnFlowThread::createAnonymous(document(), styleRef());
     case PagedFlowThread:
         // Paged overflow is currently done using the multicol implementation.
         return LayoutPagedFlowThread::createAnonymous(document(), styleRef());
     default:
         ASSERT_NOT_REACHED();
         return nullptr;
     }
 }
 
-void LayoutBlockFlow::createOrDestroyMultiColumnFlowThreadIfNeeded(const LayoutStyle* oldStyle)
+void LayoutBlockFlow::createOrDestroyMultiColumnFlowThreadIfNeeded(const ComputedStyle* oldStyle)
 {
     if (!RuntimeEnabledFeatures::regionBasedColumnsEnabled())
         return;
 
     // Paged overflow trumps multicol in this implementation. Ideally, it should be possible to have
     // both paged overflow and multicol on the same element, but then we need two flow
     // threads. Anyway, this is nothing to worry about until we can actually nest multicol properly
     // inside other fragmentation contexts.
     FlowThreadType type = flowThreadType(styleRef());
 
@@ skipping 73 matching lines @@
     }
     if (isAnonymous())
         return "LayoutBlockFlow (anonymous)";
     if (isRelPositioned())
         return "LayoutBlockFlow (relative positioned)";
     return "LayoutBlockFlow";
 }
 
 
 } // namespace blink