Standardize usage of virtual/override/final specifiers.

ui/aura/window_unittest.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/aura/window.h"
 
 #include <string>
 #include <utility>
 #include <vector>
 
@@ skipping 37 matching lines @@
 DECLARE_WINDOW_PROPERTY_TYPE(int)
 
 namespace aura {
 namespace test {
 
 class WindowTest : public AuraTestBase {
  public:
   WindowTest() : max_separation_(0) {
   }
 
-  virtual void SetUp() override {
+  void SetUp() override {
     AuraTestBase::SetUp();
     // TODO: there needs to be an easier way to do this.
     max_separation_ = ui::GestureConfiguration::
         max_separation_for_gesture_touches_in_pixels();
     ui::GestureConfiguration::
         set_max_separation_for_gesture_touches_in_pixels(0);
   }
 
-  virtual void TearDown() override {
+  void TearDown() override {
     AuraTestBase::TearDown();
     ui::GestureConfiguration::
         set_max_separation_for_gesture_touches_in_pixels(max_separation_);
   }
 
  private:
   float max_separation_;
 
   DISALLOW_COPY_AND_ASSIGN(WindowTest);
 };
 
 namespace {
 
 // Used for verifying destruction methods are invoked.
 class DestroyTrackingDelegateImpl : public TestWindowDelegate {
  public:
   DestroyTrackingDelegateImpl()
       : destroying_count_(0),
         destroyed_count_(0),
         in_destroying_(false) {}
 
   void clear_destroying_count() { destroying_count_ = 0; }
   int destroying_count() const { return destroying_count_; }
 
   void clear_destroyed_count() { destroyed_count_ = 0; }
   int destroyed_count() const { return destroyed_count_; }
 
   bool in_destroying() const { return in_destroying_; }
 
-  virtual void OnWindowDestroying(Window* window) override {
+  void OnWindowDestroying(Window* window) override {
     EXPECT_FALSE(in_destroying_);
     in_destroying_ = true;
     destroying_count_++;
   }
 
-  virtual void OnWindowDestroyed(Window* window) override {
+  void OnWindowDestroyed(Window* window) override {
     EXPECT_TRUE(in_destroying_);
     in_destroying_ = false;
     destroyed_count_++;
   }
 
  private:
   int destroying_count_;
   int destroyed_count_;
   bool in_destroying_;
 
   DISALLOW_COPY_AND_ASSIGN(DestroyTrackingDelegateImpl);
 };
 
 // Used to verify that when OnWindowDestroying is invoked the parent is also
 // is in the process of being destroyed.
 class ChildWindowDelegateImpl : public DestroyTrackingDelegateImpl {
  public:
   explicit ChildWindowDelegateImpl(
       DestroyTrackingDelegateImpl* parent_delegate)
       : parent_delegate_(parent_delegate) {
   }
 
-  virtual void OnWindowDestroying(Window* window) override {
+  void OnWindowDestroying(Window* window) override {
     EXPECT_TRUE(parent_delegate_->in_destroying());
     DestroyTrackingDelegateImpl::OnWindowDestroying(window);
   }
 
  private:
   DestroyTrackingDelegateImpl* parent_delegate_;
 
   DISALLOW_COPY_AND_ASSIGN(ChildWindowDelegateImpl);
 };
 
 // Used to verify that a Window is removed from its parent when
 // OnWindowDestroyed is called.
 class DestroyOrphanDelegate : public TestWindowDelegate {
  public:
   DestroyOrphanDelegate() : window_(NULL) {
   }
 
   void set_window(Window* window) { window_ = window; }
 
-  virtual void OnWindowDestroyed(Window* window) override {
+  void OnWindowDestroyed(Window* window) override {
     EXPECT_FALSE(window_->parent());
   }
 
  private:
   Window* window_;
   DISALLOW_COPY_AND_ASSIGN(DestroyOrphanDelegate);
 };
 
 // Used in verifying mouse capture.
 class CaptureWindowDelegateImpl : public TestWindowDelegate {
@@ skipping 11 matching lines @@
   }
 
   int capture_changed_event_count() const {
     return capture_changed_event_count_;
   }
   int capture_lost_count() const { return capture_lost_count_; }
   int mouse_event_count() const { return mouse_event_count_; }
   int touch_event_count() const { return touch_event_count_; }
   int gesture_event_count() const { return gesture_event_count_; }
 
-  virtual void OnMouseEvent(ui::MouseEvent* event) override {
+  void OnMouseEvent(ui::MouseEvent* event) override {
     if (event->type() == ui::ET_MOUSE_CAPTURE_CHANGED)
       capture_changed_event_count_++;
     mouse_event_count_++;
   }
-  virtual void OnTouchEvent(ui::TouchEvent* event) override {
-    touch_event_count_++;
-  }
-  virtual void OnGestureEvent(ui::GestureEvent* event) override {
+  void OnTouchEvent(ui::TouchEvent* event) override { touch_event_count_++; }
+  void OnGestureEvent(ui::GestureEvent* event) override {
     gesture_event_count_++;
   }
-  virtual void OnCaptureLost() override {
-    capture_lost_count_++;
-  }
+  void OnCaptureLost() override { capture_lost_count_++; }
 
  private:
   int capture_changed_event_count_;
   int capture_lost_count_;
   int mouse_event_count_;
   int touch_event_count_;
   int gesture_event_count_;
 
   DISALLOW_COPY_AND_ASSIGN(CaptureWindowDelegateImpl);
 };
 
 // Keeps track of the location of the gesture.
 class GestureTrackPositionDelegate : public TestWindowDelegate {
  public:
   GestureTrackPositionDelegate() {}
 
-  virtual void OnGestureEvent(ui::GestureEvent* event) override {
+  void OnGestureEvent(ui::GestureEvent* event) override {
     position_ = event->location();
     event->StopPropagation();
   }
 
   const gfx::Point& position() const { return position_; }
 
  private:
   gfx::Point position_;
 
   DISALLOW_COPY_AND_ASSIGN(GestureTrackPositionDelegate);
 };
 
 base::TimeDelta getTime() {
   return ui::EventTimeForNow();
 }
 
 class SelfEventHandlingWindowDelegate : public TestWindowDelegate {
  public:
   SelfEventHandlingWindowDelegate() {}
 
-  virtual bool ShouldDescendIntoChildForEventHandling(
+  bool ShouldDescendIntoChildForEventHandling(
       Window* child,
       const gfx::Point& location) override {
     return false;
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(SelfEventHandlingWindowDelegate);
 };
 
 // The delegate deletes itself when the window is being destroyed.
 class DestroyWindowDelegate : public TestWindowDelegate {
  public:
   DestroyWindowDelegate() {}
 
  private:
-  virtual ~DestroyWindowDelegate() {}
+  ~DestroyWindowDelegate() override {}
 
   // Overridden from WindowDelegate.
-  virtual void OnWindowDestroyed(Window* window) override {
-    delete this;
-  }
+  void OnWindowDestroyed(Window* window) override { delete this; }
 
   DISALLOW_COPY_AND_ASSIGN(DestroyWindowDelegate);
 };
 
 }  // namespace
 
 TEST_F(WindowTest, GetChildById) {
   scoped_ptr<Window> w1(CreateTestWindowWithId(1, root_window()));
   scoped_ptr<Window> w11(CreateTestWindowWithId(11, w1.get()));
   scoped_ptr<Window> w111(CreateTestWindowWithId(111, w11.get()));
@@ skipping 308 matching lines @@
   EXPECT_TRUE(w1->GetToplevelWindow() == NULL);
   EXPECT_EQ(w11.get(), w11->GetToplevelWindow());
   EXPECT_EQ(w11.get(), w111->GetToplevelWindow());
   EXPECT_EQ(w11.get(), w1111->GetToplevelWindow());
 }
 
 class AddedToRootWindowObserver : public WindowObserver {
  public:
   AddedToRootWindowObserver() : called_(false) {}
 
-  virtual void OnWindowAddedToRootWindow(Window* window) override {
-    called_ = true;
-  }
+  void OnWindowAddedToRootWindow(Window* window) override { called_ = true; }
 
   bool called() const { return called_; }
 
  private:
   bool called_;
 
   DISALLOW_COPY_AND_ASSIGN(AddedToRootWindowObserver);
 };
 
 TEST_F(WindowTest, WindowAddedToRootWindowShouldNotifyChildAndNotParent) {
@@ skipping 488 matching lines @@
   // The |child| window is moved to the 0,0 in screen coordinates.
   // |GetBoundsInRootWindow()| should return 0,0.
   child->SetBounds(gfx::Rect(100, 100, 100, 100));
   EXPECT_EQ("0,0 100x100", child->GetBoundsInRootWindow().ToString());
 }
 
 class MouseEnterExitWindowDelegate : public TestWindowDelegate {
  public:
   MouseEnterExitWindowDelegate() : entered_(false), exited_(false) {}
 
-  virtual void OnMouseEvent(ui::MouseEvent* event) override {
+  void OnMouseEvent(ui::MouseEvent* event) override {
     switch (event->type()) {
       case ui::ET_MOUSE_ENTERED:
         EXPECT_TRUE(event->flags() & ui::EF_IS_SYNTHESIZED);
         entered_ = true;
         break;
       case ui::ET_MOUSE_EXITED:
         EXPECT_TRUE(event->flags() & ui::EF_IS_SYNTHESIZED);
         exited_ = true;
         break;
       default:
@@ skipping 264 matching lines @@
         hidden_(0) {
   }
 
   int shown() const { return shown_; }
   int hidden() const { return hidden_; }
   void Clear() {
     shown_ = 0;
     hidden_ = 0;
   }
 
-  virtual void OnWindowTargetVisibilityChanged(bool visible) override {
+  void OnWindowTargetVisibilityChanged(bool visible) override {
     if (visible)
       shown_++;
     else
       hidden_++;
   }
 
  private:
   int shown_;
   int hidden_;
 
@@ skipping 282 matching lines @@
     int changed_count;
   };
 
   WindowObserverTest()
       : added_count_(0),
         removed_count_(0),
         destroyed_count_(0),
         old_property_value_(-3) {
   }
 
-  virtual ~WindowObserverTest() {}
+  ~WindowObserverTest() override {}
 
   const VisibilityInfo* GetVisibilityInfo() const {
     return visibility_info_.get();
   }
 
   void ResetVisibilityInfo() {
     visibility_info_.reset();
   }
 
   // Returns a description of the WindowObserver methods that have been invoked.
@@ skipping 25 matching lines @@
             transform_notifications_.begin();
         it != transform_notifications_.end();
         ++it) {
       base::StringAppendF(&result, "(%d,%d)", it->first, it->second);
     }
     transform_notifications_.clear();
     return result;
   }
 
  private:
-  virtual void OnWindowAdded(Window* new_window) override {
-    added_count_++;
-  }
+  void OnWindowAdded(Window* new_window) override { added_count_++; }
 
-  virtual void OnWillRemoveWindow(Window* window) override {
-    removed_count_++;
-  }
+  void OnWillRemoveWindow(Window* window) override { removed_count_++; }
 
-  virtual void OnWindowVisibilityChanged(Window* window,
-                                         bool visible) override {
+  void OnWindowVisibilityChanged(Window* window, bool visible) override {
     if (!visibility_info_) {
       visibility_info_.reset(new VisibilityInfo);
       visibility_info_->changed_count = 0;
     }
     visibility_info_->window_visible = window->IsVisible();
     visibility_info_->visible_param = visible;
     visibility_info_->changed_count++;
   }
 
-  virtual void OnWindowDestroyed(Window* window) override {
+  void OnWindowDestroyed(Window* window) override {
     EXPECT_FALSE(window->parent());
     destroyed_count_++;
   }
 
-  virtual void OnWindowPropertyChanged(Window* window,
-                                       const void* key,
-                                       intptr_t old) override {
+  void OnWindowPropertyChanged(Window* window,
+                               const void* key,
+                               intptr_t old) override {
     property_key_ = key;
     old_property_value_ = old;
   }
 
-  virtual void OnAncestorWindowTransformed(Window* source,
-                                           Window* window) override {
+  void OnAncestorWindowTransformed(Window* source, Window* window) override {
     transform_notifications_.push_back(
         std::make_pair(source->id(), window->id()));
   }
 
   int added_count_;
   int removed_count_;
   int destroyed_count_;
   scoped_ptr<VisibilityInfo> visibility_info_;
   const void* property_key_;
   intptr_t old_property_value_;
@@ skipping 260 matching lines @@
   EXPECT_EQ("3 1 2",
             ui::test::ChildLayerNamesAsString(*root_window()->layer()));
 }
 
 class TestVisibilityClient : public client::VisibilityClient {
  public:
   explicit TestVisibilityClient(Window* root_window)
       : ignore_visibility_changes_(false) {
     client::SetVisibilityClient(root_window, this);
   }
-  virtual ~TestVisibilityClient() {
-  }
+  ~TestVisibilityClient() override {}
 
   void set_ignore_visibility_changes(bool ignore_visibility_changes) {
     ignore_visibility_changes_ = ignore_visibility_changes;
   }
 
   // Overridden from client::VisibilityClient:
-  virtual void UpdateLayerVisibility(aura::Window* window,
-                                     bool visible) override {
+  void UpdateLayerVisibility(aura::Window* window, bool visible) override {
     if (!ignore_visibility_changes_)
       window->layer()->SetVisible(visible);
   }
 
  private:
   bool ignore_visibility_changes_;
   DISALLOW_COPY_AND_ASSIGN(TestVisibilityClient);
 };
 
 TEST_F(WindowTest, VisibilityClientIsVisible) {
@@ skipping 104 matching lines @@
   // Closing windows
   w11.reset();
   RunAllPendingInMessageLoop();
   EXPECT_EQ("0 0 0", d1.GetMouseMotionCountsAndReset());
   EXPECT_EQ("0 0 0", d11.GetMouseMotionCountsAndReset());
 }
 
 class RootWindowAttachmentObserver : public WindowObserver {
  public:
   RootWindowAttachmentObserver() : added_count_(0), removed_count_(0) {}
-  virtual ~RootWindowAttachmentObserver() {}
+  ~RootWindowAttachmentObserver() override {}
 
   int added_count() const { return added_count_; }
   int removed_count() const { return removed_count_; }
 
   void Clear() {
     added_count_ = 0;
     removed_count_ = 0;
   }
 
   // Overridden from WindowObserver:
-  virtual void OnWindowAddedToRootWindow(Window* window) override {
-    ++added_count_;
-  }
-  virtual void OnWindowRemovingFromRootWindow(Window* window,
-                                              Window* new_root) override {
+  void OnWindowAddedToRootWindow(Window* window) override { ++added_count_; }
+  void OnWindowRemovingFromRootWindow(Window* window,
+                                      Window* new_root) override {
     ++removed_count_;
   }
 
  private:
   int added_count_;
   int removed_count_;
 
   DISALLOW_COPY_AND_ASSIGN(RootWindowAttachmentObserver);
 };
 
@@ skipping 59 matching lines @@
   w11 = NULL;
   w111 = NULL;
   EXPECT_EQ(2, observer.added_count());
   EXPECT_EQ(2, observer.removed_count());
 }
 
 class BoundsChangedWindowObserver : public WindowObserver {
  public:
   BoundsChangedWindowObserver() : root_set_(false) {}
 
-  virtual void OnWindowBoundsChanged(Window* window,
-                                     const gfx::Rect& old_bounds,
-                                     const gfx::Rect& new_bounds) override {
+  void OnWindowBoundsChanged(Window* window,
+                             const gfx::Rect& old_bounds,
+                             const gfx::Rect& new_bounds) override {
     root_set_ = window->GetRootWindow() != NULL;
   }
 
   bool root_set() const { return root_set_; }
 
  private:
   bool root_set_;
 
   DISALLOW_COPY_AND_ASSIGN(BoundsChangedWindowObserver);
 };
@@ skipping 58 matching lines @@
 // Used By DeleteWindowFromOnWindowDestroyed. Destroys a Window from
 // OnWindowDestroyed().
 class OwningWindowDelegate : public TestWindowDelegate {
  public:
   OwningWindowDelegate() {}
 
   void SetOwnedWindow(Window* window) {
     owned_window_.reset(window);
   }
 
-  virtual void OnWindowDestroyed(Window* window) override {
-    owned_window_.reset(NULL);
-  }
+  void OnWindowDestroyed(Window* window) override { owned_window_.reset(NULL); }
 
  private:
   scoped_ptr<Window> owned_window_;
 
   DISALLOW_COPY_AND_ASSIGN(OwningWindowDelegate);
 };
 
 }  // namespace
 
 // Creates a window with two child windows. When the first child window is
@@ skipping 22 matching lines @@
 class BoundsChangeDelegate : public TestWindowDelegate {
  public:
   BoundsChangeDelegate() : bounds_changed_(false) {}
 
   void clear_bounds_changed() { bounds_changed_ = false; }
   bool bounds_changed() const {
     return bounds_changed_;
   }
 
   // Window
-  virtual void OnBoundsChanged(const gfx::Rect& old_bounds,
-                               const gfx::Rect& new_bounds) override {
+  void OnBoundsChanged(const gfx::Rect& old_bounds,
+                       const gfx::Rect& new_bounds) override {
     bounds_changed_ = true;
   }
 
  private:
   // Was OnBoundsChanged() invoked?
   bool bounds_changed_;
 
   DISALLOW_COPY_AND_ASSIGN(BoundsChangeDelegate);
 };
 
@@ skipping 87 matching lines @@
   AddChildNotificationsObserver() : added_count_(0), removed_count_(0) {}
 
   std::string CountStringAndReset() {
     std::string result = base::IntToString(added_count_) + " " +
         base::IntToString(removed_count_);
     added_count_ = removed_count_ = 0;
     return result;
   }
 
   // WindowObserver overrides:
-  virtual void OnWindowAddedToRootWindow(Window* window) override {
-    added_count_++;
-  }
-  virtual void OnWindowRemovingFromRootWindow(Window* window,
-                                              Window* new_root) override {
+  void OnWindowAddedToRootWindow(Window* window) override { added_count_++; }
+  void OnWindowRemovingFromRootWindow(Window* window,
+                                      Window* new_root) override {
     removed_count_++;
   }
 
  private:
   int added_count_;
   int removed_count_;
 
   DISALLOW_COPY_AND_ASSIGN(AddChildNotificationsObserver);
 };
 
@@ skipping 24 matching lines @@
       0,
       gfx::Rect(10, 20, 30, 40),
       root_window()));
 }
 
 class HierarchyObserver : public WindowObserver {
  public:
   HierarchyObserver(Window* target) : target_(target) {
     target_->AddObserver(this);
   }
-  virtual ~HierarchyObserver() {
-    target_->RemoveObserver(this);
-  }
+  ~HierarchyObserver() override { target_->RemoveObserver(this); }
 
   void ValidateState(
       int index,
       const WindowObserver::HierarchyChangeParams& params) const {
     ParamsMatch(params_[index], params);
   }
 
   void Reset() {
     params_.clear();
   }
 
  private:
   // Overridden from WindowObserver:
-  virtual void OnWindowHierarchyChanging(
-      const HierarchyChangeParams& params) override {
+  void OnWindowHierarchyChanging(const HierarchyChangeParams& params) override {
     params_.push_back(params);
   }
-  virtual void OnWindowHierarchyChanged(
-      const HierarchyChangeParams& params) override {
+  void OnWindowHierarchyChanged(const HierarchyChangeParams& params) override {
     params_.push_back(params);
   }
 
   void ParamsMatch(const WindowObserver::HierarchyChangeParams& p1,
                    const WindowObserver::HierarchyChangeParams& p2) const {
     EXPECT_EQ(p1.phase, p2.phase);
     EXPECT_EQ(p1.target, p2.target);
     EXPECT_EQ(p1.new_parent, p2.new_parent);
     EXPECT_EQ(p1.old_parent, p2.old_parent);
     EXPECT_EQ(p1.receiver, p2.receiver);
@@ skipping 346 matching lines @@
   delete w1ll;
 }
 
 namespace {
 
 // Tracks the number of times paint is invoked along with what the clip and
 // translate was.
 class PaintWindowDelegate : public TestWindowDelegate {
  public:
   PaintWindowDelegate() : paint_count_(0) {}
-  virtual ~PaintWindowDelegate() {}
+  ~PaintWindowDelegate() override {}
 
   const gfx::Rect& most_recent_paint_clip_bounds() const {
     return most_recent_paint_clip_bounds_;
   }
 
   const gfx::Vector2d& most_recent_paint_matrix_offset() const {
     return most_recent_paint_matrix_offset_;
   }
 
   void clear_paint_count() { paint_count_ = 0; }
   int paint_count() const { return paint_count_; }
 
   // TestWindowDelegate::
-  virtual void OnPaint(gfx::Canvas* canvas) override {
+  void OnPaint(gfx::Canvas* canvas) override {
     paint_count_++;
     canvas->GetClipBounds(&most_recent_paint_clip_bounds_);
     const SkMatrix& matrix = canvas->sk_canvas()->getTotalMatrix();
     most_recent_paint_matrix_offset_ = gfx::Vector2d(
         SkScalarFloorToInt(matrix.getTranslateX()),
         SkScalarFloorToInt(matrix.getTranslateY()));
   }
 
  private:
   int paint_count_;
@@ skipping 442 matching lines @@
   }
 }
 
 namespace {
 
 class TestLayerAnimationObserver : public ui::LayerAnimationObserver {
  public:
   TestLayerAnimationObserver()
       : animation_completed_(false),
         animation_aborted_(false) {}
-  virtual ~TestLayerAnimationObserver() {}
+  ~TestLayerAnimationObserver() override {}
 
   bool animation_completed() const { return animation_completed_; }
   bool animation_aborted() const { return animation_aborted_; }
 
   void Reset() {
     animation_completed_ = false;
     animation_aborted_ = false;
   }
 
  private:
   // ui::LayerAnimationObserver:
-  virtual void OnLayerAnimationEnded(
-      ui::LayerAnimationSequence* sequence) override {
+  void OnLayerAnimationEnded(ui::LayerAnimationSequence* sequence) override {
     animation_completed_ = true;
   }
 
-  virtual void OnLayerAnimationAborted(
-      ui::LayerAnimationSequence* sequence) override {
+  void OnLayerAnimationAborted(ui::LayerAnimationSequence* sequence) override {
     animation_aborted_ = true;
   }
 
-  virtual void OnLayerAnimationScheduled(
-      ui::LayerAnimationSequence* sequence) override {
-  }
+  void OnLayerAnimationScheduled(
+      ui::LayerAnimationSequence* sequence) override {}
 
   bool animation_completed_;
   bool animation_aborted_;
 
   DISALLOW_COPY_AND_ASSIGN(TestLayerAnimationObserver);
 };
 
 }
 
 TEST_F(WindowTest, WindowDestroyCompletesAnimations) {
@@ skipping 40 matching lines @@
 
   EXPECT_TRUE(animator.get());
   EXPECT_FALSE(animator->is_animating());
   EXPECT_TRUE(observer.animation_completed());
   EXPECT_FALSE(observer.animation_aborted());
   animator->RemoveObserver(&observer);
 }
 
 }  // namespace test
 }  // namespace aura