workers: Move ownership of WebThread from WorkerThread

Source/core/workers/WorkerThread.cpp

 /*
  * Copyright (C) 2008 Apple 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 238 matching lines @@
         ASSERT(context->isWorkerGlobalScope());
         m_thread->runDebuggerTask(WorkerThread::DontWaitForMessage);
     }
 
 private:
     explicit RunDebuggerQueueTask(WorkerThread* thread) : m_thread(thread) { }
 
     WorkerThread* m_thread;
 };
 
-WorkerThread::WorkerThread(const char* threadName, PassRefPtr<WorkerLoaderProxy> workerLoaderProxy, WorkerReportingProxy& workerReportingProxy, PassOwnPtr<WorkerThreadStartupData> startupData)
-    : m_threadName(threadName)
+WorkerThread::WorkerThread(PassRefPtr<WorkerLoaderProxy> workerLoaderProxy, WorkerReportingProxy& workerReportingProxy, PassOwnPtr<WorkerThreadStartupData> startupData)
+    : m_started(false)
     , m_terminated(false)
     , m_workerLoaderProxy(workerLoaderProxy)
     , m_workerReportingProxy(workerReportingProxy)
     , m_startupData(startupData)
     , m_isolate(nullptr)
     , m_shutdownEvent(adoptPtr(Platform::current()->createWaitableEvent()))
     , m_terminationEvent(adoptPtr(Platform::current()->createWaitableEvent()))
 {
     MutexLocker lock(threadSetMutex());
     workerThreads().add(this);
 }
 
 WorkerThread::~WorkerThread()
 {
     MutexLocker lock(threadSetMutex());
     ASSERT(workerThreads().contains(this));
     workerThreads().remove(this);
 }
 
 void WorkerThread::start()
 {
-    if (m_thread)
+    if (m_started)
         return;
 
-    m_thread = createWebThreadSupportingGC();
-    m_thread->postTask(FROM_HERE, new Task(threadSafeBind(&WorkerThread::initialize, AllowCrossThreadAccess(this))));
+    m_started = true;
+    backingThread().postTask(FROM_HERE, new Task(threadSafeBind(&WorkerThread::initialize, AllowCrossThreadAccess(this))));
 }
 
 void WorkerThread::interruptAndDispatchInspectorCommands()
 {
     MutexLocker locker(m_workerInspectorControllerMutex);
     if (m_workerInspectorController)
         m_workerInspectorController->interruptAndDispatchInspectorCommands();
 }
 
-PlatformThreadId WorkerThread::platformThreadId() const
+PlatformThreadId WorkerThread::platformThreadId()
 {
-    if (!m_thread)
+    if (!m_started)
         return 0;
-    return m_thread->platformThread().threadId();
+    return backingThread().platformThread().threadId();
 }
 
 void WorkerThread::initialize()
 {
     KURL scriptURL = m_startupData->m_scriptURL;
     String sourceCode = m_startupData->m_sourceCode;
     WorkerThreadStartMode startMode = m_startupData->m_startMode;
     OwnPtr<Vector<char>> cachedMetaData = m_startupData->m_cachedMetaData.release();
     V8CacheOptions v8CacheOptions = m_startupData->m_v8CacheOptions;
 
     {
         MutexLocker lock(m_threadCreationMutex);
 
         // The worker was terminated before the thread had a chance to run.
         if (m_terminated) {
             // Notify the proxy that the WorkerGlobalScope has been disposed of.
             // This can free this thread object, hence it must not be touched afterwards.
             m_workerReportingProxy.workerThreadTerminated();
             return;
         }
 
         m_microtaskRunner = adoptPtr(new MicrotaskRunner(this));
-        m_thread->addTaskObserver(m_microtaskRunner.get());
-        m_thread->attachGC();
+        backingThread().addTaskObserver(m_microtaskRunner.get());
+        backingThread().attachGC();
 
         m_isolate = initializeIsolate();
         m_workerGlobalScope = createWorkerGlobalScope(m_startupData.release());
         m_workerGlobalScope->scriptLoaded(sourceCode.length(), cachedMetaData.get() ? cachedMetaData->size() : 0);
 
         PlatformThreadData::current().threadTimers().setSharedTimer(adoptPtr(new WorkerSharedTimer(this)));
     }
 
     // The corresponding call to stopRunLoop() is in ~WorkerScriptController().
     didStartRunLoop();
@@ skipping 10 matching lines @@
     OwnPtr<CachedMetadataHandler> handler(workerGlobalScope()->createWorkerScriptCachedMetadataHandler(scriptURL, cachedMetaData.get()));
     bool success = script->evaluate(ScriptSourceCode(sourceCode, scriptURL), nullptr, handler.get(), v8CacheOptions);
     m_workerGlobalScope->didEvaluateWorkerScript();
     m_workerReportingProxy.didEvaluateWorkerScript(success);
 
     postInitialize();
 
     postDelayedTask(FROM_HERE, createSameThreadTask(&WorkerThread::idleHandler, this), kShortIdleHandlerDelayMs);
 }
 
-PassOwnPtr<WebThreadSupportingGC> WorkerThread::createWebThreadSupportingGC()
-{
-    return WebThreadSupportingGC::create(m_threadName);
-}
-
 void WorkerThread::cleanup()
 {
     // This should be called before we start the shutdown procedure.
     workerReportingProxy().willDestroyWorkerGlobalScope();
 
     // The below assignment will destroy the context, which will in turn notify messaging proxy.
     // We cannot let any objects survive past thread exit, because no other thread will run GC or otherwise destroy them.
     // If Oilpan is enabled, we detach of the context/global scope, with the final heap cleanup below sweeping it out.
 #if !ENABLE(OILPAN)
     ASSERT(m_workerGlobalScope->hasOneRef());
 #endif
     m_workerGlobalScope->notifyContextDestroyed();
     m_workerGlobalScope = nullptr;
 
-    m_thread->detachGC();
+    backingThread().detachGC();
     destroyIsolate();
 
-    m_thread->removeTaskObserver(m_microtaskRunner.get());
+    backingThread().removeTaskObserver(m_microtaskRunner.get());
     m_microtaskRunner = nullptr;
 
     // Notify the proxy that the WorkerGlobalScope has been disposed of.
     // This can free this thread object, hence it must not be touched afterwards.
     workerReportingProxy().workerThreadTerminated();
 
     m_terminationEvent->signal();
 
     // Clean up PlatformThreadData before WTF::WTFThreadData goes away!
     PlatformThreadData::current().destroy();
 }
 
 class WorkerThreadShutdownFinishTask : public ExecutionContextTask {
 public:
     static PassOwnPtr<WorkerThreadShutdownFinishTask> create()
     {
         return adoptPtr(new WorkerThreadShutdownFinishTask());
     }
 
     virtual void performTask(ExecutionContext *context)
     {
         WorkerGlobalScope* workerGlobalScope = toWorkerGlobalScope(context);
         workerGlobalScope->dispose();
 
         WorkerThread* workerThread = workerGlobalScope->thread();
         workerThread->willDestroyIsolate();
-        workerThread->m_thread->postTask(FROM_HERE, new Task(WTF::bind(&WorkerThread::cleanup, workerThread)));
+        workerThread->backingThread().postTask(FROM_HERE, new Task(WTF::bind(&WorkerThread::cleanup, workerThread)));
     }
 
     virtual bool isCleanupTask() const { return true; }
 };
 
 class WorkerThreadShutdownStartTask : public ExecutionContextTask {
 public:
     static PassOwnPtr<WorkerThreadShutdownStartTask> create()
     {
         return adoptPtr(new WorkerThreadShutdownStartTask());
@@ skipping 83 matching lines @@
     // Keep this lock to prevent WorkerThread instances from being destroyed.
     MutexLocker lock(threadSetMutex());
     HashSet<WorkerThread*> threads = workerThreads();
     for (WorkerThread* thread : threads)
         thread->stopInShutdownSequence();
 
     for (WorkerThread* thread : threads)
         thread->terminationEvent()->wait();
 }
 
-bool WorkerThread::isCurrentThread() const
+bool WorkerThread::isCurrentThread()
 {
-    return m_thread && m_thread->isCurrentThread();
+    return m_started && backingThread().isCurrentThread();
 }
 
 void WorkerThread::idleHandler()
 {
     ASSERT(m_workerGlobalScope.get());
     int64_t delay = kLongIdleHandlerDelayMs;
 
     // Do a script engine idle notification if the next event is distant enough.
     const double kMinIdleTimespan = 0.3;
     const double nextFireTime = PlatformThreadData::current().threadTimers().nextFireTime();
     if (nextFireTime == 0.0 || nextFireTime > currentTime() + kMinIdleTimespan) {
         bool hasMoreWork = !isolate()->IdleNotificationDeadline(Platform::current()->monotonicallyIncreasingTime() + 1.0);
         if (hasMoreWork)
             delay = kShortIdleHandlerDelayMs;
     }
 
     postDelayedTask(FROM_HERE, createSameThreadTask(&WorkerThread::idleHandler, this), delay);
 }
 
 void WorkerThread::postTask(const WebTraceLocation& location, PassOwnPtr<ExecutionContextTask> task)
 {
-    m_thread->postTask(location, WorkerThreadTask::create(*this, task, true).leakPtr());
+    backingThread().postTask(location, WorkerThreadTask::create(*this, task, true).leakPtr());
 }
 
 void WorkerThread::postDelayedTask(const WebTraceLocation& location, PassOwnPtr<ExecutionContextTask> task, long long delayMs)
 {
-    m_thread->postDelayedTask(location, WorkerThreadTask::create(*this, task, true).leakPtr(), delayMs);
+    backingThread().postDelayedTask(location, WorkerThreadTask::create(*this, task, true).leakPtr(), delayMs);
 }
 
 v8::Isolate* WorkerThread::initializeIsolate()
 {
     ASSERT(isCurrentThread());
     ASSERT(!m_isolate);
     v8::Isolate* isolate = V8PerIsolateData::initialize();
     V8Initializer::initializeWorker(isolate);
 
     m_interruptor = adoptPtr(new V8IsolateInterruptor(isolate));
@@ skipping 63 matching lines @@
     InspectorInstrumentation::didLeaveNestedRunLoop(m_workerGlobalScope.get());
 }
 
 void WorkerThread::setWorkerInspectorController(WorkerInspectorController* workerInspectorController)
 {
     MutexLocker locker(m_workerInspectorControllerMutex);
     m_workerInspectorController = workerInspectorController;
 }
 
 } // namespace blink