Standardize usage of virtual/override/final specifiers.

chrome/browser/ui/views/tabs/tab.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/tabs/tab.h"
 
 #include <limits>
 
 #include "base/command_line.h"
 #include "base/debug/alias.h"
@@ skipping 181 matching lines @@
 // FaviconCrashAnimation
 //
 //  A custom animation subclass to manage the favicon crash animation.
 class Tab::FaviconCrashAnimation : public gfx::LinearAnimation,
                                    public gfx::AnimationDelegate {
  public:
   explicit FaviconCrashAnimation(Tab* target)
       : gfx::LinearAnimation(1000, 25, this),
         target_(target) {
   }
-  virtual ~FaviconCrashAnimation() {}
+  ~FaviconCrashAnimation() override {}
 
   // gfx::Animation overrides:
-  virtual void AnimateToState(double state) override {
+  void AnimateToState(double state) override {
     const double kHidingOffset = 27;
 
     if (state < .5) {
       target_->SetFaviconHidingOffset(
           static_cast<int>(floor(kHidingOffset * 2.0 * state)));
     } else {
       target_->DisplayCrashedFavicon();
       target_->SetFaviconHidingOffset(
           static_cast<int>(
               floor(kHidingOffset - ((state - .5) * 2.0 * kHidingOffset))));
     }
   }
 
   // gfx::AnimationDelegate overrides:
-  virtual void AnimationCanceled(const gfx::Animation* animation) override {
+  void AnimationCanceled(const gfx::Animation* animation) override {
     target_->SetFaviconHidingOffset(0);
   }
 
  private:
   Tab* target_;
 
   DISALLOW_COPY_AND_ASSIGN(FaviconCrashAnimation);
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 // TabCloseButton
 //
 //  This is a Button subclass that causes middle clicks to be forwarded to the
 //  parent View by explicitly not handling them in OnMousePressed.
 class Tab::TabCloseButton : public views::ImageButton,
                             public views::MaskedTargeterDelegate {
  public:
   explicit TabCloseButton(Tab* tab)
       : views::ImageButton(tab),
         tab_(tab) {
     SetEventTargeter(
         scoped_ptr<views::ViewTargeter>(new views::ViewTargeter(this)));
   }
 
-  virtual ~TabCloseButton() {}
+  ~TabCloseButton() override {}
 
   // views::View:
-  virtual View* GetTooltipHandlerForPoint(const gfx::Point& point) override {
+  View* GetTooltipHandlerForPoint(const gfx::Point& point) override {
     // Tab close button has no children, so tooltip handler should be the same
     // as the event handler.
     // In addition, a hit test has to be performed for the point (as
     // GetTooltipHandlerForPoint() is responsible for it).
     if (!HitTestPoint(point))
       return NULL;
     return GetEventHandlerForPoint(point);
   }
 
-  virtual bool OnMousePressed(const ui::MouseEvent& event) override {
+  bool OnMousePressed(const ui::MouseEvent& event) override {
     tab_->controller_->OnMouseEventInTab(this, event);
 
     bool handled = ImageButton::OnMousePressed(event);
     // Explicitly mark midle-mouse clicks as non-handled to ensure the tab
     // sees them.
     return event.IsOnlyMiddleMouseButton() ? false : handled;
   }
 
-  virtual void OnMouseMoved(const ui::MouseEvent& event) override {
+  void OnMouseMoved(const ui::MouseEvent& event) override {
     tab_->controller_->OnMouseEventInTab(this, event);
     CustomButton::OnMouseMoved(event);
   }
 
-  virtual void OnMouseReleased(const ui::MouseEvent& event) override {
+  void OnMouseReleased(const ui::MouseEvent& event) override {
     tab_->controller_->OnMouseEventInTab(this, event);
     CustomButton::OnMouseReleased(event);
   }
 
-  virtual void OnGestureEvent(ui::GestureEvent* event) override {
+  void OnGestureEvent(ui::GestureEvent* event) override {
     // Consume all gesture events here so that the parent (Tab) does not
     // start consuming gestures.
     ImageButton::OnGestureEvent(event);
     event->SetHandled();
   }
 
-  virtual const char* GetClassName() const override {
-    return kTabCloseButtonName;
-  }
+  const char* GetClassName() const override { return kTabCloseButtonName; }
 
  private:
   // Returns the rectangular bounds of parent tab's visible region in the
   // local coordinate space of |this|.
   gfx::Rect GetTabBounds() const {
     gfx::Path tab_mask;
     tab_->GetHitTestMask(&tab_mask);
 
     gfx::RectF tab_bounds_f(gfx::SkRectToRectF(tab_mask.getBounds()));
     views::View::ConvertRectToTarget(tab_, this, &tab_bounds_f);
@@ skipping 12 matching lines @@
     int bottom_overflow = button_bounds.bottom() - tab_bounds.bottom();
     if (top_overflow > 0)
       button_bounds.set_y(tab_bounds.y());
     else if (bottom_overflow > 0)
       button_bounds.set_height(button_bounds.height() - bottom_overflow);
 
     return button_bounds;
   }
 
   // views::ViewTargeterDelegate:
-  virtual View* TargetForRect(View* root, const gfx::Rect& rect) override {
+  View* TargetForRect(View* root, const gfx::Rect& rect) override {
     CHECK_EQ(root, this);
 
     if (!views::UsePointBasedTargeting(rect))
       return ViewTargeterDelegate::TargetForRect(root, rect);
 
     // Ignore the padding set on the button.
     gfx::Rect contents_bounds = GetContentsBounds();
     contents_bounds.set_x(GetMirroredXForRect(contents_bounds));
 
     // Include the padding in hit-test for touch events.
     if (aura::Env::GetInstance()->is_touch_down())
       contents_bounds = GetLocalBounds();
 
     return contents_bounds.Intersects(rect) ? this : parent();
   }
 
   // views:MaskedTargeterDelegate:
-  virtual bool GetHitTestMask(gfx::Path* mask) const override {
+  bool GetHitTestMask(gfx::Path* mask) const override {
     DCHECK(mask);
     mask->reset();
 
     // The parent tab may be partially occluded by another tab if we are
     // in stacked tab mode, which means that the tab close button may also
     // be partially occluded. Define the hit test mask of the tab close
     // button to be the intersection of the parent tab's visible bounds
     // and the bounds of the tab close button.
     gfx::Rect tab_bounds(GetTabBounds());
     gfx::Rect button_bounds(GetTabCloseButtonBounds(tab_bounds));
     gfx::Rect intersection(gfx::IntersectRects(tab_bounds, button_bounds));
 
     if (!intersection.IsEmpty()) {
       mask->addRect(RectToSkRect(intersection));
       return true;
     }
 
     return false;
   }
 
-  virtual bool DoesIntersectRect(const View* target,
-                                 const gfx::Rect& rect) const override {
+  bool DoesIntersectRect(const View* target,
+                         const gfx::Rect& rect) const override {
     CHECK_EQ(target, this);
 
     // If the request is not made in response to a gesture, use the
     // default implementation.
     if (views::UsePointBasedTargeting(rect))
       return MaskedTargeterDelegate::DoesIntersectRect(target, rect);
 
     // The hit test request is in response to a gesture. Return false if any
     // part of the tab close button is hidden from the user.
     // TODO(tdanderson): Consider always returning the intersection if the
@@ skipping 1225 matching lines @@
                          const gfx::ImageSkia& image) {
   DCHECK_NE(scale_factor, ui::SCALE_FACTOR_NONE);
   ImageCacheEntry entry;
   entry.resource_id = resource_id;
   entry.scale_factor = scale_factor;
   entry.image = image;
   image_cache_->push_front(entry);
   if (image_cache_->size() > kMaxImageCacheSize)
     image_cache_->pop_back();
 }