replace OVERRIDE and FINAL with override and final in cc/

cc/output/overlay_unittest.cc

 // Copyright 2014 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/base/scoped_ptr_vector.h"
 #include "cc/output/gl_renderer.h"
 #include "cc/output/output_surface.h"
 #include "cc/output/output_surface_client.h"
 #include "cc/output/overlay_candidate_validator.h"
 #include "cc/output/overlay_processor.h"
@@ skipping 22 matching lines @@
 const gfx::PointF kUVTopLeft(0.1f, 0.2f);
 const gfx::PointF kUVBottomRight(1.0f, 1.0f);
 
 void MailboxReleased(unsigned sync_point,
                      bool lost_resource,
                      BlockingTaskRunner* main_thread_task_runner) {
 }
 
 class SingleOverlayValidator : public OverlayCandidateValidator {
  public:
-  virtual void CheckOverlaySupport(OverlayCandidateList* surfaces) OVERRIDE;
+  virtual void CheckOverlaySupport(OverlayCandidateList* surfaces) override;
 };
 
 void SingleOverlayValidator::CheckOverlaySupport(
     OverlayCandidateList* surfaces) {
   ASSERT_EQ(2U, surfaces->size());
 
   OverlayCandidate& candidate = surfaces->back();
   if (candidate.display_rect.width() == 64)
     EXPECT_EQ(kOverlayBottomRightRect, candidate.display_rect);
   else
     EXPECT_EQ(kOverlayRect, candidate.display_rect);
   EXPECT_EQ(BoundingRect(kUVTopLeft, kUVBottomRight).ToString(),
             candidate.uv_rect.ToString());
   candidate.overlay_handled = true;
 }
 
 class SingleOverlayProcessor : public OverlayProcessor {
  public:
   SingleOverlayProcessor(OutputSurface* surface,
                          ResourceProvider* resource_provider);
   // Virtual to allow testing different strategies.
-  virtual void Initialize() OVERRIDE;
+  virtual void Initialize() override;
 };
 
 SingleOverlayProcessor::SingleOverlayProcessor(
     OutputSurface* surface,
     ResourceProvider* resource_provider)
     : OverlayProcessor(surface, resource_provider) {
   EXPECT_EQ(surface, surface_);
   EXPECT_EQ(resource_provider, resource_provider_);
 }
 
@@ skipping 446 matching lines @@
       : GLRenderer(client,
                    settings,
                    output_surface,
                    resource_provider,
                    NULL,
                    0),
         expect_overlays_(false) {}
 
   MOCK_METHOD2(DoDrawQuad, void(DrawingFrame* frame, const DrawQuad* quad));
 
-  virtual void FinishDrawingFrame(DrawingFrame* frame) OVERRIDE {
+  virtual void FinishDrawingFrame(DrawingFrame* frame) override {
     GLRenderer::FinishDrawingFrame(frame);
 
     if (!expect_overlays_) {
       EXPECT_EQ(0U, frame->overlay_list.size());
       return;
     }
 
     ASSERT_EQ(2U, frame->overlay_list.size());
     EXPECT_NE(0U, frame->overlay_list.back().resource_id);
   }
 
   void set_expect_overlays(bool expect_overlays) {
     expect_overlays_ = expect_overlays;
   }
 
  private:
   bool expect_overlays_;
 };
 
 class FakeRendererClient : public RendererClient {
  public:
   // RendererClient methods.
-  virtual void SetFullRootLayerDamage() OVERRIDE {}
+  virtual void SetFullRootLayerDamage() override {}
 };
 
 class MockOverlayScheduler {
  public:
   MOCK_METHOD5(Schedule,
                void(int plane_z_order,
                     gfx::OverlayTransform plane_transform,
                     unsigned overlay_texture_id,
                     const gfx::Rect& display_bounds,
                     const gfx::RectF& uv_rect));
@@ skipping 215 matching lines @@
   renderer_->set_expect_overlays(false);
   renderer_->FinishDrawingFrame(&frame3);
   EXPECT_TRUE(resource_provider_->InUseByConsumer(resource1));
   SwapBuffers();
   EXPECT_FALSE(resource_provider_->InUseByConsumer(resource1));
   Mock::VerifyAndClearExpectations(&scheduler_);
 }
 
 }  // namespace
 }  // namespace cc