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