replace OVERRIDE and FINAL with override and final in athena/

athena/content/web_activity.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 "athena/content/web_activity.h"
 
 #include "athena/activity/public/activity_factory.h"
 #include "athena/activity/public/activity_manager.h"
 #include "athena/content/content_proxy.h"
 #include "athena/content/public/dialogs.h"
@@ skipping 83 matching lines @@
   }
 
   void HandleKeyboardEvent(content::WebContents* source,
                            const content::NativeWebKeyboardEvent& event) {
     unhandled_keyboard_event_handler_.HandleKeyboardEvent(
         event, web_view_->GetFocusManager());
   }
 
  private:
   // AcceleratorHandler:
-  virtual bool IsCommandEnabled(int command_id) const OVERRIDE {
+  virtual bool IsCommandEnabled(int command_id) const override {
     switch (command_id) {
       case CMD_RELOAD:
       case CMD_RELOAD_IGNORE_CACHE:
         return true;
       case CMD_BACK:
         return web_view_->GetWebContents()->GetController().CanGoBack();
       case CMD_FORWARD:
         return web_view_->GetWebContents()->GetController().CanGoForward();
       case CMD_CLOSE:
         // TODO(oshima): check onbeforeunload handler.
         return true;
       case CMD_STOP:
         return web_view_->GetWebContents()->IsLoading();
     }
     return false;
   }
 
   virtual bool OnAcceleratorFired(int command_id,
-                                  const ui::Accelerator& accelerator) OVERRIDE {
+                                  const ui::Accelerator& accelerator) override {
     switch (command_id) {
       case CMD_RELOAD:
         web_view_->GetWebContents()->GetController().Reload(false);
         return true;
       case CMD_RELOAD_IGNORE_CACHE:
         web_view_->GetWebContents()->GetController().ReloadIgnoringCache(false);
         return true;
       case CMD_BACK:
         web_view_->GetWebContents()->GetController().GoBack();
         return true;
@@ skipping 85 matching lines @@
 
     SwapWebContents(evicted_web_contents_.Pass());
   }
 
   // Check if the content got evicted.
   const bool IsContentEvicted() { return !!evicted_web_contents_.get(); }
 
   // content::WebContentsDelegate:
   virtual content::WebContents* OpenURLFromTab(
       content::WebContents* source,
-      const content::OpenURLParams& params) OVERRIDE {
+      const content::OpenURLParams& params) override {
     switch(params.disposition) {
       case CURRENT_TAB: {
         DCHECK(source == web_contents());
         content::NavigationController::LoadURLParams load_url_params(
             params.url);
         load_url_params.referrer = params.referrer;
         load_url_params.frame_tree_node_id = params.frame_tree_node_id;
         load_url_params.transition_type = params.transition;
         load_url_params.extra_headers = params.extra_headers;
         load_url_params.should_replace_current_entry =
@@ skipping 13 matching lines @@
         Activity::Show(activity);
         break;
       }
       default:
         break;
     }
     // NULL is returned if the URL wasn't opened immediately.
     return NULL;
   }
 
-  virtual bool CanOverscrollContent() const OVERRIDE {
+  virtual bool CanOverscrollContent() const override {
     const std::string value = CommandLine::ForCurrentProcess()->
         GetSwitchValueASCII(switches::kOverscrollHistoryNavigation);
     return value != "0";
   }
 
-  virtual void OverscrollUpdate(int delta_y) OVERRIDE {
+  virtual void OverscrollUpdate(int delta_y) override {
     overscroll_y_ = delta_y;
     if (overscroll_y_ > kDistanceShowReloadMessage) {
       if (!reload_message_)
         CreateReloadMessage();
       reload_message_->Show();
       float opacity = 1.0f;
       if (overscroll_y_ < kDistanceReload) {
         opacity =
             (overscroll_y_ - kDistanceShowReloadMessage) /
             static_cast<float>(kDistanceReload - kDistanceShowReloadMessage);
       }
       reload_message_->GetLayer()->SetOpacity(opacity);
     } else if (reload_message_) {
       reload_message_->Hide();
     }
   }
 
-  virtual void OverscrollComplete() OVERRIDE {
+  virtual void OverscrollComplete() override {
     if (overscroll_y_ >= kDistanceReload)
       GetWebContents()->GetController().Reload(false);
     if (reload_message_)
       reload_message_->Hide();
     overscroll_y_ = 0;
   }
 
   virtual void AddNewContents(content::WebContents* source,
                               content::WebContents* new_contents,
                               WindowOpenDisposition disposition,
                               const gfx::Rect& initial_pos,
                               bool user_gesture,
-                              bool* was_blocked) OVERRIDE {
+                              bool* was_blocked) override {
     // TODO(oshima): Use factory.
     ActivityManager::Get()->AddActivity(
         new WebActivity(new AthenaWebView(new_contents)));
   }
 
   virtual bool PreHandleKeyboardEvent(
       content::WebContents* source,
       const content::NativeWebKeyboardEvent& event,
-      bool* is_keyboard_shortcut) OVERRIDE {
+      bool* is_keyboard_shortcut) override {
     return controller_->PreHandleKeyboardEvent(
         source, event, is_keyboard_shortcut);
   }
 
   virtual void HandleKeyboardEvent(
       content::WebContents* source,
-      const content::NativeWebKeyboardEvent& event) OVERRIDE {
+      const content::NativeWebKeyboardEvent& event) override {
     controller_->HandleKeyboardEvent(source, event);
   }
 
   virtual void ToggleFullscreenModeForTab(content::WebContents* web_contents,
-                                          bool enter_fullscreen) OVERRIDE {
+                                          bool enter_fullscreen) override {
     fullscreen_ = enter_fullscreen;
     GetWidget()->SetFullscreen(fullscreen_);
   }
 
   virtual bool IsFullscreenForTabOrPending(
-      const content::WebContents* web_contents) const OVERRIDE {
+      const content::WebContents* web_contents) const override {
     return fullscreen_;
   }
 
   virtual void LoadingStateChanged(content::WebContents* source,
-                                   bool to_different_document) OVERRIDE {
+                                   bool to_different_document) override {
     bool has_stopped = source == NULL || !source->IsLoading();
     LoadProgressChanged(source, has_stopped ? 1 : 0);
   }
 
   virtual void LoadProgressChanged(content::WebContents* source,
-                                   double progress) OVERRIDE {
+                                   double progress) override {
     if (!progress)
       return;
 
     if (!progress_bar_) {
       CreateProgressBar();
       source->GetNativeView()->layer()->Add(progress_bar_.get());
     }
     progress_bar_->SetBounds(gfx::Rect(
         0, 0, progress * progress_bar_->parent()->bounds().width(), 3));
     if (progress < 1)
       return;
 
     ui::ScopedLayerAnimationSettings settings(progress_bar_->GetAnimator());
     settings.SetTweenType(gfx::Tween::EASE_IN);
     ui::Layer* layer = progress_bar_.get();
     settings.AddObserver(new ui::ClosureAnimationObserver(
         base::Bind(&base::DeletePointer<ui::Layer>, progress_bar_.release())));
     layer->SetOpacity(0.f);
   }
 
   virtual content::ColorChooser* OpenColorChooser(
       content::WebContents* web_contents,
       SkColor color,
-      const std::vector<content::ColorSuggestion>& suggestions) OVERRIDE {
+      const std::vector<content::ColorSuggestion>& suggestions) override {
     return athena::OpenColorChooser(web_contents, color, suggestions);
   }
 
   // Called when a file selection is to be done.
   virtual void RunFileChooser(
       content::WebContents* web_contents,
-      const content::FileChooserParams& params) OVERRIDE {
+      const content::FileChooserParams& params) override {
     return athena::OpenFileChooser(web_contents, params);
   }
 
  private:
   void CreateProgressBar() {
     CHECK(!progress_bar_);
     progress_bar_.reset(new ui::Layer(ui::LAYER_SOLID_COLOR));
     progress_bar_->SetColor(SkColorSetRGB(0x17, 0x59, 0xcd));
   }
 
@@ skipping 245 matching lines @@
   if (content_proxy_.get())
     content_proxy_.reset(NULL);
 }
 
 void WebActivity::ShowContentProxy() {
   if (!content_proxy_.get())
     content_proxy_.reset(new ContentProxy(web_view_));
 }
 
 }  // namespace athena