void DatabaseContext::didCloseDatabase(DatabaseBackendBase& database)
{
if (!database.isSyncDatabase())
return;
ASSERT(isContextThread());
m_openSyncDatabases.remove(&database);
}
void DatabaseContext::didOpenDatabase(DatabaseBackendBase& database)
{
if (!database.isSyncDatabase())
return;
ASSERT(isContextThread());
m_openSyncDatabases.add(&database);
}
void WorkerGlobalScope::addConsoleMessage(ConsoleMessage* consoleMessage) {
DCHECK(isContextThread());
thread()->workerReportingProxy().reportConsoleMessage(
consoleMessage->source(), consoleMessage->level(),
consoleMessage->message(), consoleMessage->location());
thread()->consoleMessageStorage()->addConsoleMessage(this, consoleMessage);
}
void WorkerGlobalScope::addConsoleMessage(RawPtr<ConsoleMessage> prpConsoleMessage)
{
ASSERT(isContextThread());
RawPtr<ConsoleMessage> consoleMessage = prpConsoleMessage;
thread()->workerReportingProxy().reportConsoleMessage(consoleMessage);
addMessageToWorkerConsole(consoleMessage.release());
}
void WorkerGlobalScope::addMessageToWorkerConsole(MessageSource source, MessageLevel level, const String& message, const String& sourceURL, unsigned lineNumber, unsigned columnNumber, PassRefPtr<ScriptCallStack> callStack, ScriptState* state, unsigned long requestIdentifier)
{
ASSERT(isContextThread());
if (callStack)
InspectorInstrumentation::addMessageToConsole(this, source, LogMessageType, level, message, callStack.get(), requestIdentifier);
else
InspectorInstrumentation::addMessageToConsole(this, source, LogMessageType, level, message, sourceURL, lineNumber, columnNumber, state, requestIdentifier);
}
void ScriptExecutionContext::removeOpenDatabase(Database* database)
{
ASSERT(isContextThread());
ASSERT(m_openDatabaseSet && m_openDatabaseSet->contains(database));
if (!m_openDatabaseSet)
return;
m_openDatabaseSet->remove(database);
}
void ScriptExecutionContext::stopDatabases(DatabaseTaskSynchronizer* cleanupSync)
{
ASSERT(isContextThread());
if (m_databaseThread)
m_databaseThread->requestTermination(cleanupSync);
else if (cleanupSync)
cleanupSync->taskCompleted();
}
void WorkerContext::addMessageToWorkerConsole(MessageSource source, MessageType type, MessageLevel level, const String& message, const String& sourceURL, unsigned lineNumber, PassRefPtr<ScriptCallStack> callStack)
{
ASSERT(isContextThread());
if (callStack)
InspectorInstrumentation::addMessageToConsole(this, source, type, level, message, 0, callStack);
else
InspectorInstrumentation::addMessageToConsole(this, source, type, level, message, sourceURL, lineNumber);
}
void DatabaseContext::didCloseDatabase(DatabaseBackendBase& database)
{
#if !ENABLE(OILPAN)
if (!database.isSyncDatabase())
return;
ASSERT(isContextThread());
m_openSyncDatabases.remove(&database);
#endif
}
void WorkerContext::addMessage(MessageSource source, MessageLevel level, const String& message, const String& sourceURL, unsigned lineNumber, PassRefPtr<ScriptCallStack> callStack, ScriptState* state, unsigned long requestIdentifier)
{
if (!isContextThread()) {
postTask(AddConsoleMessageTask::create(source, level, message));
return;
}
thread()->workerReportingProxy().postConsoleMessageToWorkerObject(source, level, message, lineNumber, sourceURL);
addMessageToWorkerConsole(source, level, message, sourceURL, lineNumber, callStack, state, requestIdentifier);
}
void ScriptExecutionContext::addOpenDatabase(Database* database)
{
ASSERT(isContextThread());
if (!m_openDatabaseSet)
m_openDatabaseSet.set(new DatabaseSet());
ASSERT(!m_openDatabaseSet->contains(database));
m_openDatabaseSet->add(database);
}
void WorkerGlobalScope::addMessage(MessageSource source, MessageLevel level, const String& message, const String& sourceURL, unsigned lineNumber, ScriptState* state)
{
if (!isContextThread()) {
postTask(AddConsoleMessageTask::create(source, level, message));
return;
}
thread()->workerReportingProxy().postConsoleMessageToWorkerObject(source, level, message, lineNumber, sourceURL);
addMessageToWorkerConsole(source, level, message, sourceURL, lineNumber, 0, state);
}
void WorkerGlobalScope::addConsoleMessage(std::unique_ptr<Inspector::ConsoleMessage> message)
{
if (!isContextThread()) {
postTask(AddConsoleMessageTask(message->source(), message->level(), StringCapture(message->message())));
return;
}
thread().workerReportingProxy().postConsoleMessageToWorkerObject(message->source(), message->level(), message->message(), message->line(), message->column(), message->url());
addMessageToWorkerConsole(WTFMove(message));
}
void WorkerGlobalScope::addMessage(MessageSource source, MessageLevel level, const String& message, const String& sourceURL, unsigned lineNumber, unsigned columnNumber, RefPtr<ScriptCallStack>&& callStack, JSC::ExecState* state, unsigned long requestIdentifier)
{
if (!isContextThread()) {
postTask(AddConsoleMessageTask(source, level, StringCapture(message)));
return;
}
thread().workerReportingProxy().postConsoleMessageToWorkerObject(source, level, message, lineNumber, columnNumber, sourceURL);
addMessageToWorkerConsole(source, level, message, sourceURL, lineNumber, columnNumber, WTF::move(callStack), state, requestIdentifier);
}
void WorkerGlobalScope::addConsoleMessage(PassRefPtrWillBeRawPtr<ConsoleMessage> prpConsoleMessage)
{
RefPtrWillBeRawPtr<ConsoleMessage> consoleMessage = prpConsoleMessage;
if (!isContextThread()) {
postTask(AddConsoleMessageTask::create(consoleMessage->source(), consoleMessage->level(), consoleMessage->message()));
return;
}
thread()->workerReportingProxy().reportConsoleMessage(consoleMessage);
addMessageToWorkerConsole(consoleMessage.release());
}
void WorkerGlobalScope::addConsoleMessage(MessageSource source, MessageLevel level, const String& message, unsigned long requestIdentifier)
{
if (!isContextThread()) {
postTask(AddConsoleMessageTask::create(source, level, message));
return;
}
thread()->workerReportingProxy().postConsoleMessageToWorkerObject(source, level, message, 0, 0, String());
addMessageToWorkerConsole(source, level, message, String(), 0, 0, 0, 0, requestIdentifier);
}
void DatabaseContext::didOpenDatabase(DatabaseBackendBase& database)
{
if (!database.isSyncDatabase())
return;
ASSERT(isContextThread());
#if ENABLE(OILPAN)
m_openSyncDatabases.add(&database, adoptPtr(new DatabaseCloser(database)));
#else
m_openSyncDatabases.add(&database);
#endif
}
void WorkerGlobalScope::addMessageToWorkerConsole(MessageSource source, MessageLevel level, const String& messageText, const String& suggestedURL, unsigned suggestedLineNumber, unsigned suggestedColumnNumber, RefPtr<ScriptCallStack>&& callStack, JSC::ExecState* state, unsigned long requestIdentifier)
{
ASSERT(isContextThread());
std::unique_ptr<Inspector::ConsoleMessage> message;
if (callStack)
message = std::make_unique<Inspector::ConsoleMessage>(source, MessageType::Log, level, messageText, WTF::move(callStack), requestIdentifier);
else
message = std::make_unique<Inspector::ConsoleMessage>(source, MessageType::Log, level, messageText, suggestedURL, suggestedLineNumber, suggestedColumnNumber, state, requestIdentifier);
InspectorInstrumentation::addMessageToConsole(this, WTF::move(message));
}
void DatabaseContext::stopSyncDatabases()
{
// SQLite is "multi-thread safe", but each database handle can only be used
// on a single thread at a time.
//
// For DatabaseBackendSync, we open the SQLite database on the script
// context thread. And hence we should also close it on that same
// thread. This means that the SQLite database need to be closed here in the
// destructor.
ASSERT(isContextThread());
Vector<DatabaseBackendBase*> syncDatabases;
copyToVector(m_openSyncDatabases, syncDatabases);
m_openSyncDatabases.clear();
for (size_t i = 0; i < syncDatabases.size(); ++i)
syncDatabases[i]->closeImmediately();
}
void ScriptExecutionContext::stopDatabases(DatabaseTaskSynchronizer* cleanupSync)
{
ASSERT(isContextThread());
if (m_openDatabaseSet) {
DatabaseSet::iterator i = m_openDatabaseSet->begin();
DatabaseSet::iterator end = m_openDatabaseSet->end();
for (; i != end; ++i) {
(*i)->stop();
if (m_databaseThread)
m_databaseThread->unscheduleDatabaseTasks(*i);
}
}
if (m_databaseThread)
m_databaseThread->requestTermination(cleanupSync);
else if (cleanupSync)
cleanupSync->taskCompleted();
}
void WorkerGlobalScope::addMessageToWorkerConsole(std::unique_ptr<Inspector::ConsoleMessage> message)
{
ASSERT(isContextThread());
InspectorInstrumentation::addMessageToConsole(this, WTFMove(message));
}
void ThreadedWorkletGlobalScope::countFeature(UseCounter::Feature feature) {
DCHECK(isContextThread());
DCHECK(m_thread);
m_thread->workerReportingProxy().countFeature(feature);
}
void ThreadedWorkletGlobalScope::countDeprecation(UseCounter::Feature feature) {
DCHECK(isContextThread());
DCHECK(m_thread);
addDeprecationMessage(feature);
m_thread->workerReportingProxy().countDeprecation(feature);
}
void ThreadedWorkletGlobalScope::dispose() {
DCHECK(isContextThread());
WorkletGlobalScope::dispose();
m_thread = nullptr;
}
void ThreadedWorkletGlobalScope::exceptionThrown(ErrorEvent* errorEvent) {
DCHECK(isContextThread());
if (WorkerThreadDebugger* debugger =
WorkerThreadDebugger::from(thread()->isolate()))
debugger->exceptionThrown(m_thread, errorEvent);
}
void WorkerGlobalScope::addMessageToWorkerConsole(RawPtr<ConsoleMessage> consoleMessage)
{
ASSERT(isContextThread());
m_messageStorage->reportMessage(this, consoleMessage);
}
void WorkerGlobalScope::addMessageToWorkerConsole(PassRefPtrWillBeRawPtr<ConsoleMessage> consoleMessage)
{
ASSERT(isContextThread());
m_messageStorage->reportMessage(consoleMessage);
}
