Standardize usage of virtual/override/final in media/

media/cast/sender/congestion_control.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.
 
 // The purpose of this file is determine what bitrate to use for mirroring.
 // Ideally this should be as much as possible, without causing any frames to
 // arrive late.
 
 // The current algorithm is to measure how much bandwidth we've been using
 // recently. We also keep track of how much data has been queued up for sending
@@ skipping 11 matching lines @@
 namespace media {
 namespace cast {
 
 class AdaptiveCongestionControl : public CongestionControl {
  public:
   AdaptiveCongestionControl(base::TickClock* clock,
                             uint32 max_bitrate_configured,
                             uint32 min_bitrate_configured,
                             double max_frame_rate);
 
-  virtual ~AdaptiveCongestionControl() override;
+  ~AdaptiveCongestionControl() override;
 
-  virtual void UpdateRtt(base::TimeDelta rtt) override;
+  void UpdateRtt(base::TimeDelta rtt) override;
 
-  virtual void UpdateTargetPlayoutDelay(base::TimeDelta delay) override;
+  void UpdateTargetPlayoutDelay(base::TimeDelta delay) override;
 
   // Called when an encoded frame is sent to the transport.
-  virtual void SendFrameToTransport(uint32 frame_id,
-                                    size_t frame_size,
-                                    base::TimeTicks when) override;
+  void SendFrameToTransport(uint32 frame_id,
+                            size_t frame_size,
+                            base::TimeTicks when) override;
 
   // Called when we receive an ACK for a frame.
-  virtual void AckFrame(uint32 frame_id, base::TimeTicks when) override;
+  void AckFrame(uint32 frame_id, base::TimeTicks when) override;
 
   // Returns the bitrate we should use for the next frame.
-  virtual uint32 GetBitrate(base::TimeTicks playout_time,
-                            base::TimeDelta playout_delay) override;
+  uint32 GetBitrate(base::TimeTicks playout_time,
+                    base::TimeDelta playout_delay) override;
 
  private:
   struct FrameStats {
     FrameStats();
     // Time this frame was sent to the transport.
     base::TimeTicks sent_time;
     // Time this frame was acked.
     base::TimeTicks ack_time;
     // Size of encoded frame in bits.
     size_t frame_size;
@@ skipping 30 matching lines @@
   size_t history_size_;
   size_t acked_bits_in_history_;
   base::TimeDelta dead_time_in_history_;
 
   DISALLOW_COPY_AND_ASSIGN(AdaptiveCongestionControl);
 };
 
 class FixedCongestionControl : public CongestionControl {
  public:
   FixedCongestionControl(uint32 bitrate) : bitrate_(bitrate) {}
-  virtual ~FixedCongestionControl() override {}
+  ~FixedCongestionControl() override {}
 
-  virtual void UpdateRtt(base::TimeDelta rtt) override {
-  }
+  void UpdateRtt(base::TimeDelta rtt) override {}
 
-  virtual void UpdateTargetPlayoutDelay(base::TimeDelta delay) override {
-  }
+  void UpdateTargetPlayoutDelay(base::TimeDelta delay) override {}
 
   // Called when an encoded frame is sent to the transport.
-  virtual void SendFrameToTransport(uint32 frame_id,
-                                    size_t frame_size,
-                                    base::TimeTicks when) override {
-  }
+  void SendFrameToTransport(uint32 frame_id,
+                            size_t frame_size,
+                            base::TimeTicks when) override {}
 
   // Called when we receive an ACK for a frame.
-  virtual void AckFrame(uint32 frame_id, base::TimeTicks when) override {
-  }
+  void AckFrame(uint32 frame_id, base::TimeTicks when) override {}
 
   // Returns the bitrate we should use for the next frame.
-  virtual uint32 GetBitrate(base::TimeTicks playout_time,
-                            base::TimeDelta playout_delay) override {
+  uint32 GetBitrate(base::TimeTicks playout_time,
+                    base::TimeDelta playout_delay) override {
     return bitrate_;
   }
 
  private:
   uint32 bitrate_;
   DISALLOW_COPY_AND_ASSIGN(FixedCongestionControl);
 };
 
 
 CongestionControl* NewAdaptiveCongestionControl(
@@ skipping 204 matching lines @@
   VLOG(3) << " FBR:" << (bits_per_second / 1E6)
           << " EBF:" << empty_buffer_fraction
           << " SBR:" << (safe_bitrate / 1E6);
   bits_per_second = std::max(bits_per_second, min_bitrate_configured_);
   bits_per_second = std::min(bits_per_second, max_bitrate_configured_);
   return bits_per_second;
 }
 
 }  // namespace cast
 }  // namespace media