Oilpan: Unship oilpan from temporary animation objects

Source/core/animation/animatable/AnimatableFilterOperations.h

 /*
  * 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 20 matching lines @@
 #ifndef AnimatableFilterOperations_h
 #define AnimatableFilterOperations_h
 
 #include "core/animation/animatable/AnimatableValue.h"
 #include "platform/graphics/filters/FilterOperations.h"
 
 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());
 
 } // namespace blink
 
 #endif // AnimatableFilterOperations_h