#include "ClearScriptV8Native.h"

class FromMaybeScope final

{

};

class FromMaybeFailure final

{

};

template <typename T>

inline T FromMaybe(FromMaybeScope& /*scope*/, const v8::Maybe<T>& maybe)

}

template <typename T>

inline v8::Local<T> FromMaybe(FromMaybeScope& /*scope*/, const v8::MaybeLocal<T>& maybe)

}

template <typename T>

inline T FromMaybeDefault(const v8::Maybe<T>& maybe, const T& defaultValue = T())

{

return maybe.FromMaybe(defaultValue);

}

template <typename T>

inline v8::Local<T> FromMaybeDefault(const v8::MaybeLocal<T>& maybe, const v8::Local<T>& defaultValue = v8::Local<T>())

{

return maybe.FromMaybe(defaultValue);

}

inline v8::Local<v8::String> ValueAsString(const v8::Local<v8::Value>& hValue)

{

return (!hValue.IsEmpty() && hValue->IsString()) ? hValue.As<v8::String>() : v8::Local<v8::String>();

}

inline v8::Local<v8::Object> ValueAsObject(const v8::Local<v8::Value>& hValue)

{

return (!hValue.IsEmpty() && hValue->IsObject()) ? hValue.As<v8::Object>() : v8::Local<v8::Object>();

}

inline v8::Local<v8::External> ValueAsExternal(const v8::Local<v8::Value>& hValue)

{

return (!hValue.IsEmpty() && hValue->IsExternal()) ? hValue.As<v8::External>() : v8::Local<v8::External>();

}

inline v8::Local<v8::BigInt> ValueAsBigInt(const v8::Local<v8::Value>& hValue)

{

return (!hValue.IsEmpty() && hValue->IsBigInt()) ? hValue.As<v8::BigInt>() : v8::Local<v8::BigInt>();

}

template <typename TInfo>

static V8ContextImpl* GetContextImplFromHolder(const TInfo& info)

{

auto hHolder = info.Holder();

if (!hHolder.IsEmpty() && hHolder->InternalFieldCount() > 0)

{

auto hField = hHolder->GetInternalField(0);

if (!hField.IsEmpty() && !hField->IsUndefined())

{

return static_cast<V8ContextImpl*>(hHolder->GetAlignedPointerFromInternalField(0));

}

}

return nullptr;

}

template <typename TInfo>

static V8ContextImpl* GetContextImplFromData(const TInfo& info)

{

auto hContextImpl = ::ValueAsExternal(info.Data());

return !hContextImpl.IsEmpty() ? static_cast<V8ContextImpl*>(hContextImpl->Value()) : nullptr;

}

#define BEGIN_ISOLATE_SCOPE \

{ \

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

V8IsolateImpl::Scope t_IsolateScope(*m_spIsolateImpl); \

DEFAULT_WARNING(4456)

#define END_ISOLATE_SCOPE \

IGNORE_UNUSED(t_IsolateScope); \

}

#define FROM_MAYBE_TRY \

{ \

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

FromMaybeScope t_FromMaybeScope; \

DEFAULT_WARNING(4456) \

try \

{

#define FROM_MAYBE_CATCH \

IGNORE_UNUSED(t_FromMaybeScope); \

} \

catch (const FromMaybeFailure&) \

{ \

#define FROM_MAYBE_END \

IGNORE_UNUSED(t_FromMaybeScope); \

} \

}

#define FROM_MAYBE_CATCH_CONSUME \

FROM_MAYBE_CATCH \

FROM_MAYBE_END

#define FROM_MAYBE(...) \

(::FromMaybe(t_FromMaybeScope, __VA_ARGS__))

#define FROM_MAYBE_DEFAULT(...) \

(::FromMaybeDefault(__VA_ARGS__))

#define BEGIN_CONTEXT_SCOPE \

{ \

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

Scope t_ContextScope(this); \

DEFAULT_WARNING(4456)

#define END_CONTEXT_SCOPE \

IGNORE_UNUSED(t_ContextScope); \

}

#define BEGIN_EXECUTION_SCOPE \

{ \

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

V8IsolateImpl::ExecutionScope t_ExecutionScope(*m_spIsolateImpl); \

V8IsolateImpl::TryCatch t_TryCatch(*m_spIsolateImpl); \

DEFAULT_WARNING(4456)

#define END_EXECUTION_SCOPE \

IGNORE_UNUSED(t_TryCatch); \

IGNORE_UNUSED(t_ExecutionScope); \

}

#define EXECUTION_STARTED \

(t_ExecutionScope.ExecutionStarted())

#define BEGIN_DOCUMENT_SCOPE(DOCUMENT_INFO) \

{ \

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

V8IsolateImpl::DocumentScope t_DocumentScope(*m_spIsolateImpl, DOCUMENT_INFO); \

DEFAULT_WARNING(4456)

#define END_DOCUMENT_SCOPE \

IGNORE_UNUSED(t_DocumentScope); \

}

#define VERIFY(RESULT) \

(Verify(t_ExecutionScope, t_TryCatch, RESULT))

#define VERIFY_MAYBE(RESULT) \

VERIFY(FROM_MAYBE_DEFAULT(RESULT))

#define VERIFY_CHECKPOINT() \

(Verify(t_ExecutionScope, t_TryCatch))

#define CALLBACK_RETURN(RESULT) \

BEGIN_COMPOUND_MACRO \

info.GetReturnValue().Set(RESULT); \

return; \

END_COMPOUND_MACRO

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

V8ContextImpl::V8ContextImpl(V8IsolateImpl* pIsolateImpl, const StdString& name):

V8ContextImpl(SharedPtr<V8IsolateImpl>(pIsolateImpl), name, Options())

{

}

V8ContextImpl::V8ContextImpl(SharedPtr<V8IsolateImpl>&& spIsolateImpl, const StdString& name, const Options& options):

}

auto hContextImpl = CreateExternal(this);

v8::Local<v8::FunctionTemplate> hGetIteratorFunction;

v8::Local<v8::FunctionTemplate> hGetAsyncIteratorFunction;

v8::Local<v8::FunctionTemplate> hToFunctionFunction;

BEGIN_CONTEXT_SCOPE

m_hIsHostObjectKey = CreatePersistent(CreateSymbol());

FROM_MAYBE(m_hContext->Global()->Set(m_hContext, FROM_MAYBE(CreateString(StdString(SL("isHostObjectKey")))), m_hIsHostObjectKey));

m_hHostExceptionKey = CreatePersistent(FROM_MAYBE(CreateString(StdString(SL("hostException")))));

m_hCacheKey = CreatePersistent(CreatePrivate());

m_hAccessTokenKey = CreatePersistent(CreatePrivate());

m_hInternalUseOnly = CreatePersistent(FROM_MAYBE(CreateString(StdString(SL("The invoked function is for ClearScript internal use only")))));

m_hStackKey = CreatePersistent(FROM_MAYBE(CreateString(StdString(SL("stack")))));

m_hObjectNotInvocable = CreatePersistent(FROM_MAYBE(CreateString(StdString(SL("The object does not support invocation")))));

m_hMethodOrPropertyNotFound = CreatePersistent(FROM_MAYBE(CreateString(StdString(SL("Method or property not found")))));

m_hPropertyValueNotInvocable = CreatePersistent(FROM_MAYBE(CreateString(StdString(SL("Property value does not support invocation")))));

m_hInvalidModuleRequest = CreatePersistent(FROM_MAYBE(CreateString(StdString(SL("Invalid module load request")))));

hGetIteratorFunction = CreateFunctionTemplate(GetHostObjectIterator, hContextImpl);

hGetAsyncIteratorFunction = CreateFunctionTemplate(GetHostObjectAsyncIterator, hContextImpl);

hToFunctionFunction = CreateFunctionTemplate(CreateFunctionForHostDelegate, hContextImpl);

m_hAccessToken = CreatePersistent(CreateObject());

m_hFlushFunction = CreatePersistent(FROM_MAYBE(v8::Function::New(m_hContext, FlushCallback)));

m_hTerminationException = CreatePersistent(v8::Exception::Error(FROM_MAYBE(CreateString(StdString(SL("Script execution was interrupted"))))));

END_CONTEXT_SCOPE

m_hHostObjectTemplate = CreatePersistent(CreateFunctionTemplate());

m_hHostObjectTemplate->SetClassName(FROM_MAYBE(CreateString(StdString(SL("HostObject")))));

m_hHostObjectTemplate->SetCallHandler(HostObjectConstructorCallHandler, hContextImpl);

m_hHostObjectTemplate->InstanceTemplate()->SetHandler(v8::NamedPropertyHandlerConfiguration(GetHostObjectProperty, SetHostObjectProperty, QueryHostObjectProperty, DeleteHostObjectProperty, GetHostObjectPropertyNames, hContextImpl, v8::PropertyHandlerFlags::kNone));

m_hHostObjectTemplate->InstanceTemplate()->SetHandler(v8::IndexedPropertyHandlerConfiguration(GetHostObjectProperty, SetHostObjectProperty, QueryHostObjectProperty, DeleteHostObjectProperty, GetHostObjectPropertyIndices, hContextImpl));

m_hHostObjectTemplate->PrototypeTemplate()->Set(GetIteratorSymbol(), hGetIteratorFunction);

m_hHostObjectTemplate->PrototypeTemplate()->Set(GetAsyncIteratorSymbol(), hGetAsyncIteratorFunction);

m_hHostInvocableTemplate = CreatePersistent(CreateFunctionTemplate());

m_hHostInvocableTemplate->SetClassName(FROM_MAYBE(CreateString(StdString(SL("HostInvocable")))));

m_hHostInvocableTemplate->SetCallHandler(HostObjectConstructorCallHandler, hContextImpl);

m_hHostInvocableTemplate->InstanceTemplate()->SetHandler(v8::NamedPropertyHandlerConfiguration(GetHostObjectProperty, SetHostObjectProperty, QueryHostObjectProperty, DeleteHostObjectProperty, GetHostObjectPropertyNames, hContextImpl, v8::PropertyHandlerFlags::kNone));

m_hHostInvocableTemplate->InstanceTemplate()->SetHandler(v8::IndexedPropertyHandlerConfiguration(GetHostObjectProperty, SetHostObjectProperty, QueryHostObjectProperty, DeleteHostObjectProperty, GetHostObjectPropertyIndices, hContextImpl));

m_hHostInvocableTemplate->PrototypeTemplate()->Set(GetIteratorSymbol(), hGetIteratorFunction);

m_hHostInvocableTemplate->PrototypeTemplate()->Set(GetAsyncIteratorSymbol(), hGetAsyncIteratorFunction);

m_hHostInvocableTemplate->InstanceTemplate()->SetCallAsFunctionHandler(InvokeHostObject, hContextImpl);

m_hHostDelegateTemplate = CreatePersistent(CreateFunctionTemplate());

m_hHostDelegateTemplate->SetClassName(FROM_MAYBE(CreateString(StdString(SL("HostDelegate")))));

m_hHostDelegateTemplate->SetCallHandler(HostObjectConstructorCallHandler, hContextImpl);

m_hHostDelegateTemplate->InstanceTemplate()->SetHandler(v8::NamedPropertyHandlerConfiguration(GetHostObjectProperty, SetHostObjectProperty, QueryHostObjectProperty, DeleteHostObjectProperty, GetHostObjectPropertyNames, hContextImpl, v8::PropertyHandlerFlags::kNone));

m_hHostDelegateTemplate->InstanceTemplate()->SetHandler(v8::IndexedPropertyHandlerConfiguration(GetHostObjectProperty, SetHostObjectProperty, QueryHostObjectProperty, DeleteHostObjectProperty, GetHostObjectPropertyIndices, hContextImpl));

m_hHostDelegateTemplate->PrototypeTemplate()->Set(GetIteratorSymbol(), hGetIteratorFunction);

m_hHostDelegateTemplate->PrototypeTemplate()->Set(GetAsyncIteratorSymbol(), hGetAsyncIteratorFunction);

m_hHostDelegateTemplate->InstanceTemplate()->SetCallAsFunctionHandler(InvokeHostObject, hContextImpl);

m_hHostDelegateTemplate->InstanceTemplate()->SetHostDelegate(); // instructs our patched V8 typeof implementation to return "function"

m_hHostDelegateTemplate->PrototypeTemplate()->Set(FROM_MAYBE(CreateString(StdString(SL("toFunction")))), hToFunctionFunction);

m_pvV8ObjectCache = HostObjectUtil::GetInstance().CreateV8ObjectCache();

m_spIsolateImpl->AddContext(this, options);

FROM_MAYBE_CATCH

Teardown();

throw V8Exception(V8Exception::Type::General, m_Name, StdString(SL("The V8 runtime cannot initialize the script engine because a script exception is pending")), false /*executionStarted*/);

FROM_MAYBE_END

END_ISOLATE_SCOPE

++s_InstanceCount;

}

size_t V8ContextImpl::GetInstanceCount()

{

return s_InstanceCount;

}

size_t V8ContextImpl::GetMaxIsolateHeapSize()

{

return m_spIsolateImpl->GetMaxHeapSize();

}

void V8ContextImpl::SetMaxIsolateHeapSize(size_t value)

{

m_spIsolateImpl->SetMaxHeapSize(value);

}

double V8ContextImpl::GetIsolateHeapSizeSampleInterval()

{

return m_spIsolateImpl->GetHeapSizeSampleInterval();

}

void V8ContextImpl::SetIsolateHeapSizeSampleInterval(double value)

{

m_spIsolateImpl->SetHeapSizeSampleInterval(value);

}

size_t V8ContextImpl::GetMaxIsolateStackUsage()

{

return m_spIsolateImpl->GetMaxStackUsage();

}

void V8ContextImpl::SetMaxIsolateStackUsage(size_t value)

{

m_spIsolateImpl->SetMaxStackUsage(value);

}

void V8ContextImpl::CallWithLock(CallWithLockCallback* pCallback, void* pvArg)

}

V8Value V8ContextImpl::GetRootObject()

}

void V8ContextImpl::SetGlobalProperty(const StdString& name, const V8Value& value, bool globalMembers)

}

void V8ContextImpl::AwaitDebuggerAndPause()

{

m_spIsolateImpl->AwaitDebuggerAndPause();

}

void V8ContextImpl::CancelAwaitDebugger()

{

m_spIsolateImpl->CancelAwaitDebugger();

}

V8Value V8ContextImpl::Execute(const V8DocumentInfo& documentInfo, const StdString& code, bool evaluate)

}

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

{

BEGIN_CONTEXT_SCOPE

BEGIN_DOCUMENT_SCOPE(documentInfo)

BEGIN_EXECUTION_SCOPE

FROM_MAYBE_TRY

auto codeDigest = code.GetDigest();

v8::ScriptCompiler::Source source(FROM_MAYBE(CreateString(code)), CreateScriptOrigin(documentInfo));

std::unique_ptr<V8ScriptHolder> upScriptHolder;

if (documentInfo.IsModule())

{

auto hModule = GetCachedModule(documentInfo.GetUniqueId(), codeDigest);

if (hModule.IsEmpty())

{

hModule = VERIFY_MAYBE(CompileModule(&source));

if (hModule.IsEmpty())

{

throw V8Exception(V8Exception::Type::General, m_Name, StdString(SL("Module compilation failed; no additional information was provided by the V8 runtime")), false /*executionStarted*/);

}

CacheModule(documentInfo, codeDigest, hModule);

}

upScriptHolder.reset(new V8ScriptHolderImpl(GetWeakBinding(), ::PtrFromHandle(CreatePersistent(hModule)), documentInfo, codeDigest, std::move(code)));

}

else

{

auto hScript = GetCachedScript(documentInfo.GetUniqueId(), codeDigest);

if (hScript.IsEmpty())

{

hScript = VERIFY_MAYBE(CompileUnboundScript(&source));

if (hScript.IsEmpty())

{

throw V8Exception(V8Exception::Type::General, m_Name, StdString(SL("Script compilation failed; no additional information was provided by the V8 runtime")), false /*executionStarted*/);

}

CacheScript(documentInfo, codeDigest, hScript);

}

upScriptHolder.reset(new V8ScriptHolderImpl(GetWeakBinding(), ::PtrFromHandle(CreatePersistent(hScript)), documentInfo, codeDigest));

}

return upScriptHolder.release();

FROM_MAYBE_CATCH

throw V8Exception(V8Exception::Type::General, m_Name, StdString(SL("The V8 runtime cannot perform the requested operation because a script exception is pending")), EXECUTION_STARTED);

FROM_MAYBE_END

END_EXECUTION_SCOPE

END_DOCUMENT_SCOPE

END_CONTEXT_SCOPE

}

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

{

if (cacheType == V8CacheType::None)

{

cacheBytes.clear();

return Compile(documentInfo, std::move(code));

}

BEGIN_CONTEXT_SCOPE

BEGIN_DOCUMENT_SCOPE(documentInfo)

BEGIN_EXECUTION_SCOPE

FROM_MAYBE_TRY

auto codeDigest = code.GetDigest();

v8::ScriptCompiler::Source source(FROM_MAYBE(CreateString(code)), CreateScriptOrigin(documentInfo));

std::unique_ptr<V8ScriptHolder> upScriptHolder;

std::unique_ptr<v8::ScriptCompiler::CachedData> upCachedData;

if (documentInfo.IsModule())

{

auto hModule = GetCachedModule(documentInfo.GetUniqueId(), codeDigest);

if (hModule.IsEmpty())

{

hModule = VERIFY_MAYBE(CompileModule(&source));

if (hModule.IsEmpty())

{

throw V8Exception(V8Exception::Type::General, m_Name, StdString(SL("Module compilation failed; no additional information was provided by the V8 runtime")), false /*executionStarted*/);

}

CacheModule(documentInfo, codeDigest, hModule);

}

upScriptHolder.reset(new V8ScriptHolderImpl(GetWeakBinding(), ::PtrFromHandle(CreatePersistent(hModule)), documentInfo, codeDigest, std::move(code)));

upCachedData.reset(v8::ScriptCompiler::CreateCodeCache(hModule->GetUnboundModuleScript()));

}

else

{

auto hScript = GetCachedScript(documentInfo.GetUniqueId(), codeDigest);

if (hScript.IsEmpty())

{

hScript = VERIFY_MAYBE(CompileUnboundScript(&source));

if (hScript.IsEmpty())

{

throw V8Exception(V8Exception::Type::General, m_Name, StdString(SL("Script compilation failed; no additional information was provided by the V8 runtime")), false /*executionStarted*/);

}

CacheScript(documentInfo, codeDigest, hScript);

}

upScriptHolder.reset(new V8ScriptHolderImpl(GetWeakBinding(), ::PtrFromHandle(CreatePersistent(hScript)), documentInfo, codeDigest));

upCachedData.reset(v8::ScriptCompiler::CreateCodeCache(hScript));

}

cacheBytes.clear();

if (upCachedData && (upCachedData->length > 0) && (upCachedData->data != nullptr))

{

cacheBytes.resize(upCachedData->length);

memcpy(cacheBytes.data(), upCachedData->data, upCachedData->length);

if (documentInfo.IsModule())

{

upScriptHolder->SetCacheBytes(cacheBytes);

}

}

return upScriptHolder.release();

FROM_MAYBE_CATCH

throw V8Exception(V8Exception::Type::General, m_Name, StdString(SL("The V8 runtime cannot perform the requested operation because a script exception is pending")), EXECUTION_STARTED);

FROM_MAYBE_END

END_EXECUTION_SCOPE

END_DOCUMENT_SCOPE

END_CONTEXT_SCOPE

}

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

{

if ((cacheType == V8CacheType::None) || (cacheBytes.size() < 1))

{

cacheAccepted = false;

return Compile(documentInfo, std::move(code));

}

BEGIN_CONTEXT_SCOPE

BEGIN_DOCUMENT_SCOPE(documentInfo)

BEGIN_EXECUTION_SCOPE

FROM_MAYBE_TRY

auto codeDigest = code.GetDigest();

auto pCachedData = new v8::ScriptCompiler::CachedData(cacheBytes.data(), static_cast<int>(cacheBytes.size()), v8::ScriptCompiler::CachedData::BufferNotOwned);

v8::ScriptCompiler::Source source(FROM_MAYBE(CreateString(code)), CreateScriptOrigin(documentInfo), pCachedData);

std::unique_ptr<V8ScriptHolder> upScriptHolder;

if (documentInfo.IsModule())

{

auto hModule = GetCachedModule(documentInfo.GetUniqueId(), codeDigest);

if (hModule.IsEmpty())

{

hModule = VERIFY_MAYBE(CompileModule(&source, v8::ScriptCompiler::kConsumeCodeCache));

if (hModule.IsEmpty())

{

throw V8Exception(V8Exception::Type::General, m_Name, StdString(SL("Module compilation failed; no additional information was provided by the V8 runtime")), false /*executionStarted*/);

}

CacheModule(documentInfo, codeDigest, hModule);

}

upScriptHolder.reset(new V8ScriptHolderImpl(GetWeakBinding(), ::PtrFromHandle(CreatePersistent(hModule)), documentInfo, codeDigest, std::move(code)));

}

else

{

auto hScript = GetCachedScript(documentInfo.GetUniqueId(), codeDigest);

if (hScript.IsEmpty())

{

hScript = VERIFY_MAYBE(CompileUnboundScript(&source, v8::ScriptCompiler::kConsumeCodeCache));

if (hScript.IsEmpty())

{

throw V8Exception(V8Exception::Type::General, m_Name, StdString(SL("Script compilation failed; no additional information was provided by the V8 runtime")), false /*executionStarted*/);

}

CacheScript(documentInfo, codeDigest, hScript);

}

upScriptHolder.reset(new V8ScriptHolderImpl(GetWeakBinding(), ::PtrFromHandle(CreatePersistent(hScript)), documentInfo, codeDigest));

}

cacheAccepted = !pCachedData->rejected;

if (cacheAccepted && documentInfo.IsModule())

{

upScriptHolder->SetCacheBytes(cacheBytes);

}

return upScriptHolder.release();

FROM_MAYBE_CATCH

throw V8Exception(V8Exception::Type::General, m_Name, StdString(SL("The V8 runtime cannot perform the requested operation because a script exception is pending")), EXECUTION_STARTED);

FROM_MAYBE_END

END_EXECUTION_SCOPE

END_DOCUMENT_SCOPE

END_CONTEXT_SCOPE

}

bool V8ContextImpl::CanExecute(const SharedPtr<V8ScriptHolder>& spHolder)

{

return spHolder->IsSameIsolate(m_spIsolateImpl);

}

V8Value V8ContextImpl::Execute(const SharedPtr<V8ScriptHolder>& spHolder, bool evaluate)

}

void V8ContextImpl::Interrupt()

{

TerminateExecution();

}

void V8ContextImpl::CancelInterrupt()

{

CancelTerminateExecution();

}

bool V8ContextImpl::GetEnableIsolateInterruptPropagation()

{

return m_spIsolateImpl->GetEnableInterruptPropagation();

}

void V8ContextImpl::SetEnableIsolateInterruptPropagation(bool value)

{

m_spIsolateImpl->SetEnableInterruptPropagation(value);

}

void V8ContextImpl::GetIsolateHeapStatistics(v8::HeapStatistics& heapStatistics)

{

m_spIsolateImpl->GetHeapStatistics(heapStatistics);

}

V8Isolate::Statistics V8ContextImpl::GetIsolateStatistics()

{

return m_spIsolateImpl->GetStatistics();

}

V8ContextImpl::Statistics V8ContextImpl::GetStatistics()

}

void V8ContextImpl::CollectGarbage(bool exhaustive)

{

m_spIsolateImpl->CollectGarbage(exhaustive);

}

void V8ContextImpl::OnAccessSettingsChanged()

}

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

{

return m_spIsolateImpl->BeginCpuProfile(name, mode, recordSamples);

}

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

{

return m_spIsolateImpl->EndCpuProfile(name, pCallback, pvArg);

}

void V8ContextImpl::CollectCpuProfileSample()

{

return m_spIsolateImpl->CollectCpuProfileSample();

}

uint32_t V8ContextImpl::GetCpuProfileSampleInterval()

{

return m_spIsolateImpl->GetCpuProfileSampleInterval();

}

void V8ContextImpl::SetCpuProfileSampleInterval(uint32_t value)

{

m_spIsolateImpl->SetCpuProfileSampleInterval(value);

}

void V8ContextImpl::WriteIsolateHeapSnapshot(void* pvStream)

{

m_spIsolateImpl->WriteHeapSnapshot(pvStream);

}

void V8ContextImpl::Flush()

}

void V8ContextImpl::Destroy()

}

V8Value V8ContextImpl::GetV8ObjectProperty(void* pvObject, const StdString& name)

}

void V8ContextImpl::SetV8ObjectProperty(void* pvObject, const StdString& name, const V8Value& value)