diff --git a/audio/channel_send.cc b/audio/channel_send.cc
index 7899cf7108..c16903fa4d 100644
--- a/audio/channel_send.cc
+++ b/audio/channel_send.cc
@@ -410,7 +410,7 @@ class VoERtcpObserver : public RtcpBandwidthObserver {
  public:
   explicit VoERtcpObserver(ChannelSend* owner)
       : owner_(owner), bandwidth_observer_(nullptr) {}
-  virtual ~VoERtcpObserver() {}
+  ~VoERtcpObserver() override {}
 
   void SetBandwidthObserver(RtcpBandwidthObserver* bandwidth_observer) {
     rtc::CritScope lock(&crit_);
diff --git a/modules/audio_device/audio_device_data_observer.cc b/modules/audio_device/audio_device_data_observer.cc
index d9e6cdad62..a8b94d5e73 100644
--- a/modules/audio_device/audio_device_data_observer.cc
+++ b/modules/audio_device/audio_device_data_observer.cc
@@ -28,7 +28,7 @@ class ADMWrapper : public AudioDeviceModule, public AudioTransport {
     auto res = impl_->RegisterAudioCallback(this);
     is_valid_ = (impl_.get() != nullptr) && (res == 0);
   }
-  virtual ~ADMWrapper() {
+  ~ADMWrapper() override {
     audio_transport_ = nullptr;
     observer_ = nullptr;
   }
diff --git a/modules/audio_device/include/test_audio_device.cc b/modules/audio_device/include/test_audio_device.cc
index 98c1612151..3cfb36f56b 100644
--- a/modules/audio_device/include/test_audio_device.cc
+++ b/modules/audio_device/include/test_audio_device.cc
@@ -79,7 +79,7 @@ class TestAudioDeviceModuleImpl
     }
   }
 
-  ~TestAudioDeviceModuleImpl() {
+  ~TestAudioDeviceModuleImpl() override {
     StopPlayout();
     StopRecording();
     if (thread_) {
@@ -91,7 +91,7 @@ class TestAudioDeviceModuleImpl
     }
   }
 
-  int32_t Init() {
+  int32_t Init() override {
     thread_ = absl::make_unique<rtc::PlatformThread>(
         TestAudioDeviceModuleImpl::Run, this, "TestAudioDeviceModuleImpl",
         rtc::kHighPriority);
@@ -99,58 +99,58 @@ class TestAudioDeviceModuleImpl
     return 0;
   }
 
-  int32_t RegisterAudioCallback(AudioTransport* callback) {
+  int32_t RegisterAudioCallback(AudioTransport* callback) override {
     rtc::CritScope cs(&lock_);
     RTC_DCHECK(callback || audio_callback_);
     audio_callback_ = callback;
     return 0;
   }
 
-  int32_t StartPlayout() {
+  int32_t StartPlayout() override {
     rtc::CritScope cs(&lock_);
     RTC_CHECK(renderer_);
     rendering_ = true;
     return 0;
   }
 
-  int32_t StopPlayout() {
+  int32_t StopPlayout() override {
     rtc::CritScope cs(&lock_);
     rendering_ = false;
     return 0;
   }
 
-  int32_t StartRecording() {
+  int32_t StartRecording() override {
     rtc::CritScope cs(&lock_);
     RTC_CHECK(capturer_);
     capturing_ = true;
     return 0;
   }
 
-  int32_t StopRecording() {
+  int32_t StopRecording() override {
     rtc::CritScope cs(&lock_);
     capturing_ = false;
     return 0;
   }
 
-  bool Playing() const {
+  bool Playing() const override {
     rtc::CritScope cs(&lock_);
     return rendering_;
   }
 
-  bool Recording() const {
+  bool Recording() const override {
     rtc::CritScope cs(&lock_);
     return capturing_;
   }
 
   // Blocks until the Renderer refuses to receive data.
   // Returns false if |timeout_ms| passes before that happens.
-  bool WaitForPlayoutEnd(int timeout_ms = rtc::Event::kForever) {
+  bool WaitForPlayoutEnd(int timeout_ms = rtc::Event::kForever) override {
     return done_rendering_.Wait(timeout_ms);
   }
 
   // Blocks until the Recorder stops producing data.
   // Returns false if |timeout_ms| passes before that happens.
-  bool WaitForRecordingEnd(int timeout_ms = rtc::Event::kForever) {
+  bool WaitForRecordingEnd(int timeout_ms = rtc::Event::kForever) override {
     return done_capturing_.Wait(timeout_ms);
   }
 
diff --git a/modules/remote_bitrate_estimator/bwe_simulations.cc b/modules/remote_bitrate_estimator/bwe_simulations.cc
index a1fde94f97..3beaf20ab6 100644
--- a/modules/remote_bitrate_estimator/bwe_simulations.cc
+++ b/modules/remote_bitrate_estimator/bwe_simulations.cc
@@ -36,7 +36,7 @@ class BweSimulation : public BweTest,
  public:
   BweSimulation()
       : BweTest(), random_(Clock::GetRealTimeClock()->TimeInMicroseconds()) {}
-  virtual ~BweSimulation() {}
+  ~BweSimulation() override {}
 
  protected:
   void SetUp() override {
diff --git a/modules/video_coding/utility/simulcast_test_fixture_impl.cc b/modules/video_coding/utility/simulcast_test_fixture_impl.cc
index 781c7d0f71..c65941a930 100644
--- a/modules/video_coding/utility/simulcast_test_fixture_impl.cc
+++ b/modules/video_coding/utility/simulcast_test_fixture_impl.cc
@@ -70,14 +70,14 @@ class SimulcastTestFixtureImpl::TestEncodedImageCallback
     memset(layer_sync_, false, sizeof(layer_sync_));
   }
 
-  ~TestEncodedImageCallback() {
+  ~TestEncodedImageCallback() override {
     delete[] encoded_key_frame_.data();
     delete[] encoded_frame_.data();
   }
 
-  virtual Result OnEncodedImage(const EncodedImage& encoded_image,
-                                const CodecSpecificInfo* codec_specific_info,
-                                const RTPFragmentationHeader* fragmentation) {
+  Result OnEncodedImage(const EncodedImage& encoded_image,
+                        const CodecSpecificInfo* codec_specific_info,
+                        const RTPFragmentationHeader* fragmentation) override {
     bool is_vp8 = (codec_specific_info->codecType == kVideoCodecVP8);
     // Only store the base layer.
     if (encoded_image.SpatialIndex().value_or(0) == 0) {
diff --git a/modules/video_coding/video_coding_impl.cc b/modules/video_coding/video_coding_impl.cc
index 9796e8ccda..2c1d89833e 100644
--- a/modules/video_coding/video_coding_impl.cc
+++ b/modules/video_coding/video_coding_impl.cc
@@ -50,7 +50,7 @@ class VideoCodingModuleImpl : public VideoCodingModule {
         timing_(new VCMTiming(clock)),
         receiver_(clock, timing_.get(), nack_sender, keyframe_request_sender) {}
 
-  virtual ~VideoCodingModuleImpl() {}
+  ~VideoCodingModuleImpl() override {}
 
   int64_t TimeUntilNextProcess() override {
     int64_t receiver_time = receiver_.TimeUntilNextProcess();
diff --git a/sdk/objc/native/src/objc_video_decoder_factory.mm b/sdk/objc/native/src/objc_video_decoder_factory.mm
index f5c53b0f12..c79fb06647 100644
--- a/sdk/objc/native/src/objc_video_decoder_factory.mm
+++ b/sdk/objc/native/src/objc_video_decoder_factory.mm
@@ -37,7 +37,7 @@ class ObjCVideoDecoder : public VideoDecoder {
   ObjCVideoDecoder(id<RTCVideoDecoder> decoder)
       : decoder_(decoder), implementation_name_([decoder implementationName].stdString) {}
 
-  int32_t InitDecode(const VideoCodec *codec_settings, int32_t number_of_cores) {
+  int32_t InitDecode(const VideoCodec *codec_settings, int32_t number_of_cores) override {
     if ([decoder_ respondsToSelector:@selector(startDecodeWithNumberOfCores:)]) {
       return [decoder_ startDecodeWithNumberOfCores:number_of_cores];
     } else {
@@ -52,7 +52,7 @@ class ObjCVideoDecoder : public VideoDecoder {
   int32_t Decode(const EncodedImage &input_image,
                  bool missing_frames,
                  const CodecSpecificInfo *codec_specific_info = NULL,
-                 int64_t render_time_ms = -1) {
+                 int64_t render_time_ms = -1) override {
     RTCEncodedImage *encodedImage =
         [[RTCEncodedImage alloc] initWithNativeEncodedImage:input_image];
 
@@ -73,7 +73,7 @@ class ObjCVideoDecoder : public VideoDecoder {
                renderTimeMs:render_time_ms];
   }
 
-  int32_t RegisterDecodeCompleteCallback(DecodedImageCallback *callback) {
+  int32_t RegisterDecodeCompleteCallback(DecodedImageCallback *callback) override {
     [decoder_ setCallback:^(RTCVideoFrame *frame) {
       const rtc::scoped_refptr<VideoFrameBuffer> buffer =
           new rtc::RefCountedObject<ObjCFrameBuffer>(frame.buffer);
@@ -92,9 +92,9 @@ class ObjCVideoDecoder : public VideoDecoder {
     return WEBRTC_VIDEO_CODEC_OK;
   }
 
-  int32_t Release() { return [decoder_ releaseDecoder]; }
+  int32_t Release() override { return [decoder_ releaseDecoder]; }
 
-  const char *ImplementationName() const { return implementation_name_.c_str(); }
+  const char *ImplementationName() const override { return implementation_name_.c_str(); }
 
  private:
   id<RTCVideoDecoder> decoder_;
diff --git a/sdk/objc/native/src/objc_video_encoder_factory.mm b/sdk/objc/native/src/objc_video_encoder_factory.mm
index ca61c4dc54..bfa76ad430 100644
--- a/sdk/objc/native/src/objc_video_encoder_factory.mm
+++ b/sdk/objc/native/src/objc_video_encoder_factory.mm
@@ -43,13 +43,13 @@ class ObjCVideoEncoder : public VideoEncoder {
 
   int32_t InitEncode(const VideoCodec *codec_settings,
                      int32_t number_of_cores,
-                     size_t max_payload_size) {
+                     size_t max_payload_size) override {
     RTCVideoEncoderSettings *settings =
         [[RTCVideoEncoderSettings alloc] initWithNativeVideoCodec:codec_settings];
     return [encoder_ startEncodeWithSettings:settings numberOfCores:number_of_cores];
   }
 
-  int32_t RegisterEncodeCompleteCallback(EncodedImageCallback *callback) {
+  int32_t RegisterEncodeCompleteCallback(EncodedImageCallback *callback) override {
     [encoder_ setCallback:^BOOL(RTCEncodedImage *_Nonnull frame,
                                 id<RTCCodecSpecificInfo> _Nonnull info,
                                 RTCRtpFragmentationHeader *_Nonnull header) {
@@ -71,11 +71,11 @@ class ObjCVideoEncoder : public VideoEncoder {
     return WEBRTC_VIDEO_CODEC_OK;
   }
 
-  int32_t Release() { return [encoder_ releaseEncoder]; }
+  int32_t Release() override { return [encoder_ releaseEncoder]; }
 
   int32_t Encode(const VideoFrame &frame,
                  const CodecSpecificInfo *codec_specific_info,
-                 const std::vector<FrameType> *frame_types) {
+                 const std::vector<FrameType> *frame_types) override {
     NSMutableArray<NSNumber *> *rtcFrameTypes = [NSMutableArray array];
     for (size_t i = 0; i < frame_types->size(); ++i) {
       [rtcFrameTypes addObject:@(RTCFrameType(frame_types->at(i)))];
@@ -86,11 +86,11 @@ class ObjCVideoEncoder : public VideoEncoder {
                  frameTypes:rtcFrameTypes];
   }
 
-  int32_t SetRates(uint32_t bitrate, uint32_t framerate) {
+  int32_t SetRates(uint32_t bitrate, uint32_t framerate) override {
     return [encoder_ setBitrate:bitrate framerate:framerate];
   }
 
-  VideoEncoder::EncoderInfo GetEncoderInfo() const {
+  VideoEncoder::EncoderInfo GetEncoderInfo() const override {
     EncoderInfo info;
     info.supports_native_handle = true;
     info.implementation_name = implementation_name_;
diff --git a/test/frame_generator.cc b/test/frame_generator.cc
index 68abede9e7..8daeb7137c 100644
--- a/test/frame_generator.cc
+++ b/test/frame_generator.cc
@@ -197,7 +197,7 @@ class YuvFileGenerator : public FrameGenerator {
     RTC_DCHECK_GT(frame_repeat_count, 0);
   }
 
-  virtual ~YuvFileGenerator() {
+  ~YuvFileGenerator() override {
     for (FILE* file : files_)
       fclose(file);
   }
@@ -359,7 +359,7 @@ class ScrollingImageFrameGenerator : public FrameGenerator {
     RTC_DCHECK_GT(scroll_time_ms + pause_time_ms, 0);
   }
 
-  virtual ~ScrollingImageFrameGenerator() {}
+  ~ScrollingImageFrameGenerator() override {}
 
   VideoFrame* NextFrame() override {
     const int64_t kFrameDisplayTime = scroll_time_ + pause_time_;
diff --git a/test/rtp_file_reader.cc b/test/rtp_file_reader.cc
index 203bf3007d..294338a043 100644
--- a/test/rtp_file_reader.cc
+++ b/test/rtp_file_reader.cc
@@ -69,15 +69,15 @@ class RtpFileReaderImpl : public RtpFileReader {
 
 class InterleavedRtpFileReader : public RtpFileReaderImpl {
  public:
-  virtual ~InterleavedRtpFileReader() {
+  ~InterleavedRtpFileReader() override {
     if (file_ != NULL) {
       fclose(file_);
       file_ = NULL;
     }
   }
 
-  virtual bool Init(const std::string& filename,
-                    const std::set<uint32_t>& ssrc_filter) {
+  bool Init(const std::string& filename,
+            const std::set<uint32_t>& ssrc_filter) override {
     file_ = fopen(filename.c_str(), "rb");
     if (file_ == NULL) {
       printf("ERROR: Can't open file: %s\n", filename.c_str());
@@ -85,7 +85,7 @@ class InterleavedRtpFileReader : public RtpFileReaderImpl {
     }
     return true;
   }
-  virtual bool NextPacket(RtpPacket* packet) {
+  bool NextPacket(RtpPacket* packet) override {
     assert(file_ != NULL);
     packet->length = RtpPacket::kMaxPacketBufferSize;
     uint32_t len = 0;
@@ -116,7 +116,7 @@ class InterleavedRtpFileReader : public RtpFileReaderImpl {
 class RtpDumpReader : public RtpFileReaderImpl {
  public:
   RtpDumpReader() : file_(NULL) {}
-  virtual ~RtpDumpReader() {
+  ~RtpDumpReader() override {
     if (file_ != NULL) {
       fclose(file_);
       file_ = NULL;
@@ -255,7 +255,7 @@ class PcapReader : public RtpFileReaderImpl {
         next_packet_it_() {
   }
 
-  virtual ~PcapReader() {
+  ~PcapReader() override {
     if (file_ != NULL) {
       fclose(file_);
       file_ = NULL;
diff --git a/test/rtp_file_writer.cc b/test/rtp_file_writer.cc
index de9f71198e..3d1bfbe62f 100644
--- a/test/rtp_file_writer.cc
+++ b/test/rtp_file_writer.cc
@@ -31,7 +31,7 @@ class RtpDumpWriter : public RtpFileWriter {
     RTC_CHECK(file_ != NULL);
     Init();
   }
-  virtual ~RtpDumpWriter() {
+  ~RtpDumpWriter() override {
     if (file_ != NULL) {
       fclose(file_);
       file_ = NULL;
diff --git a/video/overuse_frame_detector.cc b/video/overuse_frame_detector.cc
index 510d5e0250..e3e6141e1d 100644
--- a/video/overuse_frame_detector.cc
+++ b/video/overuse_frame_detector.cc
@@ -83,7 +83,7 @@ class SendProcessingUsage1 : public OveruseFrameDetector::ProcessingUsage {
         filtered_frame_diff_ms_(new rtc::ExpFilter(kWeightFactorFrameDiff)) {
     Reset();
   }
-  virtual ~SendProcessingUsage1() {}
+  ~SendProcessingUsage1() override {}
 
   void Reset() override {
     frame_timing_.clear();
@@ -226,7 +226,7 @@ class SendProcessingUsage2 : public OveruseFrameDetector::ProcessingUsage {
       : options_(options) {
     Reset();
   }
-  virtual ~SendProcessingUsage2() = default;
+  ~SendProcessingUsage2() override = default;
 
   void Reset() override {
     prev_time_us_ = -1;
diff --git a/video/video_replay.cc b/video/video_replay.cc
index 084abb964a..071df8ce90 100644
--- a/video/video_replay.cc
+++ b/video/video_replay.cc
@@ -186,7 +186,7 @@ class FileRenderPassthrough : public rtc::VideoSinkInterface<VideoFrame> {
                         rtc::VideoSinkInterface<VideoFrame>* renderer)
       : basename_(basename), renderer_(renderer), file_(nullptr), count_(0) {}
 
-  ~FileRenderPassthrough() {
+  ~FileRenderPassthrough() override {
     if (file_)
       fclose(file_);
   }
@@ -219,7 +219,7 @@ class DecoderBitstreamFileWriter : public test::FakeDecoder {
       : file_(fopen(filename, "wb")) {
     RTC_DCHECK(file_);
   }
-  ~DecoderBitstreamFileWriter() { fclose(file_); }
+  ~DecoderBitstreamFileWriter() override { fclose(file_); }
 
   int32_t Decode(const EncodedImage& encoded_frame,
                  bool /* missing_frames */,