Standardize usage of virtual/override/final in cc/

cc/layers/tiled_layer_unittest.cc

 // Copyright 2011 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/layers/tiled_layer.h"
 
 #include <limits>
 #include <vector>
 
 #include "base/run_loop.h"
@@ skipping 39 matching lines @@
  public:
   static scoped_ptr<SynchronousOutputSurfaceLayerTreeHost> Create(
       LayerTreeHostClient* client,
       SharedBitmapManager* manager,
       const LayerTreeSettings& settings,
       scoped_refptr<base::SingleThreadTaskRunner> impl_task_runner) {
     return make_scoped_ptr(new SynchronousOutputSurfaceLayerTreeHost(
         client, manager, settings, impl_task_runner));
   }
 
-  virtual ~SynchronousOutputSurfaceLayerTreeHost() {}
+  ~SynchronousOutputSurfaceLayerTreeHost() override {}
 
   bool EnsureOutputSurfaceCreated() {
     base::MessageLoop::current()->PostDelayedTask(
         FROM_HERE,
         run_loop_.QuitClosure(),
         base::TimeDelta::FromSeconds(5));
     run_loop_.Run();
     return output_surface_created_;
   }
 
-  virtual void OnCreateAndInitializeOutputSurfaceAttempted(
-      bool success) override {
+  void OnCreateAndInitializeOutputSurfaceAttempted(bool success) override {
     LayerTreeHost::OnCreateAndInitializeOutputSurfaceAttempted(success);
     output_surface_created_ = success;
     run_loop_.Quit();
   }
 
  private:
   SynchronousOutputSurfaceLayerTreeHost(
       LayerTreeHostClient* client,
       SharedBitmapManager* manager,
       const LayerTreeSettings& settings,
@@ skipping 1559 matching lines @@
                                 resource_provider_.get());
   layer_tree_host_->SetRootLayer(nullptr);
 }
 
 class TrackingLayerPainter : public LayerPainter {
  public:
   static scoped_ptr<TrackingLayerPainter> Create() {
     return make_scoped_ptr(new TrackingLayerPainter());
   }
 
-  virtual void Paint(SkCanvas* canvas, const gfx::Rect& content_rect) override {
+  void Paint(SkCanvas* canvas, const gfx::Rect& content_rect) override {
     painted_rect_ = content_rect;
   }
 
   gfx::Rect PaintedRect() const { return painted_rect_; }
   void ResetPaintedRect() { painted_rect_ = gfx::Rect(); }
 
  private:
   gfx::Rect painted_rect_;
 };
 
 class UpdateTrackingTiledLayer : public FakeTiledLayer {
  public:
   explicit UpdateTrackingTiledLayer(PrioritizedResourceManager* manager)
       : FakeTiledLayer(manager) {
     scoped_ptr<TrackingLayerPainter> painter(TrackingLayerPainter::Create());
     tracking_layer_painter_ = painter.get();
     layer_updater_ = BitmapContentLayerUpdater::Create(
         painter.Pass(), &stats_instrumentation_, 0);
   }
 
   TrackingLayerPainter* tracking_layer_painter() const {
     return tracking_layer_painter_;
   }
 
  private:
-  virtual LayerUpdater* Updater() const override {
-    return layer_updater_.get();
-  }
-  virtual ~UpdateTrackingTiledLayer() {}
+  LayerUpdater* Updater() const override { return layer_updater_.get(); }
+  ~UpdateTrackingTiledLayer() override {}
 
   TrackingLayerPainter* tracking_layer_painter_;
   scoped_refptr<BitmapContentLayerUpdater> layer_updater_;
   FakeRenderingStatsInstrumentation stats_instrumentation_;
 };
 
 TEST_F(TiledLayerTest, NonIntegerContentsScaleIsNotDistortedDuringPaint) {
   scoped_refptr<UpdateTrackingTiledLayer> layer =
       make_scoped_refptr(new UpdateTrackingTiledLayer(resource_manager_.get()));
 
@@ skipping 66 matching lines @@
 
   // Rounding leads to an extra pixel.
   gfx::Rect expanded_layer_rect(layer_rect);
   expanded_layer_rect.set_height(32);
   EXPECT_RECT_EQ(expanded_layer_rect,
                  layer->tracking_layer_painter()->PaintedRect());
 }
 
 }  // namespace
 }  // namespace cc