{

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> spTask) override;

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

virtual void CallOnForegroundThread(v8::Isolate* pIsolate, v8::Task* pTask) override;

virtual void CallDelayedOnForegroundThread(v8::Isolate* pIsolate, v8::Task* pTask, double delayInSeconds) 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)

{

spTask->Run();

}

else

{

V8IsolateImpl::GetInstanceFromIsolate(pIsolate)->RunTaskAsync(spTask.release());

}

{

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

if (pIsolate != nullptr)

{

V8IsolateImpl::GetInstanceFromIsolate(pIsolate)->RunTaskDelayed(spTask.release(), delayInSeconds);

}

{

PROHIBIT_COPY(V8ForegroundTaskRunner)

V8ForegroundTaskRunner(V8IsolateImpl* pIsolateImpl);

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

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

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

virtual bool IdleTasksEnabled() override;

V8IsolateImpl* m_pIsolateImpl;

WeakRef<V8Isolate> m_wrIsolate;

m_pIsolateImpl(pIsolateImpl),

m_wrIsolate(pIsolateImpl->CreateWeakRef())

{

{

auto spIsolate = m_wrIsolate.GetTarget();

if (spIsolate.IsEmpty())

{

spTask->Run();

}

else

{

m_pIsolateImpl->RunTaskWithLockAsync(spTask.release());

}

{

auto spIsolate = m_wrIsolate.GetTarget();

if (!spIsolate.IsEmpty())

{

m_pIsolateImpl->RunTaskWithLockDelayed(spTask.release(), 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_DebuggingEnabled(false),

m_AwaitingDebugger(false),

m_InMessageLoop(false),

m_QuitMessageLoop(false),

m_AbortMessageLoop(false),

m_MaxHeapSize(0),

m_HeapWatchLevel(0),

m_MaxStackUsage(0),

m_CpuProfileSampleInterval(1000U),

m_StackWatchLevel(0),

m_pStackLimit(nullptr),

m_pExecutionScope(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_semi_space_size_in_kb(pConstraints->max_semi_space_size_in_kb());

params.constraints.set_max_old_space_size(pConstraints->max_old_space_size());

}

BEGIN_PULSE_VALUE_SCOPE(&s_pInstanceInConstructor, this)

m_spIsolate.reset(v8::Isolate::New(params));

END_PULSE_VALUE_SCOPE

m_spIsolate->AddBeforeCallEnteredCallback(OnBeforeCallEntered);

m_spIsolate->SetPromiseHook(PromiseHook);

BEGIN_ADDREF_SCOPE

BEGIN_ISOLATE_SCOPE

m_spIsolate->SetData(0, this);

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

m_hHostObjectHolderKey = CreatePersistent(CreatePrivate());

if (options.EnableDebugging)

{

EnableDebugging(options.DebugPort, options.EnableRemoteDebugging);

}

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 (m_spInspector)

{

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

}

{

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

if (m_spInspector)

{

m_spInspector->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 = HostObjectHelpers::CreateDebugAgent(m_Name, version, port, remote, [this, wrIsolate] (HostObjectHelpers::DebugDirective directive, const StdString* pCommand)

{

auto spIsolate = wrIsolate.GetTarget();

if (!spIsolate.IsEmpty())

{

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

{

ConnectDebugClient();

}

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

{

SendDebugCommand(*pCommand);

}

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

{

DisconnectDebugClient();

}

}

});

m_spInspector = v8_inspector::V8Inspector::create(m_spIsolate.get(), this);

m_DebuggingEnabled = true;

m_DebugPort = port;

}

{

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

if (m_DebuggingEnabled)

{

m_spInspectorSession.reset();

m_spInspector.reset();

HostObjectHelpers::DestroyDebugAgent(m_pvDebugAgent);

m_DebuggingEnabled = false;

}

{

m_MaxHeapSize = value;

m_IsOutOfMemory = false;

{

BEGIN_ISOLATE_SCOPE

if (m_DebuggingEnabled)

{

if (!m_spInspectorSession && !RunMessageLoop(true))

{

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

}

_ASSERTE(m_spInspectorSession);

if (m_spInspectorSession)

{

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

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

}

}

END_ISOLATE_SCOPE

{

BEGIN_ISOLATE_SCOPE

m_spIsolate->GetHeapStatistics(&heapStatistics);

END_ISOLATE_SCOPE

{

BEGIN_ISOLATE_SCOPE

if (exhaustive)

{

LowMemoryNotification();

}

else

{

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

{

BEGIN_ISOLATE_SCOPE

if (!m_spCpuProfiler)

{

m_spCpuProfiler.reset(v8::CpuProfiler::New(m_spIsolate.get()));

}

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

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

{

return false;

}

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

return true;

END_ISOLATE_SCOPE

{

BEGIN_ISOLATE_SCOPE

if (!m_spCpuProfiler)

{

return false;

}

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

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

{

return false;

}

UniqueDeletePtr<v8::CpuProfile> spProfile(m_spCpuProfiler->StopProfiling(hName));

if (!spProfile)

{

return false;

}

if (pCallback)

{

pCallback(*spProfile, pvArg);

}

return true;

END_ISOLATE_SCOPE

{

BEGIN_ISOLATE_SCOPE

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

END_ISOLATE_SCOPE

{

BEGIN_ISOLATE_SCOPE

if (value != m_CpuProfileSampleInterval)

{

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

if (!m_spCpuProfiler)

{

m_spCpuProfiler.reset(v8::CpuProfiler::New(m_spIsolate.get()));

}

m_spCpuProfiler->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)

{

HostObjectHelpers::SendDebugMessage(m_pvDebugAgent, StdString(spMessage->string()));

}

{

CallWithLockNoWait([pvObject] (V8IsolateImpl* pIsolateImpl)

{

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

});

{

CallWithLockNoWait([pvScript] (V8IsolateImpl* pIsolateImpl)

{

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

});

{

if (m_Released)

{

pTask->Run();

delete pTask;

}

else

{

std::shared_ptr<v8::Task> spTask(pTask);

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

BEGIN_MUTEX_SCOPE(m_DataMutex)

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

END_MUTEX_SCOPE

auto wrIsolate = CreateWeakRef();

HostObjectHelpers::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());

END_MUTEX_SCOPE

}

}

});

}

{

if (m_Released)

{

delete pTask;

}

else

{

std::shared_ptr<v8::Task> spTask(pTask);

auto wrIsolate = CreateWeakRef();

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

{

if (spTask)

{

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(), pTimer);

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

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);

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 (m_Released)

{

pTask->Run();

delete pTask;

}

else

{

std::shared_ptr<v8::Task> spTask(pTask);

CallWithLockAsync([spTask] (V8IsolateImpl* /*pIsolateImpl*/)

{

spTask->Run();

});

}

{

if (m_Released)

{

delete pTask;

}

else

{

std::shared_ptr<v8::Task> spTask(pTask);

auto wrIsolate = CreateWeakRef();

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

{

if (spTask)

{

auto spIsolate = wrIsolate.GetTarget();

if (!spIsolate.IsEmpty())

{

CallWithLockNoWait([spTask] (V8IsolateImpl* /*pIsolateImpl*/)

{

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(), pTimer);

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

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);

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();

}

{

BEGIN_MUTEX_SCOPE(m_DataMutex)