Commit 0d3f9e02 authored by haraken@chromium.org's avatar haraken@chromium.org

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

This CL changes OwnPtr<OwnPtr<InterporableValue>[]> in InterpolableValueList to Vector<OwnPtr<InterporableValue>>. As far as I see the code, I don't think this change will affect performance.

BUG=340522

Review URL: https://codereview.chromium.org/212213007

git-svn-id: svn://svn.chromium.org/blink/trunk@170298 bbb929c8-8fbe-4397-9dbb-9b2b20218538
parent b89bf587
...@@ -7,7 +7,9 @@ ...@@ -7,7 +7,9 @@
namespace WebCore { namespace WebCore {
PassOwnPtr<InterpolableValue> InterpolableNumber::interpolate(const InterpolableValue &to, const double progress) const DEFINE_EMPTY_DESTRUCTOR_WILL_BE_REMOVED(InterpolableValue);
PassOwnPtrWillBeRawPtr<InterpolableValue> InterpolableNumber::interpolate(const InterpolableValue &to, const double progress) const
{ {
const InterpolableNumber* toNumber = toInterpolableNumber(&to); const InterpolableNumber* toNumber = toInterpolableNumber(&to);
if (!progress) if (!progress)
...@@ -17,7 +19,7 @@ PassOwnPtr<InterpolableValue> InterpolableNumber::interpolate(const Interpolable ...@@ -17,7 +19,7 @@ PassOwnPtr<InterpolableValue> InterpolableNumber::interpolate(const Interpolable
return create(m_value * (1 - progress) + toNumber->m_value * progress); return create(m_value * (1 - progress) + toNumber->m_value * progress);
} }
PassOwnPtr<InterpolableValue> InterpolableBool::interpolate(const InterpolableValue &to, const double progress) const PassOwnPtrWillBeRawPtr<InterpolableValue> InterpolableBool::interpolate(const InterpolableValue &to, const double progress) const
{ {
if (progress < 0.5) { if (progress < 0.5) {
return clone(); return clone();
...@@ -25,7 +27,7 @@ PassOwnPtr<InterpolableValue> InterpolableBool::interpolate(const InterpolableVa ...@@ -25,7 +27,7 @@ PassOwnPtr<InterpolableValue> InterpolableBool::interpolate(const InterpolableVa
return to.clone(); return to.clone();
} }
PassOwnPtr<InterpolableValue> InterpolableList::interpolate(const InterpolableValue &to, const double progress) const PassOwnPtrWillBeRawPtr<InterpolableValue> InterpolableList::interpolate(const InterpolableValue &to, const double progress) const
{ {
const InterpolableList* toList = toInterpolableList(&to); const InterpolableList* toList = toInterpolableList(&to);
ASSERT(toList->m_size == m_size); ASSERT(toList->m_size == m_size);
...@@ -37,16 +39,23 @@ PassOwnPtr<InterpolableValue> InterpolableList::interpolate(const InterpolableVa ...@@ -37,16 +39,23 @@ PassOwnPtr<InterpolableValue> InterpolableList::interpolate(const InterpolableVa
return InterpolableList::create(*toList); return InterpolableList::create(*toList);
} }
OwnPtr<InterpolableList> result = create(m_size); OwnPtrWillBeRawPtr<InterpolableList> result = create(m_size);
for (size_t i = 0; i < m_size; i++) { for (size_t i = 0; i < m_size; i++) {
ASSERT(m_values.get()[i]); ASSERT(m_values[i]);
ASSERT(toList->m_values.get()[i]); ASSERT(toList->m_values[i]);
result->set(i, m_values.get()[i]->interpolate(*(toList->m_values.get()[i]), progress)); result->set(i, m_values[i]->interpolate(*(toList->m_values[i]), progress));
} }
return result.release(); return result.release();
} }
PassOwnPtr<InterpolableValue> InterpolableAnimatableValue::interpolate(const InterpolableValue &other, const double percentage) const void InterpolableList::trace(Visitor* visitor)
{
#if ENABLE_OILPAN
visitor->trace(m_values);
#endif
}
PassOwnPtrWillBeRawPtr<InterpolableValue> InterpolableAnimatableValue::interpolate(const InterpolableValue &other, const double percentage) const
{ {
const InterpolableAnimatableValue *otherValue = toInterpolableAnimatableValue(&other); const InterpolableAnimatableValue *otherValue = toInterpolableAnimatableValue(&other);
if (!percentage) if (!percentage)
...@@ -56,4 +65,9 @@ PassOwnPtr<InterpolableValue> InterpolableAnimatableValue::interpolate(const Int ...@@ -56,4 +65,9 @@ PassOwnPtr<InterpolableValue> InterpolableAnimatableValue::interpolate(const Int
return create(AnimatableValue::interpolate(m_value.get(), otherValue->m_value.get(), percentage)); return create(AnimatableValue::interpolate(m_value.get(), otherValue->m_value.get(), percentage));
} }
void InterpolableAnimatableValue::trace(Visitor* visitor)
{
visitor->trace(m_value);
}
} }
...@@ -8,21 +8,24 @@ ...@@ -8,21 +8,24 @@
#include "core/animation/AnimatableValue.h" #include "core/animation/AnimatableValue.h"
#include "wtf/OwnPtr.h" #include "wtf/OwnPtr.h"
#include "wtf/PassOwnPtr.h" #include "wtf/PassOwnPtr.h"
#include "wtf/Vector.h"
namespace WebCore { namespace WebCore {
class InterpolableValue { class InterpolableValue : public NoBaseWillBeGarbageCollected<InterpolableValue> {
DECLARE_EMPTY_VIRTUAL_DESTRUCTOR_WILL_BE_REMOVED(InterpolableValue);
public: public:
virtual bool isNumber() const { return false; } virtual bool isNumber() const { return false; }
virtual bool isBool() const { return false; } virtual bool isBool() const { return false; }
virtual bool isList() const { return false; } virtual bool isList() const { return false; }
virtual bool isAnimatableValue() const { return false; } virtual bool isAnimatableValue() const { return false; }
virtual ~InterpolableValue() { } virtual PassOwnPtrWillBeRawPtr<InterpolableValue> clone() const = 0;
virtual PassOwnPtr<InterpolableValue> clone() const = 0;
virtual void trace(Visitor*) = 0;
private: private:
virtual PassOwnPtr<InterpolableValue> interpolate(const InterpolableValue &to, const double progress) const = 0; virtual PassOwnPtrWillBeRawPtr<InterpolableValue> interpolate(const InterpolableValue &to, const double progress) const = 0;
friend class Interpolation; friend class Interpolation;
...@@ -35,111 +38,124 @@ private: ...@@ -35,111 +38,124 @@ private:
class InterpolableNumber : public InterpolableValue { class InterpolableNumber : public InterpolableValue {
public: public:
static PassOwnPtr<InterpolableNumber> create(double value) static PassOwnPtrWillBeRawPtr<InterpolableNumber> create(double value)
{ {
return adoptPtr(new InterpolableNumber(value)); return adoptPtrWillBeNoop(new InterpolableNumber(value));
} }
virtual bool isNumber() const OVERRIDE FINAL { return true; } virtual bool isNumber() const OVERRIDE FINAL { return true; }
double value() const { return m_value; } double value() const { return m_value; }
virtual PassOwnPtr<InterpolableValue> clone() const OVERRIDE FINAL { return create(m_value); } virtual PassOwnPtrWillBeRawPtr<InterpolableValue> clone() const OVERRIDE FINAL { return create(m_value); }
virtual void trace(Visitor*) OVERRIDE { }
private: private:
virtual PassOwnPtr<InterpolableValue> interpolate(const InterpolableValue &to, const double progress) const OVERRIDE FINAL; virtual PassOwnPtrWillBeRawPtr<InterpolableValue> interpolate(const InterpolableValue &to, const double progress) const OVERRIDE FINAL;
double m_value; double m_value;
InterpolableNumber(double value) explicit InterpolableNumber(double value)
: m_value(value) : m_value(value)
{ } {
}
}; };
class InterpolableBool : public InterpolableValue { class InterpolableBool : public InterpolableValue {
public: public:
static PassOwnPtr<InterpolableBool> create(bool value) static PassOwnPtrWillBeRawPtr<InterpolableBool> create(bool value)
{ {
return adoptPtr(new InterpolableBool(value)); return adoptPtrWillBeNoop(new InterpolableBool(value));
} }
virtual bool isBool() const OVERRIDE FINAL { return true; } virtual bool isBool() const OVERRIDE FINAL { return true; }
bool value() const { return m_value; } bool value() const { return m_value; }
virtual PassOwnPtr<InterpolableValue> clone() const OVERRIDE FINAL { return create(m_value); } virtual PassOwnPtrWillBeRawPtr<InterpolableValue> clone() const OVERRIDE FINAL { return create(m_value); }
virtual void trace(Visitor*) OVERRIDE { }
private: private:
virtual PassOwnPtr<InterpolableValue> interpolate(const InterpolableValue &to, const double progress) const OVERRIDE FINAL; virtual PassOwnPtrWillBeRawPtr<InterpolableValue> interpolate(const InterpolableValue &to, const double progress) const OVERRIDE FINAL;
bool m_value; bool m_value;
InterpolableBool(bool value) explicit InterpolableBool(bool value)
: m_value(value) : m_value(value)
{ } {
}
}; };
class InterpolableList : public InterpolableValue { class InterpolableList : public InterpolableValue {
public: public:
static PassOwnPtr<InterpolableList> create(const InterpolableList &other) static PassOwnPtrWillBeRawPtr<InterpolableList> create(const InterpolableList &other)
{ {
return adoptPtr(new InterpolableList(other)); return adoptPtrWillBeNoop(new InterpolableList(other));
} }
static PassOwnPtr<InterpolableList> create(size_t size) static PassOwnPtrWillBeRawPtr<InterpolableList> create(size_t size)
{ {
return adoptPtr(new InterpolableList(size)); return adoptPtrWillBeNoop(new InterpolableList(size));
} }
virtual bool isList() const OVERRIDE FINAL { return true; } virtual bool isList() const OVERRIDE FINAL { return true; }
void set(size_t position, PassOwnPtr<InterpolableValue> value) void set(size_t position, PassOwnPtrWillBeRawPtr<InterpolableValue> value)
{ {
ASSERT(position < m_size); ASSERT(position < m_size);
m_values.get()[position] = value; m_values[position] = value;
} }
const InterpolableValue* get(size_t position) const const InterpolableValue* get(size_t position) const
{ {
ASSERT(position < m_size); ASSERT(position < m_size);
return m_values.get()[position].get(); return m_values[position].get();
} }
size_t length() const { return m_size; } size_t length() const { return m_size; }
virtual PassOwnPtr<InterpolableValue> clone() const OVERRIDE FINAL { return create(*this); } virtual PassOwnPtrWillBeRawPtr<InterpolableValue> clone() const OVERRIDE FINAL { return create(*this); }
virtual void trace(Visitor*) OVERRIDE;
private: private:
virtual PassOwnPtr<InterpolableValue> interpolate(const InterpolableValue &other, const double progress) const OVERRIDE FINAL; virtual PassOwnPtrWillBeRawPtr<InterpolableValue> interpolate(const InterpolableValue &other, const double progress) const OVERRIDE FINAL;
InterpolableList(size_t size) explicit InterpolableList(size_t size)
: m_size(size) : m_size(size)
{ {
m_values = adoptArrayPtr(new OwnPtr<InterpolableValue>[size]); m_values.reserveCapacity(m_size);
m_values.resize(m_size);
} }
InterpolableList(const InterpolableList& other) InterpolableList(const InterpolableList& other)
: m_size(other.m_size) : m_size(other.m_size)
{ {
m_values = adoptArrayPtr(new OwnPtr<InterpolableValue>[m_size]); m_values.reserveCapacity(m_size);
m_values.resize(m_size);
for (size_t i = 0; i < m_size; i++) for (size_t i = 0; i < m_size; i++)
set(i, other.m_values.get()[i]->clone()); set(i, other.m_values[i]->clone());
} }
size_t m_size; size_t m_size;
OwnPtr<OwnPtr<InterpolableValue>[]> m_values; WillBeHeapVector<OwnPtrWillBeMember<InterpolableValue> > m_values;
}; };
// FIXME: Remove this when we can. // FIXME: Remove this when we can.
class InterpolableAnimatableValue : public InterpolableValue { class InterpolableAnimatableValue : public InterpolableValue {
public: public:
static PassOwnPtr<InterpolableAnimatableValue> create(PassRefPtrWillBeRawPtr<AnimatableValue> value) static PassOwnPtrWillBeRawPtr<InterpolableAnimatableValue> create(PassRefPtrWillBeRawPtr<AnimatableValue> value)
{ {
return adoptPtr(new InterpolableAnimatableValue(value)); return adoptPtrWillBeNoop(new InterpolableAnimatableValue(value));
} }
virtual bool isAnimatableValue() const OVERRIDE FINAL { return true; } virtual bool isAnimatableValue() const OVERRIDE FINAL { return true; }
AnimatableValue* value() const { return m_value.get(); } AnimatableValue* value() const { return m_value.get(); }
virtual PassOwnPtr<InterpolableValue> clone() const OVERRIDE FINAL { return create(m_value); } virtual PassOwnPtrWillBeRawPtr<InterpolableValue> clone() const OVERRIDE FINAL { return create(m_value); }
virtual void trace(Visitor*) OVERRIDE;
private: private:
virtual PassOwnPtr<InterpolableValue> interpolate(const InterpolableValue &other, const double progress) const OVERRIDE FINAL; virtual PassOwnPtrWillBeRawPtr<InterpolableValue> interpolate(const InterpolableValue &other, const double progress) const OVERRIDE FINAL;
RefPtrWillBePersistent<AnimatableValue> m_value; RefPtrWillBeMember<AnimatableValue> m_value;
InterpolableAnimatableValue(PassRefPtrWillBeRawPtr<AnimatableValue> value) InterpolableAnimatableValue(PassRefPtrWillBeRawPtr<AnimatableValue> value)
: m_value(value) : m_value(value)
{ } {
}
}; };
DEFINE_TYPE_CASTS(InterpolableNumber, InterpolableValue, value, value->isNumber(), value.isNumber()); DEFINE_TYPE_CASTS(InterpolableNumber, InterpolableValue, value, value->isNumber(), value.isNumber());
......
...@@ -32,7 +32,7 @@ protected: ...@@ -32,7 +32,7 @@ protected:
return toInterpolableBool(interpolationValue(*i.get()))->value(); return toInterpolableBool(interpolationValue(*i.get()))->value();
} }
PassRefPtrWillBeRawPtr<Interpolation> interpolateLists(PassOwnPtr<InterpolableList> listA, PassOwnPtr<InterpolableList> listB, double progress) PassRefPtrWillBeRawPtr<Interpolation> interpolateLists(PassOwnPtrWillBeRawPtr<InterpolableList> listA, PassOwnPtrWillBeRawPtr<InterpolableList> listB, double progress)
{ {
RefPtrWillBeRawPtr<Interpolation> i = Interpolation::create(listA, listB); RefPtrWillBeRawPtr<Interpolation> i = Interpolation::create(listA, listB);
i->interpolate(0, progress); i->interpolate(0, progress);
...@@ -62,12 +62,12 @@ TEST_F(AnimationInterpolableValueTest, InterpolateBools) ...@@ -62,12 +62,12 @@ TEST_F(AnimationInterpolableValueTest, InterpolateBools)
TEST_F(AnimationInterpolableValueTest, SimpleList) TEST_F(AnimationInterpolableValueTest, SimpleList)
{ {
OwnPtr<InterpolableList> listA = InterpolableList::create(3); OwnPtrWillBeRawPtr<InterpolableList> listA = InterpolableList::create(3);
listA->set(0, InterpolableNumber::create(0)); listA->set(0, InterpolableNumber::create(0));
listA->set(1, InterpolableNumber::create(42)); listA->set(1, InterpolableNumber::create(42));
listA->set(2, InterpolableNumber::create(20.5)); listA->set(2, InterpolableNumber::create(20.5));
OwnPtr<InterpolableList> listB = InterpolableList::create(3); OwnPtrWillBeRawPtr<InterpolableList> listB = InterpolableList::create(3);
listB->set(0, InterpolableNumber::create(100)); listB->set(0, InterpolableNumber::create(100));
listB->set(1, InterpolableNumber::create(-200)); listB->set(1, InterpolableNumber::create(-200));
listB->set(2, InterpolableNumber::create(300)); listB->set(2, InterpolableNumber::create(300));
...@@ -81,16 +81,16 @@ TEST_F(AnimationInterpolableValueTest, SimpleList) ...@@ -81,16 +81,16 @@ TEST_F(AnimationInterpolableValueTest, SimpleList)
TEST_F(AnimationInterpolableValueTest, NestedList) TEST_F(AnimationInterpolableValueTest, NestedList)
{ {
OwnPtr<InterpolableList> listA = InterpolableList::create(3); OwnPtrWillBeRawPtr<InterpolableList> listA = InterpolableList::create(3);
listA->set(0, InterpolableNumber::create(0)); listA->set(0, InterpolableNumber::create(0));
OwnPtr<InterpolableList> subListA = InterpolableList::create(1); OwnPtrWillBeRawPtr<InterpolableList> subListA = InterpolableList::create(1);
subListA->set(0, InterpolableNumber::create(100)); subListA->set(0, InterpolableNumber::create(100));
listA->set(1, subListA.release()); listA->set(1, subListA.release());
listA->set(2, InterpolableBool::create(false)); listA->set(2, InterpolableBool::create(false));
OwnPtr<InterpolableList> listB = InterpolableList::create(3); OwnPtrWillBeRawPtr<InterpolableList> listB = InterpolableList::create(3);
listB->set(0, InterpolableNumber::create(100)); listB->set(0, InterpolableNumber::create(100));
OwnPtr<InterpolableList> subListB = InterpolableList::create(1); OwnPtrWillBeRawPtr<InterpolableList> subListB = InterpolableList::create(1);
subListB->set(0, InterpolableNumber::create(50)); subListB->set(0, InterpolableNumber::create(50));
listB->set(1, subListB.release()); listB->set(1, subListB.release());
listB->set(2, InterpolableBool::create(true)); listB->set(2, InterpolableBool::create(true));
......
...@@ -10,6 +10,8 @@ ...@@ -10,6 +10,8 @@
namespace WebCore { namespace WebCore {
DEFINE_EMPTY_DESTRUCTOR_WILL_BE_REMOVED(Interpolation);
namespace { namespace {
bool typesMatch(const InterpolableValue* start, const InterpolableValue* end) bool typesMatch(const InterpolableValue* start, const InterpolableValue* end)
...@@ -35,7 +37,7 @@ bool typesMatch(const InterpolableValue* start, const InterpolableValue* end) ...@@ -35,7 +37,7 @@ bool typesMatch(const InterpolableValue* start, const InterpolableValue* end)
} }
Interpolation::Interpolation(PassOwnPtr<InterpolableValue> start, PassOwnPtr<InterpolableValue> end) Interpolation::Interpolation(PassOwnPtrWillBeRawPtr<InterpolableValue> start, PassOwnPtrWillBeRawPtr<InterpolableValue> end)
: m_start(start) : m_start(start)
, m_end(end) , m_end(end)
, m_cachedFraction(0) , m_cachedFraction(0)
...@@ -54,6 +56,13 @@ void Interpolation::interpolate(int iteration, double fraction) const ...@@ -54,6 +56,13 @@ void Interpolation::interpolate(int iteration, double fraction) const
} }
} }
void Interpolation::trace(Visitor* visitor)
{
visitor->trace(m_start);
visitor->trace(m_end);
visitor->trace(m_cachedValue);
}
void StyleInterpolation::trace(Visitor* visitor) void StyleInterpolation::trace(Visitor* visitor)
{ {
Interpolation::trace(visitor); Interpolation::trace(visitor);
......
...@@ -14,9 +14,10 @@ namespace WebCore { ...@@ -14,9 +14,10 @@ namespace WebCore {
class StyleResolverState; class StyleResolverState;
class Interpolation : public RefCountedWillBeGarbageCollectedFinalized<Interpolation> { class Interpolation : public RefCountedWillBeGarbageCollected<Interpolation> {
DECLARE_EMPTY_VIRTUAL_DESTRUCTOR_WILL_BE_REMOVED(Interpolation);
public: public:
static PassRefPtrWillBeRawPtr<Interpolation> create(PassOwnPtr<InterpolableValue> start, PassOwnPtr<InterpolableValue> end) static PassRefPtrWillBeRawPtr<Interpolation> create(PassOwnPtrWillBeRawPtr<InterpolableValue> start, PassOwnPtrWillBeRawPtr<InterpolableValue> end)
{ {
return adoptRefWillBeNoop(new Interpolation(start, end)); return adoptRefWillBeNoop(new Interpolation(start, end));
} }
...@@ -26,19 +27,17 @@ public: ...@@ -26,19 +27,17 @@ public:
virtual bool isStyleInterpolation() const { return false; } virtual bool isStyleInterpolation() const { return false; }
virtual bool isLegacyStyleInterpolation() const { return false; } virtual bool isLegacyStyleInterpolation() const { return false; }
virtual ~Interpolation() { } virtual void trace(Visitor*);
virtual void trace(Visitor*) { }
protected: protected:
const OwnPtr<InterpolableValue> m_start; const OwnPtrWillBeMember<InterpolableValue> m_start;
const OwnPtr<InterpolableValue> m_end; const OwnPtrWillBeMember<InterpolableValue> m_end;
mutable double m_cachedFraction; mutable double m_cachedFraction;
mutable int m_cachedIteration; mutable int m_cachedIteration;
mutable OwnPtr<InterpolableValue> m_cachedValue; mutable OwnPtrWillBeMember<InterpolableValue> m_cachedValue;
Interpolation(PassOwnPtr<InterpolableValue> start, PassOwnPtr<InterpolableValue> end); Interpolation(PassOwnPtrWillBeRawPtr<InterpolableValue> start, PassOwnPtrWillBeRawPtr<InterpolableValue> end);
private: private:
InterpolableValue* getCachedValueForTesting() const { return m_cachedValue.get(); } InterpolableValue* getCachedValueForTesting() const { return m_cachedValue.get(); }
...@@ -67,7 +66,7 @@ public: ...@@ -67,7 +66,7 @@ public:
protected: protected:
CSSPropertyID m_id; CSSPropertyID m_id;
StyleInterpolation(PassOwnPtr<InterpolableValue> start, PassOwnPtr<InterpolableValue> end, CSSPropertyID id) StyleInterpolation(PassOwnPtrWillBeRawPtr<InterpolableValue> start, PassOwnPtrWillBeRawPtr<InterpolableValue> end, CSSPropertyID id)
: Interpolation(start, end) : Interpolation(start, end)
, m_id(id) , m_id(id)
{ {
...@@ -93,7 +92,7 @@ public: ...@@ -93,7 +92,7 @@ public:
virtual void trace(Visitor*) OVERRIDE; virtual void trace(Visitor*) OVERRIDE;
private: private:
LegacyStyleInterpolation(PassOwnPtr<InterpolableValue> start, PassOwnPtr<InterpolableValue> end, CSSPropertyID id) LegacyStyleInterpolation(PassOwnPtrWillBeRawPtr<InterpolableValue> start, PassOwnPtrWillBeRawPtr<InterpolableValue> end, CSSPropertyID id)
: StyleInterpolation(start, end, id) : StyleInterpolation(start, end, id)
{ {
} }
......
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment