replace OVERRIDE and FINAL with override and 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/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/scoped_vector.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() {}
 
   // MidiManager implementation.
-  virtual void StartInitialization() OVERRIDE {
+  virtual void StartInitialization() override {
     start_initialization_is_called_ = true;
   }
 
   virtual void DispatchSendMidiData(MidiManagerClient* client,
                                     uint32 port_index,
                                     const std::vector<uint8>& data,
-                                    double timestamp) OVERRIDE {}
+                                    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() {}
 
   // MidiManagerClient implementation.
-  virtual void CompleteStartSession(int client_id, MidiResult result) OVERRIDE {
+  virtual 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 {}
+                               size_t size, double timestamp) override {}
+  virtual void AccumulateMidiBytesSent(size_t size) override {}
 
   int client_id() const { return client_id_; }
   MidiResult result() const { return result_; }
 
   MidiResult WaitForResult() {
     base::RunLoop run_loop;
     // CompleteStartSession() is called inside the message loop on the same
     // thread. Protection for |wait_for_result_| is not needed.
     while (wait_for_result_)
       run_loop.RunUntilIdle();
@@ skipping 176 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