[Oilpan] Migrate most classes under core/animations to Oilpan heap.

Source/core/animation/css/CSSAnimatableValueFactory.cpp

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 44 matching lines @@
 #include "core/css/CSSCalculationValue.h"
 #include "core/css/CSSPrimitiveValue.h"
 #include "core/css/CSSPrimitiveValueMappings.h"
 #include "core/css/CSSPropertyMetadata.h"
 #include "core/style/ComputedStyle.h"
 #include "platform/Length.h"
 #include "platform/LengthBox.h"
 
 namespace blink {
 
-static PassRefPtrWillBeRawPtr<AnimatableValue> createFromLengthWithZoom(const Length& length, float zoom)
+static AnimatableValue* createFromLengthWithZoom(const Length& length, float zoom)
 {
     switch (length.type()) {
     case Fixed:
     case Percent:
     case Calculated:
         return AnimatableLength::create(length, zoom);
     case Auto:
     case Intrinsic:
     case MinIntrinsic:
     case MinContent:
     case MaxContent:
     case FillAvailable:
     case FitContent:
         return AnimatableUnknown::create(CSSPrimitiveValue::create(length, 1));
     case MaxSizeNone:
         return AnimatableUnknown::create(CSSValueNone);
     case ExtendToZoom: // Does not apply to elements.
     case DeviceWidth:
     case DeviceHeight:
         ASSERT_NOT_REACHED();
         return nullptr;
     }
     ASSERT_NOT_REACHED();
     return nullptr;
 }
 
-static PassRefPtrWillBeRawPtr<AnimatableValue> createFromLength(const Length& length, const ComputedStyle& style)
+static AnimatableValue* createFromLength(const Length& length, const ComputedStyle& style)
 {
     return createFromLengthWithZoom(length, style.effectiveZoom());
 }
 
-static PassRefPtrWillBeRawPtr<AnimatableValue> createFromUnzoomedLength(const UnzoomedLength& unzoomedLength)
+static AnimatableValue* createFromUnzoomedLength(const UnzoomedLength& unzoomedLength)
 {
     return createFromLengthWithZoom(unzoomedLength.length(), 1);
 }
 
-static PassRefPtrWillBeRawPtr<AnimatableValue> createFromLineHeight(const Length& length, const ComputedStyle& style)
+static AnimatableValue* createFromLineHeight(const Length& length, const ComputedStyle& style)
 {
     if (length.type() == Percent) {
         double value = length.value();
         // -100% is used to represent "normal" line height.
         if (value == -100)
             return AnimatableUnknown::create(CSSValueNormal);
         return AnimatableDouble::create(value);
     }
     return createFromLength(length, style);
 }
 
-inline static PassRefPtrWillBeRawPtr<AnimatableValue> createFromDouble(double value, AnimatableDouble::Constraint constraint = AnimatableDouble::Unconstrained)
+inline static AnimatableValue* createFromDouble(double value, AnimatableDouble::Constraint constraint = AnimatableDouble::Unconstrained)
 {
     return AnimatableDouble::create(value, constraint);
 }
 
-inline static PassRefPtrWillBeRawPtr<AnimatableValue> createFromLengthBox(const LengthBox& lengthBox, const ComputedStyle& style)
+inline static AnimatableValue* createFromLengthBox(const LengthBox& lengthBox, const ComputedStyle& style)
 {
     return AnimatableLengthBox::create(
         createFromLength(lengthBox.left(), style),
         createFromLength(lengthBox.right(), style),
         createFromLength(lengthBox.top(), style),
         createFromLength(lengthBox.bottom(), style));
 }
 
-static PassRefPtrWillBeRawPtr<AnimatableValue> createFromBorderImageLength(const BorderImageLength& borderImageLength, const ComputedStyle& style)
+static AnimatableValue* createFromBorderImageLength(const BorderImageLength& borderImageLength, const ComputedStyle& style)
 {
     if (borderImageLength.isNumber())
         return createFromDouble(borderImageLength.number());
     return createFromLength(borderImageLength.length(), style);
 }
 
-inline static PassRefPtrWillBeRawPtr<AnimatableValue> createFromBorderImageLengthBox(const BorderImageLengthBox& borderImageLengthBox, const ComputedStyle& style)
+inline static AnimatableValue* createFromBorderImageLengthBox(const BorderImageLengthBox& borderImageLengthBox, const ComputedStyle& style)
 {
     return AnimatableLengthBox::create(
         createFromBorderImageLength(borderImageLengthBox.left(), style),
         createFromBorderImageLength(borderImageLengthBox.right(), style),
         createFromBorderImageLength(borderImageLengthBox.top(), style),
         createFromBorderImageLength(borderImageLengthBox.bottom(), style));
 }
 
-inline static PassRefPtrWillBeRawPtr<AnimatableValue> createFromLengthBoxAndBool(const LengthBox lengthBox, const bool flag, const ComputedStyle& style)
+inline static AnimatableValue* createFromLengthBoxAndBool(const LengthBox lengthBox, const bool flag, const ComputedStyle& style)
 {
     return AnimatableLengthBoxAndBool::create(
         createFromLengthBox(lengthBox, style),
         flag);
 }
 
-inline static PassRefPtrWillBeRawPtr<AnimatableValue> createFromDoubleAndBool(double number, const bool flag, const ComputedStyle& style)
+inline static AnimatableValue* createFromDoubleAndBool(double number, const bool flag, const ComputedStyle& style)
 {
     return AnimatableDoubleAndBool::create(number, flag);
 }
 
-inline static PassRefPtrWillBeRawPtr<AnimatableValue> createFromLengthPoint(const LengthPoint& lengthPoint, const ComputedStyle& style)
+inline static AnimatableValue* createFromLengthPoint(const LengthPoint& lengthPoint, const ComputedStyle& style)
 {
     return AnimatableLengthPoint::create(
         createFromLength(lengthPoint.x(), style),
         createFromLength(lengthPoint.y(), style));
 }
 
-inline static PassRefPtrWillBeRawPtr<AnimatableValue> createFromTransformOrigin(const TransformOrigin& transformOrigin, const ComputedStyle& style)
+inline static AnimatableValue* createFromTransformOrigin(const TransformOrigin& transformOrigin, const ComputedStyle& style)
 {
     return AnimatableLengthPoint3D::create(
         createFromLength(transformOrigin.x(), style),
         createFromLength(transformOrigin.y(), style),
         createFromDouble(transformOrigin.z()));
 }
 
-inline static PassRefPtrWillBeRawPtr<AnimatableValue> createFromLengthSize(const LengthSize& lengthSize, const ComputedStyle& style)
+inline static AnimatableValue* createFromLengthSize(const LengthSize& lengthSize, const ComputedStyle& style)
 {
     return AnimatableLengthSize::create(
         createFromLength(lengthSize.width(), style),
         createFromLength(lengthSize.height(), style));
 }
 
-inline static PassRefPtrWillBeRawPtr<AnimatableValue> createFromStyleImage(StyleImage* image)
+inline static AnimatableValue* createFromStyleImage(StyleImage* image)
 {
     if (image) {
         if (RefPtrWillBeRawPtr<CSSValue> cssValue = image->cssValue())
             return AnimatableImage::create(cssValue.release());
     }
     return AnimatableUnknown::create(CSSValueNone);
 }
 
-inline static PassRefPtrWillBeRawPtr<AnimatableValue> createFromFillSize(const FillSize& fillSize, const ComputedStyle& style)
+inline static AnimatableValue* createFromFillSize(const FillSize& fillSize, const ComputedStyle& style)
 {
     switch (fillSize.type) {
     case SizeLength:
         return createFromLengthSize(fillSize.size, style);
     case Contain:
     case Cover:
     case SizeNone:
         return AnimatableUnknown::create(CSSPrimitiveValue::create(fillSize.type));
     default:
         ASSERT_NOT_REACHED();
         return nullptr;
     }
 }
 
-inline static PassRefPtrWillBeRawPtr<AnimatableValue> createFromBackgroundPosition(const Length& length, bool originIsSet, BackgroundEdgeOrigin origin, const ComputedStyle& style)
+inline static AnimatableValue* createFromBackgroundPosition(const Length& length, bool originIsSet, BackgroundEdgeOrigin origin, const ComputedStyle& style)
 {
     if (!originIsSet || origin == LeftEdge || origin == TopEdge)
         return createFromLength(length, style);
     return createFromLength(length.subtractFromOneHundredPercent(), style);
 }
 
 template<CSSPropertyID property>
-inline static PassRefPtrWillBeRawPtr<AnimatableValue> createFromFillLayers(const FillLayer& fillLayers, const ComputedStyle& style)
+inline static AnimatableValue* createFromFillLayers(const FillLayer& fillLayers, const ComputedStyle& style)
 {
-    WillBeHeapVector<RefPtrWillBeMember<AnimatableValue>> values;
+    HeapVector<Member<AnimatableValue>> values;
     for (const FillLayer* fillLayer = &fillLayers; fillLayer; fillLayer = fillLayer->next()) {
         if (property == CSSPropertyBackgroundImage || property == CSSPropertyWebkitMaskImage) {
             if (!fillLayer->isImageSet())
                 break;
             values.append(createFromStyleImage(fillLayer->image()));
         } else if (property == CSSPropertyBackgroundPositionX || property == CSSPropertyWebkitMaskPositionX) {
             if (!fillLayer->isXPositionSet())
                 break;
             values.append(createFromBackgroundPosition(fillLayer->xPosition(), fillLayer->isBackgroundXOriginSet(), fillLayer->backgroundXOrigin(), style));
         } else if (property == CSSPropertyBackgroundPositionY || property == CSSPropertyWebkitMaskPositionY) {
             if (!fillLayer->isYPositionSet())
                 break;
             values.append(createFromBackgroundPosition(fillLayer->yPosition(), fillLayer->isBackgroundYOriginSet(), fillLayer->backgroundYOrigin(), style));
         } else if (property == CSSPropertyBackgroundSize || property == CSSPropertyWebkitMaskSize) {
             if (!fillLayer->isSizeSet())
                 break;
             values.append(createFromFillSize(fillLayer->size(), style));
         } else {
             ASSERT_NOT_REACHED();
         }
     }
     return AnimatableRepeatable::create(values);
 }
 
-PassRefPtrWillBeRawPtr<AnimatableValue> CSSAnimatableValueFactory::createFromColor(CSSPropertyID property, const ComputedStyle& style)
+AnimatableValue* CSSAnimatableValueFactory::createFromColor(CSSPropertyID property, const ComputedStyle& style)
 {
     Color color = style.colorIncludingFallback(property, false);
     Color visitedLinkColor = style.colorIncludingFallback(property, true);
     return AnimatableColor::create(color, visitedLinkColor);
 }
 
-inline static PassRefPtrWillBeRawPtr<AnimatableValue> createFromShapeValue(ShapeValue* value)
+inline static AnimatableValue* createFromShapeValue(ShapeValue* value)
 {
     if (value)
         return AnimatableShapeValue::create(value);
     return AnimatableUnknown::create(CSSValueNone);
 }
 
 static double fontStretchToDouble(FontStretch fontStretch)
 {
     return static_cast<unsigned>(fontStretch);
 }
 
-static PassRefPtrWillBeRawPtr<AnimatableValue> createFromFontStretch(FontStretch fontStretch)
+static AnimatableValue* createFromFontStretch(FontStretch fontStretch)
 {
     return createFromDouble(fontStretchToDouble(fontStretch));
 }
 
 static double fontWeightToDouble(FontWeight fontWeight)
 {
     switch (fontWeight) {
     case FontWeight100:
         return 100;
     case FontWeight200:
@@ skipping 11 matching lines @@
     case FontWeight800:
         return 800;
     case FontWeight900:
         return 900;
     }
 
     ASSERT_NOT_REACHED();
     return 400;
 }
 
-static PassRefPtrWillBeRawPtr<AnimatableValue> createFromFontWeight(FontWeight fontWeight)
+static AnimatableValue* createFromFontWeight(FontWeight fontWeight)
 {
     return createFromDouble(fontWeightToDouble(fontWeight));
 }
 
 static SVGPaintType normalizeSVGPaintType(SVGPaintType paintType)
 {
     // If the <paint> is 'currentColor', then create an AnimatableSVGPaint with
     // a <rgbcolor> type. This is similar in vein to the handling of colors.
     return paintType == SVG_PAINTTYPE_CURRENTCOLOR ? SVG_PAINTTYPE_RGBCOLOR : paintType;
 }
 
 // FIXME: Generate this function.
-PassRefPtrWillBeRawPtr<AnimatableValue> CSSAnimatableValueFactory::create(CSSPropertyID property, const ComputedStyle& style)
+AnimatableValue* CSSAnimatableValueFactory::create(CSSPropertyID property, const ComputedStyle& style)
 {
     ASSERT(CSSPropertyMetadata::isAnimatableProperty(property));
     switch (property) {
     case CSSPropertyBackgroundColor:
         return createFromColor(property, style);
     case CSSPropertyBackgroundImage:
         return createFromFillLayers<CSSPropertyBackgroundImage>(style.backgroundLayers(), style);
     case CSSPropertyBackgroundPositionX:
         return createFromFillLayers<CSSPropertyBackgroundPositionX>(style.backgroundLayers(), style);
     case CSSPropertyBackgroundPositionY:
@@ skipping 251 matching lines @@
         return createFromLength(style.svgStyle().ry(), style);
     case CSSPropertyZIndex:
         return createFromDouble(style.zIndex());
     default:
         ASSERT_NOT_REACHED();
         return nullptr;
     }
 }
 
 } // namespace blink