Standardize usage of virtual/override/final in cc/

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 344 matching lines @@
                        viewport_rect,
                        viewport_rect,
                        false);
   EXPECT_TRUE(renderer_->stencil_enabled());
 }
 
 class ForbidSynchronousCallContext : public TestWebGraphicsContext3D {
  public:
   ForbidSynchronousCallContext() {}
 
-  virtual void getAttachedShaders(GLuint program,
-                                  GLsizei max_count,
-                                  GLsizei* count,
-                                  GLuint* shaders) override {
+  void getAttachedShaders(GLuint program,
+                          GLsizei max_count,
+                          GLsizei* count,
+                          GLuint* shaders) override {
     ADD_FAILURE();
   }
-  virtual GLint getAttribLocation(GLuint program, const GLchar* name) override {
+  GLint getAttribLocation(GLuint program, const GLchar* name) override {
     ADD_FAILURE();
     return 0;
   }
-  virtual void getBooleanv(GLenum pname, GLboolean* value) override {
+  void getBooleanv(GLenum pname, GLboolean* value) override { ADD_FAILURE(); }
+  void getBufferParameteriv(GLenum target,
+                            GLenum pname,
+                            GLint* value) override {
     ADD_FAILURE();
   }
-  virtual void getBufferParameteriv(GLenum target,
-                                    GLenum pname,
-                                    GLint* value) override {
-    ADD_FAILURE();
-  }
-  virtual GLenum getError() override {
+  GLenum getError() override {
     ADD_FAILURE();
     return GL_NO_ERROR;
   }
-  virtual void getFloatv(GLenum pname, GLfloat* value) override {
+  void getFloatv(GLenum pname, GLfloat* value) override { ADD_FAILURE(); }
+  void getFramebufferAttachmentParameteriv(GLenum target,
+                                           GLenum attachment,
+                                           GLenum pname,
+                                           GLint* value) override {
     ADD_FAILURE();
   }
-  virtual void getFramebufferAttachmentParameteriv(GLenum target,
-                                                   GLenum attachment,
-                                                   GLenum pname,
-                                                   GLint* value) override {
-    ADD_FAILURE();
-  }
-  virtual void getIntegerv(GLenum pname, GLint* value) override {
+  void getIntegerv(GLenum pname, GLint* 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(GLuint program,
-                            GLenum pname,
-                            GLint* value) override {
+  void getProgramiv(GLuint program, GLenum pname, GLint* value) override {
 #ifndef NDEBUG
     *value = 1;
 #else
     ADD_FAILURE();
 #endif
   }
 
-  virtual void getShaderiv(GLuint shader, GLenum pname, GLint* value) override {
+  void getShaderiv(GLuint shader, GLenum pname, GLint* value) override {
 #ifndef NDEBUG
     *value = 1;
 #else
     ADD_FAILURE();
 #endif
   }
 
-  virtual void getRenderbufferParameteriv(GLenum target,
-                                          GLenum pname,
-                                          GLint* value) override {
+  void getRenderbufferParameteriv(GLenum target,
+                                  GLenum pname,
+                                  GLint* value) override {
     ADD_FAILURE();
   }
 
-  virtual void getShaderPrecisionFormat(GLenum shadertype,
-                                        GLenum precisiontype,
-                                        GLint* range,
-                                        GLint* precision) override {
+  void getShaderPrecisionFormat(GLenum shadertype,
+                                GLenum precisiontype,
+                                GLint* range,
+                                GLint* precision) override {
     ADD_FAILURE();
   }
-  virtual void getTexParameterfv(GLenum target,
-                                 GLenum pname,
-                                 GLfloat* value) override {
+  void getTexParameterfv(GLenum target, GLenum pname, GLfloat* value) override {
     ADD_FAILURE();
   }
-  virtual void getTexParameteriv(GLenum target,
-                                 GLenum pname,
-                                 GLint* value) override {
+  void getTexParameteriv(GLenum target, GLenum pname, GLint* value) override {
     ADD_FAILURE();
   }
-  virtual void getUniformfv(GLuint program,
-                            GLint location,
-                            GLfloat* value) override {
+  void getUniformfv(GLuint program, GLint location, GLfloat* value) override {
     ADD_FAILURE();
   }
-  virtual void getUniformiv(GLuint program,
-                            GLint location,
-                            GLint* value) override {
+  void getUniformiv(GLuint program, GLint location, GLint* value) override {
     ADD_FAILURE();
   }
-  virtual GLint getUniformLocation(GLuint program,
-                                   const GLchar* name) override {
+  GLint getUniformLocation(GLuint program, const GLchar* name) override {
     ADD_FAILURE();
     return 0;
   }
-  virtual void getVertexAttribfv(GLuint index,
-                                 GLenum pname,
-                                 GLfloat* value) override {
+  void getVertexAttribfv(GLuint index, GLenum pname, GLfloat* value) override {
     ADD_FAILURE();
   }
-  virtual void getVertexAttribiv(GLuint index,
-                                 GLenum pname,
-                                 GLint* value) override {
+  void getVertexAttribiv(GLuint index, GLenum pname, GLint* value) override {
     ADD_FAILURE();
   }
-  virtual GLsizeiptr getVertexAttribOffset(GLuint index,
-                                           GLenum pname) override {
+  GLsizeiptr getVertexAttribOffset(GLuint index, GLenum 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));
 
@@ skipping 14 matching lines @@
   FakeRendererGL renderer(&renderer_client,
                           &settings,
                           output_surface.get(),
                           resource_provider.get());
 }
 
 class LoseContextOnFirstGetContext : public TestWebGraphicsContext3D {
  public:
   LoseContextOnFirstGetContext() {}
 
-  virtual void getProgramiv(GLuint program,
-                            GLenum pname,
-                            GLint* value) override {
+  void getProgramiv(GLuint program, GLenum pname, GLint* value) override {
     context_lost_ = true;
     *value = 0;
   }
 
-  virtual void getShaderiv(GLuint shader, GLenum pname, GLint* value) override {
+  void getShaderiv(GLuint shader, GLenum pname, GLint* value) override {
     context_lost_ = true;
     *value = 0;
   }
 };
 
 TEST_F(GLRendererTest, InitializationWithQuicklyLostContextDoesNotAssert) {
   FakeOutputSurfaceClient output_surface_client;
   scoped_ptr<OutputSurface> output_surface(FakeOutputSurface::Create3d(
       scoped_ptr<TestWebGraphicsContext3D>(new LoseContextOnFirstGetContext)));
   CHECK(output_surface->BindToClient(&output_surface_client));
@@ skipping 174 matching lines @@
   Mock::VerifyAndClearExpectations(context);
 }
 
 class VisibilityChangeIsLastCallTrackingContext
     : public TestWebGraphicsContext3D {
  public:
   VisibilityChangeIsLastCallTrackingContext()
       : last_call_was_set_visibility_(false) {}
 
   // TestWebGraphicsContext3D methods.
-  virtual void flush() override { last_call_was_set_visibility_ = false; }
-  virtual void deleteTexture(GLuint) override {
+  void flush() override { last_call_was_set_visibility_ = false; }
+  void deleteTexture(GLuint) override { last_call_was_set_visibility_ = false; }
+  void deleteFramebuffer(GLuint) override {
     last_call_was_set_visibility_ = false;
   }
-  virtual void deleteFramebuffer(GLuint) override {
+  void deleteQueryEXT(GLuint) override {
     last_call_was_set_visibility_ = false;
   }
-  virtual void deleteQueryEXT(GLuint) override {
-    last_call_was_set_visibility_ = false;
-  }
-  virtual void deleteRenderbuffer(GLuint) override {
+  void deleteRenderbuffer(GLuint) 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_;
@@ skipping 251 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(GLbitfield) override { EXPECT_FALSE(scissor_enabled_); }
+  void clear(GLbitfield) override { EXPECT_FALSE(scissor_enabled_); }
 
-  virtual void enable(GLenum cap) override {
+  void enable(GLenum cap) override {
     if (cap == GL_SCISSOR_TEST)
       scissor_enabled_ = true;
   }
 
-  virtual void disable(GLenum cap) override {
+  void disable(GLenum cap) override {
     if (cap == GL_SCISSOR_TEST)
       scissor_enabled_ = false;
   }
 
  private:
   bool scissor_enabled_;
 };
 
 TEST_F(GLRendererTest, ScissorTestWhenClearing) {
   scoped_ptr<ScissorTestOnClearCheckingContext> context_owned(
@@ skipping 61 matching lines @@
                      false);
 }
 
 class DiscardCheckingContext : public TestWebGraphicsContext3D {
  public:
   DiscardCheckingContext() : discarded_(0) {
     set_have_post_sub_buffer(true);
     set_have_discard_framebuffer(true);
   }
 
-  virtual void discardFramebufferEXT(GLenum target,
-                                     GLsizei numAttachments,
-                                     const GLenum* attachments) override {
+  void discardFramebufferEXT(GLenum target,
+                             GLsizei numAttachments,
+                             const GLenum* attachments) override {
     ++discarded_;
   }
 
   int discarded() const { return discarded_; }
   void reset() { discarded_ = 0; }
 
  private:
   int discarded_;
 };
 
 class NonReshapableOutputSurface : public FakeOutputSurface {
  public:
   explicit NonReshapableOutputSurface(
       scoped_ptr<TestWebGraphicsContext3D> context3d)
       : FakeOutputSurface(TestContextProvider::Create(context3d.Pass()),
                           false) {
     surface_size_ = gfx::Size(500, 500);
   }
-  virtual void Reshape(const gfx::Size& size, float scale_factor) override {}
+  void Reshape(const gfx::Size& size, float scale_factor) override {}
   void set_fixed_size(const gfx::Size& size) { surface_size_ = size; }
 };
 
 TEST_F(GLRendererTest, NoDiscardOnPartialUpdates) {
   scoped_ptr<DiscardCheckingContext> context_owned(new DiscardCheckingContext);
   DiscardCheckingContext* context = context_owned.get();
 
   FakeOutputSurfaceClient output_surface_client;
   scoped_ptr<NonReshapableOutputSurface> output_surface(
       new NonReshapableOutputSurface(context_owned.Pass()));
@@ skipping 144 matching lines @@
                        false);
     EXPECT_EQ(0, context->discarded());
     context->reset();
   }
 }
 
 class FlippedScissorAndViewportContext : public TestWebGraphicsContext3D {
  public:
   FlippedScissorAndViewportContext()
       : did_call_viewport_(false), did_call_scissor_(false) {}
-  virtual ~FlippedScissorAndViewportContext() {
+  ~FlippedScissorAndViewportContext() override {
     EXPECT_TRUE(did_call_viewport_);
     EXPECT_TRUE(did_call_scissor_);
   }
 
-  virtual void viewport(GLint x, GLint y, GLsizei width, GLsizei height)
-      override {
+  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)
-      override {
+  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 557 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