Standardize usage of virtual/override/final in ui/

ui/gfx/image/image_skia_unittest.cc

 // Copyright (c) 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 "ui/gfx/image/image_skia.h"
 
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/threading/simple_thread.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 12 matching lines @@
 #endif
 
 namespace gfx {
 
 namespace {
 
 class FixedSource : public ImageSkiaSource {
  public:
   explicit FixedSource(const ImageSkiaRep& image) : image_(image) {}
 
-  virtual ~FixedSource() {
-  }
+  ~FixedSource() override {}
 
-  virtual ImageSkiaRep GetImageForScale(float scale) override {
-    return image_;
-  }
+  ImageSkiaRep GetImageForScale(float scale) override { return image_; }
 
  private:
   ImageSkiaRep image_;
 
   DISALLOW_COPY_AND_ASSIGN(FixedSource);
 };
 
 class FixedScaleSource : public ImageSkiaSource {
  public:
   explicit FixedScaleSource(const ImageSkiaRep& image) : image_(image) {}
 
-  virtual ~FixedScaleSource() {
-  }
+  ~FixedScaleSource() override {}
 
-  virtual ImageSkiaRep GetImageForScale(float scale) override {
+  ImageSkiaRep GetImageForScale(float scale) override {
     if (!image_.unscaled() && image_.scale() != scale)
       return ImageSkiaRep();
     return image_;
   }
 
  private:
   ImageSkiaRep image_;
 
   DISALLOW_COPY_AND_ASSIGN(FixedScaleSource);
 };
 
 class DynamicSource : public ImageSkiaSource {
  public:
   explicit DynamicSource(const gfx::Size& size)
       : size_(size),
         last_requested_scale_(0.0f) {}
 
-  virtual ~DynamicSource() {
-  }
+  ~DynamicSource() override {}
 
-  virtual ImageSkiaRep GetImageForScale(float scale) override {
+  ImageSkiaRep GetImageForScale(float scale) override {
     last_requested_scale_ = scale;
     return gfx::ImageSkiaRep(size_, scale);
   }
 
   float GetLastRequestedScaleAndReset() {
     float result = last_requested_scale_;
     last_requested_scale_ = 0.0f;
     return result;
   }
 
  private:
   gfx::Size size_;
   float last_requested_scale_;
 
   DISALLOW_COPY_AND_ASSIGN(DynamicSource);
 };
 
 class NullSource: public ImageSkiaSource {
  public:
   NullSource() {
   }
 
-  virtual ~NullSource() {
-  }
+  ~NullSource() override {}
 
-  virtual ImageSkiaRep GetImageForScale(float scale) override {
+  ImageSkiaRep GetImageForScale(float scale) override {
     return gfx::ImageSkiaRep();
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(NullSource);
 };
 
 }  // namespace
 
 namespace test {
 class TestOnThread : public base::SimpleThread {
  public:
   explicit TestOnThread(ImageSkia* image_skia)
       : SimpleThread("image_skia_on_thread"),
         image_skia_(image_skia),
         can_read_(false),
         can_modify_(false) {
   }
 
-  virtual void Run() override {
+  void Run() override {
     can_read_ = image_skia_->CanRead();
     can_modify_ = image_skia_->CanModify();
     if (can_read_)
       image_skia_->image_reps();
   }
 
   void StartAndJoin() {
     Start();
     Join();
   }
@@ skipping 487 matching lines @@
   EXPECT_EQ(1U, image.image_reps().size());
 
   const ImageSkiaRep& rep12 = image.GetRepresentation(1.2f);
   EXPECT_EQ(1.0f, rep12.scale());
   EXPECT_EQ("100x200", rep12.pixel_size().ToString());
   EXPECT_TRUE(rep12.unscaled());
   EXPECT_EQ(1U, image.image_reps().size());
 }
 
 }  // namespace gfx