Decouple cc::FakeWebGraphicsContext3D from blink::WGC3D

cc/output/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/output/gl_renderer.h"
 
 #include <set>
 
 #include "cc/base/math_util.h"
 #include "cc/output/compositor_frame_metadata.h"
@@ skipping 161 matching lines @@
   using GLRenderer::IsBackbufferDiscarded;
   using GLRenderer::DoDrawQuad;
   using GLRenderer::BeginDrawingFrame;
   using GLRenderer::FinishDrawingQuadList;
   using GLRenderer::stencil_enabled;
 };
 
 class GLRendererWithDefaultHarnessTest : public GLRendererTest {
  protected:
   GLRendererWithDefaultHarnessTest() {
-    output_surface_ = FakeOutputSurface::Create3d(
-        TestWebGraphicsContext3D::Create()).Pass();
+    output_surface_ =
+        FakeOutputSurface::Create3d(TestWebGraphicsContext3D::Create()).Pass();
     CHECK(output_surface_->BindToClient(&output_surface_client_));
 
     resource_provider_ = ResourceProvider::Create(
-        output_surface_.get(), NULL, 0, false, 1).Pass();
+                             output_surface_.get(), NULL, 0, false, 1).Pass();
     renderer_ = make_scoped_ptr(new FakeRendererGL(&renderer_client_,
                                                    &settings_,
                                                    output_surface_.get(),
                                                    resource_provider_.get()));
   }
 
   void SwapBuffers() { renderer_->SwapBuffers(CompositorFrameMetadata()); }
 
   LayerTreeSettings settings_;
   FakeOutputSurfaceClient output_surface_client_;
   scoped_ptr<FakeOutputSurface> output_surface_;
   FakeRendererClient renderer_client_;
   scoped_ptr<ResourceProvider> resource_provider_;
   scoped_ptr<FakeRendererGL> renderer_;
 };
 
 // Closing the namespace here so that GLRendererShaderTest can take advantage
 // of the friend relationship with GLRenderer and all of the mock classes
 // declared above it.
 }  // namespace
 
 class GLRendererShaderTest : public GLRendererTest {
  protected:
   GLRendererShaderTest() {
     output_surface_ = FakeOutputSurface::Create3d().Pass();
     CHECK(output_surface_->BindToClient(&output_surface_client_));
 
     resource_provider_ = ResourceProvider::Create(
-        output_surface_.get(), NULL, 0, false, 1).Pass();
+                             output_surface_.get(), NULL, 0, false, 1).Pass();
     renderer_.reset(new FakeRendererGL(&renderer_client_,
                                        &settings_,
                                        output_surface_.get(),
                                        resource_provider_.get()));
   }
 
   void TestRenderPassProgram(TexCoordPrecision precision) {
     EXPECT_PROGRAM_VALID(&renderer_->render_pass_program_[precision]);
     EXPECT_EQ(renderer_->render_pass_program_[precision].program(),
               renderer_->program_shadow_);
@@ skipping 176 matching lines @@
                        false);
   EXPECT_TRUE(renderer_->stencil_enabled());
 }
 
 class ForbidSynchronousCallContext : public TestWebGraphicsContext3D {
  public:
   ForbidSynchronousCallContext() {}
 
   virtual bool getActiveAttrib(WebGLId program,
                                WGC3Duint index,
-                               ActiveInfo& info) {
+                               blink::WebGraphicsContext3D::ActiveInfo& info)
+      OVERRIDE {
     ADD_FAILURE();
     return false;
   }
   virtual bool getActiveUniform(WebGLId program,
                                 WGC3Duint index,
-                                ActiveInfo& info) {
+                                blink::WebGraphicsContext3D::ActiveInfo& info)
+      OVERRIDE {
     ADD_FAILURE();
     return false;
   }
   virtual void getAttachedShaders(WebGLId program,
                                   WGC3Dsizei max_count,
                                   WGC3Dsizei* count,
-                                  WebGLId* shaders) {
+                                  WebGLId* shaders) OVERRIDE {
     ADD_FAILURE();
   }
-  virtual WGC3Dint getAttribLocation(WebGLId program, const WGC3Dchar* name) {
+  virtual WGC3Dint getAttribLocation(WebGLId program,
+                                     const WGC3Dchar* name) OVERRIDE {
     ADD_FAILURE();
     return 0;
   }
-  virtual void getBooleanv(WGC3Denum pname, WGC3Dboolean* value) {
+  virtual void getBooleanv(WGC3Denum pname, WGC3Dboolean* value) OVERRIDE {
     ADD_FAILURE();
   }
   virtual void getBufferParameteriv(WGC3Denum target,
                                     WGC3Denum pname,
-                                    WGC3Dint* value) {
+                                    WGC3Dint* value) OVERRIDE {
     ADD_FAILURE();
   }
-  virtual Attributes getContextAttributes() {
-    ADD_FAILURE();
-    return attributes_;
-  }
-  virtual WGC3Denum getError() {
+  virtual WGC3Denum getError() OVERRIDE {
     ADD_FAILURE();
     return 0;
   }
-  virtual void getFloatv(WGC3Denum pname, WGC3Dfloat* value) { ADD_FAILURE(); }
+  virtual void getFloatv(WGC3Denum pname, WGC3Dfloat* value) OVERRIDE {
+    ADD_FAILURE();
+  }
   virtual void getFramebufferAttachmentParameteriv(WGC3Denum target,
                                                    WGC3Denum attachment,
                                                    WGC3Denum pname,
-                                                   WGC3Dint* value) {
+                                                   WGC3Dint* value) OVERRIDE {
     ADD_FAILURE();
   }
-  virtual void getIntegerv(WGC3Denum pname, WGC3Dint* value) {
+  virtual void getIntegerv(WGC3Denum pname, WGC3Dint* value) OVERRIDE {
     if (pname == GL_MAX_TEXTURE_SIZE) {
       // MAX_TEXTURE_SIZE is cached client side, so it's OK to query.
       *value = 1024;
     } else {
       ADD_FAILURE();
     }
   }
 
   // We allow querying the shader compilation and program link status in debug
   // mode, but not release.
-  virtual void getProgramiv(WebGLId program, WGC3Denum pname, WGC3Dint* value) {
+  virtual void getProgramiv(WebGLId program,
+                            WGC3Denum pname,
+                            WGC3Dint* value) OVERRIDE {
 #ifndef NDEBUG
     *value = 1;
 #else
     ADD_FAILURE();
 #endif
   }
 
-  virtual void getShaderiv(WebGLId shader, WGC3Denum pname, WGC3Dint* value) {
+  virtual void getShaderiv(WebGLId shader,
+                           WGC3Denum pname,
+                           WGC3Dint* value) OVERRIDE {
 #ifndef NDEBUG
     *value = 1;
 #else
     ADD_FAILURE();
 #endif
   }
 
-  virtual WebString getString(WGC3Denum name) {
+  virtual WebString getString(WGC3Denum name) OVERRIDE {
     ADD_FAILURE() << name;
     return WebString();
   }
 
-  virtual WebString getProgramInfoLog(WebGLId program) {
+  virtual WebString getProgramInfoLog(WebGLId program) OVERRIDE {
     ADD_FAILURE();
     return WebString();
   }
   virtual void getRenderbufferParameteriv(WGC3Denum target,
                                           WGC3Denum pname,
-                                          WGC3Dint* value) {
+                                          WGC3Dint* value) OVERRIDE {
     ADD_FAILURE();
   }
 
-  virtual WebString getShaderInfoLog(WebGLId shader) {
+  virtual WebString getShaderInfoLog(WebGLId shader) OVERRIDE {
     ADD_FAILURE();
     return WebString();
   }
   virtual void getShaderPrecisionFormat(WGC3Denum shadertype,
                                         WGC3Denum precisiontype,
                                         WGC3Dint* range,
-                                        WGC3Dint* precision) {
+                                        WGC3Dint* precision) OVERRIDE {
     ADD_FAILURE();
   }
-  virtual WebString getShaderSource(WebGLId shader) {
+  virtual WebString getShaderSource(WebGLId shader) OVERRIDE {
     ADD_FAILURE();
     return WebString();
   }
   virtual void getTexParameterfv(WGC3Denum target,
                                  WGC3Denum pname,
-                                 WGC3Dfloat* value) {
+                                 WGC3Dfloat* value) OVERRIDE {
     ADD_FAILURE();
   }
   virtual void getTexParameteriv(WGC3Denum target,
                                  WGC3Denum pname,
-                                 WGC3Dint* value) {
+                                 WGC3Dint* value) OVERRIDE {
     ADD_FAILURE();
   }
   virtual void getUniformfv(WebGLId program,
                             WGC3Dint location,
-                            WGC3Dfloat* value) {
+                            WGC3Dfloat* value) OVERRIDE {
     ADD_FAILURE();
   }
   virtual void getUniformiv(WebGLId program,
                             WGC3Dint location,
-                            WGC3Dint* value) {
+                            WGC3Dint* value) OVERRIDE {
     ADD_FAILURE();
   }
-  virtual WGC3Dint getUniformLocation(WebGLId program, const WGC3Dchar* name) {
+  virtual WGC3Dint getUniformLocation(WebGLId program,
+                                      const WGC3Dchar* name) OVERRIDE {
     ADD_FAILURE();
     return 0;
   }
   virtual void getVertexAttribfv(WGC3Duint index,
                                  WGC3Denum pname,
-                                 WGC3Dfloat* value) {
+                                 WGC3Dfloat* value) OVERRIDE {
     ADD_FAILURE();
   }
   virtual void getVertexAttribiv(WGC3Duint index,
                                  WGC3Denum pname,
-                                 WGC3Dint* value) {
+                                 WGC3Dint* value) OVERRIDE {
     ADD_FAILURE();
   }
   virtual WGC3Dsizeiptr getVertexAttribOffset(WGC3Duint index,
-                                              WGC3Denum pname) {
+                                              WGC3Denum pname) OVERRIDE {
     ADD_FAILURE();
     return 0;
   }
 };
-
 TEST_F(GLRendererTest, InitializationDoesNotMakeSynchronousCalls) {
   FakeOutputSurfaceClient output_surface_client;
   scoped_ptr<OutputSurface> output_surface(FakeOutputSurface::Create3d(
       scoped_ptr<TestWebGraphicsContext3D>(new ForbidSynchronousCallContext)));
   CHECK(output_surface->BindToClient(&output_surface_client));
 
   scoped_ptr<ResourceProvider> resource_provider(
       ResourceProvider::Create(output_surface.get(), NULL, 0, false, 1));
 
   LayerTreeSettings settings;
@@ skipping 175 matching lines @@
   Mock::VerifyAndClearExpectations(context);
 }
 
 class VisibilityChangeIsLastCallTrackingContext
     : public TestWebGraphicsContext3D {
  public:
   VisibilityChangeIsLastCallTrackingContext()
       : last_call_was_set_visibility_(false) {}
 
   // WebGraphicsContext3D methods.
-  virtual void flush() {
+  virtual void flush() OVERRIDE { last_call_was_set_visibility_ = false; }
+  virtual void deleteTexture(WebGLId) OVERRIDE {
     last_call_was_set_visibility_ = false;
   }
-  virtual void deleteTexture(WebGLId) {
+  virtual void deleteFramebuffer(WebGLId) OVERRIDE {
     last_call_was_set_visibility_ = false;
   }
-  virtual void deleteFramebuffer(WebGLId) {
+  virtual void deleteQueryEXT(WebGLId) OVERRIDE {
     last_call_was_set_visibility_ = false;
   }
-  virtual void deleteQueryEXT(WebGLId) {
-    last_call_was_set_visibility_ = false;
-  }
-  virtual void deleteRenderbuffer(WebGLId) {
+  virtual void deleteRenderbuffer(WebGLId) OVERRIDE {
     last_call_was_set_visibility_ = false;
   }
 
   // Methods added for test.
   void set_last_call_was_visibility(bool visible) {
     DCHECK(last_call_was_set_visibility_ == false);
     last_call_was_set_visibility_ = true;
   }
   bool last_call_was_set_visibility() const {
     return last_call_was_set_visibility_;
   }
 
  private:
   bool last_call_was_set_visibility_;
 };
 
 TEST_F(GLRendererTest, VisibilityChangeIsLastCall) {
   scoped_ptr<VisibilityChangeIsLastCallTrackingContext> context_owned(
       new VisibilityChangeIsLastCallTrackingContext);
   VisibilityChangeIsLastCallTrackingContext* context = context_owned.get();
 
   scoped_refptr<TestContextProvider> provider = TestContextProvider::Create(
       context_owned.PassAs<TestWebGraphicsContext3D>());
 
   provider->support()->SetSurfaceVisibleCallback(base::Bind(
       &VisibilityChangeIsLastCallTrackingContext::set_last_call_was_visibility,
       base::Unretained(context)));
 
   FakeOutputSurfaceClient output_surface_client;
-  scoped_ptr<OutputSurface> output_surface(FakeOutputSurface::Create3d(
-        provider));
+  scoped_ptr<OutputSurface> output_surface(
+      FakeOutputSurface::Create3d(provider));
   CHECK(output_surface->BindToClient(&output_surface_client));
 
   scoped_ptr<ResourceProvider> resource_provider(
       ResourceProvider::Create(output_surface.get(), NULL, 0, false, 1));
 
   LayerTreeSettings settings;
   FakeRendererClient renderer_client;
   FakeRendererGL renderer(&renderer_client,
                           &settings,
                           output_surface.get(),
@@ skipping 199 matching lines @@
 
   // In multiple render passes all but the root pass should clear the
   // framebuffer.
   Mock::VerifyAndClearExpectations(&mock_context);
 }
 
 class ScissorTestOnClearCheckingContext : public TestWebGraphicsContext3D {
  public:
   ScissorTestOnClearCheckingContext() : scissor_enabled_(false) {}
 
-  virtual void clear(WGC3Dbitfield) { EXPECT_FALSE(scissor_enabled_); }
+  virtual void clear(WGC3Dbitfield) OVERRIDE { EXPECT_FALSE(scissor_enabled_); }
 
-  virtual void enable(WGC3Denum cap) {
+  virtual void enable(WGC3Denum cap) OVERRIDE {
     if (cap == GL_SCISSOR_TEST)
       scissor_enabled_ = true;
   }
 
-  virtual void disable(WGC3Denum cap) {
+  virtual void disable(WGC3Denum cap) OVERRIDE {
     if (cap == GL_SCISSOR_TEST)
       scissor_enabled_ = false;
   }
 
  private:
   bool scissor_enabled_;
 };
 
 TEST_F(GLRendererTest, ScissorTestWhenClearing) {
   scoped_ptr<ScissorTestOnClearCheckingContext> context_owned(
@@ skipping 56 matching lines @@
 
 class DiscardCheckingContext : public TestWebGraphicsContext3D {
  public:
   DiscardCheckingContext() : discarded_(0) {
     set_have_post_sub_buffer(true);
     set_have_discard_framebuffer(true);
   }
 
   virtual void discardFramebufferEXT(WGC3Denum target,
                                      WGC3Dsizei numAttachments,
-                                     const WGC3Denum* attachments) {
+                                     const WGC3Denum* attachments) OVERRIDE {
     ++discarded_;
   }
 
   int discarded() const { return discarded_; }
   void reset() { discarded_ = 0; }
 
  private:
   int discarded_;
 };
 
@@ skipping 193 matching lines @@
 
 class FlippedScissorAndViewportContext : public TestWebGraphicsContext3D {
  public:
   FlippedScissorAndViewportContext()
       : did_call_viewport_(false), did_call_scissor_(false) {}
   virtual ~FlippedScissorAndViewportContext() {
     EXPECT_TRUE(did_call_viewport_);
     EXPECT_TRUE(did_call_scissor_);
   }
 
-  virtual void viewport(GLint x, GLint y, GLsizei width, GLsizei height) {
+  virtual void viewport(GLint x, GLint y, GLsizei width, GLsizei height)
+      OVERRIDE {
     EXPECT_EQ(10, x);
     EXPECT_EQ(390, y);
     EXPECT_EQ(100, width);
     EXPECT_EQ(100, height);
     did_call_viewport_ = true;
   }
 
-  virtual void scissor(GLint x, GLint y, GLsizei width, GLsizei height) {
+  virtual void scissor(GLint x, GLint y, GLsizei width, GLsizei height)
+      OVERRIDE {
     EXPECT_EQ(30, x);
     EXPECT_EQ(450, y);
     EXPECT_EQ(20, width);
     EXPECT_EQ(20, height);
     did_call_scissor_ = true;
   }
 
  private:
   bool did_call_viewport_;
   bool did_call_scissor_;
@@ skipping 364 matching lines @@
                        viewport_rect,
                        viewport_rect,
                        true,
                        false);
 
   TestSolidColorProgramAA();
 }
 
 class OutputSurfaceMockContext : public TestWebGraphicsContext3D {
  public:
-  OutputSurfaceMockContext() {
-    test_capabilities_.post_sub_buffer = true;
-  }
+  OutputSurfaceMockContext() { test_capabilities_.post_sub_buffer = true; }
 
   // Specifically override methods even if they are unused (used in conjunction
   // with StrictMock). We need to make sure that GLRenderer does not issue
   // framebuffer-related GL calls directly. Instead these are supposed to go
   // through the OutputSurface abstraction.
   MOCK_METHOD2(bindFramebuffer, void(WGC3Denum target, WebGLId framebuffer));
   MOCK_METHOD3(reshapeWithScaleFactor,
                void(int width, int height, float scale_factor));
   MOCK_METHOD4(drawElements,
                void(WGC3Denum mode,
@@ skipping 60 matching lines @@
                          NULL,
                          device_scale_factor,
                          device_viewport_rect,
                          device_viewport_rect,
                          true,
                          false);
   }
 
   OutputSurfaceMockContext* Context() {
     return static_cast<OutputSurfaceMockContext*>(
-        output_surface_.context_provider()->Context3d());
+        static_cast<TestContextProvider*>(
+            output_surface_.context_provider().get())->TestContext3d());
   }
 
   LayerTreeSettings settings_;
   FakeOutputSurfaceClient output_surface_client_;
   StrictMock<MockOutputSurface> output_surface_;
   scoped_ptr<ResourceProvider> resource_provider_;
   FakeRendererClient renderer_client_;
   scoped_ptr<FakeRendererGL> renderer_;
 };
 
@@ skipping 99 matching lines @@
   base::MessageLoop::current()->Run();
 
   // The sync point should have happened.
   EXPECT_EQ(1, sync_point_callback_count);
   EXPECT_EQ(1, other_callback_count);
 }
 #endif  // OS_ANDROID
 
 }  // namespace
 }  // namespace cc