Oilpan: Remove most WillBe types from the code base

third_party/WebKit/Source/core/svg/SVGAngle.cpp

 /*
  * Copyright (C) 2004, 2005, 2007, 2008 Nikolas Zimmermann <zimmermann@kde.org>
  * Copyright (C) 2004, 2005, 2006 Rob Buis <buis@kde.org>
  * Copyright (C) Research In Motion Limited 2010. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
@@ skipping 48 matching lines @@
     visitor->trace(m_angle);
     SVGEnumeration<SVGMarkerOrientType>::trace(visitor);
 }
 
 void SVGMarkerOrientEnumeration::notifyChange()
 {
     ASSERT(m_angle);
     m_angle->orientTypeChanged();
 }
 
-void SVGMarkerOrientEnumeration::add(PassRefPtrWillBeRawPtr<SVGPropertyBase>, SVGElement*)
+void SVGMarkerOrientEnumeration::add(RawPtr<SVGPropertyBase>, SVGElement*)
 {
     // SVGMarkerOrientEnumeration is only animated via SVGAngle
     ASSERT_NOT_REACHED();
 }
 
-void SVGMarkerOrientEnumeration::calculateAnimatedValue(SVGAnimationElement*, float percentage, unsigned repeatCount, PassRefPtrWillBeRawPtr<SVGPropertyBase> from, PassRefPtrWillBeRawPtr<SVGPropertyBase> to, PassRefPtrWillBeRawPtr<SVGPropertyBase> toAtEndOfDurationValue, SVGElement* contextElement)
+void SVGMarkerOrientEnumeration::calculateAnimatedValue(SVGAnimationElement*, float percentage, unsigned repeatCount, RawPtr<SVGPropertyBase> from, RawPtr<SVGPropertyBase> to, RawPtr<SVGPropertyBase> toAtEndOfDurationValue, SVGElement* contextElement)
 {
     // SVGMarkerOrientEnumeration is only animated via SVGAngle
     ASSERT_NOT_REACHED();
 }
 
-float SVGMarkerOrientEnumeration::calculateDistance(PassRefPtrWillBeRawPtr<SVGPropertyBase> to, SVGElement* contextElement)
+float SVGMarkerOrientEnumeration::calculateDistance(RawPtr<SVGPropertyBase> to, SVGElement* contextElement)
 {
     // SVGMarkerOrientEnumeration is only animated via SVGAngle
     ASSERT_NOT_REACHED();
     return -1.0;
 }
 
 SVGAngle::SVGAngle()
     : m_unitType(SVG_ANGLETYPE_UNSPECIFIED)
     , m_valueInSpecifiedUnits(0)
     , m_orientType(SVGMarkerOrientEnumeration::create(this))
@@ skipping 11 matching lines @@
 SVGAngle::~SVGAngle()
 {
 }
 
 DEFINE_TRACE(SVGAngle)
 {
     visitor->trace(m_orientType);
     SVGPropertyHelper<SVGAngle>::trace(visitor);
 }
 
-PassRefPtrWillBeRawPtr<SVGAngle> SVGAngle::clone() const
+RawPtr<SVGAngle> SVGAngle::clone() const
 {
-    return adoptRefWillBeNoop(new SVGAngle(m_unitType, m_valueInSpecifiedUnits, m_orientType->enumValue()));
+    return new SVGAngle(m_unitType, m_valueInSpecifiedUnits, m_orientType->enumValue());
 }
 
 float SVGAngle::value() const
 {
     switch (m_unitType) {
     case SVG_ANGLETYPE_GRAD:
         return grad2deg(m_valueInSpecifiedUnits);
     case SVG_ANGLETYPE_RAD:
         return rad2deg(m_valueInSpecifiedUnits);
     case SVG_ANGLETYPE_TURN:
@@ skipping 233 matching lines @@
         break;
     case SVG_ANGLETYPE_UNKNOWN:
         ASSERT_NOT_REACHED();
         break;
     }
 
     m_unitType = unitType;
     m_orientType->setEnumValue(SVGMarkerOrientAngle);
 }
 
-void SVGAngle::add(PassRefPtrWillBeRawPtr<SVGPropertyBase> other, SVGElement*)
+void SVGAngle::add(RawPtr<SVGPropertyBase> other, SVGElement*)
 {
-    RefPtrWillBeRawPtr<SVGAngle> otherAngle = toSVGAngle(other);
+    RawPtr<SVGAngle> otherAngle = toSVGAngle(other);
 
     // Only respect by animations, if from and by are both specified in angles (and not eg. 'auto').
     if (orientType()->enumValue() != SVGMarkerOrientAngle || otherAngle->orientType()->enumValue() != SVGMarkerOrientAngle)
         return;
 
     setValue(value() + otherAngle->value());
 }
 
 void SVGAngle::assign(const SVGAngle& other)
 {
     SVGMarkerOrientType otherOrientType = other.orientType()->enumValue();
     if (otherOrientType == SVGMarkerOrientAngle)
         newValueSpecifiedUnits(other.unitType(), other.valueInSpecifiedUnits());
     else
         m_orientType->setEnumValue(otherOrientType);
 }
 
-void SVGAngle::calculateAnimatedValue(SVGAnimationElement* animationElement, float percentage, unsigned repeatCount, PassRefPtrWillBeRawPtr<SVGPropertyBase> from, PassRefPtrWillBeRawPtr<SVGPropertyBase> to, PassRefPtrWillBeRawPtr<SVGPropertyBase> toAtEndOfDuration, SVGElement*)
+void SVGAngle::calculateAnimatedValue(SVGAnimationElement* animationElement, float percentage, unsigned repeatCount, RawPtr<SVGPropertyBase> from, RawPtr<SVGPropertyBase> to, RawPtr<SVGPropertyBase> toAtEndOfDuration, SVGElement*)
 {
     ASSERT(animationElement);
     bool isToAnimation = animationElement->getAnimationMode() == ToAnimation;
 
-    RefPtrWillBeRawPtr<SVGAngle> fromAngle = isToAnimation ? PassRefPtrWillBeRawPtr<SVGAngle>(this) : toSVGAngle(from);
-    RefPtrWillBeRawPtr<SVGAngle> toAngle = toSVGAngle(to);
+    RawPtr<SVGAngle> fromAngle = isToAnimation ? RawPtr<SVGAngle>(this) : toSVGAngle(from);
+    RawPtr<SVGAngle> toAngle = toSVGAngle(to);
     SVGMarkerOrientType fromOrientType = fromAngle->orientType()->enumValue();
     SVGMarkerOrientType toOrientType = toAngle->orientType()->enumValue();
 
     if (fromOrientType != toOrientType) {
         // Fall back to discrete animation.
         assign(percentage < 0.5f ? *fromAngle : *toAngle);
         return;
     }
 
     switch (fromOrientType) {
     // From 'auto' to 'auto', or 'auto-start-reverse' to 'auto-start-reverse'
     case SVGMarkerOrientAuto:
     case SVGMarkerOrientAutoStartReverse:
         orientType()->setEnumValue(fromOrientType);
         return;
 
     // Regular from angle to angle animation, with all features like additive etc.
     case SVGMarkerOrientAngle:
         {
             float animatedValue = value();
-            RefPtrWillBeRawPtr<SVGAngle> toAtEndOfDurationAngle = toSVGAngle(toAtEndOfDuration);
+            RawPtr<SVGAngle> toAtEndOfDurationAngle = toSVGAngle(toAtEndOfDuration);
 
             animationElement->animateAdditiveNumber(percentage, repeatCount, fromAngle->value(), toAngle->value(), toAtEndOfDurationAngle->value(), animatedValue);
             orientType()->setEnumValue(SVGMarkerOrientAngle);
             setValue(animatedValue);
         }
         return;
 
     // If the enumeration value is not angle or auto, its unknown.
     default:
         m_valueInSpecifiedUnits = 0;
         orientType()->setEnumValue(SVGMarkerOrientUnknown);
         return;
     }
 }
 
-float SVGAngle::calculateDistance(PassRefPtrWillBeRawPtr<SVGPropertyBase> other, SVGElement*)
+float SVGAngle::calculateDistance(RawPtr<SVGPropertyBase> other, SVGElement*)
 {
     return fabsf(value() - toSVGAngle(other)->value());
 }
 
 void SVGAngle::orientTypeChanged()
 {
     if (orientType()->enumValue() == SVGMarkerOrientAuto || orientType()->enumValue() == SVGMarkerOrientAutoStartReverse) {
         m_unitType = SVG_ANGLETYPE_UNSPECIFIED;
         m_valueInSpecifiedUnits = 0;
     }
 }
 
 } // namespace blink