Oilpan: move AsyncMethodRunner to the heap.

third_party/WebKit/Source/platform/AsyncMethodRunner.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 AsyncMethodRunner_h
 #define AsyncMethodRunner_h
 
 #include "platform/Timer.h"
 #include "wtf/Allocator.h"
 #include "wtf/Noncopyable.h"
 
 namespace blink {
 
 template <typename TargetClass>
-class AsyncMethodRunner final {
+class AsyncMethodRunner final : public GarbageCollectedFinalized<AsyncMethodRunner<TargetClass>> {
     WTF_MAKE_NONCOPYABLE(AsyncMethodRunner);
-    USING_FAST_MALLOC(AsyncMethodRunner);
 public:
     typedef void (TargetClass::*TargetMethod)();
 
-    AsyncMethodRunner(TargetClass* object, TargetMethod method)
-        : m_timer(this, &AsyncMethodRunner<TargetClass>::fired)
-        , m_object(object)
-        , m_method(method)
-        , m_suspended(false)
-        , m_runWhenResumed(false)
+    static AsyncMethodRunner* create(TargetClass* object, TargetMethod method)
+    {
+        return new AsyncMethodRunner(object, method);
+    }
+
+    ~AsyncMethodRunner()
     {
     }
 
     // Schedules to run the method asynchronously. Do nothing if it's already
     // scheduled. If it's suspended, remember to schedule to run the method when
     // resume() is called.
     void runAsync()
     {
         if (m_suspended) {
             ASSERT(!m_timer.isActive());
@@ skipping 49 matching lines @@
         ASSERT(!m_runWhenResumed);
         if (m_timer.isActive())
             m_timer.stop();
     }
 
     bool isActive() const
     {
         return m_timer.isActive();
     }
 
+    DEFINE_INLINE_TRACE()
+    {
+#if ENABLE(OILPAN)
+        visitor->trace(m_object);
+#else
+        TraceIfNeeded<typename PointerFieldStorageTrait<TargetClass>::Type>::trace(visitor, m_object);
+#endif
+    }
+
 private:
+    AsyncMethodRunner(TargetClass* object, TargetMethod method)
+        : m_timer(this, &AsyncMethodRunner<TargetClass>::fired)
+        , m_object(object)
+        , m_method(method)
+        , m_suspended(false)
+        , m_runWhenResumed(false)
+    {
+    }
+
     void fired(Timer<AsyncMethodRunner<TargetClass>>*)
     {
-        // TODO(Oilpan): when AsyncMethodRunner is on the heap, this check becomes
-        // redundant; handled directly by Timer<> instead.
-        if (!TimerIsObjectAliveTrait<TargetClass>::isHeapObjectAlive(m_object))
-            return;
         (m_object->*m_method)();
     }
 
     Timer<AsyncMethodRunner<TargetClass>> m_timer;
 
-    // TODO(Oilpan): AsyncMethodRunner should be moved to the heap and m_object should be traced.
-    // This raw pointer is safe as long as AsyncMethodRunner<X> is held by the X itself
-    // (That's the case in the current code base).
-    GC_PLUGIN_IGNORE("363031")
-    TargetClass* m_object;
+#if ENABLE(OILPAN)
+    Member<TargetClass> m_object;
+#else
+    typename PointerFieldStorageTrait<TargetClass>::Type m_object;
+#endif
     TargetMethod m_method;
 
     bool m_suspended;
     bool m_runWhenResumed;
 };
 
 }
 
 #endif