Move transforms from RenderLayer to RenderBox.

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 84 matching lines @@
 
 RenderLayer::~RenderLayer()
 {
 }
 
 void RenderLayer::updateLayerPositionsAfterLayout()
 {
     m_clipper.clearClipRectsIncludingDescendants();
 }
 
-void RenderLayer::updateTransformationMatrix()
-{
-    if (m_transform) {
-        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)
-{
-    if (oldStyle && newStyle->transformDataEquivalent(*oldStyle))
-        return;
-
-    // hasTransform() on the renderer is also true when there is transform-style: preserve-3d or perspective set,
-    // so check style too.
-    bool hasTransform = renderer()->hasTransform() && newStyle->hasTransform();
-    bool had3DTransform = has3DTransform();
-
-    bool hadTransform = m_transform;
-    if (hasTransform != hadTransform) {
-        if (hasTransform)
-            m_transform = adoptPtr(new TransformationMatrix);
-        else
-            m_transform.clear();
-
-        // Layers with transforms act as clip rects roots, so clear the cached clip rects here.
-        m_clipper.clearClipRectsIncludingDescendants();
-    } else if (hasTransform) {
-        m_clipper.clearClipRectsIncludingDescendants(AbsoluteClipRects);
-    }
-
-    updateTransformationMatrix();
-
-    if (had3DTransform != has3DTransform())
-        dirty3DTransformedDescendantStatus();
-}
 
 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.
-    while (stackingNode && stackingNode->layer()->preserves3D()) {
+    while (stackingNode && stackingNode->layer()->renderer()->style()->preserves3D()) {
         stackingNode->layer()->m_3DTransformedDescendantStatusDirty = true;
         stackingNode = stackingNode->ancestorStackingContextNode();
     }
 }
 
 // Return true if this layer or any preserve-3d descendants have 3d.
 bool RenderLayer::update3DTransformedDescendantStatus()
 {
     if (m_3DTransformedDescendantStatusDirty) {
         m_has3DTransformedDescendant = false;
 
         m_stackingNode->updateZOrderLists();
 
         // Transformed or preserve-3d descendants can only be in the z-order lists, not
         // in the normal flow list, so we only need to check those.
         RenderLayerStackingNodeIterator iterator(*m_stackingNode.get(), PositiveZOrderChildren);
         while (RenderLayerStackingNode* node = iterator.next())
             m_has3DTransformedDescendant |= node->layer()->update3DTransformedDescendantStatus();
 
         m_3DTransformedDescendantStatusDirty = false;
     }
 
     // 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;
+    if (renderer()->style()->preserves3D())
+        return renderer()->has3DTransform() || m_has3DTransformedDescendant;
 
-    return has3DTransform();
+    return renderer()->has3DTransform();
 }
 
 IntSize RenderLayer::size() const
 {
     // FIXME: Is snapping the size really needed here?
     RenderBox* box = renderer();
     return pixelSnappedIntSize(box->size(), box->location());
 }
 
 LayoutPoint RenderLayer::location() const
@@ skipping 369 matching lines @@
 
     if (!ancestorLayer)
         ancestorLayer = this;
 
     // The root layer is always just the size of the document.
     if (isRootLayer())
         return m_renderer->view()->unscaledDocumentRect();
 
     LayoutRect localClipRect = clipper().localClipRect();
     if (localClipRect != PaintInfo::infiniteRect()) {
-        if (transform())
-            localClipRect = transform()->mapRect(localClipRect);
+        if (renderer()->transform())
+            localClipRect = renderer()->transform()->mapRect(localClipRect);
 
         LayoutPoint delta;
         convertToLayerCoords(ancestorLayer, delta);
         localClipRect.moveBy(delta);
         return localClipRect;
     }
 
     LayoutPoint origin;
     LayoutRect result = physicalBoundingBox(ancestorLayer, &origin);
 
     const_cast<RenderLayer*>(this)->stackingNode()->updateLayerListsIfNeeded();
 
     expandRectForReflectionAndStackingChildren(this, result);
 
     // FIXME: We can optimize the size of the composited layers, by not enlarging
     // filtered areas with the outsets if we know that the filter is going to render in hardware.
     // https://bugs.webkit.org/show_bug.cgi?id=81239
     m_renderer->style()->filterOutsets().expandRect(result);
 
-    if (transform())
-        result = transform()->mapRect(result);
+    if (renderer()->transform())
+        result = renderer()->transform()->mapRect(result);
 
     LayoutPoint delta;
     convertToLayerCoords(ancestorLayer, delta);
     result.moveBy(delta);
     return result;
 }
 
 bool RenderLayer::shouldBeSelfPaintingLayer() const
 {
     return m_layerType == NormalLayer;
 }
 
 void RenderLayer::styleChanged(StyleDifference diff, const RenderStyle* oldStyle)
 {
     m_stackingNode->updateIsNormalFlowOnly();
     m_stackingNode->updateStackingNodesAfterStyleChange(oldStyle);
 
     // 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());
 }
 
 } // namespace blink