<https://webkit.org/b/128834>
Codify this by storing the owner thread as a WorkerThread& and making
thread() return a reference.
This exposed a couple of unnecessary assertions.
Reviewed by Anders Carlsson.
* Modules/notifications/WorkerGlobalScopeNotifications.cpp:
(WebCore::WorkerGlobalScopeNotifications::webkitNotifications):
* Modules/websockets/ThreadableWebSocketChannel.cpp:
(WebCore::ThreadableWebSocketChannel::create):
* Modules/websockets/WorkerThreadableWebSocketChannel.cpp:
(WebCore::WorkerThreadableWebSocketChannel::Bridge::Bridge):
(WebCore::WorkerThreadableWebSocketChannel::Bridge::waitForMethodCompletion):
* bindings/js/ScheduledAction.cpp:
(WebCore::ScheduledAction::execute):
* bindings/js/WorkerScriptDebugServer.cpp:
(WebCore::WorkerScriptDebugServer::runEventLoopWhilePaused):
* dom/ScriptExecutionContext.cpp:
(WebCore::ScriptExecutionContext::createdMessagePort):
(WebCore::ScriptExecutionContext::destroyedMessagePort):
* inspector/WorkerDebuggerAgent.cpp:
(WebCore::WorkerDebuggerAgent::WorkerDebuggerAgent):
(WebCore::WorkerDebuggerAgent::~WorkerDebuggerAgent):
* inspector/WorkerInspectorController.cpp:
* inspector/WorkerRuntimeAgent.cpp:
(WebCore::WorkerRuntimeAgent::pauseWorkerGlobalScope):
* loader/WorkerThreadableLoader.cpp:
(WebCore::WorkerThreadableLoader::WorkerThreadableLoader):
(WebCore::WorkerThreadableLoader::loadResourceSynchronously):
* loader/cache/MemoryCache.cpp:
(WebCore::MemoryCache::removeRequestFromCache):
* workers/DedicatedWorkerGlobalScope.cpp:
(WebCore::DedicatedWorkerGlobalScope::create):
(WebCore::DedicatedWorkerGlobalScope::DedicatedWorkerGlobalScope):
(WebCore::DedicatedWorkerGlobalScope::postMessage):
(WebCore::DedicatedWorkerGlobalScope::importScripts):
(WebCore::DedicatedWorkerGlobalScope::thread):
* workers/DedicatedWorkerGlobalScope.h:
* workers/DedicatedWorkerThread.cpp:
(WebCore::DedicatedWorkerThread::createWorkerGlobalScope):
* workers/SharedWorkerGlobalScope.cpp:
(WebCore::SharedWorkerGlobalScope::create):
(WebCore::SharedWorkerGlobalScope::SharedWorkerGlobalScope):
(WebCore::SharedWorkerGlobalScope::thread):
* workers/SharedWorkerGlobalScope.h:
* workers/SharedWorkerThread.cpp:
(WebCore::SharedWorkerThread::createWorkerGlobalScope):
* workers/WorkerGlobalScope.cpp:
(WebCore::CloseWorkerGlobalScopeTask::performTask):
(WebCore::WorkerGlobalScope::WorkerGlobalScope):
(WebCore::WorkerGlobalScope::~WorkerGlobalScope):
(WebCore::WorkerGlobalScope::postTask):
(WebCore::WorkerGlobalScope::logExceptionToConsole):
(WebCore::WorkerGlobalScope::addConsoleMessage):
(WebCore::WorkerGlobalScope::addMessage):
(WebCore::WorkerGlobalScope::isContextThread):
* workers/WorkerGlobalScope.h:
(WebCore::WorkerGlobalScope::thread):
* workers/WorkerMessagingProxy.cpp:
(WebCore::MessageWorkerGlobalScopeTask::performTask):
(WebCore::WorkerMessagingProxy::WorkerMessagingProxy):
(WebCore::WorkerMessagingProxy::~WorkerMessagingProxy):
* workers/WorkerRunLoop.cpp:
(WebCore::WorkerRunLoop::runInMode):
(WebCore::WorkerRunLoop::runCleanupTasks):
git-svn-id: https://svn.webkit.org/repository/webkit/trunk@164158
268f45cc-cd09-0410-ab3c-
d52691b4dbfc
+2014-02-14 Andreas Kling <akling@apple.com>
+
+ CTTE: WorkerGlobalScope is always owned by a WorkerThread.
+ <https://webkit.org/b/128834>
+
+ Codify this by storing the owner thread as a WorkerThread& and making
+ thread() return a reference.
+
+ This exposed a couple of unnecessary assertions.
+
+ Reviewed by Anders Carlsson.
+
+ * Modules/notifications/WorkerGlobalScopeNotifications.cpp:
+ (WebCore::WorkerGlobalScopeNotifications::webkitNotifications):
+ * Modules/websockets/ThreadableWebSocketChannel.cpp:
+ (WebCore::ThreadableWebSocketChannel::create):
+ * Modules/websockets/WorkerThreadableWebSocketChannel.cpp:
+ (WebCore::WorkerThreadableWebSocketChannel::Bridge::Bridge):
+ (WebCore::WorkerThreadableWebSocketChannel::Bridge::waitForMethodCompletion):
+ * bindings/js/ScheduledAction.cpp:
+ (WebCore::ScheduledAction::execute):
+ * bindings/js/WorkerScriptDebugServer.cpp:
+ (WebCore::WorkerScriptDebugServer::runEventLoopWhilePaused):
+ * dom/ScriptExecutionContext.cpp:
+ (WebCore::ScriptExecutionContext::createdMessagePort):
+ (WebCore::ScriptExecutionContext::destroyedMessagePort):
+ * inspector/WorkerDebuggerAgent.cpp:
+ (WebCore::WorkerDebuggerAgent::WorkerDebuggerAgent):
+ (WebCore::WorkerDebuggerAgent::~WorkerDebuggerAgent):
+ * inspector/WorkerInspectorController.cpp:
+ * inspector/WorkerRuntimeAgent.cpp:
+ (WebCore::WorkerRuntimeAgent::pauseWorkerGlobalScope):
+ * loader/WorkerThreadableLoader.cpp:
+ (WebCore::WorkerThreadableLoader::WorkerThreadableLoader):
+ (WebCore::WorkerThreadableLoader::loadResourceSynchronously):
+ * loader/cache/MemoryCache.cpp:
+ (WebCore::MemoryCache::removeRequestFromCache):
+ * workers/DedicatedWorkerGlobalScope.cpp:
+ (WebCore::DedicatedWorkerGlobalScope::create):
+ (WebCore::DedicatedWorkerGlobalScope::DedicatedWorkerGlobalScope):
+ (WebCore::DedicatedWorkerGlobalScope::postMessage):
+ (WebCore::DedicatedWorkerGlobalScope::importScripts):
+ (WebCore::DedicatedWorkerGlobalScope::thread):
+ * workers/DedicatedWorkerGlobalScope.h:
+ * workers/DedicatedWorkerThread.cpp:
+ (WebCore::DedicatedWorkerThread::createWorkerGlobalScope):
+ * workers/SharedWorkerGlobalScope.cpp:
+ (WebCore::SharedWorkerGlobalScope::create):
+ (WebCore::SharedWorkerGlobalScope::SharedWorkerGlobalScope):
+ (WebCore::SharedWorkerGlobalScope::thread):
+ * workers/SharedWorkerGlobalScope.h:
+ * workers/SharedWorkerThread.cpp:
+ (WebCore::SharedWorkerThread::createWorkerGlobalScope):
+ * workers/WorkerGlobalScope.cpp:
+ (WebCore::CloseWorkerGlobalScopeTask::performTask):
+ (WebCore::WorkerGlobalScope::WorkerGlobalScope):
+ (WebCore::WorkerGlobalScope::~WorkerGlobalScope):
+ (WebCore::WorkerGlobalScope::postTask):
+ (WebCore::WorkerGlobalScope::logExceptionToConsole):
+ (WebCore::WorkerGlobalScope::addConsoleMessage):
+ (WebCore::WorkerGlobalScope::addMessage):
+ (WebCore::WorkerGlobalScope::isContextThread):
+ * workers/WorkerGlobalScope.h:
+ (WebCore::WorkerGlobalScope::thread):
+ * workers/WorkerMessagingProxy.cpp:
+ (WebCore::MessageWorkerGlobalScopeTask::performTask):
+ (WebCore::WorkerMessagingProxy::WorkerMessagingProxy):
+ (WebCore::WorkerMessagingProxy::~WorkerMessagingProxy):
+ * workers/WorkerRunLoop.cpp:
+ (WebCore::WorkerRunLoop::runInMode):
+ (WebCore::WorkerRunLoop::runCleanupTasks):
+
2014-02-14 Ryosuke Niwa <rniwa@webkit.org>
setSelectionRange shouldn't trigger a synchronous layout to check focusability when text field is already focused
NotificationCenter* WorkerGlobalScopeNotifications::webkitNotifications()
{
if (!m_notificationCenter)
- m_notificationCenter = NotificationCenter::create(m_context, m_context->thread()->getNotificationClient());
+ m_notificationCenter = NotificationCenter::create(m_context, m_context->thread().getNotificationClient());
return m_notificationCenter.get();
}
if (context->isWorkerGlobalScope()) {
WorkerGlobalScope* workerGlobalScope = static_cast<WorkerGlobalScope*>(context);
- WorkerRunLoop& runLoop = workerGlobalScope->thread()->runLoop();
+ WorkerRunLoop& runLoop = workerGlobalScope->thread().runLoop();
String mode = webSocketChannelMode;
mode.append(String::number(runLoop.createUniqueId()));
return WorkerThreadableWebSocketChannel::create(workerGlobalScope, client, mode);
WorkerThreadableWebSocketChannel::Bridge::Bridge(PassRefPtr<ThreadableWebSocketChannelClientWrapper> workerClientWrapper, PassRefPtr<WorkerGlobalScope> workerGlobalScope, const String& taskMode)
: m_workerClientWrapper(workerClientWrapper)
, m_workerGlobalScope(workerGlobalScope)
- , m_loaderProxy(m_workerGlobalScope->thread()->workerLoaderProxy())
+ , m_loaderProxy(m_workerGlobalScope->thread().workerLoaderProxy())
, m_taskMode(taskMode)
, m_peer(0)
{
{
if (!m_workerGlobalScope)
return;
- WorkerRunLoop& runLoop = m_workerGlobalScope->thread()->runLoop();
+ WorkerRunLoop& runLoop = m_workerGlobalScope->thread().runLoop();
MessageQueueWaitResult result = MessageQueueMessageReceived;
ThreadableWebSocketChannelClientWrapper* clientWrapper = m_workerClientWrapper.get();
while (m_workerGlobalScope && clientWrapper && !clientWrapper->syncMethodDone() && result != MessageQueueTerminated) {
void ScheduledAction::execute(WorkerGlobalScope* workerGlobalScope)
{
// In a Worker, the execution should always happen on a worker thread.
- ASSERT(workerGlobalScope->thread()->threadID() == currentThread());
+ ASSERT(workerGlobalScope->thread().threadID() == currentThread());
WorkerScriptController* scriptController = workerGlobalScope->script();
MessageQueueWaitResult result;
do {
- result = m_workerGlobalScope->thread()->runLoop().runInMode(m_workerGlobalScope, m_debuggerTaskMode);
+ result = m_workerGlobalScope->thread().runLoop().runInMode(m_workerGlobalScope, m_debuggerTaskMode);
// Keep waiting until execution is resumed.
} while (result != MessageQueueTerminated && !m_doneProcessingDebuggerEvents);
}
{
ASSERT(port);
ASSERT((isDocument() && isMainThread())
- || (isWorkerGlobalScope() && currentThread() == static_cast<WorkerGlobalScope*>(this)->thread()->threadID()));
+ || (isWorkerGlobalScope() && currentThread() == static_cast<WorkerGlobalScope*>(this)->thread().threadID()));
m_messagePorts.add(port);
}
{
ASSERT(port);
ASSERT((isDocument() && isMainThread())
- || (isWorkerGlobalScope() && currentThread() == static_cast<WorkerGlobalScope*>(this)->thread()->threadID()));
+ || (isWorkerGlobalScope() && currentThread() == static_cast<WorkerGlobalScope*>(this)->thread().threadID()));
m_messagePorts.remove(port);
}
, m_inspectedWorkerGlobalScope(inspectedWorkerGlobalScope)
{
std::lock_guard<std::mutex> lock(workerDebuggerAgentsMutex());
- workerDebuggerAgents().set(inspectedWorkerGlobalScope->thread(), this);
+ workerDebuggerAgents().set(&inspectedWorkerGlobalScope->thread(), this);
}
WorkerDebuggerAgent::~WorkerDebuggerAgent()
{
std::lock_guard<std::mutex> lock(workerDebuggerAgentsMutex());
- ASSERT(workerDebuggerAgents().contains(m_inspectedWorkerGlobalScope->thread()));
- workerDebuggerAgents().remove(m_inspectedWorkerGlobalScope->thread());
+ ASSERT(workerDebuggerAgents().contains(&m_inspectedWorkerGlobalScope->thread()));
+ workerDebuggerAgents().remove(&m_inspectedWorkerGlobalScope->thread());
}
void WorkerDebuggerAgent::interruptAndDispatchInspectorCommands(WorkerThread* thread)
private:
virtual bool sendMessageToFrontend(const String& message) override
{
- m_workerGlobalScope.thread()->workerReportingProxy().postMessageToPageInspector(message);
+ m_workerGlobalScope.thread().workerReportingProxy().postMessageToPageInspector(message);
return true;
}
WorkerGlobalScope& m_workerGlobalScope;
m_paused = true;
MessageQueueWaitResult result;
do {
- result = context->thread()->runLoop().runInMode(context, WorkerDebuggerAgent::debuggerTaskMode);
+ result = context->thread().runLoop().runInMode(context, WorkerDebuggerAgent::debuggerTaskMode);
// Keep waiting until execution is resumed.
} while (result == MessageQueueMessageReceived && m_paused);
}
WorkerThreadableLoader::WorkerThreadableLoader(WorkerGlobalScope* workerGlobalScope, ThreadableLoaderClient* client, const String& taskMode, const ResourceRequest& request, const ThreadableLoaderOptions& options)
: m_workerGlobalScope(workerGlobalScope)
, m_workerClientWrapper(ThreadableLoaderClientWrapper::create(client))
- , m_bridge(*(new MainThreadBridge(m_workerClientWrapper, m_workerGlobalScope->thread()->workerLoaderProxy(), taskMode, request, options, workerGlobalScope->url().strippedForUseAsReferrer())))
+ , m_bridge(*(new MainThreadBridge(m_workerClientWrapper, m_workerGlobalScope->thread().workerLoaderProxy(), taskMode, request, options, workerGlobalScope->url().strippedForUseAsReferrer())))
{
}
void WorkerThreadableLoader::loadResourceSynchronously(WorkerGlobalScope* workerGlobalScope, const ResourceRequest& request, ThreadableLoaderClient& client, const ThreadableLoaderOptions& options)
{
- WorkerRunLoop& runLoop = workerGlobalScope->thread()->runLoop();
+ WorkerRunLoop& runLoop = workerGlobalScope->thread().runLoop();
// Create a unique mode just for this synchronous resource load.
String mode = loadResourceSynchronouslyMode;
{
if (context->isWorkerGlobalScope()) {
WorkerGlobalScope* workerGlobalScope = static_cast<WorkerGlobalScope*>(context);
- workerGlobalScope->thread()->workerLoaderProxy().postTaskToLoader(createCallbackTask(&crossThreadRemoveRequestFromCache, request));
+ workerGlobalScope->thread().workerLoaderProxy().postTaskToLoader(createCallbackTask(&crossThreadRemoveRequestFromCache, request));
return;
}
namespace WebCore {
-PassRefPtr<DedicatedWorkerGlobalScope> DedicatedWorkerGlobalScope::create(const URL& url, const String& userAgent, std::unique_ptr<GroupSettings> settings, DedicatedWorkerThread* thread, const String& contentSecurityPolicy, ContentSecurityPolicy::HeaderType contentSecurityPolicyType, PassRefPtr<SecurityOrigin> topOrigin)
+PassRefPtr<DedicatedWorkerGlobalScope> DedicatedWorkerGlobalScope::create(const URL& url, const String& userAgent, std::unique_ptr<GroupSettings> settings, DedicatedWorkerThread& thread, const String& contentSecurityPolicy, ContentSecurityPolicy::HeaderType contentSecurityPolicyType, PassRefPtr<SecurityOrigin> topOrigin)
{
RefPtr<DedicatedWorkerGlobalScope> context = adoptRef(new DedicatedWorkerGlobalScope(url, userAgent, std::move(settings), thread, topOrigin));
context->applyContentSecurityPolicyFromString(contentSecurityPolicy, contentSecurityPolicyType);
return context.release();
}
-DedicatedWorkerGlobalScope::DedicatedWorkerGlobalScope(const URL& url, const String& userAgent, std::unique_ptr<GroupSettings> settings, DedicatedWorkerThread* thread, PassRefPtr<SecurityOrigin> topOrigin)
+DedicatedWorkerGlobalScope::DedicatedWorkerGlobalScope(const URL& url, const String& userAgent, std::unique_ptr<GroupSettings> settings, DedicatedWorkerThread& thread, PassRefPtr<SecurityOrigin> topOrigin)
: WorkerGlobalScope(url, userAgent, std::move(settings), thread, topOrigin)
{
}
std::unique_ptr<MessagePortChannelArray> channels = MessagePort::disentanglePorts(ports, ec);
if (ec)
return;
- thread()->workerObjectProxy().postMessageToWorkerObject(message, std::move(channels));
+ thread().workerObjectProxy().postMessageToWorkerObject(message, std::move(channels));
}
void DedicatedWorkerGlobalScope::importScripts(const Vector<String>& urls, ExceptionCode& ec)
{
Base::importScripts(urls, ec);
- thread()->workerObjectProxy().reportPendingActivity(hasPendingActivity());
+ thread().workerObjectProxy().reportPendingActivity(hasPendingActivity());
}
-DedicatedWorkerThread* DedicatedWorkerGlobalScope::thread()
+DedicatedWorkerThread& DedicatedWorkerGlobalScope::thread()
{
- return static_cast<DedicatedWorkerThread*>(Base::thread());
+ return static_cast<DedicatedWorkerThread&>(Base::thread());
}
} // namespace WebCore
class DedicatedWorkerGlobalScope : public WorkerGlobalScope {
public:
typedef WorkerGlobalScope Base;
- static PassRefPtr<DedicatedWorkerGlobalScope> create(const URL&, const String& userAgent, std::unique_ptr<GroupSettings>, DedicatedWorkerThread*, const String& contentSecurityPolicy, ContentSecurityPolicy::HeaderType contentSecurityPolicyType, PassRefPtr<SecurityOrigin> topOrigin);
+ static PassRefPtr<DedicatedWorkerGlobalScope> create(const URL&, const String& userAgent, std::unique_ptr<GroupSettings>, DedicatedWorkerThread&, const String& contentSecurityPolicy, ContentSecurityPolicy::HeaderType contentSecurityPolicyType, PassRefPtr<SecurityOrigin> topOrigin);
virtual ~DedicatedWorkerGlobalScope();
virtual bool isDedicatedWorkerGlobalScope() const override { return true; }
DEFINE_ATTRIBUTE_EVENT_LISTENER(message);
- DedicatedWorkerThread* thread();
+ DedicatedWorkerThread& thread();
private:
- DedicatedWorkerGlobalScope(const URL&, const String& userAgent, std::unique_ptr<GroupSettings>, DedicatedWorkerThread*, PassRefPtr<SecurityOrigin> topOrigin);
+ DedicatedWorkerGlobalScope(const URL&, const String& userAgent, std::unique_ptr<GroupSettings>, DedicatedWorkerThread&, PassRefPtr<SecurityOrigin> topOrigin);
};
} // namespace WebCore
PassRefPtr<WorkerGlobalScope> DedicatedWorkerThread::createWorkerGlobalScope(const URL& url, const String& userAgent, std::unique_ptr<GroupSettings> settings, const String& contentSecurityPolicy, ContentSecurityPolicy::HeaderType contentSecurityPolicyType, PassRefPtr<SecurityOrigin> topOrigin)
{
- return DedicatedWorkerGlobalScope::create(url, userAgent, std::move(settings), this, contentSecurityPolicy, contentSecurityPolicyType, topOrigin);
+ return DedicatedWorkerGlobalScope::create(url, userAgent, std::move(settings), *this, contentSecurityPolicy, contentSecurityPolicyType, topOrigin);
}
void DedicatedWorkerThread::runEventLoop()
}
// static
-PassRefPtr<SharedWorkerGlobalScope> SharedWorkerGlobalScope::create(const String& name, const URL& url, const String& userAgent, std::unique_ptr<GroupSettings> settings, SharedWorkerThread* thread, const String& contentSecurityPolicy, ContentSecurityPolicy::HeaderType contentSecurityPolicyType)
+PassRefPtr<SharedWorkerGlobalScope> SharedWorkerGlobalScope::create(const String& name, const URL& url, const String& userAgent, std::unique_ptr<GroupSettings> settings, SharedWorkerThread& thread, const String& contentSecurityPolicy, ContentSecurityPolicy::HeaderType contentSecurityPolicyType)
{
RefPtr<SharedWorkerGlobalScope> context = adoptRef(new SharedWorkerGlobalScope(name, url, userAgent, std::move(settings), thread));
context->applyContentSecurityPolicyFromString(contentSecurityPolicy, contentSecurityPolicyType);
return context.release();
}
-SharedWorkerGlobalScope::SharedWorkerGlobalScope(const String& name, const URL& url, const String& userAgent, std::unique_ptr<GroupSettings> settings, SharedWorkerThread* thread)
+SharedWorkerGlobalScope::SharedWorkerGlobalScope(const String& name, const URL& url, const String& userAgent, std::unique_ptr<GroupSettings> settings, SharedWorkerThread& thread)
: WorkerGlobalScope(url, userAgent, std::move(settings), thread, 0)
, m_name(name)
{
return SharedWorkerGlobalScopeEventTargetInterfaceType;
}
-SharedWorkerThread* SharedWorkerGlobalScope::thread()
+SharedWorkerThread& SharedWorkerGlobalScope::thread()
{
- return static_cast<SharedWorkerThread*>(Base::thread());
+ return static_cast<SharedWorkerThread&>(Base::thread());
}
void SharedWorkerGlobalScope::logExceptionToConsole(const String& errorMessage, const String& sourceURL, int lineNumber, int columnNumber, PassRefPtr<Inspector::ScriptCallStack> callStack)
class SharedWorkerGlobalScope : public WorkerGlobalScope {
public:
typedef WorkerGlobalScope Base;
- static PassRefPtr<SharedWorkerGlobalScope> create(const String& name, const URL&, const String& userAgent, std::unique_ptr<GroupSettings>, SharedWorkerThread*, const String& contentSecurityPolicy, ContentSecurityPolicy::HeaderType contentSecurityPolicyType);
+ static PassRefPtr<SharedWorkerGlobalScope> create(const String& name, const URL&, const String& userAgent, std::unique_ptr<GroupSettings>, SharedWorkerThread&, const String& contentSecurityPolicy, ContentSecurityPolicy::HeaderType contentSecurityPolicyType);
virtual ~SharedWorkerGlobalScope();
virtual bool isSharedWorkerGlobalScope() const override { return true; }
DEFINE_ATTRIBUTE_EVENT_LISTENER(connect);
String name() const { return m_name; }
- SharedWorkerThread* thread();
+ SharedWorkerThread& thread();
private:
- SharedWorkerGlobalScope(const String& name, const URL&, const String& userAgent, std::unique_ptr<GroupSettings>, SharedWorkerThread*);
+ SharedWorkerGlobalScope(const String& name, const URL&, const String& userAgent, std::unique_ptr<GroupSettings>, SharedWorkerThread&);
virtual void logExceptionToConsole(const String& errorMessage, const String& sourceURL, int lineNumber, int columnNumber, PassRefPtr<Inspector::ScriptCallStack>) override;
String m_name;
PassRefPtr<WorkerGlobalScope> SharedWorkerThread::createWorkerGlobalScope(const URL& url, const String& userAgent, std::unique_ptr<GroupSettings> settings, const String& contentSecurityPolicy, ContentSecurityPolicy::HeaderType contentSecurityPolicyType, PassRefPtr<SecurityOrigin>)
{
- return SharedWorkerGlobalScope::create(m_name, url, userAgent, std::move(settings), this, contentSecurityPolicy, contentSecurityPolicyType);
+ return SharedWorkerGlobalScope::create(m_name, url, userAgent, std::move(settings), *this, contentSecurityPolicy, contentSecurityPolicyType);
}
} // namespace WebCore
ASSERT_WITH_SECURITY_IMPLICATION(context->isWorkerGlobalScope());
WorkerGlobalScope* workerGlobalScope = static_cast<WorkerGlobalScope*>(context);
// Notify parent that this context is closed. Parent is responsible for calling WorkerThread::stop().
- workerGlobalScope->thread()->workerReportingProxy().workerGlobalScopeClosed();
+ workerGlobalScope->thread().workerReportingProxy().workerGlobalScopeClosed();
}
virtual bool isCleanupTask() const { return true; }
};
-WorkerGlobalScope::WorkerGlobalScope(const URL& url, const String& userAgent, std::unique_ptr<GroupSettings> settings, WorkerThread* thread, PassRefPtr<SecurityOrigin> topOrigin)
+WorkerGlobalScope::WorkerGlobalScope(const URL& url, const String& userAgent, std::unique_ptr<GroupSettings> settings, WorkerThread& thread, PassRefPtr<SecurityOrigin> topOrigin)
: m_url(url)
, m_userAgent(userAgent)
, m_groupSettings(std::move(settings))
WorkerGlobalScope::~WorkerGlobalScope()
{
- ASSERT(currentThread() == thread()->threadID());
+ ASSERT(currentThread() == thread().threadID());
// Make sure we have no observers.
notifyObserversOfStop();
// Notify proxy that we are going away. This can free the WorkerThread object, so do not access it after this.
- thread()->workerReportingProxy().workerGlobalScopeDestroyed();
+ thread().workerReportingProxy().workerGlobalScopeDestroyed();
}
void WorkerGlobalScope::applyContentSecurityPolicyFromString(const String& policy, ContentSecurityPolicy::HeaderType contentSecurityPolicyType)
void WorkerGlobalScope::postTask(PassOwnPtr<Task> task)
{
- thread()->runLoop().postTask(task);
+ thread().runLoop().postTask(task);
}
int WorkerGlobalScope::setTimeout(PassOwnPtr<ScheduledAction> action, int timeout)
void WorkerGlobalScope::logExceptionToConsole(const String& errorMessage, const String& sourceURL, int lineNumber, int columnNumber, PassRefPtr<ScriptCallStack>)
{
- thread()->workerReportingProxy().postExceptionToWorkerObject(errorMessage, lineNumber, columnNumber, sourceURL);
+ thread().workerReportingProxy().postExceptionToWorkerObject(errorMessage, lineNumber, columnNumber, sourceURL);
}
void WorkerGlobalScope::addConsoleMessage(MessageSource source, MessageLevel level, const String& message, unsigned long requestIdentifier)
return;
}
- thread()->workerReportingProxy().postConsoleMessageToWorkerObject(source, level, message, 0, 0, String());
+ thread().workerReportingProxy().postConsoleMessageToWorkerObject(source, level, message, 0, 0, String());
addMessageToWorkerConsole(source, level, message, String(), 0, 0, 0, 0, requestIdentifier);
}
return;
}
- thread()->workerReportingProxy().postConsoleMessageToWorkerObject(source, level, message, lineNumber, columnNumber, sourceURL);
+ thread().workerReportingProxy().postConsoleMessageToWorkerObject(source, level, message, lineNumber, columnNumber, sourceURL);
addMessageToWorkerConsole(source, level, message, sourceURL, lineNumber, columnNumber, callStack, state, requestIdentifier);
}
bool WorkerGlobalScope::isContextThread() const
{
- return currentThread() == thread()->threadID();
+ return currentThread() == thread().threadID();
}
bool WorkerGlobalScope::isJSExecutionForbidden() const
WorkerScriptController* script() { return m_script.get(); }
void clearScript() { m_script.clear(); }
- WorkerThread* thread() const { return m_thread; }
+ WorkerThread& thread() const { return m_thread; }
bool hasPendingActivity() const;
#endif
protected:
- WorkerGlobalScope(const URL&, const String& userAgent, std::unique_ptr<GroupSettings>, WorkerThread*, PassRefPtr<SecurityOrigin> topOrigin);
+ WorkerGlobalScope(const URL&, const String& userAgent, std::unique_ptr<GroupSettings>, WorkerThread&, PassRefPtr<SecurityOrigin> topOrigin);
void applyContentSecurityPolicyFromString(const String& contentSecurityPolicy, ContentSecurityPolicy::HeaderType);
virtual void logExceptionToConsole(const String& errorMessage, const String& sourceURL, int lineNumber, int columnNumber, PassRefPtr<Inspector::ScriptCallStack>) override;
mutable RefPtr<WorkerNavigator> m_navigator;
OwnPtr<WorkerScriptController> m_script;
- WorkerThread* m_thread;
+ WorkerThread& m_thread;
#if ENABLE(INSPECTOR)
const std::unique_ptr<WorkerInspectorController> m_workerInspectorController;
DedicatedWorkerGlobalScope* context = static_cast<DedicatedWorkerGlobalScope*>(scriptContext);
std::unique_ptr<MessagePortArray> ports = MessagePort::entanglePorts(*scriptContext, std::move(m_channels));
context->dispatchEvent(MessageEvent::create(std::move(ports), m_message));
- context->thread()->workerObjectProxy().confirmMessageFromWorkerObject(context->hasPendingActivity());
+ context->thread().workerObjectProxy().confirmMessageFromWorkerObject(context->hasPendingActivity());
}
private:
{
ASSERT(m_workerObject);
ASSERT((m_scriptExecutionContext->isDocument() && isMainThread())
- || (m_scriptExecutionContext->isWorkerGlobalScope() && currentThread() == static_cast<WorkerGlobalScope*>(m_scriptExecutionContext.get())->thread()->threadID()));
+ || (m_scriptExecutionContext->isWorkerGlobalScope() && currentThread() == static_cast<WorkerGlobalScope*>(m_scriptExecutionContext.get())->thread().threadID()));
}
WorkerMessagingProxy::~WorkerMessagingProxy()
{
ASSERT(!m_workerObject);
ASSERT((m_scriptExecutionContext->isDocument() && isMainThread())
- || (m_scriptExecutionContext->isWorkerGlobalScope() && currentThread() == static_cast<WorkerGlobalScope*>(m_scriptExecutionContext.get())->thread()->threadID()));
+ || (m_scriptExecutionContext->isWorkerGlobalScope() && currentThread() == static_cast<WorkerGlobalScope*>(m_scriptExecutionContext.get())->thread().threadID()));
}
void WorkerMessagingProxy::startWorkerGlobalScope(const URL& scriptURL, const String& userAgent, const String& sourceCode, WorkerThreadStartMode startMode)
MessageQueueWaitResult WorkerRunLoop::runInMode(WorkerGlobalScope* context, const ModePredicate& predicate, WaitMode waitMode)
{
ASSERT(context);
- ASSERT(context->thread());
- ASSERT(context->thread()->threadID() == currentThread());
+ ASSERT(context->thread().threadID() == currentThread());
double absoluteTime = 0.0;
if (waitMode == WaitForMessage)
void WorkerRunLoop::runCleanupTasks(WorkerGlobalScope* context)
{
ASSERT(context);
- ASSERT(context->thread());
- ASSERT(context->thread()->threadID() == currentThread());
+ ASSERT(context->thread().threadID() == currentThread());
ASSERT(m_messageQueue.killed());
while (true) {