replace OVERRIDE and FINAL with override and final in ash/

ash/drag_drop/drag_drop_controller_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 "ash/drag_drop/drag_drop_controller.h"
 
 #include "ash/drag_drop/drag_drop_tracker.h"
 #include "ash/drag_drop/drag_image_view.h"
 #include "ash/shell.h"
 #include "ash/test/ash_test_base.h"
@@ skipping 53 matching lines @@
 
   int num_drag_enters_;
   int num_drag_exits_;
   int num_drag_updates_;
   int num_drops_;
   bool drag_done_received_;
   bool long_tap_received_;
 
  private:
   // View overrides:
-  virtual int GetDragOperations(const gfx::Point& press_pt) OVERRIDE {
+  virtual int GetDragOperations(const gfx::Point& press_pt) override {
     return ui::DragDropTypes::DRAG_COPY;
   }
 
   virtual void WriteDragData(const gfx::Point& p,
-                             OSExchangeData* data) OVERRIDE {
+                             OSExchangeData* data) override {
     data->SetString(base::UTF8ToUTF16("I am being dragged"));
     gfx::ImageSkiaRep image_rep(gfx::Size(10, 20), 1.0f);
     gfx::ImageSkia image_skia(image_rep);
 
     drag_utils::SetDragImageOnDataObject(image_skia, gfx::Vector2d(), data);
   }
 
-  virtual bool OnMousePressed(const ui::MouseEvent& event) OVERRIDE {
+  virtual bool OnMousePressed(const ui::MouseEvent& event) override {
     return true;
   }
 
-  virtual void OnGestureEvent(ui::GestureEvent* event) OVERRIDE {
+  virtual void OnGestureEvent(ui::GestureEvent* event) override {
     if (event->type() == ui::ET_GESTURE_LONG_TAP)
       long_tap_received_ = true;
     return;
   }
 
   virtual bool GetDropFormats(
       int* formats,
-      std::set<OSExchangeData::CustomFormat>* custom_formats) OVERRIDE {
+      std::set<OSExchangeData::CustomFormat>* custom_formats) override {
     *formats = ui::OSExchangeData::STRING;
     return true;
   }
 
-  virtual bool CanDrop(const OSExchangeData& data) OVERRIDE {
+  virtual bool CanDrop(const OSExchangeData& data) override {
     return true;
   }
 
-  virtual void OnDragEntered(const ui::DropTargetEvent& event) OVERRIDE {
+  virtual void OnDragEntered(const ui::DropTargetEvent& event) override {
     num_drag_enters_++;
   }
 
-  virtual int OnDragUpdated(const ui::DropTargetEvent& event) OVERRIDE {
+  virtual int OnDragUpdated(const ui::DropTargetEvent& event) override {
     num_drag_updates_++;
     return ui::DragDropTypes::DRAG_COPY;
   }
 
-  virtual void OnDragExited() OVERRIDE {
+  virtual void OnDragExited() override {
     num_drag_exits_++;
   }
 
-  virtual int OnPerformDrop(const ui::DropTargetEvent& event) OVERRIDE {
+  virtual int OnPerformDrop(const ui::DropTargetEvent& event) override {
     num_drops_++;
     return ui::DragDropTypes::DRAG_COPY;
   }
 
-  virtual void OnDragDone() OVERRIDE {
+  virtual void OnDragDone() override {
     drag_done_received_ = true;
   }
 
   DISALLOW_COPY_AND_ASSIGN(DragTestView);
 };
 
 class CompletableLinearAnimation : public gfx::LinearAnimation {
  public:
   CompletableLinearAnimation(int duration,
                              int frame_rate,
@@ skipping 21 matching lines @@
     drag_canceled_ = false;
     drag_string_.clear();
   }
 
   virtual int StartDragAndDrop(
       const ui::OSExchangeData& data,
       aura::Window* root_window,
       aura::Window* source_window,
       const gfx::Point& location,
       int operation,
-      ui::DragDropTypes::DragEventSource source) OVERRIDE {
+      ui::DragDropTypes::DragEventSource source) override {
     drag_start_received_ = true;
     data.GetString(&drag_string_);
     return DragDropController::StartDragAndDrop(
         data, root_window, source_window, location, operation, source);
   }
 
   virtual void DragUpdate(aura::Window* target,
-                          const ui::LocatedEvent& event) OVERRIDE {
+                          const ui::LocatedEvent& event) override {
     DragDropController::DragUpdate(target, event);
     num_drag_updates_++;
   }
 
   virtual void Drop(aura::Window* target,
-                    const ui::LocatedEvent& event) OVERRIDE {
+                    const ui::LocatedEvent& event) override {
     DragDropController::Drop(target, event);
     drop_received_ = true;
   }
 
-  virtual void DragCancel() OVERRIDE {
+  virtual void DragCancel() override {
     DragDropController::DragCancel();
     drag_canceled_ = true;
   }
 
   virtual gfx::LinearAnimation* CreateCancelAnimation(
       int duration,
       int frame_rate,
-      gfx::AnimationDelegate* delegate) OVERRIDE {
+      gfx::AnimationDelegate* delegate) override {
     return new CompletableLinearAnimation(duration, frame_rate, delegate);
   }
 
-  virtual void DoDragCancel(int animation_duration_ms) OVERRIDE {
+  virtual void DoDragCancel(int animation_duration_ms) override {
     DragDropController::DoDragCancel(animation_duration_ms);
     drag_canceled_ = true;
   }
 
   bool drag_start_received_;
   int num_drag_updates_;
   bool drop_received_;
   bool drag_canceled_;
   base::string16 drag_string_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(TestDragDropController);
 };
 
 class TestNativeWidgetAura : public views::NativeWidgetAura {
  public:
   explicit TestNativeWidgetAura(views::internal::NativeWidgetDelegate* delegate)
       : NativeWidgetAura(delegate),
         check_if_capture_lost_(false) {
   }
 
   void set_check_if_capture_lost(bool value) {
     check_if_capture_lost_ = value;
   }
 
-  virtual void OnCaptureLost() OVERRIDE {
+  virtual void OnCaptureLost() override {
     DCHECK(!check_if_capture_lost_);
     views::NativeWidgetAura::OnCaptureLost();
   }
 
  private:
   bool check_if_capture_lost_;
 
   DISALLOW_COPY_AND_ASSIGN(TestNativeWidgetAura);
 };
 
@@ skipping 49 matching lines @@
   CHECK(!details.dispatcher_destroyed);
 }
 
 }  // namespace
 
 class DragDropControllerTest : public AshTestBase {
  public:
   DragDropControllerTest() : AshTestBase() {}
   virtual ~DragDropControllerTest() {}
 
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     AshTestBase::SetUp();
     drag_drop_controller_.reset(new TestDragDropController);
     drag_drop_controller_->set_should_block_during_drag_drop(false);
     aura::client::SetDragDropClient(Shell::GetPrimaryRootWindow(),
                                     drag_drop_controller_.get());
   }
 
-  virtual void TearDown() OVERRIDE {
+  virtual void TearDown() override {
     aura::client::SetDragDropClient(Shell::GetPrimaryRootWindow(), NULL);
     drag_drop_controller_.reset();
     AshTestBase::TearDown();
   }
 
   void UpdateDragData(ui::OSExchangeData* data) {
     drag_drop_controller_->drag_data_ = data;
   }
 
   aura::Window* GetDragWindow() {
@@ skipping 649 matching lines @@
   EXPECT_FALSE(drag_view->long_tap_received_);
   DispatchGesture(ui::ET_GESTURE_LONG_TAP, point);
   CompleteCancelAnimation();
   EXPECT_TRUE(drag_view->long_tap_received_);
 }
 
 namespace {
 
 class DragImageWindowObserver : public aura::WindowObserver {
  public:
-  virtual void OnWindowDestroying(aura::Window* window) OVERRIDE {
+  virtual void OnWindowDestroying(aura::Window* window) override {
     window_location_on_destroying_ = window->GetBoundsInScreen().origin();
   }
 
   gfx::Point window_location_on_destroying() const {
     return window_location_on_destroying_;
   }
 
  public:
   gfx::Point window_location_on_destroying_;
 };
@@ skipping 91 matching lines @@
     EXPECT_EQ("405,405", observer.window_location_on_destroying().ToString());
   }
   for (aura::Window::Windows::iterator iter = root_windows.begin();
        iter != root_windows.end(); ++iter) {
     aura::client::SetDragDropClient(*iter, NULL);
   }
 }
 
 }  // namespace test
 }  // namespace aura