WebKit merge 40668:40722 part 1.

third_party/WebKit/WebCore/rendering/RenderLayerBacking.cpp

 /*
  * Copyright (C) 2009 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 98 matching lines @@
 }
 
 void RenderLayerBacking::updateLayerTransform()
 {
     RenderStyle* style = renderer()->style();
 
     // FIXME: This could use m_owningLayer->transform(), but that currently has transform-origin
     // baked into it, and we don't want that.
     TransformationMatrix t;
     if (m_owningLayer->hasTransform())
-        style->applyTransform(t, renderer()->borderBoxRect().size(), false);
+        style->applyTransform(t, toRenderBox(renderer())->borderBoxRect().size(), RenderStyle::ExcludeTransformOrigin);
     
     m_graphicsLayer->setTransform(t);
 }
 
 void RenderLayerBacking::updateAfterLayout()
 {
     invalidateDrawingOptimizations();
     detectDrawingOptimizations();
 
     updateGraphicsLayerGeometry();
@@ skipping 101 matching lines @@
 
     // If we have a layer that clips children, position it.
     if (m_clippingLayer) {
         IntRect clippingBox = renderer()->getOverflowClipRect(0, 0);
         m_clippingLayer->setPosition(FloatPoint() + (clippingBox.location() - localCompositingBounds.location()));
         m_clippingLayer->setSize(clippingBox.size());
         m_clippingLayer->setOffsetFromRenderer(clippingBox.location() - IntPoint());
     }
     
     if (m_owningLayer->hasTransform()) {
-        const IntRect borderBox = renderer()->borderBoxRect();
+        const IntRect borderBox = toRenderBox(renderer())->borderBoxRect();
 
         IntRect layerBounds = IntRect(m_owningLayer->xPos(), m_owningLayer->yPos(), borderBox.width(), borderBox.height());
         // Convert to absolute coords to match bbox.
         int x = 0, y = 0;
         m_owningLayer->convertToLayerCoords(compAncestor, x, y);
         layerBounds.move(x - m_owningLayer->xPos(), y - m_owningLayer->yPos());
 
         // Update properties that depend on layer dimensions
         FloatPoint3D transformOrigin = computeTransformOrigin(borderBox);
         // Compute the anchor point, which is in the center of the renderer box unless transform-origin is set.
@@ skipping 335 matching lines @@
 
     IntRect relativeCompositingBounds = compositor()->calculateCompositedBounds(m_owningLayer, m_owningLayer);
     m_compositingContentOffset = IntSize(-relativeCompositingBounds.x(), -relativeCompositingBounds.y());
     m_compositingContentOffsetDirty = false;
 
     return m_compositingContentOffset;
 }
 
 IntRect RenderLayerBacking::contentsBox(const GraphicsLayer*)
 {
-    IntRect contentsRect = renderer()->contentBoxRect();
+    if (!renderer()->isBox())
+        return IntRect();
+
+    IntRect contentsRect = toRenderBox(renderer())->contentBoxRect();
     IntSize contentOffset = contentOffsetInCompostingLayer();
     contentsRect.move(contentOffset);
     return contentsRect;
 }
 
 // Map the given point from coordinates in the GraphicsLayer to RenderLayer coordinates.
 FloatPoint RenderLayerBacking::graphicsLayerToContentsCoordinates(const GraphicsLayer* graphicsLayer, const FloatPoint& point)
 {
     return point + FloatSize(graphicsLayer->offsetFromRenderer());
 }
@@ skipping 61 matching lines @@
     }
     
     m_owningLayer->updateLayerListsIfNeeded();
     
     // Calculate the clip rects we should use.
     IntRect layerBounds, damageRect, clipRectToApply, outlineRect;
     m_owningLayer->calculateRects(rootLayer, paintDirtyRect, layerBounds, damageRect, clipRectToApply, outlineRect);
     
     int x = layerBounds.x();        // layerBounds is computed relative to rootLayer
     int y = layerBounds.y();
-    int tx = x - renderer()->x();
-    int ty = y - renderer()->y();
+    int tx = x - toRenderBox(renderer())->x();
+    int ty = y - toRenderBox(renderer())->y();
 
     // If this layer's renderer is a child of the paintingRoot, we render unconditionally, which
     // is done by passing a nil paintingRoot down to our renderer (as if no paintingRoot was ever set).
     // Else, our renderer tree may or may not contain the painting root, so we pass that root along
     // so it will be tested against as we decend through the renderers.
     RenderObject *paintingRootForRenderer = 0;
     if (paintingRoot && !renderer()->isDescendantOf(paintingRoot))
         paintingRootForRenderer = paintingRoot;
 
     if (paintingPhase & GraphicsLayerPaintBackgroundMask) {
         // If this is the root then we need to send in a bigger bounding box
         // because we'll be painting the background as well (see RenderBox::paintRootBoxDecorations()).
         IntRect paintBox = clipRectToApply;
         
+        // FIXME: do we need this code?
         if (renderer()->node()->isDocumentNode() && renderer()->document()->isHTMLDocument()) {
-            int w = renderer()->width();
-            int h = renderer()->height();
+            RenderBox* box = toRenderBox(renderer());
+            int w = box->width();
+            int h = box->height();
             
             int rw;
             int rh;
-            if (renderer()->view()->frameView()) {
-                rw = renderer()->view()->frameView()->contentsWidth();
-                rh = renderer()->view()->frameView()->contentsHeight();
+            if (box->view()->frameView()) {
+                rw = box->view()->frameView()->contentsWidth();
+                rh = box->view()->frameView()->contentsHeight();
             } else {
-                rw = renderer()->view()->width();
-                rh = renderer()->view()->height();
+                rw = box->view()->width();
+                rh = box->view()->height();
             }
             
-            int bx = tx - renderer()->marginLeft();
-            int by = ty - renderer()->marginTop();
-            int bw = max(w + renderer()->marginLeft() + renderer()->marginRight() + renderer()->borderLeft() + renderer()->borderRight(), rw);
-            int bh = max(h + renderer()->marginTop() + renderer()->marginBottom() + renderer()->borderTop() + renderer()->borderBottom(), rh);
+            int bx = tx - box->marginLeft();
+            int by = ty - box->marginTop();
+            int bw = max(w + box->marginLeft() + box->marginRight() + box->borderLeft() + box->borderRight(), rw);
+            int bh = max(h + box->marginTop() + box->marginBottom() + box->borderTop() + box->borderBottom(), rh);
             paintBox = IntRect(bx, by, bw, bh);
         }
 
         // Paint our background first, before painting any child layers.
         // Establish the clip used to paint our background.
         setClip(context, paintDirtyRect, damageRect);
         
         RenderObject::PaintInfo info(context, paintBox, PaintPhaseBlockBackground, false, paintingRootForRenderer, 0);
         renderer()->paint(info, tx, ty);
 
@@ skipping 122 matching lines @@
         if (hasTransform)
             transformVector.insert(key, &(keyframeStyle->transform()), tf);
 
         if (hasOpacity)
             opacityVector.insert(key, keyframeStyle->opacity(), tf);
     }
 
     bool didAnimateTransform = !hasTransform;
     bool didAnimateOpacity = !hasOpacity;
     
-    if (hasTransform && m_graphicsLayer->animateTransform(transformVector, renderer()->borderBoxRect().size(), anim, beginTime, false))
+    if (hasTransform && m_graphicsLayer->animateTransform(transformVector, toRenderBox(renderer())->borderBoxRect().size(), anim, beginTime, false))
         didAnimateTransform = true;
 
     if (hasOpacity && m_graphicsLayer->animateFloat(AnimatedPropertyOpacity, opacityVector, anim, beginTime))
         didAnimateOpacity = true;
     
     return didAnimateTransform && didAnimateOpacity;
 }
 
 bool RenderLayerBacking::startTransition(double beginTime, int property, const RenderStyle* fromStyle, const RenderStyle* toStyle)
 {
@@ skipping 15 matching lines @@
 
     if (property == (int)CSSPropertyWebkitTransform && m_owningLayer->hasTransform()) {
         // We get a TransformOperation, which is a linked list of primitive operations and their arguments.
         // Arguments can be floats or Length values, which need to be converted to numbers using
         // val.calcFloatValue(renderer()->width()) (or height()).
         const Animation* transformAnim = toStyle->transitionForProperty(CSSPropertyWebkitTransform);
         if (transformAnim && !transformAnim->isEmptyOrZeroDuration()) {
             GraphicsLayer::TransformValueList transformVector;
             transformVector.insert(0, &fromStyle->transform(), 0);        
             transformVector.insert(1, &toStyle->transform(), 0);        
-            if (m_graphicsLayer->animateTransform(transformVector, renderer()->borderBoxRect().size(), transformAnim, beginTime, true))
+            if (m_graphicsLayer->animateTransform(transformVector, toRenderBox(renderer())->borderBoxRect().size(), transformAnim, beginTime, true))
                 didAnimate = true;
         }
     }
     
     return didAnimate;
 }
 
-void RenderLayerBacking::notifyTransitionStarted(const GraphicsLayer*, AnimatedPropertyID property, double time)
-{
-    renderer()->animation()->notifyTransitionStarted(renderer(), graphicsLayerToCSSProperty(property), time);
-}
-
 void RenderLayerBacking::notifyAnimationStarted(const GraphicsLayer*, double time)
 {
     renderer()->animation()->notifyAnimationStarted(renderer(), time);
 }
 
 void RenderLayerBacking::animationFinished(const String& name, int index, bool reset)
 {
     m_graphicsLayer->removeFinishedAnimations(name, index, reset);
 }
 
@@ skipping 43 matching lines @@
         case CSSPropertyBackgroundColor:
             return AnimatedPropertyBackgroundColor;
         // It's fine if we see other css properties here; they are just not accelerated.
     }
     return AnimatedPropertyInvalid;
 }
 
 } // namespace WebCore
 
 #endif // USE(ACCELERATED_COMPOSITING)