Standardize usage of virtual/override/final in mojo/

mojo/public/cpp/bindings/tests/sample_service_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 <algorithm>
 #include <ostream>
 #include <string>
 
 #include "mojo/public/cpp/environment/environment.h"
 #include "mojo/public/cpp/system/macros.h"
@@ skipping 238 matching lines @@
 
     if (i % 2 == 1)
       std::cout << " ";
     if (i % 8 == 7)
       std::cout << " ";
   }
 }
 
 class ServiceImpl : public Service {
  public:
-  virtual void Frobinate(FooPtr foo, BazOptions baz, PortPtr port) override {
+  void Frobinate(FooPtr foo, BazOptions baz, PortPtr port) override {
     // Users code goes here to handle the incoming Frobinate message.
 
     // We mainly check that we're given the expected arguments.
     EXPECT_FALSE(foo.is_null());
     if (!foo.is_null())
       CheckFoo(*foo);
     EXPECT_EQ(BAZ_OPTIONS_EXTRA, baz);
 
     if (g_dump_message_as_text) {
       // Also dump the Foo structure and all of its members.
       std::cout << "Frobinate:" << std::endl;
       int depth = 1;
       Print(depth, "foo", foo);
       Print(depth, "baz", baz);
       Print(depth, "port", port.get());
     }
   }
 
-  virtual void GetPort(mojo::InterfaceRequest<Port> port_request) override {}
+  void GetPort(mojo::InterfaceRequest<Port> port_request) override {}
 };
 
 class ServiceProxyImpl : public ServiceProxy {
  public:
   explicit ServiceProxyImpl(mojo::MessageReceiverWithResponder* receiver)
       : ServiceProxy(receiver) {}
 };
 
 class SimpleMessageReceiver : public mojo::MessageReceiverWithResponder {
  public:
-  virtual bool Accept(mojo::Message* message) override {
+  bool Accept(mojo::Message* message) override {
     // Imagine some IPC happened here.
 
     if (g_dump_message_as_hex) {
       DumpHex(reinterpret_cast<const uint8_t*>(message->data()),
               message->data_num_bytes());
     }
 
     // In the receiving process, an implementation of ServiceStub is known to
     // the system. It receives the incoming message.
     ServiceImpl impl;
 
     ServiceStub stub;
     stub.set_sink(&impl);
     return stub.Accept(message);
   }
 
-  virtual bool AcceptWithResponder(mojo::Message* message,
-                                   mojo::MessageReceiver* responder) override {
+  bool AcceptWithResponder(mojo::Message* message,
+                           mojo::MessageReceiver* responder) override {
     return false;
   }
 };
 
 class BindingsSampleTest : public testing::Test {
  public:
   BindingsSampleTest() {}
   virtual ~BindingsSampleTest() {}
 
  private:
@@ skipping 50 matching lines @@
   ASSERT_FALSE(defaults->a22.is_null());
   EXPECT_EQ(imported::SHAPE_RECTANGLE, defaults->a22->shape);
   EXPECT_EQ(imported::COLOR_BLACK, defaults->a22->color);
   EXPECT_EQ(0xFFFFFFFFFFFFFFFFULL, defaults->a23);
   EXPECT_EQ(0x123456789, defaults->a24);
   EXPECT_EQ(-0x123456789, defaults->a25);
 }
 
 }  // namespace
 }  // namespace sample