Standardize usage of virtual/override/final in media/

media/midi/midi_manager_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 "media/midi/midi_manager.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/scoped_vector.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace media {
 
 namespace {
 
 class FakeMidiManager : public MidiManager {
  public:
   FakeMidiManager() : start_initialization_is_called_(false) {}
-  virtual ~FakeMidiManager() {}
+  ~FakeMidiManager() override {}
 
   // MidiManager implementation.
-  virtual void StartInitialization() override {
+  void StartInitialization() override {
     start_initialization_is_called_ = true;
   }
 
-  virtual void DispatchSendMidiData(MidiManagerClient* client,
-                                    uint32 port_index,
-                                    const std::vector<uint8>& data,
-                                    double timestamp) override {}
+  void DispatchSendMidiData(MidiManagerClient* client,
+                            uint32 port_index,
+                            const std::vector<uint8>& data,
+                            double timestamp) override {}
 
   // Utility functions for testing.
   void CallCompleteInitialization(MidiResult result) {
     CompleteInitialization(result);
   }
 
   size_t GetClientCount() const {
     return clients_size_for_testing();
   }
 
   size_t GetPendingClientCount() const {
     return pending_clients_size_for_testing();
   }
 
   bool start_initialization_is_called_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FakeMidiManager);
 };
 
 class FakeMidiManagerClient : public MidiManagerClient {
  public:
   explicit FakeMidiManagerClient(int client_id)
       : client_id_(client_id),
         result_(MIDI_NOT_SUPPORTED),
         wait_for_result_(true) {}
-  virtual ~FakeMidiManagerClient() {}
+  ~FakeMidiManagerClient() override {}
 
   // MidiManagerClient implementation.
-  virtual void CompleteStartSession(int client_id, MidiResult result) override {
+  void CompleteStartSession(int client_id, MidiResult result) override {
     EXPECT_TRUE(wait_for_result_);
     CHECK_EQ(client_id_, client_id);
     result_ = result;
     wait_for_result_ = false;
   }
 
-  virtual void ReceiveMidiData(uint32 port_index, const uint8* data,
-                               size_t size, double timestamp) override {}
-  virtual void AccumulateMidiBytesSent(size_t size) override {}
+  void ReceiveMidiData(uint32 port_index,
+                       const uint8* data,
+                       size_t size,
+                       double timestamp) override {}
+  void AccumulateMidiBytesSent(size_t size) override {}
 
   int client_id() const { return client_id_; }
   MidiResult result() const { return result_; }
 
   MidiResult WaitForResult() {
     while (wait_for_result_) {
       base::RunLoop run_loop;
       run_loop.RunUntilIdle();
     }
     return result();
@@ skipping 175 matching lines @@
   // Temporary until http://crbug.com/371230 is resolved.
   EXPECT_TRUE((result == MIDI_OK) || (result == MIDI_INITIALIZATION_ERROR));
 #else
   EXPECT_EQ(MIDI_OK, result);
 #endif
 }
 
 }  // namespace
 
 }  // namespace media