Standardize usage of virtual/override/final specifiers.

chrome/browser/ui/views/autofill/autofill_dialog_views.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/views/autofill/autofill_dialog_views.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/location.h"
@@ skipping 140 matching lines @@
 }
 
 // This class handles layout for the first row of a SuggestionView.
 // It exists to circumvent shortcomings of GridLayout and BoxLayout (namely that
 // the former doesn't fully respect child visibility, and that the latter won't
 // expand a single child).
 class SectionRowView : public views::View {
  public:
   SectionRowView() { SetBorder(views::Border::CreateEmptyBorder(10, 0, 0, 0)); }
 
-  virtual ~SectionRowView() {}
+  ~SectionRowView() override {}
 
   // views::View implementation:
-  virtual gfx::Size GetPreferredSize() const override {
+  gfx::Size GetPreferredSize() const override {
     int height = 0;
     int width = 0;
     for (int i = 0; i < child_count(); ++i) {
       if (child_at(i)->visible()) {
         if (width > 0)
           width += kAroundTextPadding;
 
         gfx::Size size = child_at(i)->GetPreferredSize();
         height = std::max(height, size.height());
         width += size.width();
       }
     }
 
     gfx::Insets insets = GetInsets();
     return gfx::Size(width + insets.width(), height + insets.height());
   }
 
-  virtual void Layout() override {
+  void Layout() override {
     const gfx::Rect bounds = GetContentsBounds();
 
     // Icon is left aligned.
     int start_x = bounds.x();
     views::View* icon = child_at(0);
     if (icon->visible()) {
       icon->SizeToPreferredSize();
       icon->SetX(start_x);
       icon->SetY(bounds.y() +
           (bounds.height() - icon->bounds().height()) / 2);
@@ skipping 19 matching lines @@
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(SectionRowView);
 };
 
 // A view that propagates visibility and preferred size changes.
 class LayoutPropagationView : public views::View {
  public:
   LayoutPropagationView() {}
-  virtual ~LayoutPropagationView() {}
+  ~LayoutPropagationView() override {}
 
  protected:
-  virtual void ChildVisibilityChanged(views::View* child) override {
+  void ChildVisibilityChanged(views::View* child) override {
     PreferredSizeChanged();
   }
-  virtual void ChildPreferredSizeChanged(views::View* child) override {
+  void ChildPreferredSizeChanged(views::View* child) override {
     PreferredSizeChanged();
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(LayoutPropagationView);
 };
 
 // A View for a single notification banner.
 class NotificationView : public views::View,
                          public views::ButtonListener,
@@ skipping 52 matching lines @@
 
     if (!data.tooltip_text().empty())
       AddChildView(new TooltipIcon(data.tooltip_text()));
 
     set_background(
        views::Background::CreateSolidBackground(data.GetBackgroundColor()));
     SetBorder(views::Border::CreateSolidSidedBorder(
         1, 0, 1, 0, data.GetBorderColor()));
   }
 
-  virtual ~NotificationView() {}
+  ~NotificationView() override {}
 
   views::Checkbox* checkbox() {
     return checkbox_;
   }
 
   // views::View implementation.
-  virtual gfx::Insets GetInsets() const override {
+  gfx::Insets GetInsets() const override {
     int vertical_padding = kNotificationPadding;
     if (checkbox_)
       vertical_padding -= 3;
     return gfx::Insets(vertical_padding, kDialogEdgePadding,
                        vertical_padding, kDialogEdgePadding);
   }
 
-  virtual int GetHeightForWidth(int width) const override {
+  int GetHeightForWidth(int width) const override {
     int label_width = width - GetInsets().width();
     if (child_count() > 1) {
       const views::View* tooltip_icon = child_at(1);
       label_width -= tooltip_icon->GetPreferredSize().width() +
           kDialogEdgePadding;
     }
 
     return child_at(0)->GetHeightForWidth(label_width) + GetInsets().height();
   }
 
-  virtual void Layout() override {
+  void Layout() override {
     // Surprisingly, GetContentsBounds() doesn't consult GetInsets().
     gfx::Rect bounds = GetLocalBounds();
     bounds.Inset(GetInsets());
     int right_bound = bounds.right();
 
     if (child_count() > 1) {
       // The icon takes up the entire vertical space and an extra 20px on
       // each side. This increases the hover target for the tooltip.
       views::View* tooltip_icon = child_at(1);
       gfx::Size icon_size = tooltip_icon->GetPreferredSize();
       int icon_width = icon_size.width() + kDialogEdgePadding;
       right_bound -= icon_width;
       tooltip_icon->SetBounds(
           right_bound, 0,
           icon_width + kDialogEdgePadding, GetLocalBounds().height());
     }
 
     child_at(0)->SetBounds(bounds.x(), bounds.y(),
                            right_bound - bounds.x(), bounds.height());
   }
 
   // views::ButtonListener implementation.
-  virtual void ButtonPressed(views::Button* sender,
-                             const ui::Event& event) override {
+  void ButtonPressed(views::Button* sender, const ui::Event& event) override {
     DCHECK_EQ(sender, checkbox_);
     delegate_->NotificationCheckboxStateChanged(data_.type(),
                                                 checkbox_->checked());
   }
 
   // views::StyledLabelListener implementation.
-  virtual void StyledLabelLinkClicked(const gfx::Range& range, int event_flags)
-      override {
+  void StyledLabelLinkClicked(const gfx::Range& range,
+                              int event_flags) override {
     delegate_->LinkClicked(data_.link_url());
   }
 
  private:
   // The model data for this notification.
   DialogNotification data_;
 
   // The delegate that handles interaction with |this|.
   AutofillDialogViewDelegate* delegate_;
 
@@ skipping 19 matching lines @@
     animation_.reset(new LoadingAnimation(this, font_list.GetHeight()));
 
     container_->AddChildView(new views::Label(text, font_list));
 
     for (size_t i = 0; i < 3; ++i) {
       container_->AddChildView(
           new views::Label(base::ASCIIToUTF16("."), font_list));
     }
   }
 
-  virtual ~LoadingAnimationView() {}
+  ~LoadingAnimationView() override {}
 
   // views::View implementation.
-  virtual void SetVisible(bool visible) override {
+  void SetVisible(bool visible) override {
     if (visible)
       animation_->Start();
     else
       animation_->Reset();
 
     views::View::SetVisible(visible);
   }
 
-  virtual void Layout() override {
+  void Layout() override {
     gfx::Size container_size = container_->GetPreferredSize();
     gfx::Rect container_bounds((width() - container_size.width()) / 2,
                                (height() - container_size.height()) / 2,
                                container_size.width(),
                                container_size.height());
     container_->SetBoundsRect(container_bounds);
     container_->Layout();
 
     for (size_t i = 0; i < 3; ++i) {
       views::View* dot = container_->child_at(i + 1);
       dot->SetY(dot->y() + animation_->GetCurrentValueForDot(i));
     }
   }
 
-  virtual void OnNativeThemeChanged(const ui::NativeTheme* theme) override {
+  void OnNativeThemeChanged(const ui::NativeTheme* theme) override {
     set_background(views::Background::CreateSolidBackground(
         theme->GetSystemColor(ui::NativeTheme::kColorId_DialogBackground)));
   }
 
   // gfx::AnimationDelegate implementation.
-  virtual void AnimationProgressed(const gfx::Animation* animation) override {
+  void AnimationProgressed(const gfx::Animation* animation) override {
     DCHECK_EQ(animation, animation_.get());
     Layout();
   }
 
  private:
   // Contains the "Loading" label and the dots.
   views::View* container_;
 
   scoped_ptr<LoadingAnimation> animation_;
 
   DISALLOW_COPY_AND_ASSIGN(LoadingAnimationView);
 };
 
 // Gets either the Combobox or ExpandingTextfield that is an ancestor (including
 // self) of |view|.
 views::View* GetAncestralInputView(views::View* view) {
   if (view->GetClassName() == views::Combobox::kViewClassName)
     return view;
 
   return view->GetAncestorWithClassName(ExpandingTextfield::kViewClassName);
 }
 
 // A class that informs |delegate_| when an unhandled mouse press occurs.
 class MousePressedHandler : public ui::EventHandler {
  public:
   explicit MousePressedHandler(AutofillDialogViewDelegate* delegate)
       : delegate_(delegate) {}
 
   // ui::EventHandler implementation.
-  virtual void OnMouseEvent(ui::MouseEvent* event) override {
+  void OnMouseEvent(ui::MouseEvent* event) override {
     if (event->type() == ui::ET_MOUSE_PRESSED && !event->handled())
       delegate_->FocusMoved();
   }
 
  private:
   AutofillDialogViewDelegate* const delegate_;
 
   DISALLOW_COPY_AND_ASSIGN(MousePressedHandler);
 };
 
@@ skipping 2031 matching lines @@
 AutofillDialogViews::DetailsGroup::DetailsGroup(DialogSection section)
     : section(section),
       container(NULL),
       manual_input(NULL),
       suggested_info(NULL),
       suggested_button(NULL) {}
 
 AutofillDialogViews::DetailsGroup::~DetailsGroup() {}
 
 }  // namespace autofill