Standardize usage of virtual/override/final specifiers.

content/shell/browser/shell_views.cc

 // Copyright 2013 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 "content/shell/browser/shell.h"
 
 #include "base/command_line.h"
 #include "base/strings/utf_string_conversions.h"
 #include "content/public/browser/context_factory.h"
 #include "content/public/browser/render_widget_host_view.h"
@@ skipping 39 matching lines @@
 
 namespace content {
 
 namespace {
 // ViewDelegate implementation for aura content shell
 class ShellViewsDelegateAura : public views::DesktopTestViewsDelegate {
  public:
   ShellViewsDelegateAura() : use_transparent_windows_(false) {
   }
 
-  virtual ~ShellViewsDelegateAura() {
-  }
+  ~ShellViewsDelegateAura() override {}
 
   void SetUseTransparentWindows(bool transparent) {
     use_transparent_windows_ = transparent;
   }
 
  private:
   bool use_transparent_windows_;
 
   DISALLOW_COPY_AND_ASSIGN(ShellViewsDelegateAura);
 };
 
 // Model for the "Debug" menu
 class ContextMenuModel : public ui::SimpleMenuModel,
                          public ui::SimpleMenuModel::Delegate {
  public:
   explicit ContextMenuModel(
       Shell* shell, const content::ContextMenuParams& params)
     : ui::SimpleMenuModel(this),
       shell_(shell),
       params_(params) {
     AddItem(COMMAND_OPEN_DEVTOOLS, base::ASCIIToUTF16("Inspect Element"));
   }
 
   // ui::SimpleMenuModel::Delegate:
-  virtual bool IsCommandIdChecked(int command_id) const override {
+  bool IsCommandIdChecked(int command_id) const override { return false; }
+  bool IsCommandIdEnabled(int command_id) const override { return true; }
+  bool GetAcceleratorForCommandId(int command_id,
+                                  ui::Accelerator* accelerator) override {
     return false;
   }
-  virtual bool IsCommandIdEnabled(int command_id) const override {
-    return true;
-  }
-  virtual bool GetAcceleratorForCommandId(
-      int command_id,
-      ui::Accelerator* accelerator) override { return false; }
-  virtual void ExecuteCommand(int command_id, int event_flags) override {
+  void ExecuteCommand(int command_id, int event_flags) override {
     switch (command_id) {
       case COMMAND_OPEN_DEVTOOLS:
         shell_->ShowDevToolsForElementAt(params_.x, params_.y);
         break;
     };
   }
 
  private:
   enum CommandID {
     COMMAND_OPEN_DEVTOOLS
@@ skipping 14 matching lines @@
     BACK_BUTTON,
     FORWARD_BUTTON,
     STOP_BUTTON
   };
 
   ShellWindowDelegateView(Shell* shell)
     : shell_(shell),
       toolbar_view_(new View),
       contents_view_(new View) {
   }
-  virtual ~ShellWindowDelegateView() {}
+  ~ShellWindowDelegateView() override {}
 
   // Update the state of UI controls
   void SetAddressBarURL(const GURL& url) {
     url_entry_->SetText(base::ASCIIToUTF16(url.spec()));
   }
   void SetWebContents(WebContents* web_contents, const gfx::Size& size) {
     contents_view_->SetLayoutManager(new views::FillLayout());
     web_view_ = new views::WebView(web_contents->GetBrowserContext());
     web_view_->SetWebContents(web_contents);
     web_view_->SetPreferredSize(size);
@@ skipping 160 matching lines @@
                                              ui::VKEY_BROWSER_BACK,
                                              ui::VKEY_BROWSER_FORWARD };
     for (size_t i = 0; i < arraysize(keys); ++i) {
       GetFocusManager()->RegisterAccelerator(
         ui::Accelerator(keys[i], ui::EF_NONE),
         ui::AcceleratorManager::kNormalPriority,
         this);
     }
   }
   // Overridden from TextfieldController
-  virtual void ContentsChanged(views::Textfield* sender,
-                               const base::string16& new_contents) override {
-  }
-  virtual bool HandleKeyEvent(views::Textfield* sender,
-                              const ui::KeyEvent& key_event) override {
+  void ContentsChanged(views::Textfield* sender,
+                       const base::string16& new_contents) override {}
+  bool HandleKeyEvent(views::Textfield* sender,
+                      const ui::KeyEvent& key_event) override {
    if (sender == url_entry_ && key_event.key_code() == ui::VKEY_RETURN) {
      std::string text = base::UTF16ToUTF8(url_entry_->text());
      GURL url(text);
      if (!url.has_scheme()) {
        url = GURL(std::string("http://") + std::string(text));
        url_entry_->SetText(base::ASCIIToUTF16(url.spec()));
      }
      shell_->LoadURL(url);
      return true;
    }
    return false;
   }
 
   // Overridden from ButtonListener
-  virtual void ButtonPressed(views::Button* sender,
-                             const ui::Event& event) override {
+  void ButtonPressed(views::Button* sender, const ui::Event& event) override {
     if (sender == back_button_)
       shell_->GoBackOrForward(-1);
     else if (sender == forward_button_)
       shell_->GoBackOrForward(1);
     else if (sender == refresh_button_)
       shell_->Reload();
     else if (sender == stop_button_)
       shell_->Stop();
   }
 
   // Overridden from WidgetDelegateView
-  virtual bool CanResize() const override { return true; }
-  virtual bool CanMaximize() const override { return true; }
-  virtual bool CanMinimize() const override { return true; }
-  virtual base::string16 GetWindowTitle() const override {
-    return title_;
-  }
-  virtual void WindowClosing() override {
+  bool CanResize() const override { return true; }
+  bool CanMaximize() const override { return true; }
+  bool CanMinimize() const override { return true; }
+  base::string16 GetWindowTitle() const override { return title_; }
+  void WindowClosing() override {
     if (shell_) {
       delete shell_;
       shell_ = NULL;
     }
   }
-  virtual View* GetContentsView() override { return this; }
+  View* GetContentsView() override { return this; }
 
   // Overridden from View
-  virtual gfx::Size GetMinimumSize() const override {
+  gfx::Size GetMinimumSize() const override {
     // We want to be able to make the window smaller than its initial
     // (preferred) size.
     return gfx::Size();
   }
-  virtual void ViewHierarchyChanged(
+  void ViewHierarchyChanged(
       const ViewHierarchyChangedDetails& details) override {
     if (details.is_add && details.child == this) {
       InitShellWindow();
     }
   }
 
   // Overridden from AcceleratorTarget:
-  virtual bool AcceleratorPressed(const ui::Accelerator& accelerator) override {
+  bool AcceleratorPressed(const ui::Accelerator& accelerator) override {
     switch (accelerator.key_code()) {
     case ui::VKEY_F5:
       shell_->Reload();
       return true;
     case ui::VKEY_BROWSER_BACK:
       shell_->GoBackOrForward(-1);
       return true;
     case ui::VKEY_BROWSER_FORWARD:
       shell_->GoBackOrForward(1);
       return true;
@@ skipping 185 matching lines @@
 
 void Shell::PlatformWebContentsFocused(WebContents* contents) {
   if (headless_)
     return;
   ShellWindowDelegateView* delegate_view =
     static_cast<ShellWindowDelegateView*>(window_widget_->widget_delegate());
   delegate_view->OnWebContentsFocused(contents);
 }
 
 }  // namespace content