replace OVERRIDE and FINAL with override and final in ui/

ui/events/event_processor_unittest.cc

 // Copyright (c) 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 <vector>
 
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/events/event.h"
 #include "ui/events/event_targeter.h"
 #include "ui/events/test/events_test_utils.h"
 #include "ui/events/test/test_event_handler.h"
 #include "ui/events/test/test_event_processor.h"
 #include "ui/events/test/test_event_target.h"
 
 typedef std::vector<std::string> HandlerSequenceRecorder;
 
 namespace ui {
 namespace test {
 
 class EventProcessorTest : public testing::Test {
  public:
   EventProcessorTest() {}
   virtual ~EventProcessorTest() {}
 
   // testing::Test:
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     processor_.SetRoot(scoped_ptr<EventTarget>(new TestEventTarget()));
     processor_.Reset();
     root()->SetEventTargeter(make_scoped_ptr(new EventTargeter()));
   }
 
   TestEventTarget* root() {
     return static_cast<TestEventTarget*>(processor_.GetRootTarget());
   }
 
   TestEventProcessor* processor() {
@@ skipping 25 matching lines @@
   EXPECT_TRUE(root()->DidReceiveEvent(ET_MOUSE_MOVED));
 }
 
 template<typename T>
 class BoundsEventTargeter : public EventTargeter {
  public:
   virtual ~BoundsEventTargeter() {}
 
  protected:
   virtual bool SubtreeShouldBeExploredForEvent(
-      EventTarget* target, const LocatedEvent& event) OVERRIDE {
+      EventTarget* target, const LocatedEvent& event) override {
     T* t = static_cast<T*>(target);
     return (t->bounds().Contains(event.location()));
   }
 };
 
 class BoundsTestTarget : public TestEventTarget {
  public:
   BoundsTestTarget() {}
   virtual ~BoundsTestTarget() {}
 
@@ skipping 17 matching lines @@
       }
       *location += vector;
     } else {
       NOTREACHED();
     }
   }
 
  private:
   // EventTarget:
   virtual void ConvertEventToTarget(EventTarget* target,
-                                    LocatedEvent* event) OVERRIDE {
+                                    LocatedEvent* event) override {
     event->ConvertLocationToTarget(this,
                                    static_cast<BoundsTestTarget*>(target));
   }
 
   gfx::Rect bounds_;
 
   DISALLOW_COPY_AND_ASSIGN(BoundsTestTarget);
 };
 
 TEST_F(EventProcessorTest, Bounds) {
@@ skipping 57 matching lines @@
 // target and phase both before and after the nested event processing. Also
 // verifies that the location of the event remains the same after it has
 // been processed by the second EventProcessor.
 class ReDispatchEventHandler : public TestEventHandler {
  public:
   ReDispatchEventHandler(EventProcessor* processor, EventTarget* target)
       : processor_(processor), expected_target_(target) {}
   virtual ~ReDispatchEventHandler() {}
 
   // TestEventHandler:
-  virtual void OnMouseEvent(MouseEvent* event) OVERRIDE {
+  virtual void OnMouseEvent(MouseEvent* event) override {
     TestEventHandler::OnMouseEvent(event);
 
     EXPECT_EQ(expected_target_, event->target());
     EXPECT_EQ(EP_TARGET, event->phase());
 
     gfx::Point location(event->location());
     EventDispatchDetails details = processor_->OnEventFromSource(event);
     EXPECT_FALSE(details.dispatcher_destroyed);
     EXPECT_FALSE(details.target_destroyed);
 
@@ skipping 121 matching lines @@
 }
 
 class IgnoreEventTargeter : public EventTargeter {
  public:
   IgnoreEventTargeter() {}
   virtual ~IgnoreEventTargeter() {}
 
  private:
   // EventTargeter:
   virtual bool SubtreeShouldBeExploredForEvent(
-      EventTarget* target, const LocatedEvent& event) OVERRIDE {
+      EventTarget* target, const LocatedEvent& event) override {
     return false;
   }
 };
 
 // Verifies that the EventTargeter installed on an EventTarget can dictate
 // whether the target itself can process an event.
 TEST_F(EventProcessorTest, TargeterChecksOwningEventTarget) {
   scoped_ptr<TestEventTarget> child(new TestEventTarget());
   root()->AddChild(child.Pass());
 
@@ skipping 21 matching lines @@
 // specified by FindNextBestTarget().
 class BubblingEventTargeter : public EventTargeter {
  public:
   explicit BubblingEventTargeter(TestEventTarget* initial_target)
     : initial_target_(initial_target) {}
   virtual ~BubblingEventTargeter() {}
 
  private:
   // EventTargeter:
   virtual EventTarget* FindTargetForEvent(EventTarget* root,
-                                          Event* event) OVERRIDE {
+                                          Event* event) override {
     return initial_target_;
   }
 
   virtual EventTarget* FindNextBestTarget(EventTarget* previous_target,
-                                          Event* event) OVERRIDE {
+                                          Event* event) override {
     return previous_target->GetParentTarget();
   }
 
   TestEventTarget* initial_target_;
 
   DISALLOW_COPY_AND_ASSIGN(BubblingEventTargeter);
 };
 
 // Tests that unhandled events are correctly dispatched to the next-best
 // target as decided by the BubblingEventTargeter.
@@ skipping 128 matching lines @@
   DispatchEvent(&mouse);
 
   std::string expected[] = { "PreR", "PreC", "PreG", "G", "PostG", "PostC",
       "PostR", "PreR", "PreC", "C", "PostC", "PostR", "PreR", "R", "PostR" };
   EXPECT_EQ(std::vector<std::string>(
       expected, expected + arraysize(expected)), recorder);
 }
 
 }  // namespace test
 }  // namespace ui