{

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

if (!V8_SPLIT_PROXY_MANAGED_INVOKE_NOTHROW(StdBool, GetTopLevelAwait))

{

v8::V8::SetFlagsFromString("--no_harmony_top_level_await");

}

});

{

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;

{

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

if (pIsolate)

{

V8IsolateImpl::GetInstanceFromIsolate(pIsolate)->FreeArrayBuffer(pvData, size);

}

{

PROHIBIT_COPY(V8OutputStream)

explicit V8OutputStream(void* pvStream):

m_pvStream(pvStream)

{

}

virtual int GetChunkSize() override;

virtual WriteResult WriteAsciiChunk(char* pData, int size) override;

virtual void EndOfStream() override;

void* m_pvStream;

{

try

{

V8_SPLIT_PROXY_MANAGED_INVOKE_VOID(WriteBytesToStream, m_pvStream, reinterpret_cast<uint8_t*>(pData), size);

return kContinue;

}

catch (const HostException& exception)

{

V8_SPLIT_PROXY_MANAGED_INVOKE_VOID(ScheduleForwardingException, exception.GetException());

return kAbort;

}

m_Name(name),

m_CallWithLockLevel(0),

m_DebuggingEnabled(false),

m_MaxArrayBufferAllocation(options.MaxArrayBufferAllocation),

m_ArrayBufferAllocation(0),

m_MaxHeapSize(0),

m_HeapSizeSampleInterval(0.0),

m_HeapWatchLevel(0),

m_HeapExpansionMultiplier(options.HeapExpansionMultiplier),

m_MaxStackUsage(0),

m_EnableInterruptPropagation(false),

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->AddNearHeapLimitCallback(HeapExpansionCallback, this);

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)

{

auto exitReason = RunMessageLoop(RunMessageLoopReason::AwaitingDebugger);

switch (exitReason)

{

case ExitMessageLoopReason::TerminatedExecution:

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

case ExitMessageLoopReason::CanceledAwaitDebugger:

return;

default:

_ASSERTE(exitReason == ExitMessageLoopReason::ResumedExecution);

}

}

_ASSERTE(m_upInspectorSession);

if (m_upInspectorSession)

{

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

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

}

}

END_ISOLATE_SCOPE

{

BEGIN_MUTEX_SCOPE(m_DataMutex)

if (m_optRunMessageLoopReason == RunMessageLoopReason::AwaitingDebugger)

{

m_optExitMessageLoopReason = ExitMessageLoopReason::CanceledAwaitDebugger;

m_CallWithLockQueueChanged.notify_one();

}

END_MUTEX_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

{

BEGIN_ISOLATE_SCOPE

auto pSnapshot = m_upIsolate->GetHeapProfiler()->TakeHeapSnapshot();

V8OutputStream stream(pvStream);

pSnapshot->Serialize(&stream);

const_cast<v8::HeapSnapshot*>(pSnapshot)->Delete();

END_ISOLATE_SCOPE

{

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

BEGIN_MUTEX_SCOPE(m_DataMutex)

m_optExitMessageLoopReason = ExitMessageLoopReason::ResumedExecution;

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

});