Standardize usage of virtual/override/final specifiers.

ui/views/bubble/tray_bubble_view.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 "ui/views/bubble/tray_bubble_view.h"
 
 #include <algorithm>
 
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkColor.h"
@@ skipping 35 matching lines @@
 
 namespace views {
 
 namespace internal {
 
 // Detects any mouse movement. This is needed to detect mouse movements by the
 // user over the bubble if the bubble got created underneath the cursor.
 class MouseMoveDetectorHost : public MouseWatcherHost {
  public:
   MouseMoveDetectorHost();
-  virtual ~MouseMoveDetectorHost();
+  ~MouseMoveDetectorHost() override;
 
-  virtual bool Contains(const gfx::Point& screen_point,
-                        MouseEventType type) override;
+  bool Contains(const gfx::Point& screen_point, MouseEventType type) override;
+
  private:
   DISALLOW_COPY_AND_ASSIGN(MouseMoveDetectorHost);
 };
 
 MouseMoveDetectorHost::MouseMoveDetectorHost() {
 }
 
 MouseMoveDetectorHost::~MouseMoveDetectorHost() {
 }
 
@@ skipping 12 matching lines @@
       : BubbleBorder(params.arrow, params.shadow, params.arrow_color),
         owner_(owner),
         anchor_(anchor),
         tray_arrow_offset_(params.arrow_offset),
         first_item_has_no_margin_(params.first_item_has_no_margin) {
     set_alignment(params.arrow_alignment);
     set_background_color(params.arrow_color);
     set_paint_arrow(params.arrow_paint_type);
   }
 
-  virtual ~TrayBubbleBorder() {}
+  ~TrayBubbleBorder() override {}
 
   // Overridden from BubbleBorder.
   // Sets the bubble on top of the anchor when it has no arrow.
-  virtual gfx::Rect GetBounds(const gfx::Rect& position_relative_to,
-                              const gfx::Size& contents_size) const override {
+  gfx::Rect GetBounds(const gfx::Rect& position_relative_to,
+                      const gfx::Size& contents_size) const override {
     if (has_arrow(arrow())) {
       gfx::Rect rect =
           BubbleBorder::GetBounds(position_relative_to, contents_size);
       if (first_item_has_no_margin_) {
         if (arrow() == BubbleBorder::BOTTOM_RIGHT ||
             arrow() == BubbleBorder::BOTTOM_LEFT) {
           rect.set_y(rect.y() + kArrowOffsetTopBottom);
           int rtl_factor = base::i18n::IsRTL() ? -1 : 1;
           rect.set_x(rect.x() +
                      rtl_factor * kOffsetLeftRightForTopBottomOrientation);
@@ skipping 62 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(TrayBubbleBorder);
 };
 
 // This mask layer clips the bubble's content so that it does not overwrite the
 // rounded bubble corners.
 // TODO(miket): This does not work on Windows. Implement layer masking or
 // alternate solutions if the TrayBubbleView is needed there in the future.
 class TrayBubbleContentMask : public ui::LayerDelegate {
  public:
   explicit TrayBubbleContentMask(int corner_radius);
-  virtual ~TrayBubbleContentMask();
+  ~TrayBubbleContentMask() override;
 
   ui::Layer* layer() { return &layer_; }
 
   // Overridden from LayerDelegate.
-  virtual void OnPaintLayer(gfx::Canvas* canvas) override;
-  virtual void OnDelegatedFrameDamage(
-      const gfx::Rect& damage_rect_in_dip) override {}
-  virtual void OnDeviceScaleFactorChanged(float device_scale_factor) override;
-  virtual base::Closure PrepareForLayerBoundsChange() override;
+  void OnPaintLayer(gfx::Canvas* canvas) override;
+  void OnDelegatedFrameDamage(const gfx::Rect& damage_rect_in_dip) override {}
+  void OnDeviceScaleFactorChanged(float device_scale_factor) override;
+  base::Closure PrepareForLayerBoundsChange() override;
 
  private:
   ui::Layer layer_;
   int corner_radius_;
 
   DISALLOW_COPY_AND_ASSIGN(TrayBubbleContentMask);
 };
 
 TrayBubbleContentMask::TrayBubbleContentMask(int corner_radius)
     : layer_(ui::LAYER_TEXTURED),
@@ skipping 24 matching lines @@
 
 // Custom layout for the bubble-view. Does the default box-layout if there is
 // enough height. Otherwise, makes sure the bottom rows are visible.
 class BottomAlignedBoxLayout : public BoxLayout {
  public:
   explicit BottomAlignedBoxLayout(TrayBubbleView* bubble_view)
       : BoxLayout(BoxLayout::kVertical, 0, 0, 0),
         bubble_view_(bubble_view) {
   }
 
-  virtual ~BottomAlignedBoxLayout() {}
+  ~BottomAlignedBoxLayout() override {}
 
  private:
-  virtual void Layout(View* host) override {
+  void Layout(View* host) override {
     if (host->height() >= host->GetPreferredSize().height() ||
         !bubble_view_->is_gesture_dragging()) {
       BoxLayout::Layout(host);
       return;
     }
 
     int consumed_height = 0;
     for (int i = host->child_count() - 1;
         i >= 0 && consumed_height < host->height(); --i) {
       View* child = host->child_at(i);
@@ skipping 251 matching lines @@
 void TrayBubbleView::ViewHierarchyChanged(
     const ViewHierarchyChangedDetails& details) {
   if (details.is_add && details.child == this) {
     details.parent->SetPaintToLayer(true);
     details.parent->SetFillsBoundsOpaquely(true);
     details.parent->layer()->SetMasksToBounds(true);
   }
 }
 
 }  // namespace views