Standardize usage of virtual/override/final specifiers.

content/renderer/media/webrtc/webrtc_video_capturer_adapter.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 "content/renderer/media/webrtc/webrtc_video_capturer_adapter.h"
 
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
 #include "base/memory/aligned_memory.h"
 #include "media/base/video_frame.h"
@@ skipping 20 matching lines @@
  public:
   VideoFrameWrapper(const scoped_refptr<media::VideoFrame>& frame,
                     int64 elapsed_time)
       : frame_(media::VideoFrame::WrapVideoFrame(
             frame,
             frame->visible_rect(),
             frame->natural_size(),
             base::Bind(&ReleaseOriginalFrame, frame))),
         elapsed_time_(elapsed_time) {}
 
-  virtual VideoFrame* Copy() const override {
+  VideoFrame* Copy() const override {
     DCHECK(thread_checker_.CalledOnValidThread());
     return new VideoFrameWrapper(frame_, elapsed_time_);
   }
 
-  virtual size_t GetWidth() const override {
+  size_t GetWidth() const override {
     DCHECK(thread_checker_.CalledOnValidThread());
     return static_cast<size_t>(frame_->visible_rect().width());
   }
 
-  virtual size_t GetHeight() const override {
+  size_t GetHeight() const override {
     DCHECK(thread_checker_.CalledOnValidThread());
     return static_cast<size_t>(frame_->visible_rect().height());
   }
 
-  virtual const uint8* GetYPlane() const override {
+  const uint8* GetYPlane() const override {
     DCHECK(thread_checker_.CalledOnValidThread());
     return frame_->visible_data(media::VideoFrame::kYPlane);
   }
 
-  virtual const uint8* GetUPlane() const override {
+  const uint8* GetUPlane() const override {
     DCHECK(thread_checker_.CalledOnValidThread());
     return frame_->visible_data(media::VideoFrame::kUPlane);
   }
 
-  virtual const uint8* GetVPlane() const override {
+  const uint8* GetVPlane() const override {
     DCHECK(thread_checker_.CalledOnValidThread());
     return frame_->visible_data(media::VideoFrame::kVPlane);
   }
 
-  virtual uint8* GetYPlane() override {
+  uint8* GetYPlane() override {
     DCHECK(thread_checker_.CalledOnValidThread());
     return frame_->visible_data(media::VideoFrame::kYPlane);
   }
 
-  virtual uint8* GetUPlane() override {
+  uint8* GetUPlane() override {
     DCHECK(thread_checker_.CalledOnValidThread());
     return frame_->visible_data(media::VideoFrame::kUPlane);
   }
 
-  virtual uint8* GetVPlane() override {
+  uint8* GetVPlane() override {
     DCHECK(thread_checker_.CalledOnValidThread());
     return frame_->visible_data(media::VideoFrame::kVPlane);
   }
 
-  virtual int32 GetYPitch() const override {
+  int32 GetYPitch() const override {
     DCHECK(thread_checker_.CalledOnValidThread());
     return frame_->stride(media::VideoFrame::kYPlane);
   }
 
-  virtual int32 GetUPitch() const override {
+  int32 GetUPitch() const override {
     DCHECK(thread_checker_.CalledOnValidThread());
     return frame_->stride(media::VideoFrame::kUPlane);
   }
 
-  virtual int32 GetVPitch() const override {
+  int32 GetVPitch() const override {
     DCHECK(thread_checker_.CalledOnValidThread());
     return frame_->stride(media::VideoFrame::kVPlane);
   }
 
-  virtual void* GetNativeHandle() const override {
+  void* GetNativeHandle() const override {
     DCHECK(thread_checker_.CalledOnValidThread());
     return NULL;
   }
 
-  virtual size_t GetPixelWidth() const override {
+  size_t GetPixelWidth() const override {
     DCHECK(thread_checker_.CalledOnValidThread());
     return 1;
   }
-  virtual size_t GetPixelHeight() const override {
+  size_t GetPixelHeight() const override {
     DCHECK(thread_checker_.CalledOnValidThread());
     return 1;
   }
 
-  virtual int64 GetElapsedTime() const override {
+  int64 GetElapsedTime() const override {
     DCHECK(thread_checker_.CalledOnValidThread());
     return elapsed_time_;
   }
 
-  virtual int64 GetTimeStamp() const override {
+  int64 GetTimeStamp() const override {
     DCHECK(thread_checker_.CalledOnValidThread());
     return frame_->timestamp().InMicroseconds() *
            base::Time::kNanosecondsPerMicrosecond;
   }
 
-  virtual void SetElapsedTime(int64 elapsed_time) override {
+  void SetElapsedTime(int64 elapsed_time) override {
     DCHECK(thread_checker_.CalledOnValidThread());
     elapsed_time_ = elapsed_time;
   }
 
-  virtual void SetTimeStamp(int64 time_stamp) override {
+  void SetTimeStamp(int64 time_stamp) override {
     DCHECK(thread_checker_.CalledOnValidThread());
     // Round to closest microsecond.
     frame_->set_timestamp(base::TimeDelta::FromMicroseconds(
         (time_stamp + base::Time::kNanosecondsPerMicrosecond / 2) /
         base::Time::kNanosecondsPerMicrosecond));
   }
 
-  virtual int GetRotation() const override {
+  int GetRotation() const override {
     DCHECK(thread_checker_.CalledOnValidThread());
     return 0;
   }
 
   // TODO(magjed): Refactor into base class.
-  virtual size_t ConvertToRgbBuffer(uint32 to_fourcc,
-                                    uint8* buffer,
-                                    size_t size,
-                                    int stride_rgb) const override {
+  size_t ConvertToRgbBuffer(uint32 to_fourcc,
+                            uint8* buffer,
+                            size_t size,
+                            int stride_rgb) const override {
     DCHECK(thread_checker_.CalledOnValidThread());
     const size_t needed = std::abs(stride_rgb) * GetHeight();
     if (size < needed) {
       DLOG(WARNING) << "RGB buffer is not large enough";
       return needed;
     }
 
     if (libyuv::ConvertFromI420(GetYPlane(),
                                 GetYPitch(),
                                 GetUPlane(),
                                 GetUPitch(),
                                 GetVPlane(),
                                 GetVPitch(),
                                 buffer,
                                 stride_rgb,
                                 static_cast<int>(GetWidth()),
                                 static_cast<int>(GetHeight()),
                                 to_fourcc)) {
       DLOG(ERROR) << "RGB type not supported: " << to_fourcc;
       return 0;  // 0 indicates error
     }
     return needed;
   }
 
   // The rest of the public methods are NOTIMPLEMENTED.
-  virtual bool InitToBlack(int w,
-                           int h,
-                           size_t pixel_width,
-                           size_t pixel_height,
-                           int64 elapsed_time,
-                           int64 time_stamp) override {
+  bool InitToBlack(int w,
+                   int h,
+                   size_t pixel_width,
+                   size_t pixel_height,
+                   int64 elapsed_time,
+                   int64 time_stamp) override {
     NOTIMPLEMENTED();
     return false;
   }
 
-  virtual bool Reset(uint32 fourcc,
-                     int w,
-                     int h,
-                     int dw,
-                     int dh,
-                     uint8* sample,
-                     size_t sample_size,
-                     size_t pixel_width,
-                     size_t pixel_height,
-                     int64 elapsed_time,
-                     int64 time_stamp,
-                     int rotation) override {
+  bool Reset(uint32 fourcc,
+             int w,
+             int h,
+             int dw,
+             int dh,
+             uint8* sample,
+             size_t sample_size,
+             size_t pixel_width,
+             size_t pixel_height,
+             int64 elapsed_time,
+             int64 time_stamp,
+             int rotation) override {
     NOTIMPLEMENTED();
     return false;
   }
 
-  virtual bool MakeExclusive() override {
+  bool MakeExclusive() override {
     NOTIMPLEMENTED();
     return false;
   }
 
-  virtual size_t CopyToBuffer(uint8* buffer, size_t size) const override {
+  size_t CopyToBuffer(uint8* buffer, size_t size) const override {
     NOTIMPLEMENTED();
     return 0;
   }
 
  protected:
   // TODO(magjed): Refactor as a static method in WebRtcVideoFrame.
-  virtual VideoFrame* CreateEmptyFrame(int w,
-                                       int h,
-                                       size_t pixel_width,
-                                       size_t pixel_height,
-                                       int64 elapsed_time,
-                                       int64 time_stamp) const override {
+  VideoFrame* CreateEmptyFrame(int w,
+                               int h,
+                               size_t pixel_width,
+                               size_t pixel_height,
+                               int64 elapsed_time,
+                               int64 time_stamp) const override {
     DCHECK(thread_checker_.CalledOnValidThread());
     VideoFrame* frame = new cricket::WebRtcVideoFrame();
     frame->InitToBlack(
         w, h, pixel_width, pixel_height, elapsed_time, time_stamp);
     return frame;
   }
 
  private:
   scoped_refptr<media::VideoFrame> frame_;
   int64 elapsed_time_;
@@ skipping 29 matching lines @@
 
     frame_ = frame;
   }
 
   void ReleaseFrame() { frame_ = NULL; }
 
   const cricket::CapturedFrame* GetCapturedFrame() const {
     return &captured_frame_;
   }
 
-  virtual cricket::VideoFrame* CreateAliasedFrame(
+  cricket::VideoFrame* CreateAliasedFrame(
       const cricket::CapturedFrame* captured_frame,
       int dst_width,
       int dst_height) const override {
     // Check that captured_frame is actually our frame.
     DCHECK(captured_frame == &captured_frame_);
     DCHECK(frame_.get());
 
     scoped_refptr<media::VideoFrame> video_frame = frame_;
     // Check if scaling is needed.
     if (dst_width != frame_->visible_rect().width() ||
@@ skipping 129 matching lines @@
   DCHECK(frame_factory_ == frame_factory());
   frame_factory_->SetFrame(frame, elapsed_time);
 
   // This signals to libJingle that a new VideoFrame is available.
   SignalFrameCaptured(this, frame_factory_->GetCapturedFrame());
 
   frame_factory_->ReleaseFrame();  // Release the frame ASAP.
 }
 
 }  // namespace content