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

content/browser/renderer_host/render_widget_host_view_browsertest.cc

 // Copyright (c) 2013 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 "base/command_line.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/path_service.h"
 #include "base/run_loop.h"
 #include "content/browser/gpu/compositor_util.h"
 #include "content/browser/gpu/gpu_data_manager_impl.h"
@@ skipping 43 matching lines @@
 // Common base class for browser tests.  This is subclassed twice: Once to test
 // the browser in forced-compositing mode, and once to test with compositing
 // mode disabled.
 class RenderWidgetHostViewBrowserTest : public ContentBrowserTest {
  public:
   RenderWidgetHostViewBrowserTest()
       : frame_size_(400, 300),
         callback_invoke_count_(0),
         frames_captured_(0) {}
 
-  virtual void SetUpOnMainThread() OVERRIDE {
+  virtual void SetUpOnMainThread() override {
     ASSERT_TRUE(PathService::Get(DIR_TEST_DATA, &test_dir_));
   }
 
   // Attempts to set up the source surface.  Returns false if unsupported on the
   // current platform.
   virtual bool SetUpSourceSurface(const char* wait_message) = 0;
 
   int callback_invoke_count() const {
     return callback_invoke_count_;
   }
@@ skipping 125 matching lines @@
   SOFTWARE_COMPOSITING,
 };
 
 class CompositingRenderWidgetHostViewBrowserTest
     : public RenderWidgetHostViewBrowserTest,
       public testing::WithParamInterface<CompositingMode> {
  public:
   explicit CompositingRenderWidgetHostViewBrowserTest()
       : compositing_mode_(GetParam()) {}
 
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     if (compositing_mode_ == SOFTWARE_COMPOSITING)
       UseSoftwareCompositing();
     RenderWidgetHostViewBrowserTest::SetUp();
   }
 
   virtual GURL TestUrl() {
     return net::FilePathToFileURL(
         test_dir().AppendASCII("rwhv_compositing_animation.html"));
   }
 
-  virtual bool SetUpSourceSurface(const char* wait_message) OVERRIDE {
+  virtual bool SetUpSourceSurface(const char* wait_message) override {
     content::DOMMessageQueue message_queue;
     NavigateToURL(shell(), TestUrl());
     if (wait_message != NULL) {
       std::string result(wait_message);
       if (!message_queue.WaitForMessage(&result)) {
         EXPECT_TRUE(false) << "WaitForMessage " << result << " failed.";
         return false;
       }
     }
 
@@ skipping 11 matching lines @@
 class FakeFrameSubscriber : public RenderWidgetHostViewFrameSubscriber {
  public:
   FakeFrameSubscriber(
     RenderWidgetHostViewFrameSubscriber::DeliverFrameCallback callback)
       : callback_(callback) {
   }
 
   virtual bool ShouldCaptureFrame(const gfx::Rect& damage_rect,
                                   base::TimeTicks present_time,
                                   scoped_refptr<media::VideoFrame>* storage,
-                                  DeliverFrameCallback* callback) OVERRIDE {
+                                  DeliverFrameCallback* callback) override {
     // Only allow one frame capture to be made.  Otherwise, the compositor could
     // start multiple captures, unbounded, and eventually its own limiter logic
     // will begin invoking |callback| with a |false| result.  This flakes out
     // the unit tests, since they receive a "failed" callback before the later
     // "success" callbacks.
     if (callback_.is_null())
       return false;
     *storage = media::VideoFrame::CreateBlackFrame(gfx::Size(100, 100));
     *callback = callback_;
     callback_.Reset();
@@ skipping 137 matching lines @@
 }
 
 class CompositingRenderWidgetHostViewBrowserTestTabCapture
     : public CompositingRenderWidgetHostViewBrowserTest {
  public:
   CompositingRenderWidgetHostViewBrowserTestTabCapture()
       : expected_copy_from_compositing_surface_result_(false),
         allowable_error_(0),
         test_url_("data:text/html,<!doctype html>") {}
 
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     EnablePixelOutput();
     CompositingRenderWidgetHostViewBrowserTest::SetUp();
   }
 
   void CopyFromCompositingSurfaceCallback(base::Closure quit_callback,
                                           bool result,
                                           const SkBitmap& bitmap) {
     EXPECT_EQ(expected_copy_from_compositing_surface_result_, result);
     if (!result) {
       quit_callback.Run();
@@ skipping 76 matching lines @@
 
   void SetExpectedCopyFromCompositingSurfaceResult(bool result,
                                                    const SkBitmap& bitmap) {
     expected_copy_from_compositing_surface_result_ = result;
     expected_copy_from_compositing_surface_bitmap_ = bitmap;
   }
 
   void SetAllowableError(int amount) { allowable_error_ = amount; }
   void SetExcludeRect(gfx::Rect exclude) { exclude_rect_ = exclude; }
 
-  virtual GURL TestUrl() OVERRIDE {
+  virtual GURL TestUrl() override {
     return GURL(test_url_);
   }
 
   void SetTestUrl(std::string url) { test_url_ = url; }
 
   // Loads a page two boxes side-by-side, each half the width of
   // |html_rect_size|, and with different background colors. The test then
   // copies from |copy_rect| region of the page into a bitmap of size
   // |output_size|, and examines the resulting bitmap/VideoFrame.
   // Note that |output_size| may not have the same size as |copy_rect| (e.g.
@@ skipping 228 matching lines @@
                                 output_size,
                                 video_frame);
 }
 
 class CompositingRenderWidgetHostViewBrowserTestTabCaptureHighDPI
     : public CompositingRenderWidgetHostViewBrowserTestTabCapture {
  public:
   CompositingRenderWidgetHostViewBrowserTestTabCaptureHighDPI() {}
 
  protected:
-  virtual void SetUpCommandLine(base::CommandLine* cmd) OVERRIDE {
+  virtual void SetUpCommandLine(base::CommandLine* cmd) override {
     CompositingRenderWidgetHostViewBrowserTestTabCapture::SetUpCommandLine(cmd);
     cmd->AppendSwitchASCII(switches::kForceDeviceScaleFactor,
                            base::StringPrintf("%f", scale()));
   }
 
-  virtual bool ShouldContinueAfterTestURLLoad() OVERRIDE {
+  virtual bool ShouldContinueAfterTestURLLoad() override {
     // Short-circuit a pass for platforms where setting up high-DPI fails.
     const float actual_scale_factor =
         GetScaleFactorForView(GetRenderWidgetHostView());
     if (actual_scale_factor != scale()) {
       LOG(WARNING) << "Blindly passing this test; unable to force device scale "
                    << "factor: seems to be " << actual_scale_factor
                    << " but expected " << scale();
       return false;
     }
     VLOG(1) << ("Successfully forced device scale factor.  Moving forward with "
@@ skipping 134 matching lines @@
                         testing::Values(GL_COMPOSITING, SOFTWARE_COMPOSITING));
 INSTANTIATE_TEST_CASE_P(
     GLAndSoftwareCompositing,
     CompositingRenderWidgetHostViewBrowserTestTabCaptureHighDPI,
     testing::Values(GL_COMPOSITING, SOFTWARE_COMPOSITING));
 
 #endif  // !defined(OS_ANDROID) && !defined(OS_IOS)
 
 }  // namespace
 }  // namespace content