Standardize usage of virtual/override/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;
+  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;
+  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 20 matching lines @@
 size_t DefaultOverlayProcessor::GetStrategyCount() {
   return strategies_.size();
 }
 
 class OverlayOutputSurface : public OutputSurface {
  public:
   explicit OverlayOutputSurface(scoped_refptr<ContextProvider> context_provider)
       : OutputSurface(context_provider) {}
 
   // OutputSurface implementation
-  virtual void SwapBuffers(CompositorFrame* frame) override;
+  void SwapBuffers(CompositorFrame* frame) override;
 
   void InitWithSingleOverlayValidator() {
     overlay_candidate_validator_.reset(new SingleOverlayValidator);
   }
 };
 
 void OverlayOutputSurface::SwapBuffers(CompositorFrame* frame) {
   client_->DidSwapBuffers();
   client_->DidSwapBuffersComplete();
 }
@@ skipping 444 matching lines @@
     expect_overlays_ = expect_overlays;
   }
 
  private:
   bool expect_overlays_;
 };
 
 class FakeRendererClient : public RendererClient {
  public:
   // RendererClient methods.
-  virtual void SetFullRootLayerDamage() override {}
+  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