Standardize usage of virtual/override/final in content/browser/

content/browser/media/capture/web_contents_video_capture_device_unittest.cc

 // Copyright (c) 2012 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/browser/media/capture/web_contents_video_capture_device.h"
 
 #include "base/bind_helpers.h"
 #include "base/debug/debugger.h"
 #include "base/run_loop.h"
 #include "base/test/test_timeouts.h"
@@ skipping 145 matching lines @@
 // CopyFromCompositingSurfaceToVideoFrame(), and which allows the video-frame
 // readback path to be switched on and off. The behavior is controlled by a
 // CaptureTestSourceController.
 class CaptureTestView : public TestRenderWidgetHostView {
  public:
   explicit CaptureTestView(RenderWidgetHostImpl* rwh,
                            CaptureTestSourceController* controller)
       : TestRenderWidgetHostView(rwh),
         controller_(controller) {}
 
-  virtual ~CaptureTestView() {}
+  ~CaptureTestView() override {}
 
   // TestRenderWidgetHostView overrides.
-  virtual gfx::Rect GetViewBounds() const override {
+  gfx::Rect GetViewBounds() const override {
     return gfx::Rect(100, 100, 100 + kTestWidth, 100 + kTestHeight);
   }
 
-  virtual bool CanCopyToVideoFrame() const override {
+  bool CanCopyToVideoFrame() const override {
     return controller_->CanCopyToVideoFrame();
   }
 
-  virtual void CopyFromCompositingSurfaceToVideoFrame(
+  void CopyFromCompositingSurfaceToVideoFrame(
       const gfx::Rect& src_subrect,
       const scoped_refptr<media::VideoFrame>& target,
       const base::Callback<void(bool)>& callback) override {
     SkColor c = ConvertRgbToYuv(controller_->GetSolidColor());
     media::FillYUV(
         target.get(), SkColorGetR(c), SkColorGetG(c), SkColorGetB(c));
     callback.Run(true);
     controller_->SignalCopy();
   }
 
-  virtual void BeginFrameSubscription(
+  void BeginFrameSubscription(
       scoped_ptr<RenderWidgetHostViewFrameSubscriber> subscriber) override {
     subscriber_.reset(subscriber.release());
   }
 
-  virtual void EndFrameSubscription() override {
-    subscriber_.reset();
-  }
+  void EndFrameSubscription() override { subscriber_.reset(); }
 
   // Simulate a compositor paint event for our subscriber.
   void SimulateUpdate() {
     const base::TimeTicks present_time = base::TimeTicks::Now();
     RenderWidgetHostViewFrameSubscriber::DeliverFrameCallback callback;
     scoped_refptr<media::VideoFrame> target;
     if (subscriber_ && subscriber_->ShouldCaptureFrame(
             gfx::Rect(), present_time, &target, &callback)) {
       SkColor c = ConvertRgbToYuv(controller_->GetSolidColor());
       media::FillYUV(
@@ skipping 35 matching lines @@
                            main_frame_routing_id, swapped_out),
         controller_(controller) {
     // Override the default view installed by TestRenderViewHost; we need
     // our special subclass which has mocked-out tab capture support.
     RenderWidgetHostView* old_view = GetView();
     SetView(new CaptureTestView(this, controller));
     delete old_view;
   }
 
   // TestRenderViewHost overrides.
-  virtual void CopyFromBackingStore(
+  void CopyFromBackingStore(
       const gfx::Rect& src_rect,
       const gfx::Size& accelerated_dst_size,
       const base::Callback<void(bool, const SkBitmap&)>& callback,
       const SkColorType color_type) override {
     gfx::Size size = controller_->GetCopyResultSize();
     SkColor color = controller_->GetSolidColor();
 
     // Although it's not necessary, use a PlatformBitmap here (instead of a
     // regular SkBitmap) to exercise possible threading issues.
     skia::PlatformBitmap output;
@@ skipping 17 matching lines @@
 #pragma warning(pop)
 #endif
 
 class CaptureTestRenderViewHostFactory : public RenderViewHostFactory {
  public:
   explicit CaptureTestRenderViewHostFactory(
       CaptureTestSourceController* controller) : controller_(controller) {
     RegisterFactory(this);
   }
 
-  virtual ~CaptureTestRenderViewHostFactory() {
-    UnregisterFactory();
-  }
+  ~CaptureTestRenderViewHostFactory() override { UnregisterFactory(); }
 
   // RenderViewHostFactory implementation.
-  virtual RenderViewHost* CreateRenderViewHost(
+  RenderViewHost* CreateRenderViewHost(
       SiteInstance* instance,
       RenderViewHostDelegate* delegate,
       RenderWidgetHostDelegate* widget_delegate,
       int routing_id,
       int main_frame_routing_id,
       bool swapped_out) override {
     return new CaptureTestRenderViewHost(instance, delegate, widget_delegate,
                                          routing_id, main_frame_routing_id,
                                          swapped_out, controller_);
   }
  private:
   CaptureTestSourceController* controller_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(CaptureTestRenderViewHostFactory);
 };
 
 // A stub consumer of captured video frames, which checks the output of
 // WebContentsVideoCaptureDevice.
 class StubClient : public media::VideoCaptureDevice::Client {
  public:
   StubClient(const base::Callback<void(SkColor)>& color_callback,
              const base::Closure& error_callback)
       : color_callback_(color_callback),
         error_callback_(error_callback) {
     buffer_pool_ = new VideoCaptureBufferPool(2);
   }
-  virtual ~StubClient() {}
+  ~StubClient() override {}
 
-  virtual scoped_refptr<media::VideoCaptureDevice::Client::Buffer>
-  ReserveOutputBuffer(media::VideoFrame::Format format,
-                      const gfx::Size& dimensions) override {
+  scoped_refptr<media::VideoCaptureDevice::Client::Buffer> ReserveOutputBuffer(
+      media::VideoFrame::Format format,
+      const gfx::Size& dimensions) override {
     CHECK_EQ(format, media::VideoFrame::I420);
     const size_t frame_bytes =
         media::VideoFrame::AllocationSize(media::VideoFrame::I420, dimensions);
     int buffer_id_to_drop = VideoCaptureBufferPool::kInvalidId;  // Ignored.
     int buffer_id =
         buffer_pool_->ReserveForProducer(frame_bytes, &buffer_id_to_drop);
     if (buffer_id == VideoCaptureBufferPool::kInvalidId)
       return NULL;
     void* data;
     size_t size;
     buffer_pool_->GetBufferInfo(buffer_id, &data, &size);
     return scoped_refptr<media::VideoCaptureDevice::Client::Buffer>(
         new PoolBuffer(buffer_pool_, buffer_id, data, size));
   }
 
-  virtual void OnIncomingCapturedData(
-      const uint8* data,
-      int length,
-      const media::VideoCaptureFormat& frame_format,
-      int rotation,
-      base::TimeTicks timestamp) override {
+  void OnIncomingCapturedData(const uint8* data,
+                              int length,
+                              const media::VideoCaptureFormat& frame_format,
+                              int rotation,
+                              base::TimeTicks timestamp) override {
     FAIL();
   }
 
-  virtual void OnIncomingCapturedVideoFrame(
+  void OnIncomingCapturedVideoFrame(
       const scoped_refptr<Buffer>& buffer,
       const media::VideoCaptureFormat& buffer_format,
       const scoped_refptr<media::VideoFrame>& frame,
       base::TimeTicks timestamp) override {
     EXPECT_EQ(gfx::Size(kTestWidth, kTestHeight), buffer_format.frame_size);
     EXPECT_EQ(media::PIXEL_FORMAT_I420, buffer_format.pixel_format);
     EXPECT_EQ(media::VideoFrame::I420, frame->format());
     uint8 yuv[3];
     for (int plane = 0; plane < 3; ++plane)
       yuv[plane] = frame->data(plane)[0];
     // TODO(nick): We just look at the first pixel presently, because if
     // the analysis is too slow, the backlog of frames will grow without bound
     // and trouble erupts. http://crbug.com/174519
     color_callback_.Run((SkColorSetRGB(yuv[0], yuv[1], yuv[2])));
   }
 
-  virtual void OnError(const std::string& reason) override {
-    error_callback_.Run();
-  }
+  void OnError(const std::string& reason) override { error_callback_.Run(); }
 
  private:
   class PoolBuffer : public media::VideoCaptureDevice::Client::Buffer {
    public:
     PoolBuffer(const scoped_refptr<VideoCaptureBufferPool>& pool,
                int buffer_id,
                void* data,
                size_t size)
         : Buffer(buffer_id, data, size), pool_(pool) {}
 
    private:
-    virtual ~PoolBuffer() { pool_->RelinquishProducerReservation(id()); }
+    ~PoolBuffer() override { pool_->RelinquishProducerReservation(id()); }
     const scoped_refptr<VideoCaptureBufferPool> pool_;
   };
 
   scoped_refptr<VideoCaptureBufferPool> buffer_pool_;
   base::Callback<void(SkColor)> color_callback_;
   base::Closure error_callback_;
 
   DISALLOW_COPY_AND_ASSIGN(StubClient);
 };
 
@@ skipping 77 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(StubClientObserver);
 };
 
 // A dummy implementation of gfx::Screen, since WebContentsVideoCaptureDevice
 // needs access to a gfx::Display's device scale factor.
 class FakeScreen : public gfx::Screen {
  public:
   FakeScreen() : the_one_display_(0x1337, gfx::Rect(0, 0, 2560, 1440)) {
     the_one_display_.set_device_scale_factor(kTestDeviceScaleFactor);
   }
-  virtual ~FakeScreen() {}
+  ~FakeScreen() override {}
 
   // gfx::Screen implementation (only what's needed for testing).
-  virtual bool IsDIPEnabled() override { return true; }
-  virtual gfx::Point GetCursorScreenPoint() override { return gfx::Point(); }
-  virtual gfx::NativeWindow GetWindowUnderCursor() override { return NULL; }
-  virtual gfx::NativeWindow GetWindowAtScreenPoint(
-      const gfx::Point& point) override { return NULL; }
-  virtual int GetNumDisplays() const override { return 1; }
-  virtual std::vector<gfx::Display> GetAllDisplays() const override {
+  bool IsDIPEnabled() override { return true; }
+  gfx::Point GetCursorScreenPoint() override { return gfx::Point(); }
+  gfx::NativeWindow GetWindowUnderCursor() override { return NULL; }
+  gfx::NativeWindow GetWindowAtScreenPoint(const gfx::Point& point) override {
+    return NULL;
+  }
+  int GetNumDisplays() const override { return 1; }
+  std::vector<gfx::Display> GetAllDisplays() const override {
     return std::vector<gfx::Display>(1, the_one_display_);
   }
-  virtual gfx::Display GetDisplayNearestWindow(
-      gfx::NativeView view) const override {
+  gfx::Display GetDisplayNearestWindow(gfx::NativeView view) const override {
     return the_one_display_;
   }
-  virtual gfx::Display GetDisplayNearestPoint(
-      const gfx::Point& point) const override {
+  gfx::Display GetDisplayNearestPoint(const gfx::Point& point) const override {
     return the_one_display_;
   }
-  virtual gfx::Display GetDisplayMatching(
-      const gfx::Rect& match_rect) const override {
+  gfx::Display GetDisplayMatching(const gfx::Rect& match_rect) const override {
     return the_one_display_;
   }
-  virtual gfx::Display GetPrimaryDisplay() const override {
-    return the_one_display_;
-  }
-  virtual void AddObserver(gfx::DisplayObserver* observer) override {}
-  virtual void RemoveObserver(gfx::DisplayObserver* observer) override {}
+  gfx::Display GetPrimaryDisplay() const override { return the_one_display_; }
+  void AddObserver(gfx::DisplayObserver* observer) override {}
+  void RemoveObserver(gfx::DisplayObserver* observer) override {}
 
  private:
   gfx::Display the_one_display_;
 
   DISALLOW_COPY_AND_ASSIGN(FakeScreen);
 };
 
 // Test harness that sets up a minimal environment with necessary stubs.
 class WebContentsVideoCaptureDeviceTest : public testing::Test {
  public:
@@ skipping 337 matching lines @@
   source()->SetSolidColor(SK_ColorGREEN);
   ASSERT_NO_FATAL_FAILURE(client_observer()->WaitForNextColor(SK_ColorGREEN));
   source()->SetSolidColor(SK_ColorRED);
   ASSERT_NO_FATAL_FAILURE(client_observer()->WaitForNextColor(SK_ColorRED));
 
   device()->StopAndDeAllocate();
 }
 
 }  // namespace
 }  // namespace content