134d4cc2b82aa33d5ed7ca2ed4b1536e3e214b89
[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 #include "cc/CCOverdrawMetrics.h"
33
34 namespace WebCore {
35 class CCLayerImpl;
36 class CCRenderSurface;
37 class LayerChromium;
38 class RenderSurfaceChromium;
39
40 template<typename RenderSurfaceType>
41 class CCOcclusionTrackerDamageClientBase {
42 public:
43     virtual FloatRect damageRect(const RenderSurfaceType*) const = 0;
44 };
45
46 typedef CCOcclusionTrackerDamageClientBase<RenderSurfaceChromium> CCOcclusionTrackerDamageClient;
47 typedef CCOcclusionTrackerDamageClientBase<CCRenderSurface> CCOcclusionTrackerDamageClientImpl;
48
49 // 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
50 // methods in this class is called to notify it about the current target surface.
51 // Then, occlusion in the content space of the current layer may be queried, via methods such as occluded() and unoccludedContentRect().
52 // If the current layer owns a RenderSurface, then occlusion on that RenderSurface may also be queried via surfaceOccluded() and surfaceUnoccludedContentRect().
53 // Finally, once finished with the layer, occlusion behind the layer should be marked by calling markOccludedBehindLayer().
54 template<typename LayerType, typename RenderSurfaceType>
55 class CCOcclusionTrackerBase {
56     WTF_MAKE_NONCOPYABLE(CCOcclusionTrackerBase);
57     typedef CCOcclusionTrackerDamageClientBase<RenderSurfaceType> DamageClientType;
58 public:
59     CCOcclusionTrackerBase(IntRect scissorRectInScreenSpace);
60     CCOcclusionTrackerBase(IntRect scissorRectInScreenSpace, const DamageClientType*);
61
62     // Called when visiting a layer representing itself. If the target was not already current, then this indicates we have entered a new surface subtree.
63     void enterTargetRenderSurface(const RenderSurfaceType* newTarget);
64
65     // Called when visiting a layer representing a target surface. This indicates we have visited all the layers within the surface, and we may
66     // perform any surface-wide operations.
67     void finishedTargetRenderSurface(const LayerType*, const RenderSurfaceType* finishedTarget);
68
69     // Called when visiting a layer representing a contributing surface. This  indicates that we are leaving our current surface, and
70     // entering the new one. We then perform any operations required for merging results from the child subtree into its parent.
71     void leaveToTargetRenderSurface(const RenderSurfaceType* newTarget);
72
73     // Add the layer's occlusion to the tracked state.
74     void markOccludedBehindLayer(const LayerType*);
75
76     // 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.
77     bool occluded(const LayerType*, const IntRect& contentRect) const;
78     // 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.
79     IntRect unoccludedContentRect(const LayerType*, const IntRect& contentRect) const;
80
81     // Report operations for recording overdraw metrics.
82     CCOverdrawMetrics& overdrawMetrics() const { return *m_overdrawMetrics.get(); }
83
84     // FIXME: Remove this when paint tracking is on for paint culling.
85     void setUsePaintTracking(bool use) { m_usePaintTracking = use; }
86
87     // FIXME: Remove these in future, they are to make CLs for transitioning to this easier.
88     const Region& currentOcclusionInScreenSpace() const;
89     const Region& currentOcclusionInTargetSurface() const;
90
91 protected:
92     struct StackObject {
93         StackObject() : surface(0) { }
94         StackObject(const RenderSurfaceType* surface) : surface(surface) { }
95         const RenderSurfaceType* surface;
96         Region occlusionInScreen;
97         Region occlusionInTarget;
98     };
99
100     // The stack holds occluded regions for subtrees in the RenderSurface-Layer tree, so that when we leave a subtree we may
101     // apply a mask to it, but not to the parts outside the subtree.
102     // - 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.
103     // - When we visit a target surface, we apply its mask to its subtree, which is at the top of the stack.
104     // - When we visit a layer representing itself, we add its occlusion to the current subtree, which is at the top of the stack.
105     // - 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.
106     // 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.
107     Vector<StackObject, 1> m_stack;
108
109     // Allow tests to override this.
110     virtual IntRect layerScissorRectInTargetSurface(const LayerType*) const;
111
112 private:
113     IntRect m_scissorRectInScreenSpace;
114     const DamageClientType* m_surfaceDamageClient;
115     OwnPtr<CCOverdrawMetrics> m_overdrawMetrics;
116     bool m_usePaintTracking; // FIXME: Remove this when paint tracking is on for paint culling.
117 };
118
119 typedef CCOcclusionTrackerBase<LayerChromium, RenderSurfaceChromium> CCOcclusionTracker;
120 typedef CCOcclusionTrackerBase<CCLayerImpl, CCRenderSurface> CCOcclusionTrackerImpl;
121
122 }
123 #endif // CCOcclusionTracker_h