#include "config.h"
#if ENABLE(WORKERS)
#include "WorkerThread.h"
#include "DatabaseContext.h"
#include "DedicatedWorkerContext.h"
#include "InspectorInstrumentation.h"
#include "KURL.h"
#include "PlatformString.h"
#include "ScriptSourceCode.h"
#include "ScriptValue.h"
#include "ThreadGlobalData.h"
#include <utility>
#include <wtf/Noncopyable.h>
#if ENABLE(SQL_DATABASE)
#include "DatabaseTask.h"
#include "DatabaseTracker.h"
#endif
#include "WebCoreThread.h"
namespace WebCore {
static Mutex& threadCountMutex()
{
AtomicallyInitializedStatic(Mutex&, mutex = *new Mutex);
return mutex;
}
unsigned WorkerThread::m_threadCount = 0;
unsigned WorkerThread::workerThreadCount()
{
MutexLocker lock(threadCountMutex());
return m_threadCount;
}
struct WorkerThreadStartupData {
WTF_MAKE_NONCOPYABLE(WorkerThreadStartupData); WTF_MAKE_FAST_ALLOCATED;
public:
static PassOwnPtr<WorkerThreadStartupData> create(const KURL& scriptURL, const String& userAgent, const String& sourceCode, WorkerThreadStartMode startMode, const String& contentSecurityPolicy, ContentSecurityPolicy::HeaderType contentSecurityPolicyType)
{
return adoptPtr(new WorkerThreadStartupData(scriptURL, userAgent, sourceCode, startMode, contentSecurityPolicy, contentSecurityPolicyType));
}
KURL m_scriptURL;
String m_userAgent;
String m_sourceCode;
WorkerThreadStartMode m_startMode;
String m_contentSecurityPolicy;
ContentSecurityPolicy::HeaderType m_contentSecurityPolicyType;
private:
WorkerThreadStartupData(const KURL& scriptURL, const String& userAgent, const String& sourceCode, WorkerThreadStartMode, const String& contentSecurityPolicy, ContentSecurityPolicy::HeaderType contentSecurityPolicyType);
};
WorkerThreadStartupData::WorkerThreadStartupData(const KURL& scriptURL, const String& userAgent, const String& sourceCode, WorkerThreadStartMode startMode, const String& contentSecurityPolicy, ContentSecurityPolicy::HeaderType contentSecurityPolicyType)
: m_scriptURL(scriptURL.copy())
, m_userAgent(userAgent.isolatedCopy())
, m_sourceCode(sourceCode.isolatedCopy())
, m_startMode(startMode)
, m_contentSecurityPolicy(contentSecurityPolicy.isolatedCopy())
, m_contentSecurityPolicyType(contentSecurityPolicyType)
{
}
WorkerThread::WorkerThread(const KURL& scriptURL, const String& userAgent, const String& sourceCode, WorkerLoaderProxy& workerLoaderProxy, WorkerReportingProxy& workerReportingProxy, WorkerThreadStartMode startMode, const String& contentSecurityPolicy, ContentSecurityPolicy::HeaderType contentSecurityPolicyType)
: m_threadID(0)
, m_workerLoaderProxy(workerLoaderProxy)
, m_workerReportingProxy(workerReportingProxy)
, m_startupData(WorkerThreadStartupData::create(scriptURL, userAgent, sourceCode, startMode, contentSecurityPolicy, contentSecurityPolicyType))
#if ENABLE(NOTIFICATIONS) || ENABLE(LEGACY_NOTIFICATIONS)
, m_notificationClient(0)
#endif
{
MutexLocker lock(threadCountMutex());
m_threadCount++;
}
WorkerThread::~WorkerThread()
{
MutexLocker lock(threadCountMutex());
ASSERT(m_threadCount > 0);
m_threadCount--;
}
bool WorkerThread::start()
{
MutexLocker lock(m_threadCreationMutex);
if (m_threadID)
return true;
m_threadID = createThread(WorkerThread::workerThreadStart, this, "WebCore: Worker");
return m_threadID;
}
void WorkerThread::workerThreadStart(void* thread)
{
static_cast<WorkerThread*>(thread)->workerThread();
}
void WorkerThread::workerThread()
{
fesetenv(&mainThreadFEnv);
{
MutexLocker lock(m_threadCreationMutex);
m_workerContext = createWorkerContext(m_startupData->m_scriptURL, m_startupData->m_userAgent, m_startupData->m_contentSecurityPolicy, m_startupData->m_contentSecurityPolicyType);
if (m_runLoop.terminated()) {
m_workerContext->script()->forbidExecution();
}
}
#if PLATFORM(CHROMIUM)
PlatformSupport::didStartWorkerRunLoop(&m_runLoop);
#endif
WorkerScriptController* script = m_workerContext->script();
#if ENABLE(INSPECTOR)
InspectorInstrumentation::willEvaluateWorkerScript(workerContext(), m_startupData->m_startMode);
#endif
script->evaluate(ScriptSourceCode(m_startupData->m_sourceCode, m_startupData->m_scriptURL));
m_startupData.clear();
runEventLoop();
ThreadIdentifier threadID = m_threadID;
ASSERT(m_workerContext->hasOneRef());
m_workerContext = 0;
threadGlobalData().destroy();
detachThread(threadID);
}
void WorkerThread::runEventLoop()
{
m_runLoop.run(m_workerContext.get());
}
class WorkerThreadShutdownFinishTask : public ScriptExecutionContext::Task {
public:
static PassOwnPtr<WorkerThreadShutdownFinishTask> create()
{
return adoptPtr(new WorkerThreadShutdownFinishTask());
}
virtual void performTask(ScriptExecutionContext *context)
{
ASSERT(context->isWorkerContext());
WorkerContext* workerContext = static_cast<WorkerContext*>(context);
#if ENABLE(INSPECTOR)
workerContext->clearInspector();
#endif
workerContext->clearScript();
}
virtual bool isCleanupTask() const { return true; }
};
class WorkerThreadShutdownStartTask : public ScriptExecutionContext::Task {
public:
static PassOwnPtr<WorkerThreadShutdownStartTask> create()
{
return adoptPtr(new WorkerThreadShutdownStartTask());
}
virtual void performTask(ScriptExecutionContext *context)
{
ASSERT(context->isWorkerContext());
WorkerContext* workerContext = static_cast<WorkerContext*>(context);
#if ENABLE(SQL_DATABASE)
DatabaseTaskSynchronizer cleanupSync;
DatabaseContext::stopDatabases(workerContext, &cleanupSync);
#endif
workerContext->stopActiveDOMObjects();
workerContext->notifyObserversOfStop();
workerContext->removeAllEventListeners();
#if ENABLE(SQL_DATABASE)
cleanupSync.waitForTaskCompletion();
#endif
workerContext->postTask(WorkerThreadShutdownFinishTask::create());
}
virtual bool isCleanupTask() const { return true; }
};
void WorkerThread::stop()
{
MutexLocker lock(m_threadCreationMutex);
if (m_workerContext) {
m_workerContext->script()->scheduleExecutionTermination();
#if ENABLE(SQL_DATABASE)
DatabaseTracker::tracker().interruptAllDatabasesForContext(m_workerContext.get());
#endif
m_runLoop.postTask(WorkerThreadShutdownStartTask::create());
}
m_runLoop.terminate();
}
}
#endif // ENABLE(WORKERS)