replace OVERRIDE and FINAL with override and final in ui/

ui/wm/core/shadow_unittest.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 "ui/wm/core/shadow.h"
 
 #include "base/memory/scoped_ptr.h"
 #include "base/path_service.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/aura/test/aura_test_base.h"
@@ skipping 22 matching lines @@
     bitmap_large.allocPixels(
         SkImageInfo::MakeN32Premul(kLargeBitmapSize, kLargeBitmapSize));
     image_small_ = gfx::Image::CreateFrom1xBitmap(bitmap_small);
     image_large_ = gfx::Image::CreateFrom1xBitmap(bitmap_large);
   }
   virtual ~MockResourceBundleDelegate() {}
 
   // ResourceBundle::Delegate:
   virtual base::FilePath GetPathForResourcePack(
       const base::FilePath& pack_path,
-      ui::ScaleFactor scale_factor) OVERRIDE {
+      ui::ScaleFactor scale_factor) override {
     return base::FilePath();
   }
   virtual base::FilePath GetPathForLocalePack(
       const base::FilePath& pack_path,
-      const std::string& locale) OVERRIDE {
+      const std::string& locale) override {
     return base::FilePath();
   }
-  virtual gfx::Image GetImageNamed(int resource_id) OVERRIDE {
+  virtual gfx::Image GetImageNamed(int resource_id) override {
     last_resource_id_ = resource_id;
     switch (resource_id) {
       case IDR_WINDOW_BUBBLE_SHADOW_SMALL:
         return image_small_;
       case IDR_AURA_SHADOW_ACTIVE:
       case IDR_AURA_SHADOW_INACTIVE:
         return image_large_;
       default:
         NOTREACHED();
         return gfx::Image();
     }
   }
   virtual gfx::Image GetNativeImageNamed(
-      int resource_id, ui::ResourceBundle::ImageRTL rtl) OVERRIDE {
+      int resource_id, ui::ResourceBundle::ImageRTL rtl) override {
     return gfx::Image();
   }
   virtual base::RefCountedStaticMemory* LoadDataResourceBytes(
-      int resource_id, ui::ScaleFactor scale_factor) OVERRIDE {
+      int resource_id, ui::ScaleFactor scale_factor) override {
     return NULL;
   }
   virtual bool GetRawDataResource(
       int resource_id, ui::ScaleFactor scale_factor,
-      base::StringPiece* value) OVERRIDE {
+      base::StringPiece* value) override {
     return false;
   }
   virtual bool GetLocalizedString(
-      int message_id, base::string16* value) OVERRIDE {
+      int message_id, base::string16* value) override {
     return false;
   }
   virtual scoped_ptr<gfx::Font> GetFont(
-      ui::ResourceBundle::FontStyle style) OVERRIDE {
+      ui::ResourceBundle::FontStyle style) override {
     return scoped_ptr<gfx::Font>();
   }
 
   int last_resource_id() const { return last_resource_id_; }
 
  private:
   gfx::Image image_small_;
   gfx::Image image_large_;
   int last_resource_id_;
 
   DISALLOW_COPY_AND_ASSIGN(MockResourceBundleDelegate);
 };
 
 }  // namespace
 
 class ShadowTest: public aura::test::AuraTestBase {
  public:
   ShadowTest() {}
   virtual ~ShadowTest() {}
 
   MockResourceBundleDelegate* delegate() { return delegate_.get(); }
 
   // aura::testAuraBase:
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     aura::test::AuraTestBase::SetUp();
     delegate_.reset(new MockResourceBundleDelegate());
     if (ResourceBundle::HasSharedInstance())
       ui::ResourceBundle::CleanupSharedInstance();
     ui::ResourceBundle::InitSharedInstanceWithLocale(
         "en-US", delegate(), ui::ResourceBundle::LOAD_COMMON_RESOURCES);
   }
-  virtual void TearDown() OVERRIDE {
+  virtual void TearDown() override {
     ui::ResourceBundle::CleanupSharedInstance();
     base::FilePath ui_test_pak_path;
     ASSERT_TRUE(PathService::Get(ui::UI_TEST_PAK, &ui_test_pak_path));
     ui::ResourceBundle::InitSharedInstanceWithPakPath(ui_test_pak_path);
     aura::test::AuraTestBase::TearDown();
   }
  private:
   scoped_ptr<MockResourceBundleDelegate> delegate_;
   DISALLOW_COPY_AND_ASSIGN(ShadowTest);
 };
@@ skipping 19 matching lines @@
   gfx::Rect content_bounds(100, 100, 300, 300);
   shadow.SetContentBounds(content_bounds);
   EXPECT_EQ(shadow.content_bounds(), content_bounds);
   EXPECT_EQ(shadow.layer()->bounds(), gfx::Rect(36, 36, 428, 428));
 
   shadow.SetStyle(Shadow::STYLE_SMALL);
   EXPECT_EQ(shadow.content_bounds(), content_bounds);
   EXPECT_EQ(shadow.layer()->bounds(), gfx::Rect(96, 96, 308, 308));
 }
 }  // namespace wm