replace OVERRIDE and FINAL with override and 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 27 matching lines @@
   std::string log_;
 
   DISALLOW_COPY_AND_ASSIGN(Logger);
 };
 
 class FakeUsbMidiDevice : public UsbMidiDevice {
  public:
   explicit FakeUsbMidiDevice(Logger* logger) : logger_(logger) {}
   virtual ~FakeUsbMidiDevice() {}
 
-  virtual std::vector<uint8> GetDescriptor() OVERRIDE {
+  virtual std::vector<uint8> GetDescriptor() override {
     logger_->AddLog("UsbMidiDevice::GetDescriptor\n");
     return descriptor_;
   }
 
   virtual void Send(int endpoint_number,
-                    const std::vector<uint8>& data) OVERRIDE {
+                    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() {}
 
-  virtual void CompleteStartSession(int client_id, MidiResult result) OVERRIDE {
+  virtual 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 {
+                               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 {
+  virtual 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 {
+                                Callback callback) override {
     callback_ = callback;
   }
 
   Callback callback_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(TestUsbMidiDeviceFactory);
 };
 
 class MidiManagerUsbForTesting : public MidiManagerUsb {
@@ skipping 218 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