// Copyright (c) Microsoft Corporation. All rights reserved.

// Licensed under the MIT license.

#include "ClearScriptV8Native.h"

//-----------------------------------------------------------------------------

// V8Platform

//-----------------------------------------------------------------------------

class V8Platform final: public v8::Platform

{

public:

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;

private:

V8Platform();

static V8Platform ms_Instance;

static OnceFlag ms_InstallationFlag;

v8::TracingController m_TracingController;

};

//-----------------------------------------------------------------------------

V8Platform& V8Platform::GetInstance()

{

return ms_Instance;

}

//-----------------------------------------------------------------------------

void V8Platform::EnsureInstalled()

{

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

}

});

}

//-----------------------------------------------------------------------------

int V8Platform::NumberOfWorkerThreads()

{

return static_cast<int>(HighResolutionClock::GetHardwareConcurrency());

}

//-----------------------------------------------------------------------------

std::shared_ptr<v8::TaskRunner> V8Platform::GetForegroundTaskRunner(v8::Isolate* pIsolate)

{

return V8IsolateImpl::GetInstanceFromIsolate(pIsolate)->GetForegroundTaskRunner();

}

//-----------------------------------------------------------------------------

void V8Platform::CallOnWorkerThread(std::unique_ptr<v8::Task> upTask)

{

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

if (pIsolate == nullptr)

{

upTask->Run();

}

else

{

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

}

}

//-----------------------------------------------------------------------------

void V8Platform::CallDelayedOnWorkerThread(std::unique_ptr<v8::Task> upTask, double delayInSeconds)

{

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

if (pIsolate != nullptr)

{

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

}

}

//-----------------------------------------------------------------------------

std::unique_ptr<v8::JobHandle> V8Platform::PostJob(v8::TaskPriority priority, std::unique_ptr<v8::JobTask> upJobTask)

{

return v8::platform::NewDefaultJobHandle(this, priority, std::move(upJobTask), NumberOfWorkerThreads());

}

//-----------------------------------------------------------------------------

double V8Platform::MonotonicallyIncreasingTime()

{

return HighResolutionClock::GetRelativeSeconds();

}

//-----------------------------------------------------------------------------

double V8Platform::CurrentClockTimeMillis()

{

return std::chrono::duration_cast<std::chrono::duration<double, std::milli>>(std::chrono::system_clock::now().time_since_epoch()).count();

}

//-----------------------------------------------------------------------------

v8::TracingController* V8Platform::GetTracingController()

{

return &m_TracingController;

}

//-----------------------------------------------------------------------------

V8Platform::V8Platform()

{

}

//-----------------------------------------------------------------------------

V8Platform V8Platform::ms_Instance;

OnceFlag V8Platform::ms_InstallationFlag;

//-----------------------------------------------------------------------------

// V8ForegroundTaskRunner

//-----------------------------------------------------------------------------

class V8ForegroundTaskRunner final: public v8::TaskRunner

{

PROHIBIT_COPY(V8ForegroundTaskRunner)

public:

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;

private:

V8IsolateImpl* m_pIsolateImpl;

WeakRef<V8Isolate> m_wrIsolate;

};

//-----------------------------------------------------------------------------

V8ForegroundTaskRunner::V8ForegroundTaskRunner(V8IsolateImpl* pIsolateImpl):

m_pIsolateImpl(pIsolateImpl),

m_wrIsolate(pIsolateImpl->CreateWeakRef())

{

}

//-----------------------------------------------------------------------------

void V8ForegroundTaskRunner::PostTask(std::unique_ptr<v8::Task> upTask)

{

auto spIsolate = m_wrIsolate.GetTarget();

if (spIsolate.IsEmpty())

{

upTask->Run();

}

else

{

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

}

}

//-----------------------------------------------------------------------------

void V8ForegroundTaskRunner::PostNonNestableTask(std::unique_ptr<v8::Task> upTask)

{

auto spIsolate = m_wrIsolate.GetTarget();

if (!spIsolate.IsEmpty())

{

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

}

}

//-----------------------------------------------------------------------------

void V8ForegroundTaskRunner::PostDelayedTask(std::unique_ptr<v8::Task> upTask, double delayInSeconds)

{

auto spIsolate = m_wrIsolate.GetTarget();

if (!spIsolate.IsEmpty())

{

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

}

}

//-----------------------------------------------------------------------------

void V8ForegroundTaskRunner::PostNonNestableDelayedTask(std::unique_ptr<v8::Task> upTask, double delayInSeconds)

{

auto spIsolate = m_wrIsolate.GetTarget();

if (!spIsolate.IsEmpty())

{

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

}

}

//-----------------------------------------------------------------------------

void V8ForegroundTaskRunner::PostIdleTask(std::unique_ptr<v8::IdleTask> /*upTask*/)

{

// unexpected call to unsupported method

std::terminate();

}

//-----------------------------------------------------------------------------

bool V8ForegroundTaskRunner::IdleTasksEnabled()

{

return false;

}

//-----------------------------------------------------------------------------

bool V8ForegroundTaskRunner::NonNestableTasksEnabled() const

{

return true;

}

//-----------------------------------------------------------------------------

bool V8ForegroundTaskRunner::NonNestableDelayedTasksEnabled() const

{

return true;

}

//-----------------------------------------------------------------------------

// V8ArrayBufferAllocator

//-----------------------------------------------------------------------------

class V8ArrayBufferAllocator final: public v8::ArrayBuffer::Allocator

{

public:

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;

private:

V8ArrayBufferAllocator();

static V8ArrayBufferAllocator ms_Instance;

};

//-----------------------------------------------------------------------------

V8ArrayBufferAllocator& V8ArrayBufferAllocator::GetInstance()

{

return ms_Instance;

}

//-----------------------------------------------------------------------------

void* V8ArrayBufferAllocator::Allocate(size_t size)

{

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

if (pIsolate)

{

return V8IsolateImpl::GetInstanceFromIsolate(pIsolate)->AllocateArrayBuffer(size);

}

return nullptr;

}

//-----------------------------------------------------------------------------

void* V8ArrayBufferAllocator::AllocateUninitialized(size_t size)

{

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

if (pIsolate)

{

return V8IsolateImpl::GetInstanceFromIsolate(pIsolate)->AllocateUninitializedArrayBuffer(size);

}

return nullptr;

}

//-----------------------------------------------------------------------------

void V8ArrayBufferAllocator::Free(void* pvData, size_t size)

{

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

if (pIsolate)

{

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

}

}

//-----------------------------------------------------------------------------

V8ArrayBufferAllocator::V8ArrayBufferAllocator()

{

}

//-----------------------------------------------------------------------------

V8ArrayBufferAllocator V8ArrayBufferAllocator::ms_Instance;

//-----------------------------------------------------------------------------

// V8OutputStream

//-----------------------------------------------------------------------------

class V8OutputStream final: public v8::OutputStream

{

PROHIBIT_COPY(V8OutputStream)

public:

explicit V8OutputStream(void* pvStream):

m_pvStream(pvStream)

{

}

virtual int GetChunkSize() override;

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

virtual void EndOfStream() override;

private:

void* m_pvStream;

};

//-----------------------------------------------------------------------------

int V8OutputStream::GetChunkSize()

{

return 64 * 1024;

}

//-----------------------------------------------------------------------------

V8OutputStream::WriteResult V8OutputStream::WriteAsciiChunk(char* pData, int size)

{

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;

}

}

//-----------------------------------------------------------------------------

void V8OutputStream::EndOfStream()

{

}

//-----------------------------------------------------------------------------

// V8IsolateImpl implementation

//-----------------------------------------------------------------------------

#define BEGIN_ISOLATE_NATIVE_SCOPE \

{ \

DISABLE_WARNING(4456) /* declaration hides previous local declaration */ \

NativeScope t_IsolateNativeScope(*this); \

DEFAULT_WARNING(4456)

#define END_ISOLATE_NATIVE_SCOPE \

IGNORE_UNUSED(t_IsolateNativeScope); \

}

#define BEGIN_ISOLATE_SCOPE \

{ \

DISABLE_WARNING(4456) /* declaration hides previous local declaration */ \

Scope t_IsolateScope(*this); \

DEFAULT_WARNING(4456)

#define END_ISOLATE_SCOPE \

IGNORE_UNUSED(t_IsolateScope); \

}

//-----------------------------------------------------------------------------

static std::atomic<size_t> s_InstanceCount(0);

static const int s_ContextGroupId = 1;

static const size_t s_StackBreathingRoom = static_cast<size_t>(16 * 1024);

static size_t* const s_pMinStackLimit = reinterpret_cast<size_t*>(sizeof(size_t));

//-----------------------------------------------------------------------------

V8IsolateImpl::V8IsolateImpl(const StdString& name, const v8::ResourceConstraints* pConstraints, const Options& options):

m_Name(name),

m_CallWithLockLevel(0),

m_DebuggingEnabled(false),

m_AwaitingDebugger(false),

m_InMessageLoop(false),

m_QuitMessageLoop(false),

m_AbortMessageLoop(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_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;

}

//-----------------------------------------------------------------------------

V8IsolateImpl* V8IsolateImpl::GetInstanceFromIsolate(v8::Isolate* pIsolate)

{

_ASSERTE(pIsolate);

return static_cast<V8IsolateImpl*>(pIsolate->GetData(0));

}

//-----------------------------------------------------------------------------

size_t V8IsolateImpl::GetInstanceCount()

{

return s_InstanceCount;

}

//-----------------------------------------------------------------------------

void V8IsolateImpl::AddContext(V8ContextImpl* pContextImpl, const V8Context::Options& options)

{

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

}

}

//-----------------------------------------------------------------------------

void V8IsolateImpl::RemoveContext(V8ContextImpl* pContextImpl)

{

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

if (m_upInspector)

{

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

}

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

{

return contextEntry.pContextImpl == pContextImpl;

});

}

//-----------------------------------------------------------------------------

V8ContextImpl* V8IsolateImpl::FindContext(v8::Local<v8::Context> hContext)

{

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

for (const auto& entry : m_ContextEntries)

{

if (entry.pContextImpl->GetContext() == hContext)

{

return entry.pContextImpl;

}

}

return nullptr;

}

//-----------------------------------------------------------------------------

void V8IsolateImpl::EnableDebugging(int port, bool remote)

{

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

}

}

//-----------------------------------------------------------------------------

void V8IsolateImpl::DisableDebugging()

{

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

if (m_DebuggingEnabled)

{

m_upInspectorSession.reset();

m_upInspector.reset();

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

m_DebuggingEnabled = false;

}

}

//-----------------------------------------------------------------------------

size_t V8IsolateImpl::GetMaxHeapSize()

{

return m_MaxHeapSize;

}

//-----------------------------------------------------------------------------

void V8IsolateImpl::SetMaxHeapSize(size_t value)

{

m_MaxHeapSize = value;

m_IsOutOfMemory = false;

}

//-----------------------------------------------------------------------------

double V8IsolateImpl::GetHeapSizeSampleInterval()

{

return m_HeapSizeSampleInterval;

}

//-----------------------------------------------------------------------------

void V8IsolateImpl::SetHeapSizeSampleInterval(double value)

{

m_HeapSizeSampleInterval = value;

}

//-----------------------------------------------------------------------------

size_t V8IsolateImpl::GetMaxStackUsage()

{

return m_MaxStackUsage;

}

//-----------------------------------------------------------------------------

void V8IsolateImpl::SetMaxStackUsage(size_t value)

{

m_MaxStackUsage = value;

}

//-----------------------------------------------------------------------------

void V8IsolateImpl::AwaitDebuggerAndPause()

{

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

}

//-----------------------------------------------------------------------------

V8ScriptHolder* V8IsolateImpl::Compile(const V8DocumentInfo& documentInfo, StdString&& code)

{

BEGIN_ISOLATE_SCOPE

SharedPtr<V8ContextImpl> spContextImpl((m_ContextEntries.size() > 0) ? m_ContextEntries.front().pContextImpl : new V8ContextImpl(this, m_Name));

return spContextImpl->Compile(documentInfo, std::move(code));

END_ISOLATE_SCOPE

}

//-----------------------------------------------------------------------------

V8ScriptHolder* V8IsolateImpl::Compile(const V8DocumentInfo& documentInfo, StdString&& code, V8CacheType cacheType, std::vector<uint8_t>& cacheBytes)

{

BEGIN_ISOLATE_SCOPE

SharedPtr<V8ContextImpl> spContextImpl((m_ContextEntries.size() > 0) ? m_ContextEntries.front().pContextImpl : new V8ContextImpl(this, m_Name));

return spContextImpl->Compile(documentInfo, std::move(code), cacheType, cacheBytes);

END_ISOLATE_SCOPE

}

//-----------------------------------------------------------------------------

V8ScriptHolder* V8IsolateImpl::Compile(const V8DocumentInfo& documentInfo, StdString&& code, V8CacheType cacheType, const std::vector<uint8_t>& cacheBytes, bool& cacheAccepted)

{

BEGIN_ISOLATE_SCOPE

SharedPtr<V8ContextImpl> spContextImpl((m_ContextEntries.size() > 0) ? m_ContextEntries.front().pContextImpl : new V8ContextImpl(this, m_Name));

return spContextImpl->Compile(documentInfo, std::move(code), cacheType, cacheBytes, cacheAccepted);

END_ISOLATE_SCOPE

}

//-----------------------------------------------------------------------------

void V8IsolateImpl::GetHeapStatistics(v8::HeapStatistics& heapStatistics)

{

BEGIN_ISOLATE_SCOPE

m_upIsolate->GetHeapStatistics(&heapStatistics);

END_ISOLATE_SCOPE

}

//-----------------------------------------------------------------------------

V8Isolate::Statistics V8IsolateImpl::GetStatistics()

{

BEGIN_ISOLATE_SCOPE

BEGIN_MUTEX_SCOPE(m_DataMutex)

return m_Statistics;

END_MUTEX_SCOPE

END_ISOLATE_SCOPE

}

//-----------------------------------------------------------------------------

void V8IsolateImpl::CollectGarbage(bool exhaustive)

{

BEGIN_ISOLATE_SCOPE

if (exhaustive)

{

ClearScriptCache();

LowMemoryNotification();

}

else

{

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

}

END_ISOLATE_SCOPE

}

//-----------------------------------------------------------------------------

bool V8IsolateImpl::BeginCpuProfile(const StdString& name, v8::CpuProfilingMode mode, bool recordSamples)

{

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

}

//-----------------------------------------------------------------------------

bool V8IsolateImpl::EndCpuProfile(const StdString& name, CpuProfileCallback* pCallback, void* pvArg)

{

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

}

//-----------------------------------------------------------------------------

void V8IsolateImpl::CollectCpuProfileSample()

{

BEGIN_ISOLATE_SCOPE

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

END_ISOLATE_SCOPE

}

//-----------------------------------------------------------------------------

uint32_t V8IsolateImpl::GetCpuProfileSampleInterval()

{

return m_CpuProfileSampleInterval;

}

//-----------------------------------------------------------------------------

void V8IsolateImpl::SetCpuProfileSampleInterval(uint32_t value)

{

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

}

//-----------------------------------------------------------------------------

void V8IsolateImpl::WriteHeapSnapshot(void* pvStream)

{

BEGIN_ISOLATE_SCOPE

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

V8OutputStream stream(pvStream);

pSnapshot->Serialize(&stream);

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

END_ISOLATE_SCOPE

}

//-----------------------------------------------------------------------------

void V8IsolateImpl::runMessageLoopOnPause(int /*contextGroupId*/)

{

RunMessageLoop(false);

}

//-----------------------------------------------------------------------------

void V8IsolateImpl::quitMessageLoopOnPause()

{

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

BEGIN_MUTEX_SCOPE(m_DataMutex)

m_QuitMessageLoop = true;

END_MUTEX_SCOPE

}

//-----------------------------------------------------------------------------

void V8IsolateImpl::runIfWaitingForDebugger(int /*contextGroupId*/)

{

quitMessageLoopOnPause();

}

//-----------------------------------------------------------------------------

v8::Local<v8::Context> V8IsolateImpl::ensureDefaultContextInGroup(int contextGroupId)

{

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

if (m_ContextEntries.size() > 0)

{

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

}

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

}

//-----------------------------------------------------------------------------

double V8IsolateImpl::currentTimeMS()

{

return HighResolutionClock::GetRelativeSeconds() * 1000;

}

//-----------------------------------------------------------------------------

void V8IsolateImpl::sendResponse(int /*callId*/, std::unique_ptr<v8_inspector::StringBuffer> upMessage)

{

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

if (m_pvDebugAgent)

{

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

}

}

//-----------------------------------------------------------------------------

void V8IsolateImpl::sendNotification(std::unique_ptr<v8_inspector::StringBuffer> upMessage)

{

sendResponse(0, std::move(upMessage));

}

//-----------------------------------------------------------------------------

void V8IsolateImpl::flushProtocolNotifications()

{

}

//-----------------------------------------------------------------------------

void* V8IsolateImpl::AddRefV8Object(void* pvObject)

{

BEGIN_ISOLATE_SCOPE

return ::PtrFromHandle(CreatePersistent(::HandleFromPtr<v8::Object>(pvObject)));

END_ISOLATE_SCOPE

}

//-----------------------------------------------------------------------------

void V8IsolateImpl::ReleaseV8Object(void* pvObject)

{

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

{

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

});

}

//-----------------------------------------------------------------------------

void* V8IsolateImpl::AddRefV8Script(void* pvScript)

{

BEGIN_ISOLATE_SCOPE

return ::PtrFromHandle(CreatePersistent(::HandleFromPtr<v8::UnboundScript>(pvScript)));

END_ISOLATE_SCOPE

}

//-----------------------------------------------------------------------------

void V8IsolateImpl::ReleaseV8Script(void* pvScript)

{

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

{

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

});

}

//-----------------------------------------------------------------------------

void V8IsolateImpl::RunTaskAsync(std::unique_ptr<v8::Task> upTask)

{

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)