Add the DelegatingRenderer class with its initialize path.

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"
@@ skipping 187 matching lines @@
         m_hostImpl->drawLayers(frame);
         m_hostImpl->didDrawAllLayers(frame);
     }
 
     void pinchZoomPanViewportForcesCommitRedraw(const float deviceScaleFactor);
     void pinchZoomPanViewportTest(const float deviceScaleFactor);
     void pinchZoomPanViewportAndScrollTest(const float deviceScaleFactor);
     void pinchZoomPanViewportAndScrollBoundaryTest(const float deviceScaleFactor);
 
 protected:
-    scoped_ptr<OutputSurface> createOutputSurface()
-    {
-        return FakeOutputSurface::Create3d(scoped_ptr<WebKit::WebGraphicsContext3D>(new FakeWebGraphicsContext3D)).PassAs<OutputSurface>();
-    }
+    virtual scoped_ptr<OutputSurface> createOutputSurface() { return createFakeOutputSurface(); }
 
     FakeProxy m_proxy;
     DebugScopedSetImplThread m_alwaysImplThread;
     DebugScopedSetMainThreadBlocked m_alwaysMainThreadBlocked;
 
     scoped_ptr<LayerTreeHostImpl> m_hostImpl;
     bool m_onCanDrawStateChangedCalled;
     bool m_didRequestCommit;
     bool m_didRequestRedraw;
     bool m_reduceMemoryResult;
@@ skipping 3985 matching lines @@
 struct RenderPassRemovalTestData : public LayerTreeHostImpl::FrameData {
     ScopedPtrHashMap<RenderPass::Id, TestRenderPass> renderPassCache;
     scoped_ptr<SharedQuadState> sharedQuadState;
 };
 
 class TestRenderer : public GLRenderer, public RendererClient {
 public:
     static scoped_ptr<TestRenderer> create(ResourceProvider* resourceProvider, Proxy* proxy)
     {
         scoped_ptr<TestRenderer> renderer(new TestRenderer(resourceProvider, proxy));
-        if (!renderer->initialize())
+        if (!renderer->initialize(resourceProvider))
             return scoped_ptr<TestRenderer>();
 
         return renderer.Pass();
     }
 
     void clearCachedTextures() { m_textures.clear(); }
     void setHaveCachedResourcesForRenderPassId(RenderPass::Id id) { m_textures.insert(id); }
 
     virtual bool haveCachedResourcesForRenderPassId(RenderPass::Id id) const OVERRIDE { return m_textures.count(id); }
 
@@ skipping 661 matching lines @@
 TEST_P(LayerTreeHostImplTest, pinchZoomPanViewportAndScrollBoundaryWithDeviceScaleFactor)
 {
     pinchZoomPanViewportAndScrollBoundaryTest(1);
 }
 
 TEST_P(LayerTreeHostImplTest, pinchZoomPanViewportAndScrollBoundaryWithDeviceScaleFactor2)
 {
     pinchZoomPanViewportAndScrollBoundaryTest(2);
 }
 
+class LayerTreeHostImplTestWithDelegatingRenderer : public LayerTreeHostImplTest {
+protected:
+    virtual scoped_ptr<OutputSurface> createOutputSurface()
+    {
+        // Creates an output surface with a parent to use a delegating renderer.
+        WebKit::WebGraphicsContext3D::Attributes attrs;
+        return FakeOutputSurface::CreateDelegating3d(WebKit::CompositorFakeWebGraphicsContext3D::create(attrs).PassAs<WebKit::WebGraphicsContext3D>()).PassAs<OutputSurface>();
+    }
+
+    void drawFrameAndTestDamage(const gfx::RectF& expectedDamage) {
+        LayerTreeHostImpl::FrameData frame;
+        EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
+        ASSERT_EQ(1u, frame.renderPasses.size());
+
+        // Verify the damage rect for the root render pass.
+        const RenderPass* rootRenderPass = frame.renderPasses.back();
+        EXPECT_RECT_EQ(expectedDamage, rootRenderPass->damage_rect);
+
+        // Verify the root layer's quad is generated and not being culled.
+        ASSERT_EQ(1u, rootRenderPass->quad_list.size());
+        gfx::Rect expectedVisibleRect(m_hostImpl->rootLayer()->contentBounds());
+        EXPECT_RECT_EQ(expectedVisibleRect, rootRenderPass->quad_list[0]->visible_rect);
+
+        m_hostImpl->drawLayers(frame);
+        m_hostImpl->didDrawAllLayers(frame);
+    }
+};
+
+TEST_P(LayerTreeHostImplTestWithDelegatingRenderer, FrameIncludesDamageRect)
+{
+    // Draw a frame. In the first frame, the entire viewport should be damaged.
+    gfx::Rect fullFrameDamage = gfx::Rect(m_hostImpl->deviceViewportSize());
+    drawFrameAndTestDamage(fullFrameDamage);
+
+    // The second frame should have no damage, but the quads should still be generated.
+    gfx::Rect noDamage = gfx::Rect(m_hostImpl->deviceViewportSize());
+    drawFrameAndTestDamage(noDamage);
+}
+
 INSTANTIATE_TEST_CASE_P(LayerTreeHostImplTests,
                         LayerTreeHostImplTest,
                         ::testing::Values(false, true));
 
 }  // namespace
 }  // namespace cc