Delete RenderLayerModelObject.

sky/engine/core/rendering/RenderBox.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, 2010 Apple Inc. All rights reserved.
  * Copyright (C) 2013 Adobe Systems Incorporated. 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 49 matching lines @@
     , m_maxPreferredLogicalWidth(-1)
 {
     setIsBox();
 }
 
 void RenderBox::willBeDestroyed()
 {
     clearOverrideSize();
     RenderBlock::removePercentHeightDescendantIfNeeded(this);
     RenderBoxModelObject::willBeDestroyed();
+    destroyLayer();
+}
+
+void RenderBox::destroyLayer()
+{
+    setHasLayer(false);
+    m_layer = nullptr;
+}
+
+void RenderBox::createLayer(LayerType type)
+{
+    ASSERT(!m_layer);
+    m_layer = adoptPtr(new RenderLayer(this, type));
+    setHasLayer(true);
+    m_layer->insertOnlyThisLayer();
+}
+
+bool RenderBox::hasSelfPaintingLayer() const
+{
+    return m_layer && m_layer->isSelfPaintingLayer();
 }
 
 void RenderBox::removeFloatingOrPositionedChildFromBlockLists()
 {
     ASSERT(isFloatingOrOutOfFlowPositioned());
 
     if (documentBeingDestroyed())
         return;
 
     if (isOutOfFlowPositioned())
         RenderBlock::removePositionedObject(this);
 }
 
 void RenderBox::styleWillChange(StyleDifference diff, const RenderStyle& newStyle)
 {
     RenderStyle* oldStyle = style();
-    if (oldStyle) {
+    if (oldStyle && parent()) {
         // When a layout hint happens and an object's position style changes, we have to do a layout
         // to dirty the render tree using the old position value now.
-        if (diff.needsFullLayout() && parent() && oldStyle->position() != newStyle.position()) {
+        if (diff.needsFullLayout() && oldStyle->position() != newStyle.position()) {
             markContainingBlocksForLayout();
             if (newStyle.hasOutOfFlowPosition())
                 parent()->setChildNeedsLayout();
         }
+
+        if (oldStyle->hasAutoClip() != newStyle.hasAutoClip()
+            || oldStyle->clip() != newStyle.clip())
+            layer()->clipper().clearClipRectsIncludingDescendants();
     }
 
     RenderBoxModelObject::styleWillChange(diff, newStyle);
 }
 
 void RenderBox::styleDidChange(StyleDifference diff, const RenderStyle* oldStyle)
 {
-    RenderBoxModelObject::styleDidChange(diff, oldStyle);
+    bool hadTransform = hasTransform();
+
+    RenderObject::styleDidChange(diff, oldStyle);
+    updateFromStyle();
+
+    LayerType type = layerTypeRequired();
+    if (type != NoLayer) {
+        if (!layer()) {
+            createLayer(type);
+            if (parent() && !needsLayout()) {
+                // FIXME: We should call a specialized version of this function.
+                layer()->updateLayerPositionsAfterLayout();
+            }
+        }
+    } else if (layer() && layer()->parent()) {
+        setHasTransform(false); // Either a transform wasn't specified or the object doesn't support transforms, so just null out the bit.
+        layer()->removeOnlyThisLayer(); // calls destroyLayer() which clears m_layer
+        if (hadTransform)
+            setNeedsLayoutAndPrefWidthsRecalc();
+    }
+
+    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 (needsLayout() && oldStyle)
         RenderBlock::removePercentHeightDescendantIfNeeded(this);
 }
 
+// TODO(ojan): Inline this into styleDidChange,
 void RenderBox::updateFromStyle()
 {
-    RenderBoxModelObject::updateFromStyle();
-
     RenderStyle* styleToUse = style();
 
+    setHasBoxDecorationBackground(hasBackground() || styleToUse->hasBorder() || styleToUse->boxShadow());
+    setInline(styleToUse->isDisplayInlineType());
+    setPositionState(styleToUse->position());
+
     if (isRenderView()) {
+        // TODO(ojan): Merge this into the same call above.
         setHasBoxDecorationBackground(true);
     } else if (isRenderBlock()) {
         // TODO(esprehn): Why do we not want to set this on the RenderView?
         setHasOverflowClip(!styleToUse->isOverflowVisible());
     }
 
     setHasTransform(styleToUse->hasTransformRelatedProperty());
 }
 
 void RenderBox::layout()
@@ skipping 96 matching lines @@
     rect.move(absPos.x(), absPos.y());
     return rect;
 }
 
 FloatQuad RenderBox::absoluteContentQuad() const
 {
     LayoutRect rect = contentBoxRect();
     return localToAbsoluteQuad(FloatRect(rect));
 }
 
-void RenderBox::addFocusRingRects(Vector<IntRect>& rects, const LayoutPoint& additionalOffset, const RenderLayerModelObject*) const
+void RenderBox::addFocusRingRects(Vector<IntRect>& rects, const LayoutPoint& additionalOffset, const RenderBox*) const
 {
     if (!size().isEmpty())
         rects.append(pixelSnappedIntRect(additionalOffset, size()));
 }
 
 bool RenderBox::needsPreferredWidthsRecalculation() const
 {
     return style()->paddingStart().isPercent() || style()->paddingEnd().isPercent();
 }
 
@@ skipping 108 matching lines @@
         height -= borderAndPaddingLogicalHeight();
     return std::max<LayoutUnit>(0, height);
 }
 
 bool RenderBox::nodeAtPoint(const HitTestRequest& request, HitTestResult& result, const HitTestLocation& locationInContainer, const LayoutPoint& accumulatedOffset)
 {
     LayoutPoint adjustedLocation = accumulatedOffset + location();
 
     // Check kids first.
     for (RenderObject* child = slowLastChild(); child; child = child->previousSibling()) {
-        if ((!child->hasLayer() || !toRenderLayerModelObject(child)->layer()->isSelfPaintingLayer()) && child->nodeAtPoint(request, result, locationInContainer, adjustedLocation)) {
+        if ((!child->hasLayer() || !toRenderBox(child)->layer()->isSelfPaintingLayer()) && child->nodeAtPoint(request, result, locationInContainer, adjustedLocation)) {
             updateHitTestResult(result, locationInContainer.point() - toLayoutSize(adjustedLocation));
             return true;
         }
     }
 
     // Check our bounds next.
     LayoutRect boundsRect = borderBoxRect();
     boundsRect.moveBy(adjustedLocation);
     if (visibleToHitTestRequest(request) && locationInContainer.intersects(boundsRect)) {
         updateHitTestResult(result, locationInContainer.point() - toLayoutSize(adjustedLocation));
@@ skipping 65 matching lines @@
         if (childZOffset > *zOffset) {
             *zOffset = childZOffset;
             return true;
         }
         return false;
     }
 
     return true;
 }
 
-static inline bool reverseCompareZIndex(RenderLayerModelObject* first, RenderLayerModelObject* second)
+static inline bool reverseCompareZIndex(RenderBox* first, RenderBox* second)
 {
     return first->style()->zIndex() > second->style()->zIndex();
 }
 
 // hitTestLocation and hitTestRect are relative to rootLayer.
 // A 'flattening' layer is one preserves3D() == false.
 // transformState.m_accumulatedTransform holds the transform from the containing flattening layer.
 // transformState.m_lastPlanarPoint is the hitTestLocation in the plane of the containing flattening layer.
 // transformState.m_lastPlanarQuad is the hitTestRect as a quad in the plane of the containing flattening layer.
 //
@@ skipping 592 matching lines @@
         clipRect.contract(0, height() - valueForLength(style()->clipBottom(), height()));
 
     return clipRect;
 }
 
 LayoutUnit RenderBox::containingBlockLogicalHeightForContent(AvailableLogicalHeightType heightType) const
 {
     return containingBlock()->availableLogicalHeight(heightType);
 }
 
-void RenderBox::mapLocalToContainer(const RenderLayerModelObject* paintInvalidationContainer, TransformState& transformState, MapCoordinatesFlags mode) const
+void RenderBox::mapLocalToContainer(const RenderBox* paintInvalidationContainer, TransformState& transformState, MapCoordinatesFlags mode) const
 {
     if (paintInvalidationContainer == this)
         return;
 
     bool containerSkipped;
     RenderObject* o = container(paintInvalidationContainer, &containerSkipped);
     if (!o)
         return;
 
     LayoutSize containerOffset = offsetFromContainer(o, roundedLayoutPoint(transformState.mappedPoint()));
@@ skipping 1885 matching lines @@
 
 RenderBox::BoxDecorationData::BoxDecorationData(const RenderStyle& style)
 {
     backgroundColor = style.colorIncludingFallback(CSSPropertyBackgroundColor);
     hasBackground = backgroundColor.alpha() || style.hasBackgroundImage();
     ASSERT(hasBackground == style.hasBackground());
     hasBorder = style.hasBorder();
 }
 
 } // namespace blink