Standardize usage of virtual/override/final in mojo/

mojo/services/network/udp_socket_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 "base/at_exit.h"
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "mojo/public/cpp/bindings/callback.h"
 #include "mojo/services/public/interfaces/network/network_service.mojom.h"
 #include "mojo/services/public/interfaces/network/udp_socket.mojom.h"
@@ skipping 113 matching lines @@
  public:
   TestCallback() {
     Initialize(new State());
   }
   ~TestCallback() {}
 
   const NetworkErrorPtr& result() const { return result_; }
 
  private:
   struct State: public StateBase {
-    virtual ~State() {}
+    ~State() override {}
 
-    virtual void Run(NetworkErrorPtr result) const override {
+    void Run(NetworkErrorPtr result) const override {
       if (test_callback_) {
         TestCallback* callback = static_cast<TestCallback*>(test_callback_);
         callback->result_ = result.Pass();
       }
       NotifyRun();
     }
   };
 
   NetworkErrorPtr result_;
 };
 
 class TestCallbackWithAddress
     : public TestCallbackBase<Callback<void(NetworkErrorPtr, NetAddressPtr)>> {
  public:
   TestCallbackWithAddress() {
     Initialize(new State());
   }
   ~TestCallbackWithAddress() {}
 
   const NetworkErrorPtr& result() const { return result_; }
   const NetAddressPtr& net_address() const { return net_address_; }
 
  private:
   struct State : public StateBase {
-    virtual ~State() {}
+    ~State() override {}
 
-    virtual void Run(NetworkErrorPtr result,
-                     NetAddressPtr net_address) const override {
+    void Run(NetworkErrorPtr result, NetAddressPtr net_address) const override {
       if (test_callback_) {
         TestCallbackWithAddress* callback =
             static_cast<TestCallbackWithAddress*>(test_callback_);
         callback->result_ = result.Pass();
         callback->net_address_ = net_address.Pass();
       }
       NotifyRun();
     }
   };
 
   NetworkErrorPtr result_;
   NetAddressPtr net_address_;
 };
 
 class TestCallbackWithUint32
     : public TestCallbackBase<Callback<void(uint32_t)>> {
  public:
   TestCallbackWithUint32() : result_(0) {
     Initialize(new State());
   }
   ~TestCallbackWithUint32() {}
 
   uint32_t result() const { return result_; }
 
  private:
   struct State : public StateBase {
-    virtual ~State() {}
+    ~State() override {}
 
-    virtual void Run(uint32_t result) const override {
+    void Run(uint32_t result) const override {
       if (test_callback_) {
         TestCallbackWithUint32* callback =
             static_cast<TestCallbackWithUint32*>(test_callback_);
         callback->result_ = result;
       }
       NotifyRun();
     }
   };
 
   uint32_t result_;
@@ skipping 19 matching lines @@
     NetworkErrorPtr result;
     NetAddressPtr addr;
     Array<uint8_t> data;
   };
 
   class UDPSocketClientImpl : public UDPSocketClient {
    public:
 
     UDPSocketClientImpl() : run_loop_(nullptr), expected_receive_count_(0) {}
 
-    virtual ~UDPSocketClientImpl() {
+    ~UDPSocketClientImpl() override {
       while (!results_.empty()) {
         delete results_.front();
         results_.pop();
       }
     }
 
-    virtual void OnReceived(NetworkErrorPtr result,
-                            NetAddressPtr src_addr,
-                            Array<uint8_t> data) override {
+    void OnReceived(NetworkErrorPtr result,
+                    NetAddressPtr src_addr,
+                    Array<uint8_t> data) override {
       ReceiveResult* entry = new ReceiveResult();
       entry->result = result.Pass();
       entry->addr = src_addr.Pass();
       entry->data = data.Pass();
 
       results_.push(entry);
 
       if (results_.size() == expected_receive_count_ && run_loop_) {
         expected_receive_count_ = 0;
         run_loop_->Quit();
@@ skipping 124 matching lines @@
 
     EXPECT_EQ(static_cast<int>(kDatagramSize), result->result->code);
     EXPECT_TRUE(AreEqualArrays(
         CreateTestMessage(static_cast<uint8_t>(i), kDatagramSize),
         result->data));
   }
 }
 
 }  // namespace service
 }  // namespace mojo