Merge back LayoutLayerModelObject into RenderBoxModelObject

Source/core/layout/LayoutBoxModelObject.cpp

 /*
  * 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
@@ skipping 42 matching lines @@
 // The HashMap for storing continuation pointers.
 // An inline can be split with blocks occuring in between the inline content.
 // When this occurs we need a pointer to the next object. We can basically be
 // split into a sequence of inlines and blocks. The continuation will either be
 // an anonymous block (that houses other blocks) or it will be an inline flow.
 // <b><i><p>Hello</p></i></b>. In this example the <i> will have a block as
 // its continuation but the <b> will just have an inline as its continuation.
 typedef HashMap<const LayoutBoxModelObject*, LayoutBoxModelObject*> ContinuationMap;
 static ContinuationMap* continuationMap = nullptr;
 
+bool LayoutBoxModelObject::s_wasFloating = false;
+
 void LayoutBoxModelObject::setSelectionState(SelectionState state)
 {
     if (state == SelectionInside && selectionState() != SelectionNone)
         return;
 
     if ((state == SelectionStart && selectionState() == SelectionEnd)
         || (state == SelectionEnd && selectionState() == SelectionStart))
         LayoutObject::setSelectionState(SelectionBoth);
     else
         LayoutObject::setSelectionState(state);
@@ skipping 13 matching lines @@
 
     layer()->contentChanged(changeType);
 }
 
 bool LayoutBoxModelObject::hasAcceleratedCompositing() const
 {
     return view()->compositor()->hasAcceleratedCompositing();
 }
 
 LayoutBoxModelObject::LayoutBoxModelObject(ContainerNode* node)
-    : LayoutLayerModelObject(node)
+    : LayoutObject(node)
 {
 }
 
 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());
 
-    LayoutLayerModelObject::willBeDestroyed();
-}
+    if (isPositioned()) {
+        // Don't use this->view() because the document's renderView 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 LayoutStyle& newStyle)
+{
+    s_wasFloating = isFloating();
+
+    if (const LayoutStyle* oldStyle = style()) {
+        if (parent() && diff.needsPaintInvalidationLayer()) {
+            if (oldStyle->hasAutoClip() != newStyle.hasAutoClip()
+                || oldStyle->clip() != newStyle.clip())
+                layer()->clipper().clearClipRectsIncludingDescendants();
+        }
+    }
+
+    LayoutObject::styleWillChange(diff, newStyle);
+}
+
+void LayoutBoxModelObject::styleDidChange(StyleDifference diff, const LayoutStyle* oldStyle)
+{
+    bool hadTransform = hasTransformRelatedProperty();
+    bool hadLayer = hasLayer();
+    bool layerWasSelfPainting = hadLayer && layer()->isSelfPaintingLayer();
+
+    LayoutObject::styleDidChange(diff, oldStyle);
+    updateFromStyle();
+
+    LayerType type = layerTypeRequired();
+    if (type != NoLayer) {
+        if (!layer() && layerCreationAllowedForSubtree()) {
+            if (s_wasFloating && isFloating())
+                setChildNeedsLayout();
+            createLayer(type);
+            if (parent() && !needsLayout()) {
+                // FIXME: We should call a specialized version of this function.
+                layer()->updateLayerPositionsAfterLayout();
+            }
+        }
+    } else if (layer() && layer()->parent()) {
+        setHasTransformRelatedProperty(false); // Either a transform wasn't specified or the object doesn't support transforms, so just null out the bit.
+        setHasReflection(false);
+        layer()->removeOnlyThisLayer(); // calls destroyLayer() which clears m_layer
+        if (s_wasFloating && isFloating())
+            setChildNeedsLayout();
+        if (hadTransform)
+            setNeedsLayoutAndPrefWidthsRecalcAndFullPaintInvalidation();
+    }
+
+    if (layer()) {
+        // FIXME: Ideally we shouldn't need this setter but we can't easily infer an overflow-only layer
+        // from the style.
+        layer()->setLayerType(type);
+
+        layer()->styleChanged(diff, oldStyle);
+        if (hadLayer && layer()->isSelfPaintingLayer() != layerWasSelfPainting)
+            setChildNeedsLayout();
+    }
+
+    if (FrameView *frameView = view()->frameView()) {
+        bool newStyleIsViewportConstained = style()->hasViewportConstrainedPosition();
+        bool oldStyleIsViewportConstrained = oldStyle && oldStyle->hasViewportConstrainedPosition();
+        if (newStyleIsViewportConstained != oldStyleIsViewportConstrained) {
+            if (newStyleIsViewportConstained && layer())
+                frameView->addViewportConstrainedObject(this);
+            else
+                frameView->removeViewportConstrainedObject(this);
+        }
+    }
+}
+
+void LayoutBoxModelObject::createLayer(LayerType type)
+{
+    ASSERT(!m_layer);
+    m_layer = adoptPtr(new Layer(this, type));
+    setHasLayer(true);
+    m_layer->insertOnlyThisLayer();
+}
+
+void LayoutBoxModelObject::destroyLayer()
+{
+    setHasLayer(false);
+    m_layer = nullptr;
+}
+
+bool LayoutBoxModelObject::hasSelfPaintingLayer() const
+{
+    return m_layer && m_layer->isSelfPaintingLayer();
+}
+
+LayerScrollableArea* LayoutBoxModelObject::scrollableArea() const
+{
+    return m_layer ? m_layer->scrollableArea() : 0;
+}
+
+void LayoutBoxModelObject::addLayerHitTestRects(LayerHitTestRects& rects, const Layer* currentLayer, const LayoutPoint& layerOffset, const LayoutRect& containerRect) const
+{
+    if (hasLayer()) {
+        if (isRenderView()) {
+            // RenderView 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);
+    }
+}
+
+void LayoutBoxModelObject::invalidateTreeIfNeeded(const PaintInvalidationState& paintInvalidationState)
+{
+    ASSERT(!needsLayout());
+
+    if (!shouldCheckForPaintInvalidation(paintInvalidationState))
+        return;
+
+    bool establishesNewPaintInvalidationContainer = isPaintInvalidationContainer();
+    const LayoutBoxModelObject& newPaintInvalidationContainer = *adjustCompositedContainerForSpecialAncestors(establishesNewPaintInvalidationContainer ? this : &paintInvalidationState.paintInvalidationContainer());
+    // FIXME: This assert should be re-enabled when we move paint invalidation to after compositing update. crbug.com/360286
+    // ASSERT(&newPaintInvalidationContainer == containerForPaintInvalidation());
+
+    PaintInvalidationReason reason = invalidatePaintIfNeeded(paintInvalidationState, newPaintInvalidationContainer);
+    clearPaintInvalidationState(paintInvalidationState);
+
+    PaintInvalidationState childTreeWalkState(paintInvalidationState, *this, newPaintInvalidationContainer);
+    if (reason == PaintInvalidationLocationChange)
+        childTreeWalkState.setForceCheckForPaintInvalidation();
+    invalidatePaintOfSubtreesIfNeeded(childTreeWalkState);
+}
+
+void LayoutBoxModelObject::setBackingNeedsPaintInvalidationInRect(const LayoutRect& r, PaintInvalidationReason invalidationReason) const
+{
+    // https://bugs.webkit.org/show_bug.cgi?id=61159 describes an unreproducible crash here,
+    // so assert but check that the layer is composited.
+    ASSERT(compositingState() != NotComposited);
+
+    // FIXME: generalize accessors to backing GraphicsLayers so that this code is squashing-agnostic.
+    if (layer()->groupedMapping()) {
+        LayoutRect paintInvalidationRect = r;
+        if (GraphicsLayer* squashingLayer = layer()->groupedMapping()->squashingLayer()) {
+            // Note: the subpixel accumulation of layer() does not need to be added here. It is already taken into account.
+            squashingLayer->setNeedsDisplayInRect(pixelSnappedIntRect(paintInvalidationRect), invalidationReason);
+        }
+    } else {
+        layer()->compositedLayerMapping()->setContentsNeedDisplayInRect(r, invalidationReason);
+    }
+}
+
+void LayoutBoxModelObject::addChildFocusRingRects(Vector<LayoutRect>& rects, const LayoutPoint& additionalOffset) const
+{
+    for (LayoutObject* current = slowFirstChild(); current; current = current->nextSibling()) {
+        if (current->isText() || current->isListMarker())
+            continue;
+
+        if (!current->isBox()) {
+            current->addFocusRingRects(rects, additionalOffset);
+            continue;
+        }
+
+        RenderBox* box = toRenderBox(current);
+        if (!box->hasLayer()) {
+            box->addFocusRingRects(rects, additionalOffset + box->locationOffset());
+            continue;
+        }
+
+        Vector<LayoutRect> layerFocusRingRects;
+        box->addFocusRingRects(layerFocusRingRects, LayoutPoint());
+        for (size_t i = 0; i < layerFocusRingRects.size(); ++i) {
+            FloatQuad quadInBox = box->localToContainerQuad(FloatQuad(layerFocusRingRects[i]), this);
+            LayoutRect rect = LayoutRect(quadInBox.boundingBox());
+            if (!rect.isEmpty()) {
+                rect.moveBy(additionalOffset);
+                rects.append(rect);
+            }
+        }
+    }
+}
+
 
 bool LayoutBoxModelObject::calculateHasBoxDecorations() const
 {
     const LayoutStyle& styleToUse = styleRef();
     return hasBackground() || styleToUse.hasBorder() || styleToUse.hasAppearance() || styleToUse.boxShadow();
 }
 
 void LayoutBoxModelObject::updateFromStyle()
 {
-    LayoutLayerModelObject::updateFromStyle();
-
     const LayoutStyle& styleToUse = styleRef();
     setHasBoxDecorationBackground(calculateHasBoxDecorations());
     setInline(styleToUse.isDisplayInlineType());
     setPositionState(styleToUse.position());
     setHorizontalWritingMode(styleToUse.isHorizontalWritingMode());
 }
 
 static LayoutSize accumulateInFlowPositionOffsets(const LayoutObject* child)
 {
     if (!child->isAnonymousBlock() || !child->isRelPositioned())
@@ skipping 340 matching lines @@
             continuationMap = new ContinuationMap;
         continuationMap->set(this, continuation);
     } else {
         if (continuationMap)
             continuationMap->remove(this);
     }
 }
 
 void LayoutBoxModelObject::computeLayerHitTestRects(LayerHitTestRects& rects) const
 {
-    LayoutLayerModelObject::computeLayerHitTestRects(rects);
+    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)
@@ skipping 85 matching lines @@
     bool preserve3D = mode & UseTransforms && (o->style()->preserves3D() || style()->preserves3D());
     if (mode & UseTransforms && shouldUseTransformFromContainer(o)) {
         TransformationMatrix t;
         getTransformFromContainer(o, containerOffset, t);
         transformState.applyTransform(t, preserve3D ? TransformState::AccumulateTransform : TransformState::FlattenTransform);
     } else {
         transformState.move(containerOffset.width(), containerOffset.height(), preserve3D ? TransformState::AccumulateTransform : TransformState::FlattenTransform);
     }
 }
 
-const LayoutObject* LayoutBoxModelObject::pushMappingToContainer(const LayoutLayerModelObject* ancestorToStopAt, LayoutGeometryMap& geometryMap) const
+const LayoutObject* LayoutBoxModelObject::pushMappingToContainer(const LayoutBoxModelObject* ancestorToStopAt, LayoutGeometryMap& geometryMap) const
 {
     ASSERT(ancestorToStopAt != this);
 
     bool ancestorSkipped;
     LayoutObject* container = this->container(ancestorToStopAt, &ancestorSkipped);
     if (!container)
         return 0;
 
     bool isInline = isRenderInline();
     bool isFixedPos = !isInline && style()->position() == FixedPosition;
@@ skipping 55 matching lines @@
     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;
     }
 }
 
 } // namespace blink