{

static V8Platform& GetInstance();

static void EnsureInstalled();

virtual int NumberOfWorkerThreads() override;

virtual std::shared_ptr<v8::TaskRunner> GetForegroundTaskRunner(v8::Isolate* pIsolate) override;

virtual void CallOnWorkerThread(std::unique_ptr<v8::Task> upTask) override;

virtual void CallDelayedOnWorkerThread(std::unique_ptr<v8::Task> upTask, double delayInSeconds) override;

virtual std::unique_ptr<v8::JobHandle> PostJob(v8::TaskPriority priority, std::unique_ptr<v8::JobTask> upJobTask) override;

virtual double MonotonicallyIncreasingTime() override;

virtual double CurrentClockTimeMillis() override;

virtual v8::TracingController* GetTracingController() override;

V8Platform();

static V8Platform ms_Instance;

static OnceFlag ms_InstallationFlag;

v8::TracingController m_TracingController;

{

ms_InstallationFlag.CallOnce([]

{

v8::V8::InitializePlatform(&ms_Instance);

ASSERT_EVAL(v8::V8::Initialize());

});

{

auto pIsolate = v8::Isolate::GetCurrent();

if (pIsolate == nullptr)

{

upTask->Run();

}

else

{

V8IsolateImpl::GetInstanceFromIsolate(pIsolate)->RunTaskAsync(std::move(upTask));

}

{

auto pIsolate = v8::Isolate::GetCurrent();

if (pIsolate != nullptr)

{

V8IsolateImpl::GetInstanceFromIsolate(pIsolate)->RunTaskDelayed(std::move(upTask), delayInSeconds);

}

{

PROHIBIT_COPY(V8ForegroundTaskRunner)

V8ForegroundTaskRunner(V8IsolateImpl* pIsolateImpl);

virtual void PostTask(std::unique_ptr<v8::Task> upTask) override;

virtual void PostNonNestableTask(std::unique_ptr<v8::Task> upTask) override;

virtual void PostDelayedTask(std::unique_ptr<v8::Task> upTask, double delayInSeconds) override;

virtual void PostNonNestableDelayedTask(std::unique_ptr<v8::Task> upTask, double delayInSeconds) override;

virtual void PostIdleTask(std::unique_ptr<v8::IdleTask> upTask) override;

virtual bool IdleTasksEnabled() override;

virtual bool NonNestableTasksEnabled() const override;

virtual bool NonNestableDelayedTasksEnabled() const override;

V8IsolateImpl* m_pIsolateImpl;

WeakRef<V8Isolate> m_wrIsolate;

m_pIsolateImpl(pIsolateImpl),

m_wrIsolate(pIsolateImpl->CreateWeakRef())

{

{

auto spIsolate = m_wrIsolate.GetTarget();

if (spIsolate.IsEmpty())

{

upTask->Run();

}

else

{

m_pIsolateImpl->RunTaskWithLockAsync(true /*allowNesting*/, std::move(upTask));

}

{

auto spIsolate = m_wrIsolate.GetTarget();

if (!spIsolate.IsEmpty())

{

m_pIsolateImpl->RunTaskWithLockAsync(false /*allowNesting*/, std::move(upTask));

}

{

auto spIsolate = m_wrIsolate.GetTarget();

if (!spIsolate.IsEmpty())

{

m_pIsolateImpl->RunTaskWithLockDelayed(true /*allowNesting*/, std::move(upTask), delayInSeconds);

}

{

auto spIsolate = m_wrIsolate.GetTarget();

if (!spIsolate.IsEmpty())

{

m_pIsolateImpl->RunTaskWithLockDelayed(false /*allowNesting*/, std::move(upTask), delayInSeconds);

}

{

// unexpected call to unsupported method

std::terminate();

{

static V8ArrayBufferAllocator& GetInstance();

virtual void* Allocate(size_t size) override;

virtual void* AllocateUninitialized(size_t size) override;

virtual void Free(void* pvData, size_t size) override;

V8ArrayBufferAllocator();

static V8ArrayBufferAllocator ms_Instance;

m_Name(name),

m_CallWithLockLevel(0),

m_DebuggingEnabled(false),

m_AwaitingDebugger(false),

m_InMessageLoop(false),

m_QuitMessageLoop(false),

m_AbortMessageLoop(false),

m_MaxHeapSize(0),

m_HeapSizeSampleInterval(0.0),

m_HeapWatchLevel(0),

m_MaxStackUsage(0),

m_CpuProfileSampleInterval(1000U),

m_StackWatchLevel(0),

m_pStackLimit(nullptr),

m_pExecutionScope(nullptr),

m_pDocumentInfo(nullptr),

m_IsOutOfMemory(false),

m_IsExecutionTerminating(false),

m_Released(false)

{

V8Platform::EnsureInstalled();

v8::Isolate::CreateParams params;

params.array_buffer_allocator = &V8ArrayBufferAllocator::GetInstance();

if (pConstraints != nullptr)

{

params.constraints.set_max_young_generation_size_in_bytes(pConstraints->max_young_generation_size_in_bytes());

params.constraints.set_max_old_generation_size_in_bytes(pConstraints->max_old_generation_size_in_bytes());

}

m_upIsolate.reset(v8::Isolate::Allocate());

m_upIsolate->SetData(0, this);

BEGIN_ADDREF_SCOPE

v8::Isolate::Initialize(m_upIsolate.get(), params);

m_upIsolate->AddBeforeCallEnteredCallback(OnBeforeCallEntered);

m_upIsolate->SetPromiseHook(PromiseHook);

BEGIN_ISOLATE_SCOPE

m_upIsolate->SetCaptureStackTraceForUncaughtExceptions(true, 64, v8::StackTrace::kDetailed);

m_hHostObjectHolderKey = CreatePersistent(CreatePrivate());

if (options.EnableDebugging)

{

EnableDebugging(options.DebugPort, options.EnableRemoteDebugging);

}

m_upIsolate->SetHostInitializeImportMetaObjectCallback(ImportMetaInitializeCallback);

if (options.EnableDynamicModuleImports)

{

m_upIsolate->SetHostImportModuleDynamicallyCallback(ModuleImportCallback);

}

END_ISOLATE_SCOPE

END_ADDREF_SCOPE

++s_InstanceCount;

{

_ASSERTE(IsCurrent() && IsLocked());

if (!options.EnableDebugging)

{

m_ContextEntries.emplace_back(pContextImpl);

}

else

{

m_ContextEntries.emplace_front(pContextImpl);

EnableDebugging(options.DebugPort, options.EnableRemoteDebugging);

}

if (options.EnableDynamicModuleImports)

{

m_upIsolate->SetHostImportModuleDynamicallyCallback(ModuleImportCallback);

}

if (m_upInspector)

{

m_upInspector->contextCreated(v8_inspector::V8ContextInfo(pContextImpl->GetContext(), s_ContextGroupId, pContextImpl->GetName().GetStringView()));

}

{

_ASSERTE(IsCurrent() && IsLocked());

if (m_upInspector)

{

m_upInspector->contextDestroyed(pContextImpl->GetContext());

}

m_ContextEntries.remove_if([pContextImpl] (const ContextEntry& contextEntry)

{

return contextEntry.pContextImpl == pContextImpl;

});

{

_ASSERTE(IsCurrent() && IsLocked());

if (!m_DebuggingEnabled)

{

const char* pVersion = v8::V8::GetVersion();

StdString version(v8_inspector::StringView(reinterpret_cast<const uint8_t*>(pVersion), strlen(pVersion)));

if (port < 1)

{

port = 9222;

}

auto wrIsolate = CreateWeakRef();

m_pvDebugAgent = HostObjectUtil::GetInstance().CreateDebugAgent(m_Name, version, port, remote, [this, wrIsolate] (IHostObjectUtil::DebugDirective directive, const StdString* pCommand)

{

auto spIsolate = wrIsolate.GetTarget();

if (!spIsolate.IsEmpty())

{

if (directive == IHostObjectUtil::DebugDirective::ConnectClient)

{

ConnectDebugClient();

}

else if ((directive == IHostObjectUtil::DebugDirective::SendCommand) && pCommand)

{

SendDebugCommand(*pCommand);

}

else if (directive == IHostObjectUtil::DebugDirective::DisconnectClient)

{

DisconnectDebugClient();

}

}

});

m_upInspector = v8_inspector::V8Inspector::create(m_upIsolate.get(), this);

m_DebuggingEnabled = true;

m_DebugPort = port;

}

{

_ASSERTE(IsCurrent() && IsLocked());

if (m_DebuggingEnabled)

{

m_upInspectorSession.reset();

m_upInspector.reset();

HostObjectUtil::GetInstance().DestroyDebugAgent(m_pvDebugAgent);

m_DebuggingEnabled = false;

}

{

m_MaxHeapSize = value;

m_IsOutOfMemory = false;

{

BEGIN_ISOLATE_SCOPE

if (m_DebuggingEnabled)

{

if (!m_upInspectorSession && !RunMessageLoop(true))

{

throw V8Exception(V8Exception::Type::Interrupt, m_Name, StdString(SL("Script execution interrupted by host while awaiting debugger connection")), false);

}

_ASSERTE(m_upInspectorSession);

if (m_upInspectorSession)

{

StdString breakReason(SL("Break on debugger connection"));

m_upInspectorSession->schedulePauseOnNextStatement(breakReason.GetStringView(), breakReason.GetStringView());

}

}

END_ISOLATE_SCOPE

{

BEGIN_ISOLATE_SCOPE

m_upIsolate->GetHeapStatistics(&heapStatistics);

END_ISOLATE_SCOPE

{

BEGIN_ISOLATE_SCOPE

BEGIN_MUTEX_SCOPE(m_DataMutex)

return m_Statistics;

END_MUTEX_SCOPE

END_ISOLATE_SCOPE

{

BEGIN_ISOLATE_SCOPE

if (exhaustive)

{

ClearScriptCache();

LowMemoryNotification();

}

else

{

while (!IdleNotificationDeadline(V8Platform::GetInstance().MonotonicallyIncreasingTime() + 0.1));

{

BEGIN_ISOLATE_SCOPE

if (!m_upCpuProfiler)

{

m_upCpuProfiler.reset(v8::CpuProfiler::New(m_upIsolate.get()));

}

v8::Local<v8::String> hName;

if (!CreateString(name).ToLocal(&hName))

{

return false;

}

m_upCpuProfiler->StartProfiling(hName, mode, recordSamples);

return true;

END_ISOLATE_SCOPE

{

BEGIN_ISOLATE_SCOPE

if (!m_upCpuProfiler)

{

return false;

}

v8::Local<v8::String> hName;

if (!CreateString(name).ToLocal(&hName))

{

return false;

}

UniqueDeletePtr<v8::CpuProfile> upProfile(m_upCpuProfiler->StopProfiling(hName));

if (!upProfile)

{

return false;

}

if (pCallback)

{

pCallback(*upProfile, pvArg);

}

return true;

END_ISOLATE_SCOPE

{

BEGIN_ISOLATE_SCOPE

v8::CpuProfiler::CollectSample(m_upIsolate.get());

END_ISOLATE_SCOPE

{

BEGIN_ISOLATE_SCOPE

if (value != m_CpuProfileSampleInterval)

{

m_CpuProfileSampleInterval = std::min(std::max(value, 125U), static_cast<uint32_t>(INT_MAX));

if (!m_upCpuProfiler)

{

m_upCpuProfiler.reset(v8::CpuProfiler::New(m_upIsolate.get()));

}

m_upCpuProfiler->SetSamplingInterval(static_cast<int>(m_CpuProfileSampleInterval));

}

END_ISOLATE_SCOPE

{

_ASSERTE(IsCurrent() && IsLocked());

BEGIN_MUTEX_SCOPE(m_DataMutex)

m_QuitMessageLoop = true;

END_MUTEX_SCOPE

{

_ASSERTE(IsCurrent() && IsLocked());

if (m_ContextEntries.size() > 0)

{

return m_ContextEntries.front().pContextImpl->GetContext();

}

return v8_inspector::V8InspectorClient::ensureDefaultContextInGroup(contextGroupId);

{

_ASSERTE(IsCurrent() && IsLocked());

if (m_pvDebugAgent)

{

HostObjectUtil::GetInstance().SendDebugMessage(m_pvDebugAgent, StdString(upMessage->string()));

}

{

CallWithLockNoWait(true /*allowNesting*/, [pvObject] (V8IsolateImpl* pIsolateImpl)

{

pIsolateImpl->Dispose(::HandleFromPtr<v8::Object>(pvObject));

});

{

CallWithLockNoWait(true /*allowNesting*/, [pvScript] (V8IsolateImpl* pIsolateImpl)

{

pIsolateImpl->Dispose(::HandleFromPtr<v8::Script>(pvScript));

});

{

if (upTask)

{

if (m_Released)

{

upTask->Run();

}

else

{

std::shared_ptr<v8::Task> spTask(std::move(upTask));

std::weak_ptr<v8::Task> wpTask(spTask);

BEGIN_MUTEX_SCOPE(m_DataMutex)

m_AsyncTasks.push_back(std::move(spTask));

m_Statistics.BumpPostedTaskCount(TaskKind::Worker);

END_MUTEX_SCOPE

auto wrIsolate = CreateWeakRef();

HostObjectUtil::GetInstance().QueueNativeCallback([this, wrIsolate, wpTask] ()

{

auto spIsolate = wrIsolate.GetTarget();

if (!spIsolate.IsEmpty())

{

auto spTask = wpTask.lock();

if (spTask)

{

spTask->Run();

BEGIN_MUTEX_SCOPE(m_DataMutex)

auto it = std::remove(m_AsyncTasks.begin(), m_AsyncTasks.end(), spTask);

m_AsyncTasks.erase(it, m_AsyncTasks.end());

m_Statistics.BumpInvokedTaskCount(TaskKind::Worker);

END_MUTEX_SCOPE

}

}

});

}

}

{

if (upTask && !m_Released)

{

std::shared_ptr<v8::Task> spTask(std::move(upTask));

auto wrIsolate = CreateWeakRef();

SharedPtr<Timer> spTimer(new Timer(static_cast<int>(delayInSeconds * 1000), -1, [this, wrIsolate, spTask] (Timer* pTimer) mutable

{

auto spIsolate = wrIsolate.GetTarget();

if (!spIsolate.IsEmpty())

{

spTask->Run();

// Release the timer's strong task reference. Doing so avoids a deadlock when

// spIsolate's implicit destruction below triggers immediate isolate teardown.

spTask.reset();

// the timer has fired; discard it

BEGIN_MUTEX_SCOPE(m_DataMutex)

auto it = std::remove(m_TaskTimers.begin(), m_TaskTimers.end(), SharedPtr<Timer>(pTimer));

m_TaskTimers.erase(it, m_TaskTimers.end());

m_Statistics.BumpInvokedTaskCount(TaskKind::DelayedWorker);

END_MUTEX_SCOPE

}

else

{

// Release the timer's strong task reference. Doing so avoids a deadlock if the

// isolate is awaiting task completion on the managed finalization thread.

spTask.reset();

}

}));

// hold on to the timer to ensure callback execution

BEGIN_MUTEX_SCOPE(m_DataMutex)

m_TaskTimers.push_back(spTimer);

m_Statistics.BumpPostedTaskCount(TaskKind::DelayedWorker);

END_MUTEX_SCOPE

// Release the local task reference explicitly. Doing so avoids a deadlock if the callback is

// executed synchronously. That shouldn't happen given the current timer implementation.

spTask.reset();

// now it's safe to start the timer

spTimer->Start();

}

{

if (upTask)

{

if (m_Released)

{

if (allowNesting)

{

upTask->Run();