replace OVERRIDE and FINAL with override and final in ui/

ui/ozone/platform/dri/ozone_platform_gbm.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/ozone/platform/dri/ozone_platform_gbm.h"
 
 #include <dlfcn.h>
 #include <gbm.h>
 #include <stdlib.h>
 
@@ skipping 39 matching lines @@
       LOG(FATAL) << "Unable to initialize gbm for " << kDefaultGraphicsCardPath;
   }
   virtual ~GbmBufferGenerator() {
     gbm_device_destroy(device_);
     if (glapi_lib_)
       dlclose(glapi_lib_);
   }
 
   gbm_device* device() const { return device_; }
 
-  virtual scoped_refptr<ScanoutBuffer> Create(const gfx::Size& size) OVERRIDE {
+  virtual scoped_refptr<ScanoutBuffer> Create(const gfx::Size& size) override {
     return GbmBuffer::CreateBuffer(
         dri_, device_, SurfaceFactoryOzone::RGBA_8888, size, true);
   }
 
  protected:
   DriWrapper* dri_;  // Not owned.
 
   // HACK: gbm drivers have broken linkage
   void *glapi_lib_;
 
   gbm_device* device_;
 
   DISALLOW_COPY_AND_ASSIGN(GbmBufferGenerator);
 };
 
 class OzonePlatformGbm : public OzonePlatform {
  public:
   OzonePlatformGbm(bool use_surfaceless) : use_surfaceless_(use_surfaceless) {
     base::AtExitManager::RegisterTask(
         base::Bind(&base::DeletePointer<OzonePlatformGbm>, this));
   }
   virtual ~OzonePlatformGbm() {}
 
   // OzonePlatform:
-  virtual ui::SurfaceFactoryOzone* GetSurfaceFactoryOzone() OVERRIDE {
+  virtual ui::SurfaceFactoryOzone* GetSurfaceFactoryOzone() override {
     return surface_factory_ozone_.get();
   }
-  virtual CursorFactoryOzone* GetCursorFactoryOzone() OVERRIDE {
+  virtual CursorFactoryOzone* GetCursorFactoryOzone() override {
     return cursor_factory_ozone_.get();
   }
-  virtual GpuPlatformSupport* GetGpuPlatformSupport() OVERRIDE {
+  virtual GpuPlatformSupport* GetGpuPlatformSupport() override {
     return gpu_platform_support_.get();
   }
-  virtual GpuPlatformSupportHost* GetGpuPlatformSupportHost() OVERRIDE {
+  virtual GpuPlatformSupportHost* GetGpuPlatformSupportHost() override {
     return gpu_platform_support_host_.get();
   }
   virtual scoped_ptr<PlatformWindow> CreatePlatformWindow(
       PlatformWindowDelegate* delegate,
-      const gfx::Rect& bounds) OVERRIDE {
+      const gfx::Rect& bounds) override {
     scoped_ptr<DriWindow> platform_window(
         new DriWindow(delegate,
                       bounds,
                       gpu_platform_support_host_.get(),
                       event_factory_ozone_.get(),
                       window_manager_.get()));
     platform_window->Initialize();
     return platform_window.PassAs<PlatformWindow>();
   }
   virtual scoped_ptr<NativeDisplayDelegate> CreateNativeDisplayDelegate()
-      OVERRIDE {
+      override {
     return scoped_ptr<NativeDisplayDelegate>(new NativeDisplayDelegateProxy(
         gpu_platform_support_host_.get(), device_manager_.get()));
   }
-  virtual void InitializeUI() OVERRIDE {
+  virtual void InitializeUI() override {
     vt_manager_.reset(new VirtualTerminalManager());
     // Needed since the browser process creates the accelerated widgets and that
     // happens through SFO.
     surface_factory_ozone_.reset(new GbmSurfaceFactory(use_surfaceless_));
     device_manager_ = CreateDeviceManager();
     gpu_platform_support_host_.reset(new DriGpuPlatformSupportHost());
     cursor_factory_ozone_.reset(new BitmapCursorFactoryOzone);
     window_manager_.reset(
         new DriWindowManager(gpu_platform_support_host_.get()));
     event_factory_ozone_.reset(new EventFactoryEvdev(window_manager_->cursor(),
                                                      device_manager_.get()));
   }
 
-  virtual void InitializeGPU() OVERRIDE {
+  virtual void InitializeGPU() override {
     dri_.reset(new DriWrapper(kDefaultGraphicsCardPath));
     dri_->Initialize();
     buffer_generator_.reset(new GbmBufferGenerator(dri_.get()));
     screen_manager_.reset(new ScreenManager(dri_.get(),
                                             buffer_generator_.get()));
     window_delegate_manager_.reset(new DriWindowDelegateManager());
     if (!surface_factory_ozone_)
       surface_factory_ozone_.reset(new GbmSurfaceFactory(use_surfaceless_));
 
     surface_factory_ozone_->InitializeGpu(dri_.get(),
@@ skipping 34 matching lines @@
 };
 
 }  // namespace
 
 OzonePlatform* CreateOzonePlatformGbm() {
   CommandLine* cmd = CommandLine::ForCurrentProcess();
   return new OzonePlatformGbm(cmd->HasSwitch(switches::kOzoneUseSurfaceless));
 }
 
 }  // namespace ui