replace OVERRIDE and FINAL with override and final in chrome/browser/ui/[w-z]*

chrome/browser/ui/window_sizer/window_sizer_common_unittest.cc

 // Copyright (c) 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 "chrome/browser/ui/window_sizer/window_sizer_common_unittest.h"
 
 #include "ash/wm/window_resizer.h"
 #include "base/compiler_specific.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/test/base/testing_profile.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gfx/display.h"
 #include "ui/gfx/screen.h"
 
 #if defined(USE_AURA)
 #include "ui/aura/window.h"
 #endif
 
 namespace {
 
 class TestScreen : public gfx::Screen {
  public:
   TestScreen() {}
   virtual ~TestScreen() {}
 
   // Overridden from gfx::Screen:
-  virtual bool IsDIPEnabled() OVERRIDE {
+  virtual bool IsDIPEnabled() override {
     NOTREACHED();
     return false;
   }
 
-  virtual gfx::Point GetCursorScreenPoint() OVERRIDE {
+  virtual gfx::Point GetCursorScreenPoint() override {
     NOTREACHED();
     return gfx::Point();
   }
 
-  virtual gfx::NativeWindow GetWindowUnderCursor() OVERRIDE {
+  virtual gfx::NativeWindow GetWindowUnderCursor() override {
     NOTREACHED();
     return NULL;
   }
 
   virtual gfx::NativeWindow GetWindowAtScreenPoint(const gfx::Point& point)
-      OVERRIDE {
+      override {
     NOTREACHED();
     return NULL;
   }
 
-  virtual int GetNumDisplays() const OVERRIDE {
+  virtual int GetNumDisplays() const override {
     return displays_.size();
   }
 
-  virtual std::vector<gfx::Display> GetAllDisplays() const OVERRIDE {
+  virtual std::vector<gfx::Display> GetAllDisplays() const override {
     return displays_;
   }
 
   virtual gfx::Display GetDisplayNearestWindow(
-      gfx::NativeView view) const OVERRIDE {
+      gfx::NativeView view) const override {
 #if defined(USE_AURA)
     return GetDisplayMatching(view->GetBoundsInScreen());
 #else
     NOTREACHED();
     return gfx::Display();
 #endif
   }
 
   virtual gfx::Display GetDisplayNearestPoint(
-      const gfx::Point& point) const OVERRIDE {
+      const gfx::Point& point) const override {
     NOTREACHED();
     return gfx::Display();
   }
 
   virtual gfx::Display GetDisplayMatching(
-      const gfx::Rect& match_rect) const OVERRIDE {
+      const gfx::Rect& match_rect) const override {
     int max_area = 0;
     size_t max_area_index = 0;
 
     for (size_t i = 0; i < displays_.size(); ++i) {
       gfx::Rect overlap = displays_[i].bounds();
       overlap.Intersect(match_rect);
       int area = overlap.width() * overlap.height();
       if (area > max_area) {
         max_area = area;
         max_area_index = i;
       }
     }
     return displays_[max_area_index];
   }
 
-  virtual gfx::Display GetPrimaryDisplay() const OVERRIDE {
+  virtual gfx::Display GetPrimaryDisplay() const override {
     return displays_[0];
   }
 
-  virtual void AddObserver(gfx::DisplayObserver* observer) OVERRIDE {
+  virtual void AddObserver(gfx::DisplayObserver* observer) override {
     NOTREACHED();
   }
 
-  virtual void RemoveObserver(gfx::DisplayObserver* observer) OVERRIDE {
+  virtual void RemoveObserver(gfx::DisplayObserver* observer) override {
     NOTREACHED();
   }
 
   void AddDisplay(const gfx::Rect& bounds,
                   const gfx::Rect& work_area) {
     gfx::Display display(displays_.size(), bounds);
     display.set_work_area(work_area);
     displays_.push_back(display);
   }
 
  private:
   std::vector<gfx::Display> displays_;
 
   DISALLOW_COPY_AND_ASSIGN(TestScreen);
 };
 
 class TestTargetDisplayProvider : public WindowSizer::TargetDisplayProvider {
 public:
   TestTargetDisplayProvider() {}
   virtual ~TestTargetDisplayProvider() {}
 
   virtual gfx::Display GetTargetDisplay(
       const gfx::Screen* screen,
-      const gfx::Rect& bounds) const OVERRIDE {
+      const gfx::Rect& bounds) const override {
     // On ash, the bounds is used as a indicator to specify
     // the target display.
     return screen->GetDisplayMatching(bounds);
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(TestTargetDisplayProvider);
 };
 
 }  // namespace
@@ skipping 329 matching lines @@
   { // Check that a window which hangs out of the screen get moved back in.
     gfx::Rect window_bounds;
     GetWindowBounds(p1024x768, p1024x768, gfx::Rect(), gfx::Rect(),
                     gfx::Rect(), DEFAULT, NULL,
                     gfx::Rect(1020, 700, 100, 100), &window_bounds);
     EXPECT_EQ("924,668 100x100", window_bounds.ToString());
   }
 }
 
 #endif // defined(OS_MACOSX)