Oilpan: Move MainThreadTaskRunner into Oilpan heap.

Source/core/dom/MainThreadTaskRunner.cpp

 /*
  * 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:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 20 matching lines @@
 #include "core/dom/ExecutionContextTask.h"
 #include "core/inspector/InspectorInstrumentation.h"
 #include "public/platform/Platform.h"
 #include "wtf/Assertions.h"
 
 namespace blink {
 
 class MainThreadTask : public WebThread::Task {
     WTF_MAKE_NONCOPYABLE(MainThreadTask); WTF_MAKE_FAST_ALLOCATED(MainThreadTask);
 public:
-    MainThreadTask(WeakPtr<MainThreadTaskRunner> runner, PassOwnPtr<ExecutionContextTask> task, bool isInspectorTask)
+    MainThreadTask(WeakPtrWillBeRawPtr<MainThreadTaskRunner> runner, PassOwnPtr<ExecutionContextTask> task, bool isInspectorTask)
         : m_runner(runner)
         , m_task(task)
         , m_isInspectorTask(isInspectorTask)
     {
     }
 
     void run() override;
 
 private:
-    WeakPtr<MainThreadTaskRunner> m_runner;

[sof, 2015/08/19 06:37:56]

The GC plugin ought to warn/disallow WeakPtr<T> if T is a GCed type.

+    WeakPtrWillBeWeakPersistent<MainThreadTaskRunner> m_runner;
     OwnPtr<ExecutionContextTask> m_task;
     bool m_isInspectorTask;
 };
 
 void MainThreadTask::run()
 {
     ASSERT(isMainThread());
 
     if (!m_runner.get())
         return;
     m_runner->perform(m_task.release(), m_isInspectorTask);
 }
 
 MainThreadTaskRunner::MainThreadTaskRunner(ExecutionContext* context)
     : m_context(context)
+#if !ENABLE(OILPAN)
     , m_weakFactory(this)
+#endif
     , m_pendingTasksTimer(this, &MainThreadTaskRunner::pendingTasksTimerFired)
     , m_suspended(false)
 {
 }
 
 MainThreadTaskRunner::~MainThreadTaskRunner()
 {
 }
 
+DEFINE_TRACE(MainThreadTaskRunner)
+{
+    visitor->trace(m_context);
+}
+
 void MainThreadTaskRunner::postTask(const WebTraceLocation& location, PassOwnPtr<ExecutionContextTask> task)
 {
     if (!task->taskNameForInstrumentation().isEmpty())
         InspectorInstrumentation::didPostExecutionContextTask(m_context, task.get());
-    Platform::current()->mainThread()->postTask(location, new MainThreadTask(m_weakFactory.createWeakPtr(), task, false));
+    Platform::current()->mainThread()->postTask(location, new MainThreadTask(createWeakPointerToSelf(), task, false));

[haraken, 2015/08/19 05:18:17]

Maybe I'm wrong but this task is created on a non-main thread and used by the
main thread, right? Then I guess we need to use CrossThreadWeakPersistent.

[Yuta Kitamura, 2015/08/19 05:56:57]

You are right; it indeed can be called from non-main thread.

However, CrossThreadWeakPersistent does not exist at this moment.
Can I create it in another patch?

 }
 
 void MainThreadTaskRunner::postInspectorTask(const WebTraceLocation& location, PassOwnPtr<ExecutionContextTask> task)
 {
-    Platform::current()->mainThread()->postTask(location, new MainThreadTask(m_weakFactory.createWeakPtr(), task, true));
+    Platform::current()->mainThread()->postTask(location, new MainThreadTask(createWeakPointerToSelf(), task, true));
 }
 
 void MainThreadTaskRunner::perform(PassOwnPtr<ExecutionContextTask> task, bool isInspectorTask)
 {
     if (!isInspectorTask && (m_context->tasksNeedSuspension() || !m_pendingTasks.isEmpty())) {
         m_pendingTasks.append(task);
         return;
     }
 
     const bool instrumenting = !isInspectorTask && !task->taskNameForInstrumentation().isEmpty();
@@ skipping 27 matching lines @@
         m_pendingTasks.remove(0);
         const bool instrumenting = !task->taskNameForInstrumentation().isEmpty();
         if (instrumenting)
             InspectorInstrumentation::willPerformExecutionContextTask(m_context, task.get());
         task->performTask(m_context);
         if (instrumenting)
             InspectorInstrumentation::didPerformExecutionContextTask(m_context);
     }
 }
 
+WeakPtrWillBeRawPtr<MainThreadTaskRunner> MainThreadTaskRunner::createWeakPointerToSelf()
+{
+#if ENABLE(OILPAN)
+    return this;
+#else
+    return m_weakFactory.createWeakPtr();
+#endif
+}
+
 } // namespace