[chromium] Do not clip root layer's subtree to viewport
[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 "CCLayerTreeHostCommon.h"
29
30 #include "CCLayerImpl.h"
31 #include "CCLayerIterator.h"
32 #include "CCLayerSorter.h"
33 #include "CCMathUtil.h"
34 #include "CCRenderSurface.h"
35 #include "FloatQuad.h"
36 #include "IntRect.h"
37 #include "LayerChromium.h"
38 #include "RenderSurfaceChromium.h"
39 #include <public/WebTransformationMatrix.h>
40
41 using WebKit::WebTransformationMatrix;
42
43 namespace WebCore {
44
45 IntRect CCLayerTreeHostCommon::calculateVisibleRect(const IntRect& targetSurfaceRect, const IntRect& layerBoundRect, const WebTransformationMatrix& transform)
46 {
47     // Is this layer fully contained within the target surface?
48     IntRect layerInSurfaceSpace = CCMathUtil::mapClippedRect(transform, layerBoundRect);
49     if (targetSurfaceRect.contains(layerInSurfaceSpace))
50         return layerBoundRect;
51
52     // If the layer doesn't fill up the entire surface, then find the part of
53     // the surface rect where the layer could be visible. This avoids trying to
54     // project surface rect points that are behind the projection point.
55     IntRect minimalSurfaceRect = targetSurfaceRect;
56     minimalSurfaceRect.intersect(layerInSurfaceSpace);
57
58     // Project the corners of the target surface rect into the layer space.
59     // This bounding rectangle may be larger than it needs to be (being
60     // axis-aligned), but is a reasonable filter on the space to consider.
61     // Non-invertible transforms will create an empty rect here.
62     const WebTransformationMatrix surfaceToLayer = transform.inverse();
63     IntRect layerRect = enclosingIntRect(CCMathUtil::projectClippedRect(surfaceToLayer, FloatRect(minimalSurfaceRect)));
64     layerRect.intersect(layerBoundRect);
65     return layerRect;
66 }
67
68 template<typename LayerType>
69 static inline bool layerIsInExisting3DRenderingContext(LayerType* layer)
70 {
71     // According to current W3C spec on CSS transforms, a layer is part of an established
72     // 3d rendering context if its parent has transform-style of preserves-3d.
73     return layer->parent() && layer->parent()->preserves3D();
74 }
75
76 template<typename LayerType>
77 static bool layerIsRootOfNewRenderingContext(LayerType* layer)
78 {
79     // According to current W3C spec on CSS transforms (Section 6.1), a layer is the
80     // beginning of 3d rendering context if its parent does not have transform-style:
81     // preserve-3d, but this layer itself does.
82     if (layer->parent())
83         return !layer->parent()->preserves3D() && layer->preserves3D();
84
85     return layer->preserves3D();
86 }
87
88 template<typename LayerType>
89 static bool isLayerBackFaceVisible(LayerType* layer)
90 {
91     // The current W3C spec on CSS transforms says that backface visibility should be
92     // determined differently depending on whether the layer is in a "3d rendering
93     // context" or not. For Chromium code, we can determine whether we are in a 3d
94     // rendering context by checking if the parent preserves 3d.
95
96     if (layerIsInExisting3DRenderingContext(layer))
97         return layer->drawTransform().isBackFaceVisible();
98
99     // In this case, either the layer establishes a new 3d rendering context, or is not in
100     // a 3d rendering context at all.
101     return layer->transform().isBackFaceVisible();
102 }
103
104 template<typename LayerType>
105 static bool isSurfaceBackFaceVisible(LayerType* layer, const WebTransformationMatrix& drawTransform)
106 {
107     if (layerIsInExisting3DRenderingContext(layer))
108         return drawTransform.isBackFaceVisible();
109
110     if (layerIsRootOfNewRenderingContext(layer))
111         return layer->transform().isBackFaceVisible();
112
113     // If the renderSurface is not part of a new or existing rendering context, then the
114     // layers that contribute to this surface will decide back-face visibility for themselves.
115     return false;
116 }
117
118 template<typename LayerType>
119 static inline bool layerClipsSubtree(LayerType* layer)
120 {
121     return layer->masksToBounds() || layer->maskLayer();
122 }
123
124 template<typename LayerType>
125 static IntRect calculateVisibleContentRect(LayerType* layer)
126 {
127     ASSERT(layer->renderTarget());
128
129     IntRect targetSurfaceRect = layer->renderTarget()->renderSurface()->contentRect();
130
131     targetSurfaceRect.intersect(layer->drawableContentRect());
132
133     if (targetSurfaceRect.isEmpty() || layer->contentBounds().isEmpty())
134         return IntRect();
135
136     const IntRect contentRect = IntRect(IntPoint(), layer->contentBounds());
137     IntRect visibleContentRect = CCLayerTreeHostCommon::calculateVisibleRect(targetSurfaceRect, contentRect, layer->drawTransform());
138     return visibleContentRect;
139 }
140
141 static bool isScaleOrTranslation(const WebTransformationMatrix& m)
142 {
143     return !m.m12() && !m.m13() && !m.m14()
144            && !m.m21() && !m.m23() && !m.m24()
145            && !m.m31() && !m.m32() && !m.m43()
146            && m.m44();
147 }
148
149 static inline bool transformToParentIsKnown(CCLayerImpl*)
150 {
151     return true;
152 }
153
154 static inline bool transformToParentIsKnown(LayerChromium* layer)
155 {
156     return !layer->transformIsAnimating();
157 }
158
159 static inline bool transformToScreenIsKnown(CCLayerImpl*)
160 {
161     return true;
162 }
163
164 static inline bool transformToScreenIsKnown(LayerChromium* layer)
165 {
166     return !layer->screenSpaceTransformIsAnimating();
167 }
168
169 template<typename LayerType>
170 static bool layerShouldBeSkipped(LayerType* layer)
171 {
172     // Layers can be skipped if any of these conditions are met.
173     //   - does not draw content.
174     //   - is transparent
175     //   - has empty bounds
176     //   - the layer is not double-sided, but its back face is visible.
177     //
178     // Some additional conditions need to be computed at a later point after the recursion is finished.
179     //   - the intersection of render surface content and layer clipRect is empty
180     //   - the visibleContentRect is empty
181     //
182     // Note, if the layer should not have been drawn due to being fully transparent,
183     // we would have skipped the entire subtree and never made it into this function,
184     // so it is safe to omit this check here.
185
186     if (!layer->drawsContent() || layer->bounds().isEmpty())
187         return true;
188
189     LayerType* backfaceTestLayer = layer;
190     if (layer->useParentBackfaceVisibility()) {
191         ASSERT(layer->parent());
192         ASSERT(!layer->parent()->useParentBackfaceVisibility());
193         backfaceTestLayer = layer->parent();
194     }
195
196     // 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.
197     if (!backfaceTestLayer->doubleSided() && transformToScreenIsKnown(backfaceTestLayer) && isLayerBackFaceVisible(backfaceTestLayer))
198         return true;
199
200     return false;
201 }
202
203 static inline bool subtreeShouldBeSkipped(CCLayerImpl* layer)
204 {
205     // The opacity of a layer always applies to its children (either implicitly
206     // via a render surface or explicitly if the parent preserves 3D), so the
207     // entire subtree can be skipped if this layer is fully transparent.
208     return !layer->opacity();
209 }
210
211 static inline bool subtreeShouldBeSkipped(LayerChromium* layer)
212 {
213     // If the opacity is being animated then the opacity on the main thread is unreliable
214     // (since the impl thread may be using a different opacity), so it should not be trusted.
215     // In particular, it should not cause the subtree to be skipped.
216     return !layer->opacity() && !layer->opacityIsAnimating();
217 }
218
219 template<typename LayerType>
220 static bool subtreeShouldRenderToSeparateSurface(LayerType* layer, bool axisAlignedWithRespectToParent)
221 {
222     // The root layer has a special render surface that is set up externally, so
223     // it shouldn't be treated as a surface in this code.
224     if (!layer->parent())
225         return false;
226
227     // Cache this value, because otherwise it walks the entire subtree several times.
228     bool descendantDrawsContent = layer->descendantDrawsContent();
229
230     //
231     // A layer and its descendants should render onto a new RenderSurface if any of these rules hold:
232     //
233
234     // If we force it.
235     if (layer->forceRenderSurface())
236         return true;
237
238     // If the layer uses a mask.
239     if (layer->maskLayer())
240         return true;
241
242     // If the layer has a reflection.
243     if (layer->replicaLayer())
244         return true;
245
246     // If the layer uses a CSS filter.
247     if (!layer->filters().isEmpty() || !layer->backgroundFilters().isEmpty())
248         return true;
249
250     // If the layer flattens its subtree (i.e. the layer doesn't preserve-3d), but it is
251     // treated as a 3D object by its parent (i.e. parent does preserve-3d).
252     if (layerIsInExisting3DRenderingContext(layer) && !layer->preserves3D() && descendantDrawsContent)
253         return true;
254
255     // If the layer clips its descendants but it is not axis-aligned with respect to its parent.
256     if (layerClipsSubtree(layer) && !axisAlignedWithRespectToParent && descendantDrawsContent)
257         return true;
258
259     // If the layer has opacity != 1 and does not have a preserves-3d transform style.
260     if (layer->opacity() != 1 && !layer->preserves3D() && descendantDrawsContent)
261         return true;
262
263     return false;
264 }
265
266 WebTransformationMatrix computeScrollCompensationForThisLayer(CCLayerImpl* scrollingLayer, const WebTransformationMatrix& parentMatrix)
267 {
268     // For every layer that has non-zero scrollDelta, we have to compute a transform that can undo the
269     // scrollDelta translation. In particular, we want this matrix to premultiply a fixed-position layer's
270     // parentMatrix, so we design this transform in three steps as follows. The steps described here apply
271     // from right-to-left, so Step 1 would be the right-most matrix:
272     //
273     //     Step 1. transform from target surface space to the exact space where scrollDelta is actually applied.
274     //           -- this is inverse of the matrix in step 3
275     //     Step 2. undo the scrollDelta
276     //           -- this is just a translation by scrollDelta.
277     //     Step 3. transform back to target surface space.
278     //           -- this transform is the "partialLayerOriginTransform" = (parentMatrix * scale(layer->pageScaleDelta()));
279     //
280     // These steps create a matrix that both start and end in targetSurfaceSpace. So this matrix can
281     // pre-multiply any fixed-position layer's drawTransform to undo the scrollDeltas -- as long as
282     // that fixed position layer is fixed onto the same renderTarget as this scrollingLayer.
283     //
284
285     WebTransformationMatrix partialLayerOriginTransform = parentMatrix;
286     partialLayerOriginTransform.scale(scrollingLayer->pageScaleDelta());
287
288     WebTransformationMatrix scrollCompensationForThisLayer = partialLayerOriginTransform; // Step 3
289     scrollCompensationForThisLayer.translate(scrollingLayer->scrollDelta().width(), scrollingLayer->scrollDelta().height()); // Step 2
290     scrollCompensationForThisLayer.multiply(partialLayerOriginTransform.inverse()); // Step 1
291     return scrollCompensationForThisLayer;
292 }
293
294 WebTransformationMatrix computeScrollCompensationMatrixForChildren(LayerChromium* currentLayer, const WebTransformationMatrix& currentParentMatrix, const WebTransformationMatrix& currentScrollCompensation)
295 {
296     // The main thread (i.e. LayerChromium) does not need to worry about scroll compensation.
297     // So we can just return an identity matrix here.
298     return WebTransformationMatrix();
299 }
300
301 WebTransformationMatrix computeScrollCompensationMatrixForChildren(CCLayerImpl* layer, const WebTransformationMatrix& parentMatrix, const WebTransformationMatrix& currentScrollCompensationMatrix)
302 {
303     // "Total scroll compensation" is the transform needed to cancel out all scrollDelta translations that
304     // occurred since the nearest container layer, even if there are renderSurfaces in-between.
305     //
306     // There are some edge cases to be aware of, that are not explicit in the code:
307     //  - A layer that is both a fixed-position and container should not be its own container, instead, that means
308     //    it is fixed to an ancestor, and is a container for any fixed-position descendants.
309     //  - A layer that is a fixed-position container and has a renderSurface should behave the same as a container
310     //    without a renderSurface, the renderSurface is irrelevant in that case.
311     //  - A layer that does not have an explicit container is simply fixed to the viewport
312     //    (i.e. the root renderSurface, and it would still compensate for root layer's scrollDelta).
313     //  - If the fixed-position layer has its own renderSurface, then the renderSurface is
314     //    the one who gets fixed.
315     //
316     // This function needs to be called AFTER layers create their own renderSurfaces.
317     //
318
319     // Avoid the overheads (including stack allocation and matrix initialization/copy) if we know that the scroll compensation doesn't need to be reset or adjusted.
320     if (!layer->isContainerForFixedPositionLayers() && layer->scrollDelta().isZero() && !layer->renderSurface())
321         return currentScrollCompensationMatrix;
322
323     // Start as identity matrix.
324     WebTransformationMatrix nextScrollCompensationMatrix;
325
326     // If this layer is not a container, then it inherits the existing scroll compensations.
327     if (!layer->isContainerForFixedPositionLayers())
328         nextScrollCompensationMatrix = currentScrollCompensationMatrix;
329
330     // If the current layer has a non-zero scrollDelta, then we should compute its local scrollCompensation
331     // and accumulate it to the nextScrollCompensationMatrix.
332     if (!layer->scrollDelta().isZero()) {
333         WebTransformationMatrix scrollCompensationForThisLayer = computeScrollCompensationForThisLayer(layer, parentMatrix);
334         nextScrollCompensationMatrix.multiply(scrollCompensationForThisLayer);
335     }
336
337     // If the layer created its own renderSurface, we have to adjust nextScrollCompensationMatrix.
338     // The adjustment allows us to continue using the scrollCompensation on the next surface.
339     //  Step 1 (right-most in the math): transform from the new surface to the original ancestor surface
340     //  Step 2: apply the scroll compensation
341     //  Step 3: transform back to the new surface.
342     if (layer->renderSurface() && !nextScrollCompensationMatrix.isIdentity())
343         nextScrollCompensationMatrix = layer->renderSurface()->drawTransform().inverse() * nextScrollCompensationMatrix * layer->renderSurface()->drawTransform();
344
345     return nextScrollCompensationMatrix;
346 }
347
348 // Should be called just before the recursive calculateDrawTransformsInternal().
349 template<typename LayerType, typename LayerList>
350 void setupRootLayerAndSurfaceForRecursion(LayerType* rootLayer, LayerList& renderSurfaceLayerList, const IntSize& deviceViewportSize)
351 {
352     if (!rootLayer->renderSurface())
353         rootLayer->createRenderSurface();
354
355     rootLayer->renderSurface()->setContentRect(IntRect(IntPoint::zero(), deviceViewportSize));
356     rootLayer->renderSurface()->clearLayerList();
357
358     ASSERT(renderSurfaceLayerList.isEmpty());
359     renderSurfaceLayerList.append(rootLayer);
360 }
361
362 // Recursively walks the layer tree starting at the given node and computes all the
363 // necessary transformations, clipRects, render surfaces, etc.
364 template<typename LayerType, typename LayerList, typename RenderSurfaceType, typename LayerSorter>
365 static void calculateDrawTransformsInternal(LayerType* layer, LayerType* rootLayer, const WebTransformationMatrix& parentMatrix,
366     const WebTransformationMatrix& fullHierarchyMatrix, const WebTransformationMatrix& currentScrollCompensationMatrix,
367     const IntRect& clipRectFromAncestor, bool ancestorClipsSubtree,
368     RenderSurfaceType* nearestAncestorThatMovesPixels, LayerList& renderSurfaceLayerList, LayerList& layerList,
369     LayerSorter* layerSorter, int maxTextureSize, float deviceScaleFactor, IntRect& drawableContentRectOfSubtree)
370 {
371     // This function computes the new matrix transformations recursively for this
372     // layer and all its descendants. It also computes the appropriate render surfaces.
373     // Some important points to remember:
374     //
375     // 0. Here, transforms are notated in Matrix x Vector order, and in words we describe what
376     //    the transform does from left to right.
377     //
378     // 1. In our terminology, the "layer origin" refers to the top-left corner of a layer, and the
379     //    positive Y-axis points downwards. This interpretation is valid because the orthographic
380     //    projection applied at draw time flips the Y axis appropriately.
381     //
382     // 2. The anchor point, when given as a FloatPoint object, is specified in "unit layer space",
383     //    where the bounds of the layer map to [0, 1]. However, as a WebTransformationMatrix object,
384     //    the transform to the anchor point is specified in "pixel layer space", where the bounds
385     //    of the layer map to [bounds.width(), bounds.height()].
386     //
387     // 3. Definition of various transforms used:
388     //        M[parent] is the parent matrix, with respect to the nearest render surface, passed down recursively.
389     //        M[root] is the full hierarchy, with respect to the root, passed down recursively.
390     //        Tr[origin] is the translation matrix from the parent's origin to this layer's origin.
391     //        Tr[origin2anchor] is the translation from the layer's origin to its anchor point
392     //        Tr[origin2center] is the translation from the layer's origin to its center
393     //        M[layer] is the layer's matrix (applied at the anchor point)
394     //        M[sublayer] is the layer's sublayer transform (applied at the layer's center)
395     //        Tr[anchor2center] is the translation offset from the anchor point and the center of the layer
396     //        S[content2layer] is the ratio of a layer's contentBounds() to its bounds().
397     //
398     //    Some shortcuts and substitutions are used in the code to reduce matrix multiplications:
399     //        Tr[anchor2center] = Tr[origin2anchor].inverse() * Tr[origin2center]
400     //
401     //    Some composite transforms can help in understanding the sequence of transforms:
402     //        compositeLayerTransform = Tr[origin2anchor] * M[layer] * Tr[origin2anchor].inverse()
403     //        compositeSublayerTransform = Tr[origin2center] * M[sublayer] * Tr[origin2center].inverse()
404     //
405     //    In words, the layer transform is applied about the anchor point, and the sublayer transform is
406     //    applied about the center of the layer.
407     //
408     // 4. When a layer (or render surface) is drawn, it is drawn into a "target render surface". Therefore the draw
409     //    transform does not necessarily transform from screen space to local layer space. Instead, the draw transform
410     //    is the transform between the "target render surface space" and local layer space. Note that render surfaces,
411     //    except for the root, also draw themselves into a different target render surface, and so their draw
412     //    transform and origin transforms are also described with respect to the target.
413     //
414     // Using these definitions, then:
415     //
416     // The draw transform for the layer is:
417     //        M[draw] = M[parent] * Tr[origin] * compositeLayerTransform * S[content2layer]
418     //                = M[parent] * Tr[layer->position()] * M[layer] * Tr[anchor2origin] * S[content2layer]
419     //
420     //        Interpreting the math left-to-right, this transforms from the layer's render surface to the origin of the layer in content space.
421     //
422     // The screen space transform is:
423     //        M[screenspace] = M[root] * Tr[origin] * compositeLayerTransform * S[content2layer]
424     //                       = M[root] * Tr[layer->position()] * M[layer] * Tr[origin2anchor].inverse() * S[content2layer]
425     //
426     //        Interpreting the math left-to-right, this transforms from the root render surface's content space to the local layer's origin in layer space.
427     //
428     // The transform hierarchy that is passed on to children (i.e. the child's parentMatrix) is:
429     //        M[parent]_for_child = M[parent] * Tr[origin] * compositeLayerTransform * compositeSublayerTransform
430     //                            = M[parent] * Tr[layer->position()] * M[layer] * Tr[anchor2center] * M[sublayer] * Tr[origin2center].inverse()
431     //                            = M[draw] * M[sublayer] * Tr[origin2center].inverse()
432     //
433     //        and a similar matrix for the full hierarchy with respect to the root.
434     //
435     // Finally, note that the final matrix used by the shader for the layer is P * M[draw] * S . This final product
436     // is computed in drawTexturedQuad(), where:
437     //        P is the projection matrix
438     //        S is the scale adjustment (to scale up to the layer size)
439     //
440     // When a render surface has a replica layer, that layer's transform is used to draw a second copy of the surface.
441     // Transforms named here are relative to the surface, unless they specify they are relative to the replica layer.
442     //
443     // We will denote a scale by device scale S[deviceScale]
444     //
445     // The render surface draw transform to its target surface origin is:
446     //        M[surfaceDraw] = M[owningLayer->Draw]
447     //
448     // The render surface origin transform to its the root (screen space) origin is:
449     //        M[surface2root] =  M[owningLayer->screenspace] * S[deviceScale].inverse()
450     //
451     // The replica draw transform to its target surface origin is:
452     //        M[replicaDraw] = S[deviceScale] * M[surfaceDraw] * Tr[replica->position() + replica->anchor()] * Tr[replica] * Tr[origin2anchor].inverse() * S[contentsScale].inverse()
453     //
454     // The replica draw transform to the root (screen space) origin is:
455     //        M[replica2root] = M[surface2root] * Tr[replica->position()] * Tr[replica] * Tr[origin2anchor].inverse()
456     //
457
458     // If we early-exit anywhere in this function, the drawableContentRect of this subtree should be considered empty.
459     drawableContentRectOfSubtree = IntRect();
460
461     if (subtreeShouldBeSkipped(layer))
462         return;
463
464     IntRect clipRectForSubtree;
465     bool subtreeShouldBeClipped = false;
466     
467     float drawOpacity = layer->opacity();
468     bool drawOpacityIsAnimating = layer->opacityIsAnimating();
469     if (layer->parent() && layer->parent()->preserves3D()) {
470         drawOpacity *= layer->parent()->drawOpacity();
471         drawOpacityIsAnimating |= layer->parent()->drawOpacityIsAnimating();
472     }
473
474     IntSize bounds = layer->bounds();
475     FloatPoint anchorPoint = layer->anchorPoint();
476     FloatPoint position = layer->position() - layer->scrollDelta();
477
478     // Offset between anchor point and the center of the quad.
479     float centerOffsetX = (0.5 - anchorPoint.x()) * bounds.width();
480     float centerOffsetY = (0.5 - anchorPoint.y()) * bounds.height();
481
482     WebTransformationMatrix layerLocalTransform;
483     // LT = S[pageScaleDelta]
484     layerLocalTransform.scale(layer->pageScaleDelta());
485     // LT = S[pageScaleDelta] * Tr[origin] * Tr[origin2anchor]
486     layerLocalTransform.translate3d(position.x() + anchorPoint.x() * bounds.width(), position.y() + anchorPoint.y() * bounds.height(), layer->anchorPointZ());
487     // LT = S[pageScaleDelta] * Tr[origin] * Tr[origin2anchor] * M[layer]
488     layerLocalTransform.multiply(layer->transform());
489     // LT = S[pageScaleDelta] * Tr[origin] * Tr[origin2anchor] * M[layer] * Tr[anchor2center]
490     layerLocalTransform.translate3d(centerOffsetX, centerOffsetY, -layer->anchorPointZ());
491
492     WebTransformationMatrix combinedTransform = parentMatrix;
493     combinedTransform.multiply(layerLocalTransform);
494
495     if (layer->fixedToContainerLayer()) {
496         // Special case: this layer is a composited fixed-position layer; we need to
497         // explicitly compensate for all ancestors' nonzero scrollDeltas to keep this layer
498         // fixed correctly.
499         combinedTransform = currentScrollCompensationMatrix * combinedTransform;
500     }
501
502     // The drawTransform that gets computed below is effectively the layer's drawTransform, unless
503     // the layer itself creates a renderSurface. In that case, the renderSurface re-parents the transforms.
504     WebTransformationMatrix drawTransform = combinedTransform;
505     // M[draw] = M[parent] * LT * Tr[anchor2center] * Tr[center2origin]
506     drawTransform.translate(-layer->bounds().width() / 2.0, -layer->bounds().height() / 2.0);
507     if (!layer->contentBounds().isEmpty() && !layer->bounds().isEmpty()) {
508         // M[draw] = M[parent] * LT * Tr[anchor2origin] * S[layer2content]
509         drawTransform.scaleNonUniform(layer->bounds().width() / static_cast<double>(layer->contentBounds().width()),
510                                       layer->bounds().height() / static_cast<double>(layer->contentBounds().height()));
511     }
512
513     // layerScreenSpaceTransform represents the transform between root layer's "screen space" and local content space.
514     WebTransformationMatrix layerScreenSpaceTransform = fullHierarchyMatrix;
515     if (!layer->preserves3D())
516         CCMathUtil::flattenTransformTo2d(layerScreenSpaceTransform);
517     layerScreenSpaceTransform.multiply(drawTransform);
518     layer->setScreenSpaceTransform(layerScreenSpaceTransform);
519
520     bool animatingTransformToTarget = layer->transformIsAnimating();
521     bool animatingTransformToScreen = animatingTransformToTarget;
522     if (layer->parent()) {
523         animatingTransformToTarget |= layer->parent()->drawTransformIsAnimating();
524         animatingTransformToScreen |= layer->parent()->screenSpaceTransformIsAnimating();
525     }
526
527     FloatRect contentRect(FloatPoint(), layer->contentBounds());
528
529     // fullHierarchyMatrix is the matrix that transforms objects between screen space (except projection matrix) and the most recent RenderSurface's space.
530     // nextHierarchyMatrix will only change if this layer uses a new RenderSurface, otherwise remains the same.
531     WebTransformationMatrix nextHierarchyMatrix = fullHierarchyMatrix;
532     WebTransformationMatrix sublayerMatrix;
533
534     if (subtreeShouldRenderToSeparateSurface(layer, isScaleOrTranslation(combinedTransform))) {
535         // Check back-face visibility before continuing with this surface and its subtree
536         if (!layer->doubleSided() && transformToParentIsKnown(layer) && isSurfaceBackFaceVisible(layer, combinedTransform))
537             return;
538
539         if (!layer->renderSurface())
540             layer->createRenderSurface();
541
542         RenderSurfaceType* renderSurface = layer->renderSurface();
543         renderSurface->clearLayerList();
544
545         // The origin of the new surface is the upper left corner of the layer.
546         renderSurface->setDrawTransform(drawTransform);
547         WebTransformationMatrix layerDrawTransform;
548         layerDrawTransform.scale(deviceScaleFactor);
549         if (!layer->contentBounds().isEmpty() && !layer->bounds().isEmpty()) {
550             layerDrawTransform.scaleNonUniform(layer->bounds().width() / static_cast<double>(layer->contentBounds().width()),
551                                                layer->bounds().height() / static_cast<double>(layer->contentBounds().height()));
552         }
553         layer->setDrawTransform(layerDrawTransform);
554
555         // The sublayer matrix transforms centered layer rects into target
556         // surface content space.
557         sublayerMatrix.makeIdentity();
558         sublayerMatrix.scale(deviceScaleFactor);
559         sublayerMatrix.translate(0.5 * bounds.width(), 0.5 * bounds.height());
560
561         // The opacity value is moved from the layer to its surface, so that the entire subtree properly inherits opacity.
562         renderSurface->setDrawOpacity(drawOpacity);
563         renderSurface->setDrawOpacityIsAnimating(drawOpacityIsAnimating);
564         layer->setDrawOpacity(1);
565         layer->setDrawOpacityIsAnimating(false);
566
567         renderSurface->setTargetSurfaceTransformsAreAnimating(animatingTransformToTarget);
568         renderSurface->setScreenSpaceTransformsAreAnimating(animatingTransformToScreen);
569         animatingTransformToTarget = false;
570         layer->setDrawTransformIsAnimating(animatingTransformToTarget);
571         layer->setScreenSpaceTransformIsAnimating(animatingTransformToScreen);
572
573         // Update the aggregate hierarchy matrix to include the transform of the
574         // newly created RenderSurface.
575         nextHierarchyMatrix.multiply(renderSurface->drawTransform());
576
577         // The new renderSurface here will correctly clip the entire subtree. So, we do
578         // not need to continue propagating the clipping state further down the tree. This
579         // way, we can avoid transforming clipRects from ancestor target surface space to
580         // current target surface space that could cause more w < 0 headaches.
581         subtreeShouldBeClipped = false;
582
583         if (layer->maskLayer())
584             layer->maskLayer()->setRenderTarget(layer);
585
586         if (layer->replicaLayer() && layer->replicaLayer()->maskLayer())
587             layer->replicaLayer()->maskLayer()->setRenderTarget(layer);
588
589         if (layer->filters().hasFilterThatMovesPixels())
590             nearestAncestorThatMovesPixels = renderSurface;
591
592         renderSurface->setNearestAncestorThatMovesPixels(nearestAncestorThatMovesPixels);
593
594         renderSurfaceLayerList.append(layer);
595     } else {
596         layer->setDrawTransform(drawTransform);
597         layer->setDrawTransformIsAnimating(animatingTransformToTarget);
598         layer->setScreenSpaceTransformIsAnimating(animatingTransformToScreen);
599         sublayerMatrix = combinedTransform;
600
601         layer->setDrawOpacity(drawOpacity);
602         layer->setDrawOpacityIsAnimating(drawOpacityIsAnimating);
603
604         if (layer != rootLayer) {
605             ASSERT(layer->parent());
606             layer->clearRenderSurface();
607
608             // Layers without renderSurfaces directly inherit the ancestor's clip status.
609             subtreeShouldBeClipped = ancestorClipsSubtree;
610             if (ancestorClipsSubtree)
611                 clipRectForSubtree = clipRectFromAncestor;
612
613             // Layers that are not their own renderTarget will render into the target of their nearest ancestor.
614             layer->setRenderTarget(layer->parent()->renderTarget());
615         } else {
616             // FIXME: This root layer special case code should eventually go away. https://bugs.webkit.org/show_bug.cgi?id=92290
617             ASSERT(!layer->parent());
618             ASSERT(layer->renderSurface());
619             ASSERT(ancestorClipsSubtree);
620             layer->renderSurface()->setClipRect(clipRectFromAncestor);
621             subtreeShouldBeClipped = false;
622         }
623     }
624
625     IntRect rectInTargetSpace = enclosingIntRect(CCMathUtil::mapClippedRect(layer->drawTransform(), contentRect));
626
627     if (layerClipsSubtree(layer)) {
628         subtreeShouldBeClipped = true;
629         if (ancestorClipsSubtree && !layer->renderSurface()) {
630             clipRectForSubtree = clipRectFromAncestor;
631             clipRectForSubtree.intersect(rectInTargetSpace);
632         } else
633             clipRectForSubtree = rectInTargetSpace;
634     }
635
636     // Flatten to 2D if the layer doesn't preserve 3D.
637     if (!layer->preserves3D())
638         CCMathUtil::flattenTransformTo2d(sublayerMatrix);
639
640     // Apply the sublayer transform at the center of the layer.
641     sublayerMatrix.multiply(layer->sublayerTransform());
642
643     // The coordinate system given to children is located at the layer's origin, not the center.
644     sublayerMatrix.translate3d(-bounds.width() * 0.5, -bounds.height() * 0.5, 0);
645
646     LayerList& descendants = (layer->renderSurface() ? layer->renderSurface()->layerList() : layerList);
647
648     // Any layers that are appended after this point are in the layer's subtree and should be included in the sorting process.
649     unsigned sortingStartIndex = descendants.size();
650
651     if (!layerShouldBeSkipped(layer))
652         descendants.append(layer);
653
654     WebTransformationMatrix nextScrollCompensationMatrix = computeScrollCompensationMatrixForChildren(layer, parentMatrix, currentScrollCompensationMatrix);;
655
656     IntRect accumulatedDrawableContentRectOfChildren;
657     for (size_t i = 0; i < layer->children().size(); ++i) {
658         LayerType* child = layer->children()[i].get();
659         IntRect drawableContentRectOfChildSubtree;
660         calculateDrawTransformsInternal<LayerType, LayerList, RenderSurfaceType, LayerSorter>(child, rootLayer, sublayerMatrix, nextHierarchyMatrix, nextScrollCompensationMatrix,
661                                                                                               clipRectForSubtree, subtreeShouldBeClipped, nearestAncestorThatMovesPixels,
662                                                                                               renderSurfaceLayerList, descendants, layerSorter, maxTextureSize, deviceScaleFactor, drawableContentRectOfChildSubtree);
663         if (!drawableContentRectOfChildSubtree.isEmpty()) {
664             accumulatedDrawableContentRectOfChildren.unite(drawableContentRectOfChildSubtree);
665             if (child->renderSurface())
666                 descendants.append(child);
667         }
668     }
669
670     // Compute the total drawableContentRect for this subtree (the rect is in targetSurface space)
671     IntRect localDrawableContentRectOfSubtree = accumulatedDrawableContentRectOfChildren;
672     if (layer->drawsContent())
673         localDrawableContentRectOfSubtree.unite(rectInTargetSpace);
674     if (subtreeShouldBeClipped)
675         localDrawableContentRectOfSubtree.intersect(clipRectForSubtree);
676
677     // Compute the layer's drawable content rect (the rect is in targetSurface space)
678     IntRect drawableContentRectOfLayer = rectInTargetSpace;
679     if (subtreeShouldBeClipped)
680         drawableContentRectOfLayer.intersect(clipRectForSubtree);
681     layer->setDrawableContentRect(drawableContentRectOfLayer);
682
683     // Compute the remaining properties for the render surface, if the layer has one.
684     if (layer->renderSurface() && layer != rootLayer) {
685         RenderSurfaceType* renderSurface = layer->renderSurface();
686         IntRect clippedContentRect = localDrawableContentRectOfSubtree;
687
688         // The render surface clipRect is expressed in the space where this surface draws, i.e. the same space as clipRectFromAncestor.
689         if (ancestorClipsSubtree)
690             renderSurface->setClipRect(clipRectFromAncestor);
691         else
692             renderSurface->setClipRect(IntRect());
693
694         // Don't clip if the layer is reflected as the reflection shouldn't be
695         // clipped. If the layer is animating, then the surface's transform to
696         // its target is not known on the main thread, and we should not use it
697         // to clip.
698         if (!layer->replicaLayer() && transformToParentIsKnown(layer)) {
699             // Note, it is correct to use ancestorClipsSubtree here, because we are looking at this layer's renderSurface, not the layer itself.
700             if (ancestorClipsSubtree && !clippedContentRect.isEmpty()) {
701                 IntRect surfaceClipRect = CCLayerTreeHostCommon::calculateVisibleRect(renderSurface->clipRect(), clippedContentRect, renderSurface->drawTransform());
702                 clippedContentRect.intersect(surfaceClipRect);
703             }
704         }
705
706         // The RenderSurface backing texture cannot exceed the maximum supported
707         // texture size.
708         clippedContentRect.setWidth(std::min(clippedContentRect.width(), maxTextureSize));
709         clippedContentRect.setHeight(std::min(clippedContentRect.height(), maxTextureSize));
710
711         if (clippedContentRect.isEmpty())
712             renderSurface->clearLayerList();
713
714         renderSurface->setContentRect(clippedContentRect);
715         renderSurface->setScreenSpaceTransform(layer->screenSpaceTransform());
716
717         if (layer->replicaLayer()) {
718             WebTransformationMatrix surfaceOriginToReplicaOriginTransform;
719             surfaceOriginToReplicaOriginTransform.scale(deviceScaleFactor);
720             surfaceOriginToReplicaOriginTransform.translate(layer->replicaLayer()->position().x() + layer->replicaLayer()->anchorPoint().x() * bounds.width(),
721                                                             layer->replicaLayer()->position().y() + layer->replicaLayer()->anchorPoint().y() * bounds.height());
722             surfaceOriginToReplicaOriginTransform.multiply(layer->replicaLayer()->transform());
723             surfaceOriginToReplicaOriginTransform.translate(-layer->replicaLayer()->anchorPoint().x() * bounds.width(), -layer->replicaLayer()->anchorPoint().y() * bounds.height());
724             surfaceOriginToReplicaOriginTransform.scale(1 / deviceScaleFactor);
725
726             // Compute the replica's "originTransform" that maps from the replica's origin space to the target surface origin space.
727             WebTransformationMatrix replicaOriginTransform = layer->renderSurface()->drawTransform() * surfaceOriginToReplicaOriginTransform;
728             renderSurface->setReplicaDrawTransform(replicaOriginTransform);
729
730             // Compute the replica's "screenSpaceTransform" that maps from the replica's origin space to the screen's origin space.
731             WebTransformationMatrix replicaScreenSpaceTransform = layer->renderSurface()->screenSpaceTransform() * surfaceOriginToReplicaOriginTransform;
732             renderSurface->setReplicaScreenSpaceTransform(replicaScreenSpaceTransform);
733         }
734
735         // If a render surface has no layer list, then it and none of its children needed to get drawn.
736         if (!layer->renderSurface()->layerList().size()) {
737             // FIXME: Originally we asserted that this layer was already at the end of the
738             //        list, and only needed to remove that layer. For now, we remove the
739             //        entire subtree of surfaces to fix a crash bug. The root cause is
740             //        https://bugs.webkit.org/show_bug.cgi?id=74147 and we should be able
741             //        to put the original assert after fixing that.
742             while (renderSurfaceLayerList.last() != layer) {
743                 renderSurfaceLayerList.last()->clearRenderSurface();
744                 renderSurfaceLayerList.removeLast();
745             }
746             ASSERT(renderSurfaceLayerList.last() == layer);
747             renderSurfaceLayerList.removeLast();
748             layer->clearRenderSurface();
749             return;
750         }
751     }
752
753     // If neither this layer nor any of its children were added, early out.
754     if (sortingStartIndex == descendants.size())
755         return;
756
757     // If preserves-3d then sort all the descendants in 3D so that they can be
758     // drawn from back to front. If the preserves-3d property is also set on the parent then
759     // skip the sorting as the parent will sort all the descendants anyway.
760     if (descendants.size() && layer->preserves3D() && (!layer->parent() || !layer->parent()->preserves3D()))
761         sortLayers(&descendants.at(sortingStartIndex), descendants.end(), layerSorter);
762
763     if (layer->renderSurface())
764         drawableContentRectOfSubtree = enclosingIntRect(layer->renderSurface()->drawableContentRect());
765     else
766         drawableContentRectOfSubtree = localDrawableContentRectOfSubtree;
767
768     return;
769 }
770
771 // FIXME: Instead of using the following function to set visibility rects on a second
772 // tree pass, revise calculateVisibleContentRect() so that this can be done in a single
773 // pass inside calculateDrawTransformsInternal<>().
774 template<typename LayerType, typename LayerList, typename RenderSurfaceType>
775 static void calculateVisibleRectsInternal(const LayerList& renderSurfaceLayerList)
776 {
777     // Use BackToFront since it's cheap and this isn't order-dependent.
778     typedef CCLayerIterator<LayerType, LayerList, RenderSurfaceType, CCLayerIteratorActions::BackToFront> CCLayerIteratorType;
779
780     CCLayerIteratorType end = CCLayerIteratorType::end(&renderSurfaceLayerList);
781     for (CCLayerIteratorType it = CCLayerIteratorType::begin(&renderSurfaceLayerList); it != end; ++it) {
782         if (it.representsTargetRenderSurface()) {
783             LayerType* maskLayer = it->maskLayer();
784             if (maskLayer)
785                 maskLayer->setVisibleContentRect(IntRect(IntPoint(), it->contentBounds()));
786             LayerType* replicaMaskLayer = it->replicaLayer() ? it->replicaLayer()->maskLayer() : 0;
787             if (replicaMaskLayer)
788                 replicaMaskLayer->setVisibleContentRect(IntRect(IntPoint(), it->contentBounds()));
789         } else if (it.representsItself()) {
790             IntRect visibleContentRect = calculateVisibleContentRect(*it);
791             it->setVisibleContentRect(visibleContentRect);
792         }
793     }
794 }
795
796 void CCLayerTreeHostCommon::calculateDrawTransforms(LayerChromium* rootLayer, const IntSize& deviceViewportSize, float deviceScaleFactor, int maxTextureSize, Vector<RefPtr<LayerChromium> >& renderSurfaceLayerList)
797 {
798     IntRect totalDrawableContentRect;
799     WebTransformationMatrix identityMatrix;
800     WebTransformationMatrix deviceScaleTransform;
801     deviceScaleTransform.scale(deviceScaleFactor);
802
803     setupRootLayerAndSurfaceForRecursion<LayerChromium, Vector<RefPtr<LayerChromium> > >(rootLayer, renderSurfaceLayerList, deviceViewportSize);
804
805     WebCore::calculateDrawTransformsInternal<LayerChromium, Vector<RefPtr<LayerChromium> >, RenderSurfaceChromium, void>(rootLayer, rootLayer, deviceScaleTransform, identityMatrix, identityMatrix,
806                                                                                                                          rootLayer->renderSurface()->contentRect(), true, 0, renderSurfaceLayerList,
807                                                                                                                          rootLayer->renderSurface()->layerList(), 0, maxTextureSize, deviceScaleFactor, totalDrawableContentRect);
808 }
809
810 void CCLayerTreeHostCommon::calculateDrawTransforms(CCLayerImpl* rootLayer, const IntSize& deviceViewportSize, float deviceScaleFactor, CCLayerSorter* layerSorter, int maxTextureSize, Vector<CCLayerImpl*>& renderSurfaceLayerList)
811 {
812     IntRect totalDrawableContentRect;
813     WebTransformationMatrix identityMatrix;
814     WebTransformationMatrix deviceScaleTransform;
815     deviceScaleTransform.scale(deviceScaleFactor);
816
817     setupRootLayerAndSurfaceForRecursion<CCLayerImpl, Vector<CCLayerImpl*> >(rootLayer, renderSurfaceLayerList, deviceViewportSize);
818
819     WebCore::calculateDrawTransformsInternal<CCLayerImpl, Vector<CCLayerImpl*>, CCRenderSurface, CCLayerSorter>(rootLayer, rootLayer, deviceScaleTransform, identityMatrix, identityMatrix,
820                                                                                                                 rootLayer->renderSurface()->contentRect(), true, 0, renderSurfaceLayerList,
821                                                                                                                 rootLayer->renderSurface()->layerList(), layerSorter, maxTextureSize, deviceScaleFactor, totalDrawableContentRect);
822 }
823
824 void CCLayerTreeHostCommon::calculateVisibleRects(Vector<RefPtr<LayerChromium> >& renderSurfaceLayerList)
825 {
826     calculateVisibleRectsInternal<LayerChromium, Vector<RefPtr<LayerChromium> >, RenderSurfaceChromium>(renderSurfaceLayerList);
827 }
828
829 void CCLayerTreeHostCommon::calculateVisibleRects(Vector<CCLayerImpl*>& renderSurfaceLayerList)
830 {
831     calculateVisibleRectsInternal<CCLayerImpl, Vector<CCLayerImpl*>, CCRenderSurface>(renderSurfaceLayerList);
832 }
833
834 static bool pointHitsRect(const IntPoint& viewportPoint, const WebTransformationMatrix& localSpaceToScreenSpaceTransform, FloatRect localSpaceRect)
835 {
836     // If the transform is not invertible, then assume that this point doesn't hit this rect.
837     if (!localSpaceToScreenSpaceTransform.isInvertible())
838         return false;
839
840     // Transform the hit test point from screen space to the local space of the given rect.
841     bool clipped = false;
842     FloatPoint hitTestPointInLocalSpace = CCMathUtil::projectPoint(localSpaceToScreenSpaceTransform.inverse(), FloatPoint(viewportPoint), clipped);
843
844     // If projectPoint could not project to a valid value, then we assume that this point doesn't hit this rect.
845     if (clipped)
846         return false;
847
848     return localSpaceRect.contains(hitTestPointInLocalSpace);
849 }
850
851 static bool pointIsClippedBySurfaceOrClipRect(const IntPoint& viewportPoint, CCLayerImpl* layer)
852 {
853     CCLayerImpl* currentLayer = layer;
854
855     // Walk up the layer tree and hit-test any renderSurfaces and any layer clipRects that are active.
856     while (currentLayer) {
857         if (currentLayer->renderSurface() && !pointHitsRect(viewportPoint, currentLayer->renderSurface()->screenSpaceTransform(), currentLayer->renderSurface()->contentRect()))
858             return true;
859
860         // Note that drawableContentRects are actually in targetSurface space, so the transform we
861         // have to provide is the target surface's screenSpaceTransform.
862         CCLayerImpl* renderTarget = currentLayer->renderTarget();
863         if (layerClipsSubtree(currentLayer) && !pointHitsRect(viewportPoint, renderTarget->renderSurface()->screenSpaceTransform(), currentLayer->drawableContentRect()))
864             return true;
865
866         currentLayer = currentLayer->parent();
867     }
868
869     // If we have finished walking all ancestors without having already exited, then the point is not clipped by any ancestors.
870     return false;
871 }
872
873 CCLayerImpl* CCLayerTreeHostCommon::findLayerThatIsHitByPoint(const IntPoint& viewportPoint, Vector<CCLayerImpl*>& renderSurfaceLayerList)
874 {
875     CCLayerImpl* foundLayer = 0;
876
877     typedef CCLayerIterator<CCLayerImpl, Vector<CCLayerImpl*>, CCRenderSurface, CCLayerIteratorActions::FrontToBack> CCLayerIteratorType;
878     CCLayerIteratorType end = CCLayerIteratorType::end(&renderSurfaceLayerList);
879
880     for (CCLayerIteratorType it = CCLayerIteratorType::begin(&renderSurfaceLayerList); it != end; ++it) {
881         // We don't want to consider renderSurfaces for hit testing.
882         if (!it.representsItself())
883             continue;
884
885         CCLayerImpl* currentLayer = (*it);
886
887         FloatRect contentRect(FloatPoint::zero(), currentLayer->contentBounds());
888         if (!pointHitsRect(viewportPoint, currentLayer->screenSpaceTransform(), contentRect))
889             continue;
890
891         // At this point, we think the point does hit the layer, but we need to walk up
892         // the parents to ensure that the layer was not clipped in such a way that the
893         // hit point actually should not hit the layer.
894         if (pointIsClippedBySurfaceOrClipRect(viewportPoint, currentLayer))
895             continue;
896
897         foundLayer = currentLayer;
898         break;
899     }
900
901     // This can potentially return 0, which means the viewportPoint did not successfully hit test any layers, not even the root layer.
902     return foundLayer;
903 }
904
905 } // namespace WebCore