Standardize usage of virtual/override/final in media/

media/midi/midi_manager_usb_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_usb.h"
 
 #include <string>
 
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
@@ skipping 25 matching lines @@
 
  private:
   std::string log_;
 
   DISALLOW_COPY_AND_ASSIGN(Logger);
 };
 
 class FakeUsbMidiDevice : public UsbMidiDevice {
  public:
   explicit FakeUsbMidiDevice(Logger* logger) : logger_(logger) {}
-  virtual ~FakeUsbMidiDevice() {}
+  ~FakeUsbMidiDevice() override {}
 
-  virtual std::vector<uint8> GetDescriptor() override {
+  std::vector<uint8> GetDescriptor() override {
     logger_->AddLog("UsbMidiDevice::GetDescriptor\n");
     return descriptor_;
   }
 
-  virtual void Send(int endpoint_number,
-                    const std::vector<uint8>& data) override {
+  void Send(int endpoint_number, const std::vector<uint8>& data) override {
     logger_->AddLog("UsbMidiDevice::Send ");
     logger_->AddLog(base::StringPrintf("endpoint = %d data =",
                                        endpoint_number));
     for (size_t i = 0; i < data.size(); ++i)
       logger_->AddLog(base::StringPrintf(" 0x%02x", data[i]));
     logger_->AddLog("\n");
   }
 
   void SetDescriptor(const std::vector<uint8> descriptor) {
     descriptor_ = descriptor;
   }
 
  private:
   std::vector<uint8> descriptor_;
   Logger* logger_;
 
   DISALLOW_COPY_AND_ASSIGN(FakeUsbMidiDevice);
 };
 
 class FakeMidiManagerClient : public MidiManagerClient {
  public:
   explicit FakeMidiManagerClient(Logger* logger)
       : complete_start_session_(false),
         result_(MIDI_NOT_SUPPORTED),
         logger_(logger) {}
-  virtual ~FakeMidiManagerClient() {}
+  ~FakeMidiManagerClient() override {}
 
-  virtual void CompleteStartSession(int client_id, MidiResult result) override {
+  void CompleteStartSession(int client_id, MidiResult result) override {
     complete_start_session_ = true;
     result_ = result;
   }
 
-  virtual void ReceiveMidiData(uint32 port_index,
-                               const uint8* data,
-                               size_t size,
-                               double timestamp) override {
+  void ReceiveMidiData(uint32 port_index,
+                       const uint8* data,
+                       size_t size,
+                       double timestamp) override {
     logger_->AddLog("MidiManagerClient::ReceiveMidiData ");
     logger_->AddLog(base::StringPrintf("port_index = %d data =", port_index));
     for (size_t i = 0; i < size; ++i)
       logger_->AddLog(base::StringPrintf(" 0x%02x", data[i]));
     logger_->AddLog("\n");
   }
 
-  virtual void AccumulateMidiBytesSent(size_t size) override {
+  void AccumulateMidiBytesSent(size_t size) override {
     logger_->AddLog("MidiManagerClient::AccumulateMidiBytesSent ");
     // Windows has no "%zu".
     logger_->AddLog(base::StringPrintf("size = %u\n",
                                        static_cast<unsigned>(size)));
   }
 
   bool complete_start_session_;
   MidiResult result_;
 
  private:
   Logger* logger_;
 
   DISALLOW_COPY_AND_ASSIGN(FakeMidiManagerClient);
 };
 
 class TestUsbMidiDeviceFactory : public UsbMidiDevice::Factory {
  public:
   TestUsbMidiDeviceFactory() {}
-  virtual ~TestUsbMidiDeviceFactory() {}
-  virtual void EnumerateDevices(UsbMidiDeviceDelegate* device,
-                                Callback callback) override {
+  ~TestUsbMidiDeviceFactory() override {}
+  void EnumerateDevices(UsbMidiDeviceDelegate* device,
+                        Callback callback) override {
     callback_ = callback;
   }
 
   Callback callback_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(TestUsbMidiDeviceFactory);
 };
 
 class MidiManagerUsbForTesting : public MidiManagerUsb {
  public:
   explicit MidiManagerUsbForTesting(
       scoped_ptr<UsbMidiDevice::Factory> device_factory)
       : MidiManagerUsb(device_factory.Pass()) {}
-  virtual ~MidiManagerUsbForTesting() {}
+  ~MidiManagerUsbForTesting() override {}
 
   void CallCompleteInitialization(MidiResult result) {
     CompleteInitialization(result);
     base::RunLoop run_loop;
     run_loop.RunUntilIdle();
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MidiManagerUsbForTesting);
 };
@@ skipping 203 matching lines @@
             "data = 0x90 0x45 0x7f\n"
             "MidiManagerClient::ReceiveMidiData port_index = 0 "
             "data = 0xf0 0x00 0x01\n"
             "MidiManagerClient::ReceiveMidiData port_index = 0 data = 0xf7\n",
             logger_.TakeLog());
 }
 
 }  // namespace
 
 }  // namespace media