Changeset 258864 in webkit


Ignore:
Timestamp:
Mar 23, 2020 11:49:09 AM (4 years ago)
Author:
Truitt Savell
Message:

Unreviewed, reverting r258847.

Broke testing on Mac Debug with an Assert

Reverted changeset:

"[LFC] Layout::Box::initialContainingBlock() should return
const InitialContainingBlock&"
​https://bugs.webkit.org/show_bug.cgi?id=209406
​https://trac.webkit.org/changeset/258847

Location:
trunk/Source/WebCore
Files:
13 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r258863 r258864  
     12020-03-23  Truitt Savell  <tsavell@apple.com>
     2
     3        Unreviewed, reverting r258847.
     4
     5        Broke testing on Mac Debug with an Assert
     6
     7        Reverted changeset:
     8
     9        "[LFC] Layout::Box::initialContainingBlock() should return
     10        const InitialContainingBlock&"
     11        https://bugs.webkit.org/show_bug.cgi?id=209406
     12        https://trac.webkit.org/changeset/258847
     13
    1142020-03-23  Kate Cheney  <katherine_cheney@apple.com>
    215

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

    r258847 r258864  
    3636#include "LayoutContext.h"
    3737#include "LayoutDescendantIterator.h"
    38 #include "LayoutInitialContainingBlock.h"
    3938#include "LayoutReplacedBox.h"
    4039#include "LayoutState.h"
    … …  
    194193#if ASSERT_ENABLED
    195194    auto isOkToAccessDisplayBox = [&] {
    196         if (!is<InitialContainingBlock>(layoutBox) && &layoutBox.formattingContextRoot() == &root()) {
     195        if (!layoutBox.isInitialContainingBlock() && &layoutBox.formattingContextRoot() == &root()) {
    197196            // This is the non-escape case of accessing a box's geometry information within the same formatting context.
    198197            return true;
    … …  
    206205        if (*escapeReason == EscapeReason::DocumentBoxStrechesToViewportQuirk) {
    207206            ASSERT(layoutState().inQuirksMode());
    208             return is<InitialContainingBlock>(layoutBox);
     207            return layoutBox.isInitialContainingBlock();
    209208        }
    210209
    211210        if (*escapeReason == EscapeReason::BodyStrechesToViewportQuirk) {
    212211            ASSERT(layoutState().inQuirksMode());
    213             return is<InitialContainingBlock>(layoutBox) || layoutBox.isDocumentBox();
     212            return layoutBox.isInitialContainingBlock() || layoutBox.isDocumentBox();
    214213
    215214        }
    216215
    217216        if (*escapeReason == EscapeReason::StrokeOverflowNeedsViewportGeometry)
    218             return is<InitialContainingBlock>(layoutBox);
     217            return layoutBox.isInitialContainingBlock();
    219218
    220219        if (*escapeReason == EscapeReason::NeedsGeometryFromEstablishedFormattingContext) {
    … …  
    245244            // Find the first containing block with fixed height quirk. See Quirks::heightValueOfNearestContainingBlockWithFixedHeight.
    246245            // This is only to check if the targetFormattingRoot is an ancestor formatting root.
    247             if (is<InitialContainingBlock>(layoutBox))
     246            if (layoutBox.isInitialContainingBlock())
    248247                return true;
    249248            auto& targetFormattingRoot = layoutBox.formattingContextRoot();
    … …  
    253252                    return true;
    254253                ancestorFormattingContextRoot = &ancestorFormattingContextRoot->formattingContextRoot();
    255                 if (is<InitialContainingBlock>(*ancestorFormattingContextRoot))
     254                if (ancestorFormattingContextRoot->isInitialContainingBlock())
    256255                    return true;
    257256            }
    … …  
    282281    if (!root.hasChild())
    283282        return;
    284     if (!root.isPositioned() && !is<InitialContainingBlock>(root))
     283    if (!root.isPositioned() && !root.isInitialContainingBlock())
    285284        return;
    286285    // 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

    r258847 r258864  
    3131#include "DisplayBox.h"
    3232#include "LayoutBox.h"
    33 #include "LayoutInitialContainingBlock.h"
    3433
    3534namespace WebCore {
    … …  
    6160        }
    6261
    63         if (is<InitialContainingBlock>(*containingBlock))
     62        if (containingBlock->isInitialContainingBlock())
    6463            break;
    6564        containingBlock = &containingBlock->containingBlock();

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

    r258847 r258864  
    3333#include "LayoutBox.h"
    3434#include "LayoutContainerBox.h"
    35 #include "LayoutInitialContainingBlock.h"
    3635#include "LayoutState.h"
    3736

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

    r258847 r258864  
    3737#include "IntRect.h"
    3838#include "LayoutContainerBox.h"
    39 #include "LayoutInitialContainingBlock.h"
    4039#include "LayoutState.h"
    4140#include "RenderStyle.h"
    … …  
    147146    if (!layoutState.hasDisplayBox(layoutBox))
    148147        return { };
    149     if (is<Layout::InitialContainingBlock>(layoutBox))
     148    if (layoutBox.isInitialContainingBlock())
    150149        return layoutState.displayBoxForLayoutBox(layoutBox);
    151150
    152151    auto absoluteBox = Box { layoutState.displayBoxForLayoutBox(layoutBox) };
    153     for (auto* containingBlock = &layoutBox.containingBlock(); !is<Layout::InitialContainingBlock>(*containingBlock); containingBlock = &containingBlock->containingBlock())
     152    for (auto* containingBlock = &layoutBox.containingBlock(); !containingBlock->isInitialContainingBlock(); containingBlock = &containingBlock->containingBlock())
    154153        absoluteBox.moveBy(layoutState.displayBoxForLayoutBox(*containingBlock).topLeft());
    155154    return absoluteBox;

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

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

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

    r258847 r258864  
    3131#include "DisplayBox.h"
    3232#include "LayoutContainerBox.h"
    33 #include "LayoutInitialContainingBlock.h"
    3433#include "LayoutPhase.h"
    3534#include "LayoutState.h"
    … …  
    7271{
    7372    // ICB always creates a new (inital) block formatting context.
    74     if (is<ContainerBox>(*this))
     73    if (isInitialContainingBlock())
    7574        return true;
    7675
    … …  
    185184    ASSERT(!Phase::isInTreeBuilding());
    186185    // If we ever end up here with the ICB, we must be doing something not-so-great.
    187     RELEASE_ASSERT(!is<InitialContainingBlock>(*this));
     186    RELEASE_ASSERT(!isInitialContainingBlock());
    188187    // The containing block in which the root element lives is a rectangle called the initial containing block.
    189188    // For other elements, if the element's position is 'relative' or 'static', the containing block is formed by the
    … …  
    194193    if (!isPositioned() || isInFlowPositioned()) {
    195194        auto* ancestor = parent();
    196         for (; !is<InitialContainingBlock>(*ancestor); ancestor = ancestor->parent()) {
     195        for (; !ancestor->isInitialContainingBlock(); ancestor = ancestor->parent()) {
    197196            if (ancestor->isBlockContainerBox() || ancestor->establishesFormattingContext())
    198197                return *ancestor;
    … …  
    203202    if (isFixedPositioned()) {
    204203        auto* ancestor = parent();
    205         for (; !is<InitialContainingBlock>(*ancestor); ancestor = ancestor->parent()) {
     204        for (; !ancestor->isInitialContainingBlock(); ancestor = ancestor->parent()) {
    206205            if (ancestor->style().hasTransform())
    207206                return *ancestor;
    … …  
    212211    if (isOutOfFlowPositioned()) {
    213212        auto* ancestor = parent();
    214         for (; !is<InitialContainingBlock>(*ancestor); ancestor = ancestor->parent()) {
     213        for (; !ancestor->isInitialContainingBlock(); ancestor = ancestor->parent()) {
    215214            if (ancestor->isPositioned() || ancestor->style().hasTransform())
    216215                return *ancestor;
    … …  
    228227    ASSERT(!Phase::isInTreeBuilding());
    229228    // We should never need to ask this question on the ICB.
    230     ASSERT(!is<InitialContainingBlock>(*this));
     229    ASSERT(!isInitialContainingBlock());
    231230    // A box lives in the same formatting context as its containing block unless the containing block establishes a formatting context.
    232231    // However relatively positioned (inflow) inline container lives in the formatting context where its parent lives unless
    … …  
    242241}
    243242
    244 const InitialContainingBlock& Box::initialContainingBlock() const
    245 {
    246     if (is<InitialContainingBlock>(*this))
    247         return downcast<InitialContainingBlock>(*this);
     243const ContainerBox& Box::initialContainingBlock() const
     244{
     245    if (isInitialContainingBlock())
     246        return downcast<ContainerBox>(*this);
    248247
    249248    auto* ancestor = parent();
    250249    for (; ancestor->parent(); ancestor = ancestor->parent()) { }
    251250
    252     return downcast<InitialContainingBlock>(*ancestor);
     251    return *ancestor;
    253252}
    254253
    … …  
    256255{
    257256    ASSERT(formattingContextRoot.establishesFormattingContext());
    258     ASSERT(!is<InitialContainingBlock>(*this));
     257    ASSERT(!isInitialContainingBlock());
    259258    auto* ancestor = &containingBlock();
    260259    while (ancestor) {
    261260        if (ancestor == &formattingContextRoot)
    262261            return true;
    263         if (is<InitialContainingBlock>(*ancestor))
     262        if (ancestor->isInitialContainingBlock())
    264263            return false;
    265264        ancestor = &ancestor->containingBlock();
    … …  
    362361        return true;
    363362    }
    364     if (is<InitialContainingBlock>(*this)) {
     363    if (isInitialContainingBlock()) {
    365364        auto* documentBox = downcast<ContainerBox>(*this).firstChild();
    366365        if (!documentBox || !documentBox->isDocumentBox() || !is<ContainerBox>(documentBox))

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

    r258847 r258864  
    4141
    4242class ContainerBox;
    43 class InitialContainingBlock;
    4443class LayoutState;
    4544class TreeBuilder;
    … …  
    6362
    6463    enum BaseTypeFlag {
    65         BoxFlag                    = 1 << 0,
    66         InlineTextBoxFlag          = 1 << 1,
    67         LineBreakBoxFlag           = 1 << 2,
    68         ReplacedBoxFlag            = 1 << 3,
    69         InitialContainingBlockFlag = 1 << 4,
    70         ContainerBoxFlag           = 1 << 5
     64        BoxFlag                = 1 << 0,
     65        InlineTextBox          = 1 << 1,
     66        LineBreakBox           = 1 << 2,
     67        ReplacedBox            = 1 << 3,
     68        InitialContainingBlock = 1 << 4,
     69        ContainerBoxFlag       = 1 << 5
    7170    };
    7271    typedef unsigned BaseTypeFlags;
    … …  
    9897    const ContainerBox& containingBlock() const;
    9998    const ContainerBox& formattingContextRoot() const;
    100     const InitialContainingBlock& initialContainingBlock() const;
     99    const ContainerBox& initialContainingBlock() const;
    101100
    102101    bool isInFormattingContextOf(const ContainerBox&) const;
    … …  
    111110    bool isInlineTableBox() const;
    112111    bool isBlockContainerBox() const;
    113     bool isInitialContainingBlock() const { return m_baseTypeFlags & InitialContainingBlockFlag; }
     112    bool isInitialContainingBlock() const { return m_baseTypeFlags & InitialContainingBlock; }
    114113
    115114    bool isDocumentBox() const { return m_elementAttributes && m_elementAttributes.value().elementType == ElementType::Document; }
    … …  
    140139
    141140    bool isContainerBox() const { return m_baseTypeFlags & ContainerBoxFlag; }
    142     bool isInlineTextBox() const { return m_baseTypeFlags & InlineTextBoxFlag; }
    143     bool isLineBreakBox() const { return m_baseTypeFlags & LineBreakBoxFlag; }
    144     bool isReplacedBox() const { return m_baseTypeFlags & ReplacedBoxFlag; }
     141    bool isInlineTextBox() const { return m_baseTypeFlags & InlineTextBox; }
     142    bool isLineBreakBox() const { return m_baseTypeFlags & LineBreakBox; }
     143    bool isReplacedBox() const { return m_baseTypeFlags & ReplacedBox; }
    145144
    146145    bool isPaddingApplicable() const;

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

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

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

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

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

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

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

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

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

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