Replacing the OVERRIDE with override and FINAL with final in content/browser/media

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 148 matching lines @@
 class CaptureTestView : public TestRenderWidgetHostView {
  public:
   explicit CaptureTestView(RenderWidgetHostImpl* rwh,
                            CaptureTestSourceController* controller)
       : TestRenderWidgetHostView(rwh),
         controller_(controller) {}
 
   virtual ~CaptureTestView() {}
 
   // TestRenderWidgetHostView overrides.
-  virtual gfx::Rect GetViewBounds() const OVERRIDE {
+  virtual gfx::Rect GetViewBounds() const override {
     return gfx::Rect(100, 100, 100 + kTestWidth, 100 + kTestHeight);
   }
 
-  virtual bool CanCopyToVideoFrame() const OVERRIDE {
+  virtual bool CanCopyToVideoFrame() const override {
     return controller_->CanCopyToVideoFrame();
   }
 
   virtual void CopyFromCompositingSurfaceToVideoFrame(
       const gfx::Rect& src_subrect,
       const scoped_refptr<media::VideoFrame>& target,
-      const base::Callback<void(bool)>& callback) OVERRIDE {
+      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(
-      scoped_ptr<RenderWidgetHostViewFrameSubscriber> subscriber) OVERRIDE {
+      scoped_ptr<RenderWidgetHostViewFrameSubscriber> subscriber) override {
     subscriber_.reset(subscriber.release());
   }
 
-  virtual void EndFrameSubscription() OVERRIDE {
+  virtual 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)) {
@@ skipping 41 matching lines @@
     RenderWidgetHostView* old_view = GetView();
     SetView(new CaptureTestView(this, controller));
     delete old_view;
   }
 
   // TestRenderViewHost overrides.
   virtual 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 {
+      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;
     EXPECT_TRUE(output.Allocate(size.width(), size.height(), false));
     {
       SkAutoLockPixels locker(output.GetBitmap());
       output.GetBitmap().eraseColor(color);
@@ skipping 24 matching lines @@
     UnregisterFactory();
   }
 
   // RenderViewHostFactory implementation.
   virtual RenderViewHost* CreateRenderViewHost(
       SiteInstance* instance,
       RenderViewHostDelegate* delegate,
       RenderWidgetHostDelegate* widget_delegate,
       int routing_id,
       int main_frame_routing_id,
-      bool swapped_out) OVERRIDE {
+      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() {}
 
   virtual scoped_refptr<media::VideoCaptureDevice::Client::Buffer>
   ReserveOutputBuffer(media::VideoFrame::Format format,
-                      const gfx::Size& dimensions) OVERRIDE {
+                      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 {
+      base::TimeTicks timestamp) override {
     FAIL();
   }
 
   virtual void OnIncomingCapturedVideoFrame(
       const scoped_refptr<Buffer>& buffer,
       const media::VideoCaptureFormat& buffer_format,
       const scoped_refptr<media::VideoFrame>& frame,
-      base::TimeTicks timestamp) OVERRIDE {
+      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 {
+  virtual 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)
@@ skipping 94 matching lines @@
 // 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() {}
 
   // 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 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 {
+      const gfx::Point& point) override { return NULL; }
+  virtual int GetNumDisplays() const override { return 1; }
+  virtual 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::NativeView view) const override {
     return the_one_display_;
   }
   virtual gfx::Display GetDisplayNearestPoint(
-      const gfx::Point& point) const OVERRIDE {
+      const gfx::Point& point) const override {
     return the_one_display_;
   }
   virtual gfx::Display GetDisplayMatching(
-      const gfx::Rect& match_rect) const OVERRIDE {
+      const gfx::Rect& match_rect) const override {
     return the_one_display_;
   }
-  virtual gfx::Display GetPrimaryDisplay() const OVERRIDE {
+  virtual gfx::Display GetPrimaryDisplay() const override {
     return the_one_display_;
   }
-  virtual void AddObserver(gfx::DisplayObserver* observer) OVERRIDE {}
-  virtual void RemoveObserver(gfx::DisplayObserver* observer) OVERRIDE {}
+  virtual void AddObserver(gfx::DisplayObserver* observer) override {}
+  virtual 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