Standardize usage of virtual/override/final in chrome/renderer/

chrome/renderer/media/cast_rtp_stream.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 "chrome/renderer/media/cast_rtp_stream.h"
 
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/memory/weak_ptr.h"
@@ skipping 242 matching lines @@
   // |expected_natural_size| is the expected dimension of the video frame.
   // |error_callback| is called if video formats don't match.
   CastVideoSink(const blink::WebMediaStreamTrack& track,
                 const gfx::Size& expected_natural_size,
                 const CastRtpStream::ErrorCallback& error_callback)
       : track_(track),
         sink_added_(false),
         expected_natural_size_(expected_natural_size),
         error_callback_(error_callback) {}
 
-  virtual ~CastVideoSink() {
+  ~CastVideoSink() override {
     if (sink_added_)
       RemoveFromVideoTrack(this, track_);
   }
 
   // This static method is used to forward video frames to |frame_input|.
   static void OnVideoFrame(
       // These parameters are already bound when callback is created.
       const gfx::Size& expected_natural_size,
       const CastRtpStream::ErrorCallback& error_callback,
       const scoped_refptr<media::cast::VideoFrameInput> frame_input,
@@ skipping 68 matching lines @@
                 int output_channels,
                 int output_sample_rate)
       : track_(track),
         sink_added_(false),
         error_callback_(error_callback),
         weak_factory_(this),
         output_channels_(output_channels),
         output_sample_rate_(output_sample_rate),
         input_preroll_(0) {}
 
-  virtual ~CastAudioSink() {
+  ~CastAudioSink() override {
     if (sink_added_)
       RemoveFromAudioTrack(this, track_);
   }
 
   // Called on real-time audio thread.
   // content::MediaStreamAudioSink implementation.
-  virtual void OnData(const int16* audio_data,
-                      int sample_rate,
-                      int number_of_channels,
-                      int number_of_frames) override {
+  void OnData(const int16* audio_data,
+              int sample_rate,
+              int number_of_channels,
+              int number_of_frames) override {
     scoped_ptr<media::AudioBus> input_bus;
     if (resampler_) {
       input_bus = ResampleData(
           audio_data, sample_rate, number_of_channels, number_of_frames);
       if (!input_bus)
         return;
     } else {
       input_bus = media::AudioBus::Create(
           number_of_channels, number_of_frames);
       input_bus->FromInterleaved(
@@ skipping 36 matching lines @@
             output_channels_,
             output_sample_rate_ * fifo_input_bus_->frames() / sample_rate));
 
     // Resampler will then call ProvideData() below to fetch data from
     // |input_data_|.
     resampler_->Resample(output_bus->frames(), output_bus.get());
     return output_bus.Pass();
   }
 
   // Called on real-time audio thread.
-  virtual void OnSetFormat(const media::AudioParameters& params) override {
+  void OnSetFormat(const media::AudioParameters& params) override {
     if (params.sample_rate() == output_sample_rate_)
       return;
     fifo_.reset(new media::AudioFifo(
         output_channels_,
         kBufferAudioData * params.frames_per_buffer()));
     fifo_input_bus_ = media::AudioBus::Create(
         params.channels(), params.frames_per_buffer());
     resampler_.reset(new media::MultiChannelResampler(
         output_channels_,
         static_cast<double>(params.sample_rate()) / output_sample_rate_,
@@ skipping 166 matching lines @@
 void CastRtpStream::DidEncounterError(const std::string& message) {
   VLOG(1) << "CastRtpStream::DidEncounterError(" << message << ") = "
           << (IsAudio() ? "audio" : "video");
   // Save the WeakPtr first because the error callback might delete this object.
   base::WeakPtr<CastRtpStream> ptr = weak_factory_.GetWeakPtr();
   error_callback_.Run(message);
   content::RenderThread::Get()->GetMessageLoop()->PostTask(
       FROM_HERE,
       base::Bind(&CastRtpStream::Stop, ptr));
 }