Enable -Winconsistent-missing-override flag.

webrtc/modules/video_coding/codecs/vp8/realtime_temporal_layers.cc

 /* Copyright (c) 2013 The WebRTC project authors. All Rights Reserved.
 *
 *  Use of this source code is governed by a BSD-style license
 *  that can be found in the LICENSE file in the root of the source
 *  tree. An additional intellectual property rights grant can be found
 *  in the file PATENTS.  All contributing project authors may
 *  be found in the AUTHORS file in the root of the source tree.
 */
 
 #include <stdlib.h>
@@ skipping 83 matching lines @@
         layer_ids_length_(0),
         layer_ids_(NULL),
         encode_flags_length_(0),
         encode_flags_(NULL) {
     assert(max_temporal_layers_ >= 1);
     assert(max_temporal_layers_ <= 3);
   }
 
   virtual ~RealTimeTemporalLayers() {}
 
-  virtual bool ConfigureBitrates(int bitrate_kbit,
-                                 int max_bitrate_kbit,
-                                 int framerate,
-                                 vpx_codec_enc_cfg_t* cfg) {
+  bool ConfigureBitrates(int bitrate_kbit,
+                         int max_bitrate_kbit,
+                         int framerate,
+                         vpx_codec_enc_cfg_t* cfg) override {
     temporal_layers_ =
         CalculateNumberOfTemporalLayers(temporal_layers_, framerate);
     temporal_layers_ = std::min(temporal_layers_, max_temporal_layers_);
     assert(temporal_layers_ >= 1 && temporal_layers_ <= 3);
 
     cfg->ts_number_layers = temporal_layers_;
     for (int tl = 0; tl < temporal_layers_; ++tl) {
       cfg->ts_target_bitrate[tl] =
           bitrate_kbit * kVp8LayerRateAlloction[temporal_layers_ - 1][tl];
     }
@@ skipping 59 matching lines @@
 
       default:
         assert(false);
         return false;
     }
     memcpy(cfg->ts_layer_id, layer_ids_,
            sizeof(unsigned int) * layer_ids_length_);
     return true;
   }
 
-  virtual int EncodeFlags(uint32_t timestamp) {
+  int EncodeFlags(uint32_t timestamp) override {
     frame_counter_++;
     return CurrentEncodeFlags();
   }
 
   int CurrentEncodeFlags() const {
     assert(encode_flags_length_ > 0 && encode_flags_ != NULL);
     int index = frame_counter_ % encode_flags_length_;
     assert(index >= 0 && index < encode_flags_length_);
     return encode_flags_[index];
   }
 
-  virtual int CurrentLayerId() const {
+  int CurrentLayerId() const override {
     assert(layer_ids_length_ > 0 && layer_ids_ != NULL);
     int index = frame_counter_ % layer_ids_length_;
     assert(index >= 0 && index < layer_ids_length_);
     return layer_ids_[index];
   }
 
-  virtual void PopulateCodecSpecific(bool base_layer_sync,
-                                     CodecSpecificInfoVP8* vp8_info,
-                                     uint32_t timestamp) {
+  void PopulateCodecSpecific(bool base_layer_sync,
+                             CodecSpecificInfoVP8* vp8_info,
+                             uint32_t timestamp) override {
     assert(temporal_layers_ > 0);
 
     if (temporal_layers_ == 1) {
       vp8_info->temporalIdx = kNoTemporalIdx;
       vp8_info->layerSync = false;
       vp8_info->tl0PicIdx = kNoTl0PicIdx;
     } else {
       if (base_layer_sync) {
         vp8_info->temporalIdx = 0;
         vp8_info->layerSync = true;
@@ skipping 49 matching lines @@
   const int* encode_flags_;
 };
 }  // namespace
 
 TemporalLayers* RealTimeTemporalLayersFactory::Create(
     int max_temporal_layers,
     uint8_t initial_tl0_pic_idx) const {
   return new RealTimeTemporalLayers(max_temporal_layers, initial_tl0_pic_idx);
 }
 }  // namespace webrtc