C++11 override style change for 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/media_utils.h"
@@ skipping 34 matching lines @@
     CMD_RELOAD_IGNORE_CACHE,
     CMD_CLOSE,
     CMD_STOP,
   };
 
   explicit WebActivityController(WebActivity* owner_activity,
                                  views::WebView* web_view)
       : owner_activity_(owner_activity),
         web_view_(web_view),
         reserved_accelerator_enabled_(true) {}
-  virtual ~WebActivityController() {}
+  ~WebActivityController() override {}
 
   // Installs accelerators for web activity.
   void InstallAccelerators() {
     accelerator_manager_ = AcceleratorManager::CreateForFocusManager(
                                web_view_->GetFocusManager()).Pass();
     const AcceleratorData accelerator_data[] = {
         {TRIGGER_ON_PRESS, ui::VKEY_R, ui::EF_CONTROL_DOWN, CMD_RELOAD,
          AF_NONE},
         {TRIGGER_ON_PRESS, ui::VKEY_BROWSER_REFRESH, ui::EF_NONE, CMD_RELOAD,
          AF_NONE},
@@ skipping 32 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 {
+  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 {
+  bool OnAcceleratorFired(int command_id,
+                          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 44 matching lines @@
 
   AthenaWebView(content::WebContents* web_contents,
                 WebActivity* owner_activity)
       : views::WebView(web_contents->GetBrowserContext()),
         controller_(new WebActivityController(owner_activity, this)),
         owner_activity_(owner_activity) {
     scoped_ptr<content::WebContents> old_contents(
         SwapWebContents(scoped_ptr<content::WebContents>(web_contents)));
   }
 
-  virtual ~AthenaWebView() {}
+  ~AthenaWebView() override {}
 
   void InstallAccelerators() { controller_->InstallAccelerators(); }
 
   void EvictContent() {
     scoped_ptr<content::WebContents> old_contents(SwapWebContents(
         scoped_ptr<content::WebContents>(content::WebContents::Create(
             content::WebContents::CreateParams(browser_context())))));
     // If there is a progress bar, we need to get rid of it now since its
     // associated content, parent window and layers will disappear with evicting
     // the content.
@@ skipping 23 matching lines @@
     // being created.
     AttachWebActivityHelpers(evicted_web_contents_.get());
 
     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* OpenURLFromTab(
       content::WebContents* source,
       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;
@@ skipping 15 matching lines @@
         Activity::Show(activity);
         break;
       }
       default:
         break;
     }
     // nullptr is returned if the URL wasn't opened immediately.
     return nullptr;
   }
 
-  virtual bool CanOverscrollContent() const override {
+  bool CanOverscrollContent() const override {
     const std::string value = CommandLine::ForCurrentProcess()->
         GetSwitchValueASCII(switches::kOverscrollHistoryNavigation);
     return value != "0";
   }
 
-  virtual void OverscrollUpdate(float delta_y) override {
+  void OverscrollUpdate(float 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) /
             (kDistanceReload - kDistanceShowReloadMessage);
       }
       reload_message_->GetLayer()->SetOpacity(opacity);
     } else if (reload_message_) {
       reload_message_->Hide();
     }
   }
 
-  virtual void OverscrollComplete() override {
+  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 {
+  void AddNewContents(content::WebContents* source,
+                      content::WebContents* new_contents,
+                      WindowOpenDisposition disposition,
+                      const gfx::Rect& initial_pos,
+                      bool user_gesture,
+                      bool* was_blocked) override {
     Activity* activity =
         ActivityFactory::Get()->CreateWebActivity(new_contents);
     Activity::Show(activity);
   }
 
-  virtual bool PreHandleKeyboardEvent(
-      content::WebContents* source,
-      const content::NativeWebKeyboardEvent& event,
-      bool* is_keyboard_shortcut) override {
+  bool PreHandleKeyboardEvent(content::WebContents* source,
+                              const content::NativeWebKeyboardEvent& event,
+                              bool* is_keyboard_shortcut) override {
     return controller_->PreHandleKeyboardEvent(
         source, event, is_keyboard_shortcut);
   }
 
-  virtual void HandleKeyboardEvent(
+  void HandleKeyboardEvent(
       content::WebContents* source,
       const content::NativeWebKeyboardEvent& event) override {
     controller_->HandleKeyboardEvent(source, event);
   }
 
-  virtual void ToggleFullscreenModeForTab(content::WebContents* web_contents,
-                                          bool enter_fullscreen) override {
+  void ToggleFullscreenModeForTab(content::WebContents* web_contents,
+                                  bool enter_fullscreen) override {
     fullscreen_ = enter_fullscreen;
     GetWidget()->SetFullscreen(fullscreen_);
   }
 
-  virtual bool IsFullscreenForTabOrPending(
+  bool IsFullscreenForTabOrPending(
       const content::WebContents* web_contents) const override {
     return fullscreen_;
   }
 
-  virtual void LoadingStateChanged(content::WebContents* source,
-                                   bool to_different_document) override {
+  void LoadingStateChanged(content::WebContents* source,
+                           bool to_different_document) override {
     bool has_stopped = source == nullptr || !source->IsLoading();
     LoadProgressChanged(source, has_stopped ? 1 : 0);
   }
 
-  virtual void LoadProgressChanged(content::WebContents* source,
-                                   double progress) override {
+  void LoadProgressChanged(content::WebContents* source,
+                           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::JavaScriptDialogManager* GetJavaScriptDialogManager()
-      override {
+  content::JavaScriptDialogManager* GetJavaScriptDialogManager() override {
     NOTIMPLEMENTED();
     return nullptr;
   }
 
-  virtual content::ColorChooser* OpenColorChooser(
+  content::ColorChooser* OpenColorChooser(
       content::WebContents* web_contents,
       SkColor color,
       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 {
+  void RunFileChooser(content::WebContents* web_contents,
+                      const content::FileChooserParams& params) override {
     return athena::OpenFileChooser(web_contents, params);
   }
 
-  virtual void CloseContents(content::WebContents* contents) override {
+  void CloseContents(content::WebContents* contents) override {
     Activity::Delete(owner_activity_);
   }
 
  private:
   void CreateProgressBar() {
     CHECK(!progress_bar_);
     progress_bar_.reset(new ui::Layer(ui::LAYER_SOLID_COLOR));
     progress_bar_->SetColor(SkColorSetRGB(0x17, 0x59, 0xcd));
   }
 
@@ skipping 249 matching lines @@
   if (content_proxy_.get())
     content_proxy_.reset(nullptr);
 }
 
 void WebActivity::ShowContentProxy() {
   if (!content_proxy_.get())
     content_proxy_.reset(new ContentProxy(web_view_));
 }
 
 }  // namespace athena