replace OVERRIDE and FINAL with override and final in ui/

ui/compositor/layer_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 "base/basictypes.h"
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/debug/trace_event.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
@@ skipping 44 matching lines @@
  public:
   explicit ColoredLayer(SkColor color)
       : Layer(LAYER_TEXTURED),
         color_(color) {
     set_delegate(this);
   }
 
   virtual ~ColoredLayer() { }
 
   // Overridden from LayerDelegate:
-  virtual void OnPaintLayer(gfx::Canvas* canvas) OVERRIDE {
+  virtual void OnPaintLayer(gfx::Canvas* canvas) override {
     canvas->DrawColor(color_);
   }
 
   virtual void OnDelegatedFrameDamage(
-      const gfx::Rect& damage_rect_in_dip) OVERRIDE {}
+      const gfx::Rect& damage_rect_in_dip) override {}
 
-  virtual void OnDeviceScaleFactorChanged(float device_scale_factor) OVERRIDE {
+  virtual void OnDeviceScaleFactorChanged(float device_scale_factor) override {
   }
 
-  virtual base::Closure PrepareForLayerBoundsChange() OVERRIDE {
+  virtual base::Closure PrepareForLayerBoundsChange() override {
     return base::Closure();
   }
 
  private:
   SkColor color_;
 };
 
 class LayerWithRealCompositorTest : public testing::Test {
  public:
   LayerWithRealCompositorTest() {
     if (PathService::Get(gfx::DIR_TEST_DATA, &test_data_directory_)) {
       test_data_directory_ = test_data_directory_.AppendASCII("compositor");
     } else {
       LOG(ERROR) << "Could not open test data directory.";
     }
   }
   virtual ~LayerWithRealCompositorTest() {}
 
   // Overridden from testing::Test:
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     bool enable_pixel_output = true;
     ui::ContextFactory* context_factory =
         InitializeContextFactoryForTests(enable_pixel_output);
 
     const gfx::Rect host_bounds(10, 10, 500, 500);
     compositor_host_.reset(
         TestCompositorHost::Create(host_bounds, context_factory));
     compositor_host_->Show();
   }
 
-  virtual void TearDown() OVERRIDE {
+  virtual void TearDown() override {
     compositor_host_.reset();
     TerminateContextFactoryForTests();
   }
 
   Compositor* GetCompositor() { return compositor_host_->GetCompositor(); }
 
   Layer* CreateLayer(LayerType type) {
     return new Layer(type);
   }
 
@@ skipping 110 matching lines @@
 
   std::string ToScaleString() const {
     return base::StringPrintf("%.1f %.1f", scale_x_, scale_y_);
   }
 
   float device_scale_factor() const {
     return device_scale_factor_;
   }
 
   // Overridden from LayerDelegate:
-  virtual void OnPaintLayer(gfx::Canvas* canvas) OVERRIDE {
+  virtual void OnPaintLayer(gfx::Canvas* canvas) override {
     SkISize size = canvas->sk_canvas()->getBaseLayerSize();
     paint_size_ = gfx::Size(size.width(), size.height());
     canvas->DrawColor(colors_[color_index_]);
     color_index_ = (color_index_ + 1) % static_cast<int>(colors_.size());
     const SkMatrix& matrix = canvas->sk_canvas()->getTotalMatrix();
     scale_x_ = matrix.getScaleX();
     scale_y_ = matrix.getScaleY();
   }
 
   virtual void OnDelegatedFrameDamage(
-      const gfx::Rect& damage_rect_in_dip) OVERRIDE {}
+      const gfx::Rect& damage_rect_in_dip) override {}
 
-  virtual void OnDeviceScaleFactorChanged(float device_scale_factor) OVERRIDE {
+  virtual void OnDeviceScaleFactorChanged(float device_scale_factor) override {
     device_scale_factor_ = device_scale_factor;
   }
 
-  virtual base::Closure PrepareForLayerBoundsChange() OVERRIDE {
+  virtual base::Closure PrepareForLayerBoundsChange() override {
     return base::Closure();
   }
 
   void reset() {
     color_index_ = 0;
     paint_size_.SetSize(0, 0);
     scale_x_ = scale_y_ = 0.0f;
     device_scale_factor_ = 0.0f;
   }
 
@@ skipping 15 matching lines @@
   virtual ~DrawTreeLayerDelegate() {}
 
   void Reset() {
     painted_ = false;
   }
 
   bool painted() const { return painted_; }
 
  private:
   // Overridden from LayerDelegate:
-  virtual void OnPaintLayer(gfx::Canvas* canvas) OVERRIDE {
+  virtual void OnPaintLayer(gfx::Canvas* canvas) override {
     painted_ = true;
     canvas->DrawColor(SK_ColorTRANSPARENT);
   }
   virtual void OnDelegatedFrameDamage(
-      const gfx::Rect& damage_rect_in_dip) OVERRIDE {}
-  virtual void OnDeviceScaleFactorChanged(float device_scale_factor) OVERRIDE {
+      const gfx::Rect& damage_rect_in_dip) override {}
+  virtual void OnDeviceScaleFactorChanged(float device_scale_factor) override {
   }
-  virtual base::Closure PrepareForLayerBoundsChange() OVERRIDE {
+  virtual base::Closure PrepareForLayerBoundsChange() override {
     return base::Closure();
   }
 
   bool painted_;
 
   DISALLOW_COPY_AND_ASSIGN(DrawTreeLayerDelegate);
 };
 
 // The simplest possible layer delegate. Does nothing.
 class NullLayerDelegate : public LayerDelegate {
  public:
   NullLayerDelegate() {}
   virtual ~NullLayerDelegate() {}
 
  private:
   // Overridden from LayerDelegate:
-  virtual void OnPaintLayer(gfx::Canvas* canvas) OVERRIDE {}
+  virtual void OnPaintLayer(gfx::Canvas* canvas) override {}
   virtual void OnDelegatedFrameDamage(
-      const gfx::Rect& damage_rect_in_dip) OVERRIDE {}
-  virtual void OnDeviceScaleFactorChanged(float device_scale_factor) OVERRIDE {}
-  virtual base::Closure PrepareForLayerBoundsChange() OVERRIDE {
+      const gfx::Rect& damage_rect_in_dip) override {}
+  virtual void OnDeviceScaleFactorChanged(float device_scale_factor) override {}
+  virtual base::Closure PrepareForLayerBoundsChange() override {
     return base::Closure();
   }
 
   DISALLOW_COPY_AND_ASSIGN(NullLayerDelegate);
 };
 
 // Remembers if it has been notified.
 class TestCompositorObserver : public CompositorObserver {
  public:
   TestCompositorObserver()
       : committed_(false), started_(false), ended_(false), aborted_(false) {}
 
   bool committed() const { return committed_; }
   bool notified() const { return started_ && ended_; }
   bool aborted() const { return aborted_; }
 
   void Reset() {
     committed_ = false;
     started_ = false;
     ended_ = false;
     aborted_ = false;
   }
 
  private:
-  virtual void OnCompositingDidCommit(Compositor* compositor) OVERRIDE {
+  virtual void OnCompositingDidCommit(Compositor* compositor) override {
     committed_ = true;
   }
 
   virtual void OnCompositingStarted(Compositor* compositor,
-                                    base::TimeTicks start_time) OVERRIDE {
+                                    base::TimeTicks start_time) override {
     started_ = true;
   }
 
-  virtual void OnCompositingEnded(Compositor* compositor) OVERRIDE {
+  virtual void OnCompositingEnded(Compositor* compositor) override {
     ended_ = true;
   }
 
-  virtual void OnCompositingAborted(Compositor* compositor) OVERRIDE {
+  virtual void OnCompositingAborted(Compositor* compositor) override {
     aborted_ = true;
   }
 
-  virtual void OnCompositingLockStateChanged(Compositor* compositor) OVERRIDE {
+  virtual void OnCompositingLockStateChanged(Compositor* compositor) override {
   }
 
   bool committed_;
   bool started_;
   bool ended_;
   bool aborted_;
 
   DISALLOW_COPY_AND_ASSIGN(TestCompositorObserver);
 };
 
@@ skipping 27 matching lines @@
 
   DrawTree(l1.get());
 }
 
 class LayerWithDelegateTest : public testing::Test {
  public:
   LayerWithDelegateTest() {}
   virtual ~LayerWithDelegateTest() {}
 
   // Overridden from testing::Test:
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     bool enable_pixel_output = false;
     ui::ContextFactory* context_factory =
         InitializeContextFactoryForTests(enable_pixel_output);
 
     const gfx::Rect host_bounds(1000, 1000);
     compositor_host_.reset(TestCompositorHost::Create(host_bounds,
                                                       context_factory));
     compositor_host_->Show();
   }
 
-  virtual void TearDown() OVERRIDE {
+  virtual void TearDown() override {
     compositor_host_.reset();
     TerminateContextFactoryForTests();
   }
 
   Compositor* compositor() { return compositor_host_->GetCompositor(); }
 
   virtual Layer* CreateLayer(LayerType type) {
     return new Layer(type);
   }
 
@@ skipping 178 matching lines @@
   EXPECT_FALSE(d2.painted());
   // |d3| should have received a paint notification.
   EXPECT_TRUE(d3.painted());
 }
 
 class LayerWithNullDelegateTest : public LayerWithDelegateTest {
  public:
   LayerWithNullDelegateTest() {}
   virtual ~LayerWithNullDelegateTest() {}
 
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     LayerWithDelegateTest::SetUp();
     default_layer_delegate_.reset(new NullLayerDelegate());
   }
 
-  virtual Layer* CreateLayer(LayerType type) OVERRIDE {
+  virtual Layer* CreateLayer(LayerType type) override {
     Layer* layer = new Layer(type);
     layer->set_delegate(default_layer_delegate_.get());
     return layer;
   }
 
   Layer* CreateTextureRootLayer(const gfx::Rect& bounds) {
     Layer* layer = CreateTextureLayer(bounds);
     compositor()->SetRootLayer(layer);
     return layer;
   }
 
   Layer* CreateTextureLayer(const gfx::Rect& bounds) {
     Layer* layer = CreateLayer(LAYER_TEXTURED);
     layer->SetBounds(bounds);
     return layer;
   }
 
-  virtual Layer* CreateNoTextureLayer(const gfx::Rect& bounds) OVERRIDE {
+  virtual Layer* CreateNoTextureLayer(const gfx::Rect& bounds) override {
     Layer* layer = CreateLayer(LAYER_NOT_DRAWN);
     layer->SetBounds(bounds);
     return layer;
   }
 
  private:
   scoped_ptr<NullLayerDelegate> default_layer_delegate_;
 
   DISALLOW_COPY_AND_ASSIGN(LayerWithNullDelegateTest);
 };
@@ skipping 545 matching lines @@
   int GetPaintCountAndClear() {
     int value = paint_count_;
     paint_count_ = 0;
     return value;
   }
 
   const gfx::RectF& last_clip_rect() const { return last_clip_rect_; }
 
  private:
   // Overridden from LayerDelegate:
-  virtual void OnPaintLayer(gfx::Canvas* canvas) OVERRIDE {
+  virtual void OnPaintLayer(gfx::Canvas* canvas) override {
     paint_count_++;
     if (!schedule_paint_rect_.IsEmpty()) {
       layer_->SchedulePaint(schedule_paint_rect_);
       schedule_paint_rect_ = gfx::Rect();
     }
     SkRect sk_clip_rect;
     if (canvas->sk_canvas()->getClipBounds(&sk_clip_rect))
       last_clip_rect_ = gfx::SkRectToRectF(sk_clip_rect);
   }
 
   virtual void OnDelegatedFrameDamage(
-      const gfx::Rect& damage_rect_in_dip) OVERRIDE {}
+      const gfx::Rect& damage_rect_in_dip) override {}
 
-  virtual void OnDeviceScaleFactorChanged(float device_scale_factor) OVERRIDE {
+  virtual void OnDeviceScaleFactorChanged(float device_scale_factor) override {
   }
 
-  virtual base::Closure PrepareForLayerBoundsChange() OVERRIDE {
+  virtual base::Closure PrepareForLayerBoundsChange() override {
     return base::Closure();
   }
 
   int paint_count_;
   Layer* layer_;
   gfx::Rect schedule_paint_rect_;
   gfx::RectF last_clip_rect_;
 
   DISALLOW_COPY_AND_ASSIGN(SchedulePaintLayerDelegate);
 };
@@ skipping 478 matching lines @@
   // 0.5 / 1.5 = 0.333...
   EXPECT_EQ("0.33 0.33",
             Vector2dFTo100thPercisionString(c11->subpixel_position_offset()));
 }
 
 class FrameDamageCheckingDelegate : public TestLayerDelegate {
  public:
   FrameDamageCheckingDelegate() : delegated_frame_damage_called_(false) {}
 
   virtual void OnDelegatedFrameDamage(
-      const gfx::Rect& damage_rect_in_dip) OVERRIDE {
+      const gfx::Rect& damage_rect_in_dip) override {
     delegated_frame_damage_called_ = true;
     delegated_frame_damage_rect_ = damage_rect_in_dip;
   }
 
   const gfx::Rect& delegated_frame_damage_rect() const {
     return delegated_frame_damage_rect_;
   }
   bool delegated_frame_damage_called() const {
     return delegated_frame_damage_called_;
   }
@@ skipping 18 matching lines @@
                                      MakeFrameData(gfx::Size(10, 10))));
   layer->SetShowDelegatedContent(frame_provider.get(), gfx::Size(10, 10));
 
   EXPECT_FALSE(delegate.delegated_frame_damage_called());
   layer->OnDelegatedFrameDamage(damage_rect);
   EXPECT_TRUE(delegate.delegated_frame_damage_called());
   EXPECT_EQ(damage_rect, delegate.delegated_frame_damage_rect());
 }
 
 }  // namespace ui