Oilpan: Unship oilpan from temporary animation objects

Source/core/animation/animatable/AnimatableFilterOperations.h

Index: Source/core/animation/animatable/AnimatableFilterOperations.h
diff --git a/Source/core/animation/animatable/AnimatableFilterOperations.h b/Source/core/animation/animatable/AnimatableFilterOperations.h
index 073155a23bb5e394b095a4a1c535fbb719a8702f..915fbd8ba47d4e79e8ed56fc341befd5969198aa 100644
--- a/Source/core/animation/animatable/AnimatableFilterOperations.h
+++ b/Source/core/animation/animatable/AnimatableFilterOperations.h
@@ -38,30 +38,44 @@ namespace blink {
 
 class AnimatableFilterOperations final : public AnimatableValue {
 public:
-    static PassRefPtrWillBeRawPtr<AnimatableFilterOperations> create(const FilterOperations& operations)
+    static PassRefPtr<AnimatableFilterOperations> create(const FilterOperations& operations)
     {
-        return adoptRefWillBeNoop(new AnimatableFilterOperations(operations));
+        return adoptRef(new AnimatableFilterOperations(operations));
     }
 
     ~AnimatableFilterOperations() override { }
-    DECLARE_VIRTUAL_TRACE();
 
-    const FilterOperations& operations() const { return m_operations; }
+    const FilterOperations& operations() const
+    {
+#if ENABLE(OILPAN)
+        return m_operationWrapper->operations();
+#else
+        return m_operations;
+#endif
+    }
 
 protected:
-    PassRefPtrWillBeRawPtr<AnimatableValue> interpolateTo(const AnimatableValue*, double fraction) const override;
+    PassRefPtr<AnimatableValue> interpolateTo(const AnimatableValue*, double fraction) const override;
     bool usesDefaultInterpolationWith(const AnimatableValue*) const override;
 
 private:
     AnimatableFilterOperations(const FilterOperations& operations)
+#if ENABLE(OILPAN)
+        : m_operationWrapper(FilterOperationsWrapper::create(operations))
+#else
         : m_operations(operations)
+#endif
     {
     }
 
     bool equalTo(const AnimatableValue*) const override;
     AnimatableType type() const override { return TypeFilterOperations; }
 
+#if ENABLE(OILPAN)
+    Persistent<FilterOperationsWrapper> m_operationWrapper;

[alancutter (OOO until 2018), 2015/09/03 02:28:09]

Why do we need to wrap the non Oilpanned FilterOperations in an Oilpanned object
that gets pointed to by a non Oilpanned object?

[haraken, 2015/09/03 02:40:12]

Your point is valid and I'm planning to remove the complexity in the future.

- FilterOperations is GarbageCollected (i.e., allocated with 'new').

- We don't want to allow GarbageCollected objects to get allocated as a compound
object because the compound object doesn't have an object header. If someone
makes a programming mistake and stores the pointer to the compound object into
Member<FilterOperations>, it can cause security issues when Oilpan traces the
Member (because the FilterOperations object doesn't have a valid header). Thus
we want to forbid GarbageCollected objects to get allocated as a compound
object. This is why we use FilterOperationsWrapper.

- However, I've already added asserts to Member's constructor etc to verify that
an object stored in the Member has a valid header. Assuming that the asserts are
sufficient, we can remove the restriction I mentioned above.

- Actually I'm not yet sure if we should force the restriction (for safety) or
remove the restriction (for convenience). It seems that the number of places
where we want to use GarbageCollected objects as compound classes is pretty
limited, I'm leaning toward to forcing the restriction. But I need more study.

(Either way, I'd like to keep the FilterOperationsWrapper at least in this CL.)

+#else
     FilterOperations m_operations;
+#endif
 };
 
 DEFINE_ANIMATABLE_VALUE_TYPE_CASTS(AnimatableFilterOperations, isFilterOperations());