Assorted cleanup of RenderLayer.

sky/engine/core/rendering/RenderLayer.cpp

 /*
  * Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011, 2012 Apple Inc. All rights reserved.
  *
  * Portions are Copyright (C) 1998 Netscape Communications Corporation.
  *
  * Other contributors:
  *   Robert O'Callahan <roc+@cs.cmu.edu>
  *   David Baron <dbaron@fas.harvard.edu>
  *   Christian Biesinger <cbiesinger@web.de>
  *   Randall Jesup <rjesup@wgate.com>
@@ skipping 74 matching lines @@
     , m_has3DTransformedDescendant(false)
     , m_hasFilterInfo(false)
     , m_renderer(renderer)
     , m_parent(0)
     , m_previous(0)
     , m_next(0)
     , m_first(0)
     , m_last(0)
     , m_clipper(*renderer)
 {
-    updateStackingNode();
-
+    m_stackingNode = adoptPtr(new RenderLayerStackingNode(this));
     m_isSelfPaintingLayer = shouldBeSelfPaintingLayer();
 }
 
 RenderLayer::~RenderLayer()
 {
     removeFilterInfoIfNeeded();
 }
 
-String RenderLayer::debugName() const
-{
-    return renderer()->debugName();
-}
-
-LayoutSize RenderLayer::subpixelAccumulation() const
-{
-    return m_subpixelAccumulation;
-}
-
-void RenderLayer::setSubpixelAccumulation(const LayoutSize& size)
-{
-    m_subpixelAccumulation = size;
-}
-
 void RenderLayer::updateLayerPositionsAfterLayout()
 {
-    TRACE_EVENT0("blink", "RenderLayer::updateLayerPositionsAfterLayout");
-
     m_clipper.clearClipRectsIncludingDescendants();
 }
 
 void RenderLayer::updateTransformationMatrix()
 {
     if (m_transform) {
-        RenderBox* box = renderBox();
-        ASSERT(box);
+        RenderBox* box = renderer();
         m_transform->makeIdentity();
         box->style()->applyTransform(*m_transform, box->pixelSnappedBorderBoxRect().size(), RenderStyle::IncludeTransformOrigin);
         // FIXME(sky): We shouldn't need to do this once Skia has 4x4 matrix support.
         // Until then, 3d transforms don't work right.
         m_transform->makeAffine();
     }
 }
 
 void RenderLayer::updateTransform(const RenderStyle* oldStyle, RenderStyle* newStyle)
 {
@@ skipping 17 matching lines @@
     } else if (hasTransform) {
         m_clipper.clearClipRectsIncludingDescendants(AbsoluteClipRects);
     }
 
     updateTransformationMatrix();
 
     if (had3DTransform != has3DTransform())
         dirty3DTransformedDescendantStatus();
 }
 
-static RenderLayer* enclosingLayerForContainingBlock(RenderLayer* layer)
-{
-    if (RenderObject* containingBlock = layer->renderer()->containingBlock())
-        return containingBlock->enclosingLayer();
-    return 0;
-}
-
-RenderLayer* RenderLayer::renderingContextRoot()
-{
-    RenderLayer* renderingContext = 0;
-
-    if (shouldPreserve3D())
-        renderingContext = this;
-
-    for (RenderLayer* current = enclosingLayerForContainingBlock(this); current && current->shouldPreserve3D(); current = enclosingLayerForContainingBlock(current))
-        renderingContext = current;
-
-    return renderingContext;
-}
-
-RenderLayer* RenderLayer::enclosingOverflowClipLayer(IncludeSelfOrNot includeSelf) const
-{
-    const RenderLayer* layer = (includeSelf == IncludeSelf) ? this : parent();
-    while (layer) {
-        if (layer->renderer()->hasOverflowClip())
-            return const_cast<RenderLayer*>(layer);
-
-        layer = layer->parent();
-    }
-    return 0;
-}
-
 void RenderLayer::dirty3DTransformedDescendantStatus()
 {
     RenderLayerStackingNode* stackingNode = m_stackingNode->ancestorStackingContextNode();
     if (!stackingNode)
         return;
 
     stackingNode->layer()->m_3DTransformedDescendantStatusDirty = true;
 
     // This propagates up through preserve-3d hierarchies to the enclosing flattening layer.
     // Note that preserves3D() creates stacking context, so we can just run up the stacking containers.
@@ skipping 23 matching lines @@
     // If we live in a 3d hierarchy, then the layer at the root of that hierarchy needs
     // the m_has3DTransformedDescendant set.
     if (preserves3D())
         return has3DTransform() || m_has3DTransformedDescendant;
 
     return has3DTransform();
 }
 
 IntSize RenderLayer::size() const
 {
-    if (renderer()->isInline() && renderer()->isRenderInline())
-        return toRenderInline(renderer())->linesBoundingBox().size();
-
     // FIXME: Is snapping the size really needed here?
-    if (RenderBox* box = renderBox())
-        return pixelSnappedIntSize(box->size(), box->location());
-
-    return IntSize();
+    RenderBox* box = renderer();
+    return pixelSnappedIntSize(box->size(), box->location());
 }
 
 LayoutPoint RenderLayer::location() const
 {
     LayoutPoint localPoint;
     LayoutSize inlineBoundingBoxOffset; // We don't put this into the RenderLayer x/y for inlines, so we need to subtract it out when done.
 
     if (renderer()->isInline() && renderer()->isRenderInline()) {
         RenderInline* inlineFlow = toRenderInline(renderer());
         IntRect lineBox = inlineFlow->linesBoundingBox();
         inlineBoundingBoxOffset = toSize(lineBox.location());
         localPoint += inlineBoundingBoxOffset;
-    } else if (RenderBox* box = renderBox()) {
-        localPoint += box->locationOffset();
+    } else {
+        localPoint += renderer()->locationOffset();
     }
 
     if (!renderer()->isOutOfFlowPositioned() && renderer()->parent()) {
         // We must adjust our position by walking up the render tree looking for the
         // nearest enclosing object with a layer.
         RenderObject* curr = renderer()->parent();
         while (curr && !curr->hasLayer()) {
             if (curr->isBox()) {
                 // Rows and cells share the same coordinate space (that of the section).
                 // Omit them when computing our xpos/ypos.
                 localPoint += toRenderBox(curr)->locationOffset();
             }
             curr = curr->parent();
         }
     }
 
     // FIXME: We'd really like to just get rid of the concept of a layer rectangle and rely on the renderers.
     localPoint -= inlineBoundingBoxOffset;
 
     return localPoint;
 }
 
-TransformationMatrix RenderLayer::perspectiveTransform() const
-{
-    if (!renderer()->hasTransform())
-        return TransformationMatrix();
-
-    RenderStyle* style = renderer()->style();
-    if (!style->hasPerspective())
-        return TransformationMatrix();
-
-    // Maybe fetch the perspective from the backing?
-    const IntRect borderBox = renderer()->pixelSnappedBorderBoxRect();
-    const float boxWidth = borderBox.width();
-    const float boxHeight = borderBox.height();
-
-    float perspectiveOriginX = floatValueForLength(style->perspectiveOriginX(), boxWidth);
-    float perspectiveOriginY = floatValueForLength(style->perspectiveOriginY(), boxHeight);
-
-    // A perspective origin of 0,0 makes the vanishing point in the center of the element.
-    // We want it to be in the top-left, so subtract half the height and width.
-    perspectiveOriginX -= boxWidth / 2.0f;
-    perspectiveOriginY -= boxHeight / 2.0f;
-
-    TransformationMatrix t;
-    t.translate(perspectiveOriginX, perspectiveOriginY);
-    t.applyPerspective(style->perspective());
-    t.translate(-perspectiveOriginX, -perspectiveOriginY);
-
-    return t;
-}
-
-FloatPoint RenderLayer::perspectiveOrigin() const
-{
-    if (!renderer()->hasTransform())
-        return FloatPoint();
-
-    const LayoutRect borderBox = renderer()->borderBoxRect();
-    RenderStyle* style = renderer()->style();
-
-    return FloatPoint(floatValueForLength(style->perspectiveOriginX(), borderBox.width().toFloat()), floatValueForLength(style->perspectiveOriginY(), borderBox.height().toFloat()));
-}
-
 RenderLayer* RenderLayer::enclosingPositionedAncestor() const
 {
     RenderLayer* curr = parent();
     while (curr && !curr->isPositionedContainer())
         curr = curr->parent();
 
     return curr;
 }
 
 const RenderLayer* RenderLayer::compositingContainer() const
@@ skipping 181 matching lines @@
         currLayer = accumulateOffsetTowardsAncestor(currLayer, ancestorLayer, location);
 }
 
 void RenderLayer::convertToLayerCoords(const RenderLayer* ancestorLayer, LayoutRect& rect) const
 {
     LayoutPoint delta;
     convertToLayerCoords(ancestorLayer, delta);
     rect.move(-delta.x(), -delta.y());
 }
 
-void RenderLayer::updateStackingNode()
-{
-    if (requiresStackingNode())
-        m_stackingNode = adoptPtr(new RenderLayerStackingNode(this));
-    else
-        m_stackingNode = nullptr;
-}
-
 static bool inContainingBlockChain(RenderLayer* startLayer, RenderLayer* endLayer)
 {
     if (startLayer == endLayer)
         return true;
 
     RenderView* view = startLayer->renderer()->view();
     for (RenderBlock* currentBlock = startLayer->renderer()->containingBlock(); currentBlock && currentBlock != view; currentBlock = currentBlock->containingBlock()) {
         if (currentBlock->layer() == endLayer)
             return true;
     }
@@ skipping 62 matching lines @@
     // line boxes of all three lines (including overflow on those lines).
     // (2) Left/Top Overflow.  The width/height of layers already includes right/bottom overflow.  However, in the case of left/top
     // overflow, we have to create a bounding box that will extend to include this overflow.
     // (3) Floats.  When a layer has overhanging floats that it paints, we need to make sure to include these overhanging floats
     // as part of our bounding box.  We do this because we are the responsible layer for both hit testing and painting those
     // floats.
     LayoutRect result;
     if (renderer()->isInline() && renderer()->isRenderInline()) {
         result = toRenderInline(renderer())->linesVisualOverflowBoundingBox();
     } else {
-        RenderBox* box = renderBox();
-        ASSERT(box);
+        RenderBox* box = renderer();
         result = box->borderBoxRect();
         result.unite(box->visualOverflowRect());
     }
 
     ASSERT(renderer()->view());
     return result;
 }
 
 LayoutRect RenderLayer::physicalBoundingBox(const RenderLayer* ancestorLayer, const LayoutPoint* offsetFromRoot) const
 {
@@ skipping 77 matching lines @@
     convertToLayerCoords(ancestorLayer, delta);
     result.moveBy(delta);
     return result;
 }
 
 bool RenderLayer::shouldBeSelfPaintingLayer() const
 {
     return m_layerType == NormalLayer;
 }
 
-bool RenderLayer::hasBoxDecorationsOrBackground() const
-{
-    return renderer()->style()->hasBoxDecorations() || renderer()->style()->hasBackground();
-}
-
-bool RenderLayer::hasVisibleBoxDecorations() const
-{
-    return hasBoxDecorationsOrBackground();
-}
-
 void RenderLayer::updateFilters(const RenderStyle* oldStyle, const RenderStyle* newStyle)
 {
     if (!newStyle->hasFilter() && (!oldStyle || !oldStyle->hasFilter()))
         return;
 
-    if (!hasFilter()) {
+    if (!renderer()->hasFilter()) {
         removeFilterInfoIfNeeded();
         return;
     }
 
     if (renderer()->style()->filter().hasReferenceFilter())
         ensureFilterInfo()->updateReferenceFilterClients(renderer()->style()->filter());
     else if (hasFilterInfo())
         filterInfo()->removeReferenceFilterClients();
 
     // FilterEffectRenderer is only used to render the filters in software mode,
@@ skipping 30 matching lines @@
 
     // Overlay scrollbars can make this layer self-painting so we need
     // to recompute the bit once scrollbars have been updated.
     m_isSelfPaintingLayer = shouldBeSelfPaintingLayer();
 
     updateTransform(oldStyle, renderer()->style());
     updateFilters(oldStyle, renderer()->style());
 }
 
 } // namespace blink