19fc2c1dd0dac8255b5642824327803b12aeee34
[WebKit-https.git] / Source / WebCore / platform / graphics / chromium / cc / CCOcclusionTracker.h
1 /*
2  * Copyright (C) 2012 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  *
8  * 1.  Redistributions of source code must retain the above copyright
9  *     notice, this list of conditions and the following disclaimer.
10  * 2.  Redistributions in binary form must reproduce the above copyright
11  *     notice, this list of conditions and the following disclaimer in the
12  *     documentation and/or other materials provided with the distribution.
13  *
14  * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
15  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
16  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
17  * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
18  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
19  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
20  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
21  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
23  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24  */
25
26 #ifndef CCOcclusionTracker_h
27 #define CCOcclusionTracker_h
28
29 #include "FloatQuad.h"
30 #include "Region.h"
31 #include "TransformationMatrix.h"
32
33 namespace WebCore {
34 class CCLayerImpl;
35 class CCRenderSurface;
36 class LayerChromium;
37 class RenderSurfaceChromium;
38
39 template<typename RenderSurfaceType>
40 class CCOcclusionTrackerDamageClientBase {
41 public:
42     virtual FloatRect damageRect(const RenderSurfaceType*) const = 0;
43 };
44
45 typedef CCOcclusionTrackerDamageClientBase<RenderSurfaceChromium> CCOcclusionTrackerDamageClient;
46 typedef CCOcclusionTrackerDamageClientBase<CCRenderSurface> CCOcclusionTrackerDamageClientImpl;
47
48 // This class is used to track occlusion of layers while traversing them in a front-to-back order. As each layer is visited, one of the
49 // methods in this class is called to notify it about the current target surface.
50 // Then, occlusion in the content space of the current layer may be queried, via methods such as occluded() and unoccludedContentRect().
51 // If the current layer owns a RenderSurface, then occlusion on that RenderSurface may also be queried via surfaceOccluded() and surfaceUnoccludedContentRect().
52 // Finally, once finished with the layer, occlusion behind the layer should be marked by calling markOccludedBehindLayer().
53 template<typename LayerType, typename RenderSurfaceType>
54 class CCOcclusionTrackerBase {
55     WTF_MAKE_NONCOPYABLE(CCOcclusionTrackerBase);
56     typedef CCOcclusionTrackerDamageClientBase<RenderSurfaceType> DamageClientType;
57 public:
58     CCOcclusionTrackerBase(IntRect scissorRectInScreenSpace);
59     CCOcclusionTrackerBase(IntRect scissorRectInScreenSpace, const DamageClientType*);
60
61     // Called when visiting a layer representing itself. If the target was not already current, then this indicates we have entered a new surface subtree.
62     void enterTargetRenderSurface(const RenderSurfaceType* newTarget);
63
64     // Called when visiting a layer representing a target surface. This indicates we have visited all the layers within the surface, and we may
65     // perform any surface-wide operations.
66     void finishedTargetRenderSurface(const LayerType*, const RenderSurfaceType* finishedTarget);
67
68     // Called when visiting a layer representing a contributing surface. This  indicates that we are leaving our current surface, and
69     // entering the new one. We then perform any operations required for merging results from the child subtree into its parent.
70     void leaveToTargetRenderSurface(const RenderSurfaceType* newTarget);
71
72     // Add the layer's occlusion to the tracked state.
73     void markOccludedBehindLayer(const LayerType*);
74
75     // Returns true if the given rect in content space for the layer is fully occluded in either screen space or the layer's target surface.
76     bool occluded(const LayerType*, const IntRect& contentRect) const;
77     // Gives an unoccluded sub-rect of |contentRect| in the content space of the layer. Used when considering occlusion for a layer that paints/draws something.
78     IntRect unoccludedContentRect(const LayerType*, const IntRect& contentRect) const;
79
80     // FIXME: Remove this when paint tracking is on for paint culling.
81     void setUsePaintTracking(bool use) { m_usePaintTracking = use; }
82
83     // FIXME: Remove these in future, they are to make CLs for transitioning to this easier.
84     const Region& currentOcclusionInScreenSpace() const;
85     const Region& currentOcclusionInTargetSurface() const;
86
87 protected:
88     struct StackObject {
89         const RenderSurfaceType* surface;
90         Region occlusionInScreen;
91         Region occlusionInTarget;
92     };
93
94     // The stack holds occluded regions for subtrees in the RenderSurface-Layer tree, so that when we leave a subtree we may
95     // apply a mask to it, but not to the parts outside the subtree.
96     // - The first time we see a new subtree under a target, we add that target to the top of the stack. This can happen as a layer representing itself, or as a target surface.
97     // - When we visit a target surface, we apply its mask to its subtree, which is at the top of the stack.
98     // - When we visit a layer representing itself, we add its occlusion to the current subtree, which is at the top of the stack.
99     // - When we visit a layer representing a contributing surface, the current target will never be the top of the stack since we just came from the contributing surface.
100     // We merge the occlusion at the top of the stack with the new current subtree. This new target is pushed onto the stack if not already there.
101     Vector<StackObject, 1> m_stack;
102
103     // Allow tests to override this.
104     virtual IntRect layerScissorRectInTargetSurface(const LayerType*) const;
105
106 private:
107     IntRect m_scissorRectInScreenSpace;
108     const DamageClientType* m_surfaceDamageClient;
109     bool m_usePaintTracking; // FIXME: Remove this when paint tracking is on for paint culling.
110 };
111
112 typedef CCOcclusionTrackerBase<LayerChromium, RenderSurfaceChromium> CCOcclusionTracker;
113 typedef CCOcclusionTrackerBase<CCLayerImpl, CCRenderSurface> CCOcclusionTrackerImpl;
114
115 }
116 #endif // CCOcclusionTracker_h