https://bugs.webkit.org/show_bug.cgi?id=81431
Patch by Dana Jansens <danakj@chromium.org> on 2012-03-20
Reviewed by Adrienne Walker.
Source/WebCore:
This change allows us to disable overdraw metrics conditionally in the
future with a one-line change in each LayerTreeHost class.
Unit test: CCQuadCullerTest.verifyWithoutMetrics
* platform/graphics/chromium/cc/CCLayerTreeHost.cpp:
(WebCore::CCLayerTreeHost::paintLayerContents):
* platform/graphics/chromium/cc/CCLayerTreeHostImpl.cpp:
(WebCore::CCLayerTreeHostImpl::calculateRenderPasses):
* platform/graphics/chromium/cc/CCOcclusionTracker.cpp:
(WebCore::::CCOcclusionTrackerBase):
(WebCore):
* platform/graphics/chromium/cc/CCOcclusionTracker.h:
(CCOcclusionTrackerBase):
* platform/graphics/chromium/cc/CCOverdrawMetrics.cpp:
(WebCore::CCOverdrawMetrics::CCOverdrawMetrics):
(WebCore::CCOverdrawMetrics::didCull):
(WebCore::CCOverdrawMetrics::didDraw):
(WebCore::CCOverdrawMetrics::recordMetrics):
* platform/graphics/chromium/cc/CCOverdrawMetrics.h:
(WebCore::CCOverdrawMetrics::create):
(CCOverdrawMetrics):
Source/WebKit/chromium:
* tests/CCOcclusionTrackerTest.cpp:
(WebCore::TestCCOcclusionTrackerBase::TestCCOcclusionTrackerBase):
* tests/CCQuadCullerTest.cpp:
(WebCore::TestCCOcclusionTrackerImpl::TestCCOcclusionTrackerImpl):
(WebCore::TEST):
(WebCore):
* tests/TiledLayerChromiumTest.cpp:
(WTF::TestCCOcclusionTracker::TestCCOcclusionTracker):
git-svn-id: https://svn.webkit.org/repository/webkit/trunk@111441
268f45cc-cd09-0410-ab3c-
d52691b4dbfc
+2012-03-20 Dana Jansens <danakj@chromium.org>
+
+ [chromium] Allow us to disable overdraw metrics when tracing is off
+ https://bugs.webkit.org/show_bug.cgi?id=81431
+
+ Reviewed by Adrienne Walker.
+
+ This change allows us to disable overdraw metrics conditionally in the
+ future with a one-line change in each LayerTreeHost class.
+
+ Unit test: CCQuadCullerTest.verifyWithoutMetrics
+
+ * platform/graphics/chromium/cc/CCLayerTreeHost.cpp:
+ (WebCore::CCLayerTreeHost::paintLayerContents):
+ * platform/graphics/chromium/cc/CCLayerTreeHostImpl.cpp:
+ (WebCore::CCLayerTreeHostImpl::calculateRenderPasses):
+ * platform/graphics/chromium/cc/CCOcclusionTracker.cpp:
+ (WebCore::::CCOcclusionTrackerBase):
+ (WebCore):
+ * platform/graphics/chromium/cc/CCOcclusionTracker.h:
+ (CCOcclusionTrackerBase):
+ * platform/graphics/chromium/cc/CCOverdrawMetrics.cpp:
+ (WebCore::CCOverdrawMetrics::CCOverdrawMetrics):
+ (WebCore::CCOverdrawMetrics::didCull):
+ (WebCore::CCOverdrawMetrics::didDraw):
+ (WebCore::CCOverdrawMetrics::recordMetrics):
+ * platform/graphics/chromium/cc/CCOverdrawMetrics.h:
+ (WebCore::CCOverdrawMetrics::create):
+ (CCOverdrawMetrics):
+
2012-03-20 Robert Hogan <robert@webkit.org>
Use-after-free of continuation in RenderBlock::paintContinuationOutlines()
// Use FrontToBack to allow for testing occlusion and performing culling during the tree walk.
typedef CCLayerIterator<LayerChromium, Vector<RefPtr<LayerChromium> >, RenderSurfaceChromium, CCLayerIteratorActions::FrontToBack> CCLayerIteratorType;
- CCOcclusionTracker occlusionTracker(IntRect(IntPoint(), viewportSize()));
+ bool recordMetricsForFrame = true; // FIXME: In the future, disable this when about:tracing is off.
+ CCOcclusionTracker occlusionTracker(IntRect(IntPoint(), viewportSize()), recordMetricsForFrame);
occlusionTracker.setUsePaintTracking(true); // FIXME: Remove this after m19 branch.
CCLayerIteratorType end = CCLayerIteratorType::end(&renderSurfaceLayerList);
scissorRect = enclosingIntRect(m_rootDamageRect);
else
scissorRect = IntRect(IntPoint(), viewportSize());
- CCOcclusionTrackerImpl occlusionTracker(scissorRect);
+
+ bool recordMetricsForFrame = true; // FIXME: In the future, disable this when about:tracing is off.
+ CCOcclusionTrackerImpl occlusionTracker(scissorRect, recordMetricsForFrame);
// Add quads to the Render passes in FrontToBack order to allow for testing occlusion and performing culling during the tree walk.
typedef CCLayerIterator<CCLayerImpl, Vector<CCLayerImpl*>, CCRenderSurface, CCLayerIteratorActions::FrontToBack> CCLayerIteratorType;
namespace WebCore {
template<typename LayerType, typename RenderSurfaceType>
-CCOcclusionTrackerBase<LayerType, RenderSurfaceType>::CCOcclusionTrackerBase(IntRect scissorRectInScreenSpace)
+CCOcclusionTrackerBase<LayerType, RenderSurfaceType>::CCOcclusionTrackerBase(IntRect scissorRectInScreenSpace, bool recordMetricsForFrame)
: m_scissorRectInScreenSpace(scissorRectInScreenSpace)
- , m_overdrawMetrics(CCOverdrawMetrics::create())
+ , m_overdrawMetrics(CCOverdrawMetrics::create(recordMetricsForFrame))
, m_usePaintTracking(true) // FIXME: Remove this when paint tracking is on for paint culling.
{
}
// Declare the possible functions here for the linker.
-template CCOcclusionTrackerBase<LayerChromium, RenderSurfaceChromium>::CCOcclusionTrackerBase(IntRect scissorRectInScreenSpace);
+template CCOcclusionTrackerBase<LayerChromium, RenderSurfaceChromium>::CCOcclusionTrackerBase(IntRect scissorRectInScreenSpace, bool recordMetricsForFrame);
template void CCOcclusionTrackerBase<LayerChromium, RenderSurfaceChromium>::enterTargetRenderSurface(const RenderSurfaceChromium* newTarget);
template void CCOcclusionTrackerBase<LayerChromium, RenderSurfaceChromium>::finishedTargetRenderSurface(const LayerChromium* owningLayer, const RenderSurfaceChromium* finishedTarget);
template void CCOcclusionTrackerBase<LayerChromium, RenderSurfaceChromium>::leaveToTargetRenderSurface(const RenderSurfaceChromium* newTarget);
template const Region& CCOcclusionTrackerBase<LayerChromium, RenderSurfaceChromium>::currentOcclusionInTargetSurface() const;
template IntRect CCOcclusionTrackerBase<LayerChromium, RenderSurfaceChromium>::layerScissorRectInTargetSurface(const LayerChromium*) const;
-template CCOcclusionTrackerBase<CCLayerImpl, CCRenderSurface>::CCOcclusionTrackerBase(IntRect scissorRectInScreenSpace);
+template CCOcclusionTrackerBase<CCLayerImpl, CCRenderSurface>::CCOcclusionTrackerBase(IntRect scissorRectInScreenSpace, bool recordMetricsForFrame);
template void CCOcclusionTrackerBase<CCLayerImpl, CCRenderSurface>::enterTargetRenderSurface(const CCRenderSurface* newTarget);
template void CCOcclusionTrackerBase<CCLayerImpl, CCRenderSurface>::finishedTargetRenderSurface(const CCLayerImpl* owningLayer, const CCRenderSurface* finishedTarget);
template void CCOcclusionTrackerBase<CCLayerImpl, CCRenderSurface>::leaveToTargetRenderSurface(const CCRenderSurface* newTarget);
class CCOcclusionTrackerBase {
WTF_MAKE_NONCOPYABLE(CCOcclusionTrackerBase);
public:
- CCOcclusionTrackerBase(IntRect scissorRectInScreenSpace);
+ CCOcclusionTrackerBase(IntRect scissorRectInScreenSpace, bool recordMetricsForFrame);
// Called when visiting a layer representing itself. If the target was not already current, then this indicates we have entered a new surface subtree.
void enterTargetRenderSurface(const RenderSurfaceType* newTarget);
namespace WebCore {
-CCOverdrawMetrics::CCOverdrawMetrics()
- : m_pixelsDrawnOpaque(0)
+CCOverdrawMetrics::CCOverdrawMetrics(bool recordMetricsForFrame)
+ : m_recordMetricsForFrame(recordMetricsForFrame)
+ , m_pixelsDrawnOpaque(0)
, m_pixelsDrawnTranslucent(0)
, m_pixelsCulled(0)
{
void CCOverdrawMetrics::didCull(const TransformationMatrix& transformToTarget, const IntRect& beforeCullRect, const IntRect& afterCullRect)
{
+ if (!m_recordMetricsForFrame)
+ return;
+
float beforeCullArea = quadArea(transformToTarget.mapQuad(FloatQuad(beforeCullRect)));
float afterCullArea = quadArea(transformToTarget.mapQuad(FloatQuad(afterCullRect)));
void CCOverdrawMetrics::didDraw(const TransformationMatrix& transformToTarget, const IntRect& afterCullRect, const IntRect& opaqueRect)
{
+ if (!m_recordMetricsForFrame)
+ return;
+
float afterCullArea = quadArea(transformToTarget.mapQuad(FloatQuad(afterCullRect)));
float afterCullOpaqueArea = quadArea(transformToTarget.mapQuad(FloatQuad(intersection(opaqueRect, afterCullRect))));
void CCOverdrawMetrics::recordMetrics(const CCLayerTreeHost* layerTreeHost) const
{
- recordMetricsInternal<CCLayerTreeHost>(UPLOADING, layerTreeHost);
+ if (m_recordMetricsForFrame)
+ recordMetricsInternal<CCLayerTreeHost>(UPLOADING, layerTreeHost);
}
void CCOverdrawMetrics::recordMetrics(const CCLayerTreeHostImpl* layerTreeHost) const
{
- recordMetricsInternal<CCLayerTreeHostImpl>(DRAWING, layerTreeHost);
+ if (m_recordMetricsForFrame)
+ recordMetricsInternal<CCLayerTreeHostImpl>(DRAWING, layerTreeHost);
}
template<typename LayerTreeHostType>
// FIXME: compute overdraw metrics only occasionally, not every frame.
class CCOverdrawMetrics {
public:
- static PassOwnPtr<CCOverdrawMetrics> create() { return adoptPtr(new CCOverdrawMetrics()); }
+ static PassOwnPtr<CCOverdrawMetrics> create(bool recordMetricsForFrame) { return adoptPtr(new CCOverdrawMetrics(recordMetricsForFrame)); }
void didCull(const TransformationMatrix& transformToTarget, const IntRect& beforeCullRect, const IntRect& afterCullRect);
void didDraw(const TransformationMatrix& transformToTarget, const IntRect& afterCullRect, const IntRect& opaqueRect);
float pixelsCulled() const { return m_pixelsCulled; }
private:
- CCOverdrawMetrics();
+ explicit CCOverdrawMetrics(bool recordMetricsForFrame);
enum MetricsType {
DRAWING,
template<typename LayerTreeHostType>
void recordMetricsInternal(MetricsType, const LayerTreeHostType*) const;
+ // When false this class is a giant no-op.
+ bool m_recordMetricsForFrame;
// Count of pixels that are opaque (and thus occlude). Ideally this is no more
// than wiewport width x height.
float m_pixelsDrawnOpaque;
+2012-03-20 Dana Jansens <danakj@chromium.org>
+
+ [chromium] Allow us to disable overdraw metrics when tracing is off
+ https://bugs.webkit.org/show_bug.cgi?id=81431
+
+ Reviewed by Adrienne Walker.
+
+ * tests/CCOcclusionTrackerTest.cpp:
+ (WebCore::TestCCOcclusionTrackerBase::TestCCOcclusionTrackerBase):
+ * tests/CCQuadCullerTest.cpp:
+ (WebCore::TestCCOcclusionTrackerImpl::TestCCOcclusionTrackerImpl):
+ (WebCore::TEST):
+ (WebCore):
+ * tests/TiledLayerChromiumTest.cpp:
+ (WTF::TestCCOcclusionTracker::TestCCOcclusionTracker):
+
2012-03-20 Dana Jansens <danakj@chromium.org>
[chromium] Use opaque contents for paint culling
template<typename LayerType, typename RenderSurfaceType>
class TestCCOcclusionTrackerBase : public CCOcclusionTrackerBase<LayerType, RenderSurfaceType> {
public:
- TestCCOcclusionTrackerBase(IntRect screenScissorRect)
- : CCOcclusionTrackerBase<LayerType, RenderSurfaceType>(screenScissorRect)
+ TestCCOcclusionTrackerBase(IntRect screenScissorRect, bool recordMetricsForFrame = false)
+ : CCOcclusionTrackerBase<LayerType, RenderSurfaceType>(screenScissorRect, recordMetricsForFrame)
, m_overrideLayerScissorRect(false)
{
}
class TestCCOcclusionTrackerImpl : public CCOcclusionTrackerImpl {
public:
- TestCCOcclusionTrackerImpl(const IntRect& scissorRectInScreen)
- : CCOcclusionTrackerImpl(scissorRectInScreen)
+ TestCCOcclusionTrackerImpl(const IntRect& scissorRectInScreen, bool recordMetricsForFrame = true)
+ : CCOcclusionTrackerImpl(scissorRectInScreen, recordMetricsForFrame)
, m_scissorRectInScreen(scissorRectInScreen)
{
// Pretend we have visited a render surface.
EXPECT_NEAR(occlusionTracker.overdrawMetrics().pixelsCulled(), 130000, 1);
}
+TEST(CCQuadCullerTest, verifyWithoutMetrics)
+{
+ DECLARE_AND_INITIALIZE_TEST_QUADS
+
+ OwnPtr<CCTiledLayerImpl> rootLayer = makeLayer(TransformationMatrix(), rootRect, 1.0, true, IntRect());
+ OwnPtr<CCTiledLayerImpl> childLayer = makeLayer(TransformationMatrix(), childRect, 1.0, true, IntRect());
+ TestCCOcclusionTrackerImpl occlusionTracker(IntRect(50, 50, 200, 200), false);
+
+ appendQuads(quadList, sharedStateList, childLayer.get(), occlusionTracker);
+ occlusionTracker.markOccludedBehindLayer(childLayer.get());
+ appendQuads(quadList, sharedStateList, rootLayer.get(), occlusionTracker);
+ EXPECT_EQ(quadList.size(), 9u);
+ EXPECT_NEAR(occlusionTracker.overdrawMetrics().pixelsDrawnOpaque(), 0, 1);
+ EXPECT_NEAR(occlusionTracker.overdrawMetrics().pixelsDrawnTranslucent(), 0, 1);
+ EXPECT_NEAR(occlusionTracker.overdrawMetrics().pixelsCulled(), 0, 1);
+}
+
+
} // namespace
class TestCCOcclusionTracker : public CCOcclusionTracker {
public:
TestCCOcclusionTracker()
- : CCOcclusionTracker(IntRect(0, 0, 1000, 1000))
+ : CCOcclusionTracker(IntRect(0, 0, 1000, 1000), true)
, m_scissorRectInScreen(IntRect(0, 0, 1000, 1000))
{
// Pretend we have visited a render surface.