Send compositor frame IPC with metadata.

cc/gl_renderer_unittest.cc

 // Copyright 2012 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/gl_renderer.h"
 
+#include "cc/compositor_frame_metadata.h"
 #include "cc/draw_quad.h"
 #include "cc/prioritized_resource_manager.h"
 #include "cc/resource_provider.h"
 #include "cc/test/fake_impl_proxy.h"
 #include "cc/test/fake_layer_tree_host_impl.h"
 #include "cc/test/fake_output_surface.h"
 #include "cc/test/fake_web_graphics_context_3d.h"
 #include "cc/test/render_pass_test_common.h"
 #include "cc/test/render_pass_test_utils.h"
 #include "testing/gmock/include/gmock/gmock.h"
@@ skipping 61 matching lines @@
     // RendererClient methods.
     virtual const gfx::Size& deviceViewportSize() const OVERRIDE { static gfx::Size fakeSize(1, 1); return fakeSize; }
     virtual const LayerTreeSettings& settings() const OVERRIDE { static LayerTreeSettings fakeSettings; return fakeSettings; }
     virtual void didLoseOutputSurface() OVERRIDE { }
     virtual void onSwapBuffersComplete() OVERRIDE { }
     virtual void setFullRootLayerDamage() OVERRIDE { m_setFullRootLayerDamageCount++; }
     virtual void setManagedMemoryPolicy(const ManagedMemoryPolicy& policy) OVERRIDE { m_memoryAllocationLimitBytes = policy.bytesLimitWhenVisible; }
     virtual void enforceManagedMemoryPolicy(const ManagedMemoryPolicy& policy) OVERRIDE { if (m_lastCallWasSetVisibility) *m_lastCallWasSetVisibility = false; }
     virtual bool hasImplThread() const OVERRIDE { return false; }
     virtual bool shouldClearRootRenderPass() const OVERRIDE { return true; }
+    virtual CompositorFrameMetadata makeCompositorFrameMetadata() const
+        OVERRIDE { return CompositorFrameMetadata(); }
 
     // Methods added for test.
     int setFullRootLayerDamageCount() const { return m_setFullRootLayerDamageCount; }
     void setLastCallWasSetVisibilityPointer(bool* lastCallWasSetVisibility) { m_lastCallWasSetVisibility = lastCallWasSetVisibility; }
 
     RenderPass* rootRenderPass() { return m_renderPassesInDrawOrder.back(); }
     RenderPassList& renderPassesInDrawOrder() { return m_renderPassesInDrawOrder; }
     RenderPassIdHashMap& renderPasses() { return m_renderPasses; }
 
     size_t memoryAllocationLimitBytes() const { return m_memoryAllocationLimitBytes; }
 
 private:
     FakeImplProxy m_proxy;
     FakeLayerTreeHostImpl m_hostImpl;
     int m_setFullRootLayerDamageCount;
     bool* m_lastCallWasSetVisibility;
     scoped_ptr<LayerImpl> m_rootLayer;
     RenderPassList m_renderPassesInDrawOrder;
     RenderPassIdHashMap m_renderPasses;
     size_t m_memoryAllocationLimitBytes;
 };
 
 class FakeRendererGL : public GLRenderer {
 public:
-    FakeRendererGL(RendererClient* client, ResourceProvider* resourceProvider) : GLRenderer(client, resourceProvider) { }
+    FakeRendererGL(RendererClient* client, OutputSurface* outputSurface, ResourceProvider* resourceProvider) : GLRenderer(client, outputSurface, resourceProvider) { }
 
     // GLRenderer methods.
 
     // Changing visibility to public.
     using GLRenderer::initialize;
     using GLRenderer::isBackbufferDiscarded;
     using GLRenderer::drawQuad;
     using GLRenderer::beginDrawingFrame;
     using GLRenderer::finishDrawingQuadList;
 };
 
 class GLRendererTest : public testing::Test {
 protected:
     GLRendererTest()
         : m_suggestHaveBackbufferYes(1, true)
         , m_suggestHaveBackbufferNo(1, false)
-        , m_context(FakeOutputSurface::Create3d(scoped_ptr<WebKit::WebGraphicsContext3D>(new FrameCountingMemoryAllocationSettingContext())))
-        , m_resourceProvider(ResourceProvider::create(m_context.get()))
-        , m_renderer(&m_mockClient, m_resourceProvider.get())
+        , m_outputSurface(FakeOutputSurface::Create3d(scoped_ptr<WebKit::WebGraphicsContext3D>(new FrameCountingMemoryAllocationSettingContext())))
+        , m_resourceProvider(ResourceProvider::create(m_outputSurface.get()))
+        , m_renderer(&m_mockClient, m_outputSurface.get(), m_resourceProvider.get())
     {
     }
 
     virtual void SetUp()
     {
         m_renderer.initialize();
     }
 
     void swapBuffers()
     {
         m_renderer.swapBuffers();
     }
 
-    FrameCountingMemoryAllocationSettingContext* context() { return static_cast<FrameCountingMemoryAllocationSettingContext*>(m_context->Context3D()); }
+    FrameCountingMemoryAllocationSettingContext* context() { return static_cast<FrameCountingMemoryAllocationSettingContext*>(m_outputSurface->Context3D()); }
 
     WebGraphicsMemoryAllocation m_suggestHaveBackbufferYes;
     WebGraphicsMemoryAllocation m_suggestHaveBackbufferNo;
 
-    scoped_ptr<OutputSurface> m_context;
+    scoped_ptr<OutputSurface> m_outputSurface;
     FakeRendererClient m_mockClient;
     scoped_ptr<ResourceProvider> m_resourceProvider;
     FakeRendererGL m_renderer;
 };
 
 // Test GLRenderer discardBackbuffer functionality:
 // Suggest recreating framebuffer when one already exists.
 // Expected: it does nothing.
 TEST_F(GLRendererTest, SuggestBackbufferYesWhenItAlreadyExistsShouldDoNothing)
 {
@@ skipping 140 matching lines @@
     virtual WGC3Dint getUniformLocation(WebGLId program, const WGC3Dchar* name) { ADD_FAILURE(); return 0; }
     virtual void getVertexAttribfv(WGC3Duint index, WGC3Denum pname, WGC3Dfloat* value) { ADD_FAILURE(); }
     virtual void getVertexAttribiv(WGC3Duint index, WGC3Denum pname, WGC3Dint* value) { ADD_FAILURE(); }
     virtual WGC3Dsizeiptr getVertexAttribOffset(WGC3Duint index, WGC3Denum pname) { ADD_FAILURE(); return 0; }
 };
 
 // This test isn't using the same fixture as GLRendererTest, and you can't mix TEST() and TEST_F() with the same name, hence LRC2.
 TEST(GLRendererTest2, initializationDoesNotMakeSynchronousCalls)
 {
     FakeRendererClient mockClient;
-    scoped_ptr<OutputSurface> context(FakeOutputSurface::Create3d(scoped_ptr<WebKit::WebGraphicsContext3D>(new ForbidSynchronousCallContext)));
-    scoped_ptr<ResourceProvider> resourceProvider(ResourceProvider::create(context.get()));
-    FakeRendererGL renderer(&mockClient, resourceProvider.get());
+    scoped_ptr<OutputSurface> outputSurface(FakeOutputSurface::Create3d(scoped_ptr<WebKit::WebGraphicsContext3D>(new ForbidSynchronousCallContext)));
+    scoped_ptr<ResourceProvider> resourceProvider(ResourceProvider::create(outputSurface.get()));
+    FakeRendererGL renderer(&mockClient, outputSurface.get(), resourceProvider.get());
 
     EXPECT_TRUE(renderer.initialize());
 }
 
 class LoseContextOnFirstGetContext : public FakeWebGraphicsContext3D {
 public:
     LoseContextOnFirstGetContext()
         : m_contextLost(false)
     {
     }
@@ skipping 20 matching lines @@
         return m_contextLost ? 1 : 0;
     }
 
 private:
     bool m_contextLost;
 };
 
 TEST(GLRendererTest2, initializationWithQuicklyLostContextDoesNotAssert)
 {
     FakeRendererClient mockClient;
-    scoped_ptr<OutputSurface> context(FakeOutputSurface::Create3d(scoped_ptr<WebKit::WebGraphicsContext3D>(new LoseContextOnFirstGetContext)));
-    scoped_ptr<ResourceProvider> resourceProvider(ResourceProvider::create(context.get()));
-    FakeRendererGL renderer(&mockClient, resourceProvider.get());
+    scoped_ptr<OutputSurface> outputSurface(FakeOutputSurface::Create3d(scoped_ptr<WebKit::WebGraphicsContext3D>(new LoseContextOnFirstGetContext)));
+    scoped_ptr<ResourceProvider> resourceProvider(ResourceProvider::create(outputSurface.get()));
+    FakeRendererGL renderer(&mockClient, outputSurface.get(), resourceProvider.get());
 
     renderer.initialize();
 }
 
 class ContextThatDoesNotSupportMemoryManagmentExtensions : public FakeWebGraphicsContext3D {
 public:
     ContextThatDoesNotSupportMemoryManagmentExtensions() { }
 
     // WebGraphicsContext3D methods.
 
     // This method would normally do a glSwapBuffers under the hood.
     virtual void prepareTexture() { }
     virtual void setMemoryAllocationChangedCallbackCHROMIUM(WebGraphicsMemoryAllocationChangedCallbackCHROMIUM* callback) { }
     virtual WebString getString(WebKit::WGC3Denum name) { return WebString(); }
 };
 
 TEST(GLRendererTest2, initializationWithoutGpuMemoryManagerExtensionSupportShouldDefaultToNonZeroAllocation)
 {
     FakeRendererClient mockClient;
     scoped_ptr<OutputSurface> outputSurface(FakeOutputSurface::Create3d(scoped_ptr<WebKit::WebGraphicsContext3D>(new ContextThatDoesNotSupportMemoryManagmentExtensions)));
     scoped_ptr<ResourceProvider> resourceProvider(ResourceProvider::create(outputSurface.get()));
-    FakeRendererGL renderer(&mockClient, resourceProvider.get());
+    FakeRendererGL renderer(&mockClient, outputSurface.get(), resourceProvider.get());
 
     renderer.initialize();
 
     EXPECT_GT(mockClient.memoryAllocationLimitBytes(), 0ul);
 }
 
 class ClearCountingContext : public FakeWebGraphicsContext3D {
 public:
     ClearCountingContext() : m_clear(0) { }
 
     virtual void clear(WGC3Dbitfield)
     {
         m_clear++;
     }
 
     int clearCount() const { return m_clear; }
 
 private:
     int m_clear;
 };
 
 TEST(GLRendererTest2, opaqueBackground)
 {
     FakeRendererClient mockClient;
     scoped_ptr<OutputSurface> outputSurface(FakeOutputSurface::Create3d(scoped_ptr<WebKit::WebGraphicsContext3D>(new ClearCountingContext)));
     ClearCountingContext* context = static_cast<ClearCountingContext*>(outputSurface->Context3D());
     scoped_ptr<ResourceProvider> resourceProvider(ResourceProvider::create(outputSurface.get()));
-    FakeRendererGL renderer(&mockClient, resourceProvider.get());
+    FakeRendererGL renderer(&mockClient, outputSurface.get(), resourceProvider.get());
 
     mockClient.rootRenderPass()->has_transparent_background = false;
 
     EXPECT_TRUE(renderer.initialize());
 
     renderer.drawFrame(mockClient.renderPassesInDrawOrder(), mockClient.renderPasses());
 
     // On DEBUG builds, render passes with opaque background clear to blue to
     // easily see regions that were not drawn on the screen.
 #ifdef NDEBUG
     EXPECT_EQ(0, context->clearCount());
 #else
     EXPECT_EQ(1, context->clearCount());
 #endif
 }
 
 TEST(GLRendererTest2, transparentBackground)
 {
     FakeRendererClient mockClient;
     scoped_ptr<OutputSurface> outputSurface(FakeOutputSurface::Create3d(scoped_ptr<WebKit::WebGraphicsContext3D>(new ClearCountingContext)));
     ClearCountingContext* context = static_cast<ClearCountingContext*>(outputSurface->Context3D());
     scoped_ptr<ResourceProvider> resourceProvider(ResourceProvider::create(outputSurface.get()));
-    FakeRendererGL renderer(&mockClient, resourceProvider.get());
+    FakeRendererGL renderer(&mockClient, outputSurface.get(), resourceProvider.get());
 
     mockClient.rootRenderPass()->has_transparent_background = true;
 
     EXPECT_TRUE(renderer.initialize());
 
     renderer.drawFrame(mockClient.renderPassesInDrawOrder(), mockClient.renderPasses());
 
     EXPECT_EQ(1, context->clearCount());
 }
 
@@ skipping 30 matching lines @@
 private:
     bool* m_lastCallWasSetVisibility;
 };
 
 TEST(GLRendererTest2, visibilityChangeIsLastCall)
 {
     FakeRendererClient mockClient;
     scoped_ptr<OutputSurface> outputSurface(FakeOutputSurface::Create3d(scoped_ptr<WebKit::WebGraphicsContext3D>(new VisibilityChangeIsLastCallTrackingContext)));
     VisibilityChangeIsLastCallTrackingContext* context = static_cast<VisibilityChangeIsLastCallTrackingContext*>(outputSurface->Context3D());
     scoped_ptr<ResourceProvider> resourceProvider(ResourceProvider::create(outputSurface.get()));
-    FakeRendererGL renderer(&mockClient, resourceProvider.get());
+    FakeRendererGL renderer(&mockClient, outputSurface.get(), resourceProvider.get());
 
     EXPECT_TRUE(renderer.initialize());
 
     bool lastCallWasSetVisiblity = false;
     // Ensure that the call to setVisibilityCHROMIUM is the last call issue to the GPU
     // process, after glFlush is called, and after the RendererClient's enforceManagedMemoryPolicy
     // is called. Plumb this tracking between both the RenderClient and the Context by giving
     // them both a pointer to a variable on the stack.
     context->setLastCallWasSetVisibilityPointer(&lastCallWasSetVisiblity);
     mockClient.setLastCallWasSetVisibilityPointer(&lastCallWasSetVisiblity);
@@ skipping 31 matching lines @@
 private:
     WGC3Denum m_activeTexture;
 };
 
 TEST(GLRendererTest2, activeTextureState)
 {
     FakeRendererClient fakeClient;
     scoped_ptr<OutputSurface> outputSurface(FakeOutputSurface::Create3d(scoped_ptr<WebKit::WebGraphicsContext3D>(new TextureStateTrackingContext)));
     TextureStateTrackingContext* context = static_cast<TextureStateTrackingContext*>(outputSurface->Context3D());
     scoped_ptr<ResourceProvider> resourceProvider(ResourceProvider::create(outputSurface.get()));
-    FakeRendererGL renderer(&fakeClient, resourceProvider.get());
+    FakeRendererGL renderer(&fakeClient, outputSurface.get(), resourceProvider.get());
 
     // During initialization we are allowed to set any texture parameters.
     EXPECT_CALL(*context, texParameteri(_, _, _)).Times(AnyNumber());
     EXPECT_TRUE(renderer.initialize());
 
     cc::RenderPass::Id id(1, 1);
     scoped_ptr<TestRenderPass> pass = TestRenderPass::Create();
     pass->SetNew(id, gfx::Rect(0, 0, 100, 100), gfx::Rect(0, 0, 100, 100), gfx::Transform());
     pass->AppendOneOfEveryQuadType(resourceProvider.get());
 
@@ skipping 47 matching lines @@
 public:
     MOCK_METHOD1(clear, void(WGC3Dbitfield mask));
     MOCK_METHOD4(drawElements, void(WGC3Denum mode, WGC3Dsizei count, WGC3Denum type, WGC3Dintptr offset));
 };
 
 TEST(GLRendererTest2, shouldClearRootRenderPass)
 {
     NoClearRootRenderPassFakeClient mockClient;
     scoped_ptr<OutputSurface> outputSurface(FakeOutputSurface::Create3d(scoped_ptr<WebKit::WebGraphicsContext3D>(new NoClearRootRenderPassMockContext)));
     NoClearRootRenderPassMockContext* mockContext = static_cast<NoClearRootRenderPassMockContext*>(outputSurface->Context3D());
-
     scoped_ptr<ResourceProvider> resourceProvider(ResourceProvider::create(outputSurface.get()));
-    FakeRendererGL renderer(&mockClient, resourceProvider.get());
+    FakeRendererGL renderer(&mockClient, outputSurface.get(), resourceProvider.get());
     EXPECT_TRUE(renderer.initialize());
 
     gfx::Rect viewportRect(mockClient.deviceViewportSize());
     ScopedPtrVector<RenderPass> renderPasses;
 
     RenderPass::Id rootPassId(1, 0);
     TestRenderPass* rootPass = addRenderPass(renderPasses, rootPassId, viewportRect, gfx::Transform());
     addQuad(rootPass, viewportRect, SK_ColorGREEN);
 
     RenderPass::Id childPassId(2, 0);
@@ skipping 26 matching lines @@
 
     renderer.decideRenderPassAllocationsForFrame(mockClient.renderPassesInDrawOrder());
     renderer.drawFrame(mockClient.renderPassesInDrawOrder(), mockClient.renderPasses());
 
     // In multiple render passes all but the root pass should clear the framebuffer.
     Mock::VerifyAndClearExpectations(&mockContext);
 }
 
 }  // namespace
 }  // namespace cc