Standardize usage of virtual/override/final in cc/

cc/debug/rasterize_and_record_benchmark_impl.cc

 // Copyright 2013 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/debug/rasterize_and_record_benchmark_impl.h"
 
 #include <algorithm>
 #include <limits>
 
 #include "base/basictypes.h"
@@ skipping 19 matching lines @@
                       float contents_scale,
                       size_t repeat_count)
       : picture_pile_(picture_pile),
         content_rect_(content_rect),
         contents_scale_(contents_scale),
         repeat_count_(repeat_count),
         is_solid_color_(false),
         best_time_(base::TimeDelta::Max()) {}
 
   // Overridden from Task:
-  virtual void RunOnWorkerThread() override {
+  void RunOnWorkerThread() override {
     // Parameters for LapTimer.
     const int kTimeLimitMillis = 1;
     const int kWarmupRuns = 0;
     const int kTimeCheckInterval = 1;
 
     for (size_t i = 0; i < repeat_count_; ++i) {
       // Run for a minimum amount of time to avoid problems with timer
       // quantization when the layer is very small.
       LapTimer timer(kWarmupRuns,
                      base::TimeDelta::FromMilliseconds(kTimeLimitMillis),
@@ skipping 18 matching lines @@
           base::TimeDelta::FromMillisecondsD(timer.MsPerLap());
       if (duration < best_time_)
         best_time_ = duration;
     }
   }
 
   bool IsSolidColor() const { return is_solid_color_; }
   base::TimeDelta GetBestTime() const { return best_time_; }
 
  private:
-  virtual ~BenchmarkRasterTask() {}
+  ~BenchmarkRasterTask() override {}
 
   PicturePileImpl* picture_pile_;
   gfx::Rect content_rect_;
   float contents_scale_;
   size_t repeat_count_;
   bool is_solid_color_;
   base::TimeDelta best_time_;
 };
 
 class FixedInvalidationPictureLayerTilingClient
     : public PictureLayerTilingClient {
  public:
   FixedInvalidationPictureLayerTilingClient(
       PictureLayerTilingClient* base_client,
       const Region invalidation)
       : base_client_(base_client), invalidation_(invalidation) {}
 
-  virtual scoped_refptr<Tile> CreateTile(
-      PictureLayerTiling* tiling,
-      const gfx::Rect& content_rect) override {
+  scoped_refptr<Tile> CreateTile(PictureLayerTiling* tiling,
+                                 const gfx::Rect& content_rect) override {
     return base_client_->CreateTile(tiling, content_rect);
   }
 
-  virtual PicturePileImpl* GetPile() override {
-    return base_client_->GetPile();
-  }
+  PicturePileImpl* GetPile() override { return base_client_->GetPile(); }
 
-  virtual gfx::Size CalculateTileSize(
-      const gfx::Size& content_bounds) const override {
+  gfx::Size CalculateTileSize(const gfx::Size& content_bounds) const override {
     return base_client_->CalculateTileSize(content_bounds);
   }
 
   // This is the only function that returns something different from the base
   // client.
-  virtual const Region* GetInvalidation() override { return &invalidation_; }
+  const Region* GetInvalidation() override { return &invalidation_; }
 
-  virtual const PictureLayerTiling* GetTwinTiling(
+  const PictureLayerTiling* GetTwinTiling(
       const PictureLayerTiling* tiling) const override {
     return base_client_->GetTwinTiling(tiling);
   }
 
-  virtual PictureLayerTiling* GetRecycledTwinTiling(
+  PictureLayerTiling* GetRecycledTwinTiling(
       const PictureLayerTiling* tiling) override {
     return base_client_->GetRecycledTwinTiling(tiling);
   }
 
-  virtual size_t GetMaxTilesForInterestArea() const override {
+  size_t GetMaxTilesForInterestArea() const override {
     return base_client_->GetMaxTilesForInterestArea();
   }
 
-  virtual float GetSkewportTargetTimeInSeconds() const override {
+  float GetSkewportTargetTimeInSeconds() const override {
     return base_client_->GetSkewportTargetTimeInSeconds();
   }
 
-  virtual int GetSkewportExtrapolationLimitInContentPixels() const override {
+  int GetSkewportExtrapolationLimitInContentPixels() const override {
     return base_client_->GetSkewportExtrapolationLimitInContentPixels();
   }
 
-  virtual WhichTree GetTree() const override { return base_client_->GetTree(); }
+  WhichTree GetTree() const override { return base_client_->GetTree(); }
 
-  virtual bool RequiresHighResToDraw() const override {
+  bool RequiresHighResToDraw() const override {
     return base_client_->RequiresHighResToDraw();
   }
 
  private:
   PictureLayerTilingClient* base_client_;
   Region invalidation_;
 };
 
 }  // namespace
 
@@ skipping 120 matching lines @@
       pixels_rasterized_with_non_solid_color(0),
       pixels_rasterized_as_opaque(0),
       total_layers(0),
       total_picture_layers(0),
       total_picture_layers_with_no_content(0),
       total_picture_layers_off_screen(0) {}
 
 RasterizeAndRecordBenchmarkImpl::RasterizeResults::~RasterizeResults() {}
 
 }  // namespace cc