Standardize usage of virtual/override/final in mojo/

mojo/public/cpp/bindings/tests/router_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 <stdlib.h>
 #include <string.h>
 
 #include "mojo/public/cpp/bindings/lib/message_builder.h"
 #include "mojo/public/cpp/bindings/lib/message_queue.h"
 #include "mojo/public/cpp/bindings/lib/router.h"
@@ skipping 20 matching lines @@
   size_t payload_size = strlen(text) + 1;  // Plus null terminator.
   internal::ResponseMessageBuilder builder(name, payload_size, request_id);
   memcpy(builder.buffer()->Allocate(payload_size), text, payload_size);
   builder.Finish(message);
 }
 
 class MessageAccumulator : public MessageReceiver {
  public:
   explicit MessageAccumulator(internal::MessageQueue* queue) : queue_(queue) {}
 
-  virtual bool Accept(Message* message) override {
+  bool Accept(Message* message) override {
     queue_->Push(message);
     return true;
   }
 
  private:
   internal::MessageQueue* queue_;
 };
 
 class ResponseGenerator : public MessageReceiverWithResponder {
  public:
   ResponseGenerator() {}
 
-  virtual bool Accept(Message* message) override { return false; }
+  bool Accept(Message* message) override { return false; }
 
-  virtual bool AcceptWithResponder(Message* message,
-                                   MessageReceiver* responder) override {
+  bool AcceptWithResponder(Message* message,
+                           MessageReceiver* responder) override {
     EXPECT_TRUE(message->has_flag(internal::kMessageExpectsResponse));
 
     return SendResponse(message->name(), message->request_id(), responder);
   }
 
   bool SendResponse(uint32_t name,
                     uint64_t request_id,
                     MessageReceiver* responder) {
     Message response;
     AllocResponseMessage(name, "world", request_id, &response);
 
     bool result = responder->Accept(&response);
     delete responder;
     return result;
   }
 };
 
 class LazyResponseGenerator : public ResponseGenerator {
  public:
   LazyResponseGenerator() : responder_(nullptr), name_(0), request_id_(0) {}
 
-  virtual ~LazyResponseGenerator() { delete responder_; }
+  ~LazyResponseGenerator() override { delete responder_; }
 
-  virtual bool AcceptWithResponder(Message* message,
-                                   MessageReceiver* responder) override {
+  bool AcceptWithResponder(Message* message,
+                           MessageReceiver* responder) override {
     name_ = message->name();
     request_id_ = message->request_id();
     responder_ = responder;
     return true;
   }
 
   bool has_responder() const { return !!responder_; }
 
   void Complete() {
     SendResponse(name_, request_id_, responder_);
@@ skipping 119 matching lines @@
 
     EXPECT_TRUE(generator.has_responder());
   }
 
   generator.Complete();  // This should end up doing nothing.
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace mojo