Chromecast: virtual/override cleanup.

chromecast/media/cma/backend/media_pipeline_device_fake.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 "chromecast/media/cma/backend/media_pipeline_device_fake.h"
 
 #include <list>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "chromecast/media/cma/backend/audio_pipeline_device.h"
 #include "chromecast/media/cma/backend/media_clock_device.h"
 #include "chromecast/media/cma/backend/media_component_device.h"
 #include "chromecast/media/cma/backend/video_pipeline_device.h"
 #include "chromecast/media/cma/base/decoder_buffer_base.h"
 #include "media/base/audio_decoder_config.h"
 #include "media/base/buffers.h"
 #include "media/base/video_decoder_config.h"
 
 namespace chromecast {
 namespace media {
 
 class MediaClockDeviceFake : public MediaClockDevice {
  public:
   MediaClockDeviceFake();
-  virtual ~MediaClockDeviceFake();
+  ~MediaClockDeviceFake() override;
 
   // MediaClockDevice implementation.
-  virtual State GetState() const override;
-  virtual bool SetState(State new_state) override;
-  virtual bool ResetTimeline(base::TimeDelta time) override;
-  virtual bool SetRate(float rate) override;
-  virtual base::TimeDelta GetTime() override;
+  State GetState() const override;
+  bool SetState(State new_state) override;
+  bool ResetTimeline(base::TimeDelta time) override;
+  bool SetRate(float rate) override;
+  base::TimeDelta GetTime() override;
 
  private:
   State state_;
 
   // Media time sampled at STC time |stc_|.
   base::TimeDelta media_time_;
   base::TimeTicks stc_;
 
   float rate_;
 
@@ skipping 75 matching lines @@
 namespace {
 
 // Maximum number of frames that can be buffered.
 const size_t kMaxFrameCount = 20;
 
 }  // namespace
 
 class MediaComponentDeviceFake : public MediaComponentDevice {
  public:
   explicit MediaComponentDeviceFake(MediaClockDeviceFake* media_clock_device);
-  virtual ~MediaComponentDeviceFake();
+  ~MediaComponentDeviceFake() override;
 
   // MediaComponentDevice implementation.
-  virtual void SetClient(const Client& client) override;
-  virtual State GetState() const override;
-  virtual bool SetState(State new_state) override;
-  virtual bool SetStartPts(base::TimeDelta time) override;
-  virtual FrameStatus PushFrame(
+  void SetClient(const Client& client) override;
+  State GetState() const override;
+  bool SetState(State new_state) override;
+  bool SetStartPts(base::TimeDelta time) override;
+  FrameStatus PushFrame(
       const scoped_refptr<DecryptContext>& decrypt_context,
       const scoped_refptr<DecoderBufferBase>& buffer,
       const FrameStatusCB& completion_cb) override;
-  virtual base::TimeDelta GetRenderingTime() const override;
-  virtual base::TimeDelta GetRenderingDelay() const override;
-  virtual bool GetStatistics(Statistics* stats) const override;
+  base::TimeDelta GetRenderingTime() const override;
+  base::TimeDelta GetRenderingDelay() const override;
+  bool GetStatistics(Statistics* stats) const override;
 
  private:
   struct FakeDecoderBuffer {
     FakeDecoderBuffer();
     ~FakeDecoderBuffer();
 
     // Buffer size.
     size_t size;
 
     // Presentation timestamp.
@@ skipping 194 matching lines @@
   stats->decoded_bytes = decoded_byte_count_;
   stats->decoded_samples = decoded_frame_count_;
   stats->dropped_samples = 0;
   return true;
 }
 
 
 class AudioPipelineDeviceFake : public AudioPipelineDevice {
  public:
   explicit AudioPipelineDeviceFake(MediaClockDeviceFake* media_clock_device);
-  virtual ~AudioPipelineDeviceFake();
+  ~AudioPipelineDeviceFake() override;
 
   // AudioPipelineDevice implementation.
-  virtual void SetClient(const Client& client) override;
-  virtual State GetState() const override;
-  virtual bool SetState(State new_state) override;
-  virtual bool SetStartPts(base::TimeDelta time) override;
-  virtual FrameStatus PushFrame(
+  void SetClient(const Client& client) override;
+  State GetState() const override;
+  bool SetState(State new_state) override;
+  bool SetStartPts(base::TimeDelta time) override;
+  FrameStatus PushFrame(
       const scoped_refptr<DecryptContext>& decrypt_context,
       const scoped_refptr<DecoderBufferBase>& buffer,
       const FrameStatusCB& completion_cb) override;
-  virtual base::TimeDelta GetRenderingTime() const override;
-  virtual base::TimeDelta GetRenderingDelay() const override;
-  virtual bool SetConfig(const ::media::AudioDecoderConfig& config) override;
-  virtual void SetStreamVolumeMultiplier(float multiplier) override;
-  virtual bool GetStatistics(Statistics* stats) const override;
+  base::TimeDelta GetRenderingTime() const override;
+  base::TimeDelta GetRenderingDelay() const override;
+  bool SetConfig(const ::media::AudioDecoderConfig& config) override;
+  void SetStreamVolumeMultiplier(float multiplier) override;
+  bool GetStatistics(Statistics* stats) const override;
 
  private:
   scoped_ptr<MediaComponentDeviceFake> fake_pipeline_;
 
   ::media::AudioDecoderConfig config_;
 
   DISALLOW_COPY_AND_ASSIGN(AudioPipelineDeviceFake);
 };
 
 AudioPipelineDeviceFake::AudioPipelineDeviceFake(
@@ skipping 60 matching lines @@
 }
 
 bool AudioPipelineDeviceFake::GetStatistics(Statistics* stats) const {
   return fake_pipeline_->GetStatistics(stats);
 }
 
 
 class VideoPipelineDeviceFake : public VideoPipelineDevice {
  public:
   explicit VideoPipelineDeviceFake(MediaClockDeviceFake* media_clock_device);
-  virtual ~VideoPipelineDeviceFake();
+  ~VideoPipelineDeviceFake() override;
 
   // VideoPipelineDevice implementation.
-  virtual void SetClient(const Client& client) override;
-  virtual State GetState() const override;
-  virtual bool SetState(State new_state) override;
-  virtual bool SetStartPts(base::TimeDelta time) override;
-  virtual FrameStatus PushFrame(
+  void SetClient(const Client& client) override;
+  State GetState() const override;
+  bool SetState(State new_state) override;
+  bool SetStartPts(base::TimeDelta time) override;
+  FrameStatus PushFrame(
       const scoped_refptr<DecryptContext>& decrypt_context,
       const scoped_refptr<DecoderBufferBase>& buffer,
       const FrameStatusCB& completion_cb) override;
-  virtual base::TimeDelta GetRenderingTime() const override;
-  virtual base::TimeDelta GetRenderingDelay() const override;
-  virtual void SetVideoClient(const VideoClient& client) override;
-  virtual bool SetConfig(const ::media::VideoDecoderConfig& config) override;
-  virtual bool GetStatistics(Statistics* stats) const override;
+  base::TimeDelta GetRenderingTime() const override;
+  base::TimeDelta GetRenderingDelay() const override;
+  void SetVideoClient(const VideoClient& client) override;
+  bool SetConfig(const ::media::VideoDecoderConfig& config) override;
+  bool GetStatistics(Statistics* stats) const override;
 
  private:
   scoped_ptr<MediaComponentDeviceFake> fake_pipeline_;
 
   ::media::VideoDecoderConfig config_;
 
   DISALLOW_COPY_AND_ASSIGN(VideoPipelineDeviceFake);
 };
 
 VideoPipelineDeviceFake::VideoPipelineDeviceFake(
@@ skipping 81 matching lines @@
 VideoPipelineDevice* MediaPipelineDeviceFake::GetVideoPipelineDevice() const {
   return video_pipeline_device_.get();
 }
 
 MediaClockDevice* MediaPipelineDeviceFake::GetMediaClockDevice() const {
   return media_clock_device_.get();
 }
 
 }  // namespace media
 }  // namespace chromecast