| /* |
| * Copyright (C) 1999 Lars Knoll (knoll@kde.org) |
| * (C) 1999 Antti Koivisto (koivisto@kde.org) |
| * (C) 2005 Allan Sandfeld Jensen (kde@carewolf.com) |
| * (C) 2005, 2006 Samuel Weinig (sam.weinig@gmail.com) |
| * Copyright (C) 2005, 2006, 2007, 2008, 2009 Apple Inc. All rights reserved. |
| * Copyright (C) 2010 Google Inc. All rights reserved. |
| * |
| * 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. |
| * |
| * This library is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| * Library General Public License for more details. |
| * |
| * You should have received a copy of the GNU Library General Public License |
| * along with this library; see the file COPYING.LIB. If not, write to |
| * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, |
| * Boston, MA 02110-1301, USA. |
| * |
| */ |
| |
| #include "core/layout/LayoutBoxModelObject.h" |
| |
| #include "core/frame/FrameView.h" |
| #include "core/frame/LocalFrame.h" |
| #include "core/html/HTMLBodyElement.h" |
| #include "core/layout/ImageQualityController.h" |
| #include "core/layout/LayoutBlock.h" |
| #include "core/layout/LayoutFlexibleBox.h" |
| #include "core/layout/LayoutGeometryMap.h" |
| #include "core/layout/LayoutInline.h" |
| #include "core/layout/LayoutView.h" |
| #include "core/layout/compositing/CompositedLayerMapping.h" |
| #include "core/layout/compositing/PaintLayerCompositor.h" |
| #include "core/paint/ObjectPaintInvalidator.h" |
| #include "core/paint/PaintLayer.h" |
| #include "core/style/ShadowList.h" |
| #include "platform/LengthFunctions.h" |
| #include "platform/geometry/TransformState.h" |
| #include "wtf/PtrUtil.h" |
| |
| namespace blink { |
| |
| class FloatStateForStyleChange { |
| public: |
| static void setWasFloating(LayoutBoxModelObject* boxModelObject, |
| bool wasFloating) { |
| s_wasFloating = wasFloating; |
| s_boxModelObject = boxModelObject; |
| } |
| |
| static bool wasFloating(LayoutBoxModelObject* boxModelObject) { |
| ASSERT(boxModelObject == s_boxModelObject); |
| return s_wasFloating; |
| } |
| |
| private: |
| // Used to store state between styleWillChange and styleDidChange |
| static bool s_wasFloating; |
| static LayoutBoxModelObject* s_boxModelObject; |
| }; |
| |
| bool FloatStateForStyleChange::s_wasFloating = false; |
| LayoutBoxModelObject* FloatStateForStyleChange::s_boxModelObject = nullptr; |
| |
| // The HashMap for storing continuation pointers. |
| // The continuation chain is a singly linked list. As such, the HashMap's value |
| // is the next pointer associated with the key. |
| typedef HashMap<const LayoutBoxModelObject*, LayoutBoxModelObject*> |
| ContinuationMap; |
| static ContinuationMap* continuationMap = nullptr; |
| |
| void LayoutBoxModelObject::setSelectionState(SelectionState state) { |
| if (state == SelectionInside && getSelectionState() != SelectionNone) |
| return; |
| |
| if ((state == SelectionStart && getSelectionState() == SelectionEnd) || |
| (state == SelectionEnd && getSelectionState() == SelectionStart)) |
| LayoutObject::setSelectionState(SelectionBoth); |
| else |
| LayoutObject::setSelectionState(state); |
| |
| // FIXME: We should consider whether it is OK propagating to ancestor |
| // LayoutInlines. This is a workaround for http://webkit.org/b/32123 |
| // The containing block can be null in case of an orphaned tree. |
| LayoutBlock* containingBlock = this->containingBlock(); |
| if (containingBlock && !containingBlock->isLayoutView()) |
| containingBlock->setSelectionState(state); |
| } |
| |
| void LayoutBoxModelObject::contentChanged(ContentChangeType changeType) { |
| if (!hasLayer()) |
| return; |
| |
| layer()->contentChanged(changeType); |
| } |
| |
| bool LayoutBoxModelObject::hasAcceleratedCompositing() const { |
| return view()->compositor()->hasAcceleratedCompositing(); |
| } |
| |
| LayoutBoxModelObject::LayoutBoxModelObject(ContainerNode* node) |
| : LayoutObject(node) {} |
| |
| bool LayoutBoxModelObject::usesCompositedScrolling() const { |
| return hasOverflowClip() && hasLayer() && |
| layer()->getScrollableArea()->usesCompositedScrolling(); |
| } |
| |
| bool LayoutBoxModelObject::hasLocalEquivalentBackground() const { |
| int minBorderWidth = std::min( |
| style()->borderTopWidth(), |
| std::min( |
| style()->borderLeftWidth(), |
| std::min(style()->borderRightWidth(), style()->borderBottomWidth()))); |
| bool outlineOverlapsPaddingBox = style()->outlineOffset() < -minBorderWidth; |
| bool hasCustomScrollbars = false; |
| // TODO(flackr): Detect opaque custom scrollbars which would cover up a |
| // border-box background. |
| if (PaintLayerScrollableArea* scrollableArea = getScrollableArea()) { |
| if ((scrollableArea->horizontalScrollbar() && |
| scrollableArea->horizontalScrollbar()->isCustomScrollbar()) || |
| (scrollableArea->verticalScrollbar() && |
| scrollableArea->verticalScrollbar()->isCustomScrollbar())) { |
| hasCustomScrollbars = true; |
| } |
| } |
| |
| // TODO(flackr): When we correctly clip the scrolling contents layer we can |
| // paint locally equivalent backgrounds into it. https://crbug.com/645957 |
| if (!style()->hasAutoClip()) |
| return false; |
| |
| // TODO(flackr): Remove this when box shadows are still painted correctly when |
| // painting into the composited scrolling contents layer. |
| // https://crbug.com/646464 |
| if (style()->boxShadow()) |
| return false; |
| |
| const FillLayer* layer = &(style()->backgroundLayers()); |
| for (; layer; layer = layer->next()) { |
| if (layer->attachment() == LocalBackgroundAttachment) |
| continue; |
| |
| // If the outline draws inside the border, it intends to draw on top of the |
| // scroller's background, however because it is painted into a layer behind |
| // the scrolling contents layer we avoid auto promoting in this case to |
| // avoid obscuring the outline. |
| // TODO(flackr): Outlines should be drawn on top of the scrolling contents |
| // layer so that they cannot be covered up by composited scrolling contents. |
| if (outlineOverlapsPaddingBox) |
| return false; |
| |
| // Solid color layers with an effective background clip of the padding box |
| // can be treated as local. |
| if (!layer->image() && !layer->next() && |
| resolveColor(CSSPropertyBackgroundColor).alpha() > 0) { |
| EFillBox clip = layer->clip(); |
| if (clip == PaddingFillBox) |
| continue; |
| // A border box can be treated as a padding box if the border is opaque or |
| // there is no border and we don't have custom scrollbars. |
| if (clip == BorderFillBox && !hasCustomScrollbars && |
| (style()->borderTopWidth() == 0 || |
| !resolveColor(CSSPropertyBorderTopColor).hasAlpha()) && |
| (style()->borderLeftWidth() == 0 || |
| !resolveColor(CSSPropertyBorderLeftColor).hasAlpha()) && |
| (style()->borderRightWidth() == 0 || |
| !resolveColor(CSSPropertyBorderRightColor).hasAlpha()) && |
| (style()->borderBottomWidth() == 0 || |
| !resolveColor(CSSPropertyBorderBottomColor).hasAlpha())) { |
| continue; |
| } |
| // A content fill box can be treated as a padding fill box if there is no |
| // padding. |
| if (clip == ContentFillBox && style()->paddingTop().isZero() && |
| style()->paddingLeft().isZero() && style()->paddingRight().isZero() && |
| style()->paddingBottom().isZero()) { |
| continue; |
| } |
| } |
| return false; |
| } |
| return true; |
| } |
| |
| LayoutBoxModelObject::~LayoutBoxModelObject() { |
| // Our layer should have been destroyed and cleared by now |
| ASSERT(!hasLayer()); |
| ASSERT(!m_layer); |
| } |
| |
| void LayoutBoxModelObject::willBeDestroyed() { |
| ImageQualityController::remove(*this); |
| |
| // A continuation of this LayoutObject should be destroyed at subclasses. |
| ASSERT(!continuation()); |
| |
| if (isPositioned()) { |
| // Don't use this->view() because the document's layoutView has been set to |
| // 0 during destruction. |
| if (LocalFrame* frame = this->frame()) { |
| if (FrameView* frameView = frame->view()) { |
| if (style()->hasViewportConstrainedPosition()) |
| frameView->removeViewportConstrainedObject(this); |
| } |
| } |
| } |
| |
| LayoutObject::willBeDestroyed(); |
| |
| destroyLayer(); |
| } |
| |
| void LayoutBoxModelObject::styleWillChange(StyleDifference diff, |
| const ComputedStyle& newStyle) { |
| // This object's layer may cease to be a stacking context, in which case the |
| // paint invalidation container of the children may change. Thus we need to |
| // invalidate paint eagerly for all such children. |
| if (hasLayer() && enclosingLayer()->stackingNode() && |
| enclosingLayer()->stackingNode()->isStackingContext() && |
| !newStyle.isStackingContext()) { |
| // The following disablers are valid because we need to invalidate based on |
| // the current status. |
| DisableCompositingQueryAsserts compositingDisabler; |
| DisablePaintInvalidationStateAsserts paintDisabler; |
| ObjectPaintInvalidator(*this) |
| .invalidatePaintIncludingNonCompositingDescendants(); |
| } |
| |
| FloatStateForStyleChange::setWasFloating(this, isFloating()); |
| |
| if (const ComputedStyle* oldStyle = style()) { |
| if (hasLayer() && diff.needsPaintInvalidationSubtree()) { |
| if (oldStyle->hasAutoClip() != newStyle.hasAutoClip() || |
| oldStyle->clip() != newStyle.clip()) |
| layer()->clipper().clearClipRectsIncludingDescendants(); |
| } |
| } |
| |
| LayoutObject::styleWillChange(diff, newStyle); |
| } |
| |
| DISABLE_CFI_PERF |
| void LayoutBoxModelObject::styleDidChange(StyleDifference diff, |
| const ComputedStyle* oldStyle) { |
| bool hadTransform = hasTransformRelatedProperty(); |
| bool hadLayer = hasLayer(); |
| bool layerWasSelfPainting = hadLayer && layer()->isSelfPaintingLayer(); |
| bool wasFloatingBeforeStyleChanged = |
| FloatStateForStyleChange::wasFloating(this); |
| bool wasHorizontalWritingMode = isHorizontalWritingMode(); |
| |
| LayoutObject::styleDidChange(diff, oldStyle); |
| updateFromStyle(); |
| |
| // When an out-of-flow-positioned element changes its display between block |
| // and inline-block, then an incremental layout on the element's containing |
| // block lays out the element through LayoutPositionedObjects, which skips |
| // laying out the element's parent. |
| // The element's parent needs to relayout so that it calls LayoutBlockFlow:: |
| // setStaticInlinePositionForChild with the out-of-flow-positioned child, so |
| // that when it's laid out, its LayoutBox::computePositionedLogicalWidth/ |
| // Height takes into account its new inline/block position rather than its old |
| // block/inline position. |
| // Position changes and other types of display changes are handled elsewhere. |
| if (oldStyle && isOutOfFlowPositioned() && parent() && |
| (parent() != containingBlock()) && |
| (styleRef().position() == oldStyle->position()) && |
| (styleRef().originalDisplay() != oldStyle->originalDisplay()) && |
| ((styleRef().originalDisplay() == EDisplay::Block) || |
| (styleRef().originalDisplay() == EDisplay::InlineBlock)) && |
| ((oldStyle->originalDisplay() == EDisplay::Block) || |
| (oldStyle->originalDisplay() == EDisplay::InlineBlock))) |
| parent()->setNeedsLayout(LayoutInvalidationReason::ChildChanged, |
| MarkContainerChain); |
| |
| PaintLayerType type = layerTypeRequired(); |
| if (type != NoPaintLayer) { |
| if (!layer() && layerCreationAllowedForSubtree()) { |
| if (wasFloatingBeforeStyleChanged && isFloating()) |
| setChildNeedsLayout(); |
| createLayer(); |
| if (parent() && !needsLayout()) { |
| // FIXME: We should call a specialized version of this function. |
| layer()->updateLayerPositionsAfterLayout(); |
| } |
| } |
| } else if (layer() && layer()->parent()) { |
| PaintLayer* parentLayer = layer()->parent(); |
| // Either a transform wasn't specified or the object doesn't support |
| // transforms, so just null out the bit. |
| setHasTransformRelatedProperty(false); |
| setHasReflection(false); |
| layer()->updateFilters(oldStyle, styleRef()); |
| layer()->updateClipPath(oldStyle, styleRef()); |
| // Calls destroyLayer() which clears m_layer. |
| layer()->removeOnlyThisLayerAfterStyleChange(); |
| if (wasFloatingBeforeStyleChanged && isFloating()) |
| setChildNeedsLayout(); |
| if (hadTransform) |
| setNeedsLayoutAndPrefWidthsRecalcAndFullPaintInvalidation( |
| LayoutInvalidationReason::StyleChange); |
| if (!needsLayout()) { |
| // FIXME: We should call a specialized version of this function. |
| parentLayer->updateLayerPositionsAfterLayout(); |
| } |
| } |
| |
| if (layer()) { |
| layer()->styleDidChange(diff, oldStyle); |
| if (hadLayer && layer()->isSelfPaintingLayer() != layerWasSelfPainting) |
| setChildNeedsLayout(); |
| } |
| |
| if (oldStyle && wasHorizontalWritingMode != isHorizontalWritingMode()) { |
| // Changing the getWritingMode() may change isOrthogonalWritingModeRoot() |
| // of children. Make sure all children are marked/unmarked as orthogonal |
| // writing-mode roots. |
| bool newHorizontalWritingMode = isHorizontalWritingMode(); |
| for (LayoutObject* child = slowFirstChild(); child; |
| child = child->nextSibling()) { |
| if (!child->isBox()) |
| continue; |
| if (newHorizontalWritingMode != child->isHorizontalWritingMode()) |
| toLayoutBox(child)->markOrthogonalWritingModeRoot(); |
| else |
| toLayoutBox(child)->unmarkOrthogonalWritingModeRoot(); |
| } |
| } |
| |
| // Fixed-position is painted using transform. In the case that the object |
| // gets the same layout after changing position property, although no |
| // re-raster (rect-based invalidation) is needed, display items should |
| // still update their paint offset. |
| if (oldStyle) { |
| bool newStyleIsFixedPosition = style()->position() == FixedPosition; |
| bool oldStyleIsFixedPosition = oldStyle->position() == FixedPosition; |
| if (newStyleIsFixedPosition != oldStyleIsFixedPosition) |
| ObjectPaintInvalidator(*this) |
| .invalidateDisplayItemClientsIncludingNonCompositingDescendants( |
| PaintInvalidationStyleChange); |
| } |
| |
| // The used style for body background may change due to computed style change |
| // on the document element because of background stealing. |
| // Refer to backgroundStolenForBeingBody() and |
| // http://www.w3.org/TR/css3-background/#body-background for more info. |
| if (isDocumentElement()) { |
| HTMLBodyElement* body = document().firstBodyElement(); |
| LayoutObject* bodyLayout = body ? body->layoutObject() : nullptr; |
| if (bodyLayout && bodyLayout->isBoxModelObject()) { |
| bool newStoleBodyBackground = toLayoutBoxModelObject(bodyLayout) |
| ->backgroundStolenForBeingBody(style()); |
| bool oldStoleBodyBackground = |
| oldStyle && |
| toLayoutBoxModelObject(bodyLayout) |
| ->backgroundStolenForBeingBody(oldStyle); |
| if (newStoleBodyBackground != oldStoleBodyBackground && |
| bodyLayout->style() && bodyLayout->style()->hasBackground()) { |
| bodyLayout->setShouldDoFullPaintInvalidation(); |
| } |
| } |
| } |
| |
| if (FrameView* frameView = view()->frameView()) { |
| bool newStyleIsViewportConstained = style()->position() == FixedPosition; |
| bool oldStyleIsViewportConstrained = |
| oldStyle && oldStyle->position() == FixedPosition; |
| bool newStyleIsSticky = style()->position() == StickyPosition; |
| bool oldStyleIsSticky = oldStyle && oldStyle->position() == StickyPosition; |
| |
| if (newStyleIsSticky != oldStyleIsSticky) { |
| if (newStyleIsSticky) { |
| // During compositing inputs update we'll have the scroll ancestor |
| // without having to walk up the tree and can compute the sticky |
| // position constraints then. |
| if (layer()) |
| layer()->setNeedsCompositingInputsUpdate(); |
| |
| // TODO(pdr): When slimming paint v2 is enabled, we will need to |
| // invalidate the scroll paint property subtree for this so main thread |
| // scroll reasons are recomputed. |
| } else { |
| // This may get re-added to viewport constrained objects if the object |
| // went from sticky to fixed. |
| frameView->removeViewportConstrainedObject(this); |
| |
| // Remove sticky constraints for this layer. |
| if (layer()) { |
| DisableCompositingQueryAsserts disabler; |
| if (const PaintLayer* ancestorOverflowLayer = |
| layer()->ancestorOverflowLayer()) |
| ancestorOverflowLayer->getScrollableArea() |
| ->invalidateStickyConstraintsFor(layer()); |
| } |
| |
| // TODO(pdr): When slimming paint v2 is enabled, we will need to |
| // invalidate the scroll paint property subtree for this so main thread |
| // scroll reasons are recomputed. |
| } |
| } |
| |
| if (newStyleIsViewportConstained != oldStyleIsViewportConstrained) { |
| if (newStyleIsViewportConstained && layer()) |
| frameView->addViewportConstrainedObject(this); |
| else |
| frameView->removeViewportConstrainedObject(this); |
| } |
| } |
| } |
| |
| void LayoutBoxModelObject::invalidateStickyConstraints() { |
| if (!layer()) |
| return; |
| |
| // This intentionally uses the stale ancestor overflow layer compositing input |
| // as if we have saved constraints for this layer they were saved in the |
| // previous frame. |
| DisableCompositingQueryAsserts disabler; |
| if (const PaintLayer* ancestorOverflowLayer = |
| layer()->ancestorOverflowLayer()) |
| ancestorOverflowLayer->getScrollableArea() |
| ->invalidateAllStickyConstraints(); |
| } |
| |
| void LayoutBoxModelObject::createLayer() { |
| ASSERT(!m_layer); |
| m_layer = makeUnique<PaintLayer>(this); |
| setHasLayer(true); |
| m_layer->insertOnlyThisLayerAfterStyleChange(); |
| } |
| |
| void LayoutBoxModelObject::destroyLayer() { |
| setHasLayer(false); |
| m_layer = nullptr; |
| } |
| |
| bool LayoutBoxModelObject::hasSelfPaintingLayer() const { |
| return m_layer && m_layer->isSelfPaintingLayer(); |
| } |
| |
| PaintLayerScrollableArea* LayoutBoxModelObject::getScrollableArea() const { |
| return m_layer ? m_layer->getScrollableArea() : 0; |
| } |
| |
| void LayoutBoxModelObject::addLayerHitTestRects( |
| LayerHitTestRects& rects, |
| const PaintLayer* currentLayer, |
| const LayoutPoint& layerOffset, |
| const LayoutRect& containerRect) const { |
| if (hasLayer()) { |
| if (isLayoutView()) { |
| // LayoutView is handled with a special fast-path, but it needs to know |
| // the current layer. |
| LayoutObject::addLayerHitTestRects(rects, layer(), LayoutPoint(), |
| LayoutRect()); |
| } else { |
| // Since a LayoutObject never lives outside it's container Layer, we can |
| // switch to marking entire layers instead. This may sometimes mark more |
| // than necessary (when a layer is made of disjoint objects) but in |
| // practice is a significant performance savings. |
| layer()->addLayerHitTestRects(rects); |
| } |
| } else { |
| LayoutObject::addLayerHitTestRects(rects, currentLayer, layerOffset, |
| containerRect); |
| } |
| } |
| |
| DISABLE_CFI_PERF |
| void LayoutBoxModelObject::invalidateTreeIfNeeded( |
| const PaintInvalidationState& paintInvalidationState) { |
| DCHECK(!RuntimeEnabledFeatures::slimmingPaintInvalidationEnabled()); |
| ensureIsReadyForPaintInvalidation(); |
| |
| PaintInvalidationState newPaintInvalidationState(paintInvalidationState, |
| *this); |
| if (!shouldCheckForPaintInvalidation(newPaintInvalidationState)) |
| return; |
| |
| if (mayNeedPaintInvalidationSubtree()) |
| newPaintInvalidationState |
| .setForceSubtreeInvalidationCheckingWithinContainer(); |
| |
| ObjectPaintInvalidator paintInvalidator(*this); |
| LayoutRect previousVisualRect = this->previousVisualRect(); |
| LayoutPoint previousLocation = paintInvalidator.previousLocationInBacking(); |
| PaintInvalidationReason reason = |
| invalidatePaintIfNeeded(newPaintInvalidationState); |
| |
| if (previousLocation != paintInvalidator.previousLocationInBacking()) { |
| newPaintInvalidationState |
| .setForceSubtreeInvalidationCheckingWithinContainer(); |
| } |
| |
| // TODO(wangxianzhu): This is a workaround for crbug.com/490725. We don't have |
| // enough saved information to do accurate check of clipping change. Will |
| // remove when we remove rect-based paint invalidation. |
| if (!RuntimeEnabledFeatures::slimmingPaintV2Enabled() && |
| previousVisualRect != this->previousVisualRect() && |
| !usesCompositedScrolling() |
| // Note that isLayoutView() below becomes unnecessary after the launch of |
| // root layer scrolling. |
| && (hasOverflowClip() || isLayoutView())) { |
| newPaintInvalidationState |
| .setForceSubtreeInvalidationRectUpdateWithinContainer(); |
| } |
| |
| newPaintInvalidationState.updateForChildren(reason); |
| invalidatePaintOfSubtreesIfNeeded(newPaintInvalidationState); |
| |
| clearPaintInvalidationFlags(); |
| } |
| |
| void LayoutBoxModelObject::addOutlineRectsForNormalChildren( |
| Vector<LayoutRect>& rects, |
| const LayoutPoint& additionalOffset, |
| IncludeBlockVisualOverflowOrNot includeBlockOverflows) const { |
| for (LayoutObject* child = slowFirstChild(); child; |
| child = child->nextSibling()) { |
| // Outlines of out-of-flow positioned descendants are handled in |
| // LayoutBlock::addOutlineRects(). |
| if (child->isOutOfFlowPositioned()) |
| continue; |
| |
| // Outline of an element continuation or anonymous block continuation is |
| // added when we iterate the continuation chain. |
| // See LayoutBlock::addOutlineRects() and LayoutInline::addOutlineRects(). |
| if (child->isElementContinuation() || |
| (child->isLayoutBlockFlow() && |
| toLayoutBlockFlow(child)->isAnonymousBlockContinuation())) |
| continue; |
| |
| addOutlineRectsForDescendant(*child, rects, additionalOffset, |
| includeBlockOverflows); |
| } |
| } |
| |
| void LayoutBoxModelObject::addOutlineRectsForDescendant( |
| const LayoutObject& descendant, |
| Vector<LayoutRect>& rects, |
| const LayoutPoint& additionalOffset, |
| IncludeBlockVisualOverflowOrNot includeBlockOverflows) const { |
| if (descendant.isText() || descendant.isListMarker()) |
| return; |
| |
| if (descendant.hasLayer()) { |
| Vector<LayoutRect> layerOutlineRects; |
| descendant.addOutlineRects(layerOutlineRects, LayoutPoint(), |
| includeBlockOverflows); |
| descendant.localToAncestorRects(layerOutlineRects, this, LayoutPoint(), |
| additionalOffset); |
| rects.appendVector(layerOutlineRects); |
| return; |
| } |
| |
| if (descendant.isBox()) { |
| descendant.addOutlineRects( |
| rects, additionalOffset + toLayoutBox(descendant).locationOffset(), |
| includeBlockOverflows); |
| return; |
| } |
| |
| if (descendant.isLayoutInline()) { |
| // As an optimization, an ancestor has added rects for its line boxes |
| // covering descendants' line boxes, so descendants don't need to add line |
| // boxes again. For example, if the parent is a LayoutBlock, it adds rects |
| // for its RootOutlineBoxes which cover the line boxes of this LayoutInline. |
| // So the LayoutInline needs to add rects for children and continuations |
| // only. |
| toLayoutInline(descendant) |
| .addOutlineRectsForChildrenAndContinuations(rects, additionalOffset, |
| includeBlockOverflows); |
| return; |
| } |
| |
| descendant.addOutlineRects(rects, additionalOffset, includeBlockOverflows); |
| } |
| |
| bool LayoutBoxModelObject::hasNonEmptyLayoutSize() const { |
| for (const LayoutBoxModelObject* root = this; root; |
| root = root->continuation()) { |
| for (const LayoutObject* object = root; object; |
| object = object->nextInPreOrder(object)) { |
| if (object->isBox()) { |
| const LayoutBox& box = toLayoutBox(*object); |
| if (box.logicalHeight() && box.logicalWidth()) |
| return true; |
| } else if (object->isLayoutInline()) { |
| const LayoutInline& layoutInline = toLayoutInline(*object); |
| if (!layoutInline.linesBoundingBox().isEmpty()) |
| return true; |
| } else { |
| ASSERT(object->isText()); |
| } |
| } |
| } |
| return false; |
| } |
| |
| void LayoutBoxModelObject::absoluteQuadsForSelf( |
| Vector<FloatQuad>& quads) const { |
| NOTREACHED(); |
| } |
| |
| void LayoutBoxModelObject::absoluteQuads(Vector<FloatQuad>& quads) const { |
| absoluteQuadsForSelf(quads); |
| |
| // Iterate over continuations, avoiding recursion in case there are |
| // many of them. See crbug.com/653767. |
| for (const LayoutBoxModelObject* continuationObject = this->continuation(); |
| continuationObject; |
| continuationObject = continuationObject->continuation()) { |
| DCHECK(continuationObject->isLayoutInline() || |
| (continuationObject->isLayoutBlockFlow() && |
| toLayoutBlockFlow(continuationObject) |
| ->isAnonymousBlockContinuation())); |
| continuationObject->absoluteQuadsForSelf(quads); |
| } |
| } |
| |
| void LayoutBoxModelObject::updateFromStyle() { |
| const ComputedStyle& styleToUse = styleRef(); |
| setHasBoxDecorationBackground(styleToUse.hasBoxDecorationBackground()); |
| setInline(styleToUse.isDisplayInlineType()); |
| setPositionState(styleToUse.position()); |
| setHorizontalWritingMode(styleToUse.isHorizontalWritingMode()); |
| } |
| |
| static inline bool isOutOfFlowPositionedWithImplicitHeight( |
| const LayoutBoxModelObject* child) { |
| return child->isOutOfFlowPositioned() && |
| !child->style()->logicalTop().isAuto() && |
| !child->style()->logicalBottom().isAuto(); |
| } |
| |
| LayoutBlock* LayoutBoxModelObject::containingBlockForAutoHeightDetection( |
| Length logicalHeight) const { |
| // For percentage heights: The percentage is calculated with respect to the |
| // height of the generated box's containing block. If the height of the |
| // containing block is not specified explicitly (i.e., it depends on content |
| // height), and this element is not absolutely positioned, the used height is |
| // calculated as if 'auto' was specified. |
| if (!logicalHeight.isPercentOrCalc() || isOutOfFlowPositioned()) |
| return nullptr; |
| |
| // Anonymous block boxes are ignored when resolving percentage values that |
| // would refer to it: the closest non-anonymous ancestor box is used instead. |
| LayoutBlock* cb = containingBlock(); |
| while (cb->isAnonymous()) |
| cb = cb->containingBlock(); |
| |
| // Matching LayoutBox::percentageLogicalHeightIsResolvableFromBlock() by |
| // ignoring table cell's attribute value, where it says that table cells |
| // violate what the CSS spec says to do with heights. Basically we don't care |
| // if the cell specified a height or not. |
| if (cb->isTableCell()) |
| return nullptr; |
| |
| // Match LayoutBox::availableLogicalHeightUsing by special casing the layout |
| // view. The available height is taken from the frame. |
| if (cb->isLayoutView()) |
| return nullptr; |
| |
| if (isOutOfFlowPositionedWithImplicitHeight(cb)) |
| return nullptr; |
| |
| return cb; |
| } |
| |
| bool LayoutBoxModelObject::hasAutoHeightOrContainingBlockWithAutoHeight() |
| const { |
| // TODO(rego): Check if we can somehow reuse LayoutBlock:: |
| // availableLogicalHeightForPercentageComputation() (see crbug.com/635655). |
| const LayoutBox* thisBox = isBox() ? toLayoutBox(this) : nullptr; |
| Length logicalHeightLength = style()->logicalHeight(); |
| LayoutBlock* cb = containingBlockForAutoHeightDetection(logicalHeightLength); |
| if (logicalHeightLength.isPercentOrCalc() && cb && isBox()) |
| cb->addPercentHeightDescendant(const_cast<LayoutBox*>(toLayoutBox(this))); |
| if (thisBox && thisBox->isFlexItem()) { |
| LayoutFlexibleBox& flexBox = toLayoutFlexibleBox(*parent()); |
| if (flexBox.childLogicalHeightForPercentageResolution(*thisBox) != |
| LayoutUnit(-1)) |
| return false; |
| } |
| if (thisBox && thisBox->isGridItem() && |
| thisBox->hasOverrideContainingBlockLogicalHeight()) |
| return false; |
| if (logicalHeightLength.isAuto() && |
| !isOutOfFlowPositionedWithImplicitHeight(this)) |
| return true; |
| |
| if (document().inQuirksMode()) |
| return false; |
| |
| if (cb) |
| return !cb->hasDefiniteLogicalHeight(); |
| |
| return false; |
| } |
| |
| LayoutSize LayoutBoxModelObject::relativePositionOffset() const { |
| LayoutSize offset = accumulateInFlowPositionOffsets(); |
| |
| LayoutBlock* containingBlock = this->containingBlock(); |
| |
| // Objects that shrink to avoid floats normally use available line width when |
| // computing containing block width. However in the case of relative |
| // positioning using percentages, we can't do this. The offset should always |
| // be resolved using the available width of the containing block. Therefore we |
| // don't use containingBlockLogicalWidthForContent() here, but instead |
| // explicitly call availableWidth on our containing block. |
| if (!style()->left().isAuto()) { |
| if (!style()->right().isAuto() && |
| !containingBlock->style()->isLeftToRightDirection()) |
| offset.setWidth( |
| -valueForLength(style()->right(), containingBlock->availableWidth())); |
| else |
| offset.expand( |
| valueForLength(style()->left(), containingBlock->availableWidth()), |
| LayoutUnit()); |
| } else if (!style()->right().isAuto()) { |
| offset.expand( |
| -valueForLength(style()->right(), containingBlock->availableWidth()), |
| LayoutUnit()); |
| } |
| |
| // If the containing block of a relatively positioned element does not specify |
| // a height, a percentage top or bottom offset should be resolved as auto. |
| // An exception to this is if the containing block has the WinIE quirk where |
| // <html> and <body> assume the size of the viewport. In this case, calculate |
| // the percent offset based on this height. |
| // See <https://bugs.webkit.org/show_bug.cgi?id=26396>. |
| if (!style()->top().isAuto() && |
| (!containingBlock->hasAutoHeightOrContainingBlockWithAutoHeight() || |
| !style()->top().isPercentOrCalc() || |
| containingBlock->stretchesToViewport())) |
| offset.expand( |
| LayoutUnit(), |
| valueForLength(style()->top(), containingBlock->availableHeight())); |
| |
| else if (!style()->bottom().isAuto() && |
| (!containingBlock->hasAutoHeightOrContainingBlockWithAutoHeight() || |
| !style()->bottom().isPercentOrCalc() || |
| containingBlock->stretchesToViewport())) |
| offset.expand( |
| LayoutUnit(), |
| -valueForLength(style()->bottom(), containingBlock->availableHeight())); |
| |
| return offset; |
| } |
| |
| void LayoutBoxModelObject::updateStickyPositionConstraints() const { |
| const FloatSize constrainingSize = computeStickyConstrainingRect().size(); |
| |
| PaintLayerScrollableArea* scrollableArea = |
| layer()->ancestorOverflowLayer()->getScrollableArea(); |
| StickyPositionScrollingConstraints constraints; |
| FloatSize skippedContainersOffset; |
| LayoutBlock* containingBlock = this->containingBlock(); |
| // Skip anonymous containing blocks. |
| while (containingBlock->isAnonymous()) { |
| skippedContainersOffset += |
| toFloatSize(FloatPoint(containingBlock->frameRect().location())); |
| containingBlock = containingBlock->containingBlock(); |
| } |
| LayoutBox* scrollAncestor = |
| layer()->ancestorOverflowLayer()->isRootLayer() |
| ? nullptr |
| : toLayoutBox(layer()->ancestorOverflowLayer()->layoutObject()); |
| |
| LayoutUnit maxContainerWidth = |
| containingBlock->isLayoutView() |
| ? containingBlock->logicalWidth() |
| : containingBlock->containingBlockLogicalWidthForContent(); |
| // Sticky positioned element ignore any override logical width on the |
| // containing block, as they don't call containingBlockLogicalWidthForContent. |
| // It's unclear whether this is totally fine. |
| // Compute the container-relative area within which the sticky element is |
| // allowed to move. |
| LayoutUnit maxWidth = containingBlock->availableLogicalWidth(); |
| |
| // Map the containing block to the inner corner of the scroll ancestor without |
| // transforms. |
| FloatRect scrollContainerRelativePaddingBoxRect( |
| containingBlock->layoutOverflowRect()); |
| FloatSize scrollContainerBorderOffset; |
| if (scrollAncestor) { |
| scrollContainerBorderOffset = |
| FloatSize(scrollAncestor->borderLeft(), scrollAncestor->borderTop()); |
| } |
| if (containingBlock != scrollAncestor) { |
| FloatQuad localQuad(FloatRect(containingBlock->paddingBoxRect())); |
| TransformState transformState(TransformState::ApplyTransformDirection, |
| localQuad.boundingBox().center(), localQuad); |
| containingBlock->mapLocalToAncestor(scrollAncestor, transformState, |
| ApplyContainerFlip); |
| transformState.flatten(); |
| scrollContainerRelativePaddingBoxRect = |
| transformState.lastPlanarQuad().boundingBox(); |
| |
| // The sticky position constraint rects should be independent of the current |
| // scroll position, so after mapping we add in the scroll position to get |
| // the container's position within the ancestor scroller's unscrolled layout |
| // overflow. |
| ScrollOffset scrollOffset( |
| scrollAncestor |
| ? toFloatSize(scrollAncestor->getScrollableArea()->scrollPosition()) |
| : FloatSize()); |
| scrollContainerRelativePaddingBoxRect.move(scrollOffset); |
| } |
| // Remove top-left border offset from overflow scroller. |
| scrollContainerRelativePaddingBoxRect.move(-scrollContainerBorderOffset); |
| |
| LayoutRect scrollContainerRelativeContainingBlockRect( |
| scrollContainerRelativePaddingBoxRect); |
| // This is removing the padding of the containing block's overflow rect to get |
| // the flow box rectangle and removing the margin of the sticky element to |
| // ensure that space between the sticky element and its containing flow box. |
| // It is an open issue whether the margin should collapse. |
| // See https://www.w3.org/TR/css-position-3/#sticky-pos |
| scrollContainerRelativeContainingBlockRect.contractEdges( |
| minimumValueForLength(containingBlock->style()->paddingTop(), |
| maxContainerWidth) + |
| minimumValueForLength(style()->marginTop(), maxWidth), |
| minimumValueForLength(containingBlock->style()->paddingRight(), |
| maxContainerWidth) + |
| minimumValueForLength(style()->marginRight(), maxWidth), |
| minimumValueForLength(containingBlock->style()->paddingBottom(), |
| maxContainerWidth) + |
| minimumValueForLength(style()->marginBottom(), maxWidth), |
| minimumValueForLength(containingBlock->style()->paddingLeft(), |
| maxContainerWidth) + |
| minimumValueForLength(style()->marginLeft(), maxWidth)); |
| |
| constraints.setScrollContainerRelativeContainingBlockRect( |
| FloatRect(scrollContainerRelativeContainingBlockRect)); |
| |
| FloatRect stickyBoxRect = |
| isLayoutInline() ? FloatRect(toLayoutInline(this)->linesBoundingBox()) |
| : FloatRect(toLayoutBox(this)->frameRect()); |
| FloatRect flippedStickyBoxRect = stickyBoxRect; |
| containingBlock->flipForWritingMode(flippedStickyBoxRect); |
| FloatPoint stickyLocation = |
| flippedStickyBoxRect.location() + skippedContainersOffset; |
| |
| // The scrollContainerRelativePaddingBoxRect's position is the padding box so |
| // we need to remove the border when finding the position of the sticky box |
| // within the scroll ancestor if the container is not our scroll ancestor. If |
| // the container is our scroll ancestor, we also need to remove the border |
| // box because we want the position from within the scroller border. |
| FloatSize containerBorderOffset(containingBlock->borderLeft(), |
| containingBlock->borderTop()); |
| stickyLocation -= containerBorderOffset; |
| constraints.setScrollContainerRelativeStickyBoxRect( |
| FloatRect(scrollContainerRelativePaddingBoxRect.location() + |
| toFloatSize(stickyLocation), |
| flippedStickyBoxRect.size())); |
| |
| // We skip the right or top sticky offset if there is not enough space to |
| // honor both the left/right or top/bottom offsets. |
| LayoutUnit horizontalOffsets = |
| minimumValueForLength(style()->right(), |
| LayoutUnit(constrainingSize.width())) + |
| minimumValueForLength(style()->left(), |
| LayoutUnit(constrainingSize.width())); |
| bool skipRight = false; |
| bool skipLeft = false; |
| if (!style()->left().isAuto() && !style()->right().isAuto()) { |
| if (horizontalOffsets > |
| scrollContainerRelativeContainingBlockRect.width() || |
| horizontalOffsets + scrollContainerRelativeContainingBlockRect.width() > |
| constrainingSize.width()) { |
| skipRight = style()->isLeftToRightDirection(); |
| skipLeft = !skipRight; |
| } |
| } |
| |
| if (!style()->left().isAuto() && !skipLeft) { |
| constraints.setLeftOffset(minimumValueForLength( |
| style()->left(), LayoutUnit(constrainingSize.width()))); |
| constraints.addAnchorEdge( |
| StickyPositionScrollingConstraints::AnchorEdgeLeft); |
| } |
| |
| if (!style()->right().isAuto() && !skipRight) { |
| constraints.setRightOffset(minimumValueForLength( |
| style()->right(), LayoutUnit(constrainingSize.width()))); |
| constraints.addAnchorEdge( |
| StickyPositionScrollingConstraints::AnchorEdgeRight); |
| } |
| |
| bool skipBottom = false; |
| // TODO(flackr): Exclude top or bottom edge offset depending on the writing |
| // mode when related sections are fixed in spec. |
| // See http://lists.w3.org/Archives/Public/www-style/2014May/0286.html |
| LayoutUnit verticalOffsets = |
| minimumValueForLength(style()->top(), |
| LayoutUnit(constrainingSize.height())) + |
| minimumValueForLength(style()->bottom(), |
| LayoutUnit(constrainingSize.height())); |
| if (!style()->top().isAuto() && !style()->bottom().isAuto()) { |
| if (verticalOffsets > scrollContainerRelativeContainingBlockRect.height() || |
| verticalOffsets + scrollContainerRelativeContainingBlockRect.height() > |
| constrainingSize.height()) { |
| skipBottom = true; |
| } |
| } |
| |
| if (!style()->top().isAuto()) { |
| constraints.setTopOffset(minimumValueForLength( |
| style()->top(), LayoutUnit(constrainingSize.height()))); |
| constraints.addAnchorEdge( |
| StickyPositionScrollingConstraints::AnchorEdgeTop); |
| } |
| |
| if (!style()->bottom().isAuto() && !skipBottom) { |
| constraints.setBottomOffset(minimumValueForLength( |
| style()->bottom(), LayoutUnit(constrainingSize.height()))); |
| constraints.addAnchorEdge( |
| StickyPositionScrollingConstraints::AnchorEdgeBottom); |
| } |
| scrollableArea->stickyConstraintsMap().set(layer(), constraints); |
| } |
| |
| FloatRect LayoutBoxModelObject::computeStickyConstrainingRect() const { |
| if (layer()->ancestorOverflowLayer()->isRootLayer()) |
| return view()->frameView()->visibleContentRect(); |
| |
| LayoutBox* enclosingClippingBox = |
| toLayoutBox(layer()->ancestorOverflowLayer()->layoutObject()); |
| FloatRect constrainingRect; |
| constrainingRect = |
| FloatRect(enclosingClippingBox->overflowClipRect(LayoutPoint(DoublePoint( |
| enclosingClippingBox->getScrollableArea()->scrollPosition())))); |
| constrainingRect.move( |
| -enclosingClippingBox->borderLeft() + enclosingClippingBox->paddingLeft(), |
| -enclosingClippingBox->borderTop() + enclosingClippingBox->paddingTop()); |
| constrainingRect.contract( |
| FloatSize(enclosingClippingBox->paddingLeft() + |
| enclosingClippingBox->paddingRight(), |
| enclosingClippingBox->paddingTop() + |
| enclosingClippingBox->paddingBottom())); |
| return constrainingRect; |
| } |
| |
| LayoutSize LayoutBoxModelObject::stickyPositionOffset() const { |
| const PaintLayer* ancestorOverflowLayer = layer()->ancestorOverflowLayer(); |
| // TODO: Force compositing input update if we ask for offset before |
| // compositing inputs have been computed? |
| if (!ancestorOverflowLayer) |
| return LayoutSize(); |
| FloatRect constrainingRect = computeStickyConstrainingRect(); |
| PaintLayerScrollableArea* scrollableArea = |
| ancestorOverflowLayer->getScrollableArea(); |
| |
| // The sticky offset is physical, so we can just return the delta computed in |
| // absolute coords (though it may be wrong with transforms). |
| // TODO: Force compositing input update if we ask for offset with stale |
| // compositing inputs. |
| if (!scrollableArea->stickyConstraintsMap().contains(layer())) |
| return LayoutSize(); |
| return LayoutSize( |
| scrollableArea->stickyConstraintsMap().get(layer()).computeStickyOffset( |
| constrainingRect)); |
| } |
| |
| LayoutPoint LayoutBoxModelObject::adjustedPositionRelativeTo( |
| const LayoutPoint& startPoint, |
| const Element* offsetParent) const { |
| // If the element is the HTML body element or doesn't have a parent |
| // return 0 and stop this algorithm. |
| if (isBody() || !parent()) |
| return LayoutPoint(); |
| |
| LayoutPoint referencePoint = startPoint; |
| |
| // If the offsetParent is null, return the distance between the canvas origin |
| // and the left/top border edge of the element and stop this algorithm. |
| if (!offsetParent) |
| return referencePoint; |
| |
| if (const LayoutBoxModelObject* offsetParentObject = |
| offsetParent->layoutBoxModelObject()) { |
| if (!isOutOfFlowPositioned()) { |
| if (isInFlowPositioned()) |
| referencePoint.move(offsetForInFlowPosition()); |
| |
| // Note that we may fail to find |offsetParent| while walking the |
| // container chain, if |offsetParent| is an inline split into |
| // continuations: <body style="display:inline;" id="offsetParent"> |
| // <div id="this"> |
| // This is why we have to do a nullptr check here. |
| for (const LayoutObject* current = container(); |
| current && current->node() != offsetParent; |
| current = current->container()) { |
| // FIXME: What are we supposed to do inside SVG content? |
| referencePoint.move(current->columnOffset(referencePoint)); |
| if (current->isBox() && !current->isTableRow()) |
| referencePoint.moveBy(toLayoutBox(current)->topLeftLocation()); |
| } |
| |
| if (offsetParentObject->isBox() && offsetParentObject->isBody() && |
| !offsetParentObject->isPositioned()) { |
| referencePoint.moveBy( |
| toLayoutBox(offsetParentObject)->topLeftLocation()); |
| } |
| } |
| |
| if (offsetParentObject->isLayoutInline()) { |
| const LayoutInline* inlineParent = toLayoutInline(offsetParentObject); |
| |
| if (isBox() && style()->position() == AbsolutePosition && |
| inlineParent->isInFlowPositioned()) { |
| // Offset for absolute elements with inline parent is a special |
| // case in the CSS spec |
| referencePoint += |
| inlineParent->offsetForInFlowPositionedInline(*toLayoutBox(this)); |
| } |
| |
| referencePoint -= inlineParent->firstLineBoxTopLeft(); |
| } |
| |
| if (offsetParentObject->isBox() && !offsetParentObject->isBody()) { |
| referencePoint.move(-toLayoutBox(offsetParentObject)->borderLeft(), |
| -toLayoutBox(offsetParentObject)->borderTop()); |
| } |
| } |
| |
| return referencePoint; |
| } |
| |
| LayoutSize LayoutBoxModelObject::offsetForInFlowPosition() const { |
| if (isRelPositioned()) |
| return relativePositionOffset(); |
| |
| if (isStickyPositioned()) |
| return stickyPositionOffset(); |
| |
| return LayoutSize(); |
| } |
| |
| LayoutUnit LayoutBoxModelObject::offsetLeft(const Element* parent) const { |
| // Note that LayoutInline and LayoutBox override this to pass a different |
| // startPoint to adjustedPositionRelativeTo. |
| return adjustedPositionRelativeTo(LayoutPoint(), parent).x(); |
| } |
| |
| LayoutUnit LayoutBoxModelObject::offsetTop(const Element* parent) const { |
| // Note that LayoutInline and LayoutBox override this to pass a different |
| // startPoint to adjustedPositionRelativeTo. |
| return adjustedPositionRelativeTo(LayoutPoint(), parent).y(); |
| } |
| |
| int LayoutBoxModelObject::pixelSnappedOffsetWidth(const Element* parent) const { |
| return snapSizeToPixel(offsetWidth(), offsetLeft(parent)); |
| } |
| |
| int LayoutBoxModelObject::pixelSnappedOffsetHeight( |
| const Element* parent) const { |
| return snapSizeToPixel(offsetHeight(), offsetTop(parent)); |
| } |
| |
| LayoutUnit LayoutBoxModelObject::computedCSSPadding( |
| const Length& padding) const { |
| LayoutUnit w; |
| if (padding.isPercentOrCalc()) |
| w = containingBlockLogicalWidthForContent(); |
| return minimumValueForLength(padding, w); |
| } |
| |
| LayoutUnit LayoutBoxModelObject::containingBlockLogicalWidthForContent() const { |
| return containingBlock()->availableLogicalWidth(); |
| } |
| |
| LayoutBoxModelObject* LayoutBoxModelObject::continuation() const { |
| return (!continuationMap) ? nullptr : continuationMap->get(this); |
| } |
| |
| void LayoutBoxModelObject::setContinuation(LayoutBoxModelObject* continuation) { |
| if (continuation) { |
| ASSERT(continuation->isLayoutInline() || continuation->isLayoutBlockFlow()); |
| if (!continuationMap) |
| continuationMap = new ContinuationMap; |
| continuationMap->set(this, continuation); |
| } else { |
| if (continuationMap) |
| continuationMap->remove(this); |
| } |
| } |
| |
| void LayoutBoxModelObject::computeLayerHitTestRects( |
| LayerHitTestRects& rects) const { |
| LayoutObject::computeLayerHitTestRects(rects); |
| |
| // If there is a continuation then we need to consult it here, since this is |
| // the root of the tree walk and it wouldn't otherwise get picked up. |
| // Continuations should always be siblings in the tree, so any others should |
| // get picked up already by the tree walk. |
| if (continuation()) |
| continuation()->computeLayerHitTestRects(rects); |
| } |
| |
| LayoutRect LayoutBoxModelObject::localCaretRectForEmptyElement( |
| LayoutUnit width, |
| LayoutUnit textIndentOffset) { |
| DCHECK(!slowFirstChild() || slowFirstChild()->isPseudoElement()); |
| |
| // FIXME: This does not take into account either :first-line or :first-letter |
| // However, as soon as some content is entered, the line boxes will be |
| // constructed and this kludge is not called any more. So only the caret size |
| // of an empty :first-line'd block is wrong. I think we can live with that. |
| const ComputedStyle& currentStyle = firstLineStyleRef(); |
| |
| enum CaretAlignment { AlignLeft, AlignRight, AlignCenter }; |
| |
| CaretAlignment alignment = AlignLeft; |
| |
| switch (currentStyle.textAlign()) { |
| case ETextAlign::Left: |
| case ETextAlign::WebkitLeft: |
| break; |
| case ETextAlign::Center: |
| case ETextAlign::WebkitCenter: |
| alignment = AlignCenter; |
| break; |
| case ETextAlign::Right: |
| case ETextAlign::WebkitRight: |
| alignment = AlignRight; |
| break; |
| case ETextAlign::Justify: |
| case ETextAlign::Start: |
| if (!currentStyle.isLeftToRightDirection()) |
| alignment = AlignRight; |
| break; |
| case ETextAlign::End: |
| if (currentStyle.isLeftToRightDirection()) |
| alignment = AlignRight; |
| break; |
| } |
| |
| LayoutUnit x = borderLeft() + paddingLeft(); |
| LayoutUnit maxX = width - borderRight() - paddingRight(); |
| |
| switch (alignment) { |
| case AlignLeft: |
| if (currentStyle.isLeftToRightDirection()) |
| x += textIndentOffset; |
| break; |
| case AlignCenter: |
| x = (x + maxX) / 2; |
| if (currentStyle.isLeftToRightDirection()) |
| x += textIndentOffset / 2; |
| else |
| x -= textIndentOffset / 2; |
| break; |
| case AlignRight: |
| x = maxX - caretWidth(); |
| if (!currentStyle.isLeftToRightDirection()) |
| x -= textIndentOffset; |
| break; |
| } |
| x = std::min(x, (maxX - caretWidth()).clampNegativeToZero()); |
| |
| const Font& font = style()->font(); |
| const SimpleFontData* fontData = font.primaryFont(); |
| LayoutUnit height; |
| // crbug.com/595692 This check should not be needed but sometimes |
| // primaryFont is null. |
| if (fontData) |
| height = LayoutUnit(fontData->getFontMetrics().height()); |
| LayoutUnit verticalSpace = |
| lineHeight(true, currentStyle.isHorizontalWritingMode() ? HorizontalLine |
| : VerticalLine, |
| PositionOfInteriorLineBoxes) - |
| height; |
| LayoutUnit y = paddingTop() + borderTop() + (verticalSpace / 2); |
| return currentStyle.isHorizontalWritingMode() |
| ? LayoutRect(x, y, caretWidth(), height) |
| : LayoutRect(y, x, height, caretWidth()); |
| } |
| |
| const LayoutObject* LayoutBoxModelObject::pushMappingToContainer( |
| const LayoutBoxModelObject* ancestorToStopAt, |
| LayoutGeometryMap& geometryMap) const { |
| ASSERT(ancestorToStopAt != this); |
| |
| bool ancestorSkipped; |
| LayoutObject* container = this->container(ancestorToStopAt, &ancestorSkipped); |
| if (!container) |
| return nullptr; |
| |
| bool isInline = isLayoutInline(); |
| bool isFixedPos = !isInline && style()->position() == FixedPosition; |
| bool containsFixedPosition = canContainFixedPositionObjects(); |
| |
| LayoutSize adjustmentForSkippedAncestor; |
| if (ancestorSkipped) { |
| // There can't be a transform between paintInvalidationContainer and |
| // ancestorToStopAt, because transforms create containers, so it should be |
| // safe to just subtract the delta between the ancestor and |
| // ancestorToStopAt. |
| adjustmentForSkippedAncestor = |
| -ancestorToStopAt->offsetFromAncestorContainer(container); |
| } |
| |
| LayoutSize containerOffset = offsetFromContainer(container); |
| bool offsetDependsOnPoint; |
| if (isLayoutFlowThread()) { |
| containerOffset += columnOffset(LayoutPoint()); |
| offsetDependsOnPoint = true; |
| } else { |
| offsetDependsOnPoint = |
| container->style()->isFlippedBlocksWritingMode() && container->isBox(); |
| } |
| |
| bool preserve3D = container->style()->preserves3D() || style()->preserves3D(); |
| GeometryInfoFlags flags = 0; |
| if (preserve3D) |
| flags |= AccumulatingTransform; |
| if (offsetDependsOnPoint) |
| flags |= IsNonUniform; |
| if (isFixedPos) |
| flags |= IsFixedPosition; |
| if (containsFixedPosition) |
| flags |= ContainsFixedPosition; |
| if (shouldUseTransformFromContainer(container)) { |
| TransformationMatrix t; |
| getTransformFromContainer(container, containerOffset, t); |
| t.translateRight(adjustmentForSkippedAncestor.width().toFloat(), |
| adjustmentForSkippedAncestor.height().toFloat()); |
| geometryMap.push(this, t, flags, LayoutSize()); |
| } else { |
| containerOffset += adjustmentForSkippedAncestor; |
| geometryMap.push(this, containerOffset, flags, LayoutSize()); |
| } |
| |
| return ancestorSkipped ? ancestorToStopAt : container; |
| } |
| |
| void LayoutBoxModelObject::moveChildTo(LayoutBoxModelObject* toBoxModelObject, |
| LayoutObject* child, |
| LayoutObject* beforeChild, |
| bool fullRemoveInsert) { |
| // We assume that callers have cleared their positioned objects list for child |
| // moves (!fullRemoveInsert) so the positioned layoutObject maps don't become |
| // stale. It would be too slow to do the map lookup on each call. |
| ASSERT(!fullRemoveInsert || !isLayoutBlock() || |
| !toLayoutBlock(this)->hasPositionedObjects()); |
| |
| ASSERT(this == child->parent()); |
| ASSERT(!beforeChild || toBoxModelObject == beforeChild->parent()); |
| |
| // If a child is moving from a block-flow to an inline-flow parent then any |
| // floats currently intruding into the child can no longer do so. This can |
| // happen if a block becomes floating or out-of-flow and is moved to an |
| // anonymous block. Remove all floats from their float-lists immediately as |
| // markAllDescendantsWithFloatsForLayout won't attempt to remove floats from |
| // parents that have inline-flow if we try later. |
| if (child->isLayoutBlockFlow() && toBoxModelObject->childrenInline() && |
| !childrenInline()) { |
| toLayoutBlockFlow(child)->removeFloatingObjectsFromDescendants(); |
| ASSERT(!toLayoutBlockFlow(child)->containsFloats()); |
| } |
| |
| if (fullRemoveInsert && isLayoutBlock() && child->isBox()) |
| toLayoutBox(child)->removeFromPercentHeightContainer(); |
| |
| if (fullRemoveInsert && (toBoxModelObject->isLayoutBlock() || |
| toBoxModelObject->isLayoutInline())) { |
| // Takes care of adding the new child correctly if toBlock and fromBlock |
| // have different kind of children (block vs inline). |
| toBoxModelObject->addChild(virtualChildren()->removeChildNode(this, child), |
| beforeChild); |
| } else { |
| toBoxModelObject->virtualChildren()->insertChildNode( |
| toBoxModelObject, |
| virtualChildren()->removeChildNode(this, child, fullRemoveInsert), |
| beforeChild, fullRemoveInsert); |
| } |
| } |
| |
| void LayoutBoxModelObject::moveChildrenTo( |
| LayoutBoxModelObject* toBoxModelObject, |
| LayoutObject* startChild, |
| LayoutObject* endChild, |
| LayoutObject* beforeChild, |
| bool fullRemoveInsert) { |
| // This condition is rarely hit since this function is usually called on |
| // anonymous blocks which can no longer carry positioned objects (see r120761) |
| // or when fullRemoveInsert is false. |
| if (fullRemoveInsert && isLayoutBlock()) { |
| LayoutBlock* block = toLayoutBlock(this); |
| block->removePositionedObjects(nullptr); |
| block->removeFromPercentHeightContainer(); |
| if (block->isLayoutBlockFlow()) |
| toLayoutBlockFlow(block)->removeFloatingObjects(); |
| } |
| |
| ASSERT(!beforeChild || toBoxModelObject == beforeChild->parent()); |
| for (LayoutObject* child = startChild; child && child != endChild;) { |
| // Save our next sibling as moveChildTo will clear it. |
| LayoutObject* nextSibling = child->nextSibling(); |
| moveChildTo(toBoxModelObject, child, beforeChild, fullRemoveInsert); |
| child = nextSibling; |
| } |
| } |
| |
| bool LayoutBoxModelObject::backgroundStolenForBeingBody( |
| const ComputedStyle* rootElementStyle) const { |
| // http://www.w3.org/TR/css3-background/#body-background |
| // If the root element is <html> with no background, and a <body> child |
| // element exists, the root element steals the first <body> child element's |
| // background. |
| if (!isBody()) |
| return false; |
| |
| Element* rootElement = document().documentElement(); |
| if (!isHTMLHtmlElement(rootElement)) |
| return false; |
| |
| if (!rootElementStyle) |
| rootElementStyle = rootElement->ensureComputedStyle(); |
| if (rootElementStyle->hasBackground()) |
| return false; |
| |
| if (node() != document().firstBodyElement()) |
| return false; |
| |
| return true; |
| } |
| |
| } // namespace blink |
