Clean up static_cast<const toBasicFoo*> by using toBasicFoo()

Source/core/rendering/style/BasicShapes.cpp

 /*
  * 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 42 matching lines @@
 }
 
 bool BasicShape::canBlend(const BasicShape* other) const
 {
     // FIXME: Support animations between different shapes in the future.
     if (!other || !isSameType(*other))
         return false;
 
     // Just polygons with same number of vertices can be animated.
     if (type() == BasicShape::BasicShapePolygonType
-        && (static_cast<const BasicShapePolygon*>(this)->values().size() != static_cast<const BasicShapePolygon*>(other)->values().size()
-        || static_cast<const BasicShapePolygon*>(this)->windRule() != static_cast<const BasicShapePolygon*>(other)->windRule()))
+        && (toBasicShapePolygon(this)->values().size() != toBasicShapePolygon(other)->values().size()
+        || toBasicShapePolygon(this)->windRule() != toBasicShapePolygon(other)->windRule()))
         return false;
 
     // Circles with keywords for radii or center coordinates cannot be animated.
     if (type() == BasicShape::BasicShapeCircleType) {
-        const BasicShapeCircle* thisCircle = static_cast<const BasicShapeCircle*>(this);
-        const BasicShapeCircle* otherCircle = static_cast<const BasicShapeCircle*>(other);
-        if (!thisCircle->radius().canBlend(otherCircle->radius()))
+        if (!toBasicShapeCircle(this)->radius().canBlend(toBasicShapeCircle(other)->radius()))
             return false;
     }
 
     // Ellipses with keywords for radii or center coordinates cannot be animated.
     if (type() != BasicShape::BasicShapeEllipseType)
         return true;
 
-    const BasicShapeEllipse* thisEllipse = static_cast<const BasicShapeEllipse*>(this);
-    const BasicShapeEllipse* otherEllipse = static_cast<const BasicShapeEllipse*>(other);
-    return (thisEllipse->radiusX().canBlend(otherEllipse->radiusX())
-        && thisEllipse->radiusY().canBlend(otherEllipse->radiusY()));
+    return (toBasicShapeEllipse(this)->radiusX().canBlend(toBasicShapeEllipse(other)->radiusX())
+        && toBasicShapeEllipse(this)->radiusY().canBlend(toBasicShapeEllipse(other)->radiusY()));
 }
 
 bool BasicShapeCircle::operator==(const BasicShape& o) const
 {
     if (!isSameType(o))
         return false;
     const BasicShapeCircle& other = toBasicShapeCircle(o);
     return m_centerX == other.m_centerX && m_centerY == other.m_centerY && m_radius == other.m_radius;
 }
 
@@ skipping 20 matching lines @@
         center.x() - radius + boundingBox.x(),
         center.y() - radius + boundingBox.y(),
         radius * 2,
         radius * 2
     ));
 }
 
 PassRefPtr<BasicShape> BasicShapeCircle::blend(const BasicShape* other, double progress) const
 {
     ASSERT(type() == other->type());
-    const BasicShapeCircle* o = static_cast<const BasicShapeCircle*>(other);
+    const BasicShapeCircle* o = toBasicShapeCircle(other);
     RefPtr<BasicShapeCircle> result =  BasicShapeCircle::create();
 
     result->setCenterX(m_centerX.blend(o->centerX(), progress));
     result->setCenterY(m_centerY.blend(o->centerY(), progress));
     result->setRadius(m_radius.blend(o->radius(), progress));
     return result.release();
 }
 
 bool BasicShapeEllipse::operator==(const BasicShape& o) const
 {
@@ skipping 25 matching lines @@
         center.x() - radiusX + boundingBox.x(),
         center.y() - radiusY + boundingBox.y(),
         radiusX * 2,
         radiusY * 2
     ));
 }
 
 PassRefPtr<BasicShape> BasicShapeEllipse::blend(const BasicShape* other, double progress) const
 {
     ASSERT(type() == other->type());
-    const BasicShapeEllipse* o = static_cast<const BasicShapeEllipse*>(other);
+    const BasicShapeEllipse* o = toBasicShapeEllipse(other);
     RefPtr<BasicShapeEllipse> result =  BasicShapeEllipse::create();
 
     if (m_radiusX.type() != BasicShapeRadius::Value || o->radiusX().type() != BasicShapeRadius::Value
         || m_radiusY.type() != BasicShapeRadius::Value || o->radiusY().type() != BasicShapeRadius::Value) {
         result->setCenterX(o->centerX());
         result->setCenterY(o->centerY());
         result->setRadiusX(o->radiusX());
         result->setRadiusY(o->radiusY());
         return result;
     }
@@ skipping 20 matching lines @@
         path.addLineTo(FloatPoint(floatValueForLength(m_values.at(i), boundingBox.width()) + boundingBox.x(),
             floatValueForLength(m_values.at(i + 1), boundingBox.height()) + boundingBox.y()));
     }
     path.closeSubpath();
 }
 
 PassRefPtr<BasicShape> BasicShapePolygon::blend(const BasicShape* other, double progress) const
 {
     ASSERT(other && isSameType(*other));
 
-    const BasicShapePolygon* o = static_cast<const BasicShapePolygon*>(other);
+    const BasicShapePolygon* o = toBasicShapePolygon(other);
     ASSERT(m_values.size() == o->values().size());
     ASSERT(!(m_values.size() % 2));
 
     size_t length = m_values.size();
     RefPtr<BasicShapePolygon> result = BasicShapePolygon::create();
     if (!length)
         return result.release();
 
     result->setWindRule(o->windRule());
 
@@ skipping 54 matching lines @@
         && m_top == other.m_top
         && m_bottom == other.m_bottom
         && m_left == other.m_left
         && m_topLeftRadius == other.m_topLeftRadius
         && m_topRightRadius == other.m_topRightRadius
         && m_bottomRightRadius == other.m_bottomRightRadius
         && m_bottomLeftRadius == other.m_bottomLeftRadius;
 }
 
 }