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

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 {
+  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 136 matching lines @@
     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 {
+  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;
       }
     }
 
     // A frame might not be available yet. So, wait for it.
     WaitForCopySourceReady();
     return true;
   }
 
  private:
   const CompositingMode compositing_mode_;
 
   DISALLOW_COPY_AND_ASSIGN(CompositingRenderWidgetHostViewBrowserTest);
 };
 
 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 {
+  bool ShouldCaptureFrame(const gfx::Rect& damage_rect,
+                          base::TimeTicks present_time,
+                          scoped_refptr<media::VideoFrame>* storage,
+                          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 234 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 {
-    return GURL(test_url_);
-  }
+  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.
   // when the output is scaled).
   void PerformTestWithLeftRightRects(const gfx::Size& html_rect_size,
@@ skipping 226 matching lines @@
                                 output_size,
                                 video_frame);
 }
 
 class CompositingRenderWidgetHostViewBrowserTestTabCaptureHighDPI
     : public CompositingRenderWidgetHostViewBrowserTestTabCapture {
  public:
   CompositingRenderWidgetHostViewBrowserTestTabCaptureHighDPI() {}
 
  protected:
-  virtual void SetUpCommandLine(base::CommandLine* cmd) override {
+  void SetUpCommandLine(base::CommandLine* cmd) override {
     CompositingRenderWidgetHostViewBrowserTestTabCapture::SetUpCommandLine(cmd);
     cmd->AppendSwitchASCII(switches::kForceDeviceScaleFactor,
                            base::StringPrintf("%f", scale()));
   }
 
-  virtual bool ShouldContinueAfterTestURLLoad() override {
+  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