Changeset 258904 in webkit


Ignore:
Timestamp:
Mar 23, 2020 9:09:30 PM (4 years ago)
Author:
Alan Bujtas
Message:

[LFC] Layout::Box::initialContainingBlock() should return const InitialContainingBlock&
​https://bugs.webkit.org/show_bug.cgi?id=209406
<rdar://problem/60749715>

Reviewed by Antti Koivisto.

Use is<InitialContainingBlock> where applicable.

  • layout/FormattingContext.cpp:

(WebCore::Layout::FormattingContext::geometryForBox const):
(WebCore::Layout::FormattingContext::collectOutOfFlowDescendantsIfNeeded):

  • layout/FormattingContextQuirks.cpp:

(WebCore::Layout::FormattingContext::Quirks::heightValueOfNearestContainingBlockWithFixedHeight):

  • layout/blockformatting/BlockFormattingContextQuirks.cpp:
  • layout/displaytree/DisplayPainter.cpp:

(WebCore::Display::absoluteDisplayBox):

  • layout/invalidation/InvalidationState.cpp:

(WebCore::Layout::InvalidationState::markNeedsUpdate):

  • layout/layouttree/LayoutBox.cpp:

(WebCore::Layout::Box::establishesBlockFormattingContext const):
(WebCore::Layout::Box::containingBlock const):
(WebCore::Layout::Box::formattingContextRoot const):
(WebCore::Layout::Box::initialContainingBlock const):
(WebCore::Layout::Box::isInFormattingContextOf const):
(WebCore::Layout::Box::isOverflowVisible const):

  • layout/layouttree/LayoutBox.h:

(WebCore::Layout::Box::isInitialContainingBlock const):
(WebCore::Layout::Box::isInlineTextBox const):
(WebCore::Layout::Box::isLineBreakBox const):
(WebCore::Layout::Box::isReplacedBox const):

  • layout/layouttree/LayoutInitialContainingBlock.cpp:

(WebCore::Layout::InitialContainingBlock::InitialContainingBlock):

  • layout/layouttree/LayoutInlineTextBox.cpp:

(WebCore::Layout::InlineTextBox::InlineTextBox):

  • layout/layouttree/LayoutLineBreakBox.cpp:

(WebCore::Layout::LineBreakBox::LineBreakBox):

  • layout/layouttree/LayoutReplacedBox.cpp:

(WebCore::Layout::ReplacedBox::ReplacedBox):

  • layout/layouttree/LayoutTreeBuilder.cpp:

(WebCore::Layout::outputLayoutBox):

Location:
trunk/Source/WebCore
Files:
13 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r258899 r258904  
     12020-03-23  Zalan Bujtas  <zalan@apple.com>
     2
     3        [LFC] Layout::Box::initialContainingBlock() should return const InitialContainingBlock&
     4        https://bugs.webkit.org/show_bug.cgi?id=209406
     5        <rdar://problem/60749715>
     6
     7        Reviewed by Antti Koivisto.
     8
     9        Use is<InitialContainingBlock> where applicable.
     10
     11        * layout/FormattingContext.cpp:
     12        (WebCore::Layout::FormattingContext::geometryForBox const):
     13        (WebCore::Layout::FormattingContext::collectOutOfFlowDescendantsIfNeeded):
     14        * layout/FormattingContextQuirks.cpp:
     15        (WebCore::Layout::FormattingContext::Quirks::heightValueOfNearestContainingBlockWithFixedHeight):
     16        * layout/blockformatting/BlockFormattingContextQuirks.cpp:
     17        * layout/displaytree/DisplayPainter.cpp:
     18        (WebCore::Display::absoluteDisplayBox):
     19        * layout/invalidation/InvalidationState.cpp:
     20        (WebCore::Layout::InvalidationState::markNeedsUpdate):
     21        * layout/layouttree/LayoutBox.cpp:
     22        (WebCore::Layout::Box::establishesBlockFormattingContext const):
     23        (WebCore::Layout::Box::containingBlock const):
     24        (WebCore::Layout::Box::formattingContextRoot const):
     25        (WebCore::Layout::Box::initialContainingBlock const):
     26        (WebCore::Layout::Box::isInFormattingContextOf const):
     27        (WebCore::Layout::Box::isOverflowVisible const):
     28        * layout/layouttree/LayoutBox.h:
     29        (WebCore::Layout::Box::isInitialContainingBlock const):
     30        (WebCore::Layout::Box::isInlineTextBox const):
     31        (WebCore::Layout::Box::isLineBreakBox const):
     32        (WebCore::Layout::Box::isReplacedBox const):
     33        * layout/layouttree/LayoutInitialContainingBlock.cpp:
     34        (WebCore::Layout::InitialContainingBlock::InitialContainingBlock):
     35        * layout/layouttree/LayoutInlineTextBox.cpp:
     36        (WebCore::Layout::InlineTextBox::InlineTextBox):
     37        * layout/layouttree/LayoutLineBreakBox.cpp:
     38        (WebCore::Layout::LineBreakBox::LineBreakBox):
     39        * layout/layouttree/LayoutReplacedBox.cpp:
     40        (WebCore::Layout::ReplacedBox::ReplacedBox):
     41        * layout/layouttree/LayoutTreeBuilder.cpp:
     42        (WebCore::Layout::outputLayoutBox):
     43
    1442020-03-23  Justin Fan  <justin_fan@apple.com>
    245

  • trunk/Source/WebCore/layout/FormattingContext.cpp

    r258864 r258904  
    3636#include "LayoutContext.h"
    3737#include "LayoutDescendantIterator.h"
     38#include "LayoutInitialContainingBlock.h"
    3839#include "LayoutReplacedBox.h"
    3940#include "LayoutState.h"
    … …  
    193194#if ASSERT_ENABLED
    194195    auto isOkToAccessDisplayBox = [&] {
    195         if (!layoutBox.isInitialContainingBlock() && &layoutBox.formattingContextRoot() == &root()) {
     196        if (!is<InitialContainingBlock>(layoutBox) && &layoutBox.formattingContextRoot() == &root()) {
    196197            // This is the non-escape case of accessing a box's geometry information within the same formatting context.
    197198            return true;
    … …  
    205206        if (*escapeReason == EscapeReason::DocumentBoxStrechesToViewportQuirk) {
    206207            ASSERT(layoutState().inQuirksMode());
    207             return layoutBox.isInitialContainingBlock();
     208            return is<InitialContainingBlock>(layoutBox);
    208209        }
    209210
    210211        if (*escapeReason == EscapeReason::BodyStrechesToViewportQuirk) {
    211212            ASSERT(layoutState().inQuirksMode());
    212             return layoutBox.isInitialContainingBlock() || layoutBox.isDocumentBox();
     213            return is<InitialContainingBlock>(layoutBox) || layoutBox.isDocumentBox();
    213214
    214215        }
    215216
    216217        if (*escapeReason == EscapeReason::StrokeOverflowNeedsViewportGeometry)
    217             return layoutBox.isInitialContainingBlock();
     218            return is<InitialContainingBlock>(layoutBox);
    218219
    219220        if (*escapeReason == EscapeReason::NeedsGeometryFromEstablishedFormattingContext) {
    … …  
    244245            // Find the first containing block with fixed height quirk. See Quirks::heightValueOfNearestContainingBlockWithFixedHeight.
    245246            // This is only to check if the targetFormattingRoot is an ancestor formatting root.
    246             if (layoutBox.isInitialContainingBlock())
     247            if (is<InitialContainingBlock>(layoutBox))
    247248                return true;
    248249            auto& targetFormattingRoot = layoutBox.formattingContextRoot();
    … …  
    252253                    return true;
    253254                ancestorFormattingContextRoot = &ancestorFormattingContextRoot->formattingContextRoot();
    254                 if (ancestorFormattingContextRoot->isInitialContainingBlock())
     255                if (is<InitialContainingBlock>(*ancestorFormattingContextRoot))
    255256                    return true;
    256257            }
    … …  
    281282    if (!root.hasChild())
    282283        return;
    283     if (!root.isPositioned() && !root.isInitialContainingBlock())
     284    if (!root.isPositioned() && !is<InitialContainingBlock>(root))
    284285        return;
    285286    // Collect the out-of-flow descendants at the formatting root level (as opposed to at the containing block level, though they might be the same).

  • trunk/Source/WebCore/layout/FormattingContextQuirks.cpp

    r258864 r258904  
    3131#include "DisplayBox.h"
    3232#include "LayoutBox.h"
     33#include "LayoutInitialContainingBlock.h"
    3334
    3435namespace WebCore {
    … …  
    6061        }
    6162
    62         if (containingBlock->isInitialContainingBlock())
     63        if (is<InitialContainingBlock>(*containingBlock))
    6364            break;
    6465        containingBlock = &containingBlock->containingBlock();

  • trunk/Source/WebCore/layout/blockformatting/BlockFormattingContextQuirks.cpp

    r258864 r258904  
    3333#include "LayoutBox.h"
    3434#include "LayoutContainerBox.h"
     35#include "LayoutInitialContainingBlock.h"
    3536#include "LayoutState.h"
    3637

  • trunk/Source/WebCore/layout/displaytree/DisplayPainter.cpp

    r258864 r258904  
    3737#include "IntRect.h"
    3838#include "LayoutContainerBox.h"
     39#include "LayoutInitialContainingBlock.h"
    3940#include "LayoutState.h"
    4041#include "RenderStyle.h"
    … …  
    146147    if (!layoutState.hasDisplayBox(layoutBox))
    147148        return { };
    148     if (layoutBox.isInitialContainingBlock())
     149    if (is<Layout::InitialContainingBlock>(layoutBox))
    149150        return layoutState.displayBoxForLayoutBox(layoutBox);
    150151
    151152    auto absoluteBox = Box { layoutState.displayBoxForLayoutBox(layoutBox) };
    152     for (auto* containingBlock = &layoutBox.containingBlock(); !containingBlock->isInitialContainingBlock(); containingBlock = &containingBlock->containingBlock())
     153    for (auto* containingBlock = &layoutBox.containingBlock(); !is<Layout::InitialContainingBlock>(*containingBlock); containingBlock = &containingBlock->containingBlock())
    153154        absoluteBox.moveBy(layoutState.displayBoxForLayoutBox(*containingBlock).topLeft());
    154155    return absoluteBox;

  • trunk/Source/WebCore/layout/invalidation/InvalidationState.cpp

    r258864 r258904  
    4343{
    4444    // We never lay out the initial containing block. It always has pre-determined geometry.
    45     ASSERT(!layoutBox.isInitialContainingBlock());
     45    ASSERT(!is<InitialContainingBlock>(layoutBox));
    4646    // FIXME: This is just a placeholder implementation.
    4747    m_formattingContextRoots.add(&layoutBox.formattingContextRoot());

  • trunk/Source/WebCore/layout/layouttree/LayoutBox.cpp

    r258864 r258904  
    3131#include "DisplayBox.h"
    3232#include "LayoutContainerBox.h"
     33#include "LayoutInitialContainingBlock.h"
    3334#include "LayoutPhase.h"
    3435#include "LayoutState.h"
    … …  
    7172{
    7273    // ICB always creates a new (inital) block formatting context.
    73     if (isInitialContainingBlock())
     74    if (is<InitialContainingBlock>(*this))
    7475        return true;
    7576
    … …  
    184185    ASSERT(!Phase::isInTreeBuilding());
    185186    // If we ever end up here with the ICB, we must be doing something not-so-great.
    186     RELEASE_ASSERT(!isInitialContainingBlock());
     187    RELEASE_ASSERT(!is<InitialContainingBlock>(*this));
    187188    // The containing block in which the root element lives is a rectangle called the initial containing block.
    188189    // For other elements, if the element's position is 'relative' or 'static', the containing block is formed by the
    … …  
    193194    if (!isPositioned() || isInFlowPositioned()) {
    194195        auto* ancestor = parent();
    195         for (; !ancestor->isInitialContainingBlock(); ancestor = ancestor->parent()) {
     196        for (; !is<InitialContainingBlock>(*ancestor); ancestor = ancestor->parent()) {
    196197            if (ancestor->isBlockContainerBox() || ancestor->establishesFormattingContext())
    197198                return *ancestor;
    … …  
    202203    if (isFixedPositioned()) {
    203204        auto* ancestor = parent();
    204         for (; !ancestor->isInitialContainingBlock(); ancestor = ancestor->parent()) {
     205        for (; !is<InitialContainingBlock>(*ancestor); ancestor = ancestor->parent()) {
    205206            if (ancestor->style().hasTransform())
    206207                return *ancestor;
    … …  
    211212    if (isOutOfFlowPositioned()) {
    212213        auto* ancestor = parent();
    213         for (; !ancestor->isInitialContainingBlock(); ancestor = ancestor->parent()) {
     214        for (; !is<InitialContainingBlock>(*ancestor); ancestor = ancestor->parent()) {
    214215            if (ancestor->isPositioned() || ancestor->style().hasTransform())
    215216                return *ancestor;
    … …  
    227228    ASSERT(!Phase::isInTreeBuilding());
    228229    // We should never need to ask this question on the ICB.
    229     ASSERT(!isInitialContainingBlock());
     230    ASSERT(!is<InitialContainingBlock>(*this));
    230231    // A box lives in the same formatting context as its containing block unless the containing block establishes a formatting context.
    231232    // However relatively positioned (inflow) inline container lives in the formatting context where its parent lives unless
    … …  
    241242}
    242243
    243 const ContainerBox& Box::initialContainingBlock() const
    244 {
    245     if (isInitialContainingBlock())
    246         return downcast<ContainerBox>(*this);
     244const InitialContainingBlock& Box::initialContainingBlock() const
     245{
     246    if (is<InitialContainingBlock>(*this))
     247        return downcast<InitialContainingBlock>(*this);
    247248
    248249    auto* ancestor = parent();
    249250    for (; ancestor->parent(); ancestor = ancestor->parent()) { }
    250251
    251     return *ancestor;
     252    return downcast<InitialContainingBlock>(*ancestor);
    252253}
    253254
    … …  
    255256{
    256257    ASSERT(formattingContextRoot.establishesFormattingContext());
    257     ASSERT(!isInitialContainingBlock());
     258    ASSERT(!is<InitialContainingBlock>(*this));
    258259    auto* ancestor = &containingBlock();
    259260    while (ancestor) {
    260261        if (ancestor == &formattingContextRoot)
    261262            return true;
    262         if (ancestor->isInitialContainingBlock())
     263        if (is<InitialContainingBlock>(*ancestor))
    263264            return false;
    264265        ancestor = &ancestor->containingBlock();
    … …  
    361362        return true;
    362363    }
    363     if (isInitialContainingBlock()) {
     364    if (is<InitialContainingBlock>(*this)) {
    364365        auto* documentBox = downcast<ContainerBox>(*this).firstChild();
    365366        if (!documentBox || !documentBox->isDocumentBox() || !is<ContainerBox>(documentBox))

  • trunk/Source/WebCore/layout/layouttree/LayoutBox.h

    r258864 r258904  
    4141
    4242class ContainerBox;
     43class InitialContainingBlock;
    4344class LayoutState;
    4445class TreeBuilder;
    … …  
    6263
    6364    enum BaseTypeFlag {
    64         BoxFlag                = 1 << 0,
    65         InlineTextBox          = 1 << 1,
    66         LineBreakBox           = 1 << 2,
    67         ReplacedBox            = 1 << 3,
    68         InitialContainingBlock = 1 << 4,
    69         ContainerBoxFlag       = 1 << 5
     65        BoxFlag                    = 1 << 0,
     66        InlineTextBoxFlag          = 1 << 1,
     67        LineBreakBoxFlag           = 1 << 2,
     68        ReplacedBoxFlag            = 1 << 3,
     69        InitialContainingBlockFlag = 1 << 4,
     70        ContainerBoxFlag           = 1 << 5
    7071    };
    7172    typedef unsigned BaseTypeFlags;
    … …  
    9798    const ContainerBox& containingBlock() const;
    9899    const ContainerBox& formattingContextRoot() const;
    99     const ContainerBox& initialContainingBlock() const;
     100    const InitialContainingBlock& initialContainingBlock() const;
    100101
    101102    bool isInFormattingContextOf(const ContainerBox&) const;
    … …  
    110111    bool isInlineTableBox() const;
    111112    bool isBlockContainerBox() const;
    112     bool isInitialContainingBlock() const { return m_baseTypeFlags & InitialContainingBlock; }
     113    bool isInitialContainingBlock() const { return m_baseTypeFlags & InitialContainingBlockFlag; }
    113114
    114115    bool isDocumentBox() const { return m_elementAttributes && m_elementAttributes.value().elementType == ElementType::Document; }
    … …  
    139140
    140141    bool isContainerBox() const { return m_baseTypeFlags & ContainerBoxFlag; }
    141     bool isInlineTextBox() const { return m_baseTypeFlags & InlineTextBox; }
    142     bool isLineBreakBox() const { return m_baseTypeFlags & LineBreakBox; }
    143     bool isReplacedBox() const { return m_baseTypeFlags & ReplacedBox; }
     142    bool isInlineTextBox() const { return m_baseTypeFlags & InlineTextBoxFlag; }
     143    bool isLineBreakBox() const { return m_baseTypeFlags & LineBreakBoxFlag; }
     144    bool isReplacedBox() const { return m_baseTypeFlags & ReplacedBoxFlag; }
    144145
    145146    bool isPaddingApplicable() const;

  • trunk/Source/WebCore/layout/layouttree/LayoutInitialContainingBlock.cpp

    r258864 r258904  
    3838
    3939InitialContainingBlock::InitialContainingBlock(RenderStyle&& style)
    40     : ContainerBox({ }, WTFMove(style), Box::InitialContainingBlock)
     40    : ContainerBox({ }, WTFMove(style), Box::InitialContainingBlockFlag)
    4141{
    4242}

  • trunk/Source/WebCore/layout/layouttree/LayoutInlineTextBox.cpp

    r258864 r258904  
    3838
    3939InlineTextBox::InlineTextBox(String content, bool canUseSimplifiedContentMeasuring, RenderStyle&& style)
    40     : Box({ }, WTFMove(style), Box::InlineTextBox)
     40    : Box({ }, WTFMove(style), Box::InlineTextBoxFlag)
    4141    , m_content(content)
    4242    , m_canUseSimplifiedContentMeasuring(canUseSimplifiedContentMeasuring)

  • trunk/Source/WebCore/layout/layouttree/LayoutLineBreakBox.cpp

    r258864 r258904  
    3838
    3939LineBreakBox::LineBreakBox(bool isOptional, RenderStyle&& style)
    40     : Box({ }, WTFMove(style), Box::LineBreakBox)
     40    : Box({ }, WTFMove(style), Box::LineBreakBoxFlag)
    4141    , m_isOptional(isOptional)
    4242{

  • trunk/Source/WebCore/layout/layouttree/LayoutReplacedBox.cpp

    r258864 r258904  
    3838
    3939ReplacedBox::ReplacedBox(RenderStyle&& style)
    40     : Box({ }, WTFMove(style), Box::ReplacedBox)
     40    : Box({ }, WTFMove(style), Box::ReplacedBoxFlag)
    4141{
    4242}

  • trunk/Source/WebCore/layout/layouttree/LayoutTreeBuilder.cpp

    r258864 r258904  
    395395        stream << "[float] ";
    396396
    397     if (layoutBox.isInitialContainingBlock())
     397    if (is<InitialContainingBlock>(layoutBox))
    398398        stream << "Initial containing block";
    399399    else if (layoutBox.isDocumentBox())
Note: See TracChangeset for help on using the changeset viewer.