Remove RawPtr from core/css

third_party/WebKit/Source/core/css/CSSBasicShapeValues.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 24 matching lines @@
 #include "core/css/CSSValuePair.h"
 #include "platform/graphics/GraphicsTypes.h"
 #include "wtf/RefPtr.h"
 #include "wtf/Vector.h"
 #include "wtf/text/WTFString.h"
 
 namespace blink {
 
 class CSSBasicShapeCircleValue final : public CSSValue {
 public:
-    static RawPtr<CSSBasicShapeCircleValue> create() { return new CSSBasicShapeCircleValue; }
+    static CSSBasicShapeCircleValue* create() { return new CSSBasicShapeCircleValue; }
 
     String customCSSText() const;
     bool equals(const CSSBasicShapeCircleValue&) const;
 
     CSSValue* centerX() const { return m_centerX.get(); }
     CSSValue* centerY() const { return m_centerY.get(); }
     CSSPrimitiveValue* radius() const { return m_radius.get(); }
 
     // TODO(sashab): Remove these and pass them as arguments in the constructor.
-    void setCenterX(RawPtr<CSSValue> centerX) { m_centerX = centerX; }
-    void setCenterY(RawPtr<CSSValue> centerY) { m_centerY = centerY; }
-    void setRadius(RawPtr<CSSPrimitiveValue> radius) { m_radius = radius; }
+    void setCenterX(CSSValue* centerX) { m_centerX = centerX; }
+    void setCenterY(CSSValue* centerY) { m_centerY = centerY; }
+    void setRadius(CSSPrimitiveValue* radius) { m_radius = radius; }
 
     DECLARE_TRACE_AFTER_DISPATCH();
 
 private:
     CSSBasicShapeCircleValue()
         : CSSValue(BasicShapeCircleClass)
         { }
 
     Member<CSSValue> m_centerX;
     Member<CSSValue> m_centerY;
     Member<CSSPrimitiveValue> m_radius;
 };
 
 class CSSBasicShapeEllipseValue final : public CSSValue {
 public:
-    static RawPtr<CSSBasicShapeEllipseValue> create() { return new CSSBasicShapeEllipseValue; }
+    static CSSBasicShapeEllipseValue* create() { return new CSSBasicShapeEllipseValue; }
 
     String customCSSText() const;
     bool equals(const CSSBasicShapeEllipseValue&) const;
 
     CSSValue* centerX() const { return m_centerX.get(); }
     CSSValue* centerY() const { return m_centerY.get(); }
     CSSPrimitiveValue* radiusX() const { return m_radiusX.get(); }
     CSSPrimitiveValue* radiusY() const { return m_radiusY.get(); }
 
     // TODO(sashab): Remove these and pass them as arguments in the constructor.
-    void setCenterX(RawPtr<CSSValue> centerX) { m_centerX = centerX; }
-    void setCenterY(RawPtr<CSSValue> centerY) { m_centerY = centerY; }
-    void setRadiusX(RawPtr<CSSPrimitiveValue> radiusX) { m_radiusX = radiusX; }
-    void setRadiusY(RawPtr<CSSPrimitiveValue> radiusY) { m_radiusY = radiusY; }
+    void setCenterX(CSSValue* centerX) { m_centerX = centerX; }
+    void setCenterY(CSSValue* centerY) { m_centerY = centerY; }
+    void setRadiusX(CSSPrimitiveValue* radiusX) { m_radiusX = radiusX; }
+    void setRadiusY(CSSPrimitiveValue* radiusY) { m_radiusY = radiusY; }
 
     DECLARE_TRACE_AFTER_DISPATCH();
 
 private:
     CSSBasicShapeEllipseValue()
         : CSSValue(BasicShapeEllipseClass)
         { }
 
     Member<CSSValue> m_centerX;
     Member<CSSValue> m_centerY;
     Member<CSSPrimitiveValue> m_radiusX;
     Member<CSSPrimitiveValue> m_radiusY;
 };
 
 class CSSBasicShapePolygonValue final : public CSSValue {
 public:
-    static RawPtr<CSSBasicShapePolygonValue> create() { return new CSSBasicShapePolygonValue; }
+    static CSSBasicShapePolygonValue* create() { return new CSSBasicShapePolygonValue; }
 
-    void appendPoint(RawPtr<CSSPrimitiveValue> x, RawPtr<CSSPrimitiveValue> y)
+    void appendPoint(CSSPrimitiveValue* x, CSSPrimitiveValue* y)
     {
         m_values.append(x);
         m_values.append(y);
     }
 
-    RawPtr<CSSPrimitiveValue> getXAt(unsigned i) const { return m_values.at(i * 2); }
-    RawPtr<CSSPrimitiveValue> getYAt(unsigned i) const { return m_values.at(i * 2 + 1); }
+    CSSPrimitiveValue* getXAt(unsigned i) const { return m_values.at(i * 2); }
+    CSSPrimitiveValue* getYAt(unsigned i) const { return m_values.at(i * 2 + 1); }
     const HeapVector<Member<CSSPrimitiveValue>>& values() const { return m_values; }
 
     // TODO(sashab): Remove this and pass it as an argument in the constructor.
     void setWindRule(WindRule w) { m_windRule = w; }
     WindRule getWindRule() const { return m_windRule; }
 
     String customCSSText() const;
     bool equals(const CSSBasicShapePolygonValue&) const;
 
     DECLARE_TRACE_AFTER_DISPATCH();
 
 private:
     CSSBasicShapePolygonValue()
         : CSSValue(BasicShapePolygonClass),
         m_windRule(RULE_NONZERO)
     { }
 
     HeapVector<Member<CSSPrimitiveValue>> m_values;
     WindRule m_windRule;
 };
 
 class CSSBasicShapeInsetValue final : public CSSValue {
 public:
-    static RawPtr<CSSBasicShapeInsetValue> create() { return new CSSBasicShapeInsetValue; }
+    static CSSBasicShapeInsetValue* create() { return new CSSBasicShapeInsetValue; }
 
     CSSPrimitiveValue* top() const { return m_top.get(); }
     CSSPrimitiveValue* right() const { return m_right.get(); }
     CSSPrimitiveValue* bottom() const { return m_bottom.get(); }
     CSSPrimitiveValue* left() const { return m_left.get(); }
 
     CSSValuePair* topLeftRadius() const { return m_topLeftRadius.get(); }
     CSSValuePair* topRightRadius() const { return m_topRightRadius.get(); }
     CSSValuePair* bottomRightRadius() const { return m_bottomRightRadius.get(); }
     CSSValuePair* bottomLeftRadius() const { return m_bottomLeftRadius.get(); }
 
     // TODO(sashab): Remove these and pass them as arguments in the constructor.
-    void setTop(RawPtr<CSSPrimitiveValue> top) { m_top = top; }
-    void setRight(RawPtr<CSSPrimitiveValue> right) { m_right = right; }
-    void setBottom(RawPtr<CSSPrimitiveValue> bottom) { m_bottom = bottom; }
-    void setLeft(RawPtr<CSSPrimitiveValue> left) { m_left = left; }
+    void setTop(CSSPrimitiveValue* top) { m_top = top; }
+    void setRight(CSSPrimitiveValue* right) { m_right = right; }
+    void setBottom(CSSPrimitiveValue* bottom) { m_bottom = bottom; }
+    void setLeft(CSSPrimitiveValue* left) { m_left = left; }
 
     void updateShapeSize4Values(CSSPrimitiveValue* top, CSSPrimitiveValue* right, CSSPrimitiveValue* bottom, CSSPrimitiveValue* left)
     {
         setTop(top);
         setRight(right);
         setBottom(bottom);
         setLeft(left);
     }
 
     void updateShapeSize1Value(CSSPrimitiveValue* value1)
     {
         updateShapeSize4Values(value1, value1, value1, value1);
     }
 
     void updateShapeSize2Values(CSSPrimitiveValue* value1,  CSSPrimitiveValue* value2)
     {
         updateShapeSize4Values(value1, value2, value1, value2);
     }
 
     void updateShapeSize3Values(CSSPrimitiveValue* value1, CSSPrimitiveValue* value2,  CSSPrimitiveValue* value3)
     {
         updateShapeSize4Values(value1, value2, value3, value2);
     }
 
-    void setTopLeftRadius(RawPtr<CSSValuePair> radius) { m_topLeftRadius = radius; }
-    void setTopRightRadius(RawPtr<CSSValuePair> radius) { m_topRightRadius = radius; }
-    void setBottomRightRadius(RawPtr<CSSValuePair> radius) { m_bottomRightRadius = radius; }
-    void setBottomLeftRadius(RawPtr<CSSValuePair> radius) { m_bottomLeftRadius = radius; }
+    void setTopLeftRadius(CSSValuePair* radius) { m_topLeftRadius = radius; }
+    void setTopRightRadius(CSSValuePair* radius) { m_topRightRadius = radius; }
+    void setBottomRightRadius(CSSValuePair* radius) { m_bottomRightRadius = radius; }
+    void setBottomLeftRadius(CSSValuePair* radius) { m_bottomLeftRadius = radius; }
 
     String customCSSText() const;
     bool equals(const CSSBasicShapeInsetValue&) const;
 
     DECLARE_TRACE_AFTER_DISPATCH();
 
 private:
     CSSBasicShapeInsetValue()
         : CSSValue(BasicShapeInsetClass)
         { }
@@ skipping 10 matching lines @@
 };
 
 DEFINE_CSS_VALUE_TYPE_CASTS(CSSBasicShapeCircleValue, isBasicShapeCircleValue());
 DEFINE_CSS_VALUE_TYPE_CASTS(CSSBasicShapeEllipseValue, isBasicShapeEllipseValue());
 DEFINE_CSS_VALUE_TYPE_CASTS(CSSBasicShapePolygonValue, isBasicShapePolygonValue());
 DEFINE_CSS_VALUE_TYPE_CASTS(CSSBasicShapeInsetValue, isBasicShapeInsetValue());
 
 } // namespace blink
 
 #endif // CSSBasicShapeValues_h