Standardize usage of virtual/override/final specifiers.

ui/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 "ui/events/event_rewriter.h"
 
 #include <list>
 #include <map>
 #include <set>
 #include <utility>
 
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/events/test/test_event_processor.h"
 
 namespace ui {
 
 namespace {
 
 // To test the handling of |EventRewriter|s through |EventSource|,
 // we rewrite and test event types.
 class TestEvent : public Event {
  public:
   explicit TestEvent(EventType type)
       : Event(type, base::TimeDelta(), 0), unique_id_(next_unique_id_++) {}
-  virtual ~TestEvent() {}
+  ~TestEvent() override {}
   int unique_id() const { return unique_id_; }
 
  private:
   static int next_unique_id_;
   int unique_id_;
 };
 
 int TestEvent::next_unique_id_ = 0;
 
 // TestEventRewriteProcessor is set up with a sequence of event types,
 // and fails if the events received via OnEventFromSource() do not match
 // this sequence. These expected event types are consumed on receipt.
 class TestEventRewriteProcessor : public test::TestEventProcessor {
  public:
   TestEventRewriteProcessor() {}
-  virtual ~TestEventRewriteProcessor() { CheckAllReceived(); }
+  ~TestEventRewriteProcessor() override { CheckAllReceived(); }
 
   void AddExpectedEvent(EventType type) { expected_events_.push_back(type); }
   // Test that all expected events have been received.
   void CheckAllReceived() { EXPECT_TRUE(expected_events_.empty()); }
 
   // EventProcessor:
-  virtual EventDispatchDetails OnEventFromSource(Event* event) override {
+  EventDispatchDetails OnEventFromSource(Event* event) override {
     EXPECT_FALSE(expected_events_.empty());
     EXPECT_EQ(expected_events_.front(), event->type());
     expected_events_.pop_front();
     return EventDispatchDetails();
   }
 
  private:
   std::list<EventType> expected_events_;
   DISALLOW_COPY_AND_ASSIGN(TestEventRewriteProcessor);
 };
 
 // Trivial EventSource that does nothing but send events.
 class TestEventRewriteSource : public EventSource {
  public:
   explicit TestEventRewriteSource(EventProcessor* processor)
       : processor_(processor) {}
-  virtual EventProcessor* GetEventProcessor() override { return processor_; }
+  EventProcessor* GetEventProcessor() override { return processor_; }
   void Send(EventType type) {
     scoped_ptr<Event> event(new TestEvent(type));
     (void)SendEventToProcessor(event.get());
   }
 
  private:
   EventProcessor* processor_;
 };
 
 // This EventRewriter always returns the same status, and if rewriting, the
 // same event type; it is used to test simple rewriting, and rewriter addition,
 // removal, and sequencing. Consequently EVENT_REWRITE_DISPATCH_ANOTHER is not
 // supported here (calls to NextDispatchEvent() would continue indefinitely).
 class TestConstantEventRewriter : public EventRewriter {
  public:
   TestConstantEventRewriter(EventRewriteStatus status, EventType type)
       : status_(status), type_(type) {
     CHECK_NE(EVENT_REWRITE_DISPATCH_ANOTHER, status);
   }
 
-  virtual EventRewriteStatus RewriteEvent(const Event& event,
-                                          scoped_ptr<Event>* rewritten_event)
-      override {
+  EventRewriteStatus RewriteEvent(const Event& event,
+                                  scoped_ptr<Event>* rewritten_event) override {
     if (status_ == EVENT_REWRITE_REWRITTEN)
       rewritten_event->reset(new TestEvent(type_));
     return status_;
   }
-  virtual EventRewriteStatus NextDispatchEvent(const Event& last_event,
-                                               scoped_ptr<Event>* new_event)
-      override {
+  EventRewriteStatus NextDispatchEvent(const Event& last_event,
+                                       scoped_ptr<Event>* new_event) override {
     NOTREACHED();
     return status_;
   }
 
  private:
   EventRewriteStatus status_;
   EventType type_;
 };
 
 // This EventRewriter runs a simple state machine; it is used to test
 // EVENT_REWRITE_DISPATCH_ANOTHER.
 class TestStateMachineEventRewriter : public EventRewriter {
  public:
   TestStateMachineEventRewriter() : last_rewritten_event_(0), state_(0) {}
   void AddRule(int from_state, EventType from_type,
                int to_state, EventType to_type, EventRewriteStatus to_status) {
     RewriteResult r = {to_state, to_type, to_status};
     rules_.insert(std::pair<RewriteCase, RewriteResult>(
         RewriteCase(from_state, from_type), r));
   }
-  virtual EventRewriteStatus RewriteEvent(const Event& event,
-                                          scoped_ptr<Event>* rewritten_event)
-      override {
+  EventRewriteStatus RewriteEvent(const Event& event,
+                                  scoped_ptr<Event>* rewritten_event) override {
     RewriteRules::iterator find =
         rules_.find(RewriteCase(state_, event.type()));
     if (find == rules_.end())
       return EVENT_REWRITE_CONTINUE;
     if ((find->second.status == EVENT_REWRITE_REWRITTEN) ||
         (find->second.status == EVENT_REWRITE_DISPATCH_ANOTHER)) {
       last_rewritten_event_ = new TestEvent(find->second.type);
       rewritten_event->reset(last_rewritten_event_);
     } else {
       last_rewritten_event_ = 0;
     }
     state_ = find->second.state;
     return find->second.status;
   }
-  virtual EventRewriteStatus NextDispatchEvent(const Event& last_event,
-                                               scoped_ptr<Event>* new_event)
-      override {
+  EventRewriteStatus NextDispatchEvent(const Event& last_event,
+                                       scoped_ptr<Event>* new_event) override {
     EXPECT_TRUE(last_rewritten_event_);
     const TestEvent* arg_last = static_cast<const TestEvent*>(&last_event);
     EXPECT_EQ(last_rewritten_event_->unique_id(), arg_last->unique_id());
     const TestEvent* arg_new = static_cast<const TestEvent*>(new_event->get());
     EXPECT_FALSE(arg_new && arg_last->unique_id() == arg_new->unique_id());
     return RewriteEvent(last_event, new_event);
   }
 
  private:
   typedef std::pair<int, EventType> RewriteCase;
@@ skipping 76 matching lines @@
   s.RemoveEventRewriter(&r3);
 
   // Continue with the state-based rewriting.
   p.AddExpectedEvent(ET_MOUSE_RELEASED);
   p.AddExpectedEvent(ET_KEY_RELEASED);
   s.Send(ET_MOUSE_RELEASED);
   p.CheckAllReceived();
 }
 
 }  // namespace ui