Replace FINAL and OVERRIDE with their C++11 counterparts in Source/core/[css|rendering|clipboard]

Source/core/css/CSSBasicShapes.h

 /*
  * Copyright (C) 2011 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 44 matching lines @@
     CSSPrimitiveValue* referenceBox() const { return m_referenceBox.get(); }
     void setReferenceBox(PassRefPtrWillBeRawPtr<CSSPrimitiveValue> referenceBox) { m_referenceBox = referenceBox; }
 
     virtual void trace(Visitor* visitor) { visitor->trace(m_referenceBox); }
 
 protected:
     CSSBasicShape() { }
     RefPtrWillBeMember<CSSPrimitiveValue> m_referenceBox;
 };
 
-class CSSBasicShapeCircle FINAL : public CSSBasicShape {
+class CSSBasicShapeCircle final : public CSSBasicShape {
 public:
     static PassRefPtrWillBeRawPtr<CSSBasicShapeCircle> create() { return adoptRefWillBeNoop(new CSSBasicShapeCircle); }
 
-    virtual Type type() const OVERRIDE { return CSSBasicShapeCircleType; }
-    virtual String cssText() const OVERRIDE;
-    virtual bool equals(const CSSBasicShape&) const OVERRIDE;
+    virtual Type type() const override { return CSSBasicShapeCircleType; }
+    virtual String cssText() const override;
+    virtual bool equals(const CSSBasicShape&) const override;
 
     CSSPrimitiveValue* centerX() const { return m_centerX.get(); }
     CSSPrimitiveValue* centerY() const { return m_centerY.get(); }
     CSSPrimitiveValue* radius() const { return m_radius.get(); }
 
     void setCenterX(PassRefPtrWillBeRawPtr<CSSPrimitiveValue> centerX) { m_centerX = centerX; }
     void setCenterY(PassRefPtrWillBeRawPtr<CSSPrimitiveValue> centerY) { m_centerY = centerY; }
     void setRadius(PassRefPtrWillBeRawPtr<CSSPrimitiveValue> radius) { m_radius = radius; }
 
     virtual void trace(Visitor*);
 
 private:
     CSSBasicShapeCircle() { }
 
     RefPtrWillBeMember<CSSPrimitiveValue> m_centerX;
     RefPtrWillBeMember<CSSPrimitiveValue> m_centerY;
     RefPtrWillBeMember<CSSPrimitiveValue> m_radius;
 };
 
-class CSSBasicShapeEllipse FINAL : public CSSBasicShape {
+class CSSBasicShapeEllipse final : public CSSBasicShape {
 public:
     static PassRefPtrWillBeRawPtr<CSSBasicShapeEllipse> create() { return adoptRefWillBeNoop(new CSSBasicShapeEllipse); }
 
-    virtual Type type() const OVERRIDE { return CSSBasicShapeEllipseType; }
-    virtual String cssText() const OVERRIDE;
-    virtual bool equals(const CSSBasicShape&) const OVERRIDE;
+    virtual Type type() const override { return CSSBasicShapeEllipseType; }
+    virtual String cssText() const override;
+    virtual bool equals(const CSSBasicShape&) const override;
 
     CSSPrimitiveValue* centerX() const { return m_centerX.get(); }
     CSSPrimitiveValue* centerY() const { return m_centerY.get(); }
     CSSPrimitiveValue* radiusX() const { return m_radiusX.get(); }
     CSSPrimitiveValue* radiusY() const { return m_radiusY.get(); }
 
     void setCenterX(PassRefPtrWillBeRawPtr<CSSPrimitiveValue> centerX) { m_centerX = centerX; }
     void setCenterY(PassRefPtrWillBeRawPtr<CSSPrimitiveValue> centerY) { m_centerY = centerY; }
     void setRadiusX(PassRefPtrWillBeRawPtr<CSSPrimitiveValue> radiusX) { m_radiusX = radiusX; }
     void setRadiusY(PassRefPtrWillBeRawPtr<CSSPrimitiveValue> radiusY) { m_radiusY = radiusY; }
 
     virtual void trace(Visitor*);
 
 private:
     CSSBasicShapeEllipse() { }
 
     RefPtrWillBeMember<CSSPrimitiveValue> m_centerX;
     RefPtrWillBeMember<CSSPrimitiveValue> m_centerY;
     RefPtrWillBeMember<CSSPrimitiveValue> m_radiusX;
     RefPtrWillBeMember<CSSPrimitiveValue> m_radiusY;
 };
 
-class CSSBasicShapePolygon FINAL : public CSSBasicShape {
+class CSSBasicShapePolygon final : public CSSBasicShape {
 public:
     static PassRefPtrWillBeRawPtr<CSSBasicShapePolygon> create() { return adoptRefWillBeNoop(new CSSBasicShapePolygon); }
 
     void appendPoint(PassRefPtrWillBeRawPtr<CSSPrimitiveValue> x, PassRefPtrWillBeRawPtr<CSSPrimitiveValue> y)
     {
         m_values.append(x);
         m_values.append(y);
     }
 
     PassRefPtrWillBeRawPtr<CSSPrimitiveValue> getXAt(unsigned i) const { return m_values.at(i * 2); }
     PassRefPtrWillBeRawPtr<CSSPrimitiveValue> getYAt(unsigned i) const { return m_values.at(i * 2 + 1); }
     const WillBeHeapVector<RefPtrWillBeMember<CSSPrimitiveValue> >& values() const { return m_values; }
 
     void setWindRule(WindRule w) { m_windRule = w; }
     WindRule windRule() const { return m_windRule; }
 
-    virtual Type type() const OVERRIDE { return CSSBasicShapePolygonType; }
-    virtual String cssText() const OVERRIDE;
-    virtual bool equals(const CSSBasicShape&) const OVERRIDE;
+    virtual Type type() const override { return CSSBasicShapePolygonType; }
+    virtual String cssText() const override;
+    virtual bool equals(const CSSBasicShape&) const override;
 
     virtual void trace(Visitor*);
 
 private:
     CSSBasicShapePolygon()
         : m_windRule(RULE_NONZERO)
     {
     }
 
     WillBeHeapVector<RefPtrWillBeMember<CSSPrimitiveValue> > m_values;
@@ skipping 41 matching lines @@
     {
         updateShapeSize4Values(value1, value2, value3, value2);
     }
 
 
     void setTopLeftRadius(PassRefPtrWillBeRawPtr<CSSPrimitiveValue> radius) { m_topLeftRadius = radius; }
     void setTopRightRadius(PassRefPtrWillBeRawPtr<CSSPrimitiveValue> radius) { m_topRightRadius = radius; }
     void setBottomRightRadius(PassRefPtrWillBeRawPtr<CSSPrimitiveValue> radius) { m_bottomRightRadius = radius; }
     void setBottomLeftRadius(PassRefPtrWillBeRawPtr<CSSPrimitiveValue> radius) { m_bottomLeftRadius = radius; }
 
-    virtual Type type() const OVERRIDE { return CSSBasicShapeInsetType; }
-    virtual String cssText() const OVERRIDE;
-    virtual bool equals(const CSSBasicShape&) const OVERRIDE;
+    virtual Type type() const override { return CSSBasicShapeInsetType; }
+    virtual String cssText() const override;
+    virtual bool equals(const CSSBasicShape&) const override;
 
     virtual void trace(Visitor*);
 
 private:
     CSSBasicShapeInset() { }
 
     RefPtrWillBeMember<CSSPrimitiveValue> m_top;
     RefPtrWillBeMember<CSSPrimitiveValue> m_right;
     RefPtrWillBeMember<CSSPrimitiveValue> m_bottom;
     RefPtrWillBeMember<CSSPrimitiveValue> m_left;
 
     RefPtrWillBeMember<CSSPrimitiveValue> m_topLeftRadius;
     RefPtrWillBeMember<CSSPrimitiveValue> m_topRightRadius;
     RefPtrWillBeMember<CSSPrimitiveValue> m_bottomRightRadius;
     RefPtrWillBeMember<CSSPrimitiveValue> m_bottomLeftRadius;
 };
 
 } // namespace blink
 
 #endif // CSSBasicShapes_h