replace OVERRIDE and FINAL with override and final in chrome/browser/chromeos/

chrome/browser/chromeos/events/event_rewriter_unittest.cc

 // Copyright 2014 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 "chrome/browser/chromeos/events/event_rewriter.h"
 
 #include <vector>
 
 #include "ash/shell.h"
 #include "ash/sticky_keys/sticky_keys_controller.h"
@@ skipping 1769 matching lines @@
   virtual ~EventBuffer() {}
 
   void PopEvents(ScopedVector<ui::Event>* events) {
     events->clear();
     events->swap(events_);
   }
 
  private:
   // ui::EventProcessor overrides:
   virtual ui::EventDispatchDetails OnEventFromSource(
-      ui::Event* event) OVERRIDE {
+      ui::Event* event) override {
     if (event->IsKeyEvent()) {
       events_.push_back(new ui::KeyEvent(*static_cast<ui::KeyEvent*>(event)));
     } else if (event->IsMouseWheelEvent()) {
       events_.push_back(
           new ui::MouseWheelEvent(*static_cast<ui::MouseWheelEvent*>(event)));
     } else if (event->IsMouseEvent()) {
       events_.push_back(
           new ui::MouseEvent(*static_cast<ui::MouseEvent*>(event)));
     }
     return ui::EventDispatchDetails();
   }
 
   ScopedVector<ui::Event> events_;
 
   DISALLOW_COPY_AND_ASSIGN(EventBuffer);
 };
 
 // Trivial EventSource that does nothing but send events.
 class TestEventSource : public ui::EventSource {
  public:
   explicit TestEventSource(ui::EventProcessor* processor)
       : processor_(processor) {}
-  virtual ui::EventProcessor* GetEventProcessor() OVERRIDE {
+  virtual ui::EventProcessor* GetEventProcessor() override {
     return processor_;
   }
   ui::EventDispatchDetails Send(ui::Event* event) {
     return SendEventToProcessor(event);
   }
 
  private:
   ui::EventProcessor* processor_;
 };
 
@@ skipping 26 matching lines @@
     SendKeyEvent(ui::ET_KEY_RELEASED, key_code);
   }
 
  protected:
   TestingPrefServiceSyncable* prefs() { return &prefs_; }
 
   void PopEvents(ScopedVector<ui::Event>* events) {
     buffer_.PopEvents(events);
   }
 
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     AshTestBase::SetUp();
     sticky_keys_controller_ =
         ash::Shell::GetInstance()->sticky_keys_controller();
     rewriter_.reset(new EventRewriter(sticky_keys_controller_));
     chromeos::Preferences::RegisterProfilePrefs(prefs_.registry());
     rewriter_->set_pref_service_for_testing(&prefs_);
 #if defined(USE_X11)
     ui::SetUpTouchPadForTest(kTouchPadDeviceId);
 #endif
     source_.AddEventRewriter(rewriter_.get());
     sticky_keys_controller_->Enable(true);
   }
 
-  virtual void TearDown() OVERRIDE {
+  virtual void TearDown() override {
     rewriter_.reset();
     AshTestBase::TearDown();
   }
 
  protected:
   ash::StickyKeysController* sticky_keys_controller_;
 
  private:
   scoped_ptr<EventRewriter> rewriter_;
 
@@ skipping 419 matching lines @@
   EXPECT_EQ(ui::VKEY_CONTROL,
             static_cast<ui::KeyEvent*>(events[1])->key_code());
 }
 
 class StickyKeysOverlayTest : public EventRewriterAshTest {
  public:
   StickyKeysOverlayTest() : overlay_(NULL) {}
 
   virtual ~StickyKeysOverlayTest() {}
 
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     EventRewriterAshTest::SetUp();
     overlay_ = sticky_keys_controller_->GetOverlayForTest();
     ASSERT_TRUE(overlay_);
   }
 
   ash::StickyKeysOverlay* overlay_;
 };
 
 TEST_F(StickyKeysOverlayTest, OneModifierEnabled) {
   EXPECT_FALSE(overlay_->is_visible());
@@ skipping 153 matching lines @@
   EXPECT_FALSE(overlay_->GetModifierVisible(ui::EF_ALTGR_DOWN));
   EXPECT_TRUE(overlay_->GetModifierVisible(ui::EF_MOD3_DOWN));
 
   // Turn off AltGr and Mod3.
   sticky_keys_controller_->SetModifiersEnabled(false, false);
   EXPECT_FALSE(overlay_->GetModifierVisible(ui::EF_ALTGR_DOWN));
   EXPECT_FALSE(overlay_->GetModifierVisible(ui::EF_MOD3_DOWN));
 }
 
 }  // namespace chromeos