diff --git a/webrtc/modules/audio_coding/codecs/cng/audio_encoder_cng_unittest.cc b/webrtc/modules/audio_coding/codecs/cng/audio_encoder_cng_unittest.cc
index c2a9ce3..03e7ba0 100644
--- a/webrtc/modules/audio_coding/codecs/cng/audio_encoder_cng_unittest.cc
+++ b/webrtc/modules/audio_coding/codecs/cng/audio_encoder_cng_unittest.cc
@@ -46,7 +46,7 @@
     config_.payload_type = kCngPayloadType;
   }
 
-  virtual void TearDown() OVERRIDE {
+  void TearDown() override {
     EXPECT_CALL(*mock_vad_, Die()).Times(1);
     cng_.reset();
     // Don't expect the cng_ object to delete the AudioEncoder object. But it
@@ -407,7 +407,7 @@
   // Override AudioEncoderCngTest::TearDown, since that one expects a call to
   // the destructor of |mock_vad_|. In this case, that object is already
   // deleted.
-  virtual void TearDown() OVERRIDE {
+  void TearDown() override {
     cng_.reset();
     // Don't expect the cng_ object to delete the AudioEncoder object. But it
     // will be deleted with the test fixture. This is why we explicitly delete
diff --git a/webrtc/modules/audio_coding/codecs/cng/include/audio_encoder_cng.h b/webrtc/modules/audio_coding/codecs/cng/include/audio_encoder_cng.h
index 2f51676..1d3c2f3 100644
--- a/webrtc/modules/audio_coding/codecs/cng/include/audio_encoder_cng.h
+++ b/webrtc/modules/audio_coding/codecs/cng/include/audio_encoder_cng.h
@@ -44,22 +44,22 @@
 
   explicit AudioEncoderCng(const Config& config);
 
-  virtual ~AudioEncoderCng();
+  ~AudioEncoderCng() override;
 
-  virtual int SampleRateHz() const OVERRIDE;
-  virtual int NumChannels() const OVERRIDE;
+  int SampleRateHz() const override;
+  int NumChannels() const override;
   int RtpTimestampRateHz() const override;
-  virtual int Num10MsFramesInNextPacket() const OVERRIDE;
-  virtual int Max10MsFramesInAPacket() const OVERRIDE;
+  int Num10MsFramesInNextPacket() const override;
+  int Max10MsFramesInAPacket() const override;
   void SetTargetBitrate(int bits_per_second) override;
   void SetProjectedPacketLossRate(double fraction) override;
 
  protected:
-  virtual void EncodeInternal(uint32_t rtp_timestamp,
-                              const int16_t* audio,
-                              size_t max_encoded_bytes,
-                              uint8_t* encoded,
-                              EncodedInfo* info) OVERRIDE;
+  void EncodeInternal(uint32_t rtp_timestamp,
+                      const int16_t* audio,
+                      size_t max_encoded_bytes,
+                      uint8_t* encoded,
+                      EncodedInfo* info) override;
 
  private:
   // Deleter for use with scoped_ptr. E.g., use as
diff --git a/webrtc/modules/audio_coding/codecs/g711/include/audio_encoder_pcm.h b/webrtc/modules/audio_coding/codecs/g711/include/audio_encoder_pcm.h
index 903b220..3967c5e 100644
--- a/webrtc/modules/audio_coding/codecs/g711/include/audio_encoder_pcm.h
+++ b/webrtc/modules/audio_coding/codecs/g711/include/audio_encoder_pcm.h
@@ -30,21 +30,21 @@
         : frame_size_ms(20), num_channels(1), payload_type(pt) {}
   };
 
-  virtual ~AudioEncoderPcm();
+  ~AudioEncoderPcm() override;
 
-  virtual int SampleRateHz() const OVERRIDE;
-  virtual int NumChannels() const OVERRIDE;
-  virtual int Num10MsFramesInNextPacket() const OVERRIDE;
-  virtual int Max10MsFramesInAPacket() const OVERRIDE;
+  int SampleRateHz() const override;
+  int NumChannels() const override;
+  int Num10MsFramesInNextPacket() const override;
+  int Max10MsFramesInAPacket() const override;
 
  protected:
   AudioEncoderPcm(const Config& config, int sample_rate_hz);
 
-  virtual void EncodeInternal(uint32_t rtp_timestamp,
-                              const int16_t* audio,
-                              size_t max_encoded_bytes,
-                              uint8_t* encoded,
-                              EncodedInfo* info) OVERRIDE;
+  void EncodeInternal(uint32_t rtp_timestamp,
+                      const int16_t* audio,
+                      size_t max_encoded_bytes,
+                      uint8_t* encoded,
+                      EncodedInfo* info) override;
 
   virtual int16_t EncodeCall(const int16_t* audio,
                              size_t input_len,
@@ -70,9 +70,9 @@
       : AudioEncoderPcm(config, kSampleRateHz) {}
 
  protected:
-  virtual int16_t EncodeCall(const int16_t* audio,
-                             size_t input_len,
-                             uint8_t* encoded) OVERRIDE;
+  int16_t EncodeCall(const int16_t* audio,
+                     size_t input_len,
+                     uint8_t* encoded) override;
 
  private:
   static const int kSampleRateHz = 8000;
@@ -88,9 +88,9 @@
       : AudioEncoderPcm(config, kSampleRateHz) {}
 
  protected:
-  virtual int16_t EncodeCall(const int16_t* audio,
-                             size_t input_len,
-                             uint8_t* encoded) OVERRIDE;
+  int16_t EncodeCall(const int16_t* audio,
+                     size_t input_len,
+                     uint8_t* encoded) override;
 
  private:
   static const int kSampleRateHz = 8000;
diff --git a/webrtc/modules/audio_coding/codecs/g722/include/audio_encoder_g722.h b/webrtc/modules/audio_coding/codecs/g722/include/audio_encoder_g722.h
index 65a0d4b..229c06e 100644
--- a/webrtc/modules/audio_coding/codecs/g722/include/audio_encoder_g722.h
+++ b/webrtc/modules/audio_coding/codecs/g722/include/audio_encoder_g722.h
@@ -28,20 +28,20 @@
   };
 
   explicit AudioEncoderG722(const Config& config);
-  virtual ~AudioEncoderG722();
+  ~AudioEncoderG722() override;
 
-  virtual int SampleRateHz() const OVERRIDE;
+  int SampleRateHz() const override;
   int RtpTimestampRateHz() const override;
-  virtual int NumChannels() const OVERRIDE;
-  virtual int Num10MsFramesInNextPacket() const OVERRIDE;
-  virtual int Max10MsFramesInAPacket() const OVERRIDE;
+  int NumChannels() const override;
+  int Num10MsFramesInNextPacket() const override;
+  int Max10MsFramesInAPacket() const override;
 
  protected:
-  virtual void EncodeInternal(uint32_t rtp_timestamp,
-                              const int16_t* audio,
-                              size_t max_encoded_bytes,
-                              uint8_t* encoded,
-                              EncodedInfo* info) OVERRIDE;
+  void EncodeInternal(uint32_t rtp_timestamp,
+                      const int16_t* audio,
+                      size_t max_encoded_bytes,
+                      uint8_t* encoded,
+                      EncodedInfo* info) override;
 
  private:
   // The encoder state for one channel.
diff --git a/webrtc/modules/audio_coding/codecs/ilbc/interface/audio_encoder_ilbc.h b/webrtc/modules/audio_coding/codecs/ilbc/interface/audio_encoder_ilbc.h
index 25c397a..fc3aa0d 100644
--- a/webrtc/modules/audio_coding/codecs/ilbc/interface/audio_encoder_ilbc.h
+++ b/webrtc/modules/audio_coding/codecs/ilbc/interface/audio_encoder_ilbc.h
@@ -29,19 +29,19 @@
   };
 
   explicit AudioEncoderIlbc(const Config& config);
-  virtual ~AudioEncoderIlbc();
+  ~AudioEncoderIlbc() override;
 
-  virtual int SampleRateHz() const OVERRIDE;
-  virtual int NumChannels() const OVERRIDE;
-  virtual int Num10MsFramesInNextPacket() const OVERRIDE;
-  virtual int Max10MsFramesInAPacket() const OVERRIDE;
+  int SampleRateHz() const override;
+  int NumChannels() const override;
+  int Num10MsFramesInNextPacket() const override;
+  int Max10MsFramesInAPacket() const override;
 
  protected:
-  virtual void EncodeInternal(uint32_t rtp_timestamp,
-                              const int16_t* audio,
-                              size_t max_encoded_bytes,
-                              uint8_t* encoded,
-                              EncodedInfo* info) OVERRIDE;
+  void EncodeInternal(uint32_t rtp_timestamp,
+                      const int16_t* audio,
+                      size_t max_encoded_bytes,
+                      uint8_t* encoded,
+                      EncodedInfo* info) override;
 
  private:
   static const int kMaxSamplesPerPacket = 480;
diff --git a/webrtc/modules/audio_coding/codecs/isac/audio_encoder_isac_t.h b/webrtc/modules/audio_coding/codecs/isac/audio_encoder_isac_t.h
index 38d5903..c918eaf 100644
--- a/webrtc/modules/audio_coding/codecs/isac/audio_encoder_isac_t.h
+++ b/webrtc/modules/audio_coding/codecs/isac/audio_encoder_isac_t.h
@@ -66,42 +66,42 @@
 
   explicit AudioEncoderDecoderIsacT(const Config& config);
   explicit AudioEncoderDecoderIsacT(const ConfigAdaptive& config);
-  virtual ~AudioEncoderDecoderIsacT() OVERRIDE;
+  ~AudioEncoderDecoderIsacT() override;
 
   // AudioEncoder public methods.
-  virtual int SampleRateHz() const OVERRIDE;
-  virtual int NumChannels() const OVERRIDE;
-  virtual int Num10MsFramesInNextPacket() const OVERRIDE;
-  virtual int Max10MsFramesInAPacket() const OVERRIDE;
+  int SampleRateHz() const override;
+  int NumChannels() const override;
+  int Num10MsFramesInNextPacket() const override;
+  int Max10MsFramesInAPacket() const override;
 
   // AudioDecoder methods.
-  virtual int Decode(const uint8_t* encoded,
-                     size_t encoded_len,
-                     int sample_rate_hz,
-                     int16_t* decoded,
-                     SpeechType* speech_type) OVERRIDE;
-  virtual int DecodeRedundant(const uint8_t* encoded,
-                              size_t encoded_len,
-                              int sample_rate_hz,
-                              int16_t* decoded,
-                              SpeechType* speech_type) OVERRIDE;
-  virtual bool HasDecodePlc() const OVERRIDE;
-  virtual int DecodePlc(int num_frames, int16_t* decoded) OVERRIDE;
-  virtual int Init() OVERRIDE;
-  virtual int IncomingPacket(const uint8_t* payload,
-                             size_t payload_len,
-                             uint16_t rtp_sequence_number,
-                             uint32_t rtp_timestamp,
-                             uint32_t arrival_timestamp) OVERRIDE;
-  virtual int ErrorCode() OVERRIDE;
+  int Decode(const uint8_t* encoded,
+             size_t encoded_len,
+             int sample_rate_hz,
+             int16_t* decoded,
+             SpeechType* speech_type) override;
+  int DecodeRedundant(const uint8_t* encoded,
+                      size_t encoded_len,
+                      int sample_rate_hz,
+                      int16_t* decoded,
+                      SpeechType* speech_type) override;
+  bool HasDecodePlc() const override;
+  int DecodePlc(int num_frames, int16_t* decoded) override;
+  int Init() override;
+  int IncomingPacket(const uint8_t* payload,
+                     size_t payload_len,
+                     uint16_t rtp_sequence_number,
+                     uint32_t rtp_timestamp,
+                     uint32_t arrival_timestamp) override;
+  int ErrorCode() override;
 
  protected:
   // AudioEncoder protected method.
-  virtual void EncodeInternal(uint32_t rtp_timestamp,
-                              const int16_t* audio,
-                              size_t max_encoded_bytes,
-                              uint8_t* encoded,
-                              EncodedInfo* info) OVERRIDE;
+  void EncodeInternal(uint32_t rtp_timestamp,
+                      const int16_t* audio,
+                      size_t max_encoded_bytes,
+                      uint8_t* encoded,
+                      EncodedInfo* info) override;
 
  private:
   // This value is taken from STREAM_SIZE_MAX_60 for iSAC float (60 ms) and
diff --git a/webrtc/modules/audio_coding/codecs/isac/fix/test/isac_speed_test.cc b/webrtc/modules/audio_coding/codecs/isac/fix/test/isac_speed_test.cc
index d93fae3..bb76257 100644
--- a/webrtc/modules/audio_coding/codecs/isac/fix/test/isac_speed_test.cc
+++ b/webrtc/modules/audio_coding/codecs/isac/fix/test/isac_speed_test.cc
@@ -23,8 +23,8 @@
 class IsacSpeedTest : public AudioCodecSpeedTest {
  protected:
   IsacSpeedTest();
-  virtual void SetUp() OVERRIDE;
-  virtual void TearDown() OVERRIDE;
+  void SetUp() override;
+  void TearDown() override;
   virtual float EncodeABlock(int16_t* in_data, uint8_t* bit_stream,
                              int max_bytes, int* encoded_bytes);
   virtual float DecodeABlock(const uint8_t* bit_stream, int encoded_bytes,
diff --git a/webrtc/modules/audio_coding/codecs/opus/interface/audio_encoder_opus.h b/webrtc/modules/audio_coding/codecs/opus/interface/audio_encoder_opus.h
index 93aca6c..417faf8 100644
--- a/webrtc/modules/audio_coding/codecs/opus/interface/audio_encoder_opus.h
+++ b/webrtc/modules/audio_coding/codecs/opus/interface/audio_encoder_opus.h
@@ -43,23 +43,23 @@
   };
 
   explicit AudioEncoderOpus(const Config& config);
-  virtual ~AudioEncoderOpus() OVERRIDE;
+  ~AudioEncoderOpus() override;
 
-  virtual int SampleRateHz() const OVERRIDE;
-  virtual int NumChannels() const OVERRIDE;
-  virtual int Num10MsFramesInNextPacket() const OVERRIDE;
-  virtual int Max10MsFramesInAPacket() const OVERRIDE;
+  int SampleRateHz() const override;
+  int NumChannels() const override;
+  int Num10MsFramesInNextPacket() const override;
+  int Max10MsFramesInAPacket() const override;
   void SetTargetBitrate(int bits_per_second) override;
   void SetProjectedPacketLossRate(double fraction) override;
   double packet_loss_rate() const { return packet_loss_rate_; }
   ApplicationMode application() const { return application_; }
 
  protected:
-  virtual void EncodeInternal(uint32_t rtp_timestamp,
-                              const int16_t* audio,
-                              size_t max_encoded_bytes,
-                              uint8_t* encoded,
-                              EncodedInfo* info) OVERRIDE;
+  void EncodeInternal(uint32_t rtp_timestamp,
+                      const int16_t* audio,
+                      size_t max_encoded_bytes,
+                      uint8_t* encoded,
+                      EncodedInfo* info) override;
 
  private:
   const int num_10ms_frames_per_packet_;
diff --git a/webrtc/modules/audio_coding/codecs/opus/opus_speed_test.cc b/webrtc/modules/audio_coding/codecs/opus/opus_speed_test.cc
index ebe4a35..b39de49 100644
--- a/webrtc/modules/audio_coding/codecs/opus/opus_speed_test.cc
+++ b/webrtc/modules/audio_coding/codecs/opus/opus_speed_test.cc
@@ -21,8 +21,8 @@
 class OpusSpeedTest : public AudioCodecSpeedTest {
  protected:
   OpusSpeedTest();
-  virtual void SetUp() OVERRIDE;
-  virtual void TearDown() OVERRIDE;
+  void SetUp() override;
+  void TearDown() override;
   virtual float EncodeABlock(int16_t* in_data, uint8_t* bit_stream,
                              int max_bytes, int* encoded_bytes);
   virtual float DecodeABlock(const uint8_t* bit_stream, int encoded_bytes,
diff --git a/webrtc/modules/audio_coding/codecs/pcm16b/include/audio_encoder_pcm16b.h b/webrtc/modules/audio_coding/codecs/pcm16b/include/audio_encoder_pcm16b.h
index a5a040f..99ecd24 100644
--- a/webrtc/modules/audio_coding/codecs/pcm16b/include/audio_encoder_pcm16b.h
+++ b/webrtc/modules/audio_coding/codecs/pcm16b/include/audio_encoder_pcm16b.h
@@ -28,9 +28,9 @@
       : AudioEncoderPcm(config, config.sample_rate_hz) {}
 
  protected:
-  virtual int16_t EncodeCall(const int16_t* audio,
-                             size_t input_len,
-                             uint8_t* encoded) OVERRIDE;
+  int16_t EncodeCall(const int16_t* audio,
+                     size_t input_len,
+                     uint8_t* encoded) override;
 };
 
 }  // namespace webrtc
diff --git a/webrtc/modules/audio_coding/codecs/red/audio_encoder_copy_red.h b/webrtc/modules/audio_coding/codecs/red/audio_encoder_copy_red.h
index beea1cf..39f1615 100644
--- a/webrtc/modules/audio_coding/codecs/red/audio_encoder_copy_red.h
+++ b/webrtc/modules/audio_coding/codecs/red/audio_encoder_copy_red.h
@@ -33,22 +33,22 @@
   // Caller keeps ownership of the AudioEncoder object.
   explicit AudioEncoderCopyRed(const Config& config);
 
-  virtual ~AudioEncoderCopyRed();
+  ~AudioEncoderCopyRed() override;
 
-  virtual int SampleRateHz() const OVERRIDE;
+  int SampleRateHz() const override;
   int RtpTimestampRateHz() const override;
-  virtual int NumChannels() const OVERRIDE;
-  virtual int Num10MsFramesInNextPacket() const OVERRIDE;
-  virtual int Max10MsFramesInAPacket() const OVERRIDE;
+  int NumChannels() const override;
+  int Num10MsFramesInNextPacket() const override;
+  int Max10MsFramesInAPacket() const override;
   void SetTargetBitrate(int bits_per_second) override;
   void SetProjectedPacketLossRate(double fraction) override;
 
  protected:
-  virtual void EncodeInternal(uint32_t rtp_timestamp,
-                              const int16_t* audio,
-                              size_t max_encoded_bytes,
-                              uint8_t* encoded,
-                              EncodedInfo* info) OVERRIDE;
+  void EncodeInternal(uint32_t rtp_timestamp,
+                      const int16_t* audio,
+                      size_t max_encoded_bytes,
+                      uint8_t* encoded,
+                      EncodedInfo* info) override;
 
  private:
   AudioEncoder* speech_encoder_;
diff --git a/webrtc/modules/audio_coding/codecs/red/audio_encoder_copy_red_unittest.cc b/webrtc/modules/audio_coding/codecs/red/audio_encoder_copy_red_unittest.cc
index b3a76a5..ea3ad43 100644
--- a/webrtc/modules/audio_coding/codecs/red/audio_encoder_copy_red_unittest.cc
+++ b/webrtc/modules/audio_coding/codecs/red/audio_encoder_copy_red_unittest.cc
@@ -46,7 +46,7 @@
         .WillRepeatedly(Return(sample_rate_hz_));
   }
 
-  virtual void TearDown() OVERRIDE {
+  void TearDown() override {
     red_.reset();
     // Don't expect the red_ object to delete the AudioEncoder object. But it
     // will be deleted with the test fixture. This is why we explicitly delete
diff --git a/webrtc/modules/audio_coding/main/acm2/acm_receive_test_oldapi.h b/webrtc/modules/audio_coding/main/acm2/acm_receive_test_oldapi.h
index 63c35e4..5e5ff9a 100644
--- a/webrtc/modules/audio_coding/main/acm2/acm_receive_test_oldapi.h
+++ b/webrtc/modules/audio_coding/main/acm2/acm_receive_test_oldapi.h
@@ -75,7 +75,7 @@
       NumOutputChannels exptected_output_channels);
 
  protected:
-  void AfterGetAudio() OVERRIDE;
+  void AfterGetAudio() override;
 
   const int output_freq_hz_1_;
   const int output_freq_hz_2_;
diff --git a/webrtc/modules/audio_coding/main/acm2/acm_receiver_unittest.cc b/webrtc/modules/audio_coding/main/acm2/acm_receiver_unittest.cc
index 2eb1bf9..602c31a 100644
--- a/webrtc/modules/audio_coding/main/acm2/acm_receiver_unittest.cc
+++ b/webrtc/modules/audio_coding/main/acm2/acm_receiver_unittest.cc
@@ -55,7 +55,7 @@
 
   ~AcmReceiverTest() {}
 
-  virtual void SetUp() OVERRIDE {
+  void SetUp() override {
     ASSERT_TRUE(receiver_.get() != NULL);
     ASSERT_TRUE(acm_.get() != NULL);
     for (int n = 0; n < ACMCodecDB::kNumCodecs; n++) {
@@ -72,8 +72,7 @@
     rtp_header_.type.Audio.isCNG = false;
   }
 
-  virtual void TearDown() OVERRIDE {
-  }
+  void TearDown() override {}
 
   void InsertOnePacketOfSilence(int codec_id) {
     CodecInst codec;
@@ -115,13 +114,12 @@
     }
   }
 
-  virtual int32_t SendData(
-      FrameType frame_type,
-      uint8_t payload_type,
-      uint32_t timestamp,
-      const uint8_t* payload_data,
-      size_t payload_len_bytes,
-      const RTPFragmentationHeader* fragmentation) OVERRIDE {
+  int32_t SendData(FrameType frame_type,
+                   uint8_t payload_type,
+                   uint32_t timestamp,
+                   const uint8_t* payload_data,
+                   size_t payload_len_bytes,
+                   const RTPFragmentationHeader* fragmentation) override {
     if (frame_type == kFrameEmpty)
       return 0;
 
diff --git a/webrtc/modules/audio_coding/main/acm2/acm_receiver_unittest_oldapi.cc b/webrtc/modules/audio_coding/main/acm2/acm_receiver_unittest_oldapi.cc
index e9096ff..aeacc06 100644
--- a/webrtc/modules/audio_coding/main/acm2/acm_receiver_unittest_oldapi.cc
+++ b/webrtc/modules/audio_coding/main/acm2/acm_receiver_unittest_oldapi.cc
@@ -54,7 +54,7 @@
 
   ~AcmReceiverTestOldApi() {}
 
-  virtual void SetUp() OVERRIDE {
+  void SetUp() override {
     ASSERT_TRUE(receiver_.get() != NULL);
     ASSERT_TRUE(acm_.get() != NULL);
     for (int n = 0; n < ACMCodecDB::kNumCodecs; n++) {
@@ -75,8 +75,7 @@
     rtp_header_.type.Audio.isCNG = false;
   }
 
-  virtual void TearDown() OVERRIDE {
-  }
+  void TearDown() override {}
 
   void InsertOnePacketOfSilence(int codec_id) {
     CodecInst codec;
@@ -115,13 +114,12 @@
     }
   }
 
-  virtual int SendData(
-      FrameType frame_type,
-      uint8_t payload_type,
-      uint32_t timestamp,
-      const uint8_t* payload_data,
-      size_t payload_len_bytes,
-      const RTPFragmentationHeader* fragmentation) OVERRIDE {
+  int SendData(FrameType frame_type,
+               uint8_t payload_type,
+               uint32_t timestamp,
+               const uint8_t* payload_data,
+               size_t payload_len_bytes,
+               const RTPFragmentationHeader* fragmentation) override {
     if (frame_type == kFrameEmpty)
       return 0;
 
diff --git a/webrtc/modules/audio_coding/main/acm2/acm_send_test.h b/webrtc/modules/audio_coding/main/acm2/acm_send_test.h
index 769a327..4c4db5b 100644
--- a/webrtc/modules/audio_coding/main/acm2/acm_send_test.h
+++ b/webrtc/modules/audio_coding/main/acm2/acm_send_test.h
@@ -41,16 +41,15 @@
   // Returns the next encoded packet. Returns NULL if the test duration was
   // exceeded. Ownership of the packet is handed over to the caller.
   // Inherited from PacketSource.
-  virtual Packet* NextPacket() OVERRIDE;
+  Packet* NextPacket() override;
 
   // Inherited from AudioPacketizationCallback.
-  virtual int32_t SendData(
-      FrameType frame_type,
-      uint8_t payload_type,
-      uint32_t timestamp,
-      const uint8_t* payload_data,
-      size_t payload_len_bytes,
-      const RTPFragmentationHeader* fragmentation) OVERRIDE;
+  int32_t SendData(FrameType frame_type,
+                   uint8_t payload_type,
+                   uint32_t timestamp,
+                   const uint8_t* payload_data,
+                   size_t payload_len_bytes,
+                   const RTPFragmentationHeader* fragmentation) override;
 
  private:
   static const int kBlockSizeMs = 10;
diff --git a/webrtc/modules/audio_coding/main/acm2/acm_send_test_oldapi.h b/webrtc/modules/audio_coding/main/acm2/acm_send_test_oldapi.h
index 05a29df..52cb415 100644
--- a/webrtc/modules/audio_coding/main/acm2/acm_send_test_oldapi.h
+++ b/webrtc/modules/audio_coding/main/acm2/acm_send_test_oldapi.h
@@ -46,13 +46,12 @@
   Packet* NextPacket();
 
   // Inherited from AudioPacketizationCallback.
-  virtual int32_t SendData(
-      FrameType frame_type,
-      uint8_t payload_type,
-      uint32_t timestamp,
-      const uint8_t* payload_data,
-      size_t payload_len_bytes,
-      const RTPFragmentationHeader* fragmentation) OVERRIDE;
+  int32_t SendData(FrameType frame_type,
+                   uint8_t payload_type,
+                   uint32_t timestamp,
+                   const uint8_t* payload_data,
+                   size_t payload_len_bytes,
+                   const RTPFragmentationHeader* fragmentation) override;
 
   AudioCodingModule* acm() { return acm_.get(); }
 
diff --git a/webrtc/modules/audio_coding/main/acm2/audio_coding_module_impl.h b/webrtc/modules/audio_coding/main/acm2/audio_coding_module_impl.h
index 10423a7..ef69ba5 100644
--- a/webrtc/modules/audio_coding/main/acm2/audio_coding_module_impl.h
+++ b/webrtc/modules/audio_coding/main/acm2/audio_coding_module_impl.h
@@ -43,59 +43,58 @@
   //
 
   // Initialize send codec.
-  virtual int InitializeSender() OVERRIDE;
+  int InitializeSender() override;
 
   // Reset send codec.
-  virtual int ResetEncoder() OVERRIDE;
+  int ResetEncoder() override;
 
   // Can be called multiple times for Codec, CNG, RED.
-  virtual int RegisterSendCodec(const CodecInst& send_codec) OVERRIDE;
+  int RegisterSendCodec(const CodecInst& send_codec) override;
 
   // Get current send codec.
-  virtual int SendCodec(CodecInst* current_codec) const OVERRIDE;
+  int SendCodec(CodecInst* current_codec) const override;
 
   // Get current send frequency.
-  virtual int SendFrequency() const OVERRIDE;
+  int SendFrequency() const override;
 
   // Get encode bit-rate.
   // Adaptive rate codecs return their current encode target rate, while other
   // codecs return there long-term average or their fixed rate.
-  virtual int SendBitrate() const OVERRIDE;
+  int SendBitrate() const override;
 
   // Set available bandwidth, inform the encoder about the
   // estimated bandwidth received from the remote party.
-  virtual int SetReceivedEstimatedBandwidth(int bw) OVERRIDE;
+  int SetReceivedEstimatedBandwidth(int bw) override;
 
   // Register a transport callback which will be
   // called to deliver the encoded buffers.
-  virtual int RegisterTransportCallback(
-      AudioPacketizationCallback* transport) OVERRIDE;
+  int RegisterTransportCallback(AudioPacketizationCallback* transport) override;
 
   // Add 10 ms of raw (PCM) audio data to the encoder.
-  virtual int Add10MsData(const AudioFrame& audio_frame) OVERRIDE;
+  int Add10MsData(const AudioFrame& audio_frame) override;
 
   /////////////////////////////////////////
   // (RED) Redundant Coding
   //
 
   // Configure RED status i.e. on/off.
-  virtual int SetREDStatus(bool enable_red) OVERRIDE;
+  int SetREDStatus(bool enable_red) override;
 
   // Get RED status.
-  virtual bool REDStatus() const OVERRIDE;
+  bool REDStatus() const override;
 
   /////////////////////////////////////////
   // (FEC) Forward Error Correction (codec internal)
   //
 
   // Configure FEC status i.e. on/off.
-  virtual int SetCodecFEC(bool enabled_codec_fec) OVERRIDE;
+  int SetCodecFEC(bool enabled_codec_fec) override;
 
   // Get FEC status.
-  virtual bool CodecFEC() const OVERRIDE;
+  bool CodecFEC() const override;
 
   // Set target packet loss rate
-  virtual int SetPacketLossRate(int loss_rate) OVERRIDE;
+  int SetPacketLossRate(int loss_rate) override;
 
   /////////////////////////////////////////
   //   (VAD) Voice Activity Detection
@@ -103,98 +102,97 @@
   //   (CNG) Comfort Noise Generation
   //
 
-  virtual int SetVAD(bool enable_dtx = true,
-                     bool enable_vad = false,
-                     ACMVADMode mode = VADNormal) OVERRIDE;
+  int SetVAD(bool enable_dtx = true,
+             bool enable_vad = false,
+             ACMVADMode mode = VADNormal) override;
 
-  virtual int VAD(bool* dtx_enabled,
-                  bool* vad_enabled,
-                  ACMVADMode* mode) const OVERRIDE;
+  int VAD(bool* dtx_enabled,
+          bool* vad_enabled,
+          ACMVADMode* mode) const override;
 
-  virtual int RegisterVADCallback(ACMVADCallback* vad_callback) OVERRIDE;
+  int RegisterVADCallback(ACMVADCallback* vad_callback) override;
 
   /////////////////////////////////////////
   //   Receiver
   //
 
   // Initialize receiver, resets codec database etc.
-  virtual int InitializeReceiver() OVERRIDE;
+  int InitializeReceiver() override;
 
   // Reset the decoder state.
-  virtual int ResetDecoder() OVERRIDE;
+  int ResetDecoder() override;
 
   // Get current receive frequency.
-  virtual int ReceiveFrequency() const OVERRIDE;
+  int ReceiveFrequency() const override;
 
   // Get current playout frequency.
-  virtual int PlayoutFrequency() const OVERRIDE;
+  int PlayoutFrequency() const override;
 
   // Register possible receive codecs, can be called multiple times,
   // for codecs, CNG, DTMF, RED.
-  virtual int RegisterReceiveCodec(const CodecInst& receive_codec) OVERRIDE;
+  int RegisterReceiveCodec(const CodecInst& receive_codec) override;
 
   // Get current received codec.
-  virtual int ReceiveCodec(CodecInst* current_codec) const OVERRIDE;
+  int ReceiveCodec(CodecInst* current_codec) const override;
 
   // Incoming packet from network parsed and ready for decode.
-  virtual int IncomingPacket(const uint8_t* incoming_payload,
-                             const size_t payload_length,
-                             const WebRtcRTPHeader& rtp_info) OVERRIDE;
+  int IncomingPacket(const uint8_t* incoming_payload,
+                     const size_t payload_length,
+                     const WebRtcRTPHeader& rtp_info) override;
 
   // Incoming payloads, without rtp-info, the rtp-info will be created in ACM.
   // One usage for this API is when pre-encoded files are pushed in ACM.
-  virtual int IncomingPayload(const uint8_t* incoming_payload,
-                              const size_t payload_length,
-                              uint8_t payload_type,
-                              uint32_t timestamp) OVERRIDE;
+  int IncomingPayload(const uint8_t* incoming_payload,
+                      const size_t payload_length,
+                      uint8_t payload_type,
+                      uint32_t timestamp) override;
 
   // Minimum playout delay.
-  virtual int SetMinimumPlayoutDelay(int time_ms) OVERRIDE;
+  int SetMinimumPlayoutDelay(int time_ms) override;
 
   // Maximum playout delay.
-  virtual int SetMaximumPlayoutDelay(int time_ms) OVERRIDE;
+  int SetMaximumPlayoutDelay(int time_ms) override;
 
   // Smallest latency NetEq will maintain.
-  virtual int LeastRequiredDelayMs() const OVERRIDE;
+  int LeastRequiredDelayMs() const override;
 
   // Impose an initial delay on playout. ACM plays silence until |delay_ms|
   // audio is accumulated in NetEq buffer, then starts decoding payloads.
-  virtual int SetInitialPlayoutDelay(int delay_ms) OVERRIDE;
+  int SetInitialPlayoutDelay(int delay_ms) override;
 
   // TODO(turajs): DTMF playout is always activated in NetEq these APIs should
   // be removed, as well as all VoE related APIs and methods.
   //
   // Configure Dtmf playout status i.e on/off playout the incoming outband Dtmf
   // tone.
-  virtual int SetDtmfPlayoutStatus(bool enable) OVERRIDE { return 0; }
+  int SetDtmfPlayoutStatus(bool enable) override { return 0; }
 
   // Get Dtmf playout status.
-  virtual bool DtmfPlayoutStatus() const OVERRIDE { return true; }
+  bool DtmfPlayoutStatus() const override { return true; }
 
   // Estimate the Bandwidth based on the incoming stream, needed
   // for one way audio where the RTCP send the BW estimate.
   // This is also done in the RTP module .
-  virtual int DecoderEstimatedBandwidth() const OVERRIDE;
+  int DecoderEstimatedBandwidth() const override;
 
   // Set playout mode voice, fax.
-  virtual int SetPlayoutMode(AudioPlayoutMode mode) OVERRIDE;
+  int SetPlayoutMode(AudioPlayoutMode mode) override;
 
   // Get playout mode voice, fax.
-  virtual AudioPlayoutMode PlayoutMode() const OVERRIDE;
+  AudioPlayoutMode PlayoutMode() const override;
 
   // Get playout timestamp.
-  virtual int PlayoutTimestamp(uint32_t* timestamp) OVERRIDE;
+  int PlayoutTimestamp(uint32_t* timestamp) override;
 
   // Get 10 milliseconds of raw audio data to play out, and
   // automatic resample to the requested frequency if > 0.
-  virtual int PlayoutData10Ms(int desired_freq_hz,
-                              AudioFrame* audio_frame) OVERRIDE;
+  int PlayoutData10Ms(int desired_freq_hz, AudioFrame* audio_frame) override;
 
   /////////////////////////////////////////
   //   Statistics
   //
 
-  virtual int GetNetworkStatistics(NetworkStatistics* statistics) OVERRIDE;
+  int GetNetworkStatistics(NetworkStatistics* statistics) override;
 
   // GET RED payload for iSAC. The method id called when 'this' ACM is
   // the default ACM.
@@ -204,40 +202,37 @@
                      uint8_t* payload,
                      int16_t* length_bytes);
 
-  virtual int ReplaceInternalDTXWithWebRtc(bool use_webrtc_dtx) OVERRIDE;
+  int ReplaceInternalDTXWithWebRtc(bool use_webrtc_dtx) override;
 
-  virtual int IsInternalDTXReplacedWithWebRtc(bool* uses_webrtc_dtx) OVERRIDE;
+  int IsInternalDTXReplacedWithWebRtc(bool* uses_webrtc_dtx) override;
 
-  virtual int SetISACMaxRate(int max_bit_per_sec) OVERRIDE;
+  int SetISACMaxRate(int max_bit_per_sec) override;
 
-  virtual int SetISACMaxPayloadSize(int max_size_bytes) OVERRIDE;
+  int SetISACMaxPayloadSize(int max_size_bytes) override;
 
-  virtual int ConfigISACBandwidthEstimator(
-      int frame_size_ms,
-      int rate_bit_per_sec,
-      bool enforce_frame_size = false) OVERRIDE;
+  int ConfigISACBandwidthEstimator(int frame_size_ms,
+                                   int rate_bit_per_sec,
+                                   bool enforce_frame_size = false) override;
 
   int SetOpusApplication(OpusApplicationMode application) override;
 
   // If current send codec is Opus, informs it about the maximum playback rate
   // the receiver will render.
-  virtual int SetOpusMaxPlaybackRate(int frequency_hz) OVERRIDE;
+  int SetOpusMaxPlaybackRate(int frequency_hz) override;
 
   int EnableOpusDtx() override;
 
   int DisableOpusDtx() override;
 
-  virtual int UnregisterReceiveCodec(uint8_t payload_type) OVERRIDE;
+  int UnregisterReceiveCodec(uint8_t payload_type) override;
 
-  virtual int EnableNack(size_t max_nack_list_size) OVERRIDE;
+  int EnableNack(size_t max_nack_list_size) override;
 
-  virtual void DisableNack() OVERRIDE;
+  void DisableNack() override;
 
-  virtual std::vector<uint16_t> GetNackList(
-      int64_t round_trip_time_ms) const OVERRIDE;
+  std::vector<uint16_t> GetNackList(int64_t round_trip_time_ms) const override;
 
-  virtual void GetDecodingCallStatistics(
-      AudioDecodingCallStats* stats) const OVERRIDE;
+  void GetDecodingCallStatistics(AudioDecodingCallStats* stats) const override;
 
  private:
   struct InputData {
@@ -372,62 +367,57 @@
     playout_frequency_hz_ = config.playout_frequency_hz;
   }
 
-  virtual ~AudioCodingImpl() OVERRIDE {};
+  ~AudioCodingImpl() override{};
 
-  virtual bool RegisterSendCodec(AudioEncoder* send_codec) OVERRIDE;
+  bool RegisterSendCodec(AudioEncoder* send_codec) override;
 
-  virtual bool RegisterSendCodec(int encoder_type,
-                                 uint8_t payload_type,
-                                 int frame_size_samples = 0) OVERRIDE;
+  bool RegisterSendCodec(int encoder_type,
+                         uint8_t payload_type,
+                         int frame_size_samples = 0) override;
 
-  virtual const AudioEncoder* GetSenderInfo() const OVERRIDE;
+  const AudioEncoder* GetSenderInfo() const override;
 
-  virtual const CodecInst* GetSenderCodecInst() OVERRIDE;
+  const CodecInst* GetSenderCodecInst() override;
 
-  virtual int Add10MsAudio(const AudioFrame& audio_frame) OVERRIDE;
+  int Add10MsAudio(const AudioFrame& audio_frame) override;
 
-  virtual const ReceiverInfo* GetReceiverInfo() const OVERRIDE;
+  const ReceiverInfo* GetReceiverInfo() const override;
 
-  virtual bool RegisterReceiveCodec(AudioDecoder* receive_codec) OVERRIDE;
+  bool RegisterReceiveCodec(AudioDecoder* receive_codec) override;
 
-  virtual bool RegisterReceiveCodec(int decoder_type,
-                                    uint8_t payload_type) OVERRIDE;
+  bool RegisterReceiveCodec(int decoder_type, uint8_t payload_type) override;
 
-  virtual bool InsertPacket(const uint8_t* incoming_payload,
-                            size_t payload_len_bytes,
-                            const WebRtcRTPHeader& rtp_info) OVERRIDE;
+  bool InsertPacket(const uint8_t* incoming_payload,
+                    size_t payload_len_bytes,
+                    const WebRtcRTPHeader& rtp_info) override;
 
-  virtual bool InsertPayload(const uint8_t* incoming_payload,
-                             size_t payload_len_byte,
-                             uint8_t payload_type,
-                             uint32_t timestamp) OVERRIDE;
+  bool InsertPayload(const uint8_t* incoming_payload,
+                     size_t payload_len_byte,
+                     uint8_t payload_type,
+                     uint32_t timestamp) override;
 
-  virtual bool SetMinimumPlayoutDelay(int time_ms) OVERRIDE;
+  bool SetMinimumPlayoutDelay(int time_ms) override;
 
-  virtual bool SetMaximumPlayoutDelay(int time_ms) OVERRIDE;
+  bool SetMaximumPlayoutDelay(int time_ms) override;
 
-  virtual int LeastRequiredDelayMs() const OVERRIDE;
+  int LeastRequiredDelayMs() const override;
 
-  virtual bool PlayoutTimestamp(uint32_t* timestamp) OVERRIDE;
+  bool PlayoutTimestamp(uint32_t* timestamp) override;
 
-  virtual bool Get10MsAudio(AudioFrame* audio_frame) OVERRIDE;
+  bool Get10MsAudio(AudioFrame* audio_frame) override;
 
-  virtual bool GetNetworkStatistics(
-      NetworkStatistics* network_statistics) OVERRIDE;
+  bool GetNetworkStatistics(NetworkStatistics* network_statistics) override;
 
-  virtual bool EnableNack(size_t max_nack_list_size) OVERRIDE;
+  bool EnableNack(size_t max_nack_list_size) override;
 
-  virtual void DisableNack() OVERRIDE;
+  void DisableNack() override;
 
-  virtual bool SetVad(bool enable_dtx,
-                      bool enable_vad,
-                      ACMVADMode vad_mode) OVERRIDE;
+  bool SetVad(bool enable_dtx, bool enable_vad, ACMVADMode vad_mode) override;
 
-  virtual std::vector<uint16_t> GetNackList(
-      int round_trip_time_ms) const OVERRIDE;
+  std::vector<uint16_t> GetNackList(int round_trip_time_ms) const override;
 
-  virtual void GetDecodingCallStatistics(
-      AudioDecodingCallStats* call_stats) const OVERRIDE;
+  void GetDecodingCallStatistics(
+      AudioDecodingCallStats* call_stats) const override;
 
  private:
   // Temporary method to be used during redesign phase.
diff --git a/webrtc/modules/audio_coding/main/acm2/audio_coding_module_unittest.cc b/webrtc/modules/audio_coding/main/acm2/audio_coding_module_unittest.cc
index b37ef9d..8527767 100644
--- a/webrtc/modules/audio_coding/main/acm2/audio_coding_module_unittest.cc
+++ b/webrtc/modules/audio_coding/main/acm2/audio_coding_module_unittest.cc
@@ -81,13 +81,12 @@
       : num_calls_(0),
         crit_sect_(CriticalSectionWrapper::CreateCriticalSection()) {}
 
-  virtual int32_t SendData(
-      FrameType frame_type,
-      uint8_t payload_type,
-      uint32_t timestamp,
-      const uint8_t* payload_data,
-      size_t payload_len_bytes,
-      const RTPFragmentationHeader* fragmentation) OVERRIDE {
+  int32_t SendData(FrameType frame_type,
+                   uint8_t payload_type,
+                   uint32_t timestamp,
+                   const uint8_t* payload_data,
+                   size_t payload_len_bytes,
+                   const RTPFragmentationHeader* fragmentation) override {
     CriticalSectionScoped lock(crit_sect_.get());
     ++num_calls_;
     last_payload_vec_.assign(payload_data, payload_data + payload_len_bytes);
@@ -124,9 +123,9 @@
 
   ~AudioCodingModuleTest() {}
 
-  void TearDown() OVERRIDE {}
+  void TearDown() override {}
 
-  void SetUp() OVERRIDE {
+  void SetUp() override {
     rtp_utility_->Populate(&rtp_header_);
 
     input_frame_.sample_rate_hz_ = kSampleRateHz;
@@ -308,7 +307,7 @@
     config_.clock = fake_clock_.get();
   }
 
-  virtual void SetUp() OVERRIDE {
+  void SetUp() override {
     AudioCodingModuleTest::SetUp();
     CreateAcm();
     StartThreads();
@@ -321,7 +320,7 @@
     ASSERT_TRUE(pull_audio_thread_->Start(thread_id));
   }
 
-  virtual void TearDown() OVERRIDE {
+  void TearDown() override {
     AudioCodingModuleTest::TearDown();
     pull_audio_thread_->Stop();
     send_thread_->Stop();
@@ -436,7 +435,7 @@
 
   ~AcmIsacMtTest() {}
 
-  virtual void SetUp() OVERRIDE {
+  void SetUp() override {
     AudioCodingModuleTest::SetUp();
     CreateAcm();
 
@@ -459,7 +458,7 @@
     StartThreads();
   }
 
-  virtual void RegisterCodec() OVERRIDE {
+  void RegisterCodec() override {
     static_assert(kSampleRateHz == 16000, "test designed for iSAC 16 kHz");
 
     // Register iSAC codec in ACM, effectively unregistering the PCM16B codec
@@ -469,7 +468,7 @@
         acm_->RegisterReceiveCodec(acm2::ACMCodecDB::kISAC, kPayloadType));
   }
 
-  virtual void InsertPacket() OVERRIDE {
+  void InsertPacket() override {
     int num_calls = packet_cb_.num_calls();  // Store locally for thread safety.
     if (num_calls > last_packet_number_) {
       // Get the new payload out from the callback handler.
@@ -486,14 +485,14 @@
         &last_payload_vec_[0], last_payload_vec_.size(), rtp_header_));
   }
 
-  virtual void InsertAudio() OVERRIDE {
+  void InsertAudio() override {
     memcpy(input_frame_.data_, audio_loop_.GetNextBlock(), kNumSamples10ms);
     AudioCodingModuleTest::InsertAudio();
   }
 
   // This method is the same as AudioCodingModuleMtTest::TestDone(), but here
   // it is using the constants defined in this class (i.e., shorter test run).
-  virtual bool TestDone() OVERRIDE {
+  bool TestDone() override {
     if (packet_cb_.num_calls() > kNumPackets) {
       CriticalSectionScoped lock(crit_sect_.get());
       if (pull_audio_count_ > kNumPullCalls) {
@@ -708,7 +707,7 @@
   // Returns a pointer to the next packet. Returns NULL if the source is
   // depleted (i.e., the test duration is exceeded), or if an error occurred.
   // Inherited from test::PacketSource.
-  virtual test::Packet* NextPacket() OVERRIDE {
+  test::Packet* NextPacket() override {
     // Get the next packet from AcmSendTest. Ownership of |packet| is
     // transferred to this method.
     test::Packet* packet = send_test_->NextPacket();
diff --git a/webrtc/modules/audio_coding/main/acm2/audio_coding_module_unittest_oldapi.cc b/webrtc/modules/audio_coding/main/acm2/audio_coding_module_unittest_oldapi.cc
index 122d027..14a73fd 100644
--- a/webrtc/modules/audio_coding/main/acm2/audio_coding_module_unittest_oldapi.cc
+++ b/webrtc/modules/audio_coding/main/acm2/audio_coding_module_unittest_oldapi.cc
@@ -86,13 +86,12 @@
         last_payload_type_(-1),
         crit_sect_(CriticalSectionWrapper::CreateCriticalSection()) {}
 
-  virtual int32_t SendData(
-      FrameType frame_type,
-      uint8_t payload_type,
-      uint32_t timestamp,
-      const uint8_t* payload_data,
-      size_t payload_len_bytes,
-      const RTPFragmentationHeader* fragmentation) OVERRIDE {
+  int32_t SendData(FrameType frame_type,
+                   uint8_t payload_type,
+                   uint32_t timestamp,
+                   const uint8_t* payload_data,
+                   size_t payload_len_bytes,
+                   const RTPFragmentationHeader* fragmentation) override {
     CriticalSectionScoped lock(crit_sect_.get());
     ++num_calls_;
     last_frame_type_ = frame_type;
@@ -855,7 +854,7 @@
   // Returns a pointer to the next packet. Returns NULL if the source is
   // depleted (i.e., the test duration is exceeded), or if an error occurred.
   // Inherited from test::PacketSource.
-  test::Packet* NextPacket() OVERRIDE {
+  test::Packet* NextPacket() override {
     // Get the next packet from AcmSendTest. Ownership of |packet| is
     // transferred to this method.
     test::Packet* packet = send_test_->NextPacket();
@@ -1185,7 +1184,7 @@
   }
 
   // Inherited from test::PacketSource.
-  test::Packet* NextPacket() OVERRIDE {
+  test::Packet* NextPacket() override {
     // Check if it is time to terminate the test. The packet source is of type
     // ConstantPcmPacketSource, which is infinite, so we must end the test
     // "manually".
diff --git a/webrtc/modules/audio_coding/main/test/Channel.h b/webrtc/modules/audio_coding/main/test/Channel.h
index 55167d3..c4ad7d1 100644
--- a/webrtc/modules/audio_coding/main/test/Channel.h
+++ b/webrtc/modules/audio_coding/main/test/Channel.h
@@ -50,13 +50,12 @@
   Channel(int16_t chID = -1);
   ~Channel();
 
-  virtual int32_t SendData(
-      FrameType frameType,
-      uint8_t payloadType,
-      uint32_t timeStamp,
-      const uint8_t* payloadData,
-      size_t payloadSize,
-      const RTPFragmentationHeader* fragmentation) OVERRIDE;
+  int32_t SendData(FrameType frameType,
+                   uint8_t payloadType,
+                   uint32_t timeStamp,
+                   const uint8_t* payloadData,
+                   size_t payloadSize,
+                   const RTPFragmentationHeader* fragmentation) override;
 
   void RegisterReceiverACM(AudioCodingModule *acm);
 
diff --git a/webrtc/modules/audio_coding/main/test/EncodeDecodeTest.h b/webrtc/modules/audio_coding/main/test/EncodeDecodeTest.h
index 4ee4fa2..44fb0b2 100644
--- a/webrtc/modules/audio_coding/main/test/EncodeDecodeTest.h
+++ b/webrtc/modules/audio_coding/main/test/EncodeDecodeTest.h
@@ -29,13 +29,12 @@
  public:
   TestPacketization(RTPStream *rtpStream, uint16_t frequency);
   ~TestPacketization();
-  virtual int32_t SendData(
-      const FrameType frameType,
-      const uint8_t payloadType,
-      const uint32_t timeStamp,
-      const uint8_t* payloadData,
-      const size_t payloadSize,
-      const RTPFragmentationHeader* fragmentation) OVERRIDE;
+  int32_t SendData(const FrameType frameType,
+                   const uint8_t payloadType,
+                   const uint32_t timeStamp,
+                   const uint8_t* payloadData,
+                   const size_t payloadSize,
+                   const RTPFragmentationHeader* fragmentation) override;
 
  private:
   static void MakeRTPheader(uint8_t* rtpHeader, uint8_t payloadType,
@@ -103,7 +102,7 @@
  public:
   EncodeDecodeTest();
   explicit EncodeDecodeTest(int testMode);
-  virtual void Perform() OVERRIDE;
+  void Perform() override;
 
   uint16_t _playoutFreq;
   uint8_t _testMode;
diff --git a/webrtc/modules/audio_coding/main/test/PacketLossTest.h b/webrtc/modules/audio_coding/main/test/PacketLossTest.h
index 70fa9ff..d25dea2 100644
--- a/webrtc/modules/audio_coding/main/test/PacketLossTest.h
+++ b/webrtc/modules/audio_coding/main/test/PacketLossTest.h
@@ -23,7 +23,8 @@
   void Setup(AudioCodingModule *acm, RTPStream *rtpStream,
              std::string out_file_name, int channels, int loss_rate,
              int burst_length);
-  bool IncomingPacket() OVERRIDE;
+  bool IncomingPacket() override;
+
  protected:
   bool PacketLost();
   int loss_rate_;
diff --git a/webrtc/modules/audio_coding/main/test/RTPFile.h b/webrtc/modules/audio_coding/main/test/RTPFile.h
index 9a2d43a..346440b 100644
--- a/webrtc/modules/audio_coding/main/test/RTPFile.h
+++ b/webrtc/modules/audio_coding/main/test/RTPFile.h
@@ -65,14 +65,19 @@
 
   ~RTPBuffer();
 
-  virtual void Write(const uint8_t payloadType, const uint32_t timeStamp,
-                     const int16_t seqNo, const uint8_t* payloadData,
-                     const size_t payloadSize, uint32_t frequency) OVERRIDE;
+  void Write(const uint8_t payloadType,
+             const uint32_t timeStamp,
+             const int16_t seqNo,
+             const uint8_t* payloadData,
+             const size_t payloadSize,
+             uint32_t frequency) override;
 
-  virtual size_t Read(WebRtcRTPHeader* rtpInfo, uint8_t* payloadData,
-                      size_t payloadSize, uint32_t* offset) OVERRIDE;
+  size_t Read(WebRtcRTPHeader* rtpInfo,
+              uint8_t* payloadData,
+              size_t payloadSize,
+              uint32_t* offset) override;
 
-  virtual bool EndOfFile() const OVERRIDE;
+  bool EndOfFile() const override;
 
  private:
   RWLockWrapper* _queueRWLock;
@@ -97,16 +102,19 @@
 
   void ReadHeader();
 
-  virtual void Write(const uint8_t payloadType, const uint32_t timeStamp,
-                     const int16_t seqNo, const uint8_t* payloadData,
-                     const size_t payloadSize, uint32_t frequency) OVERRIDE;
+  void Write(const uint8_t payloadType,
+             const uint32_t timeStamp,
+             const int16_t seqNo,
+             const uint8_t* payloadData,
+             const size_t payloadSize,
+             uint32_t frequency) override;
 
-  virtual size_t Read(WebRtcRTPHeader* rtpInfo, uint8_t* payloadData,
-                      size_t payloadSize, uint32_t* offset) OVERRIDE;
+  size_t Read(WebRtcRTPHeader* rtpInfo,
+              uint8_t* payloadData,
+              size_t payloadSize,
+              uint32_t* offset) override;
 
-  virtual bool EndOfFile() const OVERRIDE {
-    return _rtpEOF;
-  }
+  bool EndOfFile() const override { return _rtpEOF; }
 
  private:
   FILE* _rtpFile;
diff --git a/webrtc/modules/audio_coding/main/test/TestAllCodecs.h b/webrtc/modules/audio_coding/main/test/TestAllCodecs.h
index 4292d77..1cdc0cb 100644
--- a/webrtc/modules/audio_coding/main/test/TestAllCodecs.h
+++ b/webrtc/modules/audio_coding/main/test/TestAllCodecs.h
@@ -28,13 +28,12 @@
 
   void RegisterReceiverACM(AudioCodingModule* acm);
 
-  virtual int32_t SendData(
-      FrameType frame_type,
-      uint8_t payload_type,
-      uint32_t timestamp,
-      const uint8_t* payload_data,
-      size_t payload_size,
-      const RTPFragmentationHeader* fragmentation) OVERRIDE;
+  int32_t SendData(FrameType frame_type,
+                   uint8_t payload_type,
+                   uint32_t timestamp,
+                   const uint8_t* payload_data,
+                   size_t payload_size,
+                   const RTPFragmentationHeader* fragmentation) override;
 
   size_t payload_size();
   uint32_t timestamp_diff();
@@ -55,7 +54,7 @@
   explicit TestAllCodecs(int test_mode);
   ~TestAllCodecs();
 
-  virtual void Perform() OVERRIDE;
+  void Perform() override;
 
  private:
   // The default value of '-1' indicates that the registration is based only on
diff --git a/webrtc/modules/audio_coding/main/test/TestStereo.h b/webrtc/modules/audio_coding/main/test/TestStereo.h
index 89914cc..c6412c7 100644
--- a/webrtc/modules/audio_coding/main/test/TestStereo.h
+++ b/webrtc/modules/audio_coding/main/test/TestStereo.h
@@ -35,13 +35,12 @@
 
   void RegisterReceiverACM(AudioCodingModule* acm);
 
-  virtual int32_t SendData(
-      const FrameType frame_type,
-      const uint8_t payload_type,
-      const uint32_t timestamp,
-      const uint8_t* payload_data,
-      const size_t payload_size,
-      const RTPFragmentationHeader* fragmentation) OVERRIDE;
+  int32_t SendData(const FrameType frame_type,
+                   const uint8_t payload_type,
+                   const uint32_t timestamp,
+                   const uint8_t* payload_data,
+                   const size_t payload_size,
+                   const RTPFragmentationHeader* fragmentation) override;
 
   uint16_t payload_size();
   uint32_t timestamp_diff();
@@ -66,7 +65,8 @@
   explicit TestStereo(int test_mode);
   ~TestStereo();
 
-  virtual void Perform() OVERRIDE;
+  void Perform() override;
+
  private:
   // The default value of '-1' indicates that the registration is based only on
   // codec name and a sampling frequncy matching is not required. This is useful
diff --git a/webrtc/modules/audio_coding/neteq/accelerate.h b/webrtc/modules/audio_coding/neteq/accelerate.h
index 2da9993..6e3aa46 100644
--- a/webrtc/modules/audio_coding/neteq/accelerate.h
+++ b/webrtc/modules/audio_coding/neteq/accelerate.h
@@ -49,16 +49,18 @@
  protected:
   // Sets the parameters |best_correlation| and |peak_index| to suitable
   // values when the signal contains no active speech.
-  virtual void SetParametersForPassiveSpeech(size_t len,
-                                             int16_t* best_correlation,
-                                             int* peak_index) const OVERRIDE;
+  void SetParametersForPassiveSpeech(size_t len,
+                                     int16_t* best_correlation,
+                                     int* peak_index) const override;
 
   // Checks the criteria for performing the time-stretching operation and,
   // if possible, performs the time-stretching.
-  virtual ReturnCodes CheckCriteriaAndStretch(
-      const int16_t* input, size_t input_length, size_t peak_index,
-      int16_t best_correlation, bool active_speech,
-      AudioMultiVector* output) const OVERRIDE;
+  ReturnCodes CheckCriteriaAndStretch(const int16_t* input,
+                                      size_t input_length,
+                                      size_t peak_index,
+                                      int16_t best_correlation,
+                                      bool active_speech,
+                                      AudioMultiVector* output) const override;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(Accelerate);
diff --git a/webrtc/modules/audio_coding/neteq/audio_decoder_impl.h b/webrtc/modules/audio_coding/neteq/audio_decoder_impl.h
index 7d36a39..7e80a36 100644
--- a/webrtc/modules/audio_coding/neteq/audio_decoder_impl.h
+++ b/webrtc/modules/audio_coding/neteq/audio_decoder_impl.h
@@ -233,7 +233,7 @@
                              uint32_t rtp_timestamp,
                              uint32_t arrival_timestamp) { return -1; }
 
-  virtual CNG_dec_inst* CngDecoderInstance() OVERRIDE { return dec_state_; }
+  CNG_dec_inst* CngDecoderInstance() override { return dec_state_; }
 
  private:
   CNG_dec_inst* dec_state_;
diff --git a/webrtc/modules/audio_coding/neteq/decision_logic_fax.h b/webrtc/modules/audio_coding/neteq/decision_logic_fax.h
index 01a948f..97c481d 100644
--- a/webrtc/modules/audio_coding/neteq/decision_logic_fax.h
+++ b/webrtc/modules/audio_coding/neteq/decision_logic_fax.h
@@ -47,13 +47,13 @@
   // should be set to true. The output variable |reset_decoder| will be set to
   // true if a reset is required; otherwise it is left unchanged (i.e., it can
   // remain true if it was true before the call).
-  virtual Operations GetDecisionSpecialized(const SyncBuffer& sync_buffer,
-                                            const Expand& expand,
-                                            int decoder_frame_length,
-                                            const RTPHeader* packet_header,
-                                            Modes prev_mode,
-                                            bool play_dtmf,
-                                            bool* reset_decoder) OVERRIDE;
+  Operations GetDecisionSpecialized(const SyncBuffer& sync_buffer,
+                                    const Expand& expand,
+                                    int decoder_frame_length,
+                                    const RTPHeader* packet_header,
+                                    Modes prev_mode,
+                                    bool play_dtmf,
+                                    bool* reset_decoder) override;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(DecisionLogicFax);
diff --git a/webrtc/modules/audio_coding/neteq/neteq_external_decoder_unittest.cc b/webrtc/modules/audio_coding/neteq/neteq_external_decoder_unittest.cc
index 8a382e9..28e901e 100644
--- a/webrtc/modules/audio_coding/neteq/neteq_external_decoder_unittest.cc
+++ b/webrtc/modules/audio_coding/neteq/neteq_external_decoder_unittest.cc
@@ -378,7 +378,7 @@
 
 class ShortTimestampJumpTest : public LargeTimestampJumpTest {
  protected:
-  void UpdateState(NetEqOutputType output_type) OVERRIDE {
+  void UpdateState(NetEqOutputType output_type) override {
     switch (test_state_) {
       case kInitialPhase: {
         if (output_type == kOutputNormal) {
diff --git a/webrtc/modules/audio_coding/neteq/neteq_impl.h b/webrtc/modules/audio_coding/neteq/neteq_impl.h
index b82b43e..ac4689b 100644
--- a/webrtc/modules/audio_coding/neteq/neteq_impl.h
+++ b/webrtc/modules/audio_coding/neteq/neteq_impl.h
@@ -79,10 +79,10 @@
   // of the time when the packet was received, and should be measured with
   // the same tick rate as the RTP timestamp of the current payload.
   // Returns 0 on success, -1 on failure.
-  virtual int InsertPacket(const WebRtcRTPHeader& rtp_header,
-                           const uint8_t* payload,
-                           size_t length_bytes,
-                           uint32_t receive_timestamp) OVERRIDE;
+  int InsertPacket(const WebRtcRTPHeader& rtp_header,
+                   const uint8_t* payload,
+                   size_t length_bytes,
+                   uint32_t receive_timestamp) override;
 
   // Inserts a sync-packet into packet queue. Sync-packets are decoded to
   // silence and are intended to keep AV-sync intact in an event of long packet
@@ -93,8 +93,8 @@
   // type, i.e. they cannot have DTMF or CNG payload type, nor a codec change
   // can be implied by inserting a sync-packet.
   // Returns kOk on success, kFail on failure.
-  virtual int InsertSyncPacket(const WebRtcRTPHeader& rtp_header,
-                               uint32_t receive_timestamp) OVERRIDE;
+  int InsertSyncPacket(const WebRtcRTPHeader& rtp_header,
+                       uint32_t receive_timestamp) override;
 
   // Instructs NetEq to deliver 10 ms of audio data. The data is written to
   // |output_audio|, which can hold (at least) |max_length| elements.
@@ -104,97 +104,98 @@
   // the samples are interleaved.
   // The speech type is written to |type|, if |type| is not NULL.
   // Returns kOK on success, or kFail in case of an error.
-  virtual int GetAudio(size_t max_length, int16_t* output_audio,
-                       int* samples_per_channel, int* num_channels,
-                       NetEqOutputType* type) OVERRIDE;
+  int GetAudio(size_t max_length,
+               int16_t* output_audio,
+               int* samples_per_channel,
+               int* num_channels,
+               NetEqOutputType* type) override;
 
   // Associates |rtp_payload_type| with |codec| and stores the information in
   // the codec database. Returns kOK on success, kFail on failure.
-  virtual int RegisterPayloadType(enum NetEqDecoder codec,
-                                  uint8_t rtp_payload_type) OVERRIDE;
+  int RegisterPayloadType(enum NetEqDecoder codec,
+                          uint8_t rtp_payload_type) override;
 
   // Provides an externally created decoder object |decoder| to insert in the
   // decoder database. The decoder implements a decoder of type |codec| and
   // associates it with |rtp_payload_type|. Returns kOK on success, kFail on
   // failure.
-  virtual int RegisterExternalDecoder(AudioDecoder* decoder,
-                                      enum NetEqDecoder codec,
-                                      uint8_t rtp_payload_type) OVERRIDE;
+  int RegisterExternalDecoder(AudioDecoder* decoder,
+                              enum NetEqDecoder codec,
+                              uint8_t rtp_payload_type) override;
 
   // Removes |rtp_payload_type| from the codec database. Returns 0 on success,
   // -1 on failure.
-  virtual int RemovePayloadType(uint8_t rtp_payload_type) OVERRIDE;
+  int RemovePayloadType(uint8_t rtp_payload_type) override;
 
-  virtual bool SetMinimumDelay(int delay_ms) OVERRIDE;
+  bool SetMinimumDelay(int delay_ms) override;
 
-  virtual bool SetMaximumDelay(int delay_ms) OVERRIDE;
+  bool SetMaximumDelay(int delay_ms) override;
 
-  virtual int LeastRequiredDelayMs() const OVERRIDE;
+  int LeastRequiredDelayMs() const override;
 
-  virtual int SetTargetDelay() OVERRIDE { return kNotImplemented; }
+  int SetTargetDelay() override { return kNotImplemented; }
 
-  virtual int TargetDelay() OVERRIDE { return kNotImplemented; }
+  int TargetDelay() override { return kNotImplemented; }
 
-  virtual int CurrentDelay() OVERRIDE { return kNotImplemented; }
+  int CurrentDelay() override { return kNotImplemented; }
 
   // Sets the playout mode to |mode|.
   // Deprecated.
   // TODO(henrik.lundin) Delete.
-  virtual void SetPlayoutMode(NetEqPlayoutMode mode) OVERRIDE;
+  void SetPlayoutMode(NetEqPlayoutMode mode) override;
 
   // Returns the current playout mode.
   // Deprecated.
   // TODO(henrik.lundin) Delete.
-  virtual NetEqPlayoutMode PlayoutMode() const OVERRIDE;
+  NetEqPlayoutMode PlayoutMode() const override;
 
   // Writes the current network statistics to |stats|. The statistics are reset
   // after the call.
-  virtual int NetworkStatistics(NetEqNetworkStatistics* stats) OVERRIDE;
+  int NetworkStatistics(NetEqNetworkStatistics* stats) override;
 
   // Writes the last packet waiting times (in ms) to |waiting_times|. The number
   // of values written is no more than 100, but may be smaller if the interface
   // is polled again before 100 packets has arrived.
-  virtual void WaitingTimes(std::vector<int>* waiting_times) OVERRIDE;
+  void WaitingTimes(std::vector<int>* waiting_times) override;
 
   // Writes the current RTCP statistics to |stats|. The statistics are reset
   // and a new report period is started with the call.
-  virtual void GetRtcpStatistics(RtcpStatistics* stats) OVERRIDE;
+  void GetRtcpStatistics(RtcpStatistics* stats) override;
 
   // Same as RtcpStatistics(), but does not reset anything.
-  virtual void GetRtcpStatisticsNoReset(RtcpStatistics* stats) OVERRIDE;
+  void GetRtcpStatisticsNoReset(RtcpStatistics* stats) override;
 
   // Enables post-decode VAD. When enabled, GetAudio() will return
   // kOutputVADPassive when the signal contains no speech.
-  virtual void EnableVad() OVERRIDE;
+  void EnableVad() override;
 
   // Disables post-decode VAD.
-  virtual void DisableVad() OVERRIDE;
+  void DisableVad() override;
 
-  virtual bool GetPlayoutTimestamp(uint32_t* timestamp) OVERRIDE;
+  bool GetPlayoutTimestamp(uint32_t* timestamp) override;
 
-  virtual int SetTargetNumberOfChannels() OVERRIDE { return kNotImplemented; }
+  int SetTargetNumberOfChannels() override { return kNotImplemented; }
 
-  virtual int SetTargetSampleRate() OVERRIDE { return kNotImplemented; }
+  int SetTargetSampleRate() override { return kNotImplemented; }
 
   // Returns the error code for the last occurred error. If no error has
   // occurred, 0 is returned.
-  virtual int LastError() const OVERRIDE;
+  int LastError() const override;
 
   // Returns the error code last returned by a decoder (audio or comfort noise).
   // When LastError() returns kDecoderErrorCode or kComfortNoiseErrorCode, check
   // this method to get the decoder's error code.
-  virtual int LastDecoderError() OVERRIDE;
+  int LastDecoderError() override;
 
   // Flushes both the packet buffer and the sync buffer.
-  virtual void FlushBuffers() OVERRIDE;
+  void FlushBuffers() override;
 
-  virtual void PacketBufferStatistics(int* current_num_packets,
-                                      int* max_num_packets) const OVERRIDE;
+  void PacketBufferStatistics(int* current_num_packets,
+                              int* max_num_packets) const override;
 
   // Get sequence number and timestamp of the latest RTP.
   // This method is to facilitate NACK.
-  virtual int DecodedRtpInfo(int* sequence_number,
-                             uint32_t* timestamp) const OVERRIDE;
+  int DecodedRtpInfo(int* sequence_number, uint32_t* timestamp) const override;
 
   // This accessor method is only intended for testing purposes.
   const SyncBuffer* sync_buffer_for_test() const;
diff --git a/webrtc/modules/audio_coding/neteq/test/NETEQTEST_DummyRTPpacket.h b/webrtc/modules/audio_coding/neteq/test/NETEQTEST_DummyRTPpacket.h
index 9f09c94..1ac6c9a 100644
--- a/webrtc/modules/audio_coding/neteq/test/NETEQTEST_DummyRTPpacket.h
+++ b/webrtc/modules/audio_coding/neteq/test/NETEQTEST_DummyRTPpacket.h
@@ -15,9 +15,9 @@
 
 class NETEQTEST_DummyRTPpacket : public NETEQTEST_RTPpacket {
  public:
-  virtual int readFromFile(FILE* fp) OVERRIDE;
-  virtual int writeToFile(FILE* fp) OVERRIDE;
-  virtual void parseHeader() OVERRIDE;
+  int readFromFile(FILE* fp) override;
+  int writeToFile(FILE* fp) override;
+  void parseHeader() override;
 };
 
 #endif  // NETEQTEST_DUMMYRTPPACKET_H
diff --git a/webrtc/modules/audio_coding/neteq/test/neteq_isac_quality_test.cc b/webrtc/modules/audio_coding/neteq/test/neteq_isac_quality_test.cc
index b672a0c..7abf5a1 100644
--- a/webrtc/modules/audio_coding/neteq/test/neteq_isac_quality_test.cc
+++ b/webrtc/modules/audio_coding/neteq/test/neteq_isac_quality_test.cc
@@ -88,8 +88,8 @@
 class NetEqIsacQualityTest : public NetEqQualityTest {
  protected:
   NetEqIsacQualityTest();
-  virtual void SetUp() OVERRIDE;
-  virtual void TearDown() OVERRIDE;
+  void SetUp() override;
+  void TearDown() override;
   virtual int EncodeBlock(int16_t* in_data, int block_size_samples,
                           uint8_t* payload, int max_bytes);
  private:
diff --git a/webrtc/modules/audio_coding/neteq/test/neteq_opus_fec_quality_test.cc b/webrtc/modules/audio_coding/neteq/test/neteq_opus_fec_quality_test.cc
index e1f53af..55ef0c7 100644
--- a/webrtc/modules/audio_coding/neteq/test/neteq_opus_fec_quality_test.cc
+++ b/webrtc/modules/audio_coding/neteq/test/neteq_opus_fec_quality_test.cc
@@ -116,8 +116,8 @@
 class NetEqOpusFecQualityTest : public NetEqQualityTest {
  protected:
   NetEqOpusFecQualityTest();
-  virtual void SetUp() OVERRIDE;
-  virtual void TearDown() OVERRIDE;
+  void SetUp() override;
+  void TearDown() override;
   virtual int EncodeBlock(int16_t* in_data, int block_size_samples,
                           uint8_t* payload, int max_bytes);
  private:
diff --git a/webrtc/modules/audio_coding/neteq/tools/audio_checksum.h b/webrtc/modules/audio_coding/neteq/tools/audio_checksum.h
index 173713a..b4a6a81 100644
--- a/webrtc/modules/audio_coding/neteq/tools/audio_checksum.h
+++ b/webrtc/modules/audio_coding/neteq/tools/audio_checksum.h
@@ -26,7 +26,7 @@
  public:
   AudioChecksum() : finished_(false) {}
 
-  virtual bool WriteArray(const int16_t* audio, size_t num_samples) OVERRIDE {
+  bool WriteArray(const int16_t* audio, size_t num_samples) override {
     if (finished_)
       return false;
 
diff --git a/webrtc/modules/audio_coding/neteq/tools/audio_sink.h b/webrtc/modules/audio_coding/neteq/tools/audio_sink.h
index 474ec1c..b7b3ed1 100644
--- a/webrtc/modules/audio_coding/neteq/tools/audio_sink.h
+++ b/webrtc/modules/audio_coding/neteq/tools/audio_sink.h
@@ -47,7 +47,7 @@
   AudioSinkFork(AudioSink* left, AudioSink* right)
       : left_sink_(left), right_sink_(right) {}
 
-  virtual bool WriteArray(const int16_t* audio, size_t num_samples) OVERRIDE {
+  bool WriteArray(const int16_t* audio, size_t num_samples) override {
     return left_sink_->WriteArray(audio, num_samples) &&
            right_sink_->WriteArray(audio, num_samples);
   }
diff --git a/webrtc/modules/audio_coding/neteq/tools/constant_pcm_packet_source.h b/webrtc/modules/audio_coding/neteq/tools/constant_pcm_packet_source.h
index fcf4f13..b780fbf 100644
--- a/webrtc/modules/audio_coding/neteq/tools/constant_pcm_packet_source.h
+++ b/webrtc/modules/audio_coding/neteq/tools/constant_pcm_packet_source.h
@@ -33,7 +33,7 @@
 
   // Returns a pointer to the next packet. Will never return NULL. That is,
   // the source is infinite.
-  Packet* NextPacket() OVERRIDE;
+  Packet* NextPacket() override;
 
  private:
   void WriteHeader(uint8_t* packet_memory);
diff --git a/webrtc/modules/audio_coding/neteq/tools/neteq_quality_test.h b/webrtc/modules/audio_coding/neteq/tools/neteq_quality_test.h
index 6207fde..cb40b1c 100644
--- a/webrtc/modules/audio_coding/neteq/tools/neteq_quality_test.h
+++ b/webrtc/modules/audio_coding/neteq/tools/neteq_quality_test.h
@@ -33,13 +33,13 @@
 
 class NoLoss : public LossModel {
  public:
-  virtual bool Lost() OVERRIDE;
+  bool Lost() override;
 };
 
 class UniformLoss : public LossModel {
  public:
   UniformLoss(double loss_rate);
-  virtual bool Lost() OVERRIDE;
+  bool Lost() override;
   void set_loss_rate(double loss_rate) { loss_rate_ = loss_rate; }
 
  private:
@@ -49,7 +49,7 @@
 class GilbertElliotLoss : public LossModel {
  public:
   GilbertElliotLoss(double prob_trans_11, double prob_trans_01);
-  virtual bool Lost() OVERRIDE;
+  bool Lost() override;
 
  private:
   // Prob. of losing current packet, when previous packet is lost.
@@ -69,8 +69,8 @@
                    int channels,
                    std::string in_filename,
                    std::string out_filename);
-  virtual void SetUp() OVERRIDE;
-  virtual void TearDown() OVERRIDE;
+  void SetUp() override;
+  void TearDown() override;
 
   // EncodeBlock(...) does the following:
   // 1. encodes a block of audio, saved in |in_data| and has a length of
diff --git a/webrtc/modules/audio_coding/neteq/tools/output_audio_file.h b/webrtc/modules/audio_coding/neteq/tools/output_audio_file.h
index 1d61280..ff30f67 100644
--- a/webrtc/modules/audio_coding/neteq/tools/output_audio_file.h
+++ b/webrtc/modules/audio_coding/neteq/tools/output_audio_file.h
@@ -34,7 +34,7 @@
       fclose(out_file_);
   }
 
-  virtual bool WriteArray(const int16_t* audio, size_t num_samples) OVERRIDE {
+  bool WriteArray(const int16_t* audio, size_t num_samples) override {
     assert(out_file_);
     return fwrite(audio, sizeof(*audio), num_samples, out_file_) == num_samples;
   }
diff --git a/webrtc/modules/audio_coding/neteq/tools/output_wav_file.h b/webrtc/modules/audio_coding/neteq/tools/output_wav_file.h
index 1f72162..1b1ed42 100644
--- a/webrtc/modules/audio_coding/neteq/tools/output_wav_file.h
+++ b/webrtc/modules/audio_coding/neteq/tools/output_wav_file.h
@@ -27,7 +27,7 @@
   OutputWavFile(const std::string& file_name, int sample_rate_hz)
       : wav_writer_(file_name, sample_rate_hz, 1) {}
 
-  virtual bool WriteArray(const int16_t* audio, size_t num_samples) OVERRIDE {
+  bool WriteArray(const int16_t* audio, size_t num_samples) override {
     wav_writer_.WriteSamples(audio, num_samples);
     return true;
   }
diff --git a/webrtc/modules/audio_coding/neteq/tools/rtp_file_source.h b/webrtc/modules/audio_coding/neteq/tools/rtp_file_source.h
index 70b5216..d711685 100644
--- a/webrtc/modules/audio_coding/neteq/tools/rtp_file_source.h
+++ b/webrtc/modules/audio_coding/neteq/tools/rtp_file_source.h
@@ -41,7 +41,7 @@
 
   // Returns a pointer to the next packet. Returns NULL if end of file was
   // reached, or if a the data was corrupt.
-  virtual Packet* NextPacket() OVERRIDE;
+  Packet* NextPacket() override;
 
  private:
   static const int kFirstLineLength = 40;
diff --git a/webrtc/modules/audio_coding/neteq/tools/rtp_generator.h b/webrtc/modules/audio_coding/neteq/tools/rtp_generator.h
index 2280436..e09f6e4 100644
--- a/webrtc/modules/audio_coding/neteq/tools/rtp_generator.h
+++ b/webrtc/modules/audio_coding/neteq/tools/rtp_generator.h
@@ -70,7 +70,7 @@
 
   uint32_t GetRtpHeader(uint8_t payload_type,
                         size_t payload_length_samples,
-                        WebRtcRTPHeader* rtp_header) OVERRIDE;
+                        WebRtcRTPHeader* rtp_header) override;
 
  private:
   uint32_t jump_from_timestamp_;
diff --git a/webrtc/modules/audio_conference_mixer/interface/audio_conference_mixer.h b/webrtc/modules/audio_conference_mixer/interface/audio_conference_mixer.h
index c9cc6ef..b9be6c6 100644
--- a/webrtc/modules/audio_conference_mixer/interface/audio_conference_mixer.h
+++ b/webrtc/modules/audio_conference_mixer/interface/audio_conference_mixer.h
@@ -40,8 +40,8 @@
     virtual ~AudioConferenceMixer() {}
 
     // Module functions
-    virtual int64_t TimeUntilNextProcess() OVERRIDE = 0;
-    virtual int32_t Process() OVERRIDE = 0;
+    int64_t TimeUntilNextProcess() override = 0;
+    int32_t Process() override = 0;
 
     // Register/unregister a callback class for receiving the mixed audio.
     virtual int32_t RegisterMixedStreamCallback(
diff --git a/webrtc/modules/audio_conference_mixer/source/audio_conference_mixer_impl.h b/webrtc/modules/audio_conference_mixer/source/audio_conference_mixer_impl.h
index e3367f2..b1a812a 100644
--- a/webrtc/modules/audio_conference_mixer/source/audio_conference_mixer_impl.h
+++ b/webrtc/modules/audio_conference_mixer/source/audio_conference_mixer_impl.h
@@ -64,26 +64,27 @@
     bool Init();
 
     // Module functions
-    virtual int64_t TimeUntilNextProcess() OVERRIDE;
-    virtual int32_t Process() OVERRIDE;
+    int64_t TimeUntilNextProcess() override;
+    int32_t Process() override;
 
     // AudioConferenceMixer functions
-    virtual int32_t RegisterMixedStreamCallback(
-        AudioMixerOutputReceiver& mixReceiver) OVERRIDE;
-    virtual int32_t UnRegisterMixedStreamCallback() OVERRIDE;
-    virtual int32_t RegisterMixerStatusCallback(
+    int32_t RegisterMixedStreamCallback(
+        AudioMixerOutputReceiver& mixReceiver) override;
+    int32_t UnRegisterMixedStreamCallback() override;
+    int32_t RegisterMixerStatusCallback(
         AudioMixerStatusReceiver& mixerStatusCallback,
-        const uint32_t amountOf10MsBetweenCallbacks) OVERRIDE;
-    virtual int32_t UnRegisterMixerStatusCallback() OVERRIDE;
-    virtual int32_t SetMixabilityStatus(MixerParticipant& participant,
-                                        bool mixable) OVERRIDE;
-    virtual int32_t MixabilityStatus(MixerParticipant& participant,
-                                     bool& mixable) OVERRIDE;
-    virtual int32_t SetMinimumMixingFrequency(Frequency freq) OVERRIDE;
-    virtual int32_t SetAnonymousMixabilityStatus(
-        MixerParticipant& participant, const bool mixable) OVERRIDE;
-    virtual int32_t AnonymousMixabilityStatus(
-        MixerParticipant& participant, bool& mixable) OVERRIDE;
+        const uint32_t amountOf10MsBetweenCallbacks) override;
+    int32_t UnRegisterMixerStatusCallback() override;
+    int32_t SetMixabilityStatus(MixerParticipant& participant,
+                                bool mixable) override;
+    int32_t MixabilityStatus(MixerParticipant& participant,
+                             bool& mixable) override;
+    int32_t SetMinimumMixingFrequency(Frequency freq) override;
+    int32_t SetAnonymousMixabilityStatus(MixerParticipant& participant,
+                                         const bool mixable) override;
+    int32_t AnonymousMixabilityStatus(MixerParticipant& participant,
+                                      bool& mixable) override;
+
 private:
     enum{DEFAULT_AUDIO_FRAME_POOLSIZE = 50};
 
diff --git a/webrtc/modules/audio_device/audio_device_impl.h b/webrtc/modules/audio_device/audio_device_impl.h
index 010d643..294d3ba 100644
--- a/webrtc/modules/audio_device/audio_device_impl.h
+++ b/webrtc/modules/audio_device/audio_device_impl.h
@@ -43,8 +43,8 @@
     virtual ~AudioDeviceModuleImpl();
 
 public: // RefCountedModule
-    virtual int64_t TimeUntilNextProcess() OVERRIDE;
-    virtual int32_t Process() OVERRIDE;
+ int64_t TimeUntilNextProcess() override;
+ int32_t Process() override;
 
 public:
     // Factory methods (resource allocation/deallocation)
@@ -53,155 +53,142 @@
         const AudioLayer audioLayer = kPlatformDefaultAudio);
 
     // Retrieve the currently utilized audio layer
-    virtual int32_t ActiveAudioLayer(AudioLayer* audioLayer) const OVERRIDE;
+    int32_t ActiveAudioLayer(AudioLayer* audioLayer) const override;
 
     // Error handling
-    virtual ErrorCode LastError() const OVERRIDE;
-    virtual int32_t RegisterEventObserver(
-        AudioDeviceObserver* eventCallback) OVERRIDE;
+    ErrorCode LastError() const override;
+    int32_t RegisterEventObserver(AudioDeviceObserver* eventCallback) override;
 
     // Full-duplex transportation of PCM audio
-    virtual int32_t RegisterAudioCallback(
-        AudioTransport* audioCallback) OVERRIDE;
+    int32_t RegisterAudioCallback(AudioTransport* audioCallback) override;
 
     // Main initializaton and termination
-    virtual int32_t Init() OVERRIDE;
-    virtual int32_t Terminate() OVERRIDE;
-    virtual bool Initialized() const OVERRIDE;
+    int32_t Init() override;
+    int32_t Terminate() override;
+    bool Initialized() const override;
 
     // Device enumeration
-    virtual int16_t PlayoutDevices() OVERRIDE;
-    virtual int16_t RecordingDevices() OVERRIDE;
-    virtual int32_t PlayoutDeviceName(
-        uint16_t index,
-        char name[kAdmMaxDeviceNameSize],
-        char guid[kAdmMaxGuidSize]) OVERRIDE;
-    virtual int32_t RecordingDeviceName(
-        uint16_t index,
-        char name[kAdmMaxDeviceNameSize],
-        char guid[kAdmMaxGuidSize]) OVERRIDE;
+    int16_t PlayoutDevices() override;
+    int16_t RecordingDevices() override;
+    int32_t PlayoutDeviceName(uint16_t index,
+                              char name[kAdmMaxDeviceNameSize],
+                              char guid[kAdmMaxGuidSize]) override;
+    int32_t RecordingDeviceName(uint16_t index,
+                                char name[kAdmMaxDeviceNameSize],
+                                char guid[kAdmMaxGuidSize]) override;
 
     // Device selection
-    virtual int32_t SetPlayoutDevice(uint16_t index) OVERRIDE;
-    virtual int32_t SetPlayoutDevice(WindowsDeviceType device) OVERRIDE;
-    virtual int32_t SetRecordingDevice(uint16_t index) OVERRIDE;
-    virtual int32_t SetRecordingDevice(WindowsDeviceType device) OVERRIDE;
+    int32_t SetPlayoutDevice(uint16_t index) override;
+    int32_t SetPlayoutDevice(WindowsDeviceType device) override;
+    int32_t SetRecordingDevice(uint16_t index) override;
+    int32_t SetRecordingDevice(WindowsDeviceType device) override;
 
     // Audio transport initialization
-    virtual int32_t PlayoutIsAvailable(bool* available) OVERRIDE;
-    virtual int32_t InitPlayout() OVERRIDE;
-    virtual bool PlayoutIsInitialized() const OVERRIDE;
-    virtual int32_t RecordingIsAvailable(bool* available) OVERRIDE;
-    virtual int32_t InitRecording() OVERRIDE;
-    virtual bool RecordingIsInitialized() const OVERRIDE;
+    int32_t PlayoutIsAvailable(bool* available) override;
+    int32_t InitPlayout() override;
+    bool PlayoutIsInitialized() const override;
+    int32_t RecordingIsAvailable(bool* available) override;
+    int32_t InitRecording() override;
+    bool RecordingIsInitialized() const override;
 
     // Audio transport control
-    virtual int32_t StartPlayout() OVERRIDE;
-    virtual int32_t StopPlayout() OVERRIDE;
-    virtual bool Playing() const OVERRIDE;
-    virtual int32_t StartRecording() OVERRIDE;
-    virtual int32_t StopRecording() OVERRIDE;
-    virtual bool Recording() const OVERRIDE;
+    int32_t StartPlayout() override;
+    int32_t StopPlayout() override;
+    bool Playing() const override;
+    int32_t StartRecording() override;
+    int32_t StopRecording() override;
+    bool Recording() const override;
 
     // Microphone Automatic Gain Control (AGC)
-    virtual int32_t SetAGC(bool enable) OVERRIDE;
-    virtual bool AGC() const OVERRIDE;
+    int32_t SetAGC(bool enable) override;
+    bool AGC() const override;
 
     // Volume control based on the Windows Wave API (Windows only)
-    virtual int32_t SetWaveOutVolume(uint16_t volumeLeft,
-                                     uint16_t volumeRight) OVERRIDE;
-    virtual int32_t WaveOutVolume(uint16_t* volumeLeft,
-                                  uint16_t* volumeRight) const OVERRIDE;
+    int32_t SetWaveOutVolume(uint16_t volumeLeft,
+                             uint16_t volumeRight) override;
+    int32_t WaveOutVolume(uint16_t* volumeLeft,
+                          uint16_t* volumeRight) const override;
 
     // Audio mixer initialization
-    virtual int32_t InitSpeaker() OVERRIDE;
-    virtual bool SpeakerIsInitialized() const OVERRIDE;
-    virtual int32_t InitMicrophone() OVERRIDE;
-    virtual bool MicrophoneIsInitialized() const OVERRIDE;
+    int32_t InitSpeaker() override;
+    bool SpeakerIsInitialized() const override;
+    int32_t InitMicrophone() override;
+    bool MicrophoneIsInitialized() const override;
 
     // Speaker volume controls
-    virtual int32_t SpeakerVolumeIsAvailable(bool* available) OVERRIDE;
-    virtual int32_t SetSpeakerVolume(uint32_t volume) OVERRIDE;
-    virtual int32_t SpeakerVolume(uint32_t* volume) const OVERRIDE;
-    virtual int32_t MaxSpeakerVolume(uint32_t* maxVolume) const OVERRIDE;
-    virtual int32_t MinSpeakerVolume(uint32_t* minVolume) const OVERRIDE;
-    virtual int32_t SpeakerVolumeStepSize(
-        uint16_t* stepSize) const OVERRIDE;
+    int32_t SpeakerVolumeIsAvailable(bool* available) override;
+    int32_t SetSpeakerVolume(uint32_t volume) override;
+    int32_t SpeakerVolume(uint32_t* volume) const override;
+    int32_t MaxSpeakerVolume(uint32_t* maxVolume) const override;
+    int32_t MinSpeakerVolume(uint32_t* minVolume) const override;
+    int32_t SpeakerVolumeStepSize(uint16_t* stepSize) const override;
 
     // Microphone volume controls
-    virtual int32_t MicrophoneVolumeIsAvailable(bool* available) OVERRIDE;
-    virtual int32_t SetMicrophoneVolume(uint32_t volume) OVERRIDE;
-    virtual int32_t MicrophoneVolume(uint32_t* volume) const OVERRIDE;
-    virtual int32_t MaxMicrophoneVolume(
-        uint32_t* maxVolume) const OVERRIDE;
-    virtual int32_t MinMicrophoneVolume(
-        uint32_t* minVolume) const OVERRIDE;
-    virtual int32_t MicrophoneVolumeStepSize(
-        uint16_t* stepSize) const OVERRIDE;
+    int32_t MicrophoneVolumeIsAvailable(bool* available) override;
+    int32_t SetMicrophoneVolume(uint32_t volume) override;
+    int32_t MicrophoneVolume(uint32_t* volume) const override;
+    int32_t MaxMicrophoneVolume(uint32_t* maxVolume) const override;
+    int32_t MinMicrophoneVolume(uint32_t* minVolume) const override;
+    int32_t MicrophoneVolumeStepSize(uint16_t* stepSize) const override;
 
     // Speaker mute control
-    virtual int32_t SpeakerMuteIsAvailable(bool* available) OVERRIDE;
-    virtual int32_t SetSpeakerMute(bool enable) OVERRIDE;
-    virtual int32_t SpeakerMute(bool* enabled) const OVERRIDE;
+    int32_t SpeakerMuteIsAvailable(bool* available) override;
+    int32_t SetSpeakerMute(bool enable) override;
+    int32_t SpeakerMute(bool* enabled) const override;
 
     // Microphone mute control
-    virtual int32_t MicrophoneMuteIsAvailable(bool* available) OVERRIDE;
-    virtual int32_t SetMicrophoneMute(bool enable) OVERRIDE;
-    virtual int32_t MicrophoneMute(bool* enabled) const OVERRIDE;
+    int32_t MicrophoneMuteIsAvailable(bool* available) override;
+    int32_t SetMicrophoneMute(bool enable) override;
+    int32_t MicrophoneMute(bool* enabled) const override;
 
     // Microphone boost control
-    virtual int32_t MicrophoneBoostIsAvailable(bool* available) OVERRIDE;
-    virtual int32_t SetMicrophoneBoost(bool enable) OVERRIDE;
-    virtual int32_t MicrophoneBoost(bool* enabled) const OVERRIDE;
+    int32_t MicrophoneBoostIsAvailable(bool* available) override;
+    int32_t SetMicrophoneBoost(bool enable) override;
+    int32_t MicrophoneBoost(bool* enabled) const override;
 
     // Stereo support
-    virtual int32_t StereoPlayoutIsAvailable(bool* available) const OVERRIDE;
-    virtual int32_t SetStereoPlayout(bool enable) OVERRIDE;
-    virtual int32_t StereoPlayout(bool* enabled) const OVERRIDE;
-    virtual int32_t StereoRecordingIsAvailable(bool* available) const OVERRIDE;
-    virtual int32_t SetStereoRecording(bool enable) OVERRIDE;
-    virtual int32_t StereoRecording(bool* enabled) const OVERRIDE;
-    virtual int32_t SetRecordingChannel(const ChannelType channel) OVERRIDE;
-    virtual int32_t RecordingChannel(ChannelType* channel) const OVERRIDE;
+    int32_t StereoPlayoutIsAvailable(bool* available) const override;
+    int32_t SetStereoPlayout(bool enable) override;
+    int32_t StereoPlayout(bool* enabled) const override;
+    int32_t StereoRecordingIsAvailable(bool* available) const override;
+    int32_t SetStereoRecording(bool enable) override;
+    int32_t StereoRecording(bool* enabled) const override;
+    int32_t SetRecordingChannel(const ChannelType channel) override;
+    int32_t RecordingChannel(ChannelType* channel) const override;
 
     // Delay information and control
-    virtual int32_t SetPlayoutBuffer(const BufferType type,
-                                           uint16_t sizeMS = 0) OVERRIDE;
-    virtual int32_t PlayoutBuffer(BufferType* type,
-                                        uint16_t* sizeMS) const OVERRIDE;
-    virtual int32_t PlayoutDelay(uint16_t* delayMS) const OVERRIDE;
-    virtual int32_t RecordingDelay(uint16_t* delayMS) const OVERRIDE;
+    int32_t SetPlayoutBuffer(const BufferType type,
+                             uint16_t sizeMS = 0) override;
+    int32_t PlayoutBuffer(BufferType* type, uint16_t* sizeMS) const override;
+    int32_t PlayoutDelay(uint16_t* delayMS) const override;
+    int32_t RecordingDelay(uint16_t* delayMS) const override;
 
     // CPU load
-    virtual int32_t CPULoad(uint16_t* load) const OVERRIDE;
+    int32_t CPULoad(uint16_t* load) const override;
 
     // Recording of raw PCM data
-    virtual int32_t StartRawOutputFileRecording(
-        const char pcmFileNameUTF8[kAdmMaxFileNameSize]) OVERRIDE;
-    virtual int32_t StopRawOutputFileRecording() OVERRIDE;
-    virtual int32_t StartRawInputFileRecording(
-        const char pcmFileNameUTF8[kAdmMaxFileNameSize]) OVERRIDE;
-    virtual int32_t StopRawInputFileRecording() OVERRIDE;
+    int32_t StartRawOutputFileRecording(
+        const char pcmFileNameUTF8[kAdmMaxFileNameSize]) override;
+    int32_t StopRawOutputFileRecording() override;
+    int32_t StartRawInputFileRecording(
+        const char pcmFileNameUTF8[kAdmMaxFileNameSize]) override;
+    int32_t StopRawInputFileRecording() override;
 
     // Native sample rate controls (samples/sec)
-    virtual int32_t SetRecordingSampleRate(
-        const uint32_t samplesPerSec) OVERRIDE;
-    virtual int32_t RecordingSampleRate(
-        uint32_t* samplesPerSec) const OVERRIDE;
-    virtual int32_t SetPlayoutSampleRate(
-        const uint32_t samplesPerSec) OVERRIDE;
-    virtual int32_t PlayoutSampleRate(
-        uint32_t* samplesPerSec) const OVERRIDE;
+    int32_t SetRecordingSampleRate(const uint32_t samplesPerSec) override;
+    int32_t RecordingSampleRate(uint32_t* samplesPerSec) const override;
+    int32_t SetPlayoutSampleRate(const uint32_t samplesPerSec) override;
+    int32_t PlayoutSampleRate(uint32_t* samplesPerSec) const override;
 
     // Mobile device specific functions
-    virtual int32_t ResetAudioDevice() OVERRIDE;
-    virtual int32_t SetLoudspeakerStatus(bool enable) OVERRIDE;
-    virtual int32_t GetLoudspeakerStatus(bool* enabled) const OVERRIDE;
+    int32_t ResetAudioDevice() override;
+    int32_t SetLoudspeakerStatus(bool enable) override;
+    int32_t GetLoudspeakerStatus(bool* enabled) const override;
 
-    virtual bool BuiltInAECIsAvailable() const OVERRIDE;
+    bool BuiltInAECIsAvailable() const override;
 
-    virtual int32_t EnableBuiltInAEC(bool enable) OVERRIDE;
-    virtual bool BuiltInAECIsEnabled() const OVERRIDE;
+    int32_t EnableBuiltInAEC(bool enable) override;
+    bool BuiltInAECIsEnabled() const override;
 
 public:
     int32_t Id() {return _id;}
diff --git a/webrtc/modules/audio_device/dummy/audio_device_dummy.h b/webrtc/modules/audio_device/dummy/audio_device_dummy.h
index 41e52e9..75c599e 100644
--- a/webrtc/modules/audio_device/dummy/audio_device_dummy.h
+++ b/webrtc/modules/audio_device/dummy/audio_device_dummy.h
@@ -23,124 +23,123 @@
   virtual ~AudioDeviceDummy() {}
 
   // Retrieve the currently utilized audio layer
-  virtual int32_t ActiveAudioLayer(
-      AudioDeviceModule::AudioLayer& audioLayer) const OVERRIDE;
+  int32_t ActiveAudioLayer(
+      AudioDeviceModule::AudioLayer& audioLayer) const override;
 
   // Main initializaton and termination
-  virtual int32_t Init() OVERRIDE;
-  virtual int32_t Terminate() OVERRIDE;
-  virtual bool Initialized() const OVERRIDE;
+  int32_t Init() override;
+  int32_t Terminate() override;
+  bool Initialized() const override;
 
   // Device enumeration
-  virtual int16_t PlayoutDevices() OVERRIDE;
-  virtual int16_t RecordingDevices() OVERRIDE;
-  virtual int32_t PlayoutDeviceName(uint16_t index,
-                                    char name[kAdmMaxDeviceNameSize],
-                                    char guid[kAdmMaxGuidSize]) OVERRIDE;
-  virtual int32_t RecordingDeviceName(uint16_t index,
-                                      char name[kAdmMaxDeviceNameSize],
-                                      char guid[kAdmMaxGuidSize]) OVERRIDE;
+  int16_t PlayoutDevices() override;
+  int16_t RecordingDevices() override;
+  int32_t PlayoutDeviceName(uint16_t index,
+                            char name[kAdmMaxDeviceNameSize],
+                            char guid[kAdmMaxGuidSize]) override;
+  int32_t RecordingDeviceName(uint16_t index,
+                              char name[kAdmMaxDeviceNameSize],
+                              char guid[kAdmMaxGuidSize]) override;
 
   // Device selection
-  virtual int32_t SetPlayoutDevice(uint16_t index) OVERRIDE;
-  virtual int32_t SetPlayoutDevice(
-      AudioDeviceModule::WindowsDeviceType device) OVERRIDE;
-  virtual int32_t SetRecordingDevice(uint16_t index) OVERRIDE;
-  virtual int32_t SetRecordingDevice(
-      AudioDeviceModule::WindowsDeviceType device) OVERRIDE;
+  int32_t SetPlayoutDevice(uint16_t index) override;
+  int32_t SetPlayoutDevice(
+      AudioDeviceModule::WindowsDeviceType device) override;
+  int32_t SetRecordingDevice(uint16_t index) override;
+  int32_t SetRecordingDevice(
+      AudioDeviceModule::WindowsDeviceType device) override;
 
   // Audio transport initialization
-  virtual int32_t PlayoutIsAvailable(bool& available) OVERRIDE;
-  virtual int32_t InitPlayout() OVERRIDE;
-  virtual bool PlayoutIsInitialized() const OVERRIDE;
-  virtual int32_t RecordingIsAvailable(bool& available) OVERRIDE;
-  virtual int32_t InitRecording() OVERRIDE;
-  virtual bool RecordingIsInitialized() const OVERRIDE;
+  int32_t PlayoutIsAvailable(bool& available) override;
+  int32_t InitPlayout() override;
+  bool PlayoutIsInitialized() const override;
+  int32_t RecordingIsAvailable(bool& available) override;
+  int32_t InitRecording() override;
+  bool RecordingIsInitialized() const override;
 
   // Audio transport control
-  virtual int32_t StartPlayout() OVERRIDE;
-  virtual int32_t StopPlayout() OVERRIDE;
-  virtual bool Playing() const OVERRIDE;
-  virtual int32_t StartRecording() OVERRIDE;
-  virtual int32_t StopRecording() OVERRIDE;
-  virtual bool Recording() const OVERRIDE;
+  int32_t StartPlayout() override;
+  int32_t StopPlayout() override;
+  bool Playing() const override;
+  int32_t StartRecording() override;
+  int32_t StopRecording() override;
+  bool Recording() const override;
 
   // Microphone Automatic Gain Control (AGC)
-  virtual int32_t SetAGC(bool enable) OVERRIDE;
-  virtual bool AGC() const OVERRIDE;
+  int32_t SetAGC(bool enable) override;
+  bool AGC() const override;
 
   // Volume control based on the Windows Wave API (Windows only)
-  virtual int32_t SetWaveOutVolume(uint16_t volumeLeft,
-                                   uint16_t volumeRight) OVERRIDE;
-  virtual int32_t WaveOutVolume(uint16_t& volumeLeft,
-                                uint16_t& volumeRight) const OVERRIDE;
+  int32_t SetWaveOutVolume(uint16_t volumeLeft, uint16_t volumeRight) override;
+  int32_t WaveOutVolume(uint16_t& volumeLeft,
+                        uint16_t& volumeRight) const override;
 
   // Audio mixer initialization
-  virtual int32_t InitSpeaker() OVERRIDE;
-  virtual bool SpeakerIsInitialized() const OVERRIDE;
-  virtual int32_t InitMicrophone() OVERRIDE;
-  virtual bool MicrophoneIsInitialized() const OVERRIDE;
+  int32_t InitSpeaker() override;
+  bool SpeakerIsInitialized() const override;
+  int32_t InitMicrophone() override;
+  bool MicrophoneIsInitialized() const override;
 
   // Speaker volume controls
-  virtual int32_t SpeakerVolumeIsAvailable(bool& available) OVERRIDE;
-  virtual int32_t SetSpeakerVolume(uint32_t volume) OVERRIDE;
-  virtual int32_t SpeakerVolume(uint32_t& volume) const OVERRIDE;
-  virtual int32_t MaxSpeakerVolume(uint32_t& maxVolume) const OVERRIDE;
-  virtual int32_t MinSpeakerVolume(uint32_t& minVolume) const OVERRIDE;
-  virtual int32_t SpeakerVolumeStepSize(uint16_t& stepSize) const OVERRIDE;
+  int32_t SpeakerVolumeIsAvailable(bool& available) override;
+  int32_t SetSpeakerVolume(uint32_t volume) override;
+  int32_t SpeakerVolume(uint32_t& volume) const override;
+  int32_t MaxSpeakerVolume(uint32_t& maxVolume) const override;
+  int32_t MinSpeakerVolume(uint32_t& minVolume) const override;
+  int32_t SpeakerVolumeStepSize(uint16_t& stepSize) const override;
 
   // Microphone volume controls
-  virtual int32_t MicrophoneVolumeIsAvailable(bool& available) OVERRIDE;
-  virtual int32_t SetMicrophoneVolume(uint32_t volume) OVERRIDE;
-  virtual int32_t MicrophoneVolume(uint32_t& volume) const OVERRIDE;
-  virtual int32_t MaxMicrophoneVolume(uint32_t& maxVolume) const OVERRIDE;
-  virtual int32_t MinMicrophoneVolume(uint32_t& minVolume) const OVERRIDE;
-  virtual int32_t MicrophoneVolumeStepSize(uint16_t& stepSize) const OVERRIDE;
+  int32_t MicrophoneVolumeIsAvailable(bool& available) override;
+  int32_t SetMicrophoneVolume(uint32_t volume) override;
+  int32_t MicrophoneVolume(uint32_t& volume) const override;
+  int32_t MaxMicrophoneVolume(uint32_t& maxVolume) const override;
+  int32_t MinMicrophoneVolume(uint32_t& minVolume) const override;
+  int32_t MicrophoneVolumeStepSize(uint16_t& stepSize) const override;
 
   // Speaker mute control
-  virtual int32_t SpeakerMuteIsAvailable(bool& available) OVERRIDE;
-  virtual int32_t SetSpeakerMute(bool enable) OVERRIDE;
-  virtual int32_t SpeakerMute(bool& enabled) const OVERRIDE;
+  int32_t SpeakerMuteIsAvailable(bool& available) override;
+  int32_t SetSpeakerMute(bool enable) override;
+  int32_t SpeakerMute(bool& enabled) const override;
 
   // Microphone mute control
-  virtual int32_t MicrophoneMuteIsAvailable(bool& available) OVERRIDE;
-  virtual int32_t SetMicrophoneMute(bool enable) OVERRIDE;
-  virtual int32_t MicrophoneMute(bool& enabled) const OVERRIDE;
+  int32_t MicrophoneMuteIsAvailable(bool& available) override;
+  int32_t SetMicrophoneMute(bool enable) override;
+  int32_t MicrophoneMute(bool& enabled) const override;
 
   // Microphone boost control
-  virtual int32_t MicrophoneBoostIsAvailable(bool& available) OVERRIDE;
-  virtual int32_t SetMicrophoneBoost(bool enable) OVERRIDE;
-  virtual int32_t MicrophoneBoost(bool& enabled) const OVERRIDE;
+  int32_t MicrophoneBoostIsAvailable(bool& available) override;
+  int32_t SetMicrophoneBoost(bool enable) override;
+  int32_t MicrophoneBoost(bool& enabled) const override;
 
   // Stereo support
-  virtual int32_t StereoPlayoutIsAvailable(bool& available) OVERRIDE;
-  virtual int32_t SetStereoPlayout(bool enable) OVERRIDE;
-  virtual int32_t StereoPlayout(bool& enabled) const OVERRIDE;
-  virtual int32_t StereoRecordingIsAvailable(bool& available) OVERRIDE;
-  virtual int32_t SetStereoRecording(bool enable) OVERRIDE;
-  virtual int32_t StereoRecording(bool& enabled) const OVERRIDE;
+  int32_t StereoPlayoutIsAvailable(bool& available) override;
+  int32_t SetStereoPlayout(bool enable) override;
+  int32_t StereoPlayout(bool& enabled) const override;
+  int32_t StereoRecordingIsAvailable(bool& available) override;
+  int32_t SetStereoRecording(bool enable) override;
+  int32_t StereoRecording(bool& enabled) const override;
 
   // Delay information and control
-  virtual int32_t SetPlayoutBuffer(const AudioDeviceModule::BufferType type,
-                                   uint16_t sizeMS) OVERRIDE;
-  virtual int32_t PlayoutBuffer(AudioDeviceModule::BufferType& type,
-                                uint16_t& sizeMS) const OVERRIDE;
-  virtual int32_t PlayoutDelay(uint16_t& delayMS) const OVERRIDE;
-  virtual int32_t RecordingDelay(uint16_t& delayMS) const OVERRIDE;
+  int32_t SetPlayoutBuffer(const AudioDeviceModule::BufferType type,
+                           uint16_t sizeMS) override;
+  int32_t PlayoutBuffer(AudioDeviceModule::BufferType& type,
+                        uint16_t& sizeMS) const override;
+  int32_t PlayoutDelay(uint16_t& delayMS) const override;
+  int32_t RecordingDelay(uint16_t& delayMS) const override;
 
   // CPU load
-  virtual int32_t CPULoad(uint16_t& load) const OVERRIDE;
+  int32_t CPULoad(uint16_t& load) const override;
 
-  virtual bool PlayoutWarning() const OVERRIDE;
-  virtual bool PlayoutError() const OVERRIDE;
-  virtual bool RecordingWarning() const OVERRIDE;
-  virtual bool RecordingError() const OVERRIDE;
-  virtual void ClearPlayoutWarning() OVERRIDE;
-  virtual void ClearPlayoutError() OVERRIDE;
-  virtual void ClearRecordingWarning() OVERRIDE;
-  virtual void ClearRecordingError() OVERRIDE;
+  bool PlayoutWarning() const override;
+  bool PlayoutError() const override;
+  bool RecordingWarning() const override;
+  bool RecordingError() const override;
+  void ClearPlayoutWarning() override;
+  void ClearPlayoutError() override;
+  void ClearRecordingWarning() override;
+  void ClearRecordingError() override;
 
-  virtual void AttachAudioBuffer(AudioDeviceBuffer* audioBuffer) OVERRIDE;
+  void AttachAudioBuffer(AudioDeviceBuffer* audioBuffer) override;
 };
 
 }  // namespace webrtc
diff --git a/webrtc/modules/audio_device/dummy/audio_device_utility_dummy.h b/webrtc/modules/audio_device/dummy/audio_device_utility_dummy.h
index e05e30b..90aa6c2 100644
--- a/webrtc/modules/audio_device/dummy/audio_device_utility_dummy.h
+++ b/webrtc/modules/audio_device/dummy/audio_device_utility_dummy.h
@@ -24,7 +24,7 @@
     AudioDeviceUtilityDummy(const int32_t id) {}
     virtual ~AudioDeviceUtilityDummy() {}
 
-    virtual int32_t Init() OVERRIDE;
+    int32_t Init() override;
 };
 }  // namespace webrtc
 
diff --git a/webrtc/modules/audio_device/dummy/file_audio_device.h b/webrtc/modules/audio_device/dummy/file_audio_device.h
index 6f417eb..14936f5 100644
--- a/webrtc/modules/audio_device/dummy/file_audio_device.h
+++ b/webrtc/modules/audio_device/dummy/file_audio_device.h
@@ -40,124 +40,123 @@
   virtual ~FileAudioDevice();
 
   // Retrieve the currently utilized audio layer
-  virtual int32_t ActiveAudioLayer(
-      AudioDeviceModule::AudioLayer& audioLayer) const OVERRIDE;
+  int32_t ActiveAudioLayer(
+      AudioDeviceModule::AudioLayer& audioLayer) const override;
 
   // Main initializaton and termination
-  virtual int32_t Init() OVERRIDE;
-  virtual int32_t Terminate() OVERRIDE;
-  virtual bool Initialized() const OVERRIDE;
+  int32_t Init() override;
+  int32_t Terminate() override;
+  bool Initialized() const override;
 
   // Device enumeration
-  virtual int16_t PlayoutDevices() OVERRIDE;
-  virtual int16_t RecordingDevices() OVERRIDE;
-  virtual int32_t PlayoutDeviceName(uint16_t index,
-                                    char name[kAdmMaxDeviceNameSize],
-                                    char guid[kAdmMaxGuidSize]) OVERRIDE;
-  virtual int32_t RecordingDeviceName(uint16_t index,
-                                      char name[kAdmMaxDeviceNameSize],
-                                      char guid[kAdmMaxGuidSize]) OVERRIDE;
+  int16_t PlayoutDevices() override;
+  int16_t RecordingDevices() override;
+  int32_t PlayoutDeviceName(uint16_t index,
+                            char name[kAdmMaxDeviceNameSize],
+                            char guid[kAdmMaxGuidSize]) override;
+  int32_t RecordingDeviceName(uint16_t index,
+                              char name[kAdmMaxDeviceNameSize],
+                              char guid[kAdmMaxGuidSize]) override;
 
   // Device selection
-  virtual int32_t SetPlayoutDevice(uint16_t index) OVERRIDE;
-  virtual int32_t SetPlayoutDevice(
-      AudioDeviceModule::WindowsDeviceType device) OVERRIDE;
-  virtual int32_t SetRecordingDevice(uint16_t index) OVERRIDE;
-  virtual int32_t SetRecordingDevice(
-      AudioDeviceModule::WindowsDeviceType device) OVERRIDE;
+  int32_t SetPlayoutDevice(uint16_t index) override;
+  int32_t SetPlayoutDevice(
+      AudioDeviceModule::WindowsDeviceType device) override;
+  int32_t SetRecordingDevice(uint16_t index) override;
+  int32_t SetRecordingDevice(
+      AudioDeviceModule::WindowsDeviceType device) override;
 
   // Audio transport initialization
-  virtual int32_t PlayoutIsAvailable(bool& available) OVERRIDE;
-  virtual int32_t InitPlayout() OVERRIDE;
-  virtual bool PlayoutIsInitialized() const OVERRIDE;
-  virtual int32_t RecordingIsAvailable(bool& available) OVERRIDE;
-  virtual int32_t InitRecording() OVERRIDE;
-  virtual bool RecordingIsInitialized() const OVERRIDE;
+  int32_t PlayoutIsAvailable(bool& available) override;
+  int32_t InitPlayout() override;
+  bool PlayoutIsInitialized() const override;
+  int32_t RecordingIsAvailable(bool& available) override;
+  int32_t InitRecording() override;
+  bool RecordingIsInitialized() const override;
 
   // Audio transport control
-  virtual int32_t StartPlayout() OVERRIDE;
-  virtual int32_t StopPlayout() OVERRIDE;
-  virtual bool Playing() const OVERRIDE;
-  virtual int32_t StartRecording() OVERRIDE;
-  virtual int32_t StopRecording() OVERRIDE;
-  virtual bool Recording() const OVERRIDE;
+  int32_t StartPlayout() override;
+  int32_t StopPlayout() override;
+  bool Playing() const override;
+  int32_t StartRecording() override;
+  int32_t StopRecording() override;
+  bool Recording() const override;
 
   // Microphone Automatic Gain Control (AGC)
-  virtual int32_t SetAGC(bool enable) OVERRIDE;
-  virtual bool AGC() const OVERRIDE;
+  int32_t SetAGC(bool enable) override;
+  bool AGC() const override;
 
   // Volume control based on the Windows Wave API (Windows only)
-  virtual int32_t SetWaveOutVolume(uint16_t volumeLeft,
-                                   uint16_t volumeRight) OVERRIDE;
-  virtual int32_t WaveOutVolume(uint16_t& volumeLeft,
-                                uint16_t& volumeRight) const OVERRIDE;
+  int32_t SetWaveOutVolume(uint16_t volumeLeft, uint16_t volumeRight) override;
+  int32_t WaveOutVolume(uint16_t& volumeLeft,
+                        uint16_t& volumeRight) const override;
 
   // Audio mixer initialization
-  virtual int32_t InitSpeaker() OVERRIDE;
-  virtual bool SpeakerIsInitialized() const OVERRIDE;
-  virtual int32_t InitMicrophone() OVERRIDE;
-  virtual bool MicrophoneIsInitialized() const OVERRIDE;
+  int32_t InitSpeaker() override;
+  bool SpeakerIsInitialized() const override;
+  int32_t InitMicrophone() override;
+  bool MicrophoneIsInitialized() const override;
 
   // Speaker volume controls
-  virtual int32_t SpeakerVolumeIsAvailable(bool& available) OVERRIDE;
-  virtual int32_t SetSpeakerVolume(uint32_t volume) OVERRIDE;
-  virtual int32_t SpeakerVolume(uint32_t& volume) const OVERRIDE;
-  virtual int32_t MaxSpeakerVolume(uint32_t& maxVolume) const OVERRIDE;
-  virtual int32_t MinSpeakerVolume(uint32_t& minVolume) const OVERRIDE;
-  virtual int32_t SpeakerVolumeStepSize(uint16_t& stepSize) const OVERRIDE;
+  int32_t SpeakerVolumeIsAvailable(bool& available) override;
+  int32_t SetSpeakerVolume(uint32_t volume) override;
+  int32_t SpeakerVolume(uint32_t& volume) const override;
+  int32_t MaxSpeakerVolume(uint32_t& maxVolume) const override;
+  int32_t MinSpeakerVolume(uint32_t& minVolume) const override;
+  int32_t SpeakerVolumeStepSize(uint16_t& stepSize) const override;
 
   // Microphone volume controls
-  virtual int32_t MicrophoneVolumeIsAvailable(bool& available) OVERRIDE;
-  virtual int32_t SetMicrophoneVolume(uint32_t volume) OVERRIDE;
-  virtual int32_t MicrophoneVolume(uint32_t& volume) const OVERRIDE;
-  virtual int32_t MaxMicrophoneVolume(uint32_t& maxVolume) const OVERRIDE;
-  virtual int32_t MinMicrophoneVolume(uint32_t& minVolume) const OVERRIDE;
-  virtual int32_t MicrophoneVolumeStepSize(uint16_t& stepSize) const OVERRIDE;
+  int32_t MicrophoneVolumeIsAvailable(bool& available) override;
+  int32_t SetMicrophoneVolume(uint32_t volume) override;
+  int32_t MicrophoneVolume(uint32_t& volume) const override;
+  int32_t MaxMicrophoneVolume(uint32_t& maxVolume) const override;
+  int32_t MinMicrophoneVolume(uint32_t& minVolume) const override;
+  int32_t MicrophoneVolumeStepSize(uint16_t& stepSize) const override;
 
   // Speaker mute control
-  virtual int32_t SpeakerMuteIsAvailable(bool& available) OVERRIDE;
-  virtual int32_t SetSpeakerMute(bool enable) OVERRIDE;
-  virtual int32_t SpeakerMute(bool& enabled) const OVERRIDE;
+  int32_t SpeakerMuteIsAvailable(bool& available) override;
+  int32_t SetSpeakerMute(bool enable) override;
+  int32_t SpeakerMute(bool& enabled) const override;
 
   // Microphone mute control
-  virtual int32_t MicrophoneMuteIsAvailable(bool& available) OVERRIDE;
-  virtual int32_t SetMicrophoneMute(bool enable) OVERRIDE;
-  virtual int32_t MicrophoneMute(bool& enabled) const OVERRIDE;
+  int32_t MicrophoneMuteIsAvailable(bool& available) override;
+  int32_t SetMicrophoneMute(bool enable) override;
+  int32_t MicrophoneMute(bool& enabled) const override;
 
   // Microphone boost control
-  virtual int32_t MicrophoneBoostIsAvailable(bool& available) OVERRIDE;
-  virtual int32_t SetMicrophoneBoost(bool enable) OVERRIDE;
-  virtual int32_t MicrophoneBoost(bool& enabled) const OVERRIDE;
+  int32_t MicrophoneBoostIsAvailable(bool& available) override;
+  int32_t SetMicrophoneBoost(bool enable) override;
+  int32_t MicrophoneBoost(bool& enabled) const override;
 
   // Stereo support
-  virtual int32_t StereoPlayoutIsAvailable(bool& available) OVERRIDE;
-  virtual int32_t SetStereoPlayout(bool enable) OVERRIDE;
-  virtual int32_t StereoPlayout(bool& enabled) const OVERRIDE;
-  virtual int32_t StereoRecordingIsAvailable(bool& available) OVERRIDE;
-  virtual int32_t SetStereoRecording(bool enable) OVERRIDE;
-  virtual int32_t StereoRecording(bool& enabled) const OVERRIDE;
+  int32_t StereoPlayoutIsAvailable(bool& available) override;
+  int32_t SetStereoPlayout(bool enable) override;
+  int32_t StereoPlayout(bool& enabled) const override;
+  int32_t StereoRecordingIsAvailable(bool& available) override;
+  int32_t SetStereoRecording(bool enable) override;
+  int32_t StereoRecording(bool& enabled) const override;
 
   // Delay information and control
-  virtual int32_t SetPlayoutBuffer(const AudioDeviceModule::BufferType type,
-                                   uint16_t sizeMS) OVERRIDE;
-  virtual int32_t PlayoutBuffer(AudioDeviceModule::BufferType& type,
-                                uint16_t& sizeMS) const OVERRIDE;
-  virtual int32_t PlayoutDelay(uint16_t& delayMS) const OVERRIDE;
-  virtual int32_t RecordingDelay(uint16_t& delayMS) const OVERRIDE;
+  int32_t SetPlayoutBuffer(const AudioDeviceModule::BufferType type,
+                           uint16_t sizeMS) override;
+  int32_t PlayoutBuffer(AudioDeviceModule::BufferType& type,
+                        uint16_t& sizeMS) const override;
+  int32_t PlayoutDelay(uint16_t& delayMS) const override;
+  int32_t RecordingDelay(uint16_t& delayMS) const override;
 
   // CPU load
-  virtual int32_t CPULoad(uint16_t& load) const OVERRIDE;
+  int32_t CPULoad(uint16_t& load) const override;
 
-  virtual bool PlayoutWarning() const OVERRIDE;
-  virtual bool PlayoutError() const OVERRIDE;
-  virtual bool RecordingWarning() const OVERRIDE;
-  virtual bool RecordingError() const OVERRIDE;
-  virtual void ClearPlayoutWarning() OVERRIDE;
-  virtual void ClearPlayoutError() OVERRIDE;
-  virtual void ClearRecordingWarning() OVERRIDE;
-  virtual void ClearRecordingError() OVERRIDE;
+  bool PlayoutWarning() const override;
+  bool PlayoutError() const override;
+  bool RecordingWarning() const override;
+  bool RecordingError() const override;
+  void ClearPlayoutWarning() override;
+  void ClearPlayoutError() override;
+  void ClearRecordingWarning() override;
+  void ClearRecordingError() override;
 
-  virtual void AttachAudioBuffer(AudioDeviceBuffer* audioBuffer) OVERRIDE;
+  void AttachAudioBuffer(AudioDeviceBuffer* audioBuffer) override;
 
  private:
   static bool RecThreadFunc(void*);
diff --git a/webrtc/modules/audio_device/linux/audio_device_alsa_linux.h b/webrtc/modules/audio_device/linux/audio_device_alsa_linux.h
index 1d75c8e..d5be88c 100644
--- a/webrtc/modules/audio_device/linux/audio_device_alsa_linux.h
+++ b/webrtc/modules/audio_device/linux/audio_device_alsa_linux.h
@@ -35,131 +35,126 @@
     virtual ~AudioDeviceLinuxALSA();
 
     // Retrieve the currently utilized audio layer
-    virtual int32_t ActiveAudioLayer(
-        AudioDeviceModule::AudioLayer& audioLayer) const OVERRIDE;
+    int32_t ActiveAudioLayer(
+        AudioDeviceModule::AudioLayer& audioLayer) const override;
 
     // Main initializaton and termination
-    virtual int32_t Init() OVERRIDE;
-    virtual int32_t Terminate() OVERRIDE;
-    virtual bool Initialized() const OVERRIDE;
+    int32_t Init() override;
+    int32_t Terminate() override;
+    bool Initialized() const override;
 
     // Device enumeration
-    virtual int16_t PlayoutDevices() OVERRIDE;
-    virtual int16_t RecordingDevices() OVERRIDE;
-    virtual int32_t PlayoutDeviceName(
-        uint16_t index,
-        char name[kAdmMaxDeviceNameSize],
-        char guid[kAdmMaxGuidSize]) OVERRIDE;
-    virtual int32_t RecordingDeviceName(
-        uint16_t index,
-        char name[kAdmMaxDeviceNameSize],
-        char guid[kAdmMaxGuidSize]) OVERRIDE;
+    int16_t PlayoutDevices() override;
+    int16_t RecordingDevices() override;
+    int32_t PlayoutDeviceName(uint16_t index,
+                              char name[kAdmMaxDeviceNameSize],
+                              char guid[kAdmMaxGuidSize]) override;
+    int32_t RecordingDeviceName(uint16_t index,
+                                char name[kAdmMaxDeviceNameSize],
+                                char guid[kAdmMaxGuidSize]) override;
 
     // Device selection
-    virtual int32_t SetPlayoutDevice(uint16_t index) OVERRIDE;
-    virtual int32_t SetPlayoutDevice(
-        AudioDeviceModule::WindowsDeviceType device) OVERRIDE;
-    virtual int32_t SetRecordingDevice(uint16_t index) OVERRIDE;
-    virtual int32_t SetRecordingDevice(
-        AudioDeviceModule::WindowsDeviceType device) OVERRIDE;
+    int32_t SetPlayoutDevice(uint16_t index) override;
+    int32_t SetPlayoutDevice(
+        AudioDeviceModule::WindowsDeviceType device) override;
+    int32_t SetRecordingDevice(uint16_t index) override;
+    int32_t SetRecordingDevice(
+        AudioDeviceModule::WindowsDeviceType device) override;
 
     // Audio transport initialization
-    virtual int32_t PlayoutIsAvailable(bool& available) OVERRIDE;
-    virtual int32_t InitPlayout() OVERRIDE;
-    virtual bool PlayoutIsInitialized() const OVERRIDE;
-    virtual int32_t RecordingIsAvailable(bool& available) OVERRIDE;
-    virtual int32_t InitRecording() OVERRIDE;
-    virtual bool RecordingIsInitialized() const OVERRIDE;
+    int32_t PlayoutIsAvailable(bool& available) override;
+    int32_t InitPlayout() override;
+    bool PlayoutIsInitialized() const override;
+    int32_t RecordingIsAvailable(bool& available) override;
+    int32_t InitRecording() override;
+    bool RecordingIsInitialized() const override;
 
     // Audio transport control
-    virtual int32_t StartPlayout() OVERRIDE;
-    virtual int32_t StopPlayout() OVERRIDE;
-    virtual bool Playing() const OVERRIDE;
-    virtual int32_t StartRecording() OVERRIDE;
-    virtual int32_t StopRecording() OVERRIDE;
-    virtual bool Recording() const OVERRIDE;
+    int32_t StartPlayout() override;
+    int32_t StopPlayout() override;
+    bool Playing() const override;
+    int32_t StartRecording() override;
+    int32_t StopRecording() override;
+    bool Recording() const override;
 
     // Microphone Automatic Gain Control (AGC)
-    virtual int32_t SetAGC(bool enable) OVERRIDE;
-    virtual bool AGC() const OVERRIDE;
+    int32_t SetAGC(bool enable) override;
+    bool AGC() const override;
 
     // Volume control based on the Windows Wave API (Windows only)
-    virtual int32_t SetWaveOutVolume(uint16_t volumeLeft,
-                                     uint16_t volumeRight) OVERRIDE;
-    virtual int32_t WaveOutVolume(uint16_t& volumeLeft,
-                                  uint16_t& volumeRight) const OVERRIDE;
+    int32_t SetWaveOutVolume(uint16_t volumeLeft,
+                             uint16_t volumeRight) override;
+    int32_t WaveOutVolume(uint16_t& volumeLeft,
+                          uint16_t& volumeRight) const override;
 
     // Audio mixer initialization
-    virtual int32_t InitSpeaker() OVERRIDE;
-    virtual bool SpeakerIsInitialized() const OVERRIDE;
-    virtual int32_t InitMicrophone() OVERRIDE;
-    virtual bool MicrophoneIsInitialized() const OVERRIDE;
+    int32_t InitSpeaker() override;
+    bool SpeakerIsInitialized() const override;
+    int32_t InitMicrophone() override;
+    bool MicrophoneIsInitialized() const override;
 
     // Speaker volume controls
-    virtual int32_t SpeakerVolumeIsAvailable(bool& available) OVERRIDE;
-    virtual int32_t SetSpeakerVolume(uint32_t volume) OVERRIDE;
-    virtual int32_t SpeakerVolume(uint32_t& volume) const OVERRIDE;
-    virtual int32_t MaxSpeakerVolume(uint32_t& maxVolume) const OVERRIDE;
-    virtual int32_t MinSpeakerVolume(uint32_t& minVolume) const OVERRIDE;
-    virtual int32_t SpeakerVolumeStepSize(uint16_t& stepSize) const OVERRIDE;
+    int32_t SpeakerVolumeIsAvailable(bool& available) override;
+    int32_t SetSpeakerVolume(uint32_t volume) override;
+    int32_t SpeakerVolume(uint32_t& volume) const override;
+    int32_t MaxSpeakerVolume(uint32_t& maxVolume) const override;
+    int32_t MinSpeakerVolume(uint32_t& minVolume) const override;
+    int32_t SpeakerVolumeStepSize(uint16_t& stepSize) const override;
 
     // Microphone volume controls
-    virtual int32_t MicrophoneVolumeIsAvailable(bool& available) OVERRIDE;
-    virtual int32_t SetMicrophoneVolume(uint32_t volume) OVERRIDE;
-    virtual int32_t MicrophoneVolume(uint32_t& volume) const OVERRIDE;
-    virtual int32_t MaxMicrophoneVolume(uint32_t& maxVolume) const OVERRIDE;
-    virtual int32_t MinMicrophoneVolume(uint32_t& minVolume) const OVERRIDE;
-    virtual int32_t MicrophoneVolumeStepSize(
-        uint16_t& stepSize) const OVERRIDE;
+    int32_t MicrophoneVolumeIsAvailable(bool& available) override;
+    int32_t SetMicrophoneVolume(uint32_t volume) override;
+    int32_t MicrophoneVolume(uint32_t& volume) const override;
+    int32_t MaxMicrophoneVolume(uint32_t& maxVolume) const override;
+    int32_t MinMicrophoneVolume(uint32_t& minVolume) const override;
+    int32_t MicrophoneVolumeStepSize(uint16_t& stepSize) const override;
 
     // Speaker mute control
-    virtual int32_t SpeakerMuteIsAvailable(bool& available) OVERRIDE;
-    virtual int32_t SetSpeakerMute(bool enable) OVERRIDE;
-    virtual int32_t SpeakerMute(bool& enabled) const OVERRIDE;
+    int32_t SpeakerMuteIsAvailable(bool& available) override;
+    int32_t SetSpeakerMute(bool enable) override;
+    int32_t SpeakerMute(bool& enabled) const override;
 
     // Microphone mute control
-    virtual int32_t MicrophoneMuteIsAvailable(bool& available) OVERRIDE;
-    virtual int32_t SetMicrophoneMute(bool enable) OVERRIDE;
-    virtual int32_t MicrophoneMute(bool& enabled) const OVERRIDE;
+    int32_t MicrophoneMuteIsAvailable(bool& available) override;
+    int32_t SetMicrophoneMute(bool enable) override;
+    int32_t MicrophoneMute(bool& enabled) const override;
 
     // Microphone boost control
-    virtual int32_t MicrophoneBoostIsAvailable(bool& available) OVERRIDE;
-    virtual int32_t SetMicrophoneBoost(bool enable) OVERRIDE;
-    virtual int32_t MicrophoneBoost(bool& enabled) const OVERRIDE;
+    int32_t MicrophoneBoostIsAvailable(bool& available) override;
+    int32_t SetMicrophoneBoost(bool enable) override;
+    int32_t MicrophoneBoost(bool& enabled) const override;
 
     // Stereo support
-    virtual int32_t StereoPlayoutIsAvailable(bool& available) OVERRIDE;
-    virtual int32_t SetStereoPlayout(bool enable) OVERRIDE;
-    virtual int32_t StereoPlayout(bool& enabled) const OVERRIDE;
-    virtual int32_t StereoRecordingIsAvailable(bool& available) OVERRIDE;
-    virtual int32_t SetStereoRecording(bool enable) OVERRIDE;
-    virtual int32_t StereoRecording(bool& enabled) const OVERRIDE;
+    int32_t StereoPlayoutIsAvailable(bool& available) override;
+    int32_t SetStereoPlayout(bool enable) override;
+    int32_t StereoPlayout(bool& enabled) const override;
+    int32_t StereoRecordingIsAvailable(bool& available) override;
+    int32_t SetStereoRecording(bool enable) override;
+    int32_t StereoRecording(bool& enabled) const override;
 
     // Delay information and control
-    virtual int32_t SetPlayoutBuffer(
-        const AudioDeviceModule::BufferType type,
-        uint16_t sizeMS) OVERRIDE;
-    virtual int32_t PlayoutBuffer(
-        AudioDeviceModule::BufferType& type,
-        uint16_t& sizeMS) const OVERRIDE;
-    virtual int32_t PlayoutDelay(uint16_t& delayMS) const OVERRIDE;
-    virtual int32_t RecordingDelay(uint16_t& delayMS) const OVERRIDE;
+    int32_t SetPlayoutBuffer(const AudioDeviceModule::BufferType type,
+                             uint16_t sizeMS) override;
+    int32_t PlayoutBuffer(AudioDeviceModule::BufferType& type,
+                          uint16_t& sizeMS) const override;
+    int32_t PlayoutDelay(uint16_t& delayMS) const override;
+    int32_t RecordingDelay(uint16_t& delayMS) const override;
 
     // CPU load
-    virtual int32_t CPULoad(uint16_t& load) const OVERRIDE;
+    int32_t CPULoad(uint16_t& load) const override;
 
 public:
-    virtual bool PlayoutWarning() const OVERRIDE;
-    virtual bool PlayoutError() const OVERRIDE;
-    virtual bool RecordingWarning() const OVERRIDE;
-    virtual bool RecordingError() const OVERRIDE;
-    virtual void ClearPlayoutWarning() OVERRIDE;
-    virtual void ClearPlayoutError() OVERRIDE;
-    virtual void ClearRecordingWarning() OVERRIDE;
-    virtual void ClearRecordingError() OVERRIDE;
+ bool PlayoutWarning() const override;
+ bool PlayoutError() const override;
+ bool RecordingWarning() const override;
+ bool RecordingError() const override;
+ void ClearPlayoutWarning() override;
+ void ClearPlayoutError() override;
+ void ClearRecordingWarning() override;
+ void ClearRecordingError() override;
 
 public:
-    virtual void AttachAudioBuffer(AudioDeviceBuffer* audioBuffer) OVERRIDE;
+ void AttachAudioBuffer(AudioDeviceBuffer* audioBuffer) override;
 
 private:
     int32_t GetDevicesInfo(const int32_t function,
diff --git a/webrtc/modules/audio_device/linux/audio_device_pulse_linux.h b/webrtc/modules/audio_device/linux/audio_device_pulse_linux.h
index cde7e46..1644df9 100644
--- a/webrtc/modules/audio_device/linux/audio_device_pulse_linux.h
+++ b/webrtc/modules/audio_device/linux/audio_device_pulse_linux.h
@@ -96,130 +96,126 @@
     virtual ~AudioDeviceLinuxPulse();
 
     // Retrieve the currently utilized audio layer
-    virtual int32_t ActiveAudioLayer(
-        AudioDeviceModule::AudioLayer& audioLayer) const OVERRIDE;
+    int32_t ActiveAudioLayer(
+        AudioDeviceModule::AudioLayer& audioLayer) const override;
 
     // Main initializaton and termination
-    virtual int32_t Init() OVERRIDE;
-    virtual int32_t Terminate() OVERRIDE;
-    virtual bool Initialized() const OVERRIDE;
+    int32_t Init() override;
+    int32_t Terminate() override;
+    bool Initialized() const override;
 
     // Device enumeration
-    virtual int16_t PlayoutDevices() OVERRIDE;
-    virtual int16_t RecordingDevices() OVERRIDE;
-    virtual int32_t PlayoutDeviceName(
-        uint16_t index,
-        char name[kAdmMaxDeviceNameSize],
-        char guid[kAdmMaxGuidSize]) OVERRIDE;
-    virtual int32_t RecordingDeviceName(
-        uint16_t index,
-        char name[kAdmMaxDeviceNameSize],
-        char guid[kAdmMaxGuidSize]) OVERRIDE;
+    int16_t PlayoutDevices() override;
+    int16_t RecordingDevices() override;
+    int32_t PlayoutDeviceName(uint16_t index,
+                              char name[kAdmMaxDeviceNameSize],
+                              char guid[kAdmMaxGuidSize]) override;
+    int32_t RecordingDeviceName(uint16_t index,
+                                char name[kAdmMaxDeviceNameSize],
+                                char guid[kAdmMaxGuidSize]) override;
 
     // Device selection
-    virtual int32_t SetPlayoutDevice(uint16_t index) OVERRIDE;
-    virtual int32_t SetPlayoutDevice(
-        AudioDeviceModule::WindowsDeviceType device) OVERRIDE;
-    virtual int32_t SetRecordingDevice(uint16_t index) OVERRIDE;
-    virtual int32_t SetRecordingDevice(
-        AudioDeviceModule::WindowsDeviceType device) OVERRIDE;
+    int32_t SetPlayoutDevice(uint16_t index) override;
+    int32_t SetPlayoutDevice(
+        AudioDeviceModule::WindowsDeviceType device) override;
+    int32_t SetRecordingDevice(uint16_t index) override;
+    int32_t SetRecordingDevice(
+        AudioDeviceModule::WindowsDeviceType device) override;
 
     // Audio transport initialization
-    virtual int32_t PlayoutIsAvailable(bool& available) OVERRIDE;
-    virtual int32_t InitPlayout() OVERRIDE;
-    virtual bool PlayoutIsInitialized() const OVERRIDE;
-    virtual int32_t RecordingIsAvailable(bool& available) OVERRIDE;
-    virtual int32_t InitRecording() OVERRIDE;
-    virtual bool RecordingIsInitialized() const OVERRIDE;
+    int32_t PlayoutIsAvailable(bool& available) override;
+    int32_t InitPlayout() override;
+    bool PlayoutIsInitialized() const override;
+    int32_t RecordingIsAvailable(bool& available) override;
+    int32_t InitRecording() override;
+    bool RecordingIsInitialized() const override;
 
     // Audio transport control
-    virtual int32_t StartPlayout() OVERRIDE;
-    virtual int32_t StopPlayout() OVERRIDE;
-    virtual bool Playing() const OVERRIDE;
-    virtual int32_t StartRecording() OVERRIDE;
-    virtual int32_t StopRecording() OVERRIDE;
-    virtual bool Recording() const OVERRIDE;
+    int32_t StartPlayout() override;
+    int32_t StopPlayout() override;
+    bool Playing() const override;
+    int32_t StartRecording() override;
+    int32_t StopRecording() override;
+    bool Recording() const override;
 
     // Microphone Automatic Gain Control (AGC)
-    virtual int32_t SetAGC(bool enable) OVERRIDE;
-    virtual bool AGC() const OVERRIDE;
+    int32_t SetAGC(bool enable) override;
+    bool AGC() const override;
 
     // Volume control based on the Windows Wave API (Windows only)
-    virtual int32_t SetWaveOutVolume(uint16_t volumeLeft,
-                                     uint16_t volumeRight) OVERRIDE;
-    virtual int32_t WaveOutVolume(uint16_t& volumeLeft,
-                                  uint16_t& volumeRight) const OVERRIDE;
+    int32_t SetWaveOutVolume(uint16_t volumeLeft,
+                             uint16_t volumeRight) override;
+    int32_t WaveOutVolume(uint16_t& volumeLeft,
+                          uint16_t& volumeRight) const override;
 
     // Audio mixer initialization
-    virtual int32_t InitSpeaker() OVERRIDE;
-    virtual bool SpeakerIsInitialized() const OVERRIDE;
-    virtual int32_t InitMicrophone() OVERRIDE;
-    virtual bool MicrophoneIsInitialized() const OVERRIDE;
+    int32_t InitSpeaker() override;
+    bool SpeakerIsInitialized() const override;
+    int32_t InitMicrophone() override;
+    bool MicrophoneIsInitialized() const override;
 
     // Speaker volume controls
-    virtual int32_t SpeakerVolumeIsAvailable(bool& available) OVERRIDE;
-    virtual int32_t SetSpeakerVolume(uint32_t volume) OVERRIDE;
-    virtual int32_t SpeakerVolume(uint32_t& volume) const OVERRIDE;
-    virtual int32_t MaxSpeakerVolume(uint32_t& maxVolume) const OVERRIDE;
-    virtual int32_t MinSpeakerVolume(uint32_t& minVolume) const OVERRIDE;
-    virtual int32_t SpeakerVolumeStepSize(uint16_t& stepSize) const OVERRIDE;
+    int32_t SpeakerVolumeIsAvailable(bool& available) override;
+    int32_t SetSpeakerVolume(uint32_t volume) override;
+    int32_t SpeakerVolume(uint32_t& volume) const override;
+    int32_t MaxSpeakerVolume(uint32_t& maxVolume) const override;
+    int32_t MinSpeakerVolume(uint32_t& minVolume) const override;
+    int32_t SpeakerVolumeStepSize(uint16_t& stepSize) const override;
 
     // Microphone volume controls
-    virtual int32_t MicrophoneVolumeIsAvailable(bool& available) OVERRIDE;
-    virtual int32_t SetMicrophoneVolume(uint32_t volume) OVERRIDE;
-    virtual int32_t MicrophoneVolume(uint32_t& volume) const OVERRIDE;
-    virtual int32_t MaxMicrophoneVolume(uint32_t& maxVolume) const OVERRIDE;
-    virtual int32_t MinMicrophoneVolume(uint32_t& minVolume) const OVERRIDE;
-    virtual int32_t MicrophoneVolumeStepSize(
-        uint16_t& stepSize) const OVERRIDE;
+    int32_t MicrophoneVolumeIsAvailable(bool& available) override;
+    int32_t SetMicrophoneVolume(uint32_t volume) override;
+    int32_t MicrophoneVolume(uint32_t& volume) const override;
+    int32_t MaxMicrophoneVolume(uint32_t& maxVolume) const override;
+    int32_t MinMicrophoneVolume(uint32_t& minVolume) const override;
+    int32_t MicrophoneVolumeStepSize(uint16_t& stepSize) const override;
 
     // Speaker mute control
-    virtual int32_t SpeakerMuteIsAvailable(bool& available) OVERRIDE;
-    virtual int32_t SetSpeakerMute(bool enable) OVERRIDE;
-    virtual int32_t SpeakerMute(bool& enabled) const OVERRIDE;
+    int32_t SpeakerMuteIsAvailable(bool& available) override;
+    int32_t SetSpeakerMute(bool enable) override;
+    int32_t SpeakerMute(bool& enabled) const override;
 
     // Microphone mute control
-    virtual int32_t MicrophoneMuteIsAvailable(bool& available) OVERRIDE;
-    virtual int32_t SetMicrophoneMute(bool enable) OVERRIDE;
-    virtual int32_t MicrophoneMute(bool& enabled) const OVERRIDE;
+    int32_t MicrophoneMuteIsAvailable(bool& available) override;
+    int32_t SetMicrophoneMute(bool enable) override;
+    int32_t MicrophoneMute(bool& enabled) const override;
 
     // Microphone boost control
-    virtual int32_t MicrophoneBoostIsAvailable(bool& available) OVERRIDE;
-    virtual int32_t SetMicrophoneBoost(bool enable) OVERRIDE;
-    virtual int32_t MicrophoneBoost(bool& enabled) const OVERRIDE;
+    int32_t MicrophoneBoostIsAvailable(bool& available) override;
+    int32_t SetMicrophoneBoost(bool enable) override;
+    int32_t MicrophoneBoost(bool& enabled) const override;
 
     // Stereo support
-    virtual int32_t StereoPlayoutIsAvailable(bool& available) OVERRIDE;
-    virtual int32_t SetStereoPlayout(bool enable) OVERRIDE;
-    virtual int32_t StereoPlayout(bool& enabled) const OVERRIDE;
-    virtual int32_t StereoRecordingIsAvailable(bool& available) OVERRIDE;
-    virtual int32_t SetStereoRecording(bool enable) OVERRIDE;
-    virtual int32_t StereoRecording(bool& enabled) const OVERRIDE;
+    int32_t StereoPlayoutIsAvailable(bool& available) override;
+    int32_t SetStereoPlayout(bool enable) override;
+    int32_t StereoPlayout(bool& enabled) const override;
+    int32_t StereoRecordingIsAvailable(bool& available) override;
+    int32_t SetStereoRecording(bool enable) override;
+    int32_t StereoRecording(bool& enabled) const override;
 
     // Delay information and control
-    virtual int32_t
-        SetPlayoutBuffer(const AudioDeviceModule::BufferType type,
-                         uint16_t sizeMS) OVERRIDE;
-    virtual int32_t PlayoutBuffer(AudioDeviceModule::BufferType& type,
-                                  uint16_t& sizeMS) const OVERRIDE;
-    virtual int32_t PlayoutDelay(uint16_t& delayMS) const OVERRIDE;
-    virtual int32_t RecordingDelay(uint16_t& delayMS) const OVERRIDE;
+    int32_t SetPlayoutBuffer(const AudioDeviceModule::BufferType type,
+                             uint16_t sizeMS) override;
+    int32_t PlayoutBuffer(AudioDeviceModule::BufferType& type,
+                          uint16_t& sizeMS) const override;
+    int32_t PlayoutDelay(uint16_t& delayMS) const override;
+    int32_t RecordingDelay(uint16_t& delayMS) const override;
 
     // CPU load
-    virtual int32_t CPULoad(uint16_t& load) const OVERRIDE;
+    int32_t CPULoad(uint16_t& load) const override;
 
 public:
-    virtual bool PlayoutWarning() const OVERRIDE;
-    virtual bool PlayoutError() const OVERRIDE;
-    virtual bool RecordingWarning() const OVERRIDE;
-    virtual bool RecordingError() const OVERRIDE;
-    virtual void ClearPlayoutWarning() OVERRIDE;
-    virtual void ClearPlayoutError() OVERRIDE;
-    virtual void ClearRecordingWarning() OVERRIDE;
-    virtual void ClearRecordingError() OVERRIDE;
+ bool PlayoutWarning() const override;
+ bool PlayoutError() const override;
+ bool RecordingWarning() const override;
+ bool RecordingError() const override;
+ void ClearPlayoutWarning() override;
+ void ClearPlayoutError() override;
+ void ClearRecordingWarning() override;
+ void ClearRecordingError() override;
 
 public:
-    virtual void AttachAudioBuffer(AudioDeviceBuffer* audioBuffer) OVERRIDE;
+ void AttachAudioBuffer(AudioDeviceBuffer* audioBuffer) override;
 
 private:
     void Lock() EXCLUSIVE_LOCK_FUNCTION(_critSect) {
diff --git a/webrtc/modules/audio_device/linux/audio_device_utility_linux.h b/webrtc/modules/audio_device/linux/audio_device_utility_linux.h
index 0dc2646..f29e211 100644
--- a/webrtc/modules/audio_device/linux/audio_device_utility_linux.h
+++ b/webrtc/modules/audio_device/linux/audio_device_utility_linux.h
@@ -24,7 +24,7 @@
     AudioDeviceUtilityLinux(const int32_t id);
     virtual ~AudioDeviceUtilityLinux();
 
-    virtual int32_t Init() OVERRIDE;
+    int32_t Init() override;
 
 private:
     CriticalSectionWrapper& _critSect;
diff --git a/webrtc/modules/audio_processing/audio_processing_impl.cc b/webrtc/modules/audio_processing/audio_processing_impl.cc
index 5029bc7..200aa8b 100644
--- a/webrtc/modules/audio_processing/audio_processing_impl.cc
+++ b/webrtc/modules/audio_processing/audio_processing_impl.cc
@@ -75,60 +75,49 @@
   }
 
   // GainControl implementation.
-  virtual int Enable(bool enable) OVERRIDE {
+  int Enable(bool enable) override {
     return real_gain_control_->Enable(enable);
   }
-  virtual bool is_enabled() const OVERRIDE {
-    return real_gain_control_->is_enabled();
-  }
-  virtual int set_stream_analog_level(int level) OVERRIDE {
+  bool is_enabled() const override { return real_gain_control_->is_enabled(); }
+  int set_stream_analog_level(int level) override {
     volume_ = level;
     return AudioProcessing::kNoError;
   }
-  virtual int stream_analog_level() OVERRIDE {
-    return volume_;
-  }
-  virtual int set_mode(Mode mode) OVERRIDE { return AudioProcessing::kNoError; }
-  virtual Mode mode() const OVERRIDE { return GainControl::kAdaptiveAnalog; }
-  virtual int set_target_level_dbfs(int level) OVERRIDE {
+  int stream_analog_level() override { return volume_; }
+  int set_mode(Mode mode) override { return AudioProcessing::kNoError; }
+  Mode mode() const override { return GainControl::kAdaptiveAnalog; }
+  int set_target_level_dbfs(int level) override {
     return AudioProcessing::kNoError;
   }
-  virtual int target_level_dbfs() const OVERRIDE {
+  int target_level_dbfs() const override {
     return real_gain_control_->target_level_dbfs();
   }
-  virtual int set_compression_gain_db(int gain) OVERRIDE {
+  int set_compression_gain_db(int gain) override {
     return AudioProcessing::kNoError;
   }
-  virtual int compression_gain_db() const OVERRIDE {
+  int compression_gain_db() const override {
     return real_gain_control_->compression_gain_db();
   }
-  virtual int enable_limiter(bool enable) OVERRIDE {
-    return AudioProcessing::kNoError;
-  }
-  virtual bool is_limiter_enabled() const OVERRIDE {
+  int enable_limiter(bool enable) override { return AudioProcessing::kNoError; }
+  bool is_limiter_enabled() const override {
     return real_gain_control_->is_limiter_enabled();
   }
-  virtual int set_analog_level_limits(int minimum,
-                                      int maximum) OVERRIDE {
+  int set_analog_level_limits(int minimum, int maximum) override {
     return AudioProcessing::kNoError;
   }
-  virtual int analog_level_minimum() const OVERRIDE {
+  int analog_level_minimum() const override {
     return real_gain_control_->analog_level_minimum();
   }
-  virtual int analog_level_maximum() const OVERRIDE {
+  int analog_level_maximum() const override {
     return real_gain_control_->analog_level_maximum();
   }
-  virtual bool stream_is_saturated() const OVERRIDE {
+  bool stream_is_saturated() const override {
     return real_gain_control_->stream_is_saturated();
   }
 
   // VolumeCallbacks implementation.
-  virtual void SetMicVolume(int volume) OVERRIDE {
-    volume_ = volume;
-  }
-  virtual int GetMicVolume() OVERRIDE {
-    return volume_;
-  }
+  void SetMicVolume(int volume) override { volume_ = volume; }
+  int GetMicVolume() override { return volume_; }
 
  private:
   GainControl* real_gain_control_;
diff --git a/webrtc/modules/audio_processing/audio_processing_impl.h b/webrtc/modules/audio_processing/audio_processing_impl.h
index d82ef02..68abdf6 100644
--- a/webrtc/modules/audio_processing/audio_processing_impl.h
+++ b/webrtc/modules/audio_processing/audio_processing_impl.h
@@ -91,57 +91,55 @@
   virtual ~AudioProcessingImpl();
 
   // AudioProcessing methods.
-  virtual int Initialize() OVERRIDE;
-  virtual int Initialize(int input_sample_rate_hz,
-                         int output_sample_rate_hz,
-                         int reverse_sample_rate_hz,
-                         ChannelLayout input_layout,
-                         ChannelLayout output_layout,
-                         ChannelLayout reverse_layout) OVERRIDE;
-  virtual void SetExtraOptions(const Config& config) OVERRIDE;
-  virtual int set_sample_rate_hz(int rate) OVERRIDE;
-  virtual int input_sample_rate_hz() const OVERRIDE;
-  virtual int sample_rate_hz() const OVERRIDE;
-  virtual int proc_sample_rate_hz() const OVERRIDE;
-  virtual int proc_split_sample_rate_hz() const OVERRIDE;
-  virtual int num_input_channels() const OVERRIDE;
-  virtual int num_output_channels() const OVERRIDE;
-  virtual int num_reverse_channels() const OVERRIDE;
-  virtual void set_output_will_be_muted(bool muted) OVERRIDE;
-  virtual bool output_will_be_muted() const OVERRIDE;
-  virtual int ProcessStream(AudioFrame* frame) OVERRIDE;
-  virtual int ProcessStream(const float* const* src,
-                            int samples_per_channel,
-                            int input_sample_rate_hz,
-                            ChannelLayout input_layout,
-                            int output_sample_rate_hz,
-                            ChannelLayout output_layout,
-                            float* const* dest) OVERRIDE;
-  virtual int AnalyzeReverseStream(AudioFrame* frame) OVERRIDE;
-  virtual int AnalyzeReverseStream(const float* const* data,
-                                   int samples_per_channel,
-                                   int sample_rate_hz,
-                                   ChannelLayout layout) OVERRIDE;
-  virtual int set_stream_delay_ms(int delay) OVERRIDE;
-  virtual int stream_delay_ms() const OVERRIDE;
-  virtual bool was_stream_delay_set() const OVERRIDE;
-  virtual void set_delay_offset_ms(int offset) OVERRIDE;
-  virtual int delay_offset_ms() const OVERRIDE;
-  virtual void set_stream_key_pressed(bool key_pressed) OVERRIDE;
-  virtual bool stream_key_pressed() const OVERRIDE;
-  virtual int StartDebugRecording(
-      const char filename[kMaxFilenameSize]) OVERRIDE;
-  virtual int StartDebugRecording(FILE* handle) OVERRIDE;
-  virtual int StartDebugRecordingForPlatformFile(
-      rtc::PlatformFile handle) OVERRIDE;
-  virtual int StopDebugRecording() OVERRIDE;
-  virtual EchoCancellation* echo_cancellation() const OVERRIDE;
-  virtual EchoControlMobile* echo_control_mobile() const OVERRIDE;
-  virtual GainControl* gain_control() const OVERRIDE;
-  virtual HighPassFilter* high_pass_filter() const OVERRIDE;
-  virtual LevelEstimator* level_estimator() const OVERRIDE;
-  virtual NoiseSuppression* noise_suppression() const OVERRIDE;
-  virtual VoiceDetection* voice_detection() const OVERRIDE;
+  int Initialize() override;
+  int Initialize(int input_sample_rate_hz,
+                 int output_sample_rate_hz,
+                 int reverse_sample_rate_hz,
+                 ChannelLayout input_layout,
+                 ChannelLayout output_layout,
+                 ChannelLayout reverse_layout) override;
+  void SetExtraOptions(const Config& config) override;
+  int set_sample_rate_hz(int rate) override;
+  int input_sample_rate_hz() const override;
+  int sample_rate_hz() const override;
+  int proc_sample_rate_hz() const override;
+  int proc_split_sample_rate_hz() const override;
+  int num_input_channels() const override;
+  int num_output_channels() const override;
+  int num_reverse_channels() const override;
+  void set_output_will_be_muted(bool muted) override;
+  bool output_will_be_muted() const override;
+  int ProcessStream(AudioFrame* frame) override;
+  int ProcessStream(const float* const* src,
+                    int samples_per_channel,
+                    int input_sample_rate_hz,
+                    ChannelLayout input_layout,
+                    int output_sample_rate_hz,
+                    ChannelLayout output_layout,
+                    float* const* dest) override;
+  int AnalyzeReverseStream(AudioFrame* frame) override;
+  int AnalyzeReverseStream(const float* const* data,
+                           int samples_per_channel,
+                           int sample_rate_hz,
+                           ChannelLayout layout) override;
+  int set_stream_delay_ms(int delay) override;
+  int stream_delay_ms() const override;
+  bool was_stream_delay_set() const override;
+  void set_delay_offset_ms(int offset) override;
+  int delay_offset_ms() const override;
+  void set_stream_key_pressed(bool key_pressed) override;
+  bool stream_key_pressed() const override;
+  int StartDebugRecording(const char filename[kMaxFilenameSize]) override;
+  int StartDebugRecording(FILE* handle) override;
+  int StartDebugRecordingForPlatformFile(rtc::PlatformFile handle) override;
+  int StopDebugRecording() override;
+  EchoCancellation* echo_cancellation() const override;
+  EchoControlMobile* echo_control_mobile() const override;
+  GainControl* gain_control() const override;
+  HighPassFilter* high_pass_filter() const override;
+  LevelEstimator* level_estimator() const override;
+  NoiseSuppression* noise_suppression() const override;
+  VoiceDetection* voice_detection() const override;
 
  protected:
   // Overridden in a mock.
diff --git a/webrtc/modules/audio_processing/echo_cancellation_impl.h b/webrtc/modules/audio_processing/echo_cancellation_impl.h
index 4545938..ed3d7b5 100644
--- a/webrtc/modules/audio_processing/echo_cancellation_impl.h
+++ b/webrtc/modules/audio_processing/echo_cancellation_impl.h
@@ -30,39 +30,40 @@
   int ProcessCaptureAudio(AudioBuffer* audio);
 
   // EchoCancellation implementation.
-  virtual bool is_enabled() const OVERRIDE;
-  virtual int stream_drift_samples() const OVERRIDE;
+  bool is_enabled() const override;
+  int stream_drift_samples() const override;
 
   // ProcessingComponent implementation.
-  virtual int Initialize() OVERRIDE;
-  virtual void SetExtraOptions(const Config& config) OVERRIDE;
+  int Initialize() override;
+  void SetExtraOptions(const Config& config) override;
 
  private:
   // EchoCancellation implementation.
-  virtual int Enable(bool enable) OVERRIDE;
-  virtual int enable_drift_compensation(bool enable) OVERRIDE;
-  virtual bool is_drift_compensation_enabled() const OVERRIDE;
-  virtual void set_stream_drift_samples(int drift) OVERRIDE;
-  virtual int set_suppression_level(SuppressionLevel level) OVERRIDE;
-  virtual SuppressionLevel suppression_level() const OVERRIDE;
-  virtual int enable_metrics(bool enable) OVERRIDE;
-  virtual bool are_metrics_enabled() const OVERRIDE;
-  virtual bool stream_has_echo() const OVERRIDE;
-  virtual int GetMetrics(Metrics* metrics) OVERRIDE;
-  virtual int enable_delay_logging(bool enable) OVERRIDE;
-  virtual bool is_delay_logging_enabled() const OVERRIDE;
-  virtual int GetDelayMetrics(int* median, int* std) OVERRIDE;
-  virtual int GetDelayMetrics(int* median, int* std,
-                              float* fraction_poor_delays) OVERRIDE;
-  virtual struct AecCore* aec_core() const OVERRIDE;
+  int Enable(bool enable) override;
+  int enable_drift_compensation(bool enable) override;
+  bool is_drift_compensation_enabled() const override;
+  void set_stream_drift_samples(int drift) override;
+  int set_suppression_level(SuppressionLevel level) override;
+  SuppressionLevel suppression_level() const override;
+  int enable_metrics(bool enable) override;
+  bool are_metrics_enabled() const override;
+  bool stream_has_echo() const override;
+  int GetMetrics(Metrics* metrics) override;
+  int enable_delay_logging(bool enable) override;
+  bool is_delay_logging_enabled() const override;
+  int GetDelayMetrics(int* median, int* std) override;
+  int GetDelayMetrics(int* median,
+                      int* std,
+                      float* fraction_poor_delays) override;
+  struct AecCore* aec_core() const override;
 
   // ProcessingComponent implementation.
-  virtual void* CreateHandle() const OVERRIDE;
-  virtual int InitializeHandle(void* handle) const OVERRIDE;
-  virtual int ConfigureHandle(void* handle) const OVERRIDE;
-  virtual void DestroyHandle(void* handle) const OVERRIDE;
-  virtual int num_handles_required() const OVERRIDE;
-  virtual int GetHandleError(void* handle) const OVERRIDE;
+  void* CreateHandle() const override;
+  int InitializeHandle(void* handle) const override;
+  int ConfigureHandle(void* handle) const override;
+  void DestroyHandle(void* handle) const override;
+  int num_handles_required() const override;
+  int GetHandleError(void* handle) const override;
 
   const AudioProcessing* apm_;
   CriticalSectionWrapper* crit_;
diff --git a/webrtc/modules/audio_processing/echo_control_mobile_impl.h b/webrtc/modules/audio_processing/echo_control_mobile_impl.h
index 4f5b593..f399f48 100644
--- a/webrtc/modules/audio_processing/echo_control_mobile_impl.h
+++ b/webrtc/modules/audio_processing/echo_control_mobile_impl.h
@@ -30,28 +30,28 @@
   int ProcessCaptureAudio(AudioBuffer* audio);
 
   // EchoControlMobile implementation.
-  virtual bool is_enabled() const OVERRIDE;
+  bool is_enabled() const override;
 
   // ProcessingComponent implementation.
-  virtual int Initialize() OVERRIDE;
+  int Initialize() override;
 
  private:
   // EchoControlMobile implementation.
-  virtual int Enable(bool enable) OVERRIDE;
-  virtual int set_routing_mode(RoutingMode mode) OVERRIDE;
-  virtual RoutingMode routing_mode() const OVERRIDE;
-  virtual int enable_comfort_noise(bool enable) OVERRIDE;
-  virtual bool is_comfort_noise_enabled() const OVERRIDE;
-  virtual int SetEchoPath(const void* echo_path, size_t size_bytes) OVERRIDE;
-  virtual int GetEchoPath(void* echo_path, size_t size_bytes) const OVERRIDE;
+  int Enable(bool enable) override;
+  int set_routing_mode(RoutingMode mode) override;
+  RoutingMode routing_mode() const override;
+  int enable_comfort_noise(bool enable) override;
+  bool is_comfort_noise_enabled() const override;
+  int SetEchoPath(const void* echo_path, size_t size_bytes) override;
+  int GetEchoPath(void* echo_path, size_t size_bytes) const override;
 
   // ProcessingComponent implementation.
-  virtual void* CreateHandle() const OVERRIDE;
-  virtual int InitializeHandle(void* handle) const OVERRIDE;
-  virtual int ConfigureHandle(void* handle) const OVERRIDE;
-  virtual void DestroyHandle(void* handle) const OVERRIDE;
-  virtual int num_handles_required() const OVERRIDE;
-  virtual int GetHandleError(void* handle) const OVERRIDE;
+  void* CreateHandle() const override;
+  int InitializeHandle(void* handle) const override;
+  int ConfigureHandle(void* handle) const override;
+  void DestroyHandle(void* handle) const override;
+  int num_handles_required() const override;
+  int GetHandleError(void* handle) const override;
 
   const AudioProcessing* apm_;
   CriticalSectionWrapper* crit_;
diff --git a/webrtc/modules/audio_processing/gain_control_impl.h b/webrtc/modules/audio_processing/gain_control_impl.h
index 8115987..d648943 100644
--- a/webrtc/modules/audio_processing/gain_control_impl.h
+++ b/webrtc/modules/audio_processing/gain_control_impl.h
@@ -33,36 +33,36 @@
   int ProcessCaptureAudio(AudioBuffer* audio);
 
   // ProcessingComponent implementation.
-  virtual int Initialize() OVERRIDE;
+  int Initialize() override;
 
   // GainControl implementation.
-  virtual bool is_enabled() const OVERRIDE;
-  virtual int stream_analog_level() OVERRIDE;
+  bool is_enabled() const override;
+  int stream_analog_level() override;
 
  private:
   // GainControl implementation.
-  virtual int Enable(bool enable) OVERRIDE;
-  virtual int set_stream_analog_level(int level) OVERRIDE;
-  virtual int set_mode(Mode mode) OVERRIDE;
-  virtual Mode mode() const OVERRIDE;
-  virtual int set_target_level_dbfs(int level) OVERRIDE;
-  virtual int target_level_dbfs() const OVERRIDE;
-  virtual int set_compression_gain_db(int gain) OVERRIDE;
-  virtual int compression_gain_db() const OVERRIDE;
-  virtual int enable_limiter(bool enable) OVERRIDE;
-  virtual bool is_limiter_enabled() const OVERRIDE;
-  virtual int set_analog_level_limits(int minimum, int maximum) OVERRIDE;
-  virtual int analog_level_minimum() const OVERRIDE;
-  virtual int analog_level_maximum() const OVERRIDE;
-  virtual bool stream_is_saturated() const OVERRIDE;
+  int Enable(bool enable) override;
+  int set_stream_analog_level(int level) override;
+  int set_mode(Mode mode) override;
+  Mode mode() const override;
+  int set_target_level_dbfs(int level) override;
+  int target_level_dbfs() const override;
+  int set_compression_gain_db(int gain) override;
+  int compression_gain_db() const override;
+  int enable_limiter(bool enable) override;
+  bool is_limiter_enabled() const override;
+  int set_analog_level_limits(int minimum, int maximum) override;
+  int analog_level_minimum() const override;
+  int analog_level_maximum() const override;
+  bool stream_is_saturated() const override;
 
   // ProcessingComponent implementation.
-  virtual void* CreateHandle() const OVERRIDE;
-  virtual int InitializeHandle(void* handle) const OVERRIDE;
-  virtual int ConfigureHandle(void* handle) const OVERRIDE;
-  virtual void DestroyHandle(void* handle) const OVERRIDE;
-  virtual int num_handles_required() const OVERRIDE;
-  virtual int GetHandleError(void* handle) const OVERRIDE;
+  void* CreateHandle() const override;
+  int InitializeHandle(void* handle) const override;
+  int ConfigureHandle(void* handle) const override;
+  void DestroyHandle(void* handle) const override;
+  int num_handles_required() const override;
+  int GetHandleError(void* handle) const override;
 
   const AudioProcessing* apm_;
   CriticalSectionWrapper* crit_;
diff --git a/webrtc/modules/audio_processing/high_pass_filter_impl.h b/webrtc/modules/audio_processing/high_pass_filter_impl.h
index 6f91f3b..90b393e 100644
--- a/webrtc/modules/audio_processing/high_pass_filter_impl.h
+++ b/webrtc/modules/audio_processing/high_pass_filter_impl.h
@@ -28,19 +28,19 @@
   int ProcessCaptureAudio(AudioBuffer* audio);
 
   // HighPassFilter implementation.
-  virtual bool is_enabled() const OVERRIDE;
+  bool is_enabled() const override;
 
  private:
   // HighPassFilter implementation.
-  virtual int Enable(bool enable) OVERRIDE;
+  int Enable(bool enable) override;
 
   // ProcessingComponent implementation.
-  virtual void* CreateHandle() const OVERRIDE;
-  virtual int InitializeHandle(void* handle) const OVERRIDE;
-  virtual int ConfigureHandle(void* handle) const OVERRIDE;
-  virtual void DestroyHandle(void* handle) const OVERRIDE;
-  virtual int num_handles_required() const OVERRIDE;
-  virtual int GetHandleError(void* handle) const OVERRIDE;
+  void* CreateHandle() const override;
+  int InitializeHandle(void* handle) const override;
+  int ConfigureHandle(void* handle) const override;
+  void DestroyHandle(void* handle) const override;
+  int num_handles_required() const override;
+  int GetHandleError(void* handle) const override;
 
   const AudioProcessing* apm_;
   CriticalSectionWrapper* crit_;
diff --git a/webrtc/modules/audio_processing/level_estimator_impl.h b/webrtc/modules/audio_processing/level_estimator_impl.h
index b38337d..0d0050c 100644
--- a/webrtc/modules/audio_processing/level_estimator_impl.h
+++ b/webrtc/modules/audio_processing/level_estimator_impl.h
@@ -30,20 +30,20 @@
   int ProcessStream(AudioBuffer* audio);
 
   // LevelEstimator implementation.
-  virtual bool is_enabled() const OVERRIDE;
+  bool is_enabled() const override;
 
  private:
   // LevelEstimator implementation.
-  virtual int Enable(bool enable) OVERRIDE;
-  virtual int RMS() OVERRIDE;
+  int Enable(bool enable) override;
+  int RMS() override;
 
   // ProcessingComponent implementation.
-  virtual void* CreateHandle() const OVERRIDE;
-  virtual int InitializeHandle(void* handle) const OVERRIDE;
-  virtual int ConfigureHandle(void* handle) const OVERRIDE;
-  virtual void DestroyHandle(void* handle) const OVERRIDE;
-  virtual int num_handles_required() const OVERRIDE;
-  virtual int GetHandleError(void* handle) const OVERRIDE;
+  void* CreateHandle() const override;
+  int InitializeHandle(void* handle) const override;
+  int ConfigureHandle(void* handle) const override;
+  void DestroyHandle(void* handle) const override;
+  int num_handles_required() const override;
+  int GetHandleError(void* handle) const override;
 
   CriticalSectionWrapper* crit_;
 };
diff --git a/webrtc/modules/audio_processing/noise_suppression_impl.h b/webrtc/modules/audio_processing/noise_suppression_impl.h
index 14abe66..33a0e06 100644
--- a/webrtc/modules/audio_processing/noise_suppression_impl.h
+++ b/webrtc/modules/audio_processing/noise_suppression_impl.h
@@ -30,22 +30,22 @@
   int ProcessCaptureAudio(AudioBuffer* audio);
 
   // NoiseSuppression implementation.
-  virtual bool is_enabled() const OVERRIDE;
-  virtual float speech_probability() const OVERRIDE;
+  bool is_enabled() const override;
+  float speech_probability() const override;
 
  private:
   // NoiseSuppression implementation.
-  virtual int Enable(bool enable) OVERRIDE;
-  virtual int set_level(Level level) OVERRIDE;
-  virtual Level level() const OVERRIDE;
+  int Enable(bool enable) override;
+  int set_level(Level level) override;
+  Level level() const override;
 
   // ProcessingComponent implementation.
-  virtual void* CreateHandle() const OVERRIDE;
-  virtual int InitializeHandle(void* handle) const OVERRIDE;
-  virtual int ConfigureHandle(void* handle) const OVERRIDE;
-  virtual void DestroyHandle(void* handle) const OVERRIDE;
-  virtual int num_handles_required() const OVERRIDE;
-  virtual int GetHandleError(void* handle) const OVERRIDE;
+  void* CreateHandle() const override;
+  int InitializeHandle(void* handle) const override;
+  int ConfigureHandle(void* handle) const override;
+  void DestroyHandle(void* handle) const override;
+  int num_handles_required() const override;
+  int GetHandleError(void* handle) const override;
 
   const AudioProcessing* apm_;
   CriticalSectionWrapper* crit_;
diff --git a/webrtc/modules/audio_processing/voice_detection_impl.h b/webrtc/modules/audio_processing/voice_detection_impl.h
index 1dfdf20..32f031e 100644
--- a/webrtc/modules/audio_processing/voice_detection_impl.h
+++ b/webrtc/modules/audio_processing/voice_detection_impl.h
@@ -28,28 +28,28 @@
   int ProcessCaptureAudio(AudioBuffer* audio);
 
   // VoiceDetection implementation.
-  virtual bool is_enabled() const OVERRIDE;
+  bool is_enabled() const override;
 
   // ProcessingComponent implementation.
-  virtual int Initialize() OVERRIDE;
+  int Initialize() override;
 
  private:
   // VoiceDetection implementation.
-  virtual int Enable(bool enable) OVERRIDE;
-  virtual int set_stream_has_voice(bool has_voice) OVERRIDE;
-  virtual bool stream_has_voice() const OVERRIDE;
-  virtual int set_likelihood(Likelihood likelihood) OVERRIDE;
-  virtual Likelihood likelihood() const OVERRIDE;
-  virtual int set_frame_size_ms(int size) OVERRIDE;
-  virtual int frame_size_ms() const OVERRIDE;
+  int Enable(bool enable) override;
+  int set_stream_has_voice(bool has_voice) override;
+  bool stream_has_voice() const override;
+  int set_likelihood(Likelihood likelihood) override;
+  Likelihood likelihood() const override;
+  int set_frame_size_ms(int size) override;
+  int frame_size_ms() const override;
 
   // ProcessingComponent implementation.
-  virtual void* CreateHandle() const OVERRIDE;
-  virtual int InitializeHandle(void* handle) const OVERRIDE;
-  virtual int ConfigureHandle(void* handle) const OVERRIDE;
-  virtual void DestroyHandle(void* handle) const OVERRIDE;
-  virtual int num_handles_required() const OVERRIDE;
-  virtual int GetHandleError(void* handle) const OVERRIDE;
+  void* CreateHandle() const override;
+  int InitializeHandle(void* handle) const override;
+  int ConfigureHandle(void* handle) const override;
+  void DestroyHandle(void* handle) const override;
+  int num_handles_required() const override;
+  int GetHandleError(void* handle) const override;
 
   const AudioProcessing* apm_;
   CriticalSectionWrapper* crit_;
diff --git a/webrtc/modules/bitrate_controller/bitrate_controller_impl.cc b/webrtc/modules/bitrate_controller/bitrate_controller_impl.cc
index 586d8da..477276b 100644
--- a/webrtc/modules/bitrate_controller/bitrate_controller_impl.cc
+++ b/webrtc/modules/bitrate_controller/bitrate_controller_impl.cc
@@ -27,14 +27,13 @@
   virtual ~RtcpBandwidthObserverImpl() {
   }
   // Received RTCP REMB or TMMBR.
-  virtual void OnReceivedEstimatedBitrate(uint32_t bitrate) OVERRIDE {
+  void OnReceivedEstimatedBitrate(uint32_t bitrate) override {
     owner_->OnReceivedEstimatedBitrate(bitrate);
   }
   // Received RTCP receiver block.
-  virtual void OnReceivedRtcpReceiverReport(
-      const ReportBlockList& report_blocks,
-      int64_t rtt,
-      int64_t now_ms) OVERRIDE {
+  void OnReceivedRtcpReceiverReport(const ReportBlockList& report_blocks,
+                                    int64_t rtt,
+                                    int64_t now_ms) override {
     if (report_blocks.empty())
       return;
 
diff --git a/webrtc/modules/bitrate_controller/bitrate_controller_impl.h b/webrtc/modules/bitrate_controller/bitrate_controller_impl.h
index 1646f75..f089be9 100644
--- a/webrtc/modules/bitrate_controller/bitrate_controller_impl.h
+++ b/webrtc/modules/bitrate_controller/bitrate_controller_impl.h
@@ -32,23 +32,23 @@
   BitrateControllerImpl(Clock* clock, BitrateObserver* observer);
   virtual ~BitrateControllerImpl();
 
-  virtual bool AvailableBandwidth(uint32_t* bandwidth) const override;
+  bool AvailableBandwidth(uint32_t* bandwidth) const override;
 
-  virtual RtcpBandwidthObserver* CreateRtcpBandwidthObserver() override;
+  RtcpBandwidthObserver* CreateRtcpBandwidthObserver() override;
 
-  virtual void SetStartBitrate(int start_bitrate_bps) override;
-  virtual void SetMinMaxBitrate(int min_bitrate_bps,
+  void SetStartBitrate(int start_bitrate_bps) override;
+  void SetMinMaxBitrate(int min_bitrate_bps,
                                 int max_bitrate_bps) override;
 
-  virtual void SetReservedBitrate(uint32_t reserved_bitrate_bps) override;
+  void SetReservedBitrate(uint32_t reserved_bitrate_bps) override;
 
-  virtual int64_t TimeUntilNextProcess() override;
-  virtual int32_t Process() override;
+  int64_t TimeUntilNextProcess() override;
+  int32_t Process() override;
 
   // Current bitrate actually being sent.
-  virtual void SetBitrateSent(uint32_t bitrate_sent_bps) override;
+  void SetBitrateSent(uint32_t bitrate_sent_bps) override;
 
-  virtual void SetCodecMode(webrtc::VideoCodecMode mode) override;
+  void SetCodecMode(webrtc::VideoCodecMode mode) override;
 
  private:
   class RtcpBandwidthObserverImpl;
diff --git a/webrtc/modules/bitrate_controller/remb_suppressor_unittest.cc b/webrtc/modules/bitrate_controller/remb_suppressor_unittest.cc
index 7ce99a1..834ec5f 100644
--- a/webrtc/modules/bitrate_controller/remb_suppressor_unittest.cc
+++ b/webrtc/modules/bitrate_controller/remb_suppressor_unittest.cc
@@ -20,7 +20,7 @@
   explicit TestSuppressor(webrtc::Clock* clock) : RembSuppressor(clock) {}
   virtual ~TestSuppressor() {}
 
-  virtual bool Enabled() OVERRIDE { return true; }
+  bool Enabled() override { return true; }
 };
 
 class RembSuppressorTest : public ::testing::Test {
diff --git a/webrtc/modules/desktop_capture/cropping_window_capturer.h b/webrtc/modules/desktop_capture/cropping_window_capturer.h
index 4c30066..e0f598c 100644
--- a/webrtc/modules/desktop_capture/cropping_window_capturer.h
+++ b/webrtc/modules/desktop_capture/cropping_window_capturer.h
@@ -28,19 +28,19 @@
   virtual ~CroppingWindowCapturer();
 
   // DesktopCapturer implementation.
-  virtual void Start(DesktopCapturer::Callback* callback) OVERRIDE;
-  virtual void Capture(const DesktopRegion& region) OVERRIDE;
-  virtual void SetExcludedWindow(WindowId window) OVERRIDE;
+  void Start(DesktopCapturer::Callback* callback) override;
+  void Capture(const DesktopRegion& region) override;
+  void SetExcludedWindow(WindowId window) override;
 
   // WindowCapturer implementation.
-  virtual bool GetWindowList(WindowList* windows) OVERRIDE;
-  virtual bool SelectWindow(WindowId id) OVERRIDE;
-  virtual bool BringSelectedWindowToFront() OVERRIDE;
+  bool GetWindowList(WindowList* windows) override;
+  bool SelectWindow(WindowId id) override;
+  bool BringSelectedWindowToFront() override;
 
   // DesktopCapturer::Callback implementation, passed to |screen_capturer_| to
   // intercept the capture result.
-  virtual SharedMemory* CreateSharedMemory(size_t size) OVERRIDE;
-  virtual void OnCaptureCompleted(DesktopFrame* frame) OVERRIDE;
+  SharedMemory* CreateSharedMemory(size_t size) override;
+  void OnCaptureCompleted(DesktopFrame* frame) override;
 
  protected:
   explicit CroppingWindowCapturer(const DesktopCaptureOptions& options);
diff --git a/webrtc/modules/desktop_capture/cropping_window_capturer_win.cc b/webrtc/modules/desktop_capture/cropping_window_capturer_win.cc
index fc1858e..deffe66 100644
--- a/webrtc/modules/desktop_capture/cropping_window_capturer_win.cc
+++ b/webrtc/modules/desktop_capture/cropping_window_capturer_win.cc
@@ -113,8 +113,8 @@
       : CroppingWindowCapturer(options) {}
 
  private:
-  virtual bool ShouldUseScreenCapturer() OVERRIDE;
-  virtual DesktopRect GetWindowRectInVirtualScreen() OVERRIDE;
+  bool ShouldUseScreenCapturer() override;
+  DesktopRect GetWindowRectInVirtualScreen() override;
 
   // The region from GetWindowRgn in the desktop coordinate if the region is
   // rectangular, or the rect from GetWindowRect if the region is not set.
diff --git a/webrtc/modules/desktop_capture/desktop_and_cursor_composer.h b/webrtc/modules/desktop_capture/desktop_and_cursor_composer.h
index d402486..b16cf45 100644
--- a/webrtc/modules/desktop_capture/desktop_and_cursor_composer.h
+++ b/webrtc/modules/desktop_capture/desktop_and_cursor_composer.h
@@ -32,19 +32,19 @@
   virtual ~DesktopAndCursorComposer();
 
   // DesktopCapturer interface.
-  virtual void Start(DesktopCapturer::Callback* callback) OVERRIDE;
-  virtual void Capture(const DesktopRegion& region) OVERRIDE;
-  virtual void SetExcludedWindow(WindowId window) OVERRIDE;
+  void Start(DesktopCapturer::Callback* callback) override;
+  void Capture(const DesktopRegion& region) override;
+  void SetExcludedWindow(WindowId window) override;
 
  private:
   // DesktopCapturer::Callback interface.
-  virtual SharedMemory* CreateSharedMemory(size_t size) OVERRIDE;
-  virtual void OnCaptureCompleted(DesktopFrame* frame) OVERRIDE;
+  SharedMemory* CreateSharedMemory(size_t size) override;
+  void OnCaptureCompleted(DesktopFrame* frame) override;
 
   // MouseCursorMonitor::Callback interface.
-  virtual void OnMouseCursor(MouseCursor* cursor) OVERRIDE;
-  virtual void OnMouseCursorPosition(MouseCursorMonitor::CursorState state,
-                                     const DesktopVector& position) OVERRIDE;
+  void OnMouseCursor(MouseCursor* cursor) override;
+  void OnMouseCursorPosition(MouseCursorMonitor::CursorState state,
+                             const DesktopVector& position) override;
 
   rtc::scoped_ptr<DesktopCapturer> desktop_capturer_;
   rtc::scoped_ptr<MouseCursorMonitor> mouse_monitor_;
diff --git a/webrtc/modules/desktop_capture/desktop_and_cursor_composer_unittest.cc b/webrtc/modules/desktop_capture/desktop_and_cursor_composer_unittest.cc
index f1129ab..7fdfa1c 100644
--- a/webrtc/modules/desktop_capture/desktop_and_cursor_composer_unittest.cc
+++ b/webrtc/modules/desktop_capture/desktop_and_cursor_composer_unittest.cc
@@ -74,11 +74,9 @@
  public:
   FakeScreenCapturer() {}
 
-  virtual void Start(Callback* callback) OVERRIDE {
-    callback_ = callback;
-  }
+  void Start(Callback* callback) override { callback_ = callback; }
 
-  virtual void Capture(const DesktopRegion& region) OVERRIDE {
+  void Capture(const DesktopRegion& region) override {
     callback_->OnCaptureCompleted(next_frame_.release());
   }
 
@@ -107,11 +105,9 @@
     hotspot_ = hotspot;
   }
 
-  virtual void Init(Callback* callback, Mode mode) OVERRIDE {
-    callback_ = callback;
-  }
+  void Init(Callback* callback, Mode mode) override { callback_ = callback; }
 
-  virtual void Capture() OVERRIDE {
+  void Capture() override {
     if (changed_) {
       rtc::scoped_ptr<DesktopFrame> image(
           new BasicDesktopFrame(DesktopSize(kCursorWidth, kCursorHeight)));
@@ -172,13 +168,9 @@
   }
 
   // DesktopCapturer::Callback interface
-  virtual SharedMemory* CreateSharedMemory(size_t size) OVERRIDE {
-    return NULL;
-  }
+  SharedMemory* CreateSharedMemory(size_t size) override { return NULL; }
 
-  virtual void OnCaptureCompleted(DesktopFrame* frame) OVERRIDE {
-    frame_.reset(frame);
-  }
+  void OnCaptureCompleted(DesktopFrame* frame) override { frame_.reset(frame); }
 
  protected:
   // Owned by |blender_|.
diff --git a/webrtc/modules/desktop_capture/mouse_cursor_monitor_mac.mm b/webrtc/modules/desktop_capture/mouse_cursor_monitor_mac.mm
index 325feae..5a080fa 100644
--- a/webrtc/modules/desktop_capture/mouse_cursor_monitor_mac.mm
+++ b/webrtc/modules/desktop_capture/mouse_cursor_monitor_mac.mm
@@ -35,8 +35,8 @@
                         ScreenId screen_id);
   virtual ~MouseCursorMonitorMac();
 
-  virtual void Init(Callback* callback, Mode mode) OVERRIDE;
-  virtual void Capture() OVERRIDE;
+  void Init(Callback* callback, Mode mode) override;
+  void Capture() override;
 
  private:
   static void DisplaysReconfiguredCallback(CGDirectDisplayID display,
diff --git a/webrtc/modules/desktop_capture/mouse_cursor_monitor_unittest.cc b/webrtc/modules/desktop_capture/mouse_cursor_monitor_unittest.cc
index 36963a9..7238628 100644
--- a/webrtc/modules/desktop_capture/mouse_cursor_monitor_unittest.cc
+++ b/webrtc/modules/desktop_capture/mouse_cursor_monitor_unittest.cc
@@ -28,12 +28,12 @@
   }
 
   // MouseCursorMonitor::Callback interface
-  virtual void OnMouseCursor(MouseCursor* cursor_image) OVERRIDE {
+  void OnMouseCursor(MouseCursor* cursor_image) override {
     cursor_image_.reset(cursor_image);
   }
 
-  virtual void OnMouseCursorPosition(MouseCursorMonitor::CursorState state,
-                                     const DesktopVector& position) OVERRIDE {
+  void OnMouseCursorPosition(MouseCursorMonitor::CursorState state,
+                             const DesktopVector& position) override {
     state_ = state;
     position_ = position;
     position_received_ = true;
diff --git a/webrtc/modules/desktop_capture/mouse_cursor_monitor_win.cc b/webrtc/modules/desktop_capture/mouse_cursor_monitor_win.cc
index 8421161..3f4991e 100644
--- a/webrtc/modules/desktop_capture/mouse_cursor_monitor_win.cc
+++ b/webrtc/modules/desktop_capture/mouse_cursor_monitor_win.cc
@@ -26,8 +26,8 @@
   explicit MouseCursorMonitorWin(ScreenId screen);
   virtual ~MouseCursorMonitorWin();
 
-  virtual void Init(Callback* callback, Mode mode) OVERRIDE;
-  virtual void Capture() OVERRIDE;
+  void Init(Callback* callback, Mode mode) override;
+  void Capture() override;
 
  private:
   // Get the rect of the currently selected screen, relative to the primary
diff --git a/webrtc/modules/desktop_capture/mouse_cursor_monitor_x11.cc b/webrtc/modules/desktop_capture/mouse_cursor_monitor_x11.cc
index b116474..9b3cc17 100644
--- a/webrtc/modules/desktop_capture/mouse_cursor_monitor_x11.cc
+++ b/webrtc/modules/desktop_capture/mouse_cursor_monitor_x11.cc
@@ -63,12 +63,12 @@
   MouseCursorMonitorX11(const DesktopCaptureOptions& options, Window window);
   virtual ~MouseCursorMonitorX11();
 
-  virtual void Init(Callback* callback, Mode mode) OVERRIDE;
-  virtual void Capture() OVERRIDE;
+  void Init(Callback* callback, Mode mode) override;
+  void Capture() override;
 
  private:
   // SharedXDisplay::XEventHandler interface.
-  virtual bool HandleXEvent(const XEvent& event) OVERRIDE;
+  bool HandleXEvent(const XEvent& event) override;
 
   Display* display() { return x_display_->display(); }
 
diff --git a/webrtc/modules/desktop_capture/screen_capturer_mac.mm b/webrtc/modules/desktop_capture/screen_capturer_mac.mm
index af98e73..93e9a6f 100644
--- a/webrtc/modules/desktop_capture/screen_capturer_mac.mm
+++ b/webrtc/modules/desktop_capture/screen_capturer_mac.mm
@@ -196,11 +196,11 @@
   bool Init();
 
   // Overridden from ScreenCapturer:
-  virtual void Start(Callback* callback) OVERRIDE;
-  virtual void Capture(const DesktopRegion& region) OVERRIDE;
-  virtual void SetExcludedWindow(WindowId window) OVERRIDE;
-  virtual bool GetScreenList(ScreenList* screens) OVERRIDE;
-  virtual bool SelectScreen(ScreenId id) OVERRIDE;
+  void Start(Callback* callback) override;
+  void Capture(const DesktopRegion& region) override;
+  void SetExcludedWindow(WindowId window) override;
+  bool GetScreenList(ScreenList* screens) override;
+  bool SelectScreen(ScreenId id) override;
 
  private:
   void GlBlitFast(const DesktopFrame& frame,
diff --git a/webrtc/modules/desktop_capture/screen_capturer_mac_unittest.cc b/webrtc/modules/desktop_capture/screen_capturer_mac_unittest.cc
index c99138d..e3d037b 100644
--- a/webrtc/modules/desktop_capture/screen_capturer_mac_unittest.cc
+++ b/webrtc/modules/desktop_capture/screen_capturer_mac_unittest.cc
@@ -38,9 +38,7 @@
   void CaptureDoneCallback2(DesktopFrame* frame);
 
  protected:
-  virtual void SetUp() OVERRIDE {
-    capturer_.reset(ScreenCapturer::Create());
-  }
+  void SetUp() override { capturer_.reset(ScreenCapturer::Create()); }
 
   rtc::scoped_ptr<ScreenCapturer> capturer_;
   MockScreenCapturerCallback callback_;
diff --git a/webrtc/modules/desktop_capture/screen_capturer_unittest.cc b/webrtc/modules/desktop_capture/screen_capturer_unittest.cc
index 34eab7e..606c061 100644
--- a/webrtc/modules/desktop_capture/screen_capturer_unittest.cc
+++ b/webrtc/modules/desktop_capture/screen_capturer_unittest.cc
@@ -30,7 +30,7 @@
  public:
   SharedMemory* CreateSharedMemory(size_t size);
 
-  virtual void SetUp() OVERRIDE {
+  void SetUp() override {
     capturer_.reset(
         ScreenCapturer::Create(DesktopCaptureOptions::CreateDefault()));
   }
diff --git a/webrtc/modules/desktop_capture/screen_capturer_x11.cc b/webrtc/modules/desktop_capture/screen_capturer_x11.cc
index 0a758f9..1597e3f 100644
--- a/webrtc/modules/desktop_capture/screen_capturer_x11.cc
+++ b/webrtc/modules/desktop_capture/screen_capturer_x11.cc
@@ -50,18 +50,18 @@
   bool Init(const DesktopCaptureOptions& options);
 
   // DesktopCapturer interface.
-  virtual void Start(Callback* delegate) OVERRIDE;
-  virtual void Capture(const DesktopRegion& region) OVERRIDE;
+  void Start(Callback* delegate) override;
+  void Capture(const DesktopRegion& region) override;
 
   // ScreenCapturer interface.
-  virtual bool GetScreenList(ScreenList* screens) OVERRIDE;
-  virtual bool SelectScreen(ScreenId id) OVERRIDE;
+  bool GetScreenList(ScreenList* screens) override;
+  bool SelectScreen(ScreenId id) override;
 
  private:
   Display* display() { return options_.x_display()->display(); }
 
   // SharedXDisplay::XEventHandler interface.
-  virtual bool HandleXEvent(const XEvent& event) OVERRIDE;
+  bool HandleXEvent(const XEvent& event) override;
 
   void InitXDamage();
 
diff --git a/webrtc/modules/desktop_capture/win/screen_capturer_win_gdi.h b/webrtc/modules/desktop_capture/win/screen_capturer_win_gdi.h
index 34de7de..6014a18 100644
--- a/webrtc/modules/desktop_capture/win/screen_capturer_win_gdi.h
+++ b/webrtc/modules/desktop_capture/win/screen_capturer_win_gdi.h
@@ -33,10 +33,10 @@
   virtual ~ScreenCapturerWinGdi();
 
   // Overridden from ScreenCapturer:
-  virtual void Start(Callback* callback) OVERRIDE;
-  virtual void Capture(const DesktopRegion& region) OVERRIDE;
-  virtual bool GetScreenList(ScreenList* screens) OVERRIDE;
-  virtual bool SelectScreen(ScreenId id) OVERRIDE;
+  void Start(Callback* callback) override;
+  void Capture(const DesktopRegion& region) override;
+  bool GetScreenList(ScreenList* screens) override;
+  bool SelectScreen(ScreenId id) override;
 
  private:
   typedef HRESULT (WINAPI * DwmEnableCompositionFunc)(UINT);
diff --git a/webrtc/modules/desktop_capture/win/screen_capturer_win_magnifier.h b/webrtc/modules/desktop_capture/win/screen_capturer_win_magnifier.h
index 53caaa2..5bc0f81 100644
--- a/webrtc/modules/desktop_capture/win/screen_capturer_win_magnifier.h
+++ b/webrtc/modules/desktop_capture/win/screen_capturer_win_magnifier.h
@@ -43,11 +43,11 @@
   virtual ~ScreenCapturerWinMagnifier();
 
   // Overridden from ScreenCapturer:
-  virtual void Start(Callback* callback) OVERRIDE;
-  virtual void Capture(const DesktopRegion& region) OVERRIDE;
-  virtual bool GetScreenList(ScreenList* screens) OVERRIDE;
-  virtual bool SelectScreen(ScreenId id) OVERRIDE;
-  virtual void SetExcludedWindow(WindowId window) OVERRIDE;
+  void Start(Callback* callback) override;
+  void Capture(const DesktopRegion& region) override;
+  bool GetScreenList(ScreenList* screens) override;
+  bool SelectScreen(ScreenId id) override;
+  void SetExcludedWindow(WindowId window) override;
 
  private:
   typedef BOOL(WINAPI* MagImageScalingCallback)(HWND hwnd,
diff --git a/webrtc/modules/desktop_capture/window_capturer_mac.mm b/webrtc/modules/desktop_capture/window_capturer_mac.mm
index e69fc11..daa9fc7 100644
--- a/webrtc/modules/desktop_capture/window_capturer_mac.mm
+++ b/webrtc/modules/desktop_capture/window_capturer_mac.mm
@@ -50,13 +50,13 @@
   virtual ~WindowCapturerMac();
 
   // WindowCapturer interface.
-  virtual bool GetWindowList(WindowList* windows) OVERRIDE;
-  virtual bool SelectWindow(WindowId id) OVERRIDE;
-  virtual bool BringSelectedWindowToFront() OVERRIDE;
+  bool GetWindowList(WindowList* windows) override;
+  bool SelectWindow(WindowId id) override;
+  bool BringSelectedWindowToFront() override;
 
   // DesktopCapturer interface.
-  virtual void Start(Callback* callback) OVERRIDE;
-  virtual void Capture(const DesktopRegion& region) OVERRIDE;
+  void Start(Callback* callback) override;
+  void Capture(const DesktopRegion& region) override;
 
  private:
   Callback* callback_;
diff --git a/webrtc/modules/desktop_capture/window_capturer_null.cc b/webrtc/modules/desktop_capture/window_capturer_null.cc
index 5f9010d..d9ad0ca 100755
--- a/webrtc/modules/desktop_capture/window_capturer_null.cc
+++ b/webrtc/modules/desktop_capture/window_capturer_null.cc
@@ -24,13 +24,13 @@
   virtual ~WindowCapturerNull();
 
   // WindowCapturer interface.
-  virtual bool GetWindowList(WindowList* windows) OVERRIDE;
-  virtual bool SelectWindow(WindowId id) OVERRIDE;
-  virtual bool BringSelectedWindowToFront() OVERRIDE;
+  bool GetWindowList(WindowList* windows) override;
+  bool SelectWindow(WindowId id) override;
+  bool BringSelectedWindowToFront() override;
 
   // DesktopCapturer interface.
-  virtual void Start(Callback* callback) OVERRIDE;
-  virtual void Capture(const DesktopRegion& region) OVERRIDE;
+  void Start(Callback* callback) override;
+  void Capture(const DesktopRegion& region) override;
 
  private:
   Callback* callback_;
diff --git a/webrtc/modules/desktop_capture/window_capturer_unittest.cc b/webrtc/modules/desktop_capture/window_capturer_unittest.cc
index ac62c96..bb4ddf0 100644
--- a/webrtc/modules/desktop_capture/window_capturer_unittest.cc
+++ b/webrtc/modules/desktop_capture/window_capturer_unittest.cc
@@ -22,22 +22,17 @@
 class WindowCapturerTest : public testing::Test,
                            public DesktopCapturer::Callback {
  public:
-  void SetUp() OVERRIDE {
+  void SetUp() override {
     capturer_.reset(
         WindowCapturer::Create(DesktopCaptureOptions::CreateDefault()));
   }
 
-  void TearDown() OVERRIDE {
-  }
+  void TearDown() override {}
 
   // DesktopCapturer::Callback interface
-  virtual SharedMemory* CreateSharedMemory(size_t size) OVERRIDE {
-    return NULL;
-  }
+  SharedMemory* CreateSharedMemory(size_t size) override { return NULL; }
 
-  virtual void OnCaptureCompleted(DesktopFrame* frame) OVERRIDE {
-    frame_.reset(frame);
-  }
+  void OnCaptureCompleted(DesktopFrame* frame) override { frame_.reset(frame); }
 
  protected:
   rtc::scoped_ptr<WindowCapturer> capturer_;
diff --git a/webrtc/modules/desktop_capture/window_capturer_win.cc b/webrtc/modules/desktop_capture/window_capturer_win.cc
index 5d6bf64..c7e1fd8 100644
--- a/webrtc/modules/desktop_capture/window_capturer_win.cc
+++ b/webrtc/modules/desktop_capture/window_capturer_win.cc
@@ -72,13 +72,13 @@
   virtual ~WindowCapturerWin();
 
   // WindowCapturer interface.
-  virtual bool GetWindowList(WindowList* windows) OVERRIDE;
-  virtual bool SelectWindow(WindowId id) OVERRIDE;
-  virtual bool BringSelectedWindowToFront() OVERRIDE;
+  bool GetWindowList(WindowList* windows) override;
+  bool SelectWindow(WindowId id) override;
+  bool BringSelectedWindowToFront() override;
 
   // DesktopCapturer interface.
-  virtual void Start(Callback* callback) OVERRIDE;
-  virtual void Capture(const DesktopRegion& region) OVERRIDE;
+  void Start(Callback* callback) override;
+  void Capture(const DesktopRegion& region) override;
 
  private:
   bool IsAeroEnabled();
diff --git a/webrtc/modules/desktop_capture/window_capturer_x11.cc b/webrtc/modules/desktop_capture/window_capturer_x11.cc
index 0a90b0c..8dacd46 100755
--- a/webrtc/modules/desktop_capture/window_capturer_x11.cc
+++ b/webrtc/modules/desktop_capture/window_capturer_x11.cc
@@ -92,16 +92,16 @@
   virtual ~WindowCapturerLinux();
 
   // WindowCapturer interface.
-  virtual bool GetWindowList(WindowList* windows) OVERRIDE;
-  virtual bool SelectWindow(WindowId id) OVERRIDE;
-  virtual bool BringSelectedWindowToFront() OVERRIDE;
+  bool GetWindowList(WindowList* windows) override;
+  bool SelectWindow(WindowId id) override;
+  bool BringSelectedWindowToFront() override;
 
   // DesktopCapturer interface.
-  virtual void Start(Callback* callback) OVERRIDE;
-  virtual void Capture(const DesktopRegion& region) OVERRIDE;
+  void Start(Callback* callback) override;
+  void Capture(const DesktopRegion& region) override;
 
   // SharedXDisplay::XEventHandler interface.
-  virtual bool HandleXEvent(const XEvent& event) OVERRIDE;
+  bool HandleXEvent(const XEvent& event) override;
 
  private:
   Display* display() { return x_display_->display(); }
diff --git a/webrtc/modules/media_file/source/media_file_impl.h b/webrtc/modules/media_file/source/media_file_impl.h
index 9b14a86..c5038bb 100644
--- a/webrtc/modules/media_file/source/media_file_impl.h
+++ b/webrtc/modules/media_file/source/media_file_impl.h
@@ -26,72 +26,71 @@
     MediaFileImpl(const int32_t id);
     ~MediaFileImpl();
 
-    virtual int32_t Process() OVERRIDE;
-    virtual int64_t TimeUntilNextProcess() OVERRIDE;
+    int32_t Process() override;
+    int64_t TimeUntilNextProcess() override;
 
     // MediaFile functions
-    virtual int32_t PlayoutAudioData(int8_t* audioBuffer,
-                                     size_t& dataLengthInBytes) OVERRIDE;
+    int32_t PlayoutAudioData(int8_t* audioBuffer,
+                             size_t& dataLengthInBytes) override;
 
-    virtual int32_t PlayoutStereoData(int8_t* audioBufferLeft,
-                                      int8_t* audioBufferRight,
-                                      size_t& dataLengthInBytes) OVERRIDE;
+    int32_t PlayoutStereoData(int8_t* audioBufferLeft,
+                              int8_t* audioBufferRight,
+                              size_t& dataLengthInBytes) override;
 
-    virtual int32_t StartPlayingAudioFile(
-        const char*  fileName,
+    int32_t StartPlayingAudioFile(
+        const char* fileName,
         const uint32_t notificationTimeMs = 0,
-        const bool           loop = false,
-        const FileFormats    format = kFileFormatPcm16kHzFile,
-        const CodecInst*     codecInst = NULL,
+        const bool loop = false,
+        const FileFormats format = kFileFormatPcm16kHzFile,
+        const CodecInst* codecInst = NULL,
         const uint32_t startPointMs = 0,
-        const uint32_t stopPointMs = 0) OVERRIDE;
+        const uint32_t stopPointMs = 0) override;
 
-    virtual int32_t StartPlayingAudioStream(InStream& stream,
+    int32_t StartPlayingAudioStream(
+        InStream& stream,
         const uint32_t notificationTimeMs = 0,
         const FileFormats format = kFileFormatPcm16kHzFile,
         const CodecInst* codecInst = NULL,
         const uint32_t startPointMs = 0,
-        const uint32_t stopPointMs = 0) OVERRIDE;
+        const uint32_t stopPointMs = 0) override;
 
-    virtual int32_t StopPlaying() OVERRIDE;
+    int32_t StopPlaying() override;
 
-    virtual bool IsPlaying() OVERRIDE;
+    bool IsPlaying() override;
 
-    virtual int32_t PlayoutPositionMs(uint32_t& positionMs) const OVERRIDE;
+    int32_t PlayoutPositionMs(uint32_t& positionMs) const override;
 
-    virtual int32_t IncomingAudioData(const int8_t* audioBuffer,
-                                      const size_t bufferLength) OVERRIDE;
+    int32_t IncomingAudioData(const int8_t* audioBuffer,
+                              const size_t bufferLength) override;
 
-    virtual int32_t StartRecordingAudioFile(
-        const char*  fileName,
-        const FileFormats    format,
-        const CodecInst&     codecInst,
-        const uint32_t notificationTimeMs = 0,
-        const uint32_t maxSizeBytes = 0) OVERRIDE;
+    int32_t StartRecordingAudioFile(const char* fileName,
+                                    const FileFormats format,
+                                    const CodecInst& codecInst,
+                                    const uint32_t notificationTimeMs = 0,
+                                    const uint32_t maxSizeBytes = 0) override;
 
-    virtual int32_t StartRecordingAudioStream(
-        OutStream&           stream,
-        const FileFormats    format,
-        const CodecInst&     codecInst,
-        const uint32_t notificationTimeMs = 0) OVERRIDE;
+    int32_t StartRecordingAudioStream(
+        OutStream& stream,
+        const FileFormats format,
+        const CodecInst& codecInst,
+        const uint32_t notificationTimeMs = 0) override;
 
-    virtual int32_t StopRecording() OVERRIDE;
+    int32_t StopRecording() override;
 
-    virtual bool IsRecording() OVERRIDE;
+    bool IsRecording() override;
 
-    virtual int32_t RecordDurationMs(uint32_t& durationMs) OVERRIDE;
+    int32_t RecordDurationMs(uint32_t& durationMs) override;
 
-    virtual bool IsStereo() OVERRIDE;
+    bool IsStereo() override;
 
-    virtual int32_t SetModuleFileCallback(FileCallback* callback) OVERRIDE;
+    int32_t SetModuleFileCallback(FileCallback* callback) override;
 
-    virtual int32_t FileDurationMs(
-        const char*  fileName,
-        uint32_t&      durationMs,
-        const FileFormats    format,
-        const uint32_t freqInHz = 16000) OVERRIDE;
+    int32_t FileDurationMs(const char* fileName,
+                           uint32_t& durationMs,
+                           const FileFormats format,
+                           const uint32_t freqInHz = 16000) override;
 
-    virtual int32_t codec_info(CodecInst& codecInst) const OVERRIDE;
+    int32_t codec_info(CodecInst& codecInst) const override;
 
 private:
     // Returns true if the combination of format and codecInst is valid.
diff --git a/webrtc/modules/pacing/include/paced_sender.h b/webrtc/modules/pacing/include/paced_sender.h
index efd4217..645999d 100644
--- a/webrtc/modules/pacing/include/paced_sender.h
+++ b/webrtc/modules/pacing/include/paced_sender.h
@@ -121,10 +121,10 @@
 
   // Returns the number of milliseconds until the module want a worker thread
   // to call Process.
-  virtual int64_t TimeUntilNextProcess() OVERRIDE;
+  int64_t TimeUntilNextProcess() override;
 
   // Process any pending packets in the queue(s).
-  virtual int32_t Process() OVERRIDE;
+  int32_t Process() override;
 
  private:
   // Updates the number of bytes that can be sent for the next time interval.
diff --git a/webrtc/modules/remote_bitrate_estimator/aimd_rate_control.h b/webrtc/modules/remote_bitrate_estimator/aimd_rate_control.h
index b5aee76..56f1c1a 100644
--- a/webrtc/modules/remote_bitrate_estimator/aimd_rate_control.h
+++ b/webrtc/modules/remote_bitrate_estimator/aimd_rate_control.h
@@ -27,22 +27,22 @@
   virtual ~AimdRateControl() {}
 
   // Implements RemoteRateControl.
-  virtual bool ValidEstimate() const OVERRIDE;
-  virtual RateControlType GetControlType() const OVERRIDE;
-  virtual uint32_t GetMinBitrate() const OVERRIDE;
-  virtual int64_t GetFeedbackInterval() const OVERRIDE;
+  bool ValidEstimate() const override;
+  RateControlType GetControlType() const override;
+  uint32_t GetMinBitrate() const override;
+  int64_t GetFeedbackInterval() const override;
   // Returns true if the bitrate estimate hasn't been changed for more than
   // an RTT, or if the incoming_bitrate is more than 5% above the current
   // estimate. Should be used to decide if we should reduce the rate further
   // when over-using.
-  virtual bool TimeToReduceFurther(
-      int64_t time_now, uint32_t incoming_bitrate_bps) const OVERRIDE;
-  virtual uint32_t LatestEstimate() const OVERRIDE;
-  virtual uint32_t UpdateBandwidthEstimate(int64_t now_ms) OVERRIDE;
-  virtual void SetRtt(int64_t rtt) OVERRIDE;
-  virtual RateControlRegion Update(const RateControlInput* input,
-                                   int64_t now_ms) OVERRIDE;
-  virtual void SetEstimate(int bitrate_bps, int64_t now_ms) OVERRIDE;
+  bool TimeToReduceFurther(int64_t time_now,
+                           uint32_t incoming_bitrate_bps) const override;
+  uint32_t LatestEstimate() const override;
+  uint32_t UpdateBandwidthEstimate(int64_t now_ms) override;
+  void SetRtt(int64_t rtt) override;
+  RateControlRegion Update(const RateControlInput* input,
+                           int64_t now_ms) override;
+  void SetEstimate(int bitrate_bps, int64_t now_ms) override;
 
  private:
   // Update the target bitrate according based on, among other things,
diff --git a/webrtc/modules/remote_bitrate_estimator/bwe_simulations.cc b/webrtc/modules/remote_bitrate_estimator/bwe_simulations.cc
index de28c9a..9964293 100644
--- a/webrtc/modules/remote_bitrate_estimator/bwe_simulations.cc
+++ b/webrtc/modules/remote_bitrate_estimator/bwe_simulations.cc
@@ -30,7 +30,7 @@
   virtual ~BweSimulation() {}
 
  protected:
-  virtual void SetUp() OVERRIDE { BweTest::SetUp(); }
+  void SetUp() override { BweTest::SetUp(); }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(BweSimulation);
diff --git a/webrtc/modules/remote_bitrate_estimator/mimd_rate_control.h b/webrtc/modules/remote_bitrate_estimator/mimd_rate_control.h
index 1b1862c..d157993 100644
--- a/webrtc/modules/remote_bitrate_estimator/mimd_rate_control.h
+++ b/webrtc/modules/remote_bitrate_estimator/mimd_rate_control.h
@@ -25,18 +25,18 @@
   virtual ~MimdRateControl() {}
 
   // Implements RemoteRateControl.
-  virtual RateControlType GetControlType() const OVERRIDE;
-  virtual uint32_t GetMinBitrate() const OVERRIDE;
-  virtual bool ValidEstimate() const OVERRIDE;
-  virtual int64_t GetFeedbackInterval() const OVERRIDE;
-  virtual bool TimeToReduceFurther(
-      int64_t time_now, uint32_t incoming_bitrate_bps) const OVERRIDE;
-  virtual uint32_t LatestEstimate() const OVERRIDE;
-  virtual uint32_t UpdateBandwidthEstimate(int64_t now_ms) OVERRIDE;
-  virtual void SetRtt(int64_t rtt) OVERRIDE;
-  virtual RateControlRegion Update(const RateControlInput* input,
-                                   int64_t now_ms) OVERRIDE;
-  virtual void SetEstimate(int bitrate_bps, int64_t now_ms) OVERRIDE;
+  RateControlType GetControlType() const override;
+  uint32_t GetMinBitrate() const override;
+  bool ValidEstimate() const override;
+  int64_t GetFeedbackInterval() const override;
+  bool TimeToReduceFurther(int64_t time_now,
+                           uint32_t incoming_bitrate_bps) const override;
+  uint32_t LatestEstimate() const override;
+  uint32_t UpdateBandwidthEstimate(int64_t now_ms) override;
+  void SetRtt(int64_t rtt) override;
+  RateControlRegion Update(const RateControlInput* input,
+                           int64_t now_ms) override;
+  void SetEstimate(int bitrate_bps, int64_t now_ms) override;
 
  private:
   uint32_t ChangeBitRate(uint32_t current_bit_rate,
diff --git a/webrtc/modules/remote_bitrate_estimator/remote_bitrate_estimator_abs_send_time.cc b/webrtc/modules/remote_bitrate_estimator/remote_bitrate_estimator_abs_send_time.cc
index c20683d..65e5401 100644
--- a/webrtc/modules/remote_bitrate_estimator/remote_bitrate_estimator_abs_send_time.cc
+++ b/webrtc/modules/remote_bitrate_estimator/remote_bitrate_estimator_abs_send_time.cc
@@ -111,23 +111,23 @@
                                         uint32_t min_bitrate_bps);
   virtual ~RemoteBitrateEstimatorAbsSendTimeImpl() {}
 
-  virtual void IncomingPacketFeedbackVector(
-      const std::vector<PacketInfo>& packet_feedback_vector) OVERRIDE;
+  void IncomingPacketFeedbackVector(
+      const std::vector<PacketInfo>& packet_feedback_vector) override;
 
-  virtual void IncomingPacket(int64_t arrival_time_ms,
-                              size_t payload_size,
-                              const RTPHeader& header) OVERRIDE;
+  void IncomingPacket(int64_t arrival_time_ms,
+                      size_t payload_size,
+                      const RTPHeader& header) override;
   // This class relies on Process() being called periodically (at least once
   // every other second) for streams to be timed out properly. Therefore it
   // shouldn't be detached from the ProcessThread except if it's about to be
   // deleted.
-  virtual int32_t Process() OVERRIDE;
-  virtual int64_t TimeUntilNextProcess() OVERRIDE;
-  virtual void OnRttUpdate(int64_t rtt) OVERRIDE;
-  virtual void RemoveStream(unsigned int ssrc) OVERRIDE;
-  virtual bool LatestEstimate(std::vector<unsigned int>* ssrcs,
-                              unsigned int* bitrate_bps) const OVERRIDE;
-  virtual bool GetStats(ReceiveBandwidthEstimatorStats* output) const OVERRIDE;
+  int32_t Process() override;
+  int64_t TimeUntilNextProcess() override;
+  void OnRttUpdate(int64_t rtt) override;
+  void RemoveStream(unsigned int ssrc) override;
+  bool LatestEstimate(std::vector<unsigned int>* ssrcs,
+                      unsigned int* bitrate_bps) const override;
+  bool GetStats(ReceiveBandwidthEstimatorStats* output) const override;
 
  private:
   typedef std::map<unsigned int, int64_t> Ssrcs;
diff --git a/webrtc/modules/remote_bitrate_estimator/remote_bitrate_estimator_single_stream.cc b/webrtc/modules/remote_bitrate_estimator/remote_bitrate_estimator_single_stream.cc
index f9eef2a..72c476d 100644
--- a/webrtc/modules/remote_bitrate_estimator/remote_bitrate_estimator_single_stream.cc
+++ b/webrtc/modules/remote_bitrate_estimator/remote_bitrate_estimator_single_stream.cc
@@ -36,16 +36,16 @@
                              uint32_t min_bitrate_bps);
   virtual ~RemoteBitrateEstimatorImpl();
 
-  virtual void IncomingPacket(int64_t arrival_time_ms,
-                              size_t payload_size,
-                              const RTPHeader& header) OVERRIDE;
-  virtual int32_t Process() OVERRIDE;
-  virtual int64_t TimeUntilNextProcess() OVERRIDE;
-  virtual void OnRttUpdate(int64_t rtt) OVERRIDE;
-  virtual void RemoveStream(unsigned int ssrc) OVERRIDE;
-  virtual bool LatestEstimate(std::vector<unsigned int>* ssrcs,
-                              unsigned int* bitrate_bps) const OVERRIDE;
-  virtual bool GetStats(ReceiveBandwidthEstimatorStats* output) const OVERRIDE;
+  void IncomingPacket(int64_t arrival_time_ms,
+                      size_t payload_size,
+                      const RTPHeader& header) override;
+  int32_t Process() override;
+  int64_t TimeUntilNextProcess() override;
+  void OnRttUpdate(int64_t rtt) override;
+  void RemoveStream(unsigned int ssrc) override;
+  bool LatestEstimate(std::vector<unsigned int>* ssrcs,
+                      unsigned int* bitrate_bps) const override;
+  bool GetStats(ReceiveBandwidthEstimatorStats* output) const override;
 
  private:
   struct Detector {
diff --git a/webrtc/modules/remote_bitrate_estimator/remote_bitrate_estimator_unittest_helper.h b/webrtc/modules/remote_bitrate_estimator/remote_bitrate_estimator_unittest_helper.h
index 83cd97f..8da880f 100644
--- a/webrtc/modules/remote_bitrate_estimator/remote_bitrate_estimator_unittest_helper.h
+++ b/webrtc/modules/remote_bitrate_estimator/remote_bitrate_estimator_unittest_helper.h
@@ -29,8 +29,8 @@
   TestBitrateObserver() : updated_(false), latest_bitrate_(0) {}
   virtual ~TestBitrateObserver() {}
 
-  virtual void OnReceiveBitrateChanged(const std::vector<unsigned int>& ssrcs,
-                                       unsigned int bitrate) OVERRIDE;
+  void OnReceiveBitrateChanged(const std::vector<unsigned int>& ssrcs,
+                               unsigned int bitrate) override;
 
   void Reset() { updated_ = false; }
 
diff --git a/webrtc/modules/remote_bitrate_estimator/remote_bitrate_estimators_test.cc b/webrtc/modules/remote_bitrate_estimator/remote_bitrate_estimators_test.cc
index c81764e..d1b9ea7 100644
--- a/webrtc/modules/remote_bitrate_estimator/remote_bitrate_estimators_test.cc
+++ b/webrtc/modules/remote_bitrate_estimator/remote_bitrate_estimators_test.cc
@@ -267,7 +267,7 @@
   }
 
  protected:
-  virtual void SetUp() OVERRIDE { BweTest::SetUp(); }
+  void SetUp() override { BweTest::SetUp(); }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(BweFeedbackTest);
diff --git a/webrtc/modules/remote_bitrate_estimator/test/bwe.cc b/webrtc/modules/remote_bitrate_estimator/test/bwe.cc
index 3221d2b..bd22e3e 100644
--- a/webrtc/modules/remote_bitrate_estimator/test/bwe.cc
+++ b/webrtc/modules/remote_bitrate_estimator/test/bwe.cc
@@ -26,12 +26,12 @@
   NullBweSender() {}
   virtual ~NullBweSender() {}
 
-  virtual int GetFeedbackIntervalMs() const override { return 1000; }
-  virtual void GiveFeedback(const FeedbackPacket& feedback) override {}
-  virtual int64_t TimeUntilNextProcess() override {
+  int GetFeedbackIntervalMs() const override { return 1000; }
+  void GiveFeedback(const FeedbackPacket& feedback) override {}
+  int64_t TimeUntilNextProcess() override {
     return std::numeric_limits<int64_t>::max();
   }
-  virtual int Process() override { return 0; }
+  int Process() override { return 0; }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(NullBweSender);
diff --git a/webrtc/modules/remote_bitrate_estimator/test/bwe_test_framework.h b/webrtc/modules/remote_bitrate_estimator/test/bwe_test_framework.h
index 902e48f..9e893de 100644
--- a/webrtc/modules/remote_bitrate_estimator/test/bwe_test_framework.h
+++ b/webrtc/modules/remote_bitrate_estimator/test/bwe_test_framework.h
@@ -403,7 +403,7 @@
                       int64_t first_frame_offset_ms);
   virtual ~AdaptiveVideoSource() {}
 
-  virtual void SetBitrateBps(int bitrate_bps) OVERRIDE;
+  void SetBitrateBps(int bitrate_bps) override;
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(AdaptiveVideoSource);
@@ -420,9 +420,9 @@
   virtual ~PeriodicKeyFrameSource() {}
 
  protected:
-  virtual uint32_t NextFrameSize() OVERRIDE;
-  virtual uint32_t NextPacketSize(uint32_t frame_size,
-                                  uint32_t remaining_payload) OVERRIDE;
+  uint32_t NextFrameSize() override;
+  uint32_t NextPacketSize(uint32_t frame_size,
+                          uint32_t remaining_payload) override;
 
  private:
   int key_frame_interval_;
diff --git a/webrtc/modules/remote_bitrate_estimator/test/packet_receiver.h b/webrtc/modules/remote_bitrate_estimator/test/packet_receiver.h
index 18fd978..6d94ea7 100644
--- a/webrtc/modules/remote_bitrate_estimator/test/packet_receiver.h
+++ b/webrtc/modules/remote_bitrate_estimator/test/packet_receiver.h
@@ -32,7 +32,7 @@
   ~PacketReceiver();
 
   // Implements PacketProcessor.
-  virtual void RunFor(int64_t time_ms, Packets* in_out) OVERRIDE;
+  void RunFor(int64_t time_ms, Packets* in_out) override;
 
   void LogStats();
 
diff --git a/webrtc/modules/remote_bitrate_estimator/test/packet_sender.h b/webrtc/modules/remote_bitrate_estimator/test/packet_sender.h
index e5cbbcb..8c13cb1 100644
--- a/webrtc/modules/remote_bitrate_estimator/test/packet_sender.h
+++ b/webrtc/modules/remote_bitrate_estimator/test/packet_sender.h
@@ -37,14 +37,14 @@
   // output of the estimators is sampled and therefore the baseline files may
   // have to be regenerated.
   virtual int GetFeedbackIntervalMs() const;
-  virtual void RunFor(int64_t time_ms, Packets* in_out) OVERRIDE;
+  void RunFor(int64_t time_ms, Packets* in_out) override;
 
   virtual VideoSource* source() const { return source_; }
 
   // Implements BitrateObserver.
-  virtual void OnNetworkChanged(uint32_t target_bitrate_bps,
-                                uint8_t fraction_lost,
-                                int64_t rtt) OVERRIDE;
+  void OnNetworkChanged(uint32_t target_bitrate_bps,
+                        uint8_t fraction_lost,
+                        int64_t rtt) override;
 
  protected:
   void ProcessFeedbackAndGeneratePackets(int64_t time_ms,
@@ -70,19 +70,19 @@
                    BandwidthEstimatorType estimator);
   virtual ~PacedVideoSender();
 
-  virtual void RunFor(int64_t time_ms, Packets* in_out) OVERRIDE;
+  void RunFor(int64_t time_ms, Packets* in_out) override;
 
   // Implements PacedSender::Callback.
-  virtual bool TimeToSendPacket(uint32_t ssrc,
-                                uint16_t sequence_number,
-                                int64_t capture_time_ms,
-                                bool retransmission) OVERRIDE;
-  virtual size_t TimeToSendPadding(size_t bytes) OVERRIDE;
+  bool TimeToSendPacket(uint32_t ssrc,
+                        uint16_t sequence_number,
+                        int64_t capture_time_ms,
+                        bool retransmission) override;
+  size_t TimeToSendPadding(size_t bytes) override;
 
   // Implements BitrateObserver.
-  virtual void OnNetworkChanged(uint32_t target_bitrate_bps,
-                                uint8_t fraction_lost,
-                                int64_t rtt) OVERRIDE;
+  void OnNetworkChanged(uint32_t target_bitrate_bps,
+                        uint8_t fraction_lost,
+                        int64_t rtt) override;
 
  private:
   int64_t TimeUntilNextProcess(const std::list<Module*>& modules);
diff --git a/webrtc/modules/rtp_rtcp/interface/receive_statistics.h b/webrtc/modules/rtp_rtcp/interface/receive_statistics.h
index 3bd953f..f7de91f 100644
--- a/webrtc/modules/rtp_rtcp/interface/receive_statistics.h
+++ b/webrtc/modules/rtp_rtcp/interface/receive_statistics.h
@@ -85,20 +85,20 @@
 
 class NullReceiveStatistics : public ReceiveStatistics {
  public:
-  virtual void IncomingPacket(const RTPHeader& rtp_header,
-                              size_t packet_length,
-                              bool retransmitted) OVERRIDE;
-  virtual void FecPacketReceived(const RTPHeader& header,
-                                 size_t packet_length) OVERRIDE;
-  virtual StatisticianMap GetActiveStatisticians() const OVERRIDE;
-  virtual StreamStatistician* GetStatistician(uint32_t ssrc) const OVERRIDE;
-  virtual int64_t TimeUntilNextProcess() OVERRIDE;
-  virtual int32_t Process() OVERRIDE;
-  virtual void SetMaxReorderingThreshold(int max_reordering_threshold) OVERRIDE;
-  virtual void RegisterRtcpStatisticsCallback(RtcpStatisticsCallback* callback)
-      OVERRIDE;
-  virtual void RegisterRtpStatisticsCallback(
-      StreamDataCountersCallback* callback) OVERRIDE;
+  void IncomingPacket(const RTPHeader& rtp_header,
+                      size_t packet_length,
+                      bool retransmitted) override;
+  void FecPacketReceived(const RTPHeader& header,
+                         size_t packet_length) override;
+  StatisticianMap GetActiveStatisticians() const override;
+  StreamStatistician* GetStatistician(uint32_t ssrc) const override;
+  int64_t TimeUntilNextProcess() override;
+  int32_t Process() override;
+  void SetMaxReorderingThreshold(int max_reordering_threshold) override;
+  void RegisterRtcpStatisticsCallback(
+      RtcpStatisticsCallback* callback) override;
+  void RegisterRtpStatisticsCallback(
+      StreamDataCountersCallback* callback) override;
 };
 
 }  // namespace webrtc
diff --git a/webrtc/modules/rtp_rtcp/interface/rtp_rtcp_defines.h b/webrtc/modules/rtp_rtcp/interface/rtp_rtcp_defines.h
index 76091a1..4938b5f 100644
--- a/webrtc/modules/rtp_rtcp/interface/rtp_rtcp_defines.h
+++ b/webrtc/modules/rtp_rtcp/interface/rtp_rtcp_defines.h
@@ -307,24 +307,22 @@
  public:
   virtual ~NullRtpFeedback() {}
 
-  virtual int32_t OnInitializeDecoder(
-      const int32_t id,
-      const int8_t payloadType,
-      const char payloadName[RTP_PAYLOAD_NAME_SIZE],
-      const int frequency,
-      const uint8_t channels,
-      const uint32_t rate) OVERRIDE {
+  int32_t OnInitializeDecoder(const int32_t id,
+                              const int8_t payloadType,
+                              const char payloadName[RTP_PAYLOAD_NAME_SIZE],
+                              const int frequency,
+                              const uint8_t channels,
+                              const uint32_t rate) override {
     return 0;
   }
 
-  virtual void OnIncomingSSRCChanged(const int32_t id,
-                                     const uint32_t ssrc) OVERRIDE {}
+  void OnIncomingSSRCChanged(const int32_t id, const uint32_t ssrc) override {}
 
-  virtual void OnIncomingCSRCChanged(const int32_t id,
-                                     const uint32_t CSRC,
-                                     const bool added) OVERRIDE {}
+  void OnIncomingCSRCChanged(const int32_t id,
+                             const uint32_t CSRC,
+                             const bool added) override {}
 
-  virtual void ResetStatistics(uint32_t ssrc) OVERRIDE {}
+  void ResetStatistics(uint32_t ssrc) override {}
 };
 
 // Null object version of RtpData.
@@ -332,15 +330,13 @@
  public:
   virtual ~NullRtpData() {}
 
-  virtual int32_t OnReceivedPayloadData(
-      const uint8_t* payloadData,
-      const size_t payloadSize,
-      const WebRtcRTPHeader* rtpHeader) OVERRIDE {
+  int32_t OnReceivedPayloadData(const uint8_t* payloadData,
+                                const size_t payloadSize,
+                                const WebRtcRTPHeader* rtpHeader) override {
     return 0;
   }
 
-  virtual bool OnRecoveredPacket(const uint8_t* packet,
-                                 size_t packet_length) OVERRIDE {
+  bool OnRecoveredPacket(const uint8_t* packet, size_t packet_length) override {
     return true;
   }
 };
@@ -350,10 +346,10 @@
  public:
   virtual ~NullRtpAudioFeedback() {}
 
-  virtual void OnPlayTelephoneEvent(const int32_t id,
-                                    const uint8_t event,
-                                    const uint16_t lengthMs,
-                                    const uint8_t volume) OVERRIDE {}
+  void OnPlayTelephoneEvent(const int32_t id,
+                            const uint8_t event,
+                            const uint16_t lengthMs,
+                            const uint8_t volume) override {}
 };
 
 }  // namespace webrtc
diff --git a/webrtc/modules/rtp_rtcp/source/fec_receiver_impl.h b/webrtc/modules/rtp_rtcp/source/fec_receiver_impl.h
index 2f4b0fb..24db39b 100644
--- a/webrtc/modules/rtp_rtcp/source/fec_receiver_impl.h
+++ b/webrtc/modules/rtp_rtcp/source/fec_receiver_impl.h
@@ -28,14 +28,14 @@
   FecReceiverImpl(RtpData* callback);
   virtual ~FecReceiverImpl();
 
-  virtual int32_t AddReceivedRedPacket(const RTPHeader& rtp_header,
-                                       const uint8_t* incoming_rtp_packet,
-                                       size_t packet_length,
-                                       uint8_t ulpfec_payload_type) OVERRIDE;
+  int32_t AddReceivedRedPacket(const RTPHeader& rtp_header,
+                               const uint8_t* incoming_rtp_packet,
+                               size_t packet_length,
+                               uint8_t ulpfec_payload_type) override;
 
-  virtual int32_t ProcessReceivedFec() OVERRIDE;
+  int32_t ProcessReceivedFec() override;
 
-  virtual FecPacketCounter GetPacketCounter() const OVERRIDE;
+  FecPacketCounter GetPacketCounter() const override;
 
  private:
   rtc::scoped_ptr<CriticalSectionWrapper> crit_sect_;
diff --git a/webrtc/modules/rtp_rtcp/source/nack_rtx_unittest.cc b/webrtc/modules/rtp_rtcp/source/nack_rtx_unittest.cc
index e7022b5..e5c4faf 100644
--- a/webrtc/modules/rtp_rtcp/source/nack_rtx_unittest.cc
+++ b/webrtc/modules/rtp_rtcp/source/nack_rtx_unittest.cc
@@ -38,10 +38,10 @@
  public:
   VerifyingRtxReceiver() {}
 
-  virtual int32_t OnReceivedPayloadData(
+  int32_t OnReceivedPayloadData(
       const uint8_t* data,
       const size_t size,
-      const webrtc::WebRtcRTPHeader* rtp_header) OVERRIDE {
+      const webrtc::WebRtcRTPHeader* rtp_header) override {
     if (!sequence_numbers_.empty())
       EXPECT_EQ(kTestSsrc, rtp_header->header.ssrc);
     sequence_numbers_.push_back(rtp_header->header.sequenceNumber);
@@ -55,8 +55,7 @@
   TestRtpFeedback(RtpRtcp* rtp_rtcp) : rtp_rtcp_(rtp_rtcp) {}
   virtual ~TestRtpFeedback() {}
 
-  virtual void OnIncomingSSRCChanged(const int32_t id,
-                                     const uint32_t ssrc) OVERRIDE {
+  void OnIncomingSSRCChanged(const int32_t id, const uint32_t ssrc) override {
     rtp_rtcp_->SetRemoteSSRC(ssrc);
   }
 
@@ -95,7 +94,7 @@
     packet_loss_ = 0;
   }
 
-  virtual int SendPacket(int channel, const void *data, size_t len) OVERRIDE {
+  int SendPacket(int channel, const void* data, size_t len) override {
     count_++;
     const unsigned char* ptr = static_cast<const unsigned  char*>(data);
     uint32_t ssrc = (ptr[8] << 24) + (ptr[9] << 16) + (ptr[10] << 8) + ptr[11];
@@ -146,9 +145,7 @@
     return static_cast<int>(len);
   }
 
-  virtual int SendRTCPPacket(int channel,
-                             const void *data,
-                             size_t len) OVERRIDE {
+  int SendRTCPPacket(int channel, const void* data, size_t len) override {
     if (module_->IncomingRtcpPacket((const uint8_t*)data, len) == 0) {
       return static_cast<int>(len);
     }
@@ -177,7 +174,7 @@
         fake_clock(123456) {}
   ~RtpRtcpRtxNackTest() {}
 
-  virtual void SetUp() OVERRIDE {
+  void SetUp() override {
     RtpRtcp::Configuration configuration;
     configuration.id = kTestId;
     configuration.audio = false;
@@ -284,9 +281,7 @@
     receiver_.sequence_numbers_.sort();
   }
 
-  virtual void TearDown() OVERRIDE {
-    delete rtp_rtcp_module_;
-  }
+  void TearDown() override { delete rtp_rtcp_module_; }
 
   rtc::scoped_ptr<ReceiveStatistics> receive_statistics_;
   RTPPayloadRegistry rtp_payload_registry_;
diff --git a/webrtc/modules/rtp_rtcp/source/receive_statistics_impl.h b/webrtc/modules/rtp_rtcp/source/receive_statistics_impl.h
index 7828036..cd41744 100644
--- a/webrtc/modules/rtp_rtcp/source/receive_statistics_impl.h
+++ b/webrtc/modules/rtp_rtcp/source/receive_statistics_impl.h
@@ -30,16 +30,16 @@
                          StreamDataCountersCallback* rtp_callback);
   virtual ~StreamStatisticianImpl() {}
 
-  virtual bool GetStatistics(RtcpStatistics* statistics, bool reset) OVERRIDE;
-  virtual void GetDataCounters(size_t* bytes_received,
-                               uint32_t* packets_received) const OVERRIDE;
-  virtual void GetReceiveStreamDataCounters(
-      StreamDataCounters* data_counters) const OVERRIDE;
-  virtual uint32_t BitrateReceived() const OVERRIDE;
-  virtual void ResetStatistics() OVERRIDE;
-  virtual bool IsRetransmitOfOldPacket(const RTPHeader& header,
-                                       int64_t min_rtt) const OVERRIDE;
-  virtual bool IsPacketInOrder(uint16_t sequence_number) const OVERRIDE;
+  bool GetStatistics(RtcpStatistics* statistics, bool reset) override;
+  void GetDataCounters(size_t* bytes_received,
+                       uint32_t* packets_received) const override;
+  void GetReceiveStreamDataCounters(
+      StreamDataCounters* data_counters) const override;
+  uint32_t BitrateReceived() const override;
+  void ResetStatistics() override;
+  bool IsRetransmitOfOldPacket(const RTPHeader& header,
+                               int64_t min_rtt) const override;
+  bool IsPacketInOrder(uint16_t sequence_number) const override;
 
   void IncomingPacket(const RTPHeader& rtp_header,
                       size_t packet_length,
@@ -107,31 +107,31 @@
   ~ReceiveStatisticsImpl();
 
   // Implement ReceiveStatistics.
-  virtual void IncomingPacket(const RTPHeader& header,
-                              size_t packet_length,
-                              bool retransmitted) OVERRIDE;
-  virtual void FecPacketReceived(const RTPHeader& header,
-                                 size_t packet_length) OVERRIDE;
-  virtual StatisticianMap GetActiveStatisticians() const OVERRIDE;
-  virtual StreamStatistician* GetStatistician(uint32_t ssrc) const OVERRIDE;
-  virtual void SetMaxReorderingThreshold(int max_reordering_threshold) OVERRIDE;
+  void IncomingPacket(const RTPHeader& header,
+                      size_t packet_length,
+                      bool retransmitted) override;
+  void FecPacketReceived(const RTPHeader& header,
+                         size_t packet_length) override;
+  StatisticianMap GetActiveStatisticians() const override;
+  StreamStatistician* GetStatistician(uint32_t ssrc) const override;
+  void SetMaxReorderingThreshold(int max_reordering_threshold) override;
 
   // Implement Module.
-  virtual int32_t Process() OVERRIDE;
-  virtual int64_t TimeUntilNextProcess() OVERRIDE;
+  int32_t Process() override;
+  int64_t TimeUntilNextProcess() override;
 
-  virtual void RegisterRtcpStatisticsCallback(RtcpStatisticsCallback* callback)
-      OVERRIDE;
+  void RegisterRtcpStatisticsCallback(
+      RtcpStatisticsCallback* callback) override;
 
-  virtual void RegisterRtpStatisticsCallback(
-      StreamDataCountersCallback* callback) OVERRIDE;
+  void RegisterRtpStatisticsCallback(
+      StreamDataCountersCallback* callback) override;
 
  private:
-  virtual void StatisticsUpdated(const RtcpStatistics& statistics,
-                                 uint32_t ssrc) OVERRIDE;
-  virtual void CNameChanged(const char* cname, uint32_t ssrc) OVERRIDE;
-  virtual void DataCountersUpdated(const StreamDataCounters& counters,
-                                   uint32_t ssrc) OVERRIDE;
+  void StatisticsUpdated(const RtcpStatistics& statistics,
+                         uint32_t ssrc) override;
+  void CNameChanged(const char* cname, uint32_t ssrc) override;
+  void DataCountersUpdated(const StreamDataCounters& counters,
+                           uint32_t ssrc) override;
 
   typedef std::map<uint32_t, StreamStatisticianImpl*> StatisticianImplMap;
 
diff --git a/webrtc/modules/rtp_rtcp/source/receive_statistics_unittest.cc b/webrtc/modules/rtp_rtcp/source/receive_statistics_unittest.cc
index 7da5285..8b25bcf6 100644
--- a/webrtc/modules/rtp_rtcp/source/receive_statistics_unittest.cc
+++ b/webrtc/modules/rtp_rtcp/source/receive_statistics_unittest.cc
@@ -169,7 +169,7 @@
       ++num_calls_;
     }
 
-    virtual void CNameChanged(const char* cname, uint32_t ssrc) OVERRIDE {}
+    void CNameChanged(const char* cname, uint32_t ssrc) override {}
 
     uint32_t num_calls_;
     uint32_t ssrc_;
diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_format_remb_unittest.cc b/webrtc/modules/rtp_rtcp/source/rtcp_format_remb_unittest.cc
index cb89287..3c1a9a3 100644
--- a/webrtc/modules/rtp_rtcp/source/rtcp_format_remb_unittest.cc
+++ b/webrtc/modules/rtp_rtcp/source/rtcp_format_remb_unittest.cc
@@ -30,14 +30,14 @@
     rtcp_receiver_(rtcp_receiver) {
   }
 
-  virtual int SendPacket(int /*channel*/,
-                         const void* /*data*/,
-                         size_t /*len*/) OVERRIDE {
+  int SendPacket(int /*channel*/,
+                 const void* /*data*/,
+                 size_t /*len*/) override {
     return -1;
   }
-  virtual int SendRTCPPacket(int /*channel*/,
-                             const void *packet,
-                             size_t packetLength) OVERRIDE {
+  int SendRTCPPacket(int /*channel*/,
+                     const void* packet,
+                     size_t packetLength) override {
     RTCPUtility::RTCPParserV2 rtcpParser((uint8_t*)packet,
                                          packetLength,
                                          true); // Allow non-compound RTCP
@@ -73,8 +73,8 @@
                 system_clock_,
                 kMimdControl,
                 kRemoteBitrateEstimatorMinBitrateBps)) {}
-  virtual void SetUp() OVERRIDE;
-  virtual void TearDown() OVERRIDE;
+  void SetUp() override;
+  void TearDown() override;
 
   OverUseDetectorOptions over_use_detector_options_;
   Clock* system_clock_;
diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_packet.h b/webrtc/modules/rtp_rtcp/source/rtcp_packet.h
index 0ea98a2..150b5b4 100644
--- a/webrtc/modules/rtp_rtcp/source/rtcp_packet.h
+++ b/webrtc/modules/rtp_rtcp/source/rtcp_packet.h
@@ -90,8 +90,9 @@
   virtual ~Empty() {}
 
  protected:
-  virtual void Create(
-      uint8_t* packet, size_t* length, size_t max_length) const OVERRIDE;
+  void Create(uint8_t* packet,
+              size_t* length,
+              size_t max_length) const override;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(Empty);
@@ -204,8 +205,9 @@
   void WithReportBlock(ReportBlock* block);
 
  protected:
-  virtual void Create(
-      uint8_t* packet, size_t* length, size_t max_length) const OVERRIDE;
+  void Create(uint8_t* packet,
+              size_t* length,
+              size_t max_length) const override;
 
  private:
   enum { kMaxNumberOfReportBlocks = 0x1f };
@@ -250,8 +252,9 @@
   void WithReportBlock(ReportBlock* block);
 
  protected:
-  virtual void Create(
-      uint8_t* packet, size_t* length, size_t max_length) const OVERRIDE;
+  void Create(uint8_t* packet,
+              size_t* length,
+              size_t max_length) const override;
 
  private:
   enum { kMaxNumberOfReportBlocks = 0x1f };
@@ -295,8 +298,9 @@
   void WithJitterItem(uint32_t jitter);
 
  protected:
-  virtual void Create(
-      uint8_t* packet, size_t* length, size_t max_length) const OVERRIDE;
+  void Create(uint8_t* packet,
+              size_t* length,
+              size_t max_length) const override;
 
  private:
   enum { kMaxNumberOfIjItems = 0x1f };
@@ -351,8 +355,9 @@
   };
 
  protected:
-  virtual void Create(
-      uint8_t* packet, size_t* length, size_t max_length) const OVERRIDE;
+  void Create(uint8_t* packet,
+              size_t* length,
+              size_t max_length) const override;
 
  private:
   enum { kMaxNumberOfChunks = 0x1f };
@@ -392,8 +397,9 @@
   void WithCsrc(uint32_t csrc);
 
  protected:
-  virtual void Create(
-      uint8_t* packet, size_t* length, size_t max_length) const OVERRIDE;
+  void Create(uint8_t* packet,
+              size_t* length,
+              size_t max_length) const override;
 
  private:
   enum { kMaxNumberOfCsrcs = 0x1f - 1 };
@@ -452,8 +458,9 @@
   }
 
  protected:
-  virtual void Create(
-      uint8_t* packet, size_t* length, size_t max_length) const OVERRIDE;
+  void Create(uint8_t* packet,
+              size_t* length,
+              size_t max_length) const override;
 
  private:
   size_t BlockLength() const {
@@ -502,8 +509,9 @@
   }
 
  protected:
-  virtual void Create(
-      uint8_t* packet, size_t* length, size_t max_length) const OVERRIDE;
+  void Create(uint8_t* packet,
+              size_t* length,
+              size_t max_length) const override;
 
  private:
   size_t BlockLength() const {
@@ -553,8 +561,9 @@
   }
 
  protected:
-  virtual void Create(
-      uint8_t* packet, size_t* length, size_t max_length) const OVERRIDE;
+  void Create(uint8_t* packet,
+              size_t* length,
+              size_t max_length) const override;
 
  private:
   size_t BlockLength() const {
@@ -594,8 +603,9 @@
   void WithList(const uint16_t* nack_list, int length);
 
  protected:
-  virtual void Create(
-      uint8_t* packet, size_t* length, size_t max_length) const OVERRIDE;
+  void Create(uint8_t* packet,
+              size_t* length,
+              size_t max_length) const override;
 
  private:
   size_t BlockLength() const {
@@ -644,8 +654,9 @@
   void WithPictureId(uint64_t picture_id);
 
  protected:
-  virtual void Create(
-      uint8_t* packet, size_t* length, size_t max_length) const OVERRIDE;
+  void Create(uint8_t* packet,
+              size_t* length,
+              size_t max_length) const override;
 
  private:
   size_t BlockLength() const {
@@ -691,8 +702,9 @@
   }
 
  protected:
-  virtual void Create(
-      uint8_t* packet, size_t* length, size_t max_length) const OVERRIDE;
+  void Create(uint8_t* packet,
+              size_t* length,
+              size_t max_length) const override;
 
  private:
   size_t BlockLength() const {
@@ -740,8 +752,9 @@
   }
 
  protected:
-  virtual void Create(
-      uint8_t* packet, size_t* length, size_t max_length) const OVERRIDE;
+  void Create(uint8_t* packet,
+              size_t* length,
+              size_t max_length) const override;
 
  private:
   size_t BlockLength() const {
@@ -781,8 +794,9 @@
   void WithTmmbr(uint32_t ssrc, uint32_t bitrate_kbps, uint16_t overhead);
 
  protected:
-  virtual void Create(
-      uint8_t* packet, size_t* length, size_t max_length) const OVERRIDE;
+  void Create(uint8_t* packet,
+              size_t* length,
+              size_t max_length) const override;
 
  private:
   enum { kMaxNumberOfTmmbrs = 50 };
@@ -836,8 +850,9 @@
   }
 
  protected:
-  virtual void Create(
-      uint8_t* packet, size_t* length, size_t max_length) const OVERRIDE;
+  void Create(uint8_t* packet,
+              size_t* length,
+              size_t max_length) const override;
 
  private:
   enum { kMaxNumberOfSsrcs = 0xff };
@@ -883,8 +898,9 @@
   void WithVoipMetric(VoipMetric* voip_metric);
 
  protected:
-  virtual void Create(
-      uint8_t* packet, size_t* length, size_t max_length) const OVERRIDE;
+  void Create(uint8_t* packet,
+              size_t* length,
+              size_t max_length) const override;
 
  private:
   enum { kMaxNumberOfRrtrBlocks = 50 };
diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_receiver_unittest.cc b/webrtc/modules/rtp_rtcp/source/rtcp_receiver_unittest.cc
index f90c598..f2ea04b 100644
--- a/webrtc/modules/rtp_rtcp/source/rtcp_receiver_unittest.cc
+++ b/webrtc/modules/rtp_rtcp/source/rtcp_receiver_unittest.cc
@@ -39,24 +39,22 @@
   void SetRTCPReceiver(RTCPReceiver* rtcp_receiver) {
     rtcp_receiver_ = rtcp_receiver;
   }
-  virtual int SendPacket(int /*ch*/,
-                         const void* /*data*/,
-                         size_t /*len*/) OVERRIDE {
+  int SendPacket(int /*ch*/, const void* /*data*/, size_t /*len*/) override {
     ADD_FAILURE();  // FAIL() gives a compile error.
     return -1;
   }
 
   // Injects an RTCP packet into the receiver.
-  virtual int SendRTCPPacket(int /* ch */,
-                             const void *packet,
-                             size_t packet_len) OVERRIDE {
+  int SendRTCPPacket(int /* ch */,
+                     const void* packet,
+                     size_t packet_len) override {
     ADD_FAILURE();
     return 0;
   }
 
-  virtual int OnReceivedPayloadData(const uint8_t* payloadData,
-                                    const size_t payloadSize,
-                                    const WebRtcRTPHeader* rtpHeader) OVERRIDE {
+  int OnReceivedPayloadData(const uint8_t* payloadData,
+                            const size_t payloadSize,
+                            const WebRtcRTPHeader* rtpHeader) override {
     ADD_FAILURE();
     return 0;
   }
@@ -966,13 +964,13 @@
     RtcpCallbackImpl() : RtcpStatisticsCallback(), ssrc_(0) {}
     virtual ~RtcpCallbackImpl() {}
 
-    virtual void StatisticsUpdated(const RtcpStatistics& statistics,
-                                   uint32_t ssrc) OVERRIDE {
+    void StatisticsUpdated(const RtcpStatistics& statistics,
+                           uint32_t ssrc) override {
       stats_ = statistics;
       ssrc_ = ssrc;
     }
 
-    virtual void CNameChanged(const char* cname, uint32_t ssrc) OVERRIDE {}
+    void CNameChanged(const char* cname, uint32_t ssrc) override {}
 
     bool Matches(uint32_t ssrc, uint32_t extended_max, uint8_t fraction_loss,
                  uint32_t cumulative_loss, uint32_t jitter) {
diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_sender_unittest.cc b/webrtc/modules/rtp_rtcp/source/rtcp_sender_unittest.cc
index 5563b0d..a35b7c3 100644
--- a/webrtc/modules/rtp_rtcp/source/rtcp_sender_unittest.cc
+++ b/webrtc/modules/rtp_rtcp/source/rtcp_sender_unittest.cc
@@ -227,15 +227,13 @@
   void SetRTCPReceiver(RTCPReceiver* rtcp_receiver) {
     rtcp_receiver_ = rtcp_receiver;
   }
-  virtual int SendPacket(int /*ch*/,
-                         const void* /*data*/,
-                         size_t /*len*/) OVERRIDE {
+  int SendPacket(int /*ch*/, const void* /*data*/, size_t /*len*/) override {
     return -1;
   }
 
-  virtual int SendRTCPPacket(int /*ch*/,
-                             const void *packet,
-                             size_t packet_len) OVERRIDE {
+  int SendRTCPPacket(int /*ch*/,
+                     const void* packet,
+                     size_t packet_len) override {
     RTCPUtility::RTCPParserV2 rtcpParser((uint8_t*)packet,
                                          packet_len,
                                          true); // Allow non-compound RTCP
@@ -265,9 +263,9 @@
     return static_cast<int>(packet_len);
   }
 
-  virtual int OnReceivedPayloadData(const uint8_t* payloadData,
-                                    const size_t payloadSize,
-                                    const WebRtcRTPHeader* rtpHeader) OVERRIDE {
+  int OnReceivedPayloadData(const uint8_t* payloadData,
+                            const size_t payloadSize,
+                            const WebRtcRTPHeader* rtpHeader) override {
     return 0;
   }
   RTCPReceiver* rtcp_receiver_;
diff --git a/webrtc/modules/rtp_rtcp/source/rtp_format_h264.h b/webrtc/modules/rtp_rtcp/source/rtp_format_h264.h
index ba293c8..4e92895 100644
--- a/webrtc/modules/rtp_rtcp/source/rtp_format_h264.h
+++ b/webrtc/modules/rtp_rtcp/source/rtp_format_h264.h
@@ -26,10 +26,9 @@
 
   virtual ~RtpPacketizerH264();
 
-  virtual void SetPayloadData(
-      const uint8_t* payload_data,
-      size_t payload_size,
-      const RTPFragmentationHeader* fragmentation) OVERRIDE;
+  void SetPayloadData(const uint8_t* payload_data,
+                      size_t payload_size,
+                      const RTPFragmentationHeader* fragmentation) override;
 
   // Get the next payload with H264 payload header.
   // buffer is a pointer to where the output will be written.
@@ -38,15 +37,15 @@
   // the frame, false otherwise (i.e., call the function again to get the
   // next packet).
   // Returns true on success or false if there was no payload to packetize.
-  virtual bool NextPacket(uint8_t* buffer,
-                          size_t* bytes_to_send,
-                          bool* last_packet) OVERRIDE;
+  bool NextPacket(uint8_t* buffer,
+                  size_t* bytes_to_send,
+                  bool* last_packet) override;
 
-  virtual ProtectionType GetProtectionType() OVERRIDE;
+  ProtectionType GetProtectionType() override;
 
-  virtual StorageType GetStorageType(uint32_t retransmission_settings) OVERRIDE;
+  StorageType GetStorageType(uint32_t retransmission_settings) override;
 
-  virtual std::string ToString() OVERRIDE;
+  std::string ToString() override;
 
  private:
   struct Packet {
@@ -95,9 +94,9 @@
  public:
   virtual ~RtpDepacketizerH264() {}
 
-  virtual bool Parse(ParsedPayload* parsed_payload,
-                     const uint8_t* payload_data,
-                     size_t payload_data_length) OVERRIDE;
+  bool Parse(ParsedPayload* parsed_payload,
+             const uint8_t* payload_data,
+             size_t payload_data_length) override;
 };
 }  // namespace webrtc
 #endif  // WEBRTC_MODULES_RTP_RTCP_SOURCE_RTP_FORMAT_H264_H_
diff --git a/webrtc/modules/rtp_rtcp/source/rtp_format_video_generic.h b/webrtc/modules/rtp_rtcp/source/rtp_format_video_generic.h
index 2fd6aad..2e7bca5 100644
--- a/webrtc/modules/rtp_rtcp/source/rtp_format_video_generic.h
+++ b/webrtc/modules/rtp_rtcp/source/rtp_format_video_generic.h
@@ -30,10 +30,9 @@
 
   virtual ~RtpPacketizerGeneric();
 
-  virtual void SetPayloadData(
-      const uint8_t* payload_data,
-      size_t payload_size,
-      const RTPFragmentationHeader* fragmentation) OVERRIDE;
+  void SetPayloadData(const uint8_t* payload_data,
+                      size_t payload_size,
+                      const RTPFragmentationHeader* fragmentation) override;
 
   // Get the next payload with generic payload header.
   // buffer is a pointer to where the output will be written.
@@ -42,15 +41,15 @@
   // the frame, false otherwise (i.e., call the function again to get the
   // next packet).
   // Returns true on success or false if there was no payload to packetize.
-  virtual bool NextPacket(uint8_t* buffer,
-                          size_t* bytes_to_send,
-                          bool* last_packet) OVERRIDE;
+  bool NextPacket(uint8_t* buffer,
+                  size_t* bytes_to_send,
+                  bool* last_packet) override;
 
-  virtual ProtectionType GetProtectionType() OVERRIDE;
+  ProtectionType GetProtectionType() override;
 
-  virtual StorageType GetStorageType(uint32_t retransmission_settings) OVERRIDE;
+  StorageType GetStorageType(uint32_t retransmission_settings) override;
 
-  virtual std::string ToString() OVERRIDE;
+  std::string ToString() override;
 
  private:
   const uint8_t* payload_data_;
@@ -68,9 +67,9 @@
  public:
   virtual ~RtpDepacketizerGeneric() {}
 
-  virtual bool Parse(ParsedPayload* parsed_payload,
-                     const uint8_t* payload_data,
-                     size_t payload_data_length) OVERRIDE;
+  bool Parse(ParsedPayload* parsed_payload,
+             const uint8_t* payload_data,
+             size_t payload_data_length) override;
 };
 }  // namespace webrtc
 #endif  // WEBRTC_MODULES_RTP_RTCP_SOURCE_RTP_FORMAT_VIDEO_GENERIC_H_
diff --git a/webrtc/modules/rtp_rtcp/source/rtp_format_vp8.h b/webrtc/modules/rtp_rtcp/source/rtp_format_vp8.h
index dab7921..d73dfc1b 100644
--- a/webrtc/modules/rtp_rtcp/source/rtp_format_vp8.h
+++ b/webrtc/modules/rtp_rtcp/source/rtp_format_vp8.h
@@ -60,10 +60,9 @@
 
   virtual ~RtpPacketizerVp8();
 
-  virtual void SetPayloadData(
-      const uint8_t* payload_data,
-      size_t payload_size,
-      const RTPFragmentationHeader* fragmentation) OVERRIDE;
+  void SetPayloadData(const uint8_t* payload_data,
+                      size_t payload_size,
+                      const RTPFragmentationHeader* fragmentation) override;
 
   // Get the next payload with VP8 payload header.
   // max_payload_len limits the sum length of payload and VP8 payload header.
@@ -76,15 +75,15 @@
   // the first payload byte in the packet is taken, with the first partition
   // having index 0; returns negative on error.
   // For the kEqualSize mode: returns 0 on success, return negative on error.
-  virtual bool NextPacket(uint8_t* buffer,
-                          size_t* bytes_to_send,
-                          bool* last_packet) OVERRIDE;
+  bool NextPacket(uint8_t* buffer,
+                  size_t* bytes_to_send,
+                  bool* last_packet) override;
 
-  virtual ProtectionType GetProtectionType() OVERRIDE;
+  ProtectionType GetProtectionType() override;
 
-  virtual StorageType GetStorageType(uint32_t retransmission_settings) OVERRIDE;
+  StorageType GetStorageType(uint32_t retransmission_settings) override;
 
-  virtual std::string ToString() OVERRIDE;
+  std::string ToString() override;
 
  private:
   typedef struct {
@@ -221,9 +220,9 @@
  public:
   virtual ~RtpDepacketizerVp8() {}
 
-  virtual bool Parse(ParsedPayload* parsed_payload,
-                     const uint8_t* payload_data,
-                     size_t payload_data_length) OVERRIDE;
+  bool Parse(ParsedPayload* parsed_payload,
+             const uint8_t* payload_data,
+             size_t payload_data_length) override;
 };
 }  // namespace webrtc
 #endif  // WEBRTC_MODULES_RTP_RTCP_SOURCE_RTP_FORMAT_VP8_H_
diff --git a/webrtc/modules/rtp_rtcp/source/rtp_header_parser.cc b/webrtc/modules/rtp_rtcp/source/rtp_header_parser.cc
index 9a4cb64..0b8280d 100644
--- a/webrtc/modules/rtp_rtcp/source/rtp_header_parser.cc
+++ b/webrtc/modules/rtp_rtcp/source/rtp_header_parser.cc
@@ -21,14 +21,13 @@
   RtpHeaderParserImpl();
   virtual ~RtpHeaderParserImpl() {}
 
-  virtual bool Parse(const uint8_t* packet,
-                     size_t length,
-                     RTPHeader* header) const OVERRIDE;
+  bool Parse(const uint8_t* packet,
+             size_t length,
+             RTPHeader* header) const override;
 
-  virtual bool RegisterRtpHeaderExtension(RTPExtensionType type,
-                                          uint8_t id) OVERRIDE;
+  bool RegisterRtpHeaderExtension(RTPExtensionType type, uint8_t id) override;
 
-  virtual bool DeregisterRtpHeaderExtension(RTPExtensionType type) OVERRIDE;
+  bool DeregisterRtpHeaderExtension(RTPExtensionType type) override;
 
  private:
   rtc::scoped_ptr<CriticalSectionWrapper> critical_section_;
diff --git a/webrtc/modules/rtp_rtcp/source/rtp_payload_registry.cc b/webrtc/modules/rtp_rtcp/source/rtp_payload_registry.cc
index 25be1a5..9a98e2a 100644
--- a/webrtc/modules/rtp_rtcp/source/rtp_payload_registry.cc
+++ b/webrtc/modules/rtp_rtcp/source/rtp_payload_registry.cc
@@ -368,12 +368,12 @@
 
 class RTPPayloadAudioStrategy : public RTPPayloadStrategy {
  public:
-  virtual bool CodecsMustBeUnique() const OVERRIDE { return true; }
+  bool CodecsMustBeUnique() const override { return true; }
 
-  virtual bool PayloadIsCompatible(const RtpUtility::Payload& payload,
-                                   const uint32_t frequency,
-                                   const uint8_t channels,
-                                   const uint32_t rate) const OVERRIDE {
+  bool PayloadIsCompatible(const RtpUtility::Payload& payload,
+                           const uint32_t frequency,
+                           const uint8_t channels,
+                           const uint32_t rate) const override {
     return
         payload.audio &&
         payload.typeSpecific.Audio.frequency == frequency &&
@@ -382,17 +382,17 @@
             payload.typeSpecific.Audio.rate == 0 || rate == 0);
   }
 
-  virtual void UpdatePayloadRate(RtpUtility::Payload* payload,
-                                 const uint32_t rate) const OVERRIDE {
+  void UpdatePayloadRate(RtpUtility::Payload* payload,
+                         const uint32_t rate) const override {
     payload->typeSpecific.Audio.rate = rate;
   }
 
-  virtual RtpUtility::Payload* CreatePayloadType(
+  RtpUtility::Payload* CreatePayloadType(
       const char payloadName[RTP_PAYLOAD_NAME_SIZE],
       const int8_t payloadType,
       const uint32_t frequency,
       const uint8_t channels,
-      const uint32_t rate) const OVERRIDE {
+      const uint32_t rate) const override {
     RtpUtility::Payload* payload = new RtpUtility::Payload;
     payload->name[RTP_PAYLOAD_NAME_SIZE - 1] = 0;
     strncpy(payload->name, payloadName, RTP_PAYLOAD_NAME_SIZE - 1);
@@ -411,26 +411,26 @@
 
 class RTPPayloadVideoStrategy : public RTPPayloadStrategy {
  public:
-  virtual bool CodecsMustBeUnique() const OVERRIDE { return false; }
+  bool CodecsMustBeUnique() const override { return false; }
 
-  virtual bool PayloadIsCompatible(const RtpUtility::Payload& payload,
-                                   const uint32_t frequency,
-                                   const uint8_t channels,
-                                   const uint32_t rate) const OVERRIDE {
+  bool PayloadIsCompatible(const RtpUtility::Payload& payload,
+                           const uint32_t frequency,
+                           const uint8_t channels,
+                           const uint32_t rate) const override {
     return !payload.audio;
   }
 
-  virtual void UpdatePayloadRate(RtpUtility::Payload* payload,
-                                 const uint32_t rate) const OVERRIDE {
+  void UpdatePayloadRate(RtpUtility::Payload* payload,
+                         const uint32_t rate) const override {
     payload->typeSpecific.Video.maxRate = rate;
   }
 
-  virtual RtpUtility::Payload* CreatePayloadType(
+  RtpUtility::Payload* CreatePayloadType(
       const char payloadName[RTP_PAYLOAD_NAME_SIZE],
       const int8_t payloadType,
       const uint32_t frequency,
       const uint8_t channels,
-      const uint32_t rate) const OVERRIDE {
+      const uint32_t rate) const override {
     RtpVideoCodecTypes videoType = kRtpVideoGeneric;
     if (RtpUtility::StringCompare(payloadName, "VP8", 3)) {
       videoType = kRtpVideoVp8;
diff --git a/webrtc/modules/rtp_rtcp/source/rtp_receiver_audio.h b/webrtc/modules/rtp_rtcp/source/rtp_receiver_audio.h
index 9ca87f6..cd146b9 100644
--- a/webrtc/modules/rtp_rtcp/source/rtp_receiver_audio.h
+++ b/webrtc/modules/rtp_rtcp/source/rtp_receiver_audio.h
@@ -53,32 +53,31 @@
                       uint32_t* frequency,
                       bool* cng_payload_type_has_changed);
 
-  virtual int32_t ParseRtpPacket(WebRtcRTPHeader* rtp_header,
-                                 const PayloadUnion& specific_payload,
-                                 bool is_red,
-                                 const uint8_t* packet,
-                                 size_t payload_length,
-                                 int64_t timestamp_ms,
-                                 bool is_first_packet) OVERRIDE;
+  int32_t ParseRtpPacket(WebRtcRTPHeader* rtp_header,
+                         const PayloadUnion& specific_payload,
+                         bool is_red,
+                         const uint8_t* packet,
+                         size_t payload_length,
+                         int64_t timestamp_ms,
+                         bool is_first_packet) override;
 
-  int GetPayloadTypeFrequency() const OVERRIDE;
+  int GetPayloadTypeFrequency() const override;
 
-  virtual RTPAliveType ProcessDeadOrAlive(uint16_t last_payload_length) const
-      OVERRIDE;
+  RTPAliveType ProcessDeadOrAlive(uint16_t last_payload_length) const override;
 
-  virtual bool ShouldReportCsrcChanges(uint8_t payload_type) const OVERRIDE;
+  bool ShouldReportCsrcChanges(uint8_t payload_type) const override;
 
-  virtual int32_t OnNewPayloadTypeCreated(
+  int32_t OnNewPayloadTypeCreated(
       const char payload_name[RTP_PAYLOAD_NAME_SIZE],
       int8_t payload_type,
-      uint32_t frequency) OVERRIDE;
+      uint32_t frequency) override;
 
-  virtual int32_t InvokeOnInitializeDecoder(
+  int32_t InvokeOnInitializeDecoder(
       RtpFeedback* callback,
       int32_t id,
       int8_t payload_type,
       const char payload_name[RTP_PAYLOAD_NAME_SIZE],
-      const PayloadUnion& specific_payload) const OVERRIDE;
+      const PayloadUnion& specific_payload) const override;
 
   // We do not allow codecs to have multiple payload types for audio, so we
   // need to override the default behavior (which is to do nothing).
@@ -95,9 +94,9 @@
   void CheckPayloadChanged(int8_t payload_type,
                            PayloadUnion* specific_payload,
                            bool* should_reset_statistics,
-                           bool* should_discard_changes) OVERRIDE;
+                           bool* should_discard_changes) override;
 
-  int Energy(uint8_t array_of_energy[kRtpCsrcSize]) const OVERRIDE;
+  int Energy(uint8_t array_of_energy[kRtpCsrcSize]) const override;
 
  private:
 
diff --git a/webrtc/modules/rtp_rtcp/source/rtp_receiver_impl.h b/webrtc/modules/rtp_rtcp/source/rtp_receiver_impl.h
index 3b2bbf6..539c226 100644
--- a/webrtc/modules/rtp_rtcp/source/rtp_receiver_impl.h
+++ b/webrtc/modules/rtp_rtcp/source/rtp_receiver_impl.h
@@ -34,38 +34,36 @@
 
   virtual ~RtpReceiverImpl();
 
-  virtual int32_t RegisterReceivePayload(
-      const char payload_name[RTP_PAYLOAD_NAME_SIZE],
-      const int8_t payload_type,
-      const uint32_t frequency,
-      const uint8_t channels,
-      const uint32_t rate) OVERRIDE;
+  int32_t RegisterReceivePayload(const char payload_name[RTP_PAYLOAD_NAME_SIZE],
+                                 const int8_t payload_type,
+                                 const uint32_t frequency,
+                                 const uint8_t channels,
+                                 const uint32_t rate) override;
 
-  virtual int32_t DeRegisterReceivePayload(const int8_t payload_type) OVERRIDE;
+  int32_t DeRegisterReceivePayload(const int8_t payload_type) override;
 
-  virtual bool IncomingRtpPacket(
-      const RTPHeader& rtp_header,
-      const uint8_t* payload,
-      size_t payload_length,
-      PayloadUnion payload_specific,
-      bool in_order) OVERRIDE;
+  bool IncomingRtpPacket(const RTPHeader& rtp_header,
+                         const uint8_t* payload,
+                         size_t payload_length,
+                         PayloadUnion payload_specific,
+                         bool in_order) override;
 
-  virtual NACKMethod NACK() const OVERRIDE;
+  NACKMethod NACK() const override;
 
   // Turn negative acknowledgement requests on/off.
-  virtual void SetNACKStatus(const NACKMethod method) OVERRIDE;
+  void SetNACKStatus(const NACKMethod method) override;
 
   // Returns the last received timestamp.
-  virtual bool Timestamp(uint32_t* timestamp) const OVERRIDE;
-  virtual bool LastReceivedTimeMs(int64_t* receive_time_ms) const OVERRIDE;
+  bool Timestamp(uint32_t* timestamp) const override;
+  bool LastReceivedTimeMs(int64_t* receive_time_ms) const override;
 
-  virtual uint32_t SSRC() const OVERRIDE;
+  uint32_t SSRC() const override;
 
-  virtual int32_t CSRCs(uint32_t array_of_csrc[kRtpCsrcSize]) const OVERRIDE;
+  int32_t CSRCs(uint32_t array_of_csrc[kRtpCsrcSize]) const override;
 
-  virtual int32_t Energy(uint8_t array_of_energy[kRtpCsrcSize]) const OVERRIDE;
+  int32_t Energy(uint8_t array_of_energy[kRtpCsrcSize]) const override;
 
-  virtual TelephoneEventHandler* GetTelephoneEventHandler() OVERRIDE;
+  TelephoneEventHandler* GetTelephoneEventHandler() override;
 
  private:
   bool HaveReceivedFrame() const;
diff --git a/webrtc/modules/rtp_rtcp/source/rtp_receiver_video.h b/webrtc/modules/rtp_rtcp/source/rtp_receiver_video.h
index c355e80..d617d0a 100644
--- a/webrtc/modules/rtp_rtcp/source/rtp_receiver_video.h
+++ b/webrtc/modules/rtp_rtcp/source/rtp_receiver_video.h
@@ -26,34 +26,33 @@
 
   virtual ~RTPReceiverVideo();
 
-  virtual int32_t ParseRtpPacket(WebRtcRTPHeader* rtp_header,
-                                 const PayloadUnion& specific_payload,
-                                 bool is_red,
-                                 const uint8_t* packet,
-                                 size_t packet_length,
-                                 int64_t timestamp,
-                                 bool is_first_packet) OVERRIDE;
+  int32_t ParseRtpPacket(WebRtcRTPHeader* rtp_header,
+                         const PayloadUnion& specific_payload,
+                         bool is_red,
+                         const uint8_t* packet,
+                         size_t packet_length,
+                         int64_t timestamp,
+                         bool is_first_packet) override;
 
   TelephoneEventHandler* GetTelephoneEventHandler() { return NULL; }
 
-  int GetPayloadTypeFrequency() const OVERRIDE;
+  int GetPayloadTypeFrequency() const override;
 
-  virtual RTPAliveType ProcessDeadOrAlive(
-      uint16_t last_payload_length) const OVERRIDE;
+  RTPAliveType ProcessDeadOrAlive(uint16_t last_payload_length) const override;
 
-  virtual bool ShouldReportCsrcChanges(uint8_t payload_type) const OVERRIDE;
+  bool ShouldReportCsrcChanges(uint8_t payload_type) const override;
 
-  virtual int32_t OnNewPayloadTypeCreated(
+  int32_t OnNewPayloadTypeCreated(
       const char payload_name[RTP_PAYLOAD_NAME_SIZE],
       int8_t payload_type,
-      uint32_t frequency) OVERRIDE;
+      uint32_t frequency) override;
 
-  virtual int32_t InvokeOnInitializeDecoder(
+  int32_t InvokeOnInitializeDecoder(
       RtpFeedback* callback,
       int32_t id,
       int8_t payload_type,
       const char payload_name[RTP_PAYLOAD_NAME_SIZE],
-      const PayloadUnion& specific_payload) const OVERRIDE;
+      const PayloadUnion& specific_payload) const override;
 
   void SetPacketOverHead(uint16_t packet_over_head);
 
diff --git a/webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.h b/webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.h
index 2b88aef..4c007eb 100644
--- a/webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.h
+++ b/webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.h
@@ -29,277 +29,268 @@
 
   // Returns the number of milliseconds until the module want a worker thread to
   // call Process.
-  virtual int64_t TimeUntilNextProcess() OVERRIDE;
+  int64_t TimeUntilNextProcess() override;
 
   // Process any pending tasks such as timeouts.
-  virtual int32_t Process() OVERRIDE;
+  int32_t Process() override;
 
   // Receiver part.
 
   // Called when we receive an RTCP packet.
-  virtual int32_t IncomingRtcpPacket(const uint8_t* incoming_packet,
-                                     size_t incoming_packet_length) OVERRIDE;
+  int32_t IncomingRtcpPacket(const uint8_t* incoming_packet,
+                             size_t incoming_packet_length) override;
 
-  virtual void SetRemoteSSRC(uint32_t ssrc) OVERRIDE;
+  void SetRemoteSSRC(uint32_t ssrc) override;
 
   // Sender part.
 
-  virtual int32_t RegisterSendPayload(const CodecInst& voice_codec) OVERRIDE;
+  int32_t RegisterSendPayload(const CodecInst& voice_codec) override;
 
-  virtual int32_t RegisterSendPayload(const VideoCodec& video_codec) OVERRIDE;
+  int32_t RegisterSendPayload(const VideoCodec& video_codec) override;
 
-  virtual int32_t DeRegisterSendPayload(int8_t payload_type) OVERRIDE;
+  int32_t DeRegisterSendPayload(int8_t payload_type) override;
 
   int8_t SendPayloadType() const;
 
   // Register RTP header extension.
-  virtual int32_t RegisterSendRtpHeaderExtension(RTPExtensionType type,
-                                                 uint8_t id) OVERRIDE;
+  int32_t RegisterSendRtpHeaderExtension(RTPExtensionType type,
+                                         uint8_t id) override;
 
-  virtual int32_t DeregisterSendRtpHeaderExtension(
-      RTPExtensionType type) OVERRIDE;
+  int32_t DeregisterSendRtpHeaderExtension(RTPExtensionType type) override;
 
   // Get start timestamp.
-  virtual uint32_t StartTimestamp() const OVERRIDE;
+  uint32_t StartTimestamp() const override;
 
   // Configure start timestamp, default is a random number.
-  virtual void SetStartTimestamp(uint32_t timestamp) OVERRIDE;
+  void SetStartTimestamp(uint32_t timestamp) override;
 
-  virtual uint16_t SequenceNumber() const OVERRIDE;
+  uint16_t SequenceNumber() const override;
 
   // Set SequenceNumber, default is a random number.
-  virtual void SetSequenceNumber(uint16_t seq) OVERRIDE;
+  void SetSequenceNumber(uint16_t seq) override;
 
-  virtual bool SetRtpStateForSsrc(uint32_t ssrc,
-                                  const RtpState& rtp_state) OVERRIDE;
-  virtual bool GetRtpStateForSsrc(uint32_t ssrc, RtpState* rtp_state) OVERRIDE;
+  bool SetRtpStateForSsrc(uint32_t ssrc, const RtpState& rtp_state) override;
+  bool GetRtpStateForSsrc(uint32_t ssrc, RtpState* rtp_state) override;
 
-  virtual uint32_t SSRC() const OVERRIDE;
+  uint32_t SSRC() const override;
 
   // Configure SSRC, default is a random number.
-  virtual void SetSSRC(uint32_t ssrc) OVERRIDE;
+  void SetSSRC(uint32_t ssrc) override;
 
-  virtual void SetCsrcs(const std::vector<uint32_t>& csrcs) OVERRIDE;
+  void SetCsrcs(const std::vector<uint32_t>& csrcs) override;
 
   RTCPSender::FeedbackState GetFeedbackState();
 
   int CurrentSendFrequencyHz() const;
 
-  virtual void SetRtxSendStatus(int mode) OVERRIDE;
-  virtual int RtxSendStatus() const OVERRIDE;
+  void SetRtxSendStatus(int mode) override;
+  int RtxSendStatus() const override;
 
-  virtual void SetRtxSsrc(uint32_t ssrc) OVERRIDE;
+  void SetRtxSsrc(uint32_t ssrc) override;
 
-  virtual void SetRtxSendPayloadType(int payload_type) OVERRIDE;
+  void SetRtxSendPayloadType(int payload_type) override;
 
   // Sends kRtcpByeCode when going from true to false.
-  virtual int32_t SetSendingStatus(bool sending) OVERRIDE;
+  int32_t SetSendingStatus(bool sending) override;
 
-  virtual bool Sending() const OVERRIDE;
+  bool Sending() const override;
 
   // Drops or relays media packets.
-  virtual void SetSendingMediaStatus(bool sending) OVERRIDE;
+  void SetSendingMediaStatus(bool sending) override;
 
-  virtual bool SendingMedia() const OVERRIDE;
+  bool SendingMedia() const override;
 
   // Used by the codec module to deliver a video or audio frame for
   // packetization.
-  virtual int32_t SendOutgoingData(
-      FrameType frame_type,
-      int8_t payload_type,
-      uint32_t time_stamp,
-      int64_t capture_time_ms,
-      const uint8_t* payload_data,
-      size_t payload_size,
-      const RTPFragmentationHeader* fragmentation = NULL,
-      const RTPVideoHeader* rtp_video_hdr = NULL) OVERRIDE;
+  int32_t SendOutgoingData(FrameType frame_type,
+                           int8_t payload_type,
+                           uint32_t time_stamp,
+                           int64_t capture_time_ms,
+                           const uint8_t* payload_data,
+                           size_t payload_size,
+                           const RTPFragmentationHeader* fragmentation = NULL,
+                           const RTPVideoHeader* rtp_video_hdr = NULL) override;
 
-  virtual bool TimeToSendPacket(uint32_t ssrc,
-                                uint16_t sequence_number,
-                                int64_t capture_time_ms,
-                                bool retransmission) OVERRIDE;
+  bool TimeToSendPacket(uint32_t ssrc,
+                        uint16_t sequence_number,
+                        int64_t capture_time_ms,
+                        bool retransmission) override;
 
   // Returns the number of padding bytes actually sent, which can be more or
   // less than |bytes|.
-  virtual size_t TimeToSendPadding(size_t bytes) OVERRIDE;
+  size_t TimeToSendPadding(size_t bytes) override;
 
-  virtual bool GetSendSideDelay(int* avg_send_delay_ms,
-                                int* max_send_delay_ms) const OVERRIDE;
+  bool GetSendSideDelay(int* avg_send_delay_ms,
+                        int* max_send_delay_ms) const override;
 
   // RTCP part.
 
   // Get RTCP status.
-  virtual RTCPMethod RTCP() const OVERRIDE;
+  RTCPMethod RTCP() const override;
 
   // Configure RTCP status i.e on/off.
-  virtual void SetRTCPStatus(RTCPMethod method) OVERRIDE;
+  void SetRTCPStatus(RTCPMethod method) override;
 
   // Set RTCP CName.
-  virtual int32_t SetCNAME(const char c_name[RTCP_CNAME_SIZE]) OVERRIDE;
+  int32_t SetCNAME(const char c_name[RTCP_CNAME_SIZE]) override;
 
   // Get remote CName.
-  virtual int32_t RemoteCNAME(uint32_t remote_ssrc,
-                              char c_name[RTCP_CNAME_SIZE]) const OVERRIDE;
+  int32_t RemoteCNAME(uint32_t remote_ssrc,
+                      char c_name[RTCP_CNAME_SIZE]) const override;
 
   // Get remote NTP.
-  virtual int32_t RemoteNTP(uint32_t* received_ntp_secs,
-                            uint32_t* received_ntp_frac,
-                            uint32_t* rtcp_arrival_time_secs,
-                            uint32_t* rtcp_arrival_time_frac,
-                            uint32_t* rtcp_timestamp) const OVERRIDE;
+  int32_t RemoteNTP(uint32_t* received_ntp_secs,
+                    uint32_t* received_ntp_frac,
+                    uint32_t* rtcp_arrival_time_secs,
+                    uint32_t* rtcp_arrival_time_frac,
+                    uint32_t* rtcp_timestamp) const override;
 
-  virtual int32_t AddMixedCNAME(uint32_t ssrc,
-                                const char c_name[RTCP_CNAME_SIZE]) OVERRIDE;
+  int32_t AddMixedCNAME(uint32_t ssrc,
+                        const char c_name[RTCP_CNAME_SIZE]) override;
 
-  virtual int32_t RemoveMixedCNAME(uint32_t ssrc) OVERRIDE;
+  int32_t RemoveMixedCNAME(uint32_t ssrc) override;
 
   // Get RoundTripTime.
-  virtual int32_t RTT(uint32_t remote_ssrc,
-                      int64_t* rtt,
-                      int64_t* avg_rtt,
-                      int64_t* min_rtt,
-                      int64_t* max_rtt) const OVERRIDE;
+  int32_t RTT(uint32_t remote_ssrc,
+              int64_t* rtt,
+              int64_t* avg_rtt,
+              int64_t* min_rtt,
+              int64_t* max_rtt) const override;
 
   // Force a send of an RTCP packet.
   // Normal SR and RR are triggered via the process function.
-  virtual int32_t SendRTCP(uint32_t rtcp_packet_type = kRtcpReport) OVERRIDE;
+  int32_t SendRTCP(uint32_t rtcp_packet_type = kRtcpReport) override;
 
-  virtual int32_t ResetSendDataCountersRTP() OVERRIDE;
+  int32_t ResetSendDataCountersRTP() override;
 
   // Statistics of the amount of data sent and received.
-  virtual int32_t DataCountersRTP(size_t* bytes_sent,
-                                  uint32_t* packets_sent) const OVERRIDE;
+  int32_t DataCountersRTP(size_t* bytes_sent,
+                          uint32_t* packets_sent) const override;
 
-  virtual void GetSendStreamDataCounters(
+  void GetSendStreamDataCounters(
       StreamDataCounters* rtp_counters,
-      StreamDataCounters* rtx_counters) const OVERRIDE;
+      StreamDataCounters* rtx_counters) const override;
 
   // Get received RTCP report, sender info.
-  virtual int32_t RemoteRTCPStat(RTCPSenderInfo* sender_info) OVERRIDE;
+  int32_t RemoteRTCPStat(RTCPSenderInfo* sender_info) override;
 
   // Get received RTCP report, report block.
-  virtual int32_t RemoteRTCPStat(
-      std::vector<RTCPReportBlock>* receive_blocks) const OVERRIDE;
+  int32_t RemoteRTCPStat(
+      std::vector<RTCPReportBlock>* receive_blocks) const override;
 
   // Set received RTCP report block.
-  virtual int32_t AddRTCPReportBlock(
-      uint32_t ssrc,
-      const RTCPReportBlock* receive_block) OVERRIDE;
+  int32_t AddRTCPReportBlock(uint32_t ssrc,
+                             const RTCPReportBlock* receive_block) override;
 
-  virtual int32_t RemoveRTCPReportBlock(uint32_t ssrc) OVERRIDE;
+  int32_t RemoveRTCPReportBlock(uint32_t ssrc) override;
 
   // (REMB) Receiver Estimated Max Bitrate.
-  virtual bool REMB() const OVERRIDE;
+  bool REMB() const override;
 
-  virtual void SetREMBStatus(bool enable) OVERRIDE;
+  void SetREMBStatus(bool enable) override;
 
-  virtual void SetREMBData(uint32_t bitrate,
-                           const std::vector<uint32_t>& ssrcs) OVERRIDE;
+  void SetREMBData(uint32_t bitrate,
+                   const std::vector<uint32_t>& ssrcs) override;
 
   // (IJ) Extended jitter report.
-  virtual bool IJ() const OVERRIDE;
+  bool IJ() const override;
 
-  virtual void SetIJStatus(bool enable) OVERRIDE;
+  void SetIJStatus(bool enable) override;
 
   // (TMMBR) Temporary Max Media Bit Rate.
-  virtual bool TMMBR() const OVERRIDE;
+  bool TMMBR() const override;
 
-  virtual void SetTMMBRStatus(bool enable) OVERRIDE;
+  void SetTMMBRStatus(bool enable) override;
 
   int32_t SetTMMBN(const TMMBRSet* bounding_set);
 
-  virtual uint16_t MaxPayloadLength() const OVERRIDE;
+  uint16_t MaxPayloadLength() const override;
 
-  virtual uint16_t MaxDataPayloadLength() const OVERRIDE;
+  uint16_t MaxDataPayloadLength() const override;
 
-  virtual int32_t SetMaxTransferUnit(uint16_t size) OVERRIDE;
+  int32_t SetMaxTransferUnit(uint16_t size) override;
 
-  virtual int32_t SetTransportOverhead(
-      bool tcp,
-      bool ipv6,
-      uint8_t authentication_overhead = 0) OVERRIDE;
+  int32_t SetTransportOverhead(bool tcp,
+                               bool ipv6,
+                               uint8_t authentication_overhead = 0) override;
 
   // (NACK) Negative acknowledgment part.
 
-  virtual int SelectiveRetransmissions() const OVERRIDE;
+  int SelectiveRetransmissions() const override;
 
-  virtual int SetSelectiveRetransmissions(uint8_t settings) OVERRIDE;
+  int SetSelectiveRetransmissions(uint8_t settings) override;
 
   // Send a Negative acknowledgment packet.
-  virtual int32_t SendNACK(const uint16_t* nack_list, uint16_t size) OVERRIDE;
+  int32_t SendNACK(const uint16_t* nack_list, uint16_t size) override;
 
   // Store the sent packets, needed to answer to a negative acknowledgment
   // requests.
-  virtual void SetStorePacketsStatus(bool enable,
-                                     uint16_t number_to_store) OVERRIDE;
+  void SetStorePacketsStatus(bool enable, uint16_t number_to_store) override;
 
-  virtual bool StorePackets() const OVERRIDE;
+  bool StorePackets() const override;
 
   // Called on receipt of RTCP report block from remote side.
-  virtual void RegisterRtcpStatisticsCallback(
-      RtcpStatisticsCallback* callback) OVERRIDE;
-  virtual RtcpStatisticsCallback* GetRtcpStatisticsCallback() OVERRIDE;
+  void RegisterRtcpStatisticsCallback(
+      RtcpStatisticsCallback* callback) override;
+  RtcpStatisticsCallback* GetRtcpStatisticsCallback() override;
 
   // (APP) Application specific data.
-  virtual int32_t SetRTCPApplicationSpecificData(uint8_t sub_type,
-                                                 uint32_t name,
-                                                 const uint8_t* data,
-                                                 uint16_t length) OVERRIDE;
+  int32_t SetRTCPApplicationSpecificData(uint8_t sub_type,
+                                         uint32_t name,
+                                         const uint8_t* data,
+                                         uint16_t length) override;
 
   // (XR) VOIP metric.
-  virtual int32_t SetRTCPVoIPMetrics(const RTCPVoIPMetric* VoIPMetric) OVERRIDE;
+  int32_t SetRTCPVoIPMetrics(const RTCPVoIPMetric* VoIPMetric) override;
 
   // (XR) Receiver reference time report.
-  virtual void SetRtcpXrRrtrStatus(bool enable) OVERRIDE;
+  void SetRtcpXrRrtrStatus(bool enable) override;
 
-  virtual bool RtcpXrRrtrStatus() const OVERRIDE;
+  bool RtcpXrRrtrStatus() const override;
 
   // Audio part.
 
   // Set audio packet size, used to determine when it's time to send a DTMF
   // packet in silence (CNG).
-  virtual int32_t SetAudioPacketSize(uint16_t packet_size_samples) OVERRIDE;
+  int32_t SetAudioPacketSize(uint16_t packet_size_samples) override;
 
   // Send a TelephoneEvent tone using RFC 2833 (4733).
-  virtual int32_t SendTelephoneEventOutband(uint8_t key,
-                                            uint16_t time_ms,
-                                            uint8_t level) OVERRIDE;
+  int32_t SendTelephoneEventOutband(uint8_t key,
+                                    uint16_t time_ms,
+                                    uint8_t level) override;
 
   // Set payload type for Redundant Audio Data RFC 2198.
-  virtual int32_t SetSendREDPayloadType(int8_t payload_type) OVERRIDE;
+  int32_t SetSendREDPayloadType(int8_t payload_type) override;
 
   // Get payload type for Redundant Audio Data RFC 2198.
-  virtual int32_t SendREDPayloadType(int8_t& payload_type) const OVERRIDE;
+  int32_t SendREDPayloadType(int8_t& payload_type) const override;
 
   // Store the audio level in d_bov for header-extension-for-audio-level-
   // indication.
-  virtual int32_t SetAudioLevel(uint8_t level_d_bov) OVERRIDE;
+  int32_t SetAudioLevel(uint8_t level_d_bov) override;
 
   // Video part.
 
-  virtual int32_t SendRTCPSliceLossIndication(uint8_t picture_id) OVERRIDE;
+  int32_t SendRTCPSliceLossIndication(uint8_t picture_id) override;
 
   // Set method for requesting a new key frame.
-  virtual int32_t SetKeyFrameRequestMethod(
-      KeyFrameRequestMethod method) OVERRIDE;
+  int32_t SetKeyFrameRequestMethod(KeyFrameRequestMethod method) override;
 
   // Send a request for a keyframe.
-  virtual int32_t RequestKeyFrame() OVERRIDE;
+  int32_t RequestKeyFrame() override;
 
-  virtual void SetTargetSendBitrate(uint32_t bitrate_bps) OVERRIDE;
+  void SetTargetSendBitrate(uint32_t bitrate_bps) override;
 
-  virtual int32_t SetGenericFECStatus(bool enable,
-                                      uint8_t payload_type_red,
-                                      uint8_t payload_type_fec) OVERRIDE;
+  int32_t SetGenericFECStatus(bool enable,
+                              uint8_t payload_type_red,
+                              uint8_t payload_type_fec) override;
 
-  virtual int32_t GenericFECStatus(
-      bool& enable,
-      uint8_t& payload_type_red,
-      uint8_t& payload_type_fec) OVERRIDE;
+  int32_t GenericFECStatus(bool& enable,
+                           uint8_t& payload_type_red,
+                           uint8_t& payload_type_fec) override;
 
-  virtual int32_t SetFecParameters(
-      const FecProtectionParams* delta_params,
-      const FecProtectionParams* key_params) OVERRIDE;
+  int32_t SetFecParameters(const FecProtectionParams* delta_params,
+                           const FecProtectionParams* key_params) override;
 
   bool LastReceivedNTP(uint32_t* NTPsecs,
                        uint32_t* NTPfrac,
@@ -309,23 +300,22 @@
 
   virtual int32_t BoundingSet(bool& tmmbr_owner, TMMBRSet*& bounding_set_rec);
 
-  virtual void BitrateSent(uint32_t* total_rate,
-                           uint32_t* video_rate,
-                           uint32_t* fec_rate,
-                           uint32_t* nackRate) const OVERRIDE;
+  void BitrateSent(uint32_t* total_rate,
+                   uint32_t* video_rate,
+                   uint32_t* fec_rate,
+                   uint32_t* nackRate) const override;
 
   int64_t SendTimeOfSendReport(uint32_t send_report);
 
   bool SendTimeOfXrRrReport(uint32_t mid_ntp, int64_t* time_ms) const;
 
   // Good state of RTP receiver inform sender.
-  virtual int32_t SendRTCPReferencePictureSelection(
-      uint64_t picture_id) OVERRIDE;
+  int32_t SendRTCPReferencePictureSelection(uint64_t picture_id) override;
 
-  virtual void RegisterSendChannelRtpStatisticsCallback(
-      StreamDataCountersCallback* callback) OVERRIDE;
-  virtual StreamDataCountersCallback*
-      GetSendChannelRtpStatisticsCallback() const OVERRIDE;
+  void RegisterSendChannelRtpStatisticsCallback(
+      StreamDataCountersCallback* callback) override;
+  StreamDataCountersCallback* GetSendChannelRtpStatisticsCallback()
+      const override;
 
   void OnReceivedTMMBR();
 
diff --git a/webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl_unittest.cc b/webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl_unittest.cc
index e32a535..e7b58a2 100644
--- a/webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl_unittest.cc
+++ b/webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl_unittest.cc
@@ -40,12 +40,8 @@
   RtcpRttStatsTestImpl() : rtt_ms_(0) {}
   virtual ~RtcpRttStatsTestImpl() {}
 
-  virtual void OnRttUpdate(int64_t rtt_ms) OVERRIDE {
-    rtt_ms_ = rtt_ms;
-  }
-  virtual int64_t LastProcessedRtt() const OVERRIDE {
-    return rtt_ms_;
-  }
+  void OnRttUpdate(int64_t rtt_ms) override { rtt_ms_ = rtt_ms; }
+  int64_t LastProcessedRtt() const override { return rtt_ms_; }
   int64_t rtt_ms_;
 };
 
@@ -66,7 +62,7 @@
     clock_ = clock;
     delay_ms_ = delay_ms;
   }
-  virtual int SendPacket(int /*ch*/, const void* data, size_t len) OVERRIDE {
+  int SendPacket(int /*ch*/, const void* data, size_t len) override {
     RTPHeader header;
     rtc::scoped_ptr<RtpHeaderParser> parser(RtpHeaderParser::Create());
     EXPECT_TRUE(parser->Parse(static_cast<const uint8_t*>(data), len, &header));
@@ -74,9 +70,7 @@
     last_rtp_header_ = header;
     return static_cast<int>(len);
   }
-  virtual int SendRTCPPacket(int /*ch*/,
-                             const void *data,
-                             size_t len) OVERRIDE {
+  int SendRTCPPacket(int /*ch*/, const void* data, size_t len) override {
     test::RtcpPacketParser parser;
     parser.Parse(static_cast<const uint8_t*>(data), len);
     last_nack_list_ = parser.nack_item()->last_nack_list();
diff --git a/webrtc/modules/rtp_rtcp/source/rtp_sender.cc b/webrtc/modules/rtp_rtcp/source/rtp_sender.cc
index 5f5a71a..e6a912e 100644
--- a/webrtc/modules/rtp_rtcp/source/rtp_sender.cc
+++ b/webrtc/modules/rtp_rtcp/source/rtp_sender.cc
@@ -73,7 +73,7 @@
         : aggregator_(aggregator) {}
 
     // Implements Bitrate::Observer.
-    virtual void BitrateUpdated(const BitrateStatistics& stats) OVERRIDE {
+    void BitrateUpdated(const BitrateStatistics& stats) override {
       statistics_ = stats;
       aggregator_.OnStatsUpdated();
     }
diff --git a/webrtc/modules/rtp_rtcp/source/rtp_sender.h b/webrtc/modules/rtp_rtcp/source/rtp_sender.h
index 1fa46d1..9342e5e 100644
--- a/webrtc/modules/rtp_rtcp/source/rtp_sender.h
+++ b/webrtc/modules/rtp_rtcp/source/rtp_sender.h
@@ -81,7 +81,7 @@
 
   void ProcessBitrate();
 
-  virtual uint16_t ActualSendBitrateKbit() const OVERRIDE;
+  uint16_t ActualSendBitrateKbit() const override;
 
   uint32_t VideoBitrateSent() const;
   uint32_t FecOverheadRate() const;
@@ -95,7 +95,7 @@
   uint32_t GetTargetBitrate();
 
   // Includes size of RTP and FEC headers.
-  virtual size_t MaxDataPayloadLength() const OVERRIDE;
+  size_t MaxDataPayloadLength() const override;
 
   int32_t RegisterPayload(
       const char payload_name[RTP_PAYLOAD_NAME_SIZE],
@@ -126,7 +126,7 @@
   uint32_t GenerateNewSSRC();
   void SetSSRC(uint32_t ssrc);
 
-  virtual uint16_t SequenceNumber() const OVERRIDE;
+  uint16_t SequenceNumber() const override;
   void SetSequenceNumber(uint16_t seq);
 
   void SetCsrcs(const std::vector<uint32_t>& csrcs);
@@ -193,28 +193,29 @@
   void SetRtxPayloadType(int payloadType);
 
   // Functions wrapping RTPSenderInterface.
-  virtual int32_t BuildRTPheader(
-      uint8_t* data_buffer,
-      int8_t payload_type,
-      bool marker_bit,
-      uint32_t capture_timestamp,
-      int64_t capture_time_ms,
-      const bool timestamp_provided = true,
-      const bool inc_sequence_number = true) OVERRIDE;
+  int32_t BuildRTPheader(uint8_t* data_buffer,
+                         int8_t payload_type,
+                         bool marker_bit,
+                         uint32_t capture_timestamp,
+                         int64_t capture_time_ms,
+                         const bool timestamp_provided = true,
+                         const bool inc_sequence_number = true) override;
 
-  virtual size_t RTPHeaderLength() const OVERRIDE;
-  virtual uint16_t IncrementSequenceNumber() OVERRIDE;
-  virtual size_t MaxPayloadLength() const OVERRIDE;
-  virtual uint16_t PacketOverHead() const OVERRIDE;
+  size_t RTPHeaderLength() const override;
+  uint16_t IncrementSequenceNumber() override;
+  size_t MaxPayloadLength() const override;
+  uint16_t PacketOverHead() const override;
 
   // Current timestamp.
-  virtual uint32_t Timestamp() const OVERRIDE;
-  virtual uint32_t SSRC() const OVERRIDE;
+  uint32_t Timestamp() const override;
+  uint32_t SSRC() const override;
 
-  virtual int32_t SendToNetwork(
-      uint8_t *data_buffer, size_t payload_length, size_t rtp_header_length,
-      int64_t capture_time_ms, StorageType storage,
-      PacedSender::Priority priority) OVERRIDE;
+  int32_t SendToNetwork(uint8_t* data_buffer,
+                        size_t payload_length,
+                        size_t rtp_header_length,
+                        int64_t capture_time_ms,
+                        StorageType storage,
+                        PacedSender::Priority priority) override;
 
   // Audio.
 
diff --git a/webrtc/modules/rtp_rtcp/source/rtp_sender_unittest.cc b/webrtc/modules/rtp_rtcp/source/rtp_sender_unittest.cc
index 8787ad6..f57ee27 100644
--- a/webrtc/modules/rtp_rtcp/source/rtp_sender_unittest.cc
+++ b/webrtc/modules/rtp_rtcp/source/rtp_sender_unittest.cc
@@ -62,16 +62,14 @@
  public:
   LoopbackTransportTest()
       : packets_sent_(0), last_sent_packet_len_(0), total_bytes_sent_(0) {}
-  virtual int SendPacket(int channel, const void *data, size_t len) OVERRIDE {
+  int SendPacket(int channel, const void* data, size_t len) override {
     packets_sent_++;
     memcpy(last_sent_packet_, data, len);
     last_sent_packet_len_ = len;
     total_bytes_sent_ += len;
     return static_cast<int>(len);
   }
-  virtual int SendRTCPPacket(int channel,
-                             const void *data,
-                             size_t len) OVERRIDE {
+  int SendRTCPPacket(int channel, const void* data, size_t len) override {
     return -1;
   }
   int packets_sent_;
@@ -93,7 +91,7 @@
         SendPacket(_, _, _, _, _, _)).WillRepeatedly(testing::Return(true));
   }
 
-  virtual void SetUp() OVERRIDE {
+  void SetUp() override {
     rtp_sender_.reset(new RTPSender(0, false, &fake_clock_, &transport_, NULL,
                                     &mock_paced_sender_, NULL, NULL, NULL));
     rtp_sender_->SetSequenceNumber(kSeqNum);
@@ -771,8 +769,8 @@
     TestCallback() : FrameCountObserver(), num_calls_(0), ssrc_(0) {}
     virtual ~TestCallback() {}
 
-    virtual void FrameCountUpdated(const FrameCounts& frame_counts,
-                                   uint32_t ssrc) OVERRIDE {
+    void FrameCountUpdated(const FrameCounts& frame_counts,
+                           uint32_t ssrc) override {
       ++num_calls_;
       ssrc_ = ssrc;
       frame_counts_ = frame_counts;
@@ -821,9 +819,9 @@
     TestCallback() : BitrateStatisticsObserver(), num_calls_(0), ssrc_(0) {}
     virtual ~TestCallback() {}
 
-    virtual void Notify(const BitrateStatistics& total_stats,
-                        const BitrateStatistics& retransmit_stats,
-                        uint32_t ssrc) OVERRIDE {
+    void Notify(const BitrateStatistics& total_stats,
+                const BitrateStatistics& retransmit_stats,
+                uint32_t ssrc) override {
       ++num_calls_;
       ssrc_ = ssrc;
       total_stats_ = total_stats;
@@ -891,7 +889,7 @@
  protected:
   RtpSenderAudioTest() {}
 
-  virtual void SetUp() OVERRIDE {
+  void SetUp() override {
     payload_ = kAudioPayload;
     rtp_sender_.reset(new RTPSender(0, true, &fake_clock_, &transport_, NULL,
                                     &mock_paced_sender_, NULL, NULL, NULL));
@@ -906,8 +904,8 @@
       : StreamDataCountersCallback(), ssrc_(0), counters_() {}
     virtual ~TestCallback() {}
 
-    virtual void DataCountersUpdated(const StreamDataCounters& counters,
-                                     uint32_t ssrc) OVERRIDE {
+    void DataCountersUpdated(const StreamDataCounters& counters,
+                             uint32_t ssrc) override {
       ssrc_ = ssrc;
       counters_ = counters;
     }
diff --git a/webrtc/modules/rtp_rtcp/test/BWEStandAlone/BWEStandAlone.cc b/webrtc/modules/rtp_rtcp/test/BWEStandAlone/BWEStandAlone.cc
index 77ee6fb..ea8ac98 100644
--- a/webrtc/modules/rtp_rtcp/test/BWEStandAlone/BWEStandAlone.cc
+++ b/webrtc/modules/rtp_rtcp/test/BWEStandAlone/BWEStandAlone.cc
@@ -32,15 +32,15 @@
     myTransportCB (RtpRtcp *rtpMod) : _rtpMod(rtpMod) {};
 protected:
     // Inherited from UdpTransportData
-    virtual void IncomingRTPPacket(const int8_t* incomingRtpPacket,
-                                   const size_t rtpPacketLength,
-                                   const int8_t* fromIP,
-                                   const uint16_t fromPort) OVERRIDE;
+ void IncomingRTPPacket(const int8_t* incomingRtpPacket,
+                        const size_t rtpPacketLength,
+                        const int8_t* fromIP,
+                        const uint16_t fromPort) override;
 
-    virtual void IncomingRTCPPacket(const int8_t* incomingRtcpPacket,
-                                    const size_t rtcpPacketLength,
-                                    const int8_t* fromIP,
-                                    const uint16_t fromPort) OVERRIDE;
+ void IncomingRTCPPacket(const int8_t* incomingRtcpPacket,
+                         const size_t rtcpPacketLength,
+                         const int8_t* fromIP,
+                         const uint16_t fromPort) override;
 
 private:
     RtpRtcp *_rtpMod;
diff --git a/webrtc/modules/rtp_rtcp/test/BWEStandAlone/TestSenderReceiver.h b/webrtc/modules/rtp_rtcp/test/BWEStandAlone/TestSenderReceiver.h
index 30a84c9..9ebc5a5 100644
--- a/webrtc/modules/rtp_rtcp/test/BWEStandAlone/TestSenderReceiver.h
+++ b/webrtc/modules/rtp_rtcp/test/BWEStandAlone/TestSenderReceiver.h
@@ -69,43 +69,38 @@
     int32_t SetPacketTimeout(const uint32_t timeoutMS);
 
     // Inherited from RtpFeedback
-    virtual int32_t OnInitializeDecoder(
-        const int32_t id,
-        const int8_t payloadType,
-        const int8_t payloadName[RTP_PAYLOAD_NAME_SIZE],
-        const uint32_t frequency,
-        const uint8_t channels,
-        const uint32_t rate) OVERRIDE {
+    int32_t OnInitializeDecoder(const int32_t id,
+                                const int8_t payloadType,
+                                const int8_t payloadName[RTP_PAYLOAD_NAME_SIZE],
+                                const uint32_t frequency,
+                                const uint8_t channels,
+                                const uint32_t rate) override {
       return 0;
     }
 
-    virtual void OnIncomingSSRCChanged(const int32_t id,
-                                       const uint32_t SSRC) OVERRIDE {}
+    void OnIncomingSSRCChanged(const int32_t id, const uint32_t SSRC) override {
+    }
 
-    virtual void OnIncomingCSRCChanged(const int32_t id,
-                                       const uint32_t CSRC,
-                                       const bool added) OVERRIDE {}
-
+    void OnIncomingCSRCChanged(const int32_t id,
+                               const uint32_t CSRC,
+                               const bool added) override {}
 
     // Inherited from RtpData
-    virtual int32_t OnReceivedPayloadData(
+    int32_t OnReceivedPayloadData(
         const uint8_t* payloadData,
         const size_t payloadSize,
-        const webrtc::WebRtcRTPHeader* rtpHeader) OVERRIDE;
-
+        const webrtc::WebRtcRTPHeader* rtpHeader) override;
 
     // Inherited from UdpTransportData
-    virtual void IncomingRTPPacket(const int8_t* incomingRtpPacket,
-                                   const size_t rtpPacketLength,
-                                   const int8_t* fromIP,
-                                   const uint16_t fromPort) OVERRIDE;
+    void IncomingRTPPacket(const int8_t* incomingRtpPacket,
+                           const size_t rtpPacketLength,
+                           const int8_t* fromIP,
+                           const uint16_t fromPort) override;
 
-    virtual void IncomingRTCPPacket(const int8_t* incomingRtcpPacket,
-                                    const size_t rtcpPacketLength,
-                                    const int8_t* fromIP,
-                                    const uint16_t fromPort) OVERRIDE;
-
-
+    void IncomingRTCPPacket(const int8_t* incomingRtcpPacket,
+                            const size_t rtcpPacketLength,
+                            const int8_t* fromIP,
+                            const uint16_t fromPort) override;
 
     /////////////////////////////////
     // Sender methods
diff --git a/webrtc/modules/rtp_rtcp/test/testAPI/test_api.cc b/webrtc/modules/rtp_rtcp/test/testAPI/test_api.cc
index d265c86..6b4e55d 100644
--- a/webrtc/modules/rtp_rtcp/test/testAPI/test_api.cc
+++ b/webrtc/modules/rtp_rtcp/test/testAPI/test_api.cc
@@ -89,7 +89,7 @@
   }
   ~RtpRtcpAPITest() {}
 
-  virtual void SetUp() OVERRIDE {
+  void SetUp() override {
     RtpRtcp::Configuration configuration;
     configuration.id = test_id;
     configuration.audio = true;
diff --git a/webrtc/modules/rtp_rtcp/test/testAPI/test_api.h b/webrtc/modules/rtp_rtcp/test/testAPI/test_api.h
index 677d3b1..069cdc7 100644
--- a/webrtc/modules/rtp_rtcp/test/testAPI/test_api.h
+++ b/webrtc/modules/rtp_rtcp/test/testAPI/test_api.h
@@ -35,10 +35,8 @@
                      RtpReceiver* receiver,
                      ReceiveStatistics* receive_statistics);
   void DropEveryNthPacket(int n);
-  virtual int SendPacket(int channel, const void* data, size_t len) OVERRIDE;
-  virtual int SendRTCPPacket(int channel,
-                             const void* data,
-                             size_t len) OVERRIDE;
+  int SendPacket(int channel, const void* data, size_t len) override;
+  int SendRTCPPacket(int channel, const void* data, size_t len) override;
 
  private:
   int count_;
@@ -51,10 +49,10 @@
 
 class TestRtpReceiver : public NullRtpData {
  public:
-  virtual int32_t OnReceivedPayloadData(
+  int32_t OnReceivedPayloadData(
       const uint8_t* payload_data,
       const size_t payload_size,
-      const webrtc::WebRtcRTPHeader* rtp_header) OVERRIDE;
+      const webrtc::WebRtcRTPHeader* rtp_header) override;
 
   const uint8_t* payload_data() const { return payload_data_; }
   size_t payload_size() const { return payload_size_; }
diff --git a/webrtc/modules/rtp_rtcp/test/testAPI/test_api_audio.cc b/webrtc/modules/rtp_rtcp/test/testAPI/test_api_audio.cc
index c8b83d3..61923aa 100644
--- a/webrtc/modules/rtp_rtcp/test/testAPI/test_api_audio.cc
+++ b/webrtc/modules/rtp_rtcp/test/testAPI/test_api_audio.cc
@@ -25,10 +25,10 @@
 
 class VerifyingAudioReceiver : public NullRtpData {
  public:
-  virtual int32_t OnReceivedPayloadData(
+  int32_t OnReceivedPayloadData(
       const uint8_t* payloadData,
       const size_t payloadSize,
-      const webrtc::WebRtcRTPHeader* rtpHeader) OVERRIDE {
+      const webrtc::WebRtcRTPHeader* rtpHeader) override {
     if (rtpHeader->header.payloadType == 98 ||
         rtpHeader->header.payloadType == 99) {
       EXPECT_EQ(4u, payloadSize);
@@ -61,13 +61,12 @@
 
 class RTPCallback : public NullRtpFeedback {
  public:
-  virtual int32_t OnInitializeDecoder(
-      const int32_t id,
-      const int8_t payloadType,
-      const char payloadName[RTP_PAYLOAD_NAME_SIZE],
-      const int frequency,
-      const uint8_t channels,
-      const uint32_t rate) OVERRIDE {
+  int32_t OnInitializeDecoder(const int32_t id,
+                              const int8_t payloadType,
+                              const char payloadName[RTP_PAYLOAD_NAME_SIZE],
+                              const int frequency,
+                              const uint8_t channels,
+                              const uint32_t rate) override {
     if (payloadType == 96) {
       EXPECT_EQ(test_rate, rate) <<
           "The rate should be 64K for this payloadType";
@@ -88,7 +87,7 @@
   }
   ~RtpRtcpAudioTest() {}
 
-  virtual void SetUp() OVERRIDE {
+  void SetUp() override {
     audioFeedback = new NullRtpAudioFeedback();
     data_receiver1 = new VerifyingAudioReceiver();
     data_receiver2 = new VerifyingAudioReceiver();
@@ -133,7 +132,7 @@
                               rtp_receiver1_.get(), receive_statistics1_.get());
   }
 
-  virtual void TearDown() OVERRIDE {
+  void TearDown() override {
     delete module1;
     delete module2;
     delete transport1;
diff --git a/webrtc/modules/utility/source/coder.h b/webrtc/modules/utility/source/coder.h
index a821246..57eada1 100644
--- a/webrtc/modules/utility/source/coder.h
+++ b/webrtc/modules/utility/source/coder.h
@@ -42,13 +42,12 @@
                    size_t& encodedLengthInBytes);
 
 protected:
-    virtual int32_t SendData(
-        FrameType frameType,
-        uint8_t payloadType,
-        uint32_t timeStamp,
-        const uint8_t* payloadData,
-        size_t payloadSize,
-        const RTPFragmentationHeader* fragmentation) OVERRIDE;
+ int32_t SendData(FrameType frameType,
+                  uint8_t payloadType,
+                  uint32_t timeStamp,
+                  const uint8_t* payloadData,
+                  size_t payloadSize,
+                  const RTPFragmentationHeader* fragmentation) override;
 
 private:
  rtc::scoped_ptr<AudioCodingModule> _acm;
diff --git a/webrtc/modules/utility/source/file_player_unittests.cc b/webrtc/modules/utility/source/file_player_unittests.cc
index d430d9f..7ce9d47 100644
--- a/webrtc/modules/utility/source/file_player_unittests.cc
+++ b/webrtc/modules/utility/source/file_player_unittests.cc
@@ -35,7 +35,7 @@
       : player_(FilePlayer::CreateFilePlayer(kId, kFileFormat)),
         output_file_(NULL) {}
 
-  virtual void SetUp() OVERRIDE {
+  void SetUp() override {
     if (FLAGS_file_player_output) {
       std::string output_file =
           webrtc::test::OutputPath() + "file_player_unittest_out.pcm";
@@ -44,7 +44,7 @@
     }
   }
 
-  virtual void TearDown() OVERRIDE {
+  void TearDown() override {
     if (output_file_)
       fclose(output_file_);
   }
diff --git a/webrtc/modules/utility/source/rtp_dump_impl.h b/webrtc/modules/utility/source/rtp_dump_impl.h
index 5be9cbe..b49a690 100644
--- a/webrtc/modules/utility/source/rtp_dump_impl.h
+++ b/webrtc/modules/utility/source/rtp_dump_impl.h
@@ -22,11 +22,11 @@
     RtpDumpImpl();
     virtual ~RtpDumpImpl();
 
-    virtual int32_t Start(const char* fileNameUTF8) OVERRIDE;
-    virtual int32_t Stop() OVERRIDE;
-    virtual bool IsActive() const OVERRIDE;
-    virtual int32_t DumpPacket(const uint8_t* packet,
-                               size_t packetLength) OVERRIDE;
+    int32_t Start(const char* fileNameUTF8) override;
+    int32_t Stop() override;
+    bool IsActive() const override;
+    int32_t DumpPacket(const uint8_t* packet, size_t packetLength) override;
+
 private:
     // Return the system time in ms.
     inline uint32_t GetTimeInMS() const;
diff --git a/webrtc/modules/video_capture/ios/device_info_ios.h b/webrtc/modules/video_capture/ios/device_info_ios.h
index 476e919..e10db4a 100644
--- a/webrtc/modules/video_capture/ios/device_info_ios.h
+++ b/webrtc/modules/video_capture/ios/device_info_ios.h
@@ -21,40 +21,36 @@
   virtual ~DeviceInfoIos();
 
   // Implementation of DeviceInfoImpl.
-  virtual int32_t Init() OVERRIDE;
-  virtual uint32_t NumberOfDevices() OVERRIDE;
-  virtual int32_t GetDeviceName(
-      uint32_t deviceNumber,
-      char* deviceNameUTF8,
-      uint32_t deviceNameLength,
-      char* deviceUniqueIdUTF8,
-      uint32_t deviceUniqueIdUTF8Length,
-      char* productUniqueIdUTF8 = 0,
-      uint32_t productUniqueIdUTF8Length = 0) OVERRIDE;
+  int32_t Init() override;
+  uint32_t NumberOfDevices() override;
+  int32_t GetDeviceName(uint32_t deviceNumber,
+                        char* deviceNameUTF8,
+                        uint32_t deviceNameLength,
+                        char* deviceUniqueIdUTF8,
+                        uint32_t deviceUniqueIdUTF8Length,
+                        char* productUniqueIdUTF8 = 0,
+                        uint32_t productUniqueIdUTF8Length = 0) override;
 
-  virtual int32_t NumberOfCapabilities(const char* deviceUniqueIdUTF8) OVERRIDE;
+  int32_t NumberOfCapabilities(const char* deviceUniqueIdUTF8) override;
 
-  virtual int32_t GetCapability(const char* deviceUniqueIdUTF8,
-                                const uint32_t deviceCapabilityNumber,
-                                VideoCaptureCapability& capability) OVERRIDE;
+  int32_t GetCapability(const char* deviceUniqueIdUTF8,
+                        const uint32_t deviceCapabilityNumber,
+                        VideoCaptureCapability& capability) override;
 
-  virtual int32_t GetBestMatchedCapability(
-      const char* deviceUniqueIdUTF8,
-      const VideoCaptureCapability& requested,
-      VideoCaptureCapability& resulting) OVERRIDE;
+  int32_t GetBestMatchedCapability(const char* deviceUniqueIdUTF8,
+                                   const VideoCaptureCapability& requested,
+                                   VideoCaptureCapability& resulting) override;
 
-  virtual int32_t DisplayCaptureSettingsDialogBox(
-      const char* deviceUniqueIdUTF8,
-      const char* dialogTitleUTF8,
-      void* parentWindow,
-      uint32_t positionX,
-      uint32_t positionY) OVERRIDE;
+  int32_t DisplayCaptureSettingsDialogBox(const char* deviceUniqueIdUTF8,
+                                          const char* dialogTitleUTF8,
+                                          void* parentWindow,
+                                          uint32_t positionX,
+                                          uint32_t positionY) override;
 
-  virtual int32_t GetOrientation(const char* deviceUniqueIdUTF8,
-                                 VideoRotation& orientation) OVERRIDE;
+  int32_t GetOrientation(const char* deviceUniqueIdUTF8,
+                         VideoRotation& orientation) override;
 
-  virtual int32_t CreateCapabilityMap(
-      const char* device_unique_id_utf8) OVERRIDE;
+  int32_t CreateCapabilityMap(const char* device_unique_id_utf8) override;
 };
 
 }  // namespace videocapturemodule
diff --git a/webrtc/modules/video_capture/ios/video_capture_ios.h b/webrtc/modules/video_capture/ios/video_capture_ios.h
index ff8345f..1afcbad 100644
--- a/webrtc/modules/video_capture/ios/video_capture_ios.h
+++ b/webrtc/modules/video_capture/ios/video_capture_ios.h
@@ -26,11 +26,10 @@
                                     const char* device_unique_id_utf8);
 
   // Implementation of VideoCaptureImpl.
-  virtual int32_t StartCapture(
-      const VideoCaptureCapability& capability) OVERRIDE;
-  virtual int32_t StopCapture() OVERRIDE;
-  virtual bool CaptureStarted() OVERRIDE;
-  virtual int32_t CaptureSettings(VideoCaptureCapability& settings) OVERRIDE;
+  int32_t StartCapture(const VideoCaptureCapability& capability) override;
+  int32_t StopCapture() override;
+  bool CaptureStarted() override;
+  int32_t CaptureSettings(VideoCaptureCapability& settings) override;
 
  private:
   RTCVideoCaptureIosObjC* capture_device_;
diff --git a/webrtc/modules/video_coding/codecs/i420/main/interface/i420.h b/webrtc/modules/video_coding/codecs/i420/main/interface/i420.h
index 7fef060..f115907 100644
--- a/webrtc/modules/video_coding/codecs/i420/main/interface/i420.h
+++ b/webrtc/modules/video_coding/codecs/i420/main/interface/i420.h
@@ -34,9 +34,9 @@
 //
 // Return value                 : WEBRTC_VIDEO_CODEC_OK if OK.
 //                                <0 - Error
-  virtual int InitEncode(const VideoCodec* codecSettings,
-                         int /*numberOfCores*/,
-                         size_t /*maxPayloadSize*/) OVERRIDE;
+  int InitEncode(const VideoCodec* codecSettings,
+                 int /*numberOfCores*/,
+                 size_t /*maxPayloadSize*/) override;
 
 // "Encode" an I420 image (as a part of a video stream). The encoded image
 // will be returned to the user via the encode complete callback.
@@ -48,10 +48,9 @@
 //
 // Return value                 : WEBRTC_VIDEO_CODEC_OK if OK.
 //                                <0 - Error
-  virtual int Encode(
-      const I420VideoFrame& inputImage,
-      const CodecSpecificInfo* /*codecSpecificInfo*/,
-      const std::vector<VideoFrameType>* /*frame_types*/) OVERRIDE;
+  int Encode(const I420VideoFrame& inputImage,
+             const CodecSpecificInfo* /*codecSpecificInfo*/,
+             const std::vector<VideoFrameType>* /*frame_types*/) override;
 
 // Register an encode complete callback object.
 //
@@ -59,26 +58,22 @@
 //          - callback         : Callback object which handles encoded images.
 //
 // Return value                : WEBRTC_VIDEO_CODEC_OK if OK, < 0 otherwise.
-  virtual int RegisterEncodeCompleteCallback(
-      EncodedImageCallback* callback) OVERRIDE;
+  int RegisterEncodeCompleteCallback(EncodedImageCallback* callback) override;
 
 // Free encoder memory.
 //
 // Return value                : WEBRTC_VIDEO_CODEC_OK if OK, < 0 otherwise.
-  virtual int Release() OVERRIDE;
+  int Release() override;
 
-  virtual int SetRates(uint32_t /*newBitRate*/,
-                       uint32_t /*frameRate*/) OVERRIDE {
+  int SetRates(uint32_t /*newBitRate*/, uint32_t /*frameRate*/) override {
     return WEBRTC_VIDEO_CODEC_OK;
   }
 
-  virtual int SetChannelParameters(uint32_t /*packetLoss*/,
-                                   int64_t /*rtt*/) OVERRIDE {
+  int SetChannelParameters(uint32_t /*packetLoss*/, int64_t /*rtt*/) override {
     return WEBRTC_VIDEO_CODEC_OK;
   }
 
-  virtual int CodecConfigParameters(uint8_t* /*buffer*/,
-                                    int /*size*/) OVERRIDE {
+  int CodecConfigParameters(uint8_t* /*buffer*/, int /*size*/) override {
     return WEBRTC_VIDEO_CODEC_OK;
   }
 
@@ -102,11 +97,11 @@
 //
 // Return value         :  WEBRTC_VIDEO_CODEC_OK.
 //                        <0 - Errors
-  virtual int InitDecode(const VideoCodec* codecSettings,
-                         int /*numberOfCores*/) OVERRIDE;
+  int InitDecode(const VideoCodec* codecSettings,
+                 int /*numberOfCores*/) override;
 
-  virtual int SetCodecConfigParameters(const uint8_t* /*buffer*/,
-                                       int /*size*/) OVERRIDE {
+  int SetCodecConfigParameters(const uint8_t* /*buffer*/,
+                               int /*size*/) override {
     return WEBRTC_VIDEO_CODEC_OK;
   }
 
@@ -122,11 +117,11 @@
 //
 // Return value                 : WEBRTC_VIDEO_CODEC_OK if OK
 //                                 <0 - Error
-  virtual int Decode(const EncodedImage& inputImage,
-                     bool missingFrames,
-                     const RTPFragmentationHeader* /*fragmentation*/,
-                     const CodecSpecificInfo* /*codecSpecificInfo*/,
-                     int64_t /*renderTimeMs*/) OVERRIDE;
+  int Decode(const EncodedImage& inputImage,
+             bool missingFrames,
+             const RTPFragmentationHeader* /*fragmentation*/,
+             const CodecSpecificInfo* /*codecSpecificInfo*/,
+             int64_t /*renderTimeMs*/) override;
 
 // Register a decode complete callback object.
 //
@@ -134,20 +129,19 @@
 //          - callback         : Callback object which handles decoded images.
 //
 // Return value                : WEBRTC_VIDEO_CODEC_OK if OK, < 0 otherwise.
-  virtual int RegisterDecodeCompleteCallback(
-      DecodedImageCallback* callback) OVERRIDE;
+  int RegisterDecodeCompleteCallback(DecodedImageCallback* callback) override;
 
 // Free decoder memory.
 //
 // Return value                : WEBRTC_VIDEO_CODEC_OK if OK.
 //                                  <0 - Error
-  virtual int Release() OVERRIDE;
+  int Release() override;
 
 // Reset decoder state and prepare for a new call.
 //
 // Return value         :  WEBRTC_VIDEO_CODEC_OK.
 //                          <0 - Error
-  virtual int Reset() OVERRIDE;
+  int Reset() override;
 
  private:
   static const uint8_t* ExtractHeader(const uint8_t* buffer,
diff --git a/webrtc/modules/video_coding/codecs/test/packet_manipulator.h b/webrtc/modules/video_coding/codecs/test/packet_manipulator.h
index 3cf7233..5a1654a 100644
--- a/webrtc/modules/video_coding/codecs/test/packet_manipulator.h
+++ b/webrtc/modules/video_coding/codecs/test/packet_manipulator.h
@@ -91,7 +91,7 @@
                         const NetworkingConfig& config,
                         bool verbose);
   virtual ~PacketManipulatorImpl();
-  virtual int ManipulatePackets(webrtc::EncodedImage* encoded_image) OVERRIDE;
+  int ManipulatePackets(webrtc::EncodedImage* encoded_image) override;
   virtual void InitializeRandomSeed(unsigned int seed);
  protected:
   // Returns a uniformly distributed random value between 0.0 and 1.0
diff --git a/webrtc/modules/video_coding/codecs/test/predictive_packet_manipulator.h b/webrtc/modules/video_coding/codecs/test/predictive_packet_manipulator.h
index fcd5064..082712d 100644
--- a/webrtc/modules/video_coding/codecs/test/predictive_packet_manipulator.h
+++ b/webrtc/modules/video_coding/codecs/test/predictive_packet_manipulator.h
@@ -33,7 +33,7 @@
   void AddRandomResult(double result);
  protected:
   // Returns a uniformly distributed random value between 0.0 and 1.0
-  virtual double RandomUniform() OVERRIDE;
+  double RandomUniform() override;
 
  private:
   std::queue<double> random_results_;
diff --git a/webrtc/modules/video_coding/codecs/test/videoprocessor.h b/webrtc/modules/video_coding/codecs/test/videoprocessor.h
index b092363..63d7363 100644
--- a/webrtc/modules/video_coding/codecs/test/videoprocessor.h
+++ b/webrtc/modules/video_coding/codecs/test/videoprocessor.h
@@ -163,8 +163,8 @@
                      const TestConfig& config,
                      Stats* stats);
   virtual ~VideoProcessorImpl();
-  virtual bool Init() OVERRIDE;
-  virtual bool ProcessFrame(int frame_number) OVERRIDE;
+  bool Init() override;
+  bool ProcessFrame(int frame_number) override;
 
  private:
   // Invoked by the callback when a frame has completed encoding.
@@ -176,13 +176,13 @@
   int GetElapsedTimeMicroseconds(const webrtc::TickTime& start,
                                  const webrtc::TickTime& stop);
   // Updates the encoder with the target bit rate and the frame rate.
-  virtual void SetRates(int bit_rate, int frame_rate) OVERRIDE;
+  void SetRates(int bit_rate, int frame_rate) override;
   // Return the size of the encoded frame in bytes.
-  virtual size_t EncodedFrameSize() OVERRIDE;
+  size_t EncodedFrameSize() override;
   // Return the number of dropped frames.
-  virtual int NumberDroppedFrames() OVERRIDE;
+  int NumberDroppedFrames() override;
   // Return the number of spatial resizes.
-  virtual int NumberSpatialResizes() OVERRIDE;
+  int NumberSpatialResizes() override;
 
   webrtc::VideoEncoder* encoder_;
   webrtc::VideoDecoder* decoder_;
@@ -225,10 +225,10 @@
    public:
     explicit VideoProcessorEncodeCompleteCallback(VideoProcessorImpl* vp)
         : video_processor_(vp) {}
-    virtual int32_t Encoded(
+    int32_t Encoded(
         const webrtc::EncodedImage& encoded_image,
         const webrtc::CodecSpecificInfo* codec_specific_info,
-        const webrtc::RTPFragmentationHeader* fragmentation) OVERRIDE;
+        const webrtc::RTPFragmentationHeader* fragmentation) override;
 
    private:
     VideoProcessorImpl* video_processor_;
@@ -241,7 +241,7 @@
       explicit VideoProcessorDecodeCompleteCallback(VideoProcessorImpl* vp)
       : video_processor_(vp) {
     }
-    virtual int32_t Decoded(webrtc::I420VideoFrame& image) OVERRIDE;
+      int32_t Decoded(webrtc::I420VideoFrame& image) override;
 
    private:
     VideoProcessorImpl* video_processor_;
diff --git a/webrtc/modules/video_coding/codecs/vp8/screenshare_layers_unittest.cc b/webrtc/modules/video_coding/codecs/vp8/screenshare_layers_unittest.cc
index fdf378f..40677bb 100644
--- a/webrtc/modules/video_coding/codecs/vp8/screenshare_layers_unittest.cc
+++ b/webrtc/modules/video_coding/codecs/vp8/screenshare_layers_unittest.cc
@@ -46,7 +46,7 @@
   virtual ~ScreenshareLayersFT() {}
 
  protected:
-  virtual bool TargetBitrateExperimentEnabled() OVERRIDE { return true; }
+  bool TargetBitrateExperimentEnabled() override { return true; }
 };
 
 class ScreenshareLayerTest : public ::testing::Test {
diff --git a/webrtc/modules/video_coding/codecs/vp8/simulcast_encoder_adapter.h b/webrtc/modules/video_coding/codecs/vp8/simulcast_encoder_adapter.h
index 2d8a47d..d185d15 100644
--- a/webrtc/modules/video_coding/codecs/vp8/simulcast_encoder_adapter.h
+++ b/webrtc/modules/video_coding/codecs/vp8/simulcast_encoder_adapter.h
@@ -37,24 +37,21 @@
   virtual ~SimulcastEncoderAdapter();
 
   // Implements VideoEncoder
-  virtual int Release() OVERRIDE;
-  virtual int InitEncode(const VideoCodec* inst,
-                         int number_of_cores,
-                         size_t max_payload_size) OVERRIDE;
-  virtual int Encode(const I420VideoFrame& input_image,
-                     const CodecSpecificInfo* codec_specific_info,
-                     const std::vector<VideoFrameType>* frame_types) OVERRIDE;
-  virtual int RegisterEncodeCompleteCallback(
-      EncodedImageCallback* callback) OVERRIDE;
-  virtual int SetChannelParameters(uint32_t packet_loss, int64_t rtt) OVERRIDE;
-  virtual int SetRates(uint32_t new_bitrate_kbit,
-                       uint32_t new_framerate) OVERRIDE;
+  int Release() override;
+  int InitEncode(const VideoCodec* inst,
+                 int number_of_cores,
+                 size_t max_payload_size) override;
+  int Encode(const I420VideoFrame& input_image,
+             const CodecSpecificInfo* codec_specific_info,
+             const std::vector<VideoFrameType>* frame_types) override;
+  int RegisterEncodeCompleteCallback(EncodedImageCallback* callback) override;
+  int SetChannelParameters(uint32_t packet_loss, int64_t rtt) override;
+  int SetRates(uint32_t new_bitrate_kbit, uint32_t new_framerate) override;
 
   // Implements EncodedImageCallback
-  virtual int32_t Encoded(
-      const EncodedImage& encodedImage,
-      const CodecSpecificInfo* codecSpecificInfo = NULL,
-      const RTPFragmentationHeader* fragmentation = NULL) OVERRIDE;
+  int32_t Encoded(const EncodedImage& encodedImage,
+                  const CodecSpecificInfo* codecSpecificInfo = NULL,
+                  const RTPFragmentationHeader* fragmentation = NULL) override;
 
  private:
   struct StreamInfo {
diff --git a/webrtc/modules/video_coding/codecs/vp8/simulcast_encoder_adapter_unittest.cc b/webrtc/modules/video_coding/codecs/vp8/simulcast_encoder_adapter_unittest.cc
index 762c507..2c2a323 100644
--- a/webrtc/modules/video_coding/codecs/vp8/simulcast_encoder_adapter_unittest.cc
+++ b/webrtc/modules/video_coding/codecs/vp8/simulcast_encoder_adapter_unittest.cc
@@ -145,15 +145,13 @@
 
 class MockVideoEncoderFactory : public VideoEncoderFactory {
  public:
-  virtual VideoEncoder* Create() OVERRIDE {
+  VideoEncoder* Create() override {
     MockVideoEncoder* encoder = new MockVideoEncoder();
     encoders_.push_back(encoder);
     return encoder;
   }
 
-  virtual void Destroy(VideoEncoder* encoder) OVERRIDE {
-    delete encoder;
-  }
+  void Destroy(VideoEncoder* encoder) override { delete encoder; }
 
   virtual ~MockVideoEncoderFactory() {}
 
diff --git a/webrtc/modules/video_coding/codecs/vp8/simulcast_unittest.h b/webrtc/modules/video_coding/codecs/vp8/simulcast_unittest.h
index b2029b1..4925b93 100644
--- a/webrtc/modules/video_coding/codecs/vp8/simulcast_unittest.h
+++ b/webrtc/modules/video_coding/codecs/vp8/simulcast_unittest.h
@@ -186,28 +186,26 @@
       return layers_->EncodeFlags(timestamp);
     }
 
-    virtual bool ConfigureBitrates(int bitrate_kbit,
-                                   int max_bitrate_kbit,
-                                   int framerate,
-                                   vpx_codec_enc_cfg_t* cfg) OVERRIDE {
+    bool ConfigureBitrates(int bitrate_kbit,
+                           int max_bitrate_kbit,
+                           int framerate,
+                           vpx_codec_enc_cfg_t* cfg) override {
       configured_bitrate_ = bitrate_kbit;
       return layers_->ConfigureBitrates(
           bitrate_kbit, max_bitrate_kbit, framerate, cfg);
     }
 
-    virtual void PopulateCodecSpecific(bool base_layer_sync,
-                                       CodecSpecificInfoVP8* vp8_info,
-                                       uint32_t timestamp) OVERRIDE {
+    void PopulateCodecSpecific(bool base_layer_sync,
+                               CodecSpecificInfoVP8* vp8_info,
+                               uint32_t timestamp) override {
       layers_->PopulateCodecSpecific(base_layer_sync, vp8_info, timestamp);
     }
 
-    virtual void FrameEncoded(unsigned int size, uint32_t timestamp) OVERRIDE {
+    void FrameEncoded(unsigned int size, uint32_t timestamp) override {
       layers_->FrameEncoded(size, timestamp);
     }
 
-    virtual int CurrentLayerId() const OVERRIDE {
-      return layers_->CurrentLayerId();
-    }
+    int CurrentLayerId() const override { return layers_->CurrentLayerId(); }
 
     int configured_bitrate_;
     TemporalLayers* layers_;
@@ -216,8 +214,8 @@
   class SpyingTemporalLayersFactory : public TemporalLayers::Factory {
    public:
     virtual ~SpyingTemporalLayersFactory() {}
-    virtual TemporalLayers* Create(int temporal_layers,
-                                   uint8_t initial_tl0_pic_idx) const OVERRIDE {
+    TemporalLayers* Create(int temporal_layers,
+                           uint8_t initial_tl0_pic_idx) const override {
       SpyingTemporalLayers* layers =
           new SpyingTemporalLayers(TemporalLayers::Factory::Create(
               temporal_layers, initial_tl0_pic_idx));
diff --git a/webrtc/modules/video_coding/codecs/vp8/vp8_factory.cc b/webrtc/modules/video_coding/codecs/vp8/vp8_factory.cc
index 414b3a7..f701481 100644
--- a/webrtc/modules/video_coding/codecs/vp8/vp8_factory.cc
+++ b/webrtc/modules/video_coding/codecs/vp8/vp8_factory.cc
@@ -19,13 +19,9 @@
 
 class VP8EncoderImplFactory : public VideoEncoderFactory {
  public:
-  virtual VideoEncoder* Create() OVERRIDE {
-    return new VP8EncoderImpl();
-  }
+  VideoEncoder* Create() override { return new VP8EncoderImpl(); }
 
-  virtual void Destroy(VideoEncoder* encoder) OVERRIDE {
-    delete encoder;
-  }
+  void Destroy(VideoEncoder* encoder) override { delete encoder; }
 
   virtual ~VP8EncoderImplFactory() {}
 };
diff --git a/webrtc/modules/video_coding/codecs/vp9/vp9_impl.h b/webrtc/modules/video_coding/codecs/vp9/vp9_impl.h
index 9d46d0d..019e73e 100644
--- a/webrtc/modules/video_coding/codecs/vp9/vp9_impl.h
+++ b/webrtc/modules/video_coding/codecs/vp9/vp9_impl.h
@@ -25,22 +25,21 @@
 
   virtual ~VP9EncoderImpl();
 
-  virtual int Release() OVERRIDE;
+  int Release() override;
 
-  virtual int InitEncode(const VideoCodec* codec_settings,
-                         int number_of_cores,
-                         size_t max_payload_size) OVERRIDE;
+  int InitEncode(const VideoCodec* codec_settings,
+                 int number_of_cores,
+                 size_t max_payload_size) override;
 
-  virtual int Encode(const I420VideoFrame& input_image,
-                     const CodecSpecificInfo* codec_specific_info,
-                     const std::vector<VideoFrameType>* frame_types) OVERRIDE;
+  int Encode(const I420VideoFrame& input_image,
+             const CodecSpecificInfo* codec_specific_info,
+             const std::vector<VideoFrameType>* frame_types) override;
 
-  virtual int RegisterEncodeCompleteCallback(EncodedImageCallback* callback)
-  OVERRIDE;
+  int RegisterEncodeCompleteCallback(EncodedImageCallback* callback) override;
 
-  virtual int SetChannelParameters(uint32_t packet_loss, int64_t rtt) OVERRIDE;
+  int SetChannelParameters(uint32_t packet_loss, int64_t rtt) override;
 
-  virtual int SetRates(uint32_t new_bitrate_kbit, uint32_t frame_rate) OVERRIDE;
+  int SetRates(uint32_t new_bitrate_kbit, uint32_t frame_rate) override;
 
  private:
   // Determine number of encoder threads to use.
@@ -83,20 +82,19 @@
 
   virtual ~VP9DecoderImpl();
 
-  virtual int InitDecode(const VideoCodec* inst, int number_of_cores) OVERRIDE;
+  int InitDecode(const VideoCodec* inst, int number_of_cores) override;
 
-  virtual int Decode(const EncodedImage& input_image,
-                     bool missing_frames,
-                     const RTPFragmentationHeader* fragmentation,
-                     const CodecSpecificInfo* codec_specific_info,
-                     int64_t /*render_time_ms*/) OVERRIDE;
+  int Decode(const EncodedImage& input_image,
+             bool missing_frames,
+             const RTPFragmentationHeader* fragmentation,
+             const CodecSpecificInfo* codec_specific_info,
+             int64_t /*render_time_ms*/) override;
 
-  virtual int RegisterDecodeCompleteCallback(DecodedImageCallback* callback)
-  OVERRIDE;
+  int RegisterDecodeCompleteCallback(DecodedImageCallback* callback) override;
 
-  virtual int Release() OVERRIDE;
+  int Release() override;
 
-  virtual int Reset() OVERRIDE;
+  int Reset() override;
 
  private:
   int ReturnFrame(const vpx_image_t* img, uint32_t timeStamp);
diff --git a/webrtc/modules/video_coding/main/source/video_coding_impl.cc b/webrtc/modules/video_coding/main/source/video_coding_impl.cc
index ff2ab93..4f86153 100644
--- a/webrtc/modules/video_coding/main/source/video_coding_impl.cc
+++ b/webrtc/modules/video_coding/main/source/video_coding_impl.cc
@@ -88,7 +88,7 @@
     own_event_factory_.reset();
   }
 
-  virtual int64_t TimeUntilNextProcess() OVERRIDE {
+  int64_t TimeUntilNextProcess() override {
     int64_t sender_time = sender_->TimeUntilNextProcess();
     int64_t receiver_time = receiver_->TimeUntilNextProcess();
     assert(sender_time >= 0);
@@ -96,7 +96,7 @@
     return VCM_MIN(sender_time, receiver_time);
   }
 
-  virtual int32_t Process() OVERRIDE {
+  int32_t Process() override {
     int32_t sender_return = sender_->Process();
     int32_t receiver_return = receiver_->Process();
     if (sender_return != VCM_OK)
@@ -104,78 +104,75 @@
     return receiver_return;
   }
 
-  virtual int32_t InitializeSender() OVERRIDE {
-    return sender_->InitializeSender();
-  }
+  int32_t InitializeSender() override { return sender_->InitializeSender(); }
 
-  virtual int32_t RegisterSendCodec(const VideoCodec* sendCodec,
-                                    uint32_t numberOfCores,
-                                    uint32_t maxPayloadSize) OVERRIDE {
+  int32_t RegisterSendCodec(const VideoCodec* sendCodec,
+                            uint32_t numberOfCores,
+                            uint32_t maxPayloadSize) override {
     return sender_->RegisterSendCodec(sendCodec, numberOfCores, maxPayloadSize);
   }
 
-  virtual const VideoCodec& GetSendCodec() const OVERRIDE {
+  const VideoCodec& GetSendCodec() const override {
     return sender_->GetSendCodec();
   }
 
   // DEPRECATED.
-  virtual int32_t SendCodec(VideoCodec* currentSendCodec) const OVERRIDE {
+  int32_t SendCodec(VideoCodec* currentSendCodec) const override {
     return sender_->SendCodecBlocking(currentSendCodec);
   }
 
   // DEPRECATED.
-  virtual VideoCodecType SendCodec() const OVERRIDE {
+  VideoCodecType SendCodec() const override {
     return sender_->SendCodecBlocking();
   }
 
-  virtual int32_t RegisterExternalEncoder(VideoEncoder* externalEncoder,
-                                          uint8_t payloadType,
-                                          bool internalSource) OVERRIDE {
+  int32_t RegisterExternalEncoder(VideoEncoder* externalEncoder,
+                                  uint8_t payloadType,
+                                  bool internalSource) override {
     return sender_->RegisterExternalEncoder(
         externalEncoder, payloadType, internalSource);
   }
 
-  virtual int32_t CodecConfigParameters(uint8_t* buffer,
-                                        int32_t size) OVERRIDE {
+  int32_t CodecConfigParameters(uint8_t* buffer, int32_t size) override {
     return sender_->CodecConfigParameters(buffer, size);
   }
 
-  virtual int Bitrate(unsigned int* bitrate) const OVERRIDE {
+  int Bitrate(unsigned int* bitrate) const override {
     return sender_->Bitrate(bitrate);
   }
 
-  virtual int FrameRate(unsigned int* framerate) const OVERRIDE {
+  int FrameRate(unsigned int* framerate) const override {
     return sender_->FrameRate(framerate);
   }
 
-  virtual int32_t SetChannelParameters(uint32_t target_bitrate,  // bits/s.
-                                       uint8_t lossRate,
-                                       int64_t rtt) OVERRIDE {
+  int32_t SetChannelParameters(uint32_t target_bitrate,  // bits/s.
+                               uint8_t lossRate,
+                               int64_t rtt) override {
     return sender_->SetChannelParameters(target_bitrate, lossRate, rtt);
   }
 
-  virtual int32_t RegisterTransportCallback(
-      VCMPacketizationCallback* transport) OVERRIDE {
+  int32_t RegisterTransportCallback(
+      VCMPacketizationCallback* transport) override {
     return sender_->RegisterTransportCallback(transport);
   }
 
-  virtual int32_t RegisterSendStatisticsCallback(
-      VCMSendStatisticsCallback* sendStats) OVERRIDE {
+  int32_t RegisterSendStatisticsCallback(
+      VCMSendStatisticsCallback* sendStats) override {
     return sender_->RegisterSendStatisticsCallback(sendStats);
   }
 
-  virtual int32_t RegisterVideoQMCallback(
-      VCMQMSettingsCallback* videoQMSettings) OVERRIDE {
+  int32_t RegisterVideoQMCallback(
+      VCMQMSettingsCallback* videoQMSettings) override {
     return sender_->RegisterVideoQMCallback(videoQMSettings);
   }
 
-  virtual int32_t RegisterProtectionCallback(
-      VCMProtectionCallback* protection) OVERRIDE {
+  int32_t RegisterProtectionCallback(
+      VCMProtectionCallback* protection) override {
     return sender_->RegisterProtectionCallback(protection);
   }
 
-  virtual int32_t SetVideoProtection(VCMVideoProtection videoProtection,
-                                     bool enable) OVERRIDE {
+  int32_t SetVideoProtection(VCMVideoProtection videoProtection,
+                             bool enable) override {
     int32_t sender_return =
         sender_->SetVideoProtection(videoProtection, enable);
     int32_t receiver_return =
@@ -185,172 +182,168 @@
     return sender_return;
   }
 
-  virtual int32_t AddVideoFrame(
-      const I420VideoFrame& videoFrame,
-      const VideoContentMetrics* contentMetrics,
-      const CodecSpecificInfo* codecSpecificInfo) OVERRIDE {
+  int32_t AddVideoFrame(const I420VideoFrame& videoFrame,
+                        const VideoContentMetrics* contentMetrics,
+                        const CodecSpecificInfo* codecSpecificInfo) override {
     return sender_->AddVideoFrame(
         videoFrame, contentMetrics, codecSpecificInfo);
   }
 
-  virtual int32_t IntraFrameRequest(int stream_index) OVERRIDE {
+  int32_t IntraFrameRequest(int stream_index) override {
     return sender_->IntraFrameRequest(stream_index);
   }
 
-  virtual int32_t EnableFrameDropper(bool enable) OVERRIDE {
+  int32_t EnableFrameDropper(bool enable) override {
     return sender_->EnableFrameDropper(enable);
   }
 
-  virtual int32_t SentFrameCount(VCMFrameCount& frameCount) const OVERRIDE {
+  int32_t SentFrameCount(VCMFrameCount& frameCount) const override {
     return sender_->SentFrameCount(&frameCount);
   }
 
-  virtual int SetSenderNackMode(SenderNackMode mode) OVERRIDE {
+  int SetSenderNackMode(SenderNackMode mode) override {
     return sender_->SetSenderNackMode(mode);
   }
 
-  virtual int SetSenderReferenceSelection(bool enable) OVERRIDE {
+  int SetSenderReferenceSelection(bool enable) override {
     return sender_->SetSenderReferenceSelection(enable);
   }
 
-  virtual int SetSenderFEC(bool enable) OVERRIDE {
+  int SetSenderFEC(bool enable) override {
     return sender_->SetSenderFEC(enable);
   }
 
-  virtual int SetSenderKeyFramePeriod(int periodMs) OVERRIDE {
+  int SetSenderKeyFramePeriod(int periodMs) override {
     return sender_->SetSenderKeyFramePeriod(periodMs);
   }
 
-  virtual int StartDebugRecording(const char* file_name_utf8) OVERRIDE {
+  int StartDebugRecording(const char* file_name_utf8) override {
     return sender_->StartDebugRecording(file_name_utf8);
   }
 
-  virtual int StopDebugRecording() OVERRIDE {
+  int StopDebugRecording() override {
     sender_->StopDebugRecording();
     return VCM_OK;
   }
 
-  virtual void SuspendBelowMinBitrate() OVERRIDE {
+  void SuspendBelowMinBitrate() override {
     return sender_->SuspendBelowMinBitrate();
   }
 
-  virtual bool VideoSuspended() const OVERRIDE {
-    return sender_->VideoSuspended();
-  }
+  bool VideoSuspended() const override { return sender_->VideoSuspended(); }
 
-  virtual int32_t InitializeReceiver() OVERRIDE {
+  int32_t InitializeReceiver() override {
     return receiver_->InitializeReceiver();
   }
 
-  virtual int32_t RegisterReceiveCodec(const VideoCodec* receiveCodec,
-                                       int32_t numberOfCores,
-                                       bool requireKeyFrame) OVERRIDE {
+  int32_t RegisterReceiveCodec(const VideoCodec* receiveCodec,
+                               int32_t numberOfCores,
+                               bool requireKeyFrame) override {
     return receiver_->RegisterReceiveCodec(
         receiveCodec, numberOfCores, requireKeyFrame);
   }
 
-  virtual int32_t RegisterExternalDecoder(VideoDecoder* externalDecoder,
-                                          uint8_t payloadType,
-                                          bool internalRenderTiming) OVERRIDE {
+  int32_t RegisterExternalDecoder(VideoDecoder* externalDecoder,
+                                  uint8_t payloadType,
+                                  bool internalRenderTiming) override {
     return receiver_->RegisterExternalDecoder(
         externalDecoder, payloadType, internalRenderTiming);
   }
 
-  virtual int32_t RegisterReceiveCallback(
-      VCMReceiveCallback* receiveCallback) OVERRIDE {
+  int32_t RegisterReceiveCallback(
+      VCMReceiveCallback* receiveCallback) override {
     return receiver_->RegisterReceiveCallback(receiveCallback);
   }
 
-  virtual int32_t RegisterReceiveStatisticsCallback(
-      VCMReceiveStatisticsCallback* receiveStats) OVERRIDE {
+  int32_t RegisterReceiveStatisticsCallback(
+      VCMReceiveStatisticsCallback* receiveStats) override {
     return receiver_->RegisterReceiveStatisticsCallback(receiveStats);
   }
 
-  virtual int32_t RegisterDecoderTimingCallback(
-      VCMDecoderTimingCallback* decoderTiming) OVERRIDE {
+  int32_t RegisterDecoderTimingCallback(
+      VCMDecoderTimingCallback* decoderTiming) override {
     return receiver_->RegisterDecoderTimingCallback(decoderTiming);
   }
 
-  virtual int32_t RegisterFrameTypeCallback(
-      VCMFrameTypeCallback* frameTypeCallback) OVERRIDE {
+  int32_t RegisterFrameTypeCallback(
+      VCMFrameTypeCallback* frameTypeCallback) override {
     return receiver_->RegisterFrameTypeCallback(frameTypeCallback);
   }
 
-  virtual int32_t RegisterPacketRequestCallback(
-      VCMPacketRequestCallback* callback) OVERRIDE {
+  int32_t RegisterPacketRequestCallback(
+      VCMPacketRequestCallback* callback) override {
     return receiver_->RegisterPacketRequestCallback(callback);
   }
 
-  virtual int RegisterRenderBufferSizeCallback(
-      VCMRenderBufferSizeCallback* callback) OVERRIDE {
+  int RegisterRenderBufferSizeCallback(
+      VCMRenderBufferSizeCallback* callback) override {
     return receiver_->RegisterRenderBufferSizeCallback(callback);
   }
 
-  virtual int32_t Decode(uint16_t maxWaitTimeMs) OVERRIDE {
+  int32_t Decode(uint16_t maxWaitTimeMs) override {
     return receiver_->Decode(maxWaitTimeMs);
   }
 
-  virtual int32_t ResetDecoder() OVERRIDE { return receiver_->ResetDecoder(); }
+  int32_t ResetDecoder() override { return receiver_->ResetDecoder(); }
 
-  virtual int32_t ReceiveCodec(VideoCodec* currentReceiveCodec) const OVERRIDE {
+  int32_t ReceiveCodec(VideoCodec* currentReceiveCodec) const override {
     return receiver_->ReceiveCodec(currentReceiveCodec);
   }
 
-  virtual VideoCodecType ReceiveCodec() const OVERRIDE {
+  VideoCodecType ReceiveCodec() const override {
     return receiver_->ReceiveCodec();
   }
 
-  virtual int32_t IncomingPacket(const uint8_t* incomingPayload,
-                                 size_t payloadLength,
-                                 const WebRtcRTPHeader& rtpInfo) OVERRIDE {
+  int32_t IncomingPacket(const uint8_t* incomingPayload,
+                         size_t payloadLength,
+                         const WebRtcRTPHeader& rtpInfo) override {
     return receiver_->IncomingPacket(incomingPayload, payloadLength, rtpInfo);
   }
 
-  virtual int32_t SetMinimumPlayoutDelay(uint32_t minPlayoutDelayMs) OVERRIDE {
+  int32_t SetMinimumPlayoutDelay(uint32_t minPlayoutDelayMs) override {
     return receiver_->SetMinimumPlayoutDelay(minPlayoutDelayMs);
   }
 
-  virtual int32_t SetRenderDelay(uint32_t timeMS) OVERRIDE {
+  int32_t SetRenderDelay(uint32_t timeMS) override {
     return receiver_->SetRenderDelay(timeMS);
   }
 
-  virtual int32_t Delay() const OVERRIDE { return receiver_->Delay(); }
+  int32_t Delay() const override { return receiver_->Delay(); }
 
-  virtual uint32_t DiscardedPackets() const OVERRIDE {
+  uint32_t DiscardedPackets() const override {
     return receiver_->DiscardedPackets();
   }
 
-  virtual int SetReceiverRobustnessMode(ReceiverRobustness robustnessMode,
-                                        VCMDecodeErrorMode errorMode) OVERRIDE {
+  int SetReceiverRobustnessMode(ReceiverRobustness robustnessMode,
+                                VCMDecodeErrorMode errorMode) override {
     return receiver_->SetReceiverRobustnessMode(robustnessMode, errorMode);
   }
 
-  virtual void SetNackSettings(size_t max_nack_list_size,
-                               int max_packet_age_to_nack,
-                               int max_incomplete_time_ms) OVERRIDE {
+  void SetNackSettings(size_t max_nack_list_size,
+                       int max_packet_age_to_nack,
+                       int max_incomplete_time_ms) override {
     return receiver_->SetNackSettings(
         max_nack_list_size, max_packet_age_to_nack, max_incomplete_time_ms);
   }
 
-  void SetDecodeErrorMode(VCMDecodeErrorMode decode_error_mode) OVERRIDE {
+  void SetDecodeErrorMode(VCMDecodeErrorMode decode_error_mode) override {
     return receiver_->SetDecodeErrorMode(decode_error_mode);
   }
 
-  virtual int SetMinReceiverDelay(int desired_delay_ms) OVERRIDE {
+  int SetMinReceiverDelay(int desired_delay_ms) override {
     return receiver_->SetMinReceiverDelay(desired_delay_ms);
   }
 
-  virtual int32_t SetReceiveChannelParameters(int64_t rtt) OVERRIDE {
+  int32_t SetReceiveChannelParameters(int64_t rtt) override {
     return receiver_->SetReceiveChannelParameters(rtt);
   }
 
-  virtual void RegisterPreDecodeImageCallback(
-      EncodedImageCallback* observer) OVERRIDE {
+  void RegisterPreDecodeImageCallback(EncodedImageCallback* observer) override {
     receiver_->RegisterPreDecodeImageCallback(observer);
   }
 
-  virtual void RegisterPostEncodeImageCallback(
-      EncodedImageCallback* observer) OVERRIDE {
+  void RegisterPostEncodeImageCallback(
+      EncodedImageCallback* observer) override {
     post_encode_callback_.Register(observer);
   }
 
diff --git a/webrtc/modules/video_coding/main/source/video_sender_unittest.cc b/webrtc/modules/video_coding/main/source/video_sender_unittest.cc
index 6666e4b..de596d8 100644
--- a/webrtc/modules/video_coding/main/source/video_sender_unittest.cc
+++ b/webrtc/modules/video_coding/main/source/video_sender_unittest.cc
@@ -70,7 +70,7 @@
 
 class EmptyFrameGenerator : public FrameGenerator {
  public:
-  virtual I420VideoFrame* NextFrame() OVERRIDE {
+  I420VideoFrame* NextFrame() override {
     frame_.reset(new I420VideoFrame());
     return frame_.get();
   }
@@ -86,10 +86,10 @@
 
   virtual ~PacketizationCallback() {}
 
-  virtual int32_t SendData(uint8_t payload_type,
-                           const EncodedImage& encoded_image,
-                           const RTPFragmentationHeader& fragmentation_header,
-                           const RTPVideoHeader* rtp_video_header) OVERRIDE {
+  int32_t SendData(uint8_t payload_type,
+                   const EncodedImage& encoded_image,
+                   const RTPFragmentationHeader& fragmentation_header,
+                   const RTPVideoHeader* rtp_video_header) override {
     assert(rtp_video_header);
     frame_data_.push_back(FrameData(encoded_image._length, *rtp_video_header));
     return 0;
@@ -171,7 +171,7 @@
   // a special case (e.g. frame rate in media optimization).
   TestVideoSender() : clock_(1000), packetization_callback_(&clock_) {}
 
-  virtual void SetUp() OVERRIDE {
+  void SetUp() override {
     sender_.reset(new VideoSender(&clock_, &post_encode_callback_, nullptr));
     EXPECT_EQ(0, sender_->InitializeSender());
     EXPECT_EQ(0, sender_->RegisterTransportCallback(&packetization_callback_));
@@ -197,7 +197,7 @@
   static const int kNumberOfLayers = 3;
   static const int kUnusedPayloadType = 10;
 
-  virtual void SetUp() OVERRIDE {
+  void SetUp() override {
     TestVideoSender::SetUp();
     generator_.reset(new EmptyFrameGenerator());
     EXPECT_EQ(
@@ -220,7 +220,7 @@
     EXPECT_EQ(0, sender_->RegisterSendCodec(&settings_, 1, 1200));
   }
 
-  virtual void TearDown() OVERRIDE { sender_.reset(); }
+  void TearDown() override { sender_.reset(); }
 
   void ExpectIntraRequest(int stream) {
     if (stream == -1) {
@@ -313,7 +313,7 @@
   TestVideoSenderWithVp8()
       : codec_bitrate_kbps_(300), available_bitrate_kbps_(1000) {}
 
-  virtual void SetUp() OVERRIDE {
+  void SetUp() override {
     TestVideoSender::SetUp();
 
     const char* input_video = "foreman_cif";
diff --git a/webrtc/modules/video_coding/main/test/generic_codec_test.h b/webrtc/modules/video_coding/main/test/generic_codec_test.h
index 3b3ddce..9b041ce 100644
--- a/webrtc/modules/video_coding/main/test/generic_codec_test.h
+++ b/webrtc/modules/video_coding/main/test/generic_codec_test.h
@@ -75,10 +75,8 @@
 public:
     // constructor input: (receive side) rtp module to send encoded data to
     RTPSendCallback_SizeTest() : _maxPayloadSize(0), _payloadSizeSum(0), _nPackets(0) {}
-    virtual int SendPacket(int channel, const void *data, size_t len) OVERRIDE;
-    virtual int SendRTCPPacket(int channel,
-                               const void *data,
-                               size_t len) OVERRIDE {
+    int SendPacket(int channel, const void* data, size_t len) override;
+    int SendRTCPPacket(int channel, const void* data, size_t len) override {
       return 0;
     }
     void SetMaxPayloadSize(size_t maxPayloadSize);
@@ -94,11 +92,10 @@
 {
 public:
     VCMEncComplete_KeyReqTest(webrtc::VideoCodingModule &vcm) : _vcm(vcm), _seqNo(0), _timeStamp(0) {}
-    virtual int32_t SendData(
-        uint8_t payloadType,
-        const webrtc::EncodedImage& encoded_image,
-        const webrtc::RTPFragmentationHeader& fragmentationHeader,
-        const webrtc::RTPVideoHeader* videoHdr) OVERRIDE;
+    int32_t SendData(uint8_t payloadType,
+                     const webrtc::EncodedImage& encoded_image,
+                     const webrtc::RTPFragmentationHeader& fragmentationHeader,
+                     const webrtc::RTPVideoHeader* videoHdr) override;
 
 private:
     webrtc::VideoCodingModule& _vcm;
diff --git a/webrtc/modules/video_coding/main/test/mt_test_common.h b/webrtc/modules/video_coding/main/test/mt_test_common.h
index 78d73e2..c76736e 100644
--- a/webrtc/modules/video_coding/main/test/mt_test_common.h
+++ b/webrtc/modules/video_coding/main/test/mt_test_common.h
@@ -52,7 +52,7 @@
     // Add packets to list
     // Incorporate network conditions - delay and packet loss
     // Actual transmission will occur on a separate thread
-    virtual int SendPacket(int channel, const void *data, size_t len) OVERRIDE;
+    int SendPacket(int channel, const void* data, size_t len) override;
     // Send to the receiver packets which are ready to be submitted
     int TransportPackets();
 };
diff --git a/webrtc/modules/video_coding/main/test/normal_test.h b/webrtc/modules/video_coding/main/test/normal_test.h
index b2fb387..0015171 100644
--- a/webrtc/modules/video_coding/main/test/normal_test.h
+++ b/webrtc/modules/video_coding/main/test/normal_test.h
@@ -32,11 +32,10 @@
   void RegisterTransportCallback(webrtc::VCMPacketizationCallback* transport);
   // process encoded data received from the encoder,
   // pass stream to the VCMReceiver module
-  virtual int32_t SendData(
-      uint8_t payloadType,
-      const webrtc::EncodedImage& encoded_image,
-      const webrtc::RTPFragmentationHeader& fragmentationHeader,
-      const webrtc::RTPVideoHeader* videoHdr) OVERRIDE;
+  int32_t SendData(uint8_t payloadType,
+                   const webrtc::EncodedImage& encoded_image,
+                   const webrtc::RTPFragmentationHeader& fragmentationHeader,
+                   const webrtc::RTPVideoHeader* videoHdr) override;
 
   // Register existing VCM.
   // Currently - encode and decode with the same vcm module.
@@ -69,7 +68,7 @@
     void SetUserReceiveCallback(webrtc::VCMReceiveCallback* receiveCallback);
 
     // will write decoded frame into file
-    virtual int32_t FrameToRender(webrtc::I420VideoFrame& videoFrame) OVERRIDE;
+    int32_t FrameToRender(webrtc::I420VideoFrame& videoFrame) override;
 
     size_t DecodedBytes();
 private:
diff --git a/webrtc/modules/video_coding/main/test/receiver_tests.h b/webrtc/modules/video_coding/main/test/receiver_tests.h
index de1eb63..eb0a35a 100644
--- a/webrtc/modules/video_coding/main/test/receiver_tests.h
+++ b/webrtc/modules/video_coding/main/test/receiver_tests.h
@@ -27,10 +27,10 @@
   RtpDataCallback(webrtc::VideoCodingModule* vcm) : vcm_(vcm) {}
   virtual ~RtpDataCallback() {}
 
-  virtual int32_t OnReceivedPayloadData(
+  int32_t OnReceivedPayloadData(
       const uint8_t* payload_data,
       const size_t payload_size,
-      const webrtc::WebRtcRTPHeader* rtp_header) OVERRIDE {
+      const webrtc::WebRtcRTPHeader* rtp_header) override {
     return vcm_->IncomingPacket(payload_data, payload_size, *rtp_header);
   }
 
diff --git a/webrtc/modules/video_coding/main/test/test_callbacks.h b/webrtc/modules/video_coding/main/test/test_callbacks.h
index 3fe991a..3d3c543 100644
--- a/webrtc/modules/video_coding/main/test/test_callbacks.h
+++ b/webrtc/modules/video_coding/main/test/test_callbacks.h
@@ -44,10 +44,10 @@
     void RegisterTransportCallback(VCMPacketizationCallback* transport);
     // Process encoded data received from the encoder, pass stream to the
     // VCMReceiver module
-    virtual int32_t SendData(uint8_t payloadType,
-                             const EncodedImage& encoded_image,
-                             const RTPFragmentationHeader& fragmentationHeader,
-                             const RTPVideoHeader* videoHdr) OVERRIDE;
+    int32_t SendData(uint8_t payloadType,
+                     const EncodedImage& encoded_image,
+                     const RTPFragmentationHeader& fragmentationHeader,
+                     const RTPVideoHeader* videoHdr) override;
     // Register exisitng VCM. Currently - encode and decode under same module.
     void RegisterReceiverVCM(VideoCodingModule *vcm) {_VCMReceiver = vcm;}
     // Return size of last encoded frame data (all frames in the sequence)
@@ -97,10 +97,10 @@
     virtual ~VCMRTPEncodeCompleteCallback() {}
     // Process encoded data received from the encoder, pass stream to the
     // RTP module
-    virtual int32_t SendData(uint8_t payloadType,
-                             const EncodedImage& encoded_image,
-                             const RTPFragmentationHeader& fragmentationHeader,
-                             const RTPVideoHeader* videoHdr) OVERRIDE;
+    int32_t SendData(uint8_t payloadType,
+                     const EncodedImage& encoded_image,
+                     const RTPFragmentationHeader& fragmentationHeader,
+                     const RTPVideoHeader* videoHdr) override;
     // Return size of last encoded frame. Value good for one call
     // (resets to zero after call to inform test of frame drop)
     size_t EncodedBytes();
@@ -136,7 +136,7 @@
         _decodedFile(decodedFile), _decodedBytes(0) {}
     virtual ~VCMDecodeCompleteCallback() {}
     // Write decoded frame into file
-    virtual int32_t FrameToRender(webrtc::I420VideoFrame& videoFrame) OVERRIDE;
+    int32_t FrameToRender(webrtc::I420VideoFrame& videoFrame) override;
     size_t DecodedBytes();
 private:
     FILE*       _decodedFile;
@@ -157,11 +157,9 @@
 
     void SetRtpModule(RtpRtcp* rtp_module) { _rtp = rtp_module; }
     // Send Packet to receive side RTP module
-    virtual int SendPacket(int channel, const void *data, size_t len) OVERRIDE;
+    int SendPacket(int channel, const void* data, size_t len) override;
     // Send RTCP Packet to receive side RTP module
-    virtual int SendRTCPPacket(int channel,
-                               const void *data,
-                               size_t len) OVERRIDE;
+    int SendRTCPPacket(int channel, const void* data, size_t len) override;
     // Set percentage of channel loss in the network
     void SetLossPct(double lossPct);
     // Set average size of burst loss
@@ -203,8 +201,9 @@
 public:
     PacketRequester(RtpRtcp& rtp) :
         _rtp(rtp) {}
-    virtual int32_t ResendPackets(const uint16_t* sequenceNumbers,
-                                  uint16_t length) OVERRIDE;
+    int32_t ResendPackets(const uint16_t* sequenceNumbers,
+                          uint16_t length) override;
+
 private:
     webrtc::RtpRtcp& _rtp;
 };
@@ -213,7 +212,7 @@
 class KeyFrameReqTest: public VCMFrameTypeCallback
 {
 public:
-    virtual int32_t RequestKeyFrame() OVERRIDE;
+ int32_t RequestKeyFrame() override;
 };
 
 
@@ -222,8 +221,8 @@
 {
 public:
     SendStatsTest() : _framerate(15), _bitrate(500) {}
-    virtual int32_t SendStatistics(const uint32_t bitRate,
-                                   const uint32_t frameRate) OVERRIDE;
+    int32_t SendStatistics(const uint32_t bitRate,
+                           const uint32_t frameRate) override;
     void set_framerate(uint32_t frameRate) {_framerate = frameRate;}
     void set_bitrate(uint32_t bitrate) {_bitrate = bitrate;}
 private:
@@ -239,12 +238,11 @@
     VideoProtectionCallback();
     virtual ~VideoProtectionCallback();
     void RegisterRtpModule(RtpRtcp* rtp) {_rtp = rtp;}
-    virtual int32_t ProtectionRequest(
-        const FecProtectionParams* delta_fec_params,
-        const FecProtectionParams* key_fec_params,
-        uint32_t* sent_video_rate_bps,
-        uint32_t* sent_nack_rate_bps,
-        uint32_t* sent_fec_rate_bps) OVERRIDE;
+    int32_t ProtectionRequest(const FecProtectionParams* delta_fec_params,
+                              const FecProtectionParams* key_fec_params,
+                              uint32_t* sent_video_rate_bps,
+                              uint32_t* sent_nack_rate_bps,
+                              uint32_t* sent_fec_rate_bps) override;
     FecProtectionParams DeltaFecParameters() const;
     FecProtectionParams KeyFecParameters() const;
 private:
diff --git a/webrtc/modules/video_coding/main/test/vcm_payload_sink_factory.cc b/webrtc/modules/video_coding/main/test/vcm_payload_sink_factory.cc
index 3f2d609..e8dbe8d 100644
--- a/webrtc/modules/video_coding/main/test/vcm_payload_sink_factory.cc
+++ b/webrtc/modules/video_coding/main/test/vcm_payload_sink_factory.cc
@@ -48,22 +48,20 @@
   }
 
   // PayloadSinkInterface
-  virtual int32_t OnReceivedPayloadData(
-      const uint8_t* payload_data,
-      const size_t payload_size,
-      const WebRtcRTPHeader* rtp_header) OVERRIDE {
+  int32_t OnReceivedPayloadData(const uint8_t* payload_data,
+                                const size_t payload_size,
+                                const WebRtcRTPHeader* rtp_header) override {
     return vcm_->IncomingPacket(payload_data, payload_size, *rtp_header);
   }
 
-  virtual bool OnRecoveredPacket(const uint8_t* packet,
-                                 size_t packet_length) OVERRIDE {
+  bool OnRecoveredPacket(const uint8_t* packet, size_t packet_length) override {
     // We currently don't handle FEC.
     return true;
   }
 
   // VCMPacketRequestCallback
-  virtual int32_t ResendPackets(const uint16_t* sequence_numbers,
-                                uint16_t length) OVERRIDE {
+  int32_t ResendPackets(const uint16_t* sequence_numbers,
+                        uint16_t length) override {
     stream_->ResendPackets(sequence_numbers, length);
     return 0;
   }
diff --git a/webrtc/modules/video_processing/main/interface/video_processing.h b/webrtc/modules/video_processing/main/interface/video_processing.h
index a4425af..fb6770b 100644
--- a/webrtc/modules/video_processing/main/interface/video_processing.h
+++ b/webrtc/modules/video_processing/main/interface/video_processing.h
@@ -89,12 +89,12 @@
   /**
      Not supported.
   */
-  virtual int64_t TimeUntilNextProcess() OVERRIDE { return -1; }
+  int64_t TimeUntilNextProcess() override { return -1; }
 
   /**
      Not supported.
   */
-  virtual int32_t Process() OVERRIDE { return -1; }
+  int32_t Process() override { return -1; }
 
   /**
      Resets all processing components to their initial states. This should be
diff --git a/webrtc/modules/video_processing/main/source/video_processing_impl.h b/webrtc/modules/video_processing/main/source/video_processing_impl.h
index 69dcec4..14a9e54 100644
--- a/webrtc/modules/video_processing/main/source/video_processing_impl.h
+++ b/webrtc/modules/video_processing/main/source/video_processing_impl.h
@@ -27,43 +27,40 @@
 
   virtual ~VideoProcessingModuleImpl();
 
-  virtual void Reset() OVERRIDE;
+  void Reset() override;
 
-  virtual int32_t Deflickering(I420VideoFrame* frame,
-                               FrameStats* stats) OVERRIDE;
+  int32_t Deflickering(I420VideoFrame* frame, FrameStats* stats) override;
 
-  virtual int32_t BrightnessDetection(const I420VideoFrame& frame,
-                                      const FrameStats& stats) OVERRIDE;
+  int32_t BrightnessDetection(const I420VideoFrame& frame,
+                              const FrameStats& stats) override;
 
   // Frame pre-processor functions
 
   // Enable temporal decimation
-  virtual void EnableTemporalDecimation(bool enable) OVERRIDE;
+  void EnableTemporalDecimation(bool enable) override;
 
-  virtual void SetInputFrameResampleMode(
-      VideoFrameResampling resampling_mode) OVERRIDE;
+  void SetInputFrameResampleMode(VideoFrameResampling resampling_mode) override;
 
   // Enable content analysis
-  virtual void EnableContentAnalysis(bool enable) OVERRIDE;
+  void EnableContentAnalysis(bool enable) override;
 
   // Set Target Resolution: frame rate and dimension
-  virtual int32_t SetTargetResolution(uint32_t width,
-                                      uint32_t height,
-                                      uint32_t frame_rate) OVERRIDE;
-
+  int32_t SetTargetResolution(uint32_t width,
+                              uint32_t height,
+                              uint32_t frame_rate) override;
 
   // Get decimated values: frame rate/dimension
-  virtual uint32_t Decimatedframe_rate() OVERRIDE;
-  virtual uint32_t DecimatedWidth() const OVERRIDE;
-  virtual uint32_t DecimatedHeight() const OVERRIDE;
+  uint32_t Decimatedframe_rate() override;
+  uint32_t DecimatedWidth() const override;
+  uint32_t DecimatedHeight() const override;
 
   // Preprocess:
   // Pre-process incoming frame: Sample when needed and compute content
   // metrics when enabled.
   // If no resampling takes place - processed_frame is set to NULL.
-  virtual int32_t PreprocessFrame(const I420VideoFrame& frame,
-                                  I420VideoFrame** processed_frame) OVERRIDE;
-  virtual VideoContentMetrics* ContentMetrics() const OVERRIDE;
+  int32_t PreprocessFrame(const I420VideoFrame& frame,
+                          I420VideoFrame** processed_frame) override;
+  VideoContentMetrics* ContentMetrics() const override;
 
  private:
   CriticalSectionWrapper& mutex_;
diff --git a/webrtc/modules/video_render/include/video_render.h b/webrtc/modules/video_render/include/video_render.h
index 600615f..15dfd92 100644
--- a/webrtc/modules/video_render/include/video_render.h
+++ b/webrtc/modules/video_render/include/video_render.h
@@ -52,8 +52,8 @@
      */
     static void DestroyVideoRender(VideoRender* module);
 
-    virtual int64_t TimeUntilNextProcess() OVERRIDE = 0;
-    virtual int32_t Process() OVERRIDE = 0;
+    int64_t TimeUntilNextProcess() override = 0;
+    int32_t Process() override = 0;
 
     /**************************************************************************
      *
diff --git a/webrtc/modules/video_render/ios/video_render_ios_channel.h b/webrtc/modules/video_render/ios/video_render_ios_channel.h
index 53020b6..2d635a7 100644
--- a/webrtc/modules/video_render/ios/video_render_ios_channel.h
+++ b/webrtc/modules/video_render/ios/video_render_ios_channel.h
@@ -24,8 +24,8 @@
   virtual ~VideoRenderIosChannel();
 
   // Implementation of VideoRenderCallback.
-  virtual int32_t RenderFrame(const uint32_t stream_id,
-                              I420VideoFrame& video_frame) OVERRIDE;
+  int32_t RenderFrame(const uint32_t stream_id,
+                      I420VideoFrame& video_frame) override;
 
   int SetStreamSettings(const float z_order,
                         const float left,
diff --git a/webrtc/modules/video_render/ios/video_render_ios_impl.h b/webrtc/modules/video_render/ios/video_render_ios_impl.h
index 7e3029c..7fb46bf 100644
--- a/webrtc/modules/video_render/ios/video_render_ios_impl.h
+++ b/webrtc/modules/video_render/ios/video_render_ios_impl.h
@@ -30,50 +30,50 @@
   ~VideoRenderIosImpl();
 
   // Implementation of IVideoRender.
-  int32_t Init() OVERRIDE;
-  int32_t ChangeWindow(void* window) OVERRIDE;
+  int32_t Init() override;
+  int32_t ChangeWindow(void* window) override;
 
   VideoRenderCallback* AddIncomingRenderStream(const uint32_t stream_id,
                                                const uint32_t z_order,
                                                const float left,
                                                const float top,
                                                const float right,
-                                               const float bottom) OVERRIDE;
+                                               const float bottom) override;
 
-  int32_t DeleteIncomingRenderStream(const uint32_t stream_id) OVERRIDE;
+  int32_t DeleteIncomingRenderStream(const uint32_t stream_id) override;
 
   int32_t GetIncomingRenderStreamProperties(const uint32_t stream_id,
                                             uint32_t& z_order,
                                             float& left,
                                             float& top,
                                             float& right,
-                                            float& bottom) const OVERRIDE;
+                                            float& bottom) const override;
 
-  int32_t StartRender() OVERRIDE;
-  int32_t StopRender() OVERRIDE;
+  int32_t StartRender() override;
+  int32_t StopRender() override;
 
-  VideoRenderType RenderType() OVERRIDE;
-  RawVideoType PerferedVideoType() OVERRIDE;
-  bool FullScreen() OVERRIDE;
+  VideoRenderType RenderType() override;
+  RawVideoType PerferedVideoType() override;
+  bool FullScreen() override;
   int32_t GetGraphicsMemory(
       uint64_t& total_graphics_memory,
-      uint64_t& available_graphics_memory) const OVERRIDE;  // NOLINT
+      uint64_t& available_graphics_memory) const override;  // NOLINT
   int32_t GetScreenResolution(
       uint32_t& screen_width,
-      uint32_t& screen_height) const OVERRIDE;  // NOLINT
+      uint32_t& screen_height) const override;  // NOLINT
   uint32_t RenderFrameRate(const uint32_t stream_id);
   int32_t SetStreamCropping(const uint32_t stream_id,
                             const float left,
                             const float top,
                             const float right,
-                            const float bottom) OVERRIDE;
+                            const float bottom) override;
   int32_t ConfigureRenderer(const uint32_t stream_id,
                             const unsigned int z_order,
                             const float left,
                             const float top,
                             const float right,
-                            const float bottom) OVERRIDE;
-  int32_t SetTransparentBackground(const bool enable) OVERRIDE;
+                            const float bottom) override;
+  int32_t SetTransparentBackground(const bool enable) override;
   int32_t SetText(const uint8_t text_id,
                   const uint8_t* text,
                   const int32_t text_length,
@@ -82,7 +82,7 @@
                   const float left,
                   const float top,
                   const float right,
-                  const float bottom) OVERRIDE;
+                  const float bottom) override;
   int32_t SetBitmap(const void* bit_map,
                     const uint8_t picture_id,
                     const void* color_key,