Standardize usage of virtual/override/final in cc/

cc/trees/layer_tree_host_unittest_no_message_loop.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 "base/message_loop/message_loop_proxy.h"
 #include "base/threading/simple_thread.h"
 #include "cc/layers/delegated_frame_provider.h"
 #include "cc/layers/delegated_frame_resource_collection.h"
 #include "cc/layers/delegated_renderer_layer.h"
 #include "cc/layers/layer.h"
@@ skipping 10 matching lines @@
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "ui/gfx/frame_time.h"
 
 namespace cc {
 namespace {
 
 class NoMessageLoopOutputSurface : public OutputSurface {
  public:
   NoMessageLoopOutputSurface() : OutputSurface(TestContextProvider::Create()) {}
-  virtual ~NoMessageLoopOutputSurface() {}
+  ~NoMessageLoopOutputSurface() override {}
 
   // OutputSurface overrides.
-  virtual void SwapBuffers(CompositorFrame* frame) override {
+  void SwapBuffers(CompositorFrame* frame) override {
     DCHECK(client_);
     client_->DidSwapBuffers();
     client_->DidSwapBuffersComplete();
   }
 };
 
 class LayerTreeHostNoMessageLoopTest
     : public testing::Test,
       public base::DelegateSimpleThread::Delegate,
       public LayerTreeHostClient,
       public LayerTreeHostSingleThreadClient {
  public:
   LayerTreeHostNoMessageLoopTest()
       : did_initialize_output_surface_(false),
         did_commit_(false),
         did_commit_and_draw_frame_(false),
         size_(100, 100),
         no_loop_thread_(this, "LayerTreeHostNoMessageLoopTest") {}
   virtual ~LayerTreeHostNoMessageLoopTest() {}
 
   // LayerTreeHostClient overrides.
-  virtual void WillBeginMainFrame(int frame_id) override {}
-  virtual void BeginMainFrame(const BeginFrameArgs& args) override {}
-  virtual void DidBeginMainFrame() override {}
-  virtual void Layout() override {}
-  virtual void ApplyViewportDeltas(const gfx::Vector2d& inner_delta,
-                                   const gfx::Vector2d& outer_delta,
-                                   float page_scale,
-                                   float top_controls_delta) override {}
-  virtual void ApplyViewportDeltas(const gfx::Vector2d& scroll_delta,
-                                   float page_scale,
-                                   float top_controls_delta) override {}
-  virtual void RequestNewOutputSurface(bool fallback) override {
+  void WillBeginMainFrame(int frame_id) override {}
+  void BeginMainFrame(const BeginFrameArgs& args) override {}
+  void DidBeginMainFrame() override {}
+  void Layout() override {}
+  void ApplyViewportDeltas(const gfx::Vector2d& inner_delta,
+                           const gfx::Vector2d& outer_delta,
+                           float page_scale,
+                           float top_controls_delta) override {}
+  void ApplyViewportDeltas(const gfx::Vector2d& scroll_delta,
+                           float page_scale,
+                           float top_controls_delta) override {}
+  void RequestNewOutputSurface(bool fallback) override {
     layer_tree_host_->SetOutputSurface(
         make_scoped_ptr<OutputSurface>(new NoMessageLoopOutputSurface));
   }
-  virtual void DidInitializeOutputSurface() override {
+  void DidInitializeOutputSurface() override {
     did_initialize_output_surface_ = true;
   }
-  virtual void WillCommit() override {}
-  virtual void DidCommit() override { did_commit_ = true; }
-  virtual void DidCommitAndDrawFrame() override {
-    did_commit_and_draw_frame_ = true;
-  }
-  virtual void DidCompleteSwapBuffers() override {}
+  void WillCommit() override {}
+  void DidCommit() override { did_commit_ = true; }
+  void DidCommitAndDrawFrame() override { did_commit_and_draw_frame_ = true; }
+  void DidCompleteSwapBuffers() override {}
 
   // LayerTreeHostSingleThreadClient overrides.
-  virtual void DidPostSwapBuffers() override {}
-  virtual void DidAbortSwapBuffers() override {}
+  void DidPostSwapBuffers() override {}
+  void DidAbortSwapBuffers() override {}
 
   void RunTest() {
     no_loop_thread_.Start();
     no_loop_thread_.Join();
   }
 
   // base::DelegateSimpleThread::Delegate override.
-  virtual void Run() override {
+  void Run() override {
     ASSERT_FALSE(base::MessageLoopProxy::current().get());
     RunTestWithoutMessageLoop();
     EXPECT_FALSE(base::MessageLoopProxy::current().get());
   }
 
  protected:
   virtual void RunTestWithoutMessageLoop() = 0;
 
   void SetupLayerTreeHost() {
     LayerTreeSettings settings;
@@ skipping 28 matching lines @@
   bool did_commit_and_draw_frame_;
   gfx::Size size_;
 
  private:
   base::DelegateSimpleThread no_loop_thread_;
 };
 
 class LayerTreeHostNoMessageLoopSmokeTest
     : public LayerTreeHostNoMessageLoopTest {
  protected:
-  virtual void RunTestWithoutMessageLoop() override {
+  void RunTestWithoutMessageLoop() override {
     gfx::Size size(100, 100);
 
     // Set up root layer.
     {
       scoped_refptr<SolidColorLayer> solid_color_layer =
           SolidColorLayer::Create();
       solid_color_layer->SetBackgroundColor(SK_ColorRED);
       solid_color_layer->SetBounds(size_);
       solid_color_layer->SetIsDrawable(true);
       root_layer_ = solid_color_layer;
     }
 
     SetupLayerTreeHost();
     Composite();
     TearDownLayerTreeHost();
   }
 };
 
 TEST_F(LayerTreeHostNoMessageLoopSmokeTest, SmokeTest) {
   RunTest();
 }
 
 class LayerTreeHostNoMessageLoopDelegatedLayer
     : public LayerTreeHostNoMessageLoopTest,
       public DelegatedFrameResourceCollectionClient {
  protected:
-  virtual void RunTestWithoutMessageLoop() override {
+  void RunTestWithoutMessageLoop() override {
     resource_collection_ = new DelegatedFrameResourceCollection;
     frame_provider_ = new DelegatedFrameProvider(
         resource_collection_.get(), CreateFrameDataWithResource(998));
 
     root_layer_ = Layer::Create();
     delegated_layer_ =
         FakeDelegatedRendererLayer::Create(frame_provider_.get());
     delegated_layer_->SetBounds(size_);
     delegated_layer_->SetIsDrawable(true);
     root_layer_->AddChild(delegated_layer_);
@@ skipping 13 matching lines @@
     TearDownLayerTreeHost();
     delegated_layer_ = NULL;
     frame_provider_ = NULL;
 
     // Resource from second frame should be returned.
     CheckReturnedResource(1u);
     resource_collection_ = NULL;
   }
 
   // DelegatedFrameResourceCollectionClient overrides.
-  virtual void UnusedResourcesAreAvailable() override {}
+  void UnusedResourcesAreAvailable() override {}
 
  private:
   scoped_ptr<DelegatedFrameData> CreateFrameDataWithResource(
       ResourceProvider::ResourceId resource_id) {
     scoped_ptr<DelegatedFrameData> frame(new DelegatedFrameData);
     gfx::Rect frame_rect(size_);
 
     scoped_ptr<RenderPass> root_pass(RenderPass::Create());
     root_pass->SetNew(
         RenderPassId(1, 1), frame_rect, frame_rect, gfx::Transform());
@@ skipping 19 matching lines @@
   scoped_refptr<DelegatedFrameProvider> frame_provider_;
   scoped_refptr<DelegatedRendererLayer> delegated_layer_;
 };
 
 TEST_F(LayerTreeHostNoMessageLoopDelegatedLayer, SingleDelegatedLayer) {
   RunTest();
 }
 
 }  // namespace
 }  // namespace cc