replace OVERRIDE and FINAL with override and 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 345 matching lines @@
   EXPECT_TRUE(renderer_->stencil_enabled());
 }
 
 class ForbidSynchronousCallContext : public TestWebGraphicsContext3D {
  public:
   ForbidSynchronousCallContext() {}
 
   virtual void getAttachedShaders(GLuint program,
                                   GLsizei max_count,
                                   GLsizei* count,
-                                  GLuint* shaders) OVERRIDE {
+                                  GLuint* shaders) override {
     ADD_FAILURE();
   }
-  virtual GLint getAttribLocation(GLuint program, const GLchar* name) OVERRIDE {
+  virtual GLint getAttribLocation(GLuint program, const GLchar* name) override {
     ADD_FAILURE();
     return 0;
   }
-  virtual void getBooleanv(GLenum pname, GLboolean* value) OVERRIDE {
+  virtual void getBooleanv(GLenum pname, GLboolean* value) override {
     ADD_FAILURE();
   }
   virtual void getBufferParameteriv(GLenum target,
                                     GLenum pname,
-                                    GLint* value) OVERRIDE {
+                                    GLint* value) override {
     ADD_FAILURE();
   }
-  virtual GLenum getError() OVERRIDE {
+  virtual GLenum getError() override {
     ADD_FAILURE();
     return GL_NO_ERROR;
   }
-  virtual void getFloatv(GLenum pname, GLfloat* value) OVERRIDE {
+  virtual void getFloatv(GLenum pname, GLfloat* value) override {
     ADD_FAILURE();
   }
   virtual void getFramebufferAttachmentParameteriv(GLenum target,
                                                    GLenum attachment,
                                                    GLenum pname,
-                                                   GLint* value) OVERRIDE {
+                                                   GLint* value) override {
     ADD_FAILURE();
   }
-  virtual void getIntegerv(GLenum pname, GLint* value) OVERRIDE {
+  virtual 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 {
+                            GLint* value) override {
 #ifndef NDEBUG
     *value = 1;
 #else
     ADD_FAILURE();
 #endif
   }
 
-  virtual void getShaderiv(GLuint shader, GLenum pname, GLint* value) OVERRIDE {
+  virtual 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 {
+                                          GLint* value) override {
     ADD_FAILURE();
   }
 
   virtual void getShaderPrecisionFormat(GLenum shadertype,
                                         GLenum precisiontype,
                                         GLint* range,
-                                        GLint* precision) OVERRIDE {
+                                        GLint* precision) override {
     ADD_FAILURE();
   }
   virtual void getTexParameterfv(GLenum target,
                                  GLenum pname,
-                                 GLfloat* value) OVERRIDE {
+                                 GLfloat* value) override {
     ADD_FAILURE();
   }
   virtual void getTexParameteriv(GLenum target,
                                  GLenum pname,
-                                 GLint* value) OVERRIDE {
+                                 GLint* value) override {
     ADD_FAILURE();
   }
   virtual void getUniformfv(GLuint program,
                             GLint location,
-                            GLfloat* value) OVERRIDE {
+                            GLfloat* value) override {
     ADD_FAILURE();
   }
   virtual void getUniformiv(GLuint program,
                             GLint location,
-                            GLint* value) OVERRIDE {
+                            GLint* value) override {
     ADD_FAILURE();
   }
   virtual GLint getUniformLocation(GLuint program,
-                                   const GLchar* name) OVERRIDE {
+                                   const GLchar* name) override {
     ADD_FAILURE();
     return 0;
   }
   virtual void getVertexAttribfv(GLuint index,
                                  GLenum pname,
-                                 GLfloat* value) OVERRIDE {
+                                 GLfloat* value) override {
     ADD_FAILURE();
   }
   virtual void getVertexAttribiv(GLuint index,
                                  GLenum pname,
-                                 GLint* value) OVERRIDE {
+                                 GLint* value) override {
     ADD_FAILURE();
   }
   virtual GLsizeiptr getVertexAttribOffset(GLuint index,
-                                           GLenum pname) OVERRIDE {
+                                           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 15 matching lines @@
                           output_surface.get(),
                           resource_provider.get());
 }
 
 class LoseContextOnFirstGetContext : public TestWebGraphicsContext3D {
  public:
   LoseContextOnFirstGetContext() {}
 
   virtual void getProgramiv(GLuint program,
                             GLenum pname,
-                            GLint* value) OVERRIDE {
+                            GLint* value) override {
     context_lost_ = true;
     *value = 0;
   }
 
-  virtual void getShaderiv(GLuint shader, GLenum pname, GLint* value) OVERRIDE {
+  virtual 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 170 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 {
+  virtual void flush() override { last_call_was_set_visibility_ = false; }
+  virtual void deleteTexture(GLuint) override {
     last_call_was_set_visibility_ = false;
   }
-  virtual void deleteFramebuffer(GLuint) OVERRIDE {
+  virtual void deleteFramebuffer(GLuint) override {
     last_call_was_set_visibility_ = false;
   }
-  virtual void deleteQueryEXT(GLuint) OVERRIDE {
+  virtual void deleteQueryEXT(GLuint) override {
     last_call_was_set_visibility_ = false;
   }
-  virtual void deleteRenderbuffer(GLuint) OVERRIDE {
+  virtual 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 248 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_); }
+  virtual void clear(GLbitfield) override { EXPECT_FALSE(scissor_enabled_); }
 
-  virtual void enable(GLenum cap) OVERRIDE {
+  virtual void enable(GLenum cap) override {
     if (cap == GL_SCISSOR_TEST)
       scissor_enabled_ = true;
   }
 
-  virtual void disable(GLenum cap) OVERRIDE {
+  virtual 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 62 matching lines @@
 
 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 {
+                                     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 {}
+  virtual 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 149 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)
-      OVERRIDE {
+      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 {
+      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 555 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