Standardize usage of virtual/override/final in cc/

cc/layers/scrollbar_layer_unittest.cc

 // Copyright 2012 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/containers/hash_tables.h"
 #include "cc/animation/scrollbar_animation_controller.h"
 #include "cc/layers/append_quads_data.h"
 #include "cc/layers/painted_scrollbar_layer.h"
 #include "cc/layers/painted_scrollbar_layer_impl.h"
 #include "cc/layers/scrollbar_layer_interface.h"
@@ skipping 550 matching lines @@
   EXPECT_RECT_EQ(gfx::Rect(0.f, 22, 3.f, 22.f),
                  vertical_scrollbar_layer_->ComputeThumbQuadRect());
 }
 
 class ScrollbarLayerTestMaxTextureSize : public LayerTreeTest {
  public:
   ScrollbarLayerTestMaxTextureSize() {}
 
   void SetScrollbarBounds(const gfx::Size& bounds) { bounds_ = bounds; }
 
-  virtual void BeginTest() override {
+  void BeginTest() override {
     scroll_layer_ = Layer::Create();
     layer_tree_host()->root_layer()->AddChild(scroll_layer_);
 
     scoped_ptr<Scrollbar> scrollbar(new FakeScrollbar);
     scrollbar_layer_ =
         PaintedScrollbarLayer::Create(scrollbar.Pass(), scroll_layer_->id());
     scrollbar_layer_->SetScrollLayer(scroll_layer_->id());
     scrollbar_layer_->SetLayerTreeHost(layer_tree_host());
     scrollbar_layer_->SetBounds(bounds_);
     layer_tree_host()->root_layer()->AddChild(scrollbar_layer_);
 
     PostSetNeedsCommitToMainThread();
   }
 
-  virtual void DidCommitAndDrawFrame() override {
+  void DidCommitAndDrawFrame() override {
     const int kMaxTextureSize =
         layer_tree_host()->GetRendererCapabilities().max_texture_size;
 
     // Check first that we're actually testing something.
     EXPECT_GT(scrollbar_layer_->bounds().width(), kMaxTextureSize);
 
     EXPECT_EQ(scrollbar_layer_->content_bounds().width(),
               kMaxTextureSize - 1);
     EXPECT_EQ(scrollbar_layer_->content_bounds().height(),
               kMaxTextureSize - 1);
 
     EndTest();
   }
 
-  virtual void AfterTest() override {}
+  void AfterTest() override {}
 
  private:
   scoped_refptr<PaintedScrollbarLayer> scrollbar_layer_;
   scoped_refptr<Layer> scroll_layer_;
   gfx::Size bounds_;
 };
 
 TEST_F(ScrollbarLayerTestMaxTextureSize, DirectRenderer) {
   scoped_ptr<TestWebGraphicsContext3D> context =
       TestWebGraphicsContext3D::Create();
@@ skipping 16 matching lines @@
  public:
   FakeLayerTreeHost(FakeLayerTreeHostClient* client,
                     const LayerTreeSettings& settings)
       : LayerTreeHost(client, nullptr, nullptr, settings),
         next_id_(1),
         total_ui_resource_created_(0),
         total_ui_resource_deleted_(0) {
     InitializeSingleThreaded(client, base::MessageLoopProxy::current());
   }
 
-  virtual UIResourceId CreateUIResource(UIResourceClient* content) override {
+  UIResourceId CreateUIResource(UIResourceClient* content) override {
     total_ui_resource_created_++;
     UIResourceId nid = next_id_++;
     ui_resource_bitmap_map_.insert(
         std::make_pair(nid, content->GetBitmap(nid, false)));
     return nid;
   }
 
   // Deletes a UI resource.  May safely be called more than once.
-  virtual void DeleteUIResource(UIResourceId id) override {
+  void DeleteUIResource(UIResourceId id) override {
     UIResourceBitmapMap::iterator iter = ui_resource_bitmap_map_.find(id);
     if (iter != ui_resource_bitmap_map_.end()) {
       ui_resource_bitmap_map_.erase(iter);
       total_ui_resource_deleted_++;
     }
   }
 
   size_t UIResourceCount() { return ui_resource_bitmap_map_.size(); }
   int TotalUIResourceDeleted() { return total_ui_resource_deleted_; }
   int TotalUIResourceCreated() { return total_ui_resource_created_; }
@@ skipping 435 matching lines @@
   TestScale(gfx::Rect(1240, 0, 15, 1333), 2.7754839f);
   TestScale(gfx::Rect(1240, 0, 15, 677), 2.46677136f);
 
   // Horizontal Scrollbars.
   TestScale(gfx::Rect(0, 1240, 1333, 15), 2.7754839f);
   TestScale(gfx::Rect(0, 1240, 677, 15), 2.46677136f);
 }
 
 }  // namespace
 }  // namespace cc