Implement WebKit::WebUnitTestSupport::createLayerTreeViewForTesting()

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 "cc/test/test_web_graphics_context_3d.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/khronos/GLES2/gl2.h"
 #include "ui/gfx/transform.h"
 
 using namespace WebKit;
 
 using testing::_;
 using testing::AnyNumber;
 using testing::AtLeast;
 using testing::Expectation;
 using testing::InSequence;
 using testing::Mock;
 
 namespace cc {
 namespace {
 
-class FrameCountingMemoryAllocationSettingContext : public FakeWebGraphicsContext3D {
+class FrameCountingMemoryAllocationSettingContext : public TestWebGraphicsContext3D {
 public:
     FrameCountingMemoryAllocationSettingContext() : m_frame(0) { }
 
     // WebGraphicsContext3D methods.
 
     // This method would normally do a glSwapBuffers under the hood.
     virtual void prepareTexture() { m_frame++; }
     virtual void setMemoryAllocationChangedCallbackCHROMIUM(WebGraphicsMemoryAllocationChangedCallbackCHROMIUM* callback) { m_memoryAllocationChangedCallback = callback; }
     virtual WebString getString(WebKit::WGC3Denum name)
     {
@@ skipping 186 matching lines @@
 
     char pixels[4];
     m_renderer.drawFrame(m_mockClient.renderPassesInDrawOrder());
     EXPECT_FALSE(m_renderer.isBackbufferDiscarded());
 
     m_renderer.getFramebufferPixels(pixels, gfx::Rect(0, 0, 1, 1));
     EXPECT_TRUE(m_renderer.isBackbufferDiscarded());
     EXPECT_EQ(2, m_mockClient.setFullRootLayerDamageCount());
 }
 
-class ForbidSynchronousCallContext : public FakeWebGraphicsContext3D {
+class ForbidSynchronousCallContext : public TestWebGraphicsContext3D {
 public:
     ForbidSynchronousCallContext() { }
 
     virtual bool getActiveAttrib(WebGLId program, WGC3Duint index, ActiveInfo&) { ADD_FAILURE(); return false; }
     virtual bool getActiveUniform(WebGLId program, WGC3Duint index, ActiveInfo&) { ADD_FAILURE(); return false; }
     virtual void getAttachedShaders(WebGLId program, WGC3Dsizei maxCount, WGC3Dsizei* count, WebGLId* shaders) { ADD_FAILURE(); }
     virtual WGC3Dint getAttribLocation(WebGLId program, const WGC3Dchar* name) { ADD_FAILURE(); return 0; }
     virtual void getBooleanv(WGC3Denum pname, WGC3Dboolean* value) { ADD_FAILURE(); }
     virtual void getBufferParameteriv(WGC3Denum target, WGC3Denum pname, WGC3Dint* value) { ADD_FAILURE(); }
     virtual Attributes getContextAttributes() { ADD_FAILURE(); return attributes_; }
@@ skipping 56 matching lines @@
 TEST(GLRendererTest2, initializationDoesNotMakeSynchronousCalls)
 {
     FakeRendererClient mockClient;
     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 {
+class LoseContextOnFirstGetContext : public TestWebGraphicsContext3D {
 public:
     LoseContextOnFirstGetContext()
         : m_contextLost(false)
     {
     }
 
     virtual bool makeContextCurrent() OVERRIDE
     {
         return !m_contextLost;
     }
@@ skipping 22 matching lines @@
 TEST(GLRendererTest2, initializationWithQuicklyLostContextDoesNotAssert)
 {
     FakeRendererClient mockClient;
     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 {
+class ContextThatDoesNotSupportMemoryManagmentExtensions : public TestWebGraphicsContext3D {
 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, outputSurface.get(), resourceProvider.get());
 
     renderer.initialize();
 
     EXPECT_GT(mockClient.memoryAllocationLimitBytes(), 0ul);
 }
 
-class ClearCountingContext : public FakeWebGraphicsContext3D {
+class ClearCountingContext : public TestWebGraphicsContext3D {
 public:
     ClearCountingContext() : m_clear(0) { }
 
     virtual void clear(WGC3Dbitfield)
     {
         m_clear++;
     }
 
     int clearCount() const { return m_clear; }
 
@@ skipping 34 matching lines @@
 
     mockClient.rootRenderPass()->has_transparent_background = true;
 
     EXPECT_TRUE(renderer.initialize());
 
     renderer.drawFrame(mockClient.renderPassesInDrawOrder());
 
     EXPECT_EQ(1, context->clearCount());
 }
 
-class VisibilityChangeIsLastCallTrackingContext : public FakeWebGraphicsContext3D {
+class VisibilityChangeIsLastCallTrackingContext : public TestWebGraphicsContext3D {
 public:
     VisibilityChangeIsLastCallTrackingContext()
         : m_lastCallWasSetVisibility(0)
     {
     }
 
     // WebGraphicsContext3D methods.
     virtual void setVisibilityCHROMIUM(bool visible) {
         if (!m_lastCallWasSetVisibility)
             return;
@@ skipping 36 matching lines @@
     // 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);
     renderer.setVisible(true);
     renderer.drawFrame(mockClient.renderPassesInDrawOrder());
     renderer.setVisible(false);
     EXPECT_TRUE(lastCallWasSetVisiblity);
 }
 
-class TextureStateTrackingContext : public FakeWebGraphicsContext3D {
+class TextureStateTrackingContext : public TestWebGraphicsContext3D {
 public:
     TextureStateTrackingContext()
         : m_activeTexture(GL_INVALID_ENUM)
     {
     }
 
     virtual WebString getString(WGC3Denum name)
     {
         if (name == GL_EXTENSIONS)
             return WebString("GL_OES_EGL_image_external");
@@ skipping 69 matching lines @@
     renderer.finishDrawingQuadList();
     EXPECT_EQ(context->activeTexture(), GL_TEXTURE0);
     Mock::VerifyAndClearExpectations(context);
 }
 
 class NoClearRootRenderPassFakeClient : public FakeRendererClient {
 public:
     virtual bool shouldClearRootRenderPass() const OVERRIDE { return false; }
 };
 
-class NoClearRootRenderPassMockContext : public FakeWebGraphicsContext3D {
+class NoClearRootRenderPassMockContext : public TestWebGraphicsContext3D {
 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());
@@ skipping 31 matching lines @@
         .Times(AnyNumber())
         .After(firstRenderPass);
 
     renderer.decideRenderPassAllocationsForFrame(mockClient.renderPassesInDrawOrder());
     renderer.drawFrame(mockClient.renderPassesInDrawOrder());
 
     // In multiple render passes all but the root pass should clear the framebuffer.
     Mock::VerifyAndClearExpectations(&mockContext);
 }
 
-class ScissorTestOnClearCheckingContext : public FakeWebGraphicsContext3D {
+class ScissorTestOnClearCheckingContext : public TestWebGraphicsContext3D {
 public:
     ScissorTestOnClearCheckingContext() : m_scissorEnabled(false) { }
 
     virtual void clear(WGC3Dbitfield)
     {
         EXPECT_FALSE(m_scissorEnabled);
     }
 
     virtual void enable(WGC3Denum cap)
     {
@@ skipping 39 matching lines @@
 
     addRenderPassQuad(rootPass, childPass);
     addRenderPassQuad(childPass, grandChildPass);
 
     renderer.decideRenderPassAllocationsForFrame(mockClient.renderPassesInDrawOrder());
     renderer.drawFrame(mockClient.renderPassesInDrawOrder());
 }
 
 }  // namespace
 }  // namespace cc