replace OVERRIDE and FINAL with override and final in media/

media/cast/test/receiver.cc

 // Copyright 2013 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 <algorithm>
 #include <climits>
 #include <cstdarg>
 #include <cstdio>
 #include <deque>
 #include <map>
@@ skipping 186 matching lines @@
                            video_config.max_frame_rate),
 #if defined(USE_X11)
         render_(0, 0, window_width, window_height, "Cast_receiver"),
 #endif  // defined(USE_X11)
         num_video_frames_processed_(0),
         num_audio_frames_processed_(0),
         currently_playing_audio_frame_start_(-1) {}
 
   virtual ~NaivePlayer() {}
 
-  virtual void Start() OVERRIDE {
+  virtual void Start() override {
     AudioManager::Get()->GetTaskRunner()->PostTask(
         FROM_HERE,
         base::Bind(&NaivePlayer::StartAudioOutputOnAudioManagerThread,
                    base::Unretained(this)));
     // Note: No need to wait for audio polling to start since the push-and-pull
     // mechanism is synchronized via the |audio_playout_queue_|.
     InProcessReceiver::Start();
   }
 
-  virtual void Stop() OVERRIDE {
+  virtual void Stop() override {
     // First, stop audio output to the Chromium audio stack.
     base::WaitableEvent done(false, false);
     DCHECK(!AudioManager::Get()->GetTaskRunner()->BelongsToCurrentThread());
     AudioManager::Get()->GetTaskRunner()->PostTask(
         FROM_HERE,
         base::Bind(&NaivePlayer::StopAudioOutputOnAudioManagerThread,
                    base::Unretained(this),
                    &done));
     done.Wait();
 
@@ skipping 32 matching lines @@
       audio_output_stream_.reset();
     }
     done->Signal();
   }
 
   ////////////////////////////////////////////////////////////////////
   // InProcessReceiver overrides.
 
   virtual void OnVideoFrame(const scoped_refptr<VideoFrame>& video_frame,
                             const base::TimeTicks& playout_time,
-                            bool is_continuous) OVERRIDE {
+                            bool is_continuous) override {
     DCHECK(cast_env()->CurrentlyOn(CastEnvironment::MAIN));
     LOG_IF(WARNING, !is_continuous)
         << "Video: Discontinuity in received frames.";
     video_playout_queue_.push_back(std::make_pair(playout_time, video_frame));
     ScheduleVideoPlayout();
     uint16 frame_no;
     if (media::cast::test::DecodeBarcode(video_frame, &frame_no)) {
       video_play_times_.insert(
           std::pair<uint16, base::TimeTicks>(frame_no, playout_time));
     } else {
       VLOG(2) << "Barcode decode failed!";
     }
   }
 
   virtual void OnAudioFrame(scoped_ptr<AudioBus> audio_frame,
                             const base::TimeTicks& playout_time,
-                            bool is_continuous) OVERRIDE {
+                            bool is_continuous) override {
     DCHECK(cast_env()->CurrentlyOn(CastEnvironment::MAIN));
     LOG_IF(WARNING, !is_continuous)
         << "Audio: Discontinuity in received frames.";
     base::AutoLock auto_lock(audio_lock_);
     uint16 frame_no;
     if (media::cast::DecodeTimestamp(audio_frame->channel(0),
                                      audio_frame->frames(),
                                      &frame_no)) {
       // Since there are lots of audio packets with the same frame_no,
       // we really want to make sure that we get the playout_time from
@@ skipping 12 matching lines @@
         std::make_pair(playout_time, audio_frame.release()));
   }
 
   // End of InProcessReceiver overrides.
   ////////////////////////////////////////////////////////////////////
 
   ////////////////////////////////////////////////////////////////////
   // AudioSourceCallback implementation.
 
   virtual int OnMoreData(AudioBus* dest, uint32 total_bytes_delay)
-      OVERRIDE {
+      override {
     // Note: This method is being invoked by a separate thread unknown to us
     // (i.e., outside of CastEnvironment).
 
     int samples_remaining = dest->frames();
 
     while (samples_remaining > 0) {
       // Get next audio frame ready for playout.
       if (!currently_playing_audio_frame_.get()) {
         base::AutoLock auto_lock(audio_lock_);
 
@@ skipping 39 matching lines @@
       // Note: Only logging underruns after the first frame has been received.
       LOG_IF(WARNING, currently_playing_audio_frame_start_ != -1)
           << "Audio: Playback underrun of " << samples_remaining << " samples!";
       dest->ZeroFramesPartial(dest->frames() - samples_remaining,
                               samples_remaining);
     }
 
     return dest->frames();
   }
 
-  virtual void OnError(AudioOutputStream* stream) OVERRIDE {
+  virtual void OnError(AudioOutputStream* stream) override {
     LOG(ERROR) << "AudioOutputStream reports an error.  "
                << "Playback is unlikely to continue.";
   }
 
   // End of AudioSourceCallback implementation.
   ////////////////////////////////////////////////////////////////////
 
   void ScheduleVideoPlayout() {
     DCHECK(cast_env()->CurrentlyOn(CastEnvironment::MAIN));
 
@@ skipping 201 matching lines @@
                                   audio_config,
                                   video_config,
                                   window_width,
                                   window_height);
   player.Start();
 
   base::MessageLoop().Run();  // Run forever (i.e., until SIGTERM).
   NOTREACHED();
   return 0;
 }