replace OVERRIDE and FINAL with override and final in cc/

cc/resources/tile_manager_unittest.cc

 // Copyright 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 "cc/resources/eviction_tile_priority_queue.h"
 #include "cc/resources/raster_tile_priority_queue.h"
 #include "cc/resources/tile.h"
 #include "cc/resources/tile_priority.h"
 #include "cc/test/fake_impl_proxy.h"
 #include "cc/test/fake_layer_tree_host_impl.h"
@@ skipping 63 matching lines @@
     state.memory_limit_policy = memory_limit_policy_;
     state.tree_priority = tree_priority;
 
     global_state_ = state;
     resource_pool_->SetResourceUsageLimits(state.soft_memory_limit_in_bytes,
                                            state.soft_memory_limit_in_bytes,
                                            state.num_resources_limit);
     tile_manager_->SetGlobalStateForTesting(state);
   }
 
-  virtual void TearDown() OVERRIDE {
+  virtual void TearDown() override {
     tile_manager_.reset(NULL);
     picture_pile_ = NULL;
 
     testing::Test::TearDown();
   }
 
   // TileManagerClient implementation.
   virtual const std::vector<PictureLayerImpl*>& GetPictureLayers()
-      const OVERRIDE {
+      const override {
     return picture_layers_;
   }
-  virtual void NotifyReadyToActivate() OVERRIDE { ready_to_activate_ = true; }
-  virtual void NotifyTileStateChanged(const Tile* tile) OVERRIDE {}
+  virtual void NotifyReadyToActivate() override { ready_to_activate_ = true; }
+  virtual void NotifyTileStateChanged(const Tile* tile) override {}
   virtual void BuildRasterQueue(RasterTilePriorityQueue* queue,
-                                TreePriority priority) OVERRIDE {}
+                                TreePriority priority) override {}
   virtual void BuildEvictionQueue(EvictionTilePriorityQueue* queue,
-                                  TreePriority priority) OVERRIDE {}
+                                  TreePriority priority) override {}
 
   TileVector CreateTilesWithSize(int count,
                                  TilePriority active_priority,
                                  TilePriority pending_priority,
                                  const gfx::Size& tile_size) {
     TileVector tiles;
     for (int i = 0; i < count; ++i) {
       scoped_refptr<Tile> tile = tile_manager_->CreateTile(picture_pile_.get(),
                                                            tile_size,
                                                            gfx::Rect(),
@@ skipping 395 matching lines @@
     state.tree_priority = tree_priority;
 
     global_state_ = state;
     host_impl_.resource_pool()->SetResourceUsageLimits(
         state.soft_memory_limit_in_bytes,
         state.soft_memory_limit_in_bytes,
         state.num_resources_limit);
     host_impl_.tile_manager()->SetGlobalStateForTesting(state);
   }
 
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     InitializeRenderer();
     SetTreePriority(SAME_PRIORITY_FOR_BOTH_TREES);
   }
 
   virtual void InitializeRenderer() {
     host_impl_.InitializeRenderer(FakeOutputSurface::Create3d());
   }
 
   void SetupDefaultTrees(const gfx::Size& layer_bounds) {
     gfx::Size tile_size(100, 100);
@@ skipping 607 matching lines @@
     all_tiles.insert(queue.Top());
     ++tile_count;
     queue.Pop();
   }
   EXPECT_EQ(tile_count, all_tiles.size());
   EXPECT_EQ(17u, tile_count);
 }
 
 }  // namespace
 }  // namespace cc