Oilpan: Move AnimatableValue's hierarchy to oilpan's heap

Source/core/animation/AnimatableLengthTest.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 38 matching lines @@
 
 class AnimationAnimatableLengthTest : public ::testing::Test {
 protected:
     AnimationAnimatableLengthTest()
         : style(RenderStyle::createDefaultStyle())
         , conversionDataZoom1(style.get(), style.get(), 0, 0, 1.0f)
         , conversionDataZoom3(style.get(), style.get(), 0, 0, 3.0f)
     {
     }
 
-    PassRefPtr<AnimatableLength> create(double value, CSSPrimitiveValue::UnitTypes type)
+    PassRefPtrWillBeRawPtr<AnimatableLength> create(double value, CSSPrimitiveValue::UnitTypes type)
     {
         return AnimatableLength::create(CSSPrimitiveValue::create(value, type).get());
     }
 
-    PassRefPtr<AnimatableLength> create(double valueLeft, CSSPrimitiveValue::UnitTypes typeLeft, double valueRight, CSSPrimitiveValue::UnitTypes typeRight)
+    PassRefPtrWillBeRawPtr<AnimatableLength> create(double valueLeft, CSSPrimitiveValue::UnitTypes typeLeft, double valueRight, CSSPrimitiveValue::UnitTypes typeRight)
     {
         return AnimatableLength::create(createCalc(valueLeft, typeLeft, valueRight, typeRight).get());
     }
 
     PassRefPtrWillBeRawPtr<CSSCalcValue> createCalc(double valueLeft, CSSPrimitiveValue::UnitTypes typeLeft, double valueRight, CSSPrimitiveValue::UnitTypes typeRight)
     {
         return CSSCalcValue::create(CSSCalcValue::createExpressionNode(
             CSSCalcValue::createExpressionNode(CSSPrimitiveValue::create(valueLeft, typeLeft), valueLeft == trunc(valueLeft)),
             CSSCalcValue::createExpressionNode(CSSPrimitiveValue::create(valueRight, typeRight), valueRight == trunc(valueRight)),
             CalcAdd
         ));
     }
 
     PassRefPtrWillBeRawPtr<CSSValue> toCSSValue(CSSValue* cssValue)
     {
         return AnimatableLength::create(cssValue)->toCSSValue();
     }
 
-    AnimatableLength::NumberUnitType commonUnitType(PassRefPtr<AnimatableLength> a, PassRefPtr<AnimatableLength> b)
+    AnimatableLength::NumberUnitType commonUnitType(PassRefPtrWillBeRawPtr<AnimatableLength> a, PassRefPtrWillBeRawPtr<AnimatableLength> b)
     {
         return a->commonUnitType(b.get());
     }
 
-    bool isUnitlessZero(PassRefPtr<AnimatableLength> a)
+    bool isUnitlessZero(PassRefPtrWillBeRawPtr<AnimatableLength> a)
     {
         return a->isUnitlessZero();
     }
 
     RefPtr<RenderStyle> style;
     CSSToLengthConversionData conversionDataZoom1;
     CSSToLengthConversionData conversionDataZoom3;
 };
 
 TEST_F(AnimationAnimatableLengthTest, CanCreateFrom)
@@ skipping 109 matching lines @@
             adoptPtr(new CalcExpressionBinaryOperation(
                 adoptPtr(new CalcExpressionLength(Length(-15, WebCore::Fixed))),
                 adoptPtr(new CalcExpressionLength(Length(-5, Percent))),
                 CalcAdd)),
             ValueRangeNonNegative)),
         create(-5, CSSPrimitiveValue::CSS_PX, -5, CSSPrimitiveValue::CSS_PERCENTAGE)->toLength(conversionDataZoom3, NonNegativeValues));
 }
 
 TEST_F(AnimationAnimatableLengthTest, Interpolate)
 {
-    RefPtr<AnimatableLength> from10px = create(10, CSSPrimitiveValue::CSS_PX);
-    RefPtr<AnimatableLength> to20pxAsInches = create(20.0 / 96, CSSPrimitiveValue::CSS_IN);
+    RefPtrWillBeRawPtr<AnimatableLength> from10px = create(10, CSSPrimitiveValue::CSS_PX);
+    RefPtrWillBeRawPtr<AnimatableLength> to20pxAsInches = create(20.0 / 96, CSSPrimitiveValue::CSS_IN);
 
     EXPECT_REFV_EQ(create(5,  CSSPrimitiveValue::CSS_PX),
         AnimatableValue::interpolate(from10px.get(), to20pxAsInches.get(), -0.5));
 
     EXPECT_REFV_EQ(create(10, CSSPrimitiveValue::CSS_PX),
         AnimatableValue::interpolate(from10px.get(), to20pxAsInches.get(),  0));
     EXPECT_REFV_EQ(create(14, CSSPrimitiveValue::CSS_PX),
         AnimatableValue::interpolate(from10px.get(), to20pxAsInches.get(),  0.4));
     EXPECT_REFV_EQ(create(15, CSSPrimitiveValue::CSS_PX),
         AnimatableValue::interpolate(from10px.get(), to20pxAsInches.get(),  0.5));
     EXPECT_REFV_EQ(create(16, CSSPrimitiveValue::CSS_PX),
         AnimatableValue::interpolate(from10px.get(), to20pxAsInches.get(),  0.6));
     EXPECT_REFV_EQ(create(20.0 / 96, CSSPrimitiveValue::CSS_IN),
         AnimatableValue::interpolate(from10px.get(), to20pxAsInches.get(),  1));
     EXPECT_REFV_EQ(create(25, CSSPrimitiveValue::CSS_PX),
         AnimatableValue::interpolate(from10px.get(), to20pxAsInches.get(),  1.5));
 
-    RefPtr<AnimatableLength> from10em = create(10, CSSPrimitiveValue::CSS_EMS);
-    RefPtr<AnimatableLength> to20rem = create(20, CSSPrimitiveValue::CSS_REMS);
+    RefPtrWillBeRawPtr<AnimatableLength> from10em = create(10, CSSPrimitiveValue::CSS_EMS);
+    RefPtrWillBeRawPtr<AnimatableLength> to20rem = create(20, CSSPrimitiveValue::CSS_REMS);
     EXPECT_REFV_EQ(create(15, CSSPrimitiveValue::CSS_EMS, -10, CSSPrimitiveValue::CSS_REMS),
         AnimatableValue::interpolate(from10em.get(), to20rem.get(), -0.5));
     EXPECT_REFV_EQ(create(10, CSSPrimitiveValue::CSS_EMS),
         AnimatableValue::interpolate(from10em.get(), to20rem.get(),  0));
     EXPECT_REFV_EQ(create(6, CSSPrimitiveValue::CSS_EMS, 8, CSSPrimitiveValue::CSS_REMS),
         AnimatableValue::interpolate(from10em.get(), to20rem.get(),  0.4));
     EXPECT_REFV_EQ(create(5, CSSPrimitiveValue::CSS_EMS, 10, CSSPrimitiveValue::CSS_REMS),
         AnimatableValue::interpolate(from10em.get(), to20rem.get(),  0.5));
     EXPECT_REFV_EQ(create(4, CSSPrimitiveValue::CSS_EMS, 12, CSSPrimitiveValue::CSS_REMS),
         AnimatableValue::interpolate(from10em.get(), to20rem.get(),  0.6));
     EXPECT_REFV_EQ(create(20, CSSPrimitiveValue::CSS_REMS),
         AnimatableValue::interpolate(from10em.get(), to20rem.get(),  1));
     EXPECT_REFV_EQ(create(-5, CSSPrimitiveValue::CSS_EMS, 30, CSSPrimitiveValue::CSS_REMS),
         AnimatableValue::interpolate(from10em.get(), to20rem.get(),  1.5));
 
     // Zero values are typeless and hence we can don't get a calc
-    RefPtr<AnimatableLength> from0px = create(0, CSSPrimitiveValue::CSS_PX);
+    RefPtrWillBeRawPtr<AnimatableLength> from0px = create(0, CSSPrimitiveValue::CSS_PX);
     EXPECT_REFV_EQ(create(-10, CSSPrimitiveValue::CSS_REMS),
         AnimatableValue::interpolate(from0px.get(), to20rem.get(), -0.5));
     // At t=0, interpolate always returns the "from" value.
     EXPECT_REFV_EQ(create(0, CSSPrimitiveValue::CSS_PX),
         AnimatableValue::interpolate(from0px.get(), to20rem.get(), 0));
     EXPECT_REFV_EQ(create(10, CSSPrimitiveValue::CSS_REMS),
         AnimatableValue::interpolate(from0px.get(), to20rem.get(), 0.5));
     EXPECT_REFV_EQ(create(20, CSSPrimitiveValue::CSS_REMS),
         AnimatableValue::interpolate(from0px.get(), to20rem.get(), 1.0));
     EXPECT_REFV_EQ(create(30, CSSPrimitiveValue::CSS_REMS),
         AnimatableValue::interpolate(from0px.get(), to20rem.get(), 1.5));
 
     // Except 0% which is special
-    RefPtr<AnimatableLength> from0percent = create(0, CSSPrimitiveValue::CSS_PERCENTAGE);
+    RefPtrWillBeRawPtr<AnimatableLength> from0percent = create(0, CSSPrimitiveValue::CSS_PERCENTAGE);
     EXPECT_REFV_EQ(create(0, CSSPrimitiveValue::CSS_PERCENTAGE, -10, CSSPrimitiveValue::CSS_REMS),
         AnimatableValue::interpolate(from0percent.get(), to20rem.get(), -0.5));
     // At t=0, interpolate always returns the "from" value.
     EXPECT_REFV_EQ(create(0, CSSPrimitiveValue::CSS_PERCENTAGE),
         AnimatableValue::interpolate(from0percent.get(), to20rem.get(), 0));
     EXPECT_REFV_EQ(create(0, CSSPrimitiveValue::CSS_PERCENTAGE, 10, CSSPrimitiveValue::CSS_REMS),
         AnimatableValue::interpolate(from0percent.get(), to20rem.get(), 0.5));
     // At t=1, interpolate always returns the "to" value.
     EXPECT_REFV_EQ(create(20, CSSPrimitiveValue::CSS_REMS),
         AnimatableValue::interpolate(from0percent.get(), to20rem.get(), 1.0));
@@ skipping 11 matching lines @@
         create(10, CSSPrimitiveValue::CSS_EMS, 20, CSSPrimitiveValue::CSS_REMS),
         AnimatableValue::add(create(10, CSSPrimitiveValue::CSS_EMS).get(), create(20, CSSPrimitiveValue::CSS_REMS).get()));
     EXPECT_REFV_EQ(
         create(10, CSSPrimitiveValue::CSS_EMS),
         AnimatableValue::add(create(10, CSSPrimitiveValue::CSS_EMS).get(), create(0, CSSPrimitiveValue::CSS_REMS).get()));
     EXPECT_REFV_EQ(
         create(20, CSSPrimitiveValue::CSS_REMS),
         AnimatableValue::add(create(0, CSSPrimitiveValue::CSS_EMS).get(), create(20, CSSPrimitiveValue::CSS_REMS).get()));
 
     // Check you actually get the reference back for zero optimization
-    RefPtr<AnimatableLength> rems20 = create(20, CSSPrimitiveValue::CSS_REMS);
+    RefPtrWillBeRawPtr<AnimatableLength> rems20 = create(20, CSSPrimitiveValue::CSS_REMS);
     EXPECT_EQ(rems20.get(), AnimatableValue::add(create(0, CSSPrimitiveValue::CSS_EMS).get(), rems20.get()).get());
     EXPECT_EQ(rems20.get(), AnimatableValue::add(rems20.get(), create(0, CSSPrimitiveValue::CSS_EMS).get()).get());
 
     // Except 0% which is special
-    RefPtr<AnimatableLength> zeropercent = create(0, CSSPrimitiveValue::CSS_PERCENTAGE);
+    RefPtrWillBeRawPtr<AnimatableLength> zeropercent = create(0, CSSPrimitiveValue::CSS_PERCENTAGE);
     EXPECT_REFV_EQ(create(0, CSSPrimitiveValue::CSS_PERCENTAGE, -10, CSSPrimitiveValue::CSS_REMS),
         AnimatableValue::add(zeropercent.get(), create(-10, CSSPrimitiveValue::CSS_REMS).get()));
     EXPECT_REFV_EQ(create(-10, CSSPrimitiveValue::CSS_REMS, 0, CSSPrimitiveValue::CSS_PERCENTAGE),
         AnimatableValue::add(create(-10, CSSPrimitiveValue::CSS_REMS).get(), zeropercent.get()));
 }
 
 TEST_F(AnimationAnimatableLengthTest, IsUnitless)
 {
     EXPECT_TRUE(isUnitlessZero(create(0, CSSPrimitiveValue::CSS_PX)));
     EXPECT_FALSE(isUnitlessZero(create(0, CSSPrimitiveValue::CSS_PERCENTAGE)));
@@ skipping 11 matching lines @@
     EXPECT_FALSE(isUnitlessZero(create(4, CSSPrimitiveValue::CSS_EXS)));
     EXPECT_FALSE(isUnitlessZero(create(5, CSSPrimitiveValue::CSS_REMS)));
     EXPECT_FALSE(isUnitlessZero(create(6, CSSPrimitiveValue::CSS_VW)));
     EXPECT_FALSE(isUnitlessZero(create(7, CSSPrimitiveValue::CSS_VH)));
     EXPECT_FALSE(isUnitlessZero(create(8, CSSPrimitiveValue::CSS_VMIN)));
     EXPECT_FALSE(isUnitlessZero(create(9, CSSPrimitiveValue::CSS_VMAX)));
 }
 
 TEST_F(AnimationAnimatableLengthTest, CommonUnitType)
 {
-    RefPtr<AnimatableLength> length10px = create(10, CSSPrimitiveValue::CSS_PX);
+    RefPtrWillBeRawPtr<AnimatableLength> length10px = create(10, CSSPrimitiveValue::CSS_PX);
     EXPECT_EQ(AnimatableLength::UnitTypePixels,  commonUnitType(length10px, create(1, CSSPrimitiveValue::CSS_PX).get()));
     EXPECT_EQ(AnimatableLength::UnitTypeCalc, commonUnitType(length10px, create(2, CSSPrimitiveValue::CSS_PERCENTAGE).get()));
     EXPECT_EQ(AnimatableLength::UnitTypeCalc, commonUnitType(length10px, create(3, CSSPrimitiveValue::CSS_EMS).get()));
     EXPECT_EQ(AnimatableLength::UnitTypeCalc, commonUnitType(length10px, create(4, CSSPrimitiveValue::CSS_PX, 5, CSSPrimitiveValue::CSS_CM).get()));
     EXPECT_EQ(AnimatableLength::UnitTypeCalc, commonUnitType(length10px, create(0, CSSPrimitiveValue::CSS_PERCENTAGE).get()));
 
-    RefPtr<AnimatableLength> length0px = create(0, CSSPrimitiveValue::CSS_PX);
+    RefPtrWillBeRawPtr<AnimatableLength> length0px = create(0, CSSPrimitiveValue::CSS_PX);
     EXPECT_EQ(AnimatableLength::UnitTypePixels,     commonUnitType(length0px, create(1, CSSPrimitiveValue::CSS_PX).get()));
     EXPECT_EQ(AnimatableLength::UnitTypePercentage, commonUnitType(length0px, create(2, CSSPrimitiveValue::CSS_PERCENTAGE).get()));
     EXPECT_EQ(AnimatableLength::UnitTypeFontSize,   commonUnitType(length0px, create(3, CSSPrimitiveValue::CSS_EMS).get()));
     EXPECT_EQ(AnimatableLength::UnitTypeCalc,    commonUnitType(length0px, create(4, CSSPrimitiveValue::CSS_PX, 5, CSSPrimitiveValue::CSS_CM).get()));
     EXPECT_EQ(AnimatableLength::UnitTypePercentage, commonUnitType(length0px, create(0, CSSPrimitiveValue::CSS_PERCENTAGE).get()));
 
-    RefPtr<AnimatableLength> length0percent = create(0, CSSPrimitiveValue::CSS_PERCENTAGE);
+    RefPtrWillBeRawPtr<AnimatableLength> length0percent = create(0, CSSPrimitiveValue::CSS_PERCENTAGE);
     EXPECT_EQ(AnimatableLength::UnitTypeCalc,    commonUnitType(length0percent, create(1, CSSPrimitiveValue::CSS_PX).get()));
     EXPECT_EQ(AnimatableLength::UnitTypePercentage, commonUnitType(length0percent, create(2, CSSPrimitiveValue::CSS_PERCENTAGE).get()));
     EXPECT_EQ(AnimatableLength::UnitTypeCalc,    commonUnitType(length0percent, create(3, CSSPrimitiveValue::CSS_EMS).get()));
     EXPECT_EQ(AnimatableLength::UnitTypeCalc,    commonUnitType(length0percent, create(4, CSSPrimitiveValue::CSS_PX, 5, CSSPrimitiveValue::CSS_CM).get()));
     EXPECT_EQ(AnimatableLength::UnitTypePercentage, commonUnitType(length0percent, create(0, CSSPrimitiveValue::CSS_PERCENTAGE).get()));
 
-    RefPtr<AnimatableLength> lengthCalc = create(3, CSSPrimitiveValue::CSS_PX, 5, CSSPrimitiveValue::CSS_CM);
+    RefPtrWillBeRawPtr<AnimatableLength> lengthCalc = create(3, CSSPrimitiveValue::CSS_PX, 5, CSSPrimitiveValue::CSS_CM);
     EXPECT_EQ(AnimatableLength::UnitTypeCalc, commonUnitType(lengthCalc, create(1, CSSPrimitiveValue::CSS_PX).get()));
     EXPECT_EQ(AnimatableLength::UnitTypeCalc, commonUnitType(lengthCalc, create(2, CSSPrimitiveValue::CSS_PERCENTAGE).get()));
     EXPECT_EQ(AnimatableLength::UnitTypeCalc, commonUnitType(lengthCalc, create(3, CSSPrimitiveValue::CSS_EMS).get()));
     EXPECT_EQ(AnimatableLength::UnitTypeCalc, commonUnitType(lengthCalc, create(4, CSSPrimitiveValue::CSS_PX, 5, CSSPrimitiveValue::CSS_CM).get()));
     EXPECT_EQ(AnimatableLength::UnitTypeCalc, commonUnitType(lengthCalc, create(0, CSSPrimitiveValue::CSS_PERCENTAGE).get()));
 }
 
 } // namespace WebCore