Standardize usage of virtual/override/final specifiers.

ui/events/platform/platform_event_source_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 "ui/events/platform/platform_event_source.h"
 
 #include "base/bind.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/scoped_vector.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 30 matching lines @@
   PlatformEventSource::GetInstance()->AddPlatformEventDispatcher(dispatcher);
 }
 
 }  // namespace
 
 class TestPlatformEventSource : public PlatformEventSource {
  public:
   TestPlatformEventSource()
       : stop_stream_(false) {
   }
-  virtual ~TestPlatformEventSource() {}
+  ~TestPlatformEventSource() override {}
 
   uint32_t Dispatch(const PlatformEvent& event) { return DispatchEvent(event); }
 
   // Dispatches the stream of events, and returns the number of events that are
   // dispatched before it is requested to stop.
   size_t DispatchEventStream(const ScopedVector<PlatformEvent>& events) {
     stop_stream_ = false;
     for (size_t count = 0; count < events.size(); ++count) {
       DispatchEvent(*events[count]);
       if (stop_stream_)
         return count + 1;
     }
     return events.size();
   }
 
   // PlatformEventSource:
-  virtual void StopCurrentEventStream() override {
-    stop_stream_ = true;
-  }
+  void StopCurrentEventStream() override { stop_stream_ = true; }
 
  private:
   bool stop_stream_;
   DISALLOW_COPY_AND_ASSIGN(TestPlatformEventSource);
 };
 
 class TestPlatformEventDispatcher : public PlatformEventDispatcher {
  public:
   TestPlatformEventDispatcher(int id, std::vector<int>* list)
       : id_(id),
         list_(list),
         post_dispatch_action_(POST_DISPATCH_NONE),
         stop_stream_(false) {
     PlatformEventSource::GetInstance()->AddPlatformEventDispatcher(this);
   }
-  virtual ~TestPlatformEventDispatcher() {
+  ~TestPlatformEventDispatcher() override {
     PlatformEventSource::GetInstance()->RemovePlatformEventDispatcher(this);
   }
 
   void set_post_dispatch_action(uint32_t action) {
     post_dispatch_action_ = action;
   }
 
  protected:
   // PlatformEventDispatcher:
-  virtual bool CanDispatchEvent(const PlatformEvent& event) override {
-    return true;
-  }
+  bool CanDispatchEvent(const PlatformEvent& event) override { return true; }
 
-  virtual uint32_t DispatchEvent(const PlatformEvent& event) override {
+  uint32_t DispatchEvent(const PlatformEvent& event) override {
     list_->push_back(id_);
     return post_dispatch_action_;
   }
 
  private:
   int id_;
   std::vector<int>* list_;
   uint32_t post_dispatch_action_;
   bool stop_stream_;
 
   DISALLOW_COPY_AND_ASSIGN(TestPlatformEventDispatcher);
 };
 
 class TestPlatformEventObserver : public PlatformEventObserver {
  public:
   TestPlatformEventObserver(int id, std::vector<int>* list)
       : id_(id), list_(list) {
     PlatformEventSource::GetInstance()->AddPlatformEventObserver(this);
   }
-  virtual ~TestPlatformEventObserver() {
+  ~TestPlatformEventObserver() override {
     PlatformEventSource::GetInstance()->RemovePlatformEventObserver(this);
   }
 
  protected:
   // PlatformEventObserver:
-  virtual void WillProcessEvent(const PlatformEvent& event) override {
+  void WillProcessEvent(const PlatformEvent& event) override {
     list_->push_back(id_);
   }
 
-  virtual void DidProcessEvent(const PlatformEvent& event) override {}
+  void DidProcessEvent(const PlatformEvent& event) override {}
 
  private:
   int id_;
   std::vector<int>* list_;
 
   DISALLOW_COPY_AND_ASSIGN(TestPlatformEventObserver);
 };
 
 class PlatformEventTest : public testing::Test {
  public:
   PlatformEventTest() {}
-  virtual ~PlatformEventTest() {}
+  ~PlatformEventTest() override {}
 
   TestPlatformEventSource* source() { return source_.get(); }
 
  protected:
   // testing::Test:
-  virtual void SetUp() override {
-    source_.reset(new TestPlatformEventSource());
-  }
+  void SetUp() override { source_.reset(new TestPlatformEventSource()); }
 
  private:
   scoped_ptr<TestPlatformEventSource> source_;
 
   DISALLOW_COPY_AND_ASSIGN(PlatformEventTest);
 };
 
 // Tests that a dispatcher receives an event.
 TEST_F(PlatformEventTest, DispatcherBasic) {
   std::vector<int> list_dispatcher;
@@ skipping 166 matching lines @@
   EXPECT_EQ(15, list[0]);
   EXPECT_EQ(50, list[1]);
   EXPECT_EQ(10, list[2]);
 }
 
 // Runs a callback during an event dispatch.
 class RunCallbackDuringDispatch : public TestPlatformEventDispatcher {
  public:
   RunCallbackDuringDispatch(int id, std::vector<int>* list)
       : TestPlatformEventDispatcher(id, list) {}
-  virtual ~RunCallbackDuringDispatch() {}
+  ~RunCallbackDuringDispatch() override {}
 
   void set_callback(const base::Closure& callback) {
     callback_ = callback;
   }
 
  protected:
   // PlatformEventDispatcher:
-  virtual uint32_t DispatchEvent(const PlatformEvent& event) override {
+  uint32_t DispatchEvent(const PlatformEvent& event) override {
     if (!callback_.is_null())
       callback_.Run();
     return TestPlatformEventDispatcher::DispatchEvent(event);
   }
 
  private:
   base::Closure callback_;
 
   DISALLOW_COPY_AND_ASSIGN(RunCallbackDuringDispatch);
 };
@@ skipping 134 matching lines @@
   EXPECT_EQ(10, list[0]);
   EXPECT_EQ(15, list[1]);
   EXPECT_EQ(20, list[2]);
   EXPECT_EQ(30, list[3]);
 }
 
 // Provides mechanism for running tests from inside an active message-loop.
 class PlatformEventTestWithMessageLoop : public PlatformEventTest {
  public:
   PlatformEventTestWithMessageLoop() {}
-  virtual ~PlatformEventTestWithMessageLoop() {}
+  ~PlatformEventTestWithMessageLoop() override {}
 
   void Run() {
     message_loop_.PostTask(
         FROM_HERE,
         base::Bind(&PlatformEventTestWithMessageLoop::RunTest,
                    base::Unretained(this)));
     message_loop_.Run();
   }
 
  protected:
@@ skipping 12 matching lines @@
 
 #define RUN_TEST_IN_MESSAGE_LOOP(name) \
   TEST_F(name, Run) { Run(); }
 
 // Tests that a ScopedEventDispatcher restores the previous dispatcher when
 // destroyed.
 class ScopedDispatcherRestoresAfterDestroy
     : public PlatformEventTestWithMessageLoop {
  public:
   // PlatformEventTestWithMessageLoop:
-  virtual void RunTestImpl() override {
+  void RunTestImpl() override {
     std::vector<int> list;
     TestPlatformEventDispatcher dispatcher(10, &list);
     TestPlatformEventObserver observer(15, &list);
 
     TestPlatformEventDispatcher first_overriding(20, &list);
     source()->RemovePlatformEventDispatcher(&first_overriding);
     scoped_ptr<ScopedEventDispatcher> first_override_handle =
         source()->OverrideDispatcher(&first_overriding);
 
     // Install a second overriding dispatcher.
@@ skipping 18 matching lines @@
 };
 
 RUN_TEST_IN_MESSAGE_LOOP(ScopedDispatcherRestoresAfterDestroy)
 
 // This dispatcher destroys the handle to the ScopedEventDispatcher when
 // dispatching an event.
 class DestroyScopedHandleDispatcher : public TestPlatformEventDispatcher {
  public:
   DestroyScopedHandleDispatcher(int id, std::vector<int>* list)
       : TestPlatformEventDispatcher(id, list) {}
-  virtual ~DestroyScopedHandleDispatcher() {}
+  ~DestroyScopedHandleDispatcher() override {}
 
   void SetScopedHandle(scoped_ptr<ScopedEventDispatcher> handler) {
     handler_ = handler.Pass();
   }
 
   void set_callback(const base::Closure& callback) {
     callback_ = callback;
   }
 
  private:
   // PlatformEventDispatcher:
-  virtual bool CanDispatchEvent(const PlatformEvent& event) override {
-    return true;
-  }
+  bool CanDispatchEvent(const PlatformEvent& event) override { return true; }
 
-  virtual uint32_t DispatchEvent(const PlatformEvent& event) override {
+  uint32_t DispatchEvent(const PlatformEvent& event) override {
     handler_.reset();
     uint32_t action = TestPlatformEventDispatcher::DispatchEvent(event);
     if (!callback_.is_null()) {
       callback_.Run();
       callback_ = base::Closure();
     }
     return action;
   }
 
   scoped_ptr<ScopedEventDispatcher> handler_;
@@ skipping 34 matching lines @@
     ASSERT_EQ(2u, list->size());
     EXPECT_EQ(15, (*list)[0]);
     EXPECT_EQ(10, (*list)[1]);
     list->clear();
 
     // Terminate the message-loop.
     base::MessageLoopForUI::current()->QuitNow();
   }
 
   // PlatformEventTestWithMessageLoop:
-  virtual void RunTestImpl() override {
+  void RunTestImpl() override {
     std::vector<int> list;
     TestPlatformEventDispatcher dispatcher(10, &list);
     TestPlatformEventObserver observer(15, &list);
 
     DestroyScopedHandleDispatcher overriding(20, &list);
     source()->RemovePlatformEventDispatcher(&overriding);
     scoped_ptr<ScopedEventDispatcher> override_handle =
         source()->OverrideDispatcher(&overriding);
 
     scoped_ptr<PlatformEvent> event(CreatePlatformEvent());
@@ skipping 79 matching lines @@
     ASSERT_EQ(2u, list->size());
     EXPECT_EQ(15, (*list)[0]);
     EXPECT_EQ(70, (*list)[1]);
     list->clear();
 
     // Terminate the message-loop.
     base::MessageLoopForUI::current()->QuitNow();
   }
 
   // PlatformEventTestWithMessageLoop:
-  virtual void RunTestImpl() override {
+  void RunTestImpl() override {
     std::vector<int> list;
     TestPlatformEventDispatcher dispatcher(10, &list);
     TestPlatformEventObserver observer(15, &list);
 
     TestPlatformEventDispatcher overriding(20, &list);
     source()->RemovePlatformEventDispatcher(&overriding);
     scoped_ptr<ScopedEventDispatcher> override_handle =
         source()->OverrideDispatcher(&overriding);
 
     scoped_ptr<PlatformEvent> event(CreatePlatformEvent());
@@ skipping 24 matching lines @@
     ASSERT_EQ(2u, list.size());
     EXPECT_EQ(15, list[0]);
     EXPECT_EQ(10, list[1]);
   }
 };
 
 RUN_TEST_IN_MESSAGE_LOOP(
     ConsecutiveOverriddenDispatcherInTheSameMessageLoopIteration)
 
 }  // namespace ui