[chromium] Remove unused variable (gcc 4.6 complains about this)
[WebKit-https.git] / Source / WebCore / platform / graphics / chromium / cc / CCDamageTracker.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 are
6  * met:
7  *
8  *     * Redistributions of source code must retain the above copyright
9  * notice, this list of conditions and the following disclaimer.
10  *     * Redistributions in binary form must reproduce the above
11  * copyright notice, this list of conditions and the following disclaimer
12  * in the documentation and/or other materials provided with the
13  * distribution.
14  *     * Neither the name of Google Inc. nor the names of its
15  * contributors may be used to endorse or promote products derived from
16  * this software without specific prior written permission.
17  *
18  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
21  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
22  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
23  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
24  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
25  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
26  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
28  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29  */
30
31 #include "config.h"
32
33 #if USE(ACCELERATED_COMPOSITING)
34
35 #include "cc/CCDamageTracker.h"
36
37 #include "cc/CCLayerImpl.h"
38 #include "cc/CCLayerTreeHostCommon.h"
39 #include "cc/CCRenderSurface.h"
40
41 namespace WebCore {
42
43 PassOwnPtr<CCDamageTracker> CCDamageTracker::create()
44 {
45     return adoptPtr(new CCDamageTracker());
46 }
47
48 CCDamageTracker::CCDamageTracker()
49 {
50     m_currentRectHistory = adoptPtr(new RectMap);
51     m_nextRectHistory = adoptPtr(new RectMap);
52 }
53
54 CCDamageTracker::~CCDamageTracker()
55 {
56 }
57
58 void CCDamageTracker::updateDamageRectForNextFrame(const Vector<RefPtr<CCLayerImpl> >& layerList, int targetSurfaceLayerID, CCLayerImpl* targetSurfaceMaskLayer)
59 {
60     //
61     // This function computes the "damage rect" of a target surface. The damage
62     // rect is the region of the surface that may have changed and needs to be redrawn.
63     // This can be used to scissor what is actually drawn, to save GPU computation and
64     // bandwidth.
65     //
66     // The surface's damage rect is computed as the union of all possible changes that
67     // have happened to the surface since the last frame was drawn. This includes:
68     //   - any changes for existing layers/surfaces that contribute to the target surface
69     //   - layers/surfaces that existed in the previous frame, but no longer exist.
70     //
71     // The basic algorithm for computing the damage region is as follows:
72     //
73     //       // 1. compute damage caused by changes in active/new layers
74     //       for each layer in the layerList:
75     //           if the layer is actually a renderSurface:
76     //               add the surface's damage to our target surface.
77     //           else
78     //               add the layer's damage to the target surface.
79     //
80     //       // 2. compute damage caused by the target surface's mask, if it exists.
81     //
82     //       // 3. compute damage caused by old layers/surfaces that no longer exist
83     //       for each leftover layer:
84     //           add the old layer/surface bounds to the target surface damage.
85     //
86     //       // 4. combine all partial damage rects to get the full damage rect.
87     //
88     // Additional important points:
89     //
90     // - This algorithm is implicitly recursive; it assumes that descendant surfaces have
91     //   already computed their damage.
92     //
93     // - Changes to layers/surfaces indicate "damage" to the target surface; If a layer is
94     //   not changed, it does NOT mean that the layer can skip drawing. All layers that
95     //   overlap the damaged region still need to be drawn. For example, if a layer
96     //   changed its opacity, then layers underneath must be re-drawn as well, even if
97     //   they did not change.
98     //
99     // - If a layer/surface property changed, the old bounds and new bounds may overlap...
100     //   i.e. some of the exposed region may not actually be exposing anything. But this
101     //   does not artificially inflate the damage rect. If the layer changed, its entire
102     //   old bounds would always need to be redrawn, regardless of how much it overlaps
103     //   with the layer's new bounds, which also need to be entirely redrawn.
104     //
105     // - See comments in the rest of the code to see what exactly is considered a "change"
106     //   in a layer/surface.
107     //
108     // - To correctly manage exposed rects, two RectMaps are maintained:
109     //
110     //      1. The "current" map contains all the layer bounds that contributed to the
111     //         previous frame (even outside the previous damaged area). If a layer changes
112     //         or does not exist anymore, those regions are then exposed and damage the
113     //         target surface. As the algorithm progresses, entries are removed from the
114     //         map until it has only leftover layers that no longer exist.
115     //
116     //      2. The "next" map starts out empty, and as the algorithm progresses, every
117     //         layer/surface that contributes to the surface is added to the map.
118     //
119     //      3. After the damage rect is computed, the two maps are swapped, so that the
120     //         damage tracker is ready for the next frame.
121     //
122
123     // If the target surface already knows its entire region is damaged, we can return early.
124     // FIXME: this should go away, or will be cleaner, after refactoring into RenderPass/RenderSchedule.
125     CCLayerImpl* layer = layerList[0].get();
126     if (layer->targetRenderSurface()->surfacePropertyChangedOnlyFromDescendant()) {
127         m_currentDamageRect = FloatRect(layer->targetRenderSurface()->contentRect());
128         return;
129     }
130
131     FloatRect damageFromActiveLayers = computeDamageFromActiveLayers(layerList, targetSurfaceLayerID);
132     FloatRect damageFromSurfaceMask = computeDamageFromSurfaceMask(targetSurfaceMaskLayer);
133     FloatRect damageFromLeftoverRects = computeDamageFromLeftoverRects();
134
135     m_currentDamageRect = damageFromActiveLayers;
136     m_currentDamageRect.uniteIfNonZero(damageFromSurfaceMask);
137     m_currentDamageRect.uniteIfNonZero(damageFromLeftoverRects);
138
139     // The next history map becomes the current map for the next frame.
140     swap(m_currentRectHistory, m_nextRectHistory);
141 }
142
143 FloatRect CCDamageTracker::removeRectFromCurrentFrame(int layerID)
144 {
145     // This function exists mainly for readability of the code.
146     // take() will remove the entry from the map, or if not found, return a default (empty) rect.
147     return m_currentRectHistory->take(layerID);
148 }
149
150 void CCDamageTracker::saveRectForNextFrame(int layerID, const FloatRect& targetSpaceRect)
151 {
152     // This layer should not yet exist in next frame's history.
153     ASSERT(m_nextRectHistory->find(layerID) == m_nextRectHistory->end());
154     m_nextRectHistory->set(layerID, targetSpaceRect);
155 }
156
157 FloatRect CCDamageTracker::computeDamageFromActiveLayers(const Vector<RefPtr<CCLayerImpl> >& layerList, int targetSurfaceLayerID)
158 {
159     FloatRect damageRect = FloatRect();
160
161     for (unsigned layerIndex = 0; layerIndex < layerList.size(); ++layerIndex) {
162         CCLayerImpl* layer = layerList[layerIndex].get();
163
164         if (CCLayerTreeHostCommon::renderSurfaceContributesToTarget<CCLayerImpl>(layer, targetSurfaceLayerID))
165             extendDamageForRenderSurface(layer, damageRect);
166         else
167             extendDamageForLayer(layer, damageRect);
168     }
169
170     return damageRect;
171 }
172
173 FloatRect CCDamageTracker::computeDamageFromSurfaceMask(CCLayerImpl* targetSurfaceMaskLayer)
174 {
175     FloatRect damageRect = FloatRect();
176
177     if (!targetSurfaceMaskLayer)
178         return damageRect;
179
180     // Currently, if there is any change to the mask, we choose to damage the entire
181     // surface. This could potentially be optimized later, but it is not expected to be a
182     // common case.
183     if (targetSurfaceMaskLayer->layerPropertyChanged() || !targetSurfaceMaskLayer->updateRect().isEmpty())
184         damageRect = FloatRect(FloatPoint::zero(), FloatSize(targetSurfaceMaskLayer->bounds()));
185
186     return damageRect;
187 }
188
189 FloatRect CCDamageTracker::computeDamageFromLeftoverRects()
190 {
191     // After computing damage for all active layers, any leftover items in the current
192     // rect history correspond to layers/surfaces that no longer exist. So, these regions
193     // are now exposed on the target surface.
194
195     FloatRect damageRect = FloatRect();
196
197     for (RectMap::iterator it = m_currentRectHistory->begin(); it != m_currentRectHistory->end(); ++it)
198         damageRect.unite(it->second);
199
200     m_currentRectHistory->clear();
201
202     return damageRect;
203 }
204
205 void CCDamageTracker::extendDamageForLayer(CCLayerImpl* layer, FloatRect& targetDamageRect)
206 {
207     // There are two ways that a layer can damage a region of the target surface:
208     //   1. Property change (e.g. opacity, position, transforms):
209     //        - the entire region of the layer itself damages the surface.
210     //        - the old layer region also damages the surface, because this region is now exposed.
211     //        - note that in many cases the old and new layer rects may overlap, which is fine.
212     //
213     //   2. Repaint/update: If a region of the layer that was repainted/updated, that
214     //      region damages the surface.
215     //
216     // Property changes take priority over update rects.
217
218     // Compute the layer's "originTransform" by translating the drawTransform.
219     TransformationMatrix originTransform = layer->drawTransform();
220     originTransform.translate(-0.5 * layer->bounds().width(), -0.5 * layer->bounds().height());
221
222     FloatRect oldLayerRect = removeRectFromCurrentFrame(layer->id());
223
224     FloatRect layerRectInTargetSpace = originTransform.mapRect(FloatRect(FloatPoint::zero(), layer->bounds()));
225     saveRectForNextFrame(layer->id(), layerRectInTargetSpace);
226
227     if (layer->layerPropertyChanged()) {
228         // If a layer has changed, then its entire layer rect affects the target surface.
229         targetDamageRect.uniteIfNonZero(layerRectInTargetSpace);
230
231         // The layer's old region is now exposed on the target surface, too.
232         // Note oldLayerRect is already in target space.
233         targetDamageRect.uniteIfNonZero(oldLayerRect);
234     } else if (!layer->updateRect().isEmpty()) {
235         // If the layer properties havent changed, then the the target surface is only
236         // affected by the layer's update area, which could be empty.
237         FloatRect updateRectInTargetSpace = originTransform.mapRect(layer->updateRect());
238         targetDamageRect.uniteIfNonZero(updateRectInTargetSpace);
239     }
240 }
241
242 void CCDamageTracker::extendDamageForRenderSurface(CCLayerImpl* layer, FloatRect& targetDamageRect)
243 {
244     // There are two ways a "descendant surface" can damage regions of the "target surface":
245     //   1. Property change:
246     //        - a surface's geometry can change because of
247     //            - changes to descendants (i.e. the subtree) that affect the surface's content rect
248     //            - changes to ancestor layers that propagate their property changes to their entire subtree.
249     //        - just like layers, both the old surface rect and new surface rect will
250     //          damage the target surface in this case.
251     //
252     //   2. Damage rect: This surface may have been damaged by its own layerList as well, and that damage
253     //      should propagate to the target surface.
254     //
255
256     CCRenderSurface* renderSurface = layer->renderSurface();
257
258     FloatRect oldSurfaceRect = removeRectFromCurrentFrame(layer->id());
259
260     FloatRect surfaceRectInTargetSpace = renderSurface->drawableContentRect(); // already includes replica if it exists.
261     saveRectForNextFrame(layer->id(), surfaceRectInTargetSpace);
262
263     FloatRect damageRectInLocalSpace;
264     if (renderSurface->surfacePropertyChanged()) {
265         // The entire surface contributes damage.
266         damageRectInLocalSpace = renderSurface->contentRect();
267
268         // The surface's old region is now exposed on the target surface, too.
269         targetDamageRect.uniteIfNonZero(oldSurfaceRect);
270     } else {
271         // Only the surface's damageRect will damage the target surface.
272         damageRectInLocalSpace = renderSurface->damageTracker()->currentDamageRect();
273     }
274
275     // If there was damage, transform it to target space, and possibly contribute its reflection if needed.
276     if (!damageRectInLocalSpace.isEmpty()) {
277         const TransformationMatrix& originTransform = renderSurface->originTransform();
278         FloatRect damageRectInTargetSpace = originTransform.mapRect(damageRectInLocalSpace);
279         targetDamageRect.uniteIfNonZero(damageRectInTargetSpace);
280
281         if (layer->replicaLayer()) {
282             // Compute the replica's "originTransform" that maps from the replica's origin space to the target surface origin space.
283             TransformationMatrix replicaOriginTransform = layer->renderSurface()->originTransform();
284             replicaOriginTransform.translate(layer->replicaLayer()->position().x(), layer->replicaLayer()->position().y());
285             replicaOriginTransform.multiply(layer->replicaLayer()->transform());
286             replicaOriginTransform.translate(-layer->replicaLayer()->position().x(), -layer->replicaLayer()->position().y());
287
288             targetDamageRect.uniteIfNonZero(replicaOriginTransform.mapRect(damageRectInLocalSpace));
289         }
290     }
291
292     // If there was damage on the replica's mask, then the target surface receives that damage as well.
293     if (layer->replicaLayer() && layer->replicaLayer()->maskLayer()) {
294         CCLayerImpl* replicaMaskLayer = layer->replicaLayer()->maskLayer();
295
296         removeRectFromCurrentFrame(replicaMaskLayer->id());
297
298         // Compute the replica's "originTransform" that maps from the replica's origin space to the target surface origin space.
299         TransformationMatrix replicaOriginTransform = layer->renderSurface()->originTransform();
300         replicaOriginTransform.translate(layer->replicaLayer()->position().x(), layer->replicaLayer()->position().y());
301         replicaOriginTransform.multiply(layer->replicaLayer()->transform());
302         replicaOriginTransform.translate(-layer->replicaLayer()->position().x(), -layer->replicaLayer()->position().y());
303
304         FloatRect replicaMaskLayerRect = replicaOriginTransform.mapRect(FloatRect(FloatPoint::zero(), FloatSize(replicaMaskLayer->bounds().width(), replicaMaskLayer->bounds().height())));
305         saveRectForNextFrame(replicaMaskLayer->id(), replicaMaskLayerRect);
306
307         // In the current implementation, a change in the replica mask damages the entire replica region.
308         if (replicaMaskLayer->layerPropertyChanged() || !replicaMaskLayer->updateRect().isEmpty())
309             targetDamageRect.uniteIfNonZero(replicaMaskLayerRect);
310     }
311 }
312
313 } // namespace WebCore
314
315 #endif // USE(ACCELERATED_COMPOSITING)