Update remaining rendering classes to use OVERRIDE / FINAL when needed

Source/core/rendering/style/BasicShapes.h

 /*
  * Copyright (C) 2012 Adobe Systems Incorporated. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1. Redistributions of source code must retain the above
  *    copyright notice, this list of conditions and the following
  *    disclaimer.
@@ skipping 65 matching lines @@
     {
     }
 
 private:
     LayoutBox m_layoutBox;
 };
 
 #define DEFINE_BASICSHAPE_TYPE_CASTS(thisType) \
     DEFINE_TYPE_CASTS(thisType, BasicShape, value, value->type() == BasicShape::thisType##Type, value.type() == BasicShape::thisType##Type)
 
-class BasicShapeRectangle : public BasicShape {
+class BasicShapeRectangle FINAL : public BasicShape {
 public:
     static PassRefPtr<BasicShapeRectangle> create() { return adoptRef(new BasicShapeRectangle); }
 
     Length x() const { return m_x; }
     Length y() const { return m_y; }
     Length width() const { return m_width; }
     Length height() const { return m_height; }
     Length cornerRadiusX() const { return m_cornerRadiusX; }
     Length cornerRadiusY() const { return m_cornerRadiusY; }
 
     void setX(Length x) { m_x = x; }
     void setY(Length y) { m_y = y; }
     void setWidth(Length width) { m_width = width; }
     void setHeight(Length height) { m_height = height; }
     void setCornerRadiusX(Length radiusX)
     {
         m_cornerRadiusX = radiusX;
     }
     void setCornerRadiusY(Length radiusY)
     {
         m_cornerRadiusY = radiusY;
     }
 
     virtual void path(Path&, const FloatRect&) OVERRIDE;
     virtual PassRefPtr<BasicShape> blend(const BasicShape*, double) const OVERRIDE;
     virtual bool operator==(const BasicShape&) const OVERRIDE;
 
-    virtual Type type() const { return BasicShapeRectangleType; }
+    virtual Type type() const OVERRIDE { return BasicShapeRectangleType; }
 private:
     BasicShapeRectangle() { }
 
     Length m_y;
     Length m_x;
     Length m_width;
     Length m_height;
     Length m_cornerRadiusX;
     Length m_cornerRadiusY;
 };
@@ skipping 66 matching lines @@
 
         return BasicShapeRadius(m_value.blend(other.value(), progress, ValueRangeAll));
     }
 
 private:
     Length m_value;
     Type m_type;
 
 };
 
-class BasicShapeCircle : public BasicShape {
+class BasicShapeCircle FINAL : public BasicShape {
 public:
     static PassRefPtr<BasicShapeCircle> create() { return adoptRef(new BasicShapeCircle); }
 
     const BasicShapeCenterCoordinate& centerX() const { return m_centerX; }
     const BasicShapeCenterCoordinate& centerY() const { return m_centerY; }
     const BasicShapeRadius& radius() const { return m_radius; }
 
     float floatValueForRadiusInBox(FloatSize) const;
     void setCenterX(BasicShapeCenterCoordinate centerX) { m_centerX = centerX; }
     void setCenterY(BasicShapeCenterCoordinate centerY) { m_centerY = centerY; }
     void setRadius(BasicShapeRadius radius) { m_radius = radius; }
 
     virtual void path(Path&, const FloatRect&) OVERRIDE;
     virtual PassRefPtr<BasicShape> blend(const BasicShape*, double) const OVERRIDE;
     virtual bool operator==(const BasicShape&) const OVERRIDE;
 
-    virtual Type type() const { return BasicShapeCircleType; }
+    virtual Type type() const OVERRIDE { return BasicShapeCircleType; }
 private:
     BasicShapeCircle() { }
 
     BasicShapeCenterCoordinate m_centerX;
     BasicShapeCenterCoordinate m_centerY;
     BasicShapeRadius m_radius;
 };
 
 DEFINE_BASICSHAPE_TYPE_CASTS(BasicShapeCircle);
 
-class DeprecatedBasicShapeCircle : public BasicShape {
+class DeprecatedBasicShapeCircle FINAL : public BasicShape {
 public:
     static PassRefPtr<DeprecatedBasicShapeCircle> create() { return adoptRef(new DeprecatedBasicShapeCircle); }
 
     Length centerX() const { return m_centerX; }
     Length centerY() const { return m_centerY; }
     Length radius() const { return m_radius; }
 
     void setCenterX(Length centerX) { m_centerX = centerX; }
     void setCenterY(Length centerY) { m_centerY = centerY; }
     void setRadius(Length radius) { m_radius = radius; }
 
     virtual void path(Path&, const FloatRect&) OVERRIDE;
     virtual PassRefPtr<BasicShape> blend(const BasicShape*, double) const OVERRIDE;
     virtual bool operator==(const BasicShape&) const OVERRIDE;
 
-    virtual Type type() const { return DeprecatedBasicShapeCircleType; }
+    virtual Type type() const OVERRIDE { return DeprecatedBasicShapeCircleType; }
 private:
     DeprecatedBasicShapeCircle() { }
 
     Length m_centerX;
     Length m_centerY;
     Length m_radius;
 };
 
 DEFINE_BASICSHAPE_TYPE_CASTS(DeprecatedBasicShapeCircle);
 
-class BasicShapeEllipse : public BasicShape {
+class BasicShapeEllipse FINAL : public BasicShape {
 public:
     static PassRefPtr<BasicShapeEllipse> create() { return adoptRef(new BasicShapeEllipse); }
 
     const BasicShapeCenterCoordinate& centerX() const { return m_centerX; }
     const BasicShapeCenterCoordinate& centerY() const { return m_centerY; }
     const BasicShapeRadius& radiusX() const { return m_radiusX; }
     const BasicShapeRadius& radiusY() const { return m_radiusY; }
     float floatValueForRadiusInBox(const BasicShapeRadius&, float center, float boxWidthOrHeight) const;
 
     void setCenterX(BasicShapeCenterCoordinate centerX) { m_centerX = centerX; }
     void setCenterY(BasicShapeCenterCoordinate centerY) { m_centerY = centerY; }
     void setRadiusX(BasicShapeRadius radiusX) { m_radiusX = radiusX; }
     void setRadiusY(BasicShapeRadius radiusY) { m_radiusY = radiusY; }
 
     virtual void path(Path&, const FloatRect&) OVERRIDE;
     virtual PassRefPtr<BasicShape> blend(const BasicShape*, double) const OVERRIDE;
     virtual bool operator==(const BasicShape&) const OVERRIDE;
 
-    virtual Type type() const { return BasicShapeEllipseType; }
+    virtual Type type() const OVERRIDE { return BasicShapeEllipseType; }
 private:
     BasicShapeEllipse() { }
 
     BasicShapeCenterCoordinate m_centerX;
     BasicShapeCenterCoordinate m_centerY;
     BasicShapeRadius m_radiusX;
     BasicShapeRadius m_radiusY;
 };
 
 DEFINE_BASICSHAPE_TYPE_CASTS(BasicShapeEllipse);
 
-class DeprecatedBasicShapeEllipse : public BasicShape {
+class DeprecatedBasicShapeEllipse FINAL : public BasicShape {
 public:
     static PassRefPtr<DeprecatedBasicShapeEllipse> create() { return adoptRef(new DeprecatedBasicShapeEllipse); }
 
     Length centerX() const { return m_centerX; }
     Length centerY() const { return m_centerY; }
     Length radiusX() const { return m_radiusX; }
     Length radiusY() const { return m_radiusY; }
 
     void setCenterX(Length centerX) { m_centerX = centerX; }
     void setCenterY(Length centerY) { m_centerY = centerY; }
     void setRadiusX(Length radiusX) { m_radiusX = radiusX; }
     void setRadiusY(Length radiusY) { m_radiusY = radiusY; }
 
     virtual void path(Path&, const FloatRect&) OVERRIDE;
     virtual PassRefPtr<BasicShape> blend(const BasicShape*, double) const OVERRIDE;
     virtual bool operator==(const BasicShape&) const OVERRIDE;
 
-    virtual Type type() const { return DeprecatedBasicShapeEllipseType; }
+    virtual Type type() const OVERRIDE { return DeprecatedBasicShapeEllipseType; }
 private:
     DeprecatedBasicShapeEllipse() { }
 
     Length m_centerX;
     Length m_centerY;
     Length m_radiusX;
     Length m_radiusY;
 };
 
 DEFINE_BASICSHAPE_TYPE_CASTS(DeprecatedBasicShapeEllipse);
 
-class BasicShapePolygon : public BasicShape {
+class BasicShapePolygon FINAL : public BasicShape {
 public:
     static PassRefPtr<BasicShapePolygon> create() { return adoptRef(new BasicShapePolygon); }
 
     const Vector<Length>& values() const { return m_values; }
     Length getXAt(unsigned i) const { return m_values.at(2 * i); }
     Length getYAt(unsigned i) const { return m_values.at(2 * i + 1); }
 
     void setWindRule(WindRule windRule) { m_windRule = windRule; }
     void appendPoint(Length x, Length y) { m_values.append(x); m_values.append(y); }
 
     virtual void path(Path&, const FloatRect&) OVERRIDE;
     virtual PassRefPtr<BasicShape> blend(const BasicShape*, double) const OVERRIDE;
     virtual bool operator==(const BasicShape&) const OVERRIDE;
 
-    virtual WindRule windRule() const { return m_windRule; }
+    virtual WindRule windRule() const OVERRIDE { return m_windRule; }
 
-    virtual Type type() const { return BasicShapePolygonType; }
+    virtual Type type() const OVERRIDE { return BasicShapePolygonType; }
 private:
     BasicShapePolygon()
         : m_windRule(RULE_NONZERO)
     { }
 
     WindRule m_windRule;
     Vector<Length> m_values;
 };
 
 DEFINE_BASICSHAPE_TYPE_CASTS(BasicShapePolygon);
 
-class BasicShapeInsetRectangle : public BasicShape {
+class BasicShapeInsetRectangle FINAL : public BasicShape {
 public:
     static PassRefPtr<BasicShapeInsetRectangle> create() { return adoptRef(new BasicShapeInsetRectangle); }
 
     Length top() const { return m_top; }
     Length right() const { return m_right; }
     Length bottom() const { return m_bottom; }
     Length left() const { return m_left; }
     Length cornerRadiusX() const { return m_cornerRadiusX; }
     Length cornerRadiusY() const { return m_cornerRadiusY; }
 
     void setTop(Length top) { m_top = top; }
     void setRight(Length right) { m_right = right; }
     void setBottom(Length bottom) { m_bottom = bottom; }
     void setLeft(Length left) { m_left = left; }
     void setCornerRadiusX(Length radiusX)
     {
         m_cornerRadiusX = radiusX;
     }
     void setCornerRadiusY(Length radiusY)
     {
         m_cornerRadiusY = radiusY;
     }
 
     virtual void path(Path&, const FloatRect&) OVERRIDE;
     virtual PassRefPtr<BasicShape> blend(const BasicShape*, double) const OVERRIDE;
     virtual bool operator==(const BasicShape&) const OVERRIDE;
 
-    virtual Type type() const { return BasicShapeInsetRectangleType; }
+    virtual Type type() const OVERRIDE { return BasicShapeInsetRectangleType; }
 private:
     BasicShapeInsetRectangle() { }
 
     Length m_right;
     Length m_top;
     Length m_bottom;
     Length m_left;
     Length m_cornerRadiusX;
     Length m_cornerRadiusY;
 };
 
 DEFINE_BASICSHAPE_TYPE_CASTS(BasicShapeInsetRectangle);
 
 }
 #endif