cc:: Add RenderingStatsInstrumentation to manage collection of RenderingStats

cc/layer_tree_host_impl_unittest.cc

 // Copyright 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "cc/layer_tree_host_impl.h"
 
 #include <cmath>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/hash_tables.h"
 #include "cc/compositor_frame_metadata.h"
 #include "cc/delegated_renderer_layer_impl.h"
 #include "cc/gl_renderer.h"
 #include "cc/heads_up_display_layer_impl.h"
 #include "cc/io_surface_layer_impl.h"
 #include "cc/layer_impl.h"
 #include "cc/layer_tiling_data.h"
 #include "cc/layer_tree_impl.h"
 #include "cc/math_util.h"
 #include "cc/quad_sink.h"
 #include "cc/render_pass_draw_quad.h"
+#include "cc/rendering_stats_instrumentation.h"
 #include "cc/scrollbar_geometry_fixed_thumb.h"
 #include "cc/scrollbar_layer_impl.h"
 #include "cc/single_thread_proxy.h"
 #include "cc/solid_color_draw_quad.h"
 #include "cc/solid_color_layer_impl.h"
 #include "cc/test/animation_test_common.h"
 #include "cc/test/fake_output_surface.h"
 #include "cc/test/fake_proxy.h"
 #include "cc/test/fake_video_frame_provider.h"
 #include "cc/test/fake_web_scrollbar_theme_geometry.h"
@@ skipping 29 matching lines @@
     LayerTreeHostImplTest()
         : m_proxy(scoped_ptr<Thread>(NULL))
         , m_alwaysImplThread(&m_proxy)
         , m_alwaysMainThreadBlocked(&m_proxy)
         , m_onCanDrawStateChangedCalled(false)
         , m_hasPendingTree(false)
         , m_didRequestCommit(false)
         , m_didRequestRedraw(false)
         , m_didUploadVisibleHighResolutionTile(false)
         , m_reduceMemoryResult(true)
+        , m_renderingStatsInstrumentation(RenderingStatsInstrumentation::Create())
     {
         media::InitializeMediaLibraryForTesting();
     }
 
     virtual void SetUp()
     {
         LayerTreeSettings settings;
         settings.minimumOcclusionTrackingSize = gfx::Size();
 
-        m_hostImpl = LayerTreeHostImpl::Create(settings, this, &m_proxy);
+        m_hostImpl = LayerTreeHostImpl::Create(settings, this, &m_proxy, m_renderingStatsInstrumentation.get());
         m_hostImpl->InitializeRenderer(createOutputSurface());
         m_hostImpl->SetViewportSize(gfx::Size(10, 10), gfx::Size(10, 10));
     }
 
     virtual void TearDown()
     {
     }
 
     virtual void DidLoseOutputSurfaceOnImplThread() OVERRIDE { }
     virtual void OnSwapBuffersCompleteOnImplThread() OVERRIDE { }
@@ skipping 12 matching lines @@
     virtual void RenewTreePriority() OVERRIDE { }
 
     void setReduceMemoryResult(bool reduceMemoryResult) { m_reduceMemoryResult = reduceMemoryResult; }
 
     void createLayerTreeHost(bool partialSwap, scoped_ptr<OutputSurface> outputSurface)
     {
         LayerTreeSettings settings;
         settings.minimumOcclusionTrackingSize = gfx::Size();
         settings.partialSwapEnabled = partialSwap;
 
-        m_hostImpl = LayerTreeHostImpl::Create(settings, this, &m_proxy);
+        m_hostImpl = LayerTreeHostImpl::Create(settings, this, &m_proxy, m_renderingStatsInstrumentation.get());
 
         m_hostImpl->InitializeRenderer(outputSurface.Pass());
         m_hostImpl->SetViewportSize(gfx::Size(10, 10), gfx::Size(10, 10));
     }
 
     void setupRootLayerImpl(scoped_ptr<LayerImpl> root)
     {
         root->SetAnchorPoint(gfx::PointF(0, 0));
         root->SetPosition(gfx::PointF(0, 0));
         root->SetBounds(gfx::Size(10, 10));
@@ skipping 91 matching lines @@
       LayerTreeHostImpl::FrameData frameData;
       m_hostImpl->PrepareToDraw(&frameData);
       m_hostImpl->DidDrawAllLayers(frameData);
     }
 
     FakeProxy m_proxy;
     DebugScopedSetImplThread m_alwaysImplThread;
     DebugScopedSetMainThreadBlocked m_alwaysMainThreadBlocked;
 
     scoped_ptr<LayerTreeHostImpl> m_hostImpl;
+    scoped_ptr<RenderingStatsInstrumentation> m_renderingStatsInstrumentation;
     bool m_onCanDrawStateChangedCalled;
     bool m_hasPendingTree;
     bool m_didRequestCommit;
     bool m_didRequestRedraw;
     bool m_didUploadVisibleHighResolutionTile;
     bool m_reduceMemoryResult;
 };
 
 class TestWebGraphicsContext3DMakeCurrentFails : public TestWebGraphicsContext3D {
 public:
@@ skipping 140 matching lines @@
 
 TEST_F(LayerTreeHostImplTest, scrollWithoutRootLayer)
 {
     // We should not crash when trying to scroll an empty layer tree.
     EXPECT_EQ(m_hostImpl->ScrollBegin(gfx::Point(0, 0), InputHandlerClient::Wheel), InputHandlerClient::ScrollIgnored);
 }
 
 TEST_F(LayerTreeHostImplTest, scrollWithoutRenderer)
 {
     LayerTreeSettings settings;
-    m_hostImpl = LayerTreeHostImpl::Create(settings, this, &m_proxy);
+    m_hostImpl = LayerTreeHostImpl::Create(settings, this, &m_proxy, m_renderingStatsInstrumentation.get());
 
     // Initialization will fail here.
     m_hostImpl->InitializeRenderer(FakeOutputSurface::Create3d(scoped_ptr<WebKit::WebGraphicsContext3D>(new TestWebGraphicsContext3DMakeCurrentFails)).PassAs<OutputSurface>());
     m_hostImpl->SetViewportSize(gfx::Size(10, 10), gfx::Size(10, 10));
 
     setupScrollAndContentsLayers(gfx::Size(100, 100));
 
     // We should not crash when trying to scroll after the renderer initialization fails.
     EXPECT_EQ(m_hostImpl->ScrollBegin(gfx::Point(0, 0), InputHandlerClient::Wheel), InputHandlerClient::ScrollIgnored);
 }
@@ skipping 697 matching lines @@
     EXPECT_FALSE(m_didRequestRedraw);
     EXPECT_FALSE(m_didRequestCommit);
 }
 
 TEST_F(LayerTreeHostImplTest, scrollNonScrollableRootWithTopControls)
 {
     LayerTreeSettings settings;
     settings.calculateTopControlsPosition = true;
     settings.topControlsHeight = 50;
 
-    m_hostImpl = LayerTreeHostImpl::Create(settings, this, &m_proxy);
+    m_hostImpl = LayerTreeHostImpl::Create(settings, this, &m_proxy, m_renderingStatsInstrumentation.get());
     m_hostImpl->InitializeRenderer(createOutputSurface());
     m_hostImpl->SetViewportSize(gfx::Size(10, 10), gfx::Size(10, 10));
 
     gfx::Size layerSize(5, 5);
     scoped_ptr<LayerImpl> root = LayerImpl::Create(m_hostImpl->active_tree(), 1);
     root->SetScrollable(true);
     root->SetMaxScrollOffset(gfx::Vector2d(layerSize.width(), layerSize.height()));
     root->SetBounds(layerSize);
     root->SetContentBounds(layerSize);
     root->SetPosition(gfx::PointF(0, 0));
@@ skipping 1029 matching lines @@
 // where it should request to swap only the subBuffer that is damaged.
 TEST_F(LayerTreeHostImplTest, partialSwapReceivesDamageRect)
 {
     scoped_ptr<OutputSurface> outputSurface = FakeOutputSurface::Create3d(scoped_ptr<WebKit::WebGraphicsContext3D>(new PartialSwapTrackerContext)).PassAs<OutputSurface>();
     PartialSwapTrackerContext* partialSwapTracker = static_cast<PartialSwapTrackerContext*>(outputSurface->context3d());
 
     // This test creates its own LayerTreeHostImpl, so
     // that we can force partial swap enabled.
     LayerTreeSettings settings;
     settings.partialSwapEnabled = true;
-    scoped_ptr<LayerTreeHostImpl> layerTreeHostImpl = LayerTreeHostImpl::Create(settings, this, &m_proxy);
+    scoped_ptr<LayerTreeHostImpl> layerTreeHostImpl = LayerTreeHostImpl::Create(settings, this, &m_proxy, m_renderingStatsInstrumentation.get());
     layerTreeHostImpl->InitializeRenderer(outputSurface.Pass());
     layerTreeHostImpl->SetViewportSize(gfx::Size(500, 500), gfx::Size(500, 500));
 
     scoped_ptr<LayerImpl> root = FakeDrawableLayerImpl::Create(layerTreeHostImpl->active_tree(), 1);
     scoped_ptr<LayerImpl> child = FakeDrawableLayerImpl::Create(layerTreeHostImpl->active_tree(), 2);
     child->SetPosition(gfx::PointF(12, 13));
     child->SetAnchorPoint(gfx::PointF(0, 0));
     child->SetBounds(gfx::Size(14, 15));
     child->SetContentBounds(gfx::Size(14, 15));
     child->SetDrawsContent(true);
@@ skipping 271 matching lines @@
     }
 
     // Unlimited texture size.
     virtual void getIntegerv(WebKit::WGC3Denum pname, WebKit::WGC3Dint* value)
     {
         if (pname == GL_MAX_TEXTURE_SIZE)
             *value = 8192;
     }
 };
 
-static scoped_ptr<LayerTreeHostImpl> setupLayersForOpacity(bool partialSwap, LayerTreeHostImplClient* client, Proxy* proxy)
+static scoped_ptr<LayerTreeHostImpl> setupLayersForOpacity(bool partialSwap, LayerTreeHostImplClient* client, Proxy* proxy, RenderingStatsInstrumentation* RenderingStatsInstrumentation)
 {
     scoped_ptr<OutputSurface> outputSurface = FakeOutputSurface::Create3d(scoped_ptr<WebKit::WebGraphicsContext3D>(new PartialSwapContext)).PassAs<OutputSurface>();
 
     LayerTreeSettings settings;
     settings.partialSwapEnabled = partialSwap;
-    scoped_ptr<LayerTreeHostImpl> myHostImpl = LayerTreeHostImpl::Create(settings, client, proxy);
+    scoped_ptr<LayerTreeHostImpl> myHostImpl = LayerTreeHostImpl::Create(settings, client, proxy, RenderingStatsInstrumentation);
     myHostImpl->InitializeRenderer(outputSurface.Pass());
     myHostImpl->SetViewportSize(gfx::Size(100, 100), gfx::Size(100, 100));
 
     /*
       Layers are created as follows:
 
          +--------------------+
          |                  1 |
          |  +-----------+     |
          |  |         2 |     |
@@ skipping 43 matching lines @@
 
     child->AddChild(grandChild.Pass());
     root->AddChild(child.Pass());
 
     myHostImpl->active_tree()->SetRootLayer(root.Pass());
     return myHostImpl.Pass();
 }
 
 TEST_F(LayerTreeHostImplTest, contributingLayerEmptyScissorPartialSwap)
 {
-    scoped_ptr<LayerTreeHostImpl> myHostImpl = setupLayersForOpacity(true, this, &m_proxy);
+    scoped_ptr<LayerTreeHostImpl> myHostImpl = setupLayersForOpacity(true, this, &m_proxy, m_renderingStatsInstrumentation.get());
 
     {
         LayerTreeHostImpl::FrameData frame;
         EXPECT_TRUE(myHostImpl->PrepareToDraw(&frame));
 
         // Verify all quads have been computed
         ASSERT_EQ(2U, frame.render_passes.size());
         ASSERT_EQ(1U, frame.render_passes[0]->quad_list.size());
         ASSERT_EQ(1U, frame.render_passes[1]->quad_list.size());
         EXPECT_EQ(DrawQuad::SOLID_COLOR, frame.render_passes[0]->quad_list[0]->material);
         EXPECT_EQ(DrawQuad::RENDER_PASS, frame.render_passes[1]->quad_list[0]->material);
 
         myHostImpl->DrawLayers(&frame);
         myHostImpl->DidDrawAllLayers(frame);
     }
 }
 
 TEST_F(LayerTreeHostImplTest, contributingLayerEmptyScissorNoPartialSwap)
 {
-    scoped_ptr<LayerTreeHostImpl> myHostImpl = setupLayersForOpacity(false, this, &m_proxy);
+    scoped_ptr<LayerTreeHostImpl> myHostImpl = setupLayersForOpacity(false, this, &m_proxy, m_renderingStatsInstrumentation.get());
 
     {
         LayerTreeHostImpl::FrameData frame;
         EXPECT_TRUE(myHostImpl->PrepareToDraw(&frame));
 
         // Verify all quads have been computed
         ASSERT_EQ(2U, frame.render_passes.size());
         ASSERT_EQ(1U, frame.render_passes[0]->quad_list.size());
         ASSERT_EQ(1U, frame.render_passes[1]->quad_list.size());
         EXPECT_EQ(DrawQuad::SOLID_COLOR, frame.render_passes[0]->quad_list[0]->material);
@@ skipping 194 matching lines @@
 class GLRendererWithReleaseTextures : public GLRenderer {
 public:
     using GLRenderer::ReleaseRenderPassTextures;
 };
 
 TEST_F(LayerTreeHostImplTest, textureCachingWithOcclusion)
 {
     LayerTreeSettings settings;
     settings.minimumOcclusionTrackingSize = gfx::Size();
     settings.cacheRenderPassContents = true;
-    scoped_ptr<LayerTreeHostImpl> myHostImpl = LayerTreeHostImpl::Create(settings, this, &m_proxy);
+    scoped_ptr<LayerTreeHostImpl> myHostImpl = LayerTreeHostImpl::Create(settings, this, &m_proxy, m_renderingStatsInstrumentation.get());
 
     // Layers are structure as follows:
     //
     //  R +-- S1 +- L10 (owning)
     //    |      +- L11
     //    |      +- L12
     //    |
     //    +-- S2 +- L20 (owning)
     //           +- L21
     //
@@ skipping 94 matching lines @@
         myHostImpl->DidDrawAllLayers(frame);
     }
 
 }
 
 TEST_F(LayerTreeHostImplTest, textureCachingWithOcclusionEarlyOut)
 {
     LayerTreeSettings settings;
     settings.minimumOcclusionTrackingSize = gfx::Size();
     settings.cacheRenderPassContents = true;
-    scoped_ptr<LayerTreeHostImpl> myHostImpl = LayerTreeHostImpl::Create(settings, this, &m_proxy);
+    scoped_ptr<LayerTreeHostImpl> myHostImpl = LayerTreeHostImpl::Create(settings, this, &m_proxy, m_renderingStatsInstrumentation.get());
 
     // Layers are structure as follows:
     //
     //  R +-- S1 +- L10 (owning, non drawing)
     //    |      +- L11 (corner, unoccluded)
     //    |      +- L12 (corner, unoccluded)
     //    |      +- L13 (corner, unoccluded)
     //    |      +- L14 (corner, entirely occluded)
     //    |
     //    +-- S2 +- L20 (owning, drawing)
@@ skipping 94 matching lines @@
         myHostImpl->DrawLayers(&frame);
         myHostImpl->DidDrawAllLayers(frame);
     }
 }
 
 TEST_F(LayerTreeHostImplTest, textureCachingWithOcclusionExternalOverInternal)
 {
     LayerTreeSettings settings;
     settings.minimumOcclusionTrackingSize = gfx::Size();
     settings.cacheRenderPassContents = true;
-    scoped_ptr<LayerTreeHostImpl> myHostImpl = LayerTreeHostImpl::Create(settings, this, &m_proxy);
+    scoped_ptr<LayerTreeHostImpl> myHostImpl = LayerTreeHostImpl::Create(settings, this, &m_proxy, m_renderingStatsInstrumentation.get());
 
     // Layers are structured as follows:
     //
     //  R +-- S1 +- L10 (owning, drawing)
     //    |      +- L11 (corner, occluded by L12)
     //    |      +- L12 (opposite corner)
     //    |
     //    +-- S2 +- L20 (owning, drawing)
     //
 
@@ skipping 66 matching lines @@
 
         myHostImpl->DrawLayers(&frame);
         myHostImpl->DidDrawAllLayers(frame);
     }
 }
 
 TEST_F(LayerTreeHostImplTest, textureCachingWithOcclusionExternalNotAligned)
 {
     LayerTreeSettings settings;
     settings.cacheRenderPassContents = true;
-    scoped_ptr<LayerTreeHostImpl> myHostImpl = LayerTreeHostImpl::Create(settings, this, &m_proxy);
+    scoped_ptr<LayerTreeHostImpl> myHostImpl = LayerTreeHostImpl::Create(settings, this, &m_proxy, m_renderingStatsInstrumentation.get());
 
     // Layers are structured as follows:
     //
     //  R +-- S1 +- L10 (rotated, drawing)
     //           +- L11 (occupies half surface)
 
     LayerImpl* rootPtr;
     LayerImpl* layerS1Ptr;
 
     scoped_ptr<OutputSurface> outputSurface = FakeOutputSurface::Create3d(scoped_ptr<WebKit::WebGraphicsContext3D>(new PartialSwapContext)).PassAs<OutputSurface>();
@@ skipping 54 matching lines @@
         myHostImpl->DidDrawAllLayers(frame);
     }
 }
 
 TEST_F(LayerTreeHostImplTest, textureCachingWithOcclusionPartialSwap)
 {
     LayerTreeSettings settings;
     settings.minimumOcclusionTrackingSize = gfx::Size();
     settings.partialSwapEnabled = true;
     settings.cacheRenderPassContents = true;
-    scoped_ptr<LayerTreeHostImpl> myHostImpl = LayerTreeHostImpl::Create(settings, this, &m_proxy);
+    scoped_ptr<LayerTreeHostImpl> myHostImpl = LayerTreeHostImpl::Create(settings, this, &m_proxy, m_renderingStatsInstrumentation.get());
 
     // Layers are structure as follows:
     //
     //  R +-- S1 +- L10 (owning)
     //    |      +- L11
     //    |      +- L12
     //    |
     //    +-- S2 +- L20 (owning)
     //           +- L21
     //
@@ skipping 91 matching lines @@
         myHostImpl->DrawLayers(&frame);
         myHostImpl->DidDrawAllLayers(frame);
     }
 }
 
 TEST_F(LayerTreeHostImplTest, textureCachingWithScissor)
 {
     LayerTreeSettings settings;
     settings.minimumOcclusionTrackingSize = gfx::Size();
     settings.cacheRenderPassContents = true;
-    scoped_ptr<LayerTreeHostImpl> myHostImpl = LayerTreeHostImpl::Create(settings, this, &m_proxy);
+    scoped_ptr<LayerTreeHostImpl> myHostImpl = LayerTreeHostImpl::Create(settings, this, &m_proxy, m_renderingStatsInstrumentation.get());
 
     /*
       Layers are created as follows:
 
          +--------------------+
          |                  1 |
          |  +-----------+     |
          |  |         2 |     |
          |  | +-------------------+
          |  | |   3               |
@@ skipping 86 matching lines @@
     // We should have a cached texture for surface 2 again even though it was damaged.
     EXPECT_TRUE(myHostImpl->renderer()->HaveCachedResourcesForRenderPassId(childPassId));
 }
 
 TEST_F(LayerTreeHostImplTest, surfaceTextureCaching)
 {
     LayerTreeSettings settings;
     settings.minimumOcclusionTrackingSize = gfx::Size();
     settings.partialSwapEnabled = true;
     settings.cacheRenderPassContents = true;
-    scoped_ptr<LayerTreeHostImpl> myHostImpl = LayerTreeHostImpl::Create(settings, this, &m_proxy);
+    scoped_ptr<LayerTreeHostImpl> myHostImpl = LayerTreeHostImpl::Create(settings, this, &m_proxy, m_renderingStatsInstrumentation.get());
 
     LayerImpl* rootPtr;
     LayerImpl* intermediateLayerPtr;
     LayerImpl* surfaceLayerPtr;
     LayerImpl* childPtr;
 
     setupLayersForTextureCaching(myHostImpl.get(), rootPtr, intermediateLayerPtr, surfaceLayerPtr, childPtr, gfx::Size(100, 100));
 
     {
         LayerTreeHostImpl::FrameData frame;
@@ skipping 138 matching lines @@
         myHostImpl->DrawLayers(&frame);
         myHostImpl->DidDrawAllLayers(frame);
     }
 }
 
 TEST_F(LayerTreeHostImplTest, surfaceTextureCachingNoPartialSwap)
 {
     LayerTreeSettings settings;
     settings.minimumOcclusionTrackingSize = gfx::Size();
     settings.cacheRenderPassContents = true;
-    scoped_ptr<LayerTreeHostImpl> myHostImpl = LayerTreeHostImpl::Create(settings, this, &m_proxy);
+    scoped_ptr<LayerTreeHostImpl> myHostImpl = LayerTreeHostImpl::Create(settings, this, &m_proxy, m_renderingStatsInstrumentation.get());
 
     LayerImpl* rootPtr;
     LayerImpl* intermediateLayerPtr;
     LayerImpl* surfaceLayerPtr;
     LayerImpl* childPtr;
 
     setupLayersForTextureCaching(myHostImpl.get(), rootPtr, intermediateLayerPtr, surfaceLayerPtr, childPtr, gfx::Size(100, 100));
 
     {
         LayerTreeHostImpl::FrameData frame;
@@ skipping 809 matching lines @@
         EXPECT_EQ(gfx::Rect(0, 0, 100, 100).ToString(), renderPassQuad->rect.ToString());
         EXPECT_EQ(gfx::RectF(0.f, 0.f, 1.f, 1.f).ToString(), renderPassQuad->mask_uv_rect.ToString());
 
         m_hostImpl->DrawLayers(&frame);
         m_hostImpl->DidDrawAllLayers(frame);
     }
 }
 
 }  // namespace
 }  // namespace cc