#include "config.h"
#if ENABLE(WORKERS)
#include "WorkerThread.h"
#include "DedicatedWorkerContext.h"
#include "InspectorInstrumentation.h"
#include "KURL.h"
#include "ScriptSourceCode.h"
#include "ScriptValue.h"
#include "SecurityOrigin.h"
#include "ThreadGlobalData.h"
#include <utility>
#include <wtf/Noncopyable.h>
#include <wtf/text/WTFString.h>
#if ENABLE(SQL_DATABASE)
#include "DatabaseManager.h"
#include "DatabaseTask.h"
#endif
namespace WebCore {
static Mutex& threadSetMutex()
{
AtomicallyInitializedStatic(Mutex&, mutex = *new Mutex);
return mutex;
}
static HashSet<WorkerThread*>& workerThreads()
{
DEFINE_STATIC_LOCAL(HashSet<WorkerThread*>, threads, ());
return threads;
}
unsigned WorkerThread::workerThreadCount()
{
MutexLocker lock(threadSetMutex());
return workerThreads().size();
}
struct WorkerThreadStartupData {
WTF_MAKE_NONCOPYABLE(WorkerThreadStartupData); WTF_MAKE_FAST_ALLOCATED;
public:
static PassOwnPtr<WorkerThreadStartupData> create(const KURL& scriptURL, const String& userAgent, const GroupSettings* settings, const String& sourceCode, WorkerThreadStartMode startMode, const String& contentSecurityPolicy, ContentSecurityPolicy::HeaderType contentSecurityPolicyType, const SecurityOrigin* topOrigin)
{
return adoptPtr(new WorkerThreadStartupData(scriptURL, userAgent, settings, sourceCode, startMode, contentSecurityPolicy, contentSecurityPolicyType, topOrigin));
}
KURL m_scriptURL;
String m_userAgent;
OwnPtr<GroupSettings> m_groupSettings;
String m_sourceCode;
WorkerThreadStartMode m_startMode;
String m_contentSecurityPolicy;
ContentSecurityPolicy::HeaderType m_contentSecurityPolicyType;
RefPtr<SecurityOrigin> m_topOrigin;
private:
WorkerThreadStartupData(const KURL& scriptURL, const String& userAgent, const GroupSettings*, const String& sourceCode, WorkerThreadStartMode, const String& contentSecurityPolicy, ContentSecurityPolicy::HeaderType contentSecurityPolicyType, const SecurityOrigin* topOrigin);
};
WorkerThreadStartupData::WorkerThreadStartupData(const KURL& scriptURL, const String& userAgent, const GroupSettings* settings, const String& sourceCode, WorkerThreadStartMode startMode, const String& contentSecurityPolicy, ContentSecurityPolicy::HeaderType contentSecurityPolicyType, const SecurityOrigin* topOrigin)
: m_scriptURL(scriptURL.copy())
, m_userAgent(userAgent.isolatedCopy())
, m_sourceCode(sourceCode.isolatedCopy())
, m_startMode(startMode)
, m_contentSecurityPolicy(contentSecurityPolicy.isolatedCopy())
, m_contentSecurityPolicyType(contentSecurityPolicyType)
, m_topOrigin(topOrigin ? topOrigin->isolatedCopy() : 0)
{
if (!settings)
return;
m_groupSettings = GroupSettings::create();
m_groupSettings->setLocalStorageQuotaBytes(settings->localStorageQuotaBytes());
m_groupSettings->setIndexedDBQuotaBytes(settings->indexedDBQuotaBytes());
m_groupSettings->setIndexedDBDatabasePath(settings->indexedDBDatabasePath().isolatedCopy());
}
WorkerThread::WorkerThread(const KURL& scriptURL, const String& userAgent, const GroupSettings* settings, const String& sourceCode, WorkerLoaderProxy& workerLoaderProxy, WorkerReportingProxy& workerReportingProxy, WorkerThreadStartMode startMode, const String& contentSecurityPolicy, ContentSecurityPolicy::HeaderType contentSecurityPolicyType, const SecurityOrigin* topOrigin)
: m_threadID(0)
, m_workerLoaderProxy(workerLoaderProxy)
, m_workerReportingProxy(workerReportingProxy)
, m_startupData(WorkerThreadStartupData::create(scriptURL, userAgent, settings, sourceCode, startMode, contentSecurityPolicy, contentSecurityPolicyType, topOrigin))
#if ENABLE(NOTIFICATIONS) || ENABLE(LEGACY_NOTIFICATIONS)
, m_notificationClient(0)
#endif
{
MutexLocker lock(threadSetMutex());
workerThreads().add(this);
}
WorkerThread::~WorkerThread()
{
MutexLocker lock(threadSetMutex());
ASSERT(workerThreads().contains(this));
workerThreads().remove(this);
}
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()
{
{
MutexLocker lock(m_threadCreationMutex);
m_workerContext = createWorkerContext(m_startupData->m_scriptURL, m_startupData->m_userAgent, m_startupData->m_groupSettings.release(), m_startupData->m_contentSecurityPolicy, m_startupData->m_contentSecurityPolicyType, m_startupData->m_topOrigin.release());
if (m_runLoop.terminated()) {
m_workerContext->script()->forbidExecution();
}
}
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_WITH_SECURITY_IMPLICATION(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_WITH_SECURITY_IMPLICATION(context->isWorkerContext());
WorkerContext* workerContext = static_cast<WorkerContext*>(context);
#if ENABLE(SQL_DATABASE)
DatabaseTaskSynchronizer cleanupSync;
DatabaseManager::manager().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)
DatabaseManager::manager().interruptAllDatabasesForContext(m_workerContext.get());
#endif
m_runLoop.postTaskAndTerminate(WorkerThreadShutdownStartTask::create());
return;
}
m_runLoop.terminate();
}
class ReleaseFastMallocFreeMemoryTask : public ScriptExecutionContext::Task {
virtual void performTask(ScriptExecutionContext*) OVERRIDE { WTF::releaseFastMallocFreeMemory(); }
};
void WorkerThread::releaseFastMallocFreeMemoryInAllThreads()
{
MutexLocker lock(threadSetMutex());
HashSet<WorkerThread*>& threads = workerThreads();
HashSet<WorkerThread*>::iterator end = threads.end();
for (HashSet<WorkerThread*>::iterator it = threads.begin(); it != end; ++it)
(*it)->runLoop().postTask(adoptPtr(new ReleaseFastMallocFreeMemoryTask));
}
}
#endif // ENABLE(WORKERS)