Standardize usage of virtual/override/final in cc/

cc/trees/layer_tree_host_unittest_proxy.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/basictypes.h"
 #include "base/compiler_specific.h"
 #include "cc/test/layer_tree_test.h"
 #include "cc/trees/thread_proxy.h"
 
 #define THREAD_PROXY_NO_IMPL_TEST_F(TEST_FIXTURE_NAME) \
@@ skipping 19 matching lines @@
   ProxyTest() {}
   virtual ~ProxyTest() {}
 
   void Run(bool threaded, bool impl_side_painting) {
     // We don't need to care about delegating mode.
     bool delegating_renderer = true;
 
     RunTest(threaded, delegating_renderer, impl_side_painting);
   }
 
-  virtual void BeginTest() override {}
-  virtual void AfterTest() override {}
+  void BeginTest() override {}
+  void AfterTest() override {}
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ProxyTest);
 };
 
 class ProxyTestScheduledActionsBasic : public ProxyTest {
  protected:
-  virtual void BeginTest() override {
-    proxy()->SetNeedsCommit();
-  }
+  void BeginTest() override { proxy()->SetNeedsCommit(); }
 
-  virtual void ScheduledActionBeginOutputSurfaceCreation() override {
+  void ScheduledActionBeginOutputSurfaceCreation() override {
     EXPECT_EQ(0, action_phase_++);
   }
 
-  virtual void ScheduledActionSendBeginMainFrame() override {
+  void ScheduledActionSendBeginMainFrame() override {
     EXPECT_EQ(1, action_phase_++);
   }
 
-  virtual void ScheduledActionCommit() override {
-    EXPECT_EQ(2, action_phase_++);
-  }
+  void ScheduledActionCommit() override { EXPECT_EQ(2, action_phase_++); }
 
-  virtual void ScheduledActionDrawAndSwapIfPossible() override {
+  void ScheduledActionDrawAndSwapIfPossible() override {
     EXPECT_EQ(3, action_phase_++);
     EndTest();
   }
 
-  virtual void AfterTest() override {
-    EXPECT_EQ(4, action_phase_);
-  }
+  void AfterTest() override { EXPECT_EQ(4, action_phase_); }
 
   ProxyTestScheduledActionsBasic() : action_phase_(0) {
   }
   virtual ~ProxyTestScheduledActionsBasic() {}
 
  private:
   int action_phase_;
 
   DISALLOW_COPY_AND_ASSIGN(ProxyTestScheduledActionsBasic);
 };
@@ skipping 19 matching lines @@
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ThreadProxyTest);
 };
 
 class ThreadProxyTestSetNeedsCommit : public ThreadProxyTest {
  protected:
   ThreadProxyTestSetNeedsCommit() {}
   virtual ~ThreadProxyTestSetNeedsCommit() {}
 
-  virtual void BeginTest() override {
+  void BeginTest() override {
     EXPECT_FALSE(ThreadProxyMainOnly().commit_requested);
     EXPECT_FALSE(ThreadProxyMainOnly().commit_request_sent_to_impl_thread);
 
     proxy()->SetNeedsCommit();
 
     EXPECT_TRUE(ThreadProxyMainOnly().commit_requested);
     EXPECT_TRUE(ThreadProxyMainOnly().commit_request_sent_to_impl_thread);
   }
 
-  virtual void DidBeginMainFrame() override {
+  void DidBeginMainFrame() override {
     EXPECT_FALSE(ThreadProxyMainOnly().commit_requested);
     EXPECT_FALSE(ThreadProxyMainOnly().commit_request_sent_to_impl_thread);
 
     EndTest();
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ThreadProxyTestSetNeedsCommit);
 };
 
 THREAD_PROXY_TEST_F(ThreadProxyTestSetNeedsCommit);
 
 }  // namespace cc