Warn on missing OVERRIDE/virtual everywhere, not just in header files.

cc/trees/layer_tree_host_unittest.cc

 // Copyright 2011 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 "cc/trees/layer_tree_host.h"
 
 #include <algorithm>
 
 #include "base/synchronization/lock.h"
 #include "cc/animation/timing_function.h"
@@ skipping 2344 matching lines @@
     scoped_refptr<Layer> layer = PictureLayer::Create(&client_);
     layer->SetTransform(gfx::Transform(0.0, 0.0, 0.0, 0.0, 0.0, 0.0));
     layer->SetBounds(gfx::Size(10, 10));
     layer_tree_host()->root_layer()->AddChild(layer);
   }
 
   virtual void BeginTest() OVERRIDE {
     PostSetNeedsCommitToMainThread();
   }
 
-  virtual void TreeActivatedOnThread(LayerTreeHostImpl* host_impl) {
+  virtual void TreeActivatedOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
     EndTest();
   }
 
   virtual void AfterTest() OVERRIDE {
   }
 
   FakeContentLayerClient client_;
 };
 
 MULTI_THREAD_TEST_F(
@@ skipping 199 matching lines @@
     root->AddChild(child);
 
     layer_tree_host()->SetRootLayer(root);
     LayerTreeHostTest::SetupTree();
   }
 
   virtual void BeginTest() OVERRIDE {
     PostSetNeedsCommitToMainThread();
   }
 
-  virtual void DidCommitAndDrawFrame() {
+  virtual void DidCommitAndDrawFrame() OVERRIDE {
     int frame = layer_tree_host()->commit_number();
     switch (frame) {
       case 1:
         child->RequestCopyAsBitmap(base::Bind(
             &LayerTreeHostTestAsyncReadback::BitmapCallback,
             base::Unretained(this)));
         EXPECT_EQ(0u, callbacks_.size());
         break;
       case 2:
         // Flush the message loops and make sure the callbacks run.
@@ skipping 29 matching lines @@
         break;
     }
   }
 
   void BitmapCallback(scoped_ptr<SkBitmap> bitmap) {
     EXPECT_TRUE(layer_tree_host()->proxy()->IsMainThread());
     EXPECT_TRUE(bitmap);
     callbacks_.push_back(gfx::Size(bitmap->width(), bitmap->height()));
   }
 
-  virtual void AfterTest() {}
+  virtual void AfterTest() OVERRIDE {}
 
   virtual scoped_ptr<OutputSurface> CreateOutputSurface() OVERRIDE {
     if (use_gl_renderer_)
       return FakeOutputSurface::Create3d().PassAs<OutputSurface>();
     return FakeOutputSurface::CreateSoftware(
         make_scoped_ptr(new SoftwareOutputDevice)).PassAs<OutputSurface>();
   }
 
   bool use_gl_renderer_;
   std::vector<gfx::Size> callbacks_;
@@ skipping 38 matching lines @@
 
     layer_tree_host()->SetRootLayer(root_);
     LayerTreeHostTest::SetupTree();
   }
 
   virtual void BeginTest() OVERRIDE {
     callback_count_ = 0;
     PostSetNeedsCommitToMainThread();
   }
 
-  virtual void DidCommit() {
+  virtual void DidCommit() OVERRIDE {
     int frame = layer_tree_host()->commit_number();
     switch (frame) {
       case 1:
         main_destroyed_->RequestCopyAsBitmap(base::Bind(
             &LayerTreeHostTestAsyncReadbackLayerDestroyed::BitmapCallback,
             base::Unretained(this)));
         impl_destroyed_->RequestCopyAsBitmap(base::Bind(
             &LayerTreeHostTestAsyncReadbackLayerDestroyed::BitmapCallback,
             base::Unretained(this)));
         EXPECT_EQ(0, callback_count_);
@@ skipping 34 matching lines @@
         break;
     }
   }
 
   void BitmapCallback(scoped_ptr<SkBitmap> bitmap) {
     EXPECT_TRUE(layer_tree_host()->proxy()->IsMainThread());
     EXPECT_FALSE(bitmap);
     ++callback_count_;
   }
 
-  virtual void AfterTest() {}
+  virtual void AfterTest() OVERRIDE {}
 
   int callback_count_;
   FakeContentLayerClient client_;
   scoped_refptr<FakeContentLayer> root_;
   scoped_refptr<FakeContentLayer> main_destroyed_;
   scoped_refptr<FakeContentLayer> impl_destroyed_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestAsyncReadbackLayerDestroyed);
 
 }  // namespace
 }  // namespace cc