Move transforms from RenderLayer to RenderBox.

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 131 matching lines @@
             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);
     }
 
+    updateTransform(oldStyle);
+
     if (needsLayout() && oldStyle)
         RenderBlock::removePercentHeightDescendantIfNeeded(this);
 }
 
+void RenderBox::updateTransformationMatrix()
+{
+    if (m_transform) {
+        m_transform->makeIdentity();
+        style()->applyTransform(*m_transform, 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 RenderBox::updateTransform(const RenderStyle* oldStyle)
+{
+    if (oldStyle && style()->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 localHasTransform = hasTransform() && style()->hasTransform();
+    bool had3DTransform = has3DTransform();
+
+    bool hadTransform = m_transform;
+    if (localHasTransform != hadTransform) {
+        if (localHasTransform)
+            m_transform = adoptPtr(new TransformationMatrix);
+        else
+            m_transform.clear();
+
+        // Layers with transforms act as clip rects roots, so clear the cached clip rects here.
+        layer()->clipper().clearClipRectsIncludingDescendants();
+    } else if (localHasTransform) {
+        layer()->clipper().clearClipRectsIncludingDescendants(AbsoluteClipRects);
+    }
+
+    updateTransformationMatrix();
+
+    if (had3DTransform != has3DTransform())
+        layer()->dirty3DTransformedDescendantStatus();
+}
+
 // TODO(ojan): Inline this into styleDidChange,
 void RenderBox::updateFromStyle()
 {
     RenderStyle* styleToUse = style();
 
     setHasBoxDecorationBackground(hasBackground() || styleToUse->hasBorder() || styleToUse->boxShadow());
     setInline(styleToUse->isDisplayInlineType());
     setPositionState(styleToUse->position());
 
     if (isRenderView()) {
@@ skipping 73 matching lines @@
     return snapSizeToPixel(offsetHeight(), y() + clientTop());
 }
 
 void RenderBox::absoluteQuads(Vector<FloatQuad>& quads) const
 {
     quads.append(localToAbsoluteQuad(FloatRect(0, 0, width().toFloat(), height().toFloat()), 0 /* mode */));
 }
 
 void RenderBox::updateLayerTransformAfterLayout()
 {
-    // Transform-origin depends on box size, so we need to update the layer transform after layout.
-    if (hasLayer())
-        layer()->updateTransformationMatrix();
+    // Transform-origin depends on box size, so we need to update the transform after layout.
+    updateTransformationMatrix();
 }
 
 LayoutUnit RenderBox::constrainLogicalWidthByMinMax(LayoutUnit logicalWidth, LayoutUnit availableWidth, RenderBlock* cb) const
 {
     RenderStyle* styleToUse = style();
     if (!styleToUse->logicalMaxWidth().isMaxSizeNone())
         logicalWidth = std::min(logicalWidth, computeLogicalWidthUsing(MaxSize, styleToUse->logicalMaxWidth(), availableWidth, cb));
     return std::max(logicalWidth, computeLogicalWidthUsing(MinSize, styleToUse->logicalMinWidth(), availableWidth, cb));
 }
 
@@ skipping 279 matching lines @@
 {
     ASSERT(layer()->isSelfPaintingLayer());
 
     // The natural thing would be to keep HitTestingTransformState on the stack, but it's big, so we heap-allocate.
     RefPtr<HitTestingTransformState> localTransformState;
 
     LayoutRect localHitTestRect = hitTestRect;
     HitTestLocation localHitTestLocation = hitTestLocation;
 
     // We need transform state for the first time, or to offset the container state, or to accumulate the new transform.
-    if (layer()->transform() || transformState || layer()->has3DTransformedDescendant() || layer()->preserves3D())
+    if (transform() || transformState || layer()->has3DTransformedDescendant() || style()->preserves3D())
         localTransformState = createLocalTransformState(rootLayer, containerLayer, localHitTestRect, localHitTestLocation, transformState);
 
     // Apply a transform if we have one.
-    if (layer()->transform()) {
+    if (transform()) {
         // The RenderView cannot have transforms.
         ASSERT(parent());
         // Make sure the parent's clip rects have been calculated.
         ClipRect clipRect = layer()->clipper().backgroundClipRect(ClipRectsContext(rootLayer, RootRelativeClipRects));
         // Go ahead and test the enclosing clip now.
         if (!clipRect.intersects(localHitTestLocation))
             return 0;
 
         // If the transform can't be inverted, then don't hit test this layer at all.
         if (!localTransformState->m_accumulatedTransform.isInvertible())
@@ skipping 23 matching lines @@
 
     // Check for hit test on backface if backface-visibility is 'hidden'
     if (localTransformState && style()->backfaceVisibility() == BackfaceVisibilityHidden) {
         TransformationMatrix invertedMatrix = localTransformState->m_accumulatedTransform.inverse();
         // If the z-vector of the matrix is negative, the back is facing towards the viewer.
         if (invertedMatrix.m33() < 0)
             return 0;
     }
 
     RefPtr<HitTestingTransformState> unflattenedTransformState = localTransformState;
-    if (localTransformState && !layer()->preserves3D()) {
+    if (localTransformState && !style()->preserves3D()) {
         // Keep a copy of the pre-flattening state, for computing z-offsets for the container
         unflattenedTransformState = HitTestingTransformState::create(*localTransformState);
         // This layer is flattening, so flatten the state passed to descendants.
         localTransformState->flatten();
     }
 
     // The following are used for keeping track of the z-depth of the hit point of 3d-transformed
     // descendants.
     double localZOffset = -std::numeric_limits<double>::infinity();
     double* zOffsetForDescendantsPtr = 0;
     double* zOffsetForContentsPtr = 0;
 
     bool depthSortDescendants = false;
-    if (layer()->preserves3D()) {
+    if (style()->preserves3D()) {
         depthSortDescendants = true;
         // Our layers can depth-test with our container, so share the z depth pointer with the container, if it passed one down.
         zOffsetForDescendantsPtr = zOffset ? zOffset : &localZOffset;
         zOffsetForContentsPtr = zOffset ? zOffset : &localZOffset;
     } else if (zOffset) {
         zOffsetForDescendantsPtr = 0;
         // Container needs us to give back a z offset for the hit layer.
         zOffsetForContentsPtr = zOffset;
     }
 
@@ skipping 89 matching lines @@
     return first->style()->zIndex() < second->style()->zIndex();
 }
 
 void RenderBox::paintLayer(GraphicsContext* context, const LayerPaintingInfo& paintingInfo)
 {
     // If this layer is totally invisible then there is nothing to paint.
     // TODO(ojan): Return false from isSelfPainting and then ASSERT(!opacity()) here.
     if (!opacity())
         return;
 
-    TransformationMatrix* layerTransform = layer()->transform();
-
-    if (!layerTransform) {
+    if (!transform()) {
         paintLayerContents(context, paintingInfo);
         return;
     }
 
     // The RenderView can't be transformed in Sky.
     ASSERT(layer()->parent());
 
     // If the transform can't be inverted, then don't paint anything.
-    if (!layerTransform->isInvertible())
+    if (!transform()->isInvertible())
         return;
 
     // Make sure the parent's clip rects have been calculated.
     ClipRectsContext clipRectsContext(paintingInfo.rootLayer, PaintingClipRects);
     ClipRect clipRect = layer()->clipper().backgroundClipRect(clipRectsContext);
     clipRect.intersect(paintingInfo.paintDirtyRect);
 
     // Push the parent coordinate space's clip.
     layer()->parent()->clipToRect(paintingInfo, context, clipRect);
 
     // This involves subtracting out the position of the layer in our current coordinate space, but preserving
     // the accumulated error for sub-pixel layout.
     LayoutPoint delta;
     layer()->convertToLayerCoords(paintingInfo.rootLayer, delta);
-    TransformationMatrix transform(*layerTransform);
+    TransformationMatrix localTransform(*transform());
     IntPoint roundedDelta = roundedIntPoint(delta);
-    transform.translateRight(roundedDelta.x(), roundedDelta.y());
+    localTransform.translateRight(roundedDelta.x(), roundedDelta.y());
     LayoutSize adjustedSubPixelAccumulation = paintingInfo.subPixelAccumulation + (delta - roundedDelta);
 
     // Apply the transform.
     GraphicsContextStateSaver stateSaver(*context, false);
-    if (!transform.isIdentity()) {
+    if (!localTransform.isIdentity()) {
         stateSaver.save();
-        context->concatCTM(transform.toAffineTransform());
+        context->concatCTM(localTransform.toAffineTransform());
     }
 
     // Now do a paint with the root layer shifted to be us.
-    LayerPaintingInfo transformedPaintingInfo(layer(), enclosingIntRect(transform.inverse().mapRect(paintingInfo.paintDirtyRect)),
+    LayerPaintingInfo transformedPaintingInfo(layer(), enclosingIntRect(localTransform.inverse().mapRect(paintingInfo.paintDirtyRect)),
         adjustedSubPixelAccumulation);
     paintLayerContents(context, transformedPaintingInfo);
 
     // Restore the clip.
     layer()->parent()->restoreClip(context, paintingInfo.paintDirtyRect, clipRect);
 }
 
 static LayoutRect transparencyClipBox(const RenderLayer*, const RenderLayer* rootLayer, const LayoutSize& subPixelAccumulation);
 
 static void expandClipRectForDescendantsAndReflection(LayoutRect& clipRect, const RenderLayer* layer, const RenderLayer* rootLayer,
     const LayoutSize& subPixelAccumulation)
 {
     // Note: we don't have to walk z-order lists since transparent elements always establish
     // a stacking container. This means we can just walk the layer tree directly.
     for (RenderLayer* curr = layer->firstChild(); curr; curr = curr->nextSibling())
         clipRect.unite(transparencyClipBox(curr, rootLayer, subPixelAccumulation));
 }
 
 static LayoutRect transparencyClipBox(const RenderLayer* layer, const RenderLayer* rootLayer,
     const LayoutSize& subPixelAccumulation)
 {
     // FIXME: Although this function completely ignores CSS-imposed clipping, we did already intersect with the
     // paintDirtyRect, and that should cut down on the amount we have to paint.  Still it
     // would be better to respect clips.
 
-    if (rootLayer != layer && layer->transform()) {
+    if (rootLayer != layer && layer->renderer()->transform()) {
         // The best we can do here is to use enclosed bounding boxes to establish a "fuzzy" enough clip to encompass
         // the transformed layer and all of its children.
         const RenderLayer* rootLayerForTransform = rootLayer;
         LayoutPoint delta;
         layer->convertToLayerCoords(rootLayerForTransform, delta);
 
         delta.move(subPixelAccumulation);
         IntPoint pixelSnappedDelta = roundedIntPoint(delta);
         TransformationMatrix transform;
         transform.translate(pixelSnappedDelta.x(), pixelSnappedDelta.y());
-        transform = transform * *layer->transform();
+        transform = transform * *layer->renderer()->transform();
 
         // We don't use fragment boxes when collecting a transformed layer's bounding box, since it always
         // paints unfragmented.y
         LayoutRect clipRect = layer->physicalBoundingBox(layer);
         expandClipRectForDescendantsAndReflection(clipRect, layer, layer, subPixelAccumulation);
         layer->renderer()->style()->filterOutsets().expandRect(clipRect);
         LayoutRect result = transform.mapRect(clipRect);
         return result;
     }
 
@@ skipping 2196 matching lines @@
 
 LayoutRect RenderBox::layoutOverflowRectForPropagation() const
 {
     // Only propagate interior layout overflow if we don't clip it.
     LayoutRect rect = borderBoxRect();
     rect.expand(LayoutSize(LayoutUnit(), marginAfter()));
 
     if (!hasOverflowClip())
         rect.unite(layoutOverflowRect());
 
-    if (hasLayer() && layer()->transform())
-        rect = layer()->transform()->mapRect(rect);
+    if (transform())
+        rect = transform()->mapRect(rect);
 
     return rect;
 }
 
 LayoutUnit RenderBox::offsetLeft() const
 {
     return adjustedPositionRelativeToOffsetParent(location()).x();
 }
 
 LayoutUnit RenderBox::offsetTop() const
@@ skipping 10 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