Standardize usage of virtual/override/final in ui/

ui/events/event.h

 // 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.
 
 #ifndef UI_EVENTS_EVENT_H_
 #define UI_EVENTS_EVENT_H_
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/event_types.h"
@@ skipping 238 matching lines @@
   EventResult result_;
 
   // The device id the event came from, or ED_UNKNOWN_DEVICE if the information
   // is not available.
   int source_device_id_;
 };
 
 class EVENTS_EXPORT CancelModeEvent : public Event {
  public:
   CancelModeEvent();
-  virtual ~CancelModeEvent();
+  ~CancelModeEvent() override;
 };
 
 class EVENTS_EXPORT LocatedEvent : public Event {
  public:
-  virtual ~LocatedEvent();
+  ~LocatedEvent() override;
 
   float x() const { return location_.x(); }
   float y() const { return location_.y(); }
   void set_location(const gfx::PointF& location) { location_ = location; }
   // TODO(tdresser): Always return floating point location. See
   // crbug.com/337824.
   gfx::Point location() const { return gfx::ToFlooredPoint(location_); }
   const gfx::PointF& location_f() const { return location_; }
   void set_root_location(const gfx::PointF& root_location) {
     root_location_ = root_location;
@@ skipping 187 matching lines @@
                   int flags,
                   int changed_button_flags);
 
   // The amount to scroll. This is in multiples of kWheelDelta.
   // Note: x_offset() > 0/y_offset() > 0 means scroll left/up.
   int x_offset() const { return offset_.x(); }
   int y_offset() const { return offset_.y(); }
   const gfx::Vector2d& offset() const { return offset_; }
 
   // Overridden from LocatedEvent.
-  virtual void UpdateForRootTransform(
+  void UpdateForRootTransform(
       const gfx::Transform& inverted_root_transform) override;
 
  private:
   gfx::Vector2d offset_;
 };
 
 class EVENTS_EXPORT TouchEvent : public LocatedEvent {
  public:
   explicit TouchEvent(const base::NativeEvent& native_event);
 
@@ skipping 18 matching lines @@
   TouchEvent(EventType type,
              const gfx::PointF& location,
              int flags,
              int touch_id,
              base::TimeDelta timestamp,
              float radius_x,
              float radius_y,
              float angle,
              float force);
 
-  virtual ~TouchEvent();
+  ~TouchEvent() override;
 
   int touch_id() const { return touch_id_; }
   float radius_x() const { return radius_x_; }
   float radius_y() const { return radius_y_; }
   float rotation_angle() const { return rotation_angle_; }
   float force() const { return force_; }
 
   // Used for unit tests.
   void set_radius_x(const float r) { radius_x_ = r; }
   void set_radius_y(const float r) { radius_y_ = r; }
 
   // Overridden from LocatedEvent.
-  virtual void UpdateForRootTransform(
+  void UpdateForRootTransform(
       const gfx::Transform& inverted_root_transform) override;
 
  protected:
   void set_radius(float radius_x, float radius_y) {
     radius_x_ = radius_x;
     radius_y_ = radius_y;
   }
 
   void set_rotation_angle(float rotation_angle) {
     rotation_angle_ = rotation_angle;
@@ skipping 73 matching lines @@
   // See also: ui/events/keycodes/dom4/keycode_converter_data.h
   KeyEvent(EventType type,
            KeyboardCode key_code,
            const std::string& code,
            int flags);
 
   KeyEvent(const KeyEvent& rhs);
 
   KeyEvent& operator=(const KeyEvent& rhs);
 
-  virtual ~KeyEvent();
+  ~KeyEvent() override;
 
   // TODO(erg): While we transition to mojo, we have to hack around a mismatch
   // in our event types. Our ui::Events don't really have all the data we need
   // to process key events, and we instead do per-platform conversions with
   // native HWNDs or XEvents. And we can't reliably send those native data
   // types across mojo types in a cross-platform way. So instead, we set the
   // resulting data when read across IPC boundaries.
   void SetExtendedKeyEventData(scoped_ptr<ExtendedKeyEventData> data);
   const ExtendedKeyEventData* extended_key_event_data() const {
     return extended_key_event_data_.get();
@@ skipping 166 matching lines @@
 
   // Create a new GestureEvent which is identical to the provided model.
   // If source / target windows are provided, the model location will be
   // converted from |source| coordinate system to |target| coordinate system.
   template <typename T>
   GestureEvent(const GestureEvent& model, T* source, T* target)
       : LocatedEvent(model, source, target),
         details_(model.details_) {
   }
 
-  virtual ~GestureEvent();
+  ~GestureEvent() override;
 
   const GestureEventDetails& details() const { return details_; }
 
  private:
   GestureEventDetails details_;
 };
 
 }  // namespace ui
 
 #endif  // UI_EVENTS_EVENT_H_