[chromium] Cleanup scissor rect computation/use with damage
[WebKit-https.git] / Source / WebCore / platform / graphics / chromium / cc / CCLayerTreeHostCommon.cpp
1 /*
2  * Copyright (C) 2011 Google Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  * 1.  Redistributions of source code must retain the above copyright
8  *     notice, this list of conditions and the following disclaimer.
9  * 2.  Redistributions in binary form must reproduce the above copyright
10  *     notice, this list of conditions and the following disclaimer in the
11  *     documentation and/or other materials provided with the distribution.
12  *
13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' AND ANY
14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
15  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
16  * DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS BE LIABLE FOR ANY
17  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
18  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
19  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
20  * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
21  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
22  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
23  */
24
25
26 #include "config.h"
27
28 #include "cc/CCLayerTreeHostCommon.h"
29
30 #include "FloatQuad.h"
31 #include "IntRect.h"
32 #include "LayerChromium.h"
33 #include "RenderSurfaceChromium.h"
34 #include "cc/CCActiveAnimation.h"
35 #include "cc/CCLayerAnimationController.h"
36 #include "cc/CCLayerImpl.h"
37 #include "cc/CCLayerIterator.h"
38 #include "cc/CCLayerSorter.h"
39 #include "cc/CCMathUtil.h"
40 #include "cc/CCRenderSurface.h"
41 #include <public/WebTransformationMatrix.h>
42
43 using WebKit::WebTransformationMatrix;
44
45 namespace WebCore {
46
47 IntRect CCLayerTreeHostCommon::calculateVisibleRect(const IntRect& targetSurfaceRect, const IntRect& layerBoundRect, const WebTransformationMatrix& transform)
48 {
49     // Is this layer fully contained within the target surface?
50     IntRect layerInSurfaceSpace = CCMathUtil::mapClippedRect(transform, layerBoundRect);
51     if (targetSurfaceRect.contains(layerInSurfaceSpace))
52         return layerBoundRect;
53
54     // If the layer doesn't fill up the entire surface, then find the part of
55     // the surface rect where the layer could be visible. This avoids trying to
56     // project surface rect points that are behind the projection point.
57     IntRect minimalSurfaceRect = targetSurfaceRect;
58     minimalSurfaceRect.intersect(layerInSurfaceSpace);
59
60     // Project the corners of the target surface rect into the layer space.
61     // This bounding rectangle may be larger than it needs to be (being
62     // axis-aligned), but is a reasonable filter on the space to consider.
63     // Non-invertible transforms will create an empty rect here.
64     const WebTransformationMatrix surfaceToLayer = transform.inverse();
65     IntRect layerRect = enclosingIntRect(CCMathUtil::projectClippedRect(surfaceToLayer, FloatRect(minimalSurfaceRect)));
66     layerRect.intersect(layerBoundRect);
67     return layerRect;
68 }
69
70 template<typename LayerType, typename RenderSurfaceType>
71 static IntRect calculateLayerScissorRect(LayerType* layer, const FloatRect& rootScissorRect)
72 {
73     RenderSurfaceType* targetSurface = layer->targetRenderSurface();
74
75     FloatRect rootScissorRectInTargetSurface = targetSurface->computeRootScissorRectInCurrentSurface(rootScissorRect);
76     FloatRect clipAndDamage;
77     if (layer->usesLayerClipping())
78         clipAndDamage = intersection(rootScissorRectInTargetSurface, layer->clipRect());
79     else
80         clipAndDamage = intersection(rootScissorRectInTargetSurface, targetSurface->contentRect());
81
82     return enclosingIntRect(clipAndDamage);
83 }
84
85 template<typename LayerType, typename RenderSurfaceType>
86 static IntRect calculateSurfaceScissorRect(LayerType* layer, const FloatRect& rootScissorRect)
87 {
88     LayerType* parentLayer = layer->parent();
89     RenderSurfaceType* targetSurface = parentLayer->targetRenderSurface();
90     ASSERT(targetSurface);
91
92     RenderSurfaceType* currentSurface = layer->renderSurface();
93     ASSERT(currentSurface);
94
95     FloatRect clipRect = currentSurface->clipRect();
96
97     // For surfaces, empty clipRect means the same as CCLayerImpl::usesLayerClipping being false
98     if (clipRect.isEmpty())
99         clipRect = intersection(targetSurface->contentRect(), currentSurface->drawableContentRect());
100
101     FloatRect rootScissorRectInTargetSurface = targetSurface->computeRootScissorRectInCurrentSurface(rootScissorRect);
102
103     FloatRect clipAndDamage = intersection(rootScissorRectInTargetSurface, clipRect);
104     return enclosingIntRect(clipAndDamage);
105 }
106
107 template<typename LayerType>
108 static inline bool layerIsInExisting3DRenderingContext(LayerType* layer)
109 {
110     // According to current W3C spec on CSS transforms, a layer is part of an established
111     // 3d rendering context if its parent has transform-style of preserves-3d.
112     return layer->parent() && layer->parent()->preserves3D();
113 }
114
115 template<typename LayerType>
116 static bool layerIsRootOfNewRenderingContext(LayerType* layer)
117 {
118     // According to current W3C spec on CSS transforms (Section 6.1), a layer is the
119     // beginning of 3d rendering context if its parent does not have transform-style:
120     // preserve-3d, but this layer itself does.
121     if (layer->parent())
122         return !layer->parent()->preserves3D() && layer->preserves3D();
123
124     return layer->preserves3D();
125 }
126
127 template<typename LayerType>
128 static bool isLayerBackFaceVisible(LayerType* layer)
129 {
130     // The current W3C spec on CSS transforms says that backface visibility should be
131     // determined differently depending on whether the layer is in a "3d rendering
132     // context" or not. For Chromium code, we can determine whether we are in a 3d
133     // rendering context by checking if the parent preserves 3d.
134
135     if (layerIsInExisting3DRenderingContext(layer))
136         return layer->drawTransform().isBackFaceVisible();
137
138     // In this case, either the layer establishes a new 3d rendering context, or is not in
139     // a 3d rendering context at all.
140     return layer->transform().isBackFaceVisible();
141 }
142
143 template<typename LayerType>
144 static bool isSurfaceBackFaceVisible(LayerType* layer, const WebTransformationMatrix& drawTransform)
145 {
146     if (layerIsInExisting3DRenderingContext(layer))
147         return drawTransform.isBackFaceVisible();
148
149     if (layerIsRootOfNewRenderingContext(layer))
150         return layer->transform().isBackFaceVisible();
151
152     // If the renderSurface is not part of a new or existing rendering context, then the
153     // layers that contribute to this surface will decide back-face visibility for themselves.
154     return false;
155 }
156
157 template<typename LayerType>
158 static IntRect calculateVisibleLayerRect(LayerType* layer)
159 {
160     ASSERT(layer->targetRenderSurface());
161
162     IntRect targetSurfaceRect = layer->targetRenderSurface()->contentRect();
163
164     if (layer->usesLayerClipping())
165         targetSurfaceRect.intersect(layer->clipRect());
166
167     if (targetSurfaceRect.isEmpty() || layer->contentBounds().isEmpty())
168         return targetSurfaceRect;
169
170     // Note carefully these are aliases
171     const IntSize& bounds = layer->bounds();
172     const IntSize& contentBounds = layer->contentBounds();
173
174     const IntRect layerBoundRect = IntRect(IntPoint(), contentBounds);
175     WebTransformationMatrix transform = layer->drawTransform();
176
177     transform.scaleNonUniform(bounds.width() / static_cast<double>(contentBounds.width()),
178                               bounds.height() / static_cast<double>(contentBounds.height()));
179     transform.translate(-contentBounds.width() / 2.0, -contentBounds.height() / 2.0);
180
181     IntRect visibleLayerRect = CCLayerTreeHostCommon::calculateVisibleRect(targetSurfaceRect, layerBoundRect, transform);
182     return visibleLayerRect;
183 }
184
185 static bool isScaleOrTranslation(const WebTransformationMatrix& m)
186 {
187     return !m.m12() && !m.m13() && !m.m14()
188            && !m.m21() && !m.m23() && !m.m24()
189            && !m.m31() && !m.m32() && !m.m43()
190            && m.m44();
191 }
192
193 static inline bool layerOpacityIsOpaque(CCLayerImpl* layer)
194 {
195     return layer->opacity() == 1;
196 }
197
198 static inline bool layerOpacityIsOpaque(LayerChromium* layer)
199 {
200     // If the opacity is being animated then the opacity on the main thread is unreliable
201     // (since the impl thread may be using a different opacity), so it should not be trusted.
202     // In particular, it should not be treated as opaque.
203     return layer->opacity() == 1 && !layer->opacityIsAnimating();
204 }
205
206 static inline bool transformToParentIsKnown(CCLayerImpl*)
207 {
208     return true;
209 }
210
211 static inline bool transformToParentIsKnown(LayerChromium* layer)
212 {
213     return !layer->transformIsAnimating();
214 }
215
216 static inline bool transformToScreenIsKnown(CCLayerImpl*)
217 {
218     return true;
219 }
220
221 static inline bool transformToScreenIsKnown(LayerChromium* layer)
222 {
223     return !layer->screenSpaceTransformIsAnimating();
224 }
225
226 template<typename LayerType>
227 static bool layerShouldBeSkipped(LayerType* layer)
228 {
229     // Layers can be skipped if any of these conditions are met.
230     //   - does not draw content.
231     //   - is transparent
232     //   - has empty bounds
233     //   - the layer is not double-sided, but its back face is visible.
234     //
235     // Some additional conditions need to be computed at a later point after the recursion is finished.
236     //   - the intersection of render surface content and layer clipRect is empty
237     //   - the visibleLayerRect is empty
238     //
239     // Note, if the layer should not have been drawn due to being fully transparent,
240     // we would have skipped the entire subtree and never made it into this function,
241     // so it is safe to omit this check here.
242
243     if (!layer->drawsContent() || layer->bounds().isEmpty())
244         return true;
245
246     // The layer should not be drawn if (1) it is not double-sided and (2) the back of the layer is known to be facing the screen.
247     if (!layer->doubleSided() && transformToScreenIsKnown(layer) && isLayerBackFaceVisible(layer))
248         return true;
249
250     return false;
251 }
252
253 static inline bool subtreeShouldBeSkipped(CCLayerImpl* layer)
254 {
255     // The opacity of a layer always applies to its children (either implicitly
256     // via a render surface or explicitly if the parent preserves 3D), so the
257     // entire subtree can be skipped if this layer is fully transparent.
258     return !layer->opacity();
259 }
260
261 static inline bool subtreeShouldBeSkipped(LayerChromium* layer)
262 {
263     // If the opacity is being animated then the opacity on the main thread is unreliable
264     // (since the impl thread may be using a different opacity), so it should not be trusted.
265     // In particular, it should not cause the subtree to be skipped.
266     return !layer->opacity() && !layer->opacityIsAnimating();
267 }
268
269 template<typename LayerType>
270 static bool subtreeShouldRenderToSeparateSurface(LayerType* layer, bool axisAlignedWithRespectToParent)
271 {
272     // FIXME: If we decide to create a render surface here while this layer does
273     //        preserve-3d, then we may be sorting incorrectly because we will not be
274     //        sorting the individual layers of this subtree with other layers outside of
275     //        this subtree.
276
277     // Cache this value, because otherwise it walks the entire subtree several times.
278     bool descendantDrawsContent = layer->descendantDrawsContent();
279
280     //
281     // A layer and its descendants should render onto a new RenderSurface if any of these rules hold:
282     //
283
284     // If we force it.
285     if (layer->forceRenderSurface())
286         return true;
287
288     // If the layer uses a mask.
289     if (layer->maskLayer())
290         return true;
291
292     // If the layer has a reflection.
293     if (layer->replicaLayer())
294         return true;
295
296     // If the layer uses a CSS filter.
297     if (!layer->filters().isEmpty() || !layer->backgroundFilters().isEmpty())
298         return true;
299
300     // If the layer flattens its subtree (i.e. the layer doesn't preserve-3d), but it is
301     // treated as a 3D object by its parent (i.e. parent does preserve-3d).
302     if (layerIsInExisting3DRenderingContext(layer) && !layer->preserves3D() && descendantDrawsContent)
303         return true;
304
305     // If the layer clips its descendants but it is not axis-aligned with respect to its parent.
306     // On the main thread, when the transform is being animated, it is treated as unknown and we
307     // always error on the side of making a render surface, to let us consider descendents as
308     // not animating relative to their target to aid culling.
309     if (layer->masksToBounds() && (!axisAlignedWithRespectToParent || !transformToParentIsKnown(layer)) && descendantDrawsContent)
310         return true;
311
312     // If the layer has opacity != 1 and does not have a preserves-3d transform style.
313     // On the main thread, when opacity is being animated, it is treated as neither 1
314     // nor 0.
315     if (!layerOpacityIsOpaque(layer) && !layer->preserves3D() && descendantDrawsContent)
316         return true;
317
318     return false;
319 }
320
321 // Recursively walks the layer tree starting at the given node and computes all the
322 // necessary transformations, clipRects, render surfaces, etc.
323 template<typename LayerType, typename LayerList, typename RenderSurfaceType, typename LayerSorter>
324 static bool calculateDrawTransformsInternal(LayerType* layer, LayerType* rootLayer, const WebTransformationMatrix& parentMatrix, const WebTransformationMatrix& fullHierarchyMatrix, RenderSurfaceType* nearestAncestorThatMovesPixels, LayerList& renderSurfaceLayerList, LayerList& layerList, LayerSorter* layerSorter, int maxTextureSize)
325 {
326     // This function computes the new matrix transformations recursively for this
327     // layer and all its descendants. It also computes the appropriate render surfaces.
328     // Some important points to remember:
329     //
330     // 0. Here, transforms are notated in Matrix x Vector order, and in words we describe what
331     //    the transform does from left to right.
332     //
333     // 1. In our terminology, the "layer origin" refers to the top-left corner of a layer, and the
334     //    positive Y-axis points downwards. This interpretation is valid because the orthographic
335     //    projection applied at draw time flips the Y axis appropriately.
336     //
337     // 2. The anchor point, when given as a FloatPoint object, is specified in "unit layer space",
338     //    where the bounds of the layer map to [0, 1]. However, as a WebTransformationMatrix object,
339     //    the transform to the anchor point is specified in "pixel layer space", where the bounds
340     //    of the layer map to [bounds.width(), bounds.height()].
341     //
342     // 3. The value of layer->position() is actually the position of the anchor point with respect to the position
343     //    of the layer's origin. That is:
344     //        layer->position() = positionOfLayerOrigin + anchorPoint (in pixel units)
345     //
346     //    Or, equivalently,
347     //        positionOfLayerOrigin.x =  layer->position.x - (layer->anchorPoint.x * bounds.width)
348     //        positionOfLayerOrigin.y =  layer->position.y - (layer->anchorPoint.y * bounds.height)
349     //
350     // 4. Definition of various transforms used:
351     //        M[parent] is the parent matrix, with respect to the nearest render surface, passed down recursively.
352     //        M[root] is the full hierarchy, with respect to the root, passed down recursively.
353     //        Tr[origin] is the translation matrix from the parent's origin to this layer's origin.
354     //        Tr[origin2anchor] is the translation from the layer's origin to its anchor point
355     //        Tr[origin2center] is the translation from the layer's origin to its center
356     //        M[layer] is the layer's matrix (applied at the anchor point)
357     //        M[sublayer] is the layer's sublayer transform (applied at the layer's center)
358     //        Tr[anchor2center] is the translation offset from the anchor point and the center of the layer
359     //
360     //    Some shortcuts and substitutions are used in the code to reduce matrix multiplications:
361     //        Translating by the value of layer->position(), Tr[layer->position()] = Tr[origin] * Tr[origin2anchor]
362     //        Tr[anchor2center] = Tr[origin2anchor].inverse() * Tr[origin2center]
363     //
364     //    Some composite transforms can help in understanding the sequence of transforms:
365     //        compositeLayerTransform = Tr[origin2anchor] * M[layer] * Tr[origin2anchor].inverse()
366     //        compositeSublayerTransform = Tr[origin2center] * M[sublayer] * Tr[origin2center].inverse()
367     //
368     //    In words, the layer transform is applied about the anchor point, and the sublayer transform is
369     //    applied about the center of the layer.
370     //
371     // 5. When a layer (or render surface) is drawn, it is drawn into a "target render surface". Therefore the draw
372     //    transform does not necessarily transform from screen space to local layer space. Instead, the draw transform
373     //    is the transform between the "target render surface space" and local layer space. Note that render surfaces,
374     //    except for the root, also draw themselves into a different target render surface, and so their draw
375     //    transform and origin transforms are also described with respect to the target.
376     //
377     // Using these definitions, then:
378     //
379     // The draw transform for the layer is:
380     //        M[draw] = M[parent] * Tr[origin] * compositeLayerTransform * Tr[origin2center]
381     //                = M[parent] * Tr[layer->position()] * M[layer] * Tr[anchor2center]
382     //
383     //        Interpreting the math left-to-right, this transforms from the layer's render surface to the center of the layer.
384     //
385     // The screen space transform is:
386     //        M[screenspace] = M[root] * Tr[origin] * compositeLayerTransform
387     //                       = M[root] * Tr[layer->position()] * M[layer] * Tr[origin2anchor].inverse()
388     //
389     //        Interpreting the math left-to-right, this transforms from the root layer space to the local layer's origin.
390     //
391     // The transform hierarchy that is passed on to children (i.e. the child's parentMatrix) is:
392     //        M[parent]_for_child = M[parent] * Tr[origin] * compositeLayerTransform * compositeSublayerTransform
393     //                            = M[parent] * Tr[layer->position()] * M[layer] * Tr[anchor2center] * M[sublayer] * Tr[origin2center].inverse()
394     //                            = M[draw] * M[sublayer] * Tr[origin2center].inverse()
395     //
396     //        and a similar matrix for the full hierarchy with respect to the root.
397     //
398     // Finally, note that the final matrix used by the shader for the layer is P * M[draw] * S . This final product
399     // is computed in drawTexturedQuad(), where:
400     //        P is the projection matrix
401     //        S is the scale adjustment (to scale up to the layer size)
402     //
403     // When a render surface has a replica layer, that layer's transform is used to draw a second copy of the surface.
404     // Transforms named here are relative to the surface, unless they specify they are relative to the replica layer.
405     //
406     // The render surface origin transform to its target surface origin is:
407     //        M[surfaceOrigin] = M[owningLayer->Draw] * Tr[origin2center].inverse()
408     //
409     // The render surface origin transform to its the root (screen space) origin is:
410     //        M[surface2root] = M[owningLayer->screenspace]
411     //
412     // The replica draw transform is:
413     //        M[replicaDraw] = M[surfaceOrigin] * Tr[replica->position()] * Tr[replica] * Tr[anchor2center]
414     //                       = M[owningLayer->draw] * Tr[origin2center].inverse() * Tr[replica->position()] * Tr[replica] * Tr[anchor2clippedCenter]
415     //
416     // The replica origin transform to its target surface origin is:
417     //        M[replicaOrigin] = M[surfaceOrigin] * Tr[replica->position()] * Tr[replica] * Tr[origin2anchor].inverse()
418     //
419     // The replica origin transform to the root (screen space) origin is:
420     //        M[replica2root] = M[surface2root] * Tr[replica->position()] * Tr[replica] * Tr[origin2anchor].inverse()
421     //
422
423     if (subtreeShouldBeSkipped(layer))
424         return false;
425
426     float drawOpacity = layer->opacity();
427     bool drawOpacityIsAnimating = layer->opacityIsAnimating();
428     if (layer->parent() && layer->parent()->preserves3D()) {
429         drawOpacity *= layer->parent()->drawOpacity();
430         drawOpacityIsAnimating |= layer->parent()->drawOpacityIsAnimating();
431     }
432
433     IntSize bounds = layer->bounds();
434     FloatPoint anchorPoint = layer->anchorPoint();
435     FloatPoint position = layer->position() - layer->scrollDelta();
436
437     // Offset between anchor point and the center of the quad.
438     float centerOffsetX = (0.5 - anchorPoint.x()) * bounds.width();
439     float centerOffsetY = (0.5 - anchorPoint.y()) * bounds.height();
440
441     WebTransformationMatrix layerLocalTransform;
442     // LT = Tr[origin] * S[pageScaleDelta]
443     layerLocalTransform.scale(layer->pageScaleDelta());
444     // LT = Tr[origin] * S[pageScaleDelta] * Tr[origin2anchor]
445     layerLocalTransform.translate3d(position.x(), position.y(), layer->anchorPointZ());
446     // LT = Tr[origin] * S[pageScaleDelta] * Tr[origin2anchor] * M[layer]
447     layerLocalTransform.multiply(layer->transform());
448     // LT = Tr[origin] * S[pageScaleDelta] * Tr[origin2anchor] * M[layer] * Tr[anchor2center]
449     layerLocalTransform.translate3d(centerOffsetX, centerOffsetY, -layer->anchorPointZ());
450
451     WebTransformationMatrix combinedTransform = parentMatrix;
452     combinedTransform.multiply(layerLocalTransform);
453
454     bool animatingTransformToTarget = layer->transformIsAnimating();
455     bool animatingTransformToScreen = animatingTransformToTarget;
456     if (layer->parent()) {
457         animatingTransformToTarget |= layer->parent()->drawTransformIsAnimating();
458         animatingTransformToScreen |= layer->parent()->screenSpaceTransformIsAnimating();
459     }
460
461     FloatRect layerRect(-0.5 * layer->bounds().width(), -0.5 * layer->bounds().height(), layer->bounds().width(), layer->bounds().height());
462     IntRect transformedLayerRect;
463
464     // fullHierarchyMatrix is the matrix that transforms objects between screen space (except projection matrix) and the most recent RenderSurface's space.
465     // nextHierarchyMatrix will only change if this layer uses a new RenderSurface, otherwise remains the same.
466     WebTransformationMatrix nextHierarchyMatrix = fullHierarchyMatrix;
467
468     // FIXME: This seems like the wrong place to set this
469     layer->setUsesLayerClipping(false);
470
471     if (subtreeShouldRenderToSeparateSurface(layer, isScaleOrTranslation(combinedTransform))) {
472         // Check back-face visibility before continuing with this surface and its subtree
473         if (!layer->doubleSided() && transformToParentIsKnown(layer) && isSurfaceBackFaceVisible(layer, combinedTransform))
474             return false;
475
476         if (!layer->renderSurface())
477             layer->createRenderSurface();
478
479         RenderSurfaceType* renderSurface = layer->renderSurface();
480         renderSurface->clearLayerList();
481
482         // The origin of the new surface is the upper left corner of the layer.
483         WebTransformationMatrix drawTransform;
484         drawTransform.translate3d(0.5 * bounds.width(), 0.5 * bounds.height(), 0);
485         layer->setDrawTransform(drawTransform);
486
487         transformedLayerRect = IntRect(0, 0, bounds.width(), bounds.height());
488
489         // The opacity value is moved from the layer to its surface, so that the entire subtree properly inherits opacity.
490         renderSurface->setDrawOpacity(drawOpacity);
491         renderSurface->setDrawOpacityIsAnimating(drawOpacityIsAnimating);
492         layer->setDrawOpacity(1);
493         layer->setDrawOpacityIsAnimating(false);
494
495         WebTransformationMatrix surfaceOriginTransform = combinedTransform;
496         surfaceOriginTransform.translate3d(-0.5 * bounds.width(), -0.5 * bounds.height(), 0);
497         renderSurface->setOriginTransform(surfaceOriginTransform);
498
499         renderSurface->setTargetSurfaceTransformsAreAnimating(animatingTransformToTarget);
500         renderSurface->setScreenSpaceTransformsAreAnimating(animatingTransformToScreen);
501         animatingTransformToTarget = false;
502         layer->setDrawTransformIsAnimating(animatingTransformToTarget);
503         layer->setScreenSpaceTransformIsAnimating(animatingTransformToScreen);
504
505         // Update the aggregate hierarchy matrix to include the transform of the newly created RenderSurface.
506         nextHierarchyMatrix.multiply(surfaceOriginTransform);
507
508         // The render surface clipRect contributes to the scissor rect that needs to
509         // be applied before drawing the render surface onto its containing
510         // surface and is therefore expressed in the parent's coordinate system.
511         renderSurface->setClipRect(layer->parent() ? layer->parent()->clipRect() : layer->clipRect());
512
513         // The layer's clipRect can be reset here. The renderSurface will correctly clip the subtree.
514         layer->setUsesLayerClipping(false);
515         layer->setClipRect(IntRect());
516
517         if (layer->maskLayer())
518             layer->maskLayer()->setTargetRenderSurface(renderSurface);
519
520         if (layer->replicaLayer() && layer->replicaLayer()->maskLayer())
521             layer->replicaLayer()->maskLayer()->setTargetRenderSurface(renderSurface);
522
523         renderSurface->setFilters(layer->filters());
524         if (renderSurface->filters().hasFilterThatMovesPixels())
525             nearestAncestorThatMovesPixels = renderSurface;
526         renderSurface->setNearestAncestorThatMovesPixels(nearestAncestorThatMovesPixels);
527
528         renderSurface->setBackgroundFilters(layer->backgroundFilters());
529
530         renderSurfaceLayerList.append(layer);
531     } else {
532         layer->setDrawTransform(combinedTransform);
533         layer->setDrawTransformIsAnimating(animatingTransformToTarget);
534         layer->setScreenSpaceTransformIsAnimating(animatingTransformToScreen);
535         transformedLayerRect = enclosingIntRect(CCMathUtil::mapClippedRect(layer->drawTransform(), layerRect));
536
537         layer->setDrawOpacity(drawOpacity);
538         layer->setDrawOpacityIsAnimating(drawOpacityIsAnimating);
539
540         if (layer != rootLayer) {
541             ASSERT(layer->parent());
542             layer->clearRenderSurface();
543
544             // Layers inherit the clip rect from their parent.
545             layer->setClipRect(layer->parent()->clipRect());
546             if (layer->parent()->usesLayerClipping())
547                 layer->setUsesLayerClipping(true);
548
549             // Layers without their own renderSurface will render into the nearest ancestor surface.
550             layer->setTargetRenderSurface(layer->parent()->targetRenderSurface());
551         }
552     }
553
554     if (layer->masksToBounds()) {
555         IntRect clipRect = transformedLayerRect;
556
557         // If the layer already inherited a clipRect, we need to intersect with it before
558         // overriding the layer's clipRect and usesLayerClipping.
559         if (layer->usesLayerClipping())
560             clipRect.intersect(layer->clipRect());
561
562         layer->setClipRect(clipRect);
563         layer->setUsesLayerClipping(true);
564     }
565
566     // Note that at this point, layer->drawTransform() is not necessarily the same as local variable drawTransform.
567     // layerScreenSpaceTransform represents the transform between root layer's "screen space" and local layer space.
568     WebTransformationMatrix layerScreenSpaceTransform = nextHierarchyMatrix;
569     layerScreenSpaceTransform.multiply(layer->drawTransform());
570     layerScreenSpaceTransform.translate3d(-0.5 * bounds.width(), -0.5 * bounds.height(), 0);
571     layer->setScreenSpaceTransform(layerScreenSpaceTransform);
572
573     // drawableContentRect() is always stored in the coordinate system of the
574     // RenderSurface the layer draws into.
575     if (layer->drawsContent()) {
576         IntRect drawableContentRect = transformedLayerRect;
577         if (layer->usesLayerClipping())
578             drawableContentRect.intersect(layer->clipRect());
579         layer->setDrawableContentRect(drawableContentRect);
580     } else
581         layer->setDrawableContentRect(IntRect());
582
583     WebTransformationMatrix sublayerMatrix = layer->drawTransform();
584
585     // Flatten to 2D if the layer doesn't preserve 3D.
586     if (!layer->preserves3D()) {
587         sublayerMatrix.setM13(0);
588         sublayerMatrix.setM23(0);
589         sublayerMatrix.setM31(0);
590         sublayerMatrix.setM32(0);
591         sublayerMatrix.setM33(1);
592         sublayerMatrix.setM34(0);
593         sublayerMatrix.setM43(0);
594     }
595
596     // Apply the sublayer transform at the center of the layer.
597     sublayerMatrix.multiply(layer->sublayerTransform());
598
599     // The coordinate system given to children is located at the layer's origin, not the center.
600     sublayerMatrix.translate3d(-bounds.width() * 0.5, -bounds.height() * 0.5, 0);
601
602     LayerList& descendants = (layer->renderSurface() ? layer->renderSurface()->layerList() : layerList);
603
604     // Any layers that are appended after this point are in the layer's subtree and should be included in the sorting process.
605     unsigned sortingStartIndex = descendants.size();
606
607     if (!layerShouldBeSkipped(layer))
608         descendants.append(layer);
609
610     for (size_t i = 0; i < layer->children().size(); ++i) {
611         LayerType* child = layer->children()[i].get();
612         bool drawsContent = calculateDrawTransformsInternal<LayerType, LayerList, RenderSurfaceType, LayerSorter>(child, rootLayer, sublayerMatrix, nextHierarchyMatrix, nearestAncestorThatMovesPixels, renderSurfaceLayerList, descendants, layerSorter, maxTextureSize);
613
614         if (drawsContent) {
615             if (child->renderSurface()) {
616                 RenderSurfaceType* childRenderSurface = child->renderSurface();
617                 IntRect drawableContentRect = layer->drawableContentRect();
618                 drawableContentRect.unite(enclosingIntRect(childRenderSurface->drawableContentRect()));
619                 layer->setDrawableContentRect(drawableContentRect);
620                 descendants.append(child);
621             } else {
622                 IntRect drawableContentRect = layer->drawableContentRect();
623                 drawableContentRect.unite(child->drawableContentRect());
624                 layer->setDrawableContentRect(drawableContentRect);
625             }
626         }
627     }
628
629     if (layer->masksToBounds() || layer->maskLayer()) {
630         IntRect drawableContentRect = layer->drawableContentRect();
631         drawableContentRect.intersect(transformedLayerRect);
632         layer->setDrawableContentRect(drawableContentRect);
633     }
634
635     if (layer->renderSurface() && layer != rootLayer) {
636         RenderSurfaceType* renderSurface = layer->renderSurface();
637         IntRect clippedContentRect = layer->drawableContentRect();
638         FloatPoint surfaceCenter = FloatRect(clippedContentRect).center();
639
640         // Restrict the RenderSurface size to the portion that's visible.
641         FloatSize centerOffsetDueToClipping;
642
643         // Don't clip if the layer is reflected as the reflection shouldn't be
644         // clipped. If the layer is animating, then the surface's transform to
645         // its target is not known on the main thread, and we should not use it
646         // to clip.
647         if (!layer->replicaLayer() && transformToParentIsKnown(layer)) {
648             if (!renderSurface->clipRect().isEmpty() && !clippedContentRect.isEmpty()) {
649                 IntRect surfaceClipRect = CCLayerTreeHostCommon::calculateVisibleRect(renderSurface->clipRect(), clippedContentRect, renderSurface->originTransform());
650                 clippedContentRect.intersect(surfaceClipRect);
651             }
652             FloatPoint clippedSurfaceCenter = FloatRect(clippedContentRect).center();
653             centerOffsetDueToClipping = clippedSurfaceCenter - surfaceCenter;
654         }
655
656         // The RenderSurface backing texture cannot exceed the maximum supported
657         // texture size.
658         clippedContentRect.setWidth(std::min(clippedContentRect.width(), maxTextureSize));
659         clippedContentRect.setHeight(std::min(clippedContentRect.height(), maxTextureSize));
660
661         if (clippedContentRect.isEmpty())
662             renderSurface->clearLayerList();
663
664         renderSurface->setContentRect(clippedContentRect);
665
666         // Since the layer starts a new render surface we need to adjust its
667         // clipRect to be expressed in the new surface's coordinate system.
668         layer->setClipRect(layer->drawableContentRect());
669
670         // Adjust the origin of the transform to be the center of the render surface.
671         WebTransformationMatrix drawTransform = renderSurface->originTransform();
672         drawTransform.translate3d(surfaceCenter.x() + centerOffsetDueToClipping.width(), surfaceCenter.y() + centerOffsetDueToClipping.height(), 0);
673         renderSurface->setDrawTransform(drawTransform);
674
675         // The layer's origin is equal to the surface's origin so the screenSpaceTransform is the same.
676         renderSurface->setScreenSpaceTransform(layer->screenSpaceTransform());
677
678         if (layer->replicaLayer()) {
679             // Compute the transformation matrix used to draw the surface's replica to the target surface.
680             WebTransformationMatrix replicaDrawTransform = renderSurface->originTransform();
681             replicaDrawTransform.translate(layer->replicaLayer()->position().x(), layer->replicaLayer()->position().y());
682             replicaDrawTransform.multiply(layer->replicaLayer()->transform());
683             replicaDrawTransform.translate(surfaceCenter.x() - anchorPoint.x() * bounds.width(), surfaceCenter.y() - anchorPoint.y() * bounds.height());
684             renderSurface->setReplicaDrawTransform(replicaDrawTransform);
685
686             WebTransformationMatrix surfaceOriginToReplicaOriginTransform;
687             surfaceOriginToReplicaOriginTransform.translate(layer->replicaLayer()->position().x(), layer->replicaLayer()->position().y());
688             surfaceOriginToReplicaOriginTransform.multiply(layer->replicaLayer()->transform());
689             surfaceOriginToReplicaOriginTransform.translate(-anchorPoint.x() * bounds.width(), -anchorPoint.y() * bounds.height());
690
691             // Compute the replica's "originTransform" that maps from the replica's origin space to the target surface origin space.
692             WebTransformationMatrix replicaOriginTransform = layer->renderSurface()->originTransform() * surfaceOriginToReplicaOriginTransform;
693             renderSurface->setReplicaOriginTransform(replicaOriginTransform);
694
695             // Compute the replica's "screenSpaceTransform" that maps from the replica's origin space to the screen's origin space.
696             WebTransformationMatrix replicaScreenSpaceTransform = layer->renderSurface()->screenSpaceTransform() * surfaceOriginToReplicaOriginTransform;
697             renderSurface->setReplicaScreenSpaceTransform(replicaScreenSpaceTransform);
698         }
699
700         // If a render surface has no layer list, then it and none of its children needed to get drawn.
701         if (!layer->renderSurface()->layerList().size()) {
702             // FIXME: Originally we asserted that this layer was already at the end of the
703             //        list, and only needed to remove that layer. For now, we remove the
704             //        entire subtree of surfaces to fix a crash bug. The root cause is
705             //        https://bugs.webkit.org/show_bug.cgi?id=74147 and we should be able
706             //        to put the original assert after fixing that.
707             while (renderSurfaceLayerList.last() != layer) {
708                 renderSurfaceLayerList.last()->clearRenderSurface();
709                 renderSurfaceLayerList.removeLast();
710             }
711             ASSERT(renderSurfaceLayerList.last() == layer);
712             renderSurfaceLayerList.removeLast();
713             layer->clearRenderSurface();
714             return false;
715         }
716     }
717
718     // If neither this layer nor any of its children were added, early out.
719     if (sortingStartIndex == descendants.size())
720         return false;
721
722     // If preserves-3d then sort all the descendants in 3D so that they can be
723     // drawn from back to front. If the preserves-3d property is also set on the parent then
724     // skip the sorting as the parent will sort all the descendants anyway.
725     if (descendants.size() && layer->preserves3D() && (!layer->parent() || !layer->parent()->preserves3D()))
726         sortLayers(&descendants.at(sortingStartIndex), descendants.end(), layerSorter);
727
728     return true;
729 }
730
731 // FIXME: Instead of using the following function to set visibility rects on a second
732 // tree pass, revise calculateVisibleLayerRect() so that this can be done in a single
733 // pass inside calculateDrawTransformsInternal<>().
734 template<typename LayerType, typename LayerList, typename RenderSurfaceType>
735 static void calculateVisibleAndScissorRectsInternal(const LayerList& renderSurfaceLayerList, const FloatRect& rootScissorRect)
736 {
737     // Use BackToFront since it's cheap and this isn't order-dependent.
738     typedef CCLayerIterator<LayerType, LayerList, RenderSurfaceType, CCLayerIteratorActions::BackToFront> CCLayerIteratorType;
739
740     CCLayerIteratorType end = CCLayerIteratorType::end(&renderSurfaceLayerList);
741     for (CCLayerIteratorType it = CCLayerIteratorType::begin(&renderSurfaceLayerList); it != end; ++it) {
742         if (!it.representsTargetRenderSurface()) {
743             IntRect visibleLayerRect = calculateVisibleLayerRect(*it);
744             it->setVisibleLayerRect(visibleLayerRect);
745         }
746         if (it.representsItself()) {
747             IntRect scissorRect = calculateLayerScissorRect<LayerType, RenderSurfaceType>(*it, rootScissorRect);
748             it->setScissorRect(scissorRect);
749         } else if (it.representsContributingRenderSurface()) {
750             IntRect scissorRect = calculateSurfaceScissorRect<LayerType, RenderSurfaceType>(*it, rootScissorRect);
751             it->renderSurface()->setScissorRect(scissorRect);
752         }
753     }
754 }
755
756 void CCLayerTreeHostCommon::calculateDrawTransforms(LayerChromium* layer, LayerChromium* rootLayer, const WebTransformationMatrix& parentMatrix, const WebTransformationMatrix& fullHierarchyMatrix, Vector<RefPtr<LayerChromium> >& renderSurfaceLayerList, Vector<RefPtr<LayerChromium> >& layerList, int maxTextureSize)
757 {
758     WebCore::calculateDrawTransformsInternal<LayerChromium, Vector<RefPtr<LayerChromium> >, RenderSurfaceChromium, void>(layer, rootLayer, parentMatrix, fullHierarchyMatrix, 0, renderSurfaceLayerList, layerList, 0, maxTextureSize);
759 }
760
761 void CCLayerTreeHostCommon::calculateDrawTransforms(CCLayerImpl* layer, CCLayerImpl* rootLayer, const WebTransformationMatrix& parentMatrix, const WebTransformationMatrix& fullHierarchyMatrix, Vector<CCLayerImpl*>& renderSurfaceLayerList, Vector<CCLayerImpl*>& layerList, CCLayerSorter* layerSorter, int maxTextureSize)
762 {
763     WebCore::calculateDrawTransformsInternal<CCLayerImpl, Vector<CCLayerImpl*>, CCRenderSurface, CCLayerSorter>(layer, rootLayer, parentMatrix, fullHierarchyMatrix, 0, renderSurfaceLayerList, layerList, layerSorter, maxTextureSize);
764 }
765
766 void CCLayerTreeHostCommon::calculateVisibleAndScissorRects(Vector<RefPtr<LayerChromium> >& renderSurfaceLayerList, const FloatRect& rootScissorRect)
767 {
768     calculateVisibleAndScissorRectsInternal<LayerChromium, Vector<RefPtr<LayerChromium> >, RenderSurfaceChromium>(renderSurfaceLayerList, rootScissorRect);
769 }
770
771 void CCLayerTreeHostCommon::calculateVisibleAndScissorRects(Vector<CCLayerImpl*>& renderSurfaceLayerList, const FloatRect& rootScissorRect)
772 {
773     calculateVisibleAndScissorRectsInternal<CCLayerImpl, Vector<CCLayerImpl*>, CCRenderSurface>(renderSurfaceLayerList, rootScissorRect);
774 }
775
776 } // namespace WebCore