Standardize usage of virtual/override/final in media/

media/cast/sender/external_video_encoder.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "media/cast/sender/external_video_encoder.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/memory/scoped_vector.h"
 #include "base/memory/shared_memory.h"
@@ skipping 155 matching lines @@
     in_progress_frame_encodes_.push_back(InProgressFrameEncode(
         TimeDeltaToRtpDelta(video_frame->timestamp(), kVideoFrequency),
         reference_time,
         frame_encoded_callback));
 
     // BitstreamBufferReady will be called once the encoder is done.
     video_encode_accelerator_->Encode(video_frame, key_frame_requested);
   }
 
  protected:
-  virtual void NotifyError(VideoEncodeAccelerator::Error error) override {
+  void NotifyError(VideoEncodeAccelerator::Error error) override {
     DCHECK(encoder_task_runner_.get());
     DCHECK(encoder_task_runner_->RunsTasksOnCurrentThread());
     VLOG(1) << "ExternalVideoEncoder NotifyError: " << error;
 
     cast_environment_->PostTask(
         CastEnvironment::MAIN,
         FROM_HERE,
         base::Bind(&ExternalVideoEncoder::EncoderError, weak_owner_));
   }
 
   // Called to allocate the input and output buffers.
-  virtual void RequireBitstreamBuffers(unsigned int input_count,
-                                       const gfx::Size& input_coded_size,
-                                       size_t output_buffer_size) override {
+  void RequireBitstreamBuffers(unsigned int input_count,
+                               const gfx::Size& input_coded_size,
+                               size_t output_buffer_size) override {
     DCHECK(encoder_task_runner_.get());
     DCHECK(encoder_task_runner_->RunsTasksOnCurrentThread());
     DCHECK(video_encode_accelerator_);
 
     for (size_t j = 0; j < kOutputBufferCount; ++j) {
       create_video_encode_memory_cb_.Run(
           output_buffer_size,
           base::Bind(&LocalVideoEncodeAcceleratorClient::OnCreateSharedMemory,
                      this));
     }
   }
 
   // Encoder has encoded a frame and it's available in one of out output
   // buffers.
-  virtual void BitstreamBufferReady(int32 bitstream_buffer_id,
-                                    size_t payload_size,
-                                    bool key_frame) override {
+  void BitstreamBufferReady(int32 bitstream_buffer_id,
+                            size_t payload_size,
+                            bool key_frame) override {
     DCHECK(encoder_task_runner_.get());
     DCHECK(encoder_task_runner_->RunsTasksOnCurrentThread());
     if (bitstream_buffer_id < 0 ||
         bitstream_buffer_id >= static_cast<int32>(output_buffers_.size())) {
       NOTREACHED();
       VLOG(1) << "BitstreamBufferReady(): invalid bitstream_buffer_id="
               << bitstream_buffer_id;
       NotifyError(media::VideoEncodeAccelerator::kPlatformFailureError);
       return;
     }
@@ skipping 136 matching lines @@
                    true));
   }
 
   static void DestroyVideoEncodeAcceleratorOnEncoderThread(
       scoped_ptr<media::VideoEncodeAccelerator> vea) {
     // VEA::~VEA specialization takes care of calling Destroy() on the VEA impl.
   }
 
   friend class base::RefCountedThreadSafe<LocalVideoEncodeAcceleratorClient>;
 
-  virtual ~LocalVideoEncodeAcceleratorClient() {
+  ~LocalVideoEncodeAcceleratorClient() override {
     Destroy();
     DCHECK(!video_encode_accelerator_);
   }
 
   const scoped_refptr<CastEnvironment> cast_environment_;
   scoped_refptr<base::SingleThreadTaskRunner> encoder_task_runner_;
   scoped_ptr<media::VideoEncodeAccelerator> video_encode_accelerator_;
   const CreateVideoEncodeMemoryCallback create_video_encode_memory_cb_;
   const base::WeakPtr<ExternalVideoEncoder> weak_owner_;
   int max_frame_rate_;
@@ skipping 106 matching lines @@
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   key_frame_requested_ = true;
 }
 
 // Inform the encoder to only reference frames older or equal to frame_id;
 void ExternalVideoEncoder::LatestFrameIdToReference(uint32 /*frame_id*/) {
   // Do nothing not supported.
 }
 }  //  namespace cast
 }  //  namespace media