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

content/renderer/media/webrtc_audio_renderer.h

 // Copyright (c) 2012 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.
 
 #ifndef CONTENT_RENDERER_MEDIA_WEBRTC_AUDIO_RENDERER_H_
 #define CONTENT_RENDERER_MEDIA_WEBRTC_AUDIO_RENDERER_H_
 
 #include "base/memory/ref_counted.h"
 #include "base/synchronization/lock.h"
 #include "base/threading/non_thread_safe.h"
@@ skipping 87 matching lines @@
 
   // Accessors to the sink audio parameters.
   int channels() const { return sink_params_.channels(); }
   int sample_rate() const { return sink_params_.sample_rate(); }
   int frames_per_buffer() const { return sink_params_.frames_per_buffer(); }
 
  private:
   // MediaStreamAudioRenderer implementation.  This is private since we want
   // callers to use proxy objects.
   // TODO(tommi): Make the MediaStreamAudioRenderer implementation a pimpl?
-  virtual void Start() override;
-  virtual void Play() override;
-  virtual void Pause() override;
-  virtual void Stop() override;
-  virtual void SetVolume(float volume) override;
-  virtual base::TimeDelta GetCurrentRenderTime() const override;
-  virtual bool IsLocalRenderer() const override;
+  void Start() override;
+  void Play() override;
+  void Pause() override;
+  void Stop() override;
+  void SetVolume(float volume) override;
+  base::TimeDelta GetCurrentRenderTime() const override;
+  bool IsLocalRenderer() const override;
 
   // Called when an audio renderer, either the main or a proxy, starts playing.
   // Here we maintain a reference count of how many renderers are currently
   // playing so that the shared play state of all the streams can be reflected
   // correctly.
   void EnterPlayState();
 
   // Called when an audio renderer, either the main or a proxy, is paused.
   // See EnterPlayState for more details.
   void EnterPauseState();
 
  protected:
-  virtual ~WebRtcAudioRenderer();
+  ~WebRtcAudioRenderer() override;
 
  private:
   enum State {
     UNINITIALIZED,
     PLAYING,
     PAUSED,
   };
 
   // Holds raw pointers to PlaingState objects.  Ownership is managed outside
   // of this type.
   typedef std::vector<PlayingState*> PlayingStates;
   // Maps an audio source to a list of playing states that collectively hold
   // volume information for that source.
   typedef std::map<webrtc::AudioSourceInterface*, PlayingStates>
       SourcePlayingStates;
 
   // Used to DCHECK that we are called on the correct thread.
   base::ThreadChecker thread_checker_;
 
   // Flag to keep track the state of the renderer.
   State state_;
 
   // media::AudioRendererSink::RenderCallback implementation.
   // These two methods are called on the AudioOutputDevice worker thread.
-  virtual int Render(media::AudioBus* audio_bus,
-                     int audio_delay_milliseconds) override;
-  virtual void OnRenderError() override;
+  int Render(media::AudioBus* audio_bus, int audio_delay_milliseconds) override;
+  void OnRenderError() override;
 
   // Called by AudioPullFifo when more data is necessary.
   // This method is called on the AudioOutputDevice worker thread.
   void SourceCallback(int fifo_frame_delay, media::AudioBus* audio_bus);
 
   // Goes through all renderers for the |source| and applies the proper
   // volume scaling for the source based on the volume(s) of the renderer(s).
   void UpdateSourceVolume(webrtc::AudioSourceInterface* source);
 
   // Tracks a playing state.  The state must be playing when this method
@@ skipping 68 matching lines @@
   // Used for triggering new UMA histogram. Counts number of render
   // callbacks modulo |kNumCallbacksBetweenRenderTimeHistograms|.
   int render_callback_count_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(WebRtcAudioRenderer);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_RENDERER_MEDIA_WEBRTC_AUDIO_RENDERER_H_