Skip to content

GitLab

T
tangled
Commit 0d3f9e02 authored by haraken@chromium.org's avatar haraken@chromium.org
Browse files
Options

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
Show whitespace changes
Inline Side-by-side
Showing with 101 additions and 63 deletions
third_party/WebKit/Source/core/animation/InterpolableValue.cpp
View file @ 0d3f9e02
......@@ -7,7 +7,9 @@
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);
if (!progress)
......@@ -17,7 +19,7 @@ PassOwnPtr<InterpolableValue> InterpolableNumber::interpolate(const Interpolable
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) {
return clone();
......@@ -25,7 +27,7 @@ PassOwnPtr<InterpolableValue> InterpolableBool::interpolate(const InterpolableVa
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);
ASSERT(toList->m_size == m_size);
......@@ -37,16 +39,23 @@ PassOwnPtr<InterpolableValue> InterpolableList::interpolate(const InterpolableVa
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++) {
ASSERT(m_values.get()[i]);
ASSERT(toList->m_values.get()[i]);
result->set(i, m_values.get()[i]->interpolate(*(toList->m_values.get()[i]), progress));
ASSERT(m_values[i]);
ASSERT(toList->m_values[i]);
result->set(i, m_values[i]->interpolate(*(toList->m_values[i]), progress));
}
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);
if (!percentage)
......@@ -56,4 +65,9 @@ PassOwnPtr<InterpolableValue> InterpolableAnimatableValue::interpolate(const Int
return create(AnimatableValue::interpolate(m_value.get(), otherValue->m_value.get(), percentage));
}
void InterpolableAnimatableValue::trace(Visitor* visitor)
{
visitor->trace(m_value);
}
}
third_party/WebKit/Source/core/animation/InterpolableValue.h
View file @ 0d3f9e02
......@@ -8,21 +8,24 @@
#include "core/animation/AnimatableValue.h"
#include "wtf/OwnPtr.h"
#include "wtf/PassOwnPtr.h"
#include "wtf/Vector.h"
namespace WebCore {
class InterpolableValue {
class InterpolableValue : public NoBaseWillBeGarbageCollected<InterpolableValue> {
DECLARE_EMPTY_VIRTUAL_DESTRUCTOR_WILL_BE_REMOVED(InterpolableValue);
public:
virtual bool isNumber() const { return false; }
virtual bool isBool() const { return false; }
virtual bool isList() const { return false; }
virtual bool isAnimatableValue() const { return false; }
virtual ~InterpolableValue() { }
virtual PassOwnPtr<InterpolableValue> clone() const = 0;
virtual PassOwnPtrWillBeRawPtr<InterpolableValue> clone() const = 0;
virtual void trace(Visitor*) = 0;
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;
......@@ -35,111 +38,124 @@ private:
class InterpolableNumber : public InterpolableValue {
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; }
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:
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;
InterpolableNumber(double value)
explicit InterpolableNumber(double value)
: m_value(value)
{ }
{
}
};
class InterpolableBool : public InterpolableValue {
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; }
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:
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;
InterpolableBool(bool value)
explicit InterpolableBool(bool value)
: m_value(value)
{ }
{
}
};
class InterpolableList : public InterpolableValue {
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; }
void set(size_t position, PassOwnPtr<InterpolableValue> value)
void set(size_t position, PassOwnPtrWillBeRawPtr<InterpolableValue> value)
{
ASSERT(position < m_size);
m_values.get()[position] = value;
m_values[position] = value;
}
const InterpolableValue* get(size_t position) const
{
ASSERT(position < m_size);
return m_values.get()[position].get();
return m_values[position].get();
}
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:
virtual PassOwnPtr<InterpolableValue> interpolate(const InterpolableValue &other, const double progress) const OVERRIDE FINAL;
InterpolableList(size_t size)
virtual PassOwnPtrWillBeRawPtr<InterpolableValue> interpolate(const InterpolableValue &other, const double progress) const OVERRIDE FINAL;
explicit InterpolableList(size_t 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)
: 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++)
set(i, other.m_values.get()[i]->clone());
set(i, other.m_values[i]->clone());
}
size_t m_size;
OwnPtr<OwnPtr<InterpolableValue>[]> m_values;
WillBeHeapVector<OwnPtrWillBeMember<InterpolableValue> > m_values;
};
// FIXME: Remove this when we can.
class InterpolableAnimatableValue : public InterpolableValue {
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; }
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:
virtual PassOwnPtr<InterpolableValue> interpolate(const InterpolableValue &other, const double progress) const OVERRIDE FINAL;
RefPtrWillBePersistent<AnimatableValue> m_value;
virtual PassOwnPtrWillBeRawPtr<InterpolableValue> interpolate(const InterpolableValue &other, const double progress) const OVERRIDE FINAL;
RefPtrWillBeMember<AnimatableValue> m_value;
InterpolableAnimatableValue(PassRefPtrWillBeRawPtr<AnimatableValue> value)
: m_value(value)
{ }
{
}
};
DEFINE_TYPE_CASTS(InterpolableNumber, InterpolableValue, value, value->isNumber(), value.isNumber());
......
third_party/WebKit/Source/core/animation/InterpolableValueTest.cpp
View file @ 0d3f9e02
......@@ -32,7 +32,7 @@ protected:
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);
i->interpolate(0, progress);
......@@ -62,12 +62,12 @@ TEST_F(AnimationInterpolableValueTest, InterpolateBools)
TEST_F(AnimationInterpolableValueTest, SimpleList)
{
OwnPtr<InterpolableList> listA = InterpolableList::create(3);
OwnPtrWillBeRawPtr<InterpolableList> listA = InterpolableList::create(3);
listA->set(0, InterpolableNumber::create(0));
listA->set(1, InterpolableNumber::create(42));
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(1, InterpolableNumber::create(-200));
listB->set(2, InterpolableNumber::create(300));
......@@ -81,16 +81,16 @@ TEST_F(AnimationInterpolableValueTest, SimpleList)
TEST_F(AnimationInterpolableValueTest, NestedList)
{
OwnPtr<InterpolableList> listA = InterpolableList::create(3);
OwnPtrWillBeRawPtr<InterpolableList> listA = InterpolableList::create(3);
listA->set(0, InterpolableNumber::create(0));
OwnPtr<InterpolableList> subListA = InterpolableList::create(1);
OwnPtrWillBeRawPtr<InterpolableList> subListA = InterpolableList::create(1);
subListA->set(0, InterpolableNumber::create(100));
listA->set(1, subListA.release());
listA->set(2, InterpolableBool::create(false));
OwnPtr<InterpolableList> listB = InterpolableList::create(3);
OwnPtrWillBeRawPtr<InterpolableList> listB = InterpolableList::create(3);
listB->set(0, InterpolableNumber::create(100));
OwnPtr<InterpolableList> subListB = InterpolableList::create(1);
OwnPtrWillBeRawPtr<InterpolableList> subListB = InterpolableList::create(1);
subListB->set(0, InterpolableNumber::create(50));
listB->set(1, subListB.release());
listB->set(2, InterpolableBool::create(true));
......
third_party/WebKit/Source/core/animation/Interpolation.cpp
View file @ 0d3f9e02
......@@ -10,6 +10,8 @@
namespace WebCore {
DEFINE_EMPTY_DESTRUCTOR_WILL_BE_REMOVED(Interpolation);
namespace {
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_end(end)
, m_cachedFraction(0)
......@@ -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)
{
Interpolation::trace(visitor);
......
third_party/WebKit/Source/core/animation/Interpolation.h
View file @ 0d3f9e02
......@@ -14,9 +14,10 @@ namespace WebCore {
class StyleResolverState;
class Interpolation : public RefCountedWillBeGarbageCollectedFinalized<Interpolation> {
class Interpolation : public RefCountedWillBeGarbageCollected<Interpolation> {
DECLARE_EMPTY_VIRTUAL_DESTRUCTOR_WILL_BE_REMOVED(Interpolation);
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));
}
......@@ -26,19 +27,17 @@ public:
virtual bool isStyleInterpolation() const { return false; }
virtual bool isLegacyStyleInterpolation() const { return false; }
virtual ~Interpolation() { }
virtual void trace(Visitor*) { }
virtual void trace(Visitor*);
protected:
const OwnPtr<InterpolableValue> m_start;
const OwnPtr<InterpolableValue> m_end;
const OwnPtrWillBeMember<InterpolableValue> m_start;
const OwnPtrWillBeMember<InterpolableValue> m_end;
mutable double m_cachedFraction;
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:
InterpolableValue* getCachedValueForTesting() const { return m_cachedValue.get(); }
......@@ -67,7 +66,7 @@ public:
protected:
CSSPropertyID m_id;
StyleInterpolation(PassOwnPtr<InterpolableValue> start, PassOwnPtr<InterpolableValue> end, CSSPropertyID id)
StyleInterpolation(PassOwnPtrWillBeRawPtr<InterpolableValue> start, PassOwnPtrWillBeRawPtr<InterpolableValue> end, CSSPropertyID id)
: Interpolation(start, end)
, m_id(id)
{
......@@ -93,7 +92,7 @@ public:
virtual void trace(Visitor*) OVERRIDE;
private:
LegacyStyleInterpolation(PassOwnPtr<InterpolableValue> start, PassOwnPtr<InterpolableValue> end, CSSPropertyID id)
LegacyStyleInterpolation(PassOwnPtrWillBeRawPtr<InterpolableValue> start, PassOwnPtrWillBeRawPtr<InterpolableValue> end, CSSPropertyID 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