void WindowProxy::setSecurityToken(SecurityOrigin* origin) {
// If two tokens are equal, then the SecurityOrigins canAccess each other.
// If two tokens are not equal, then we have to call canAccess.
// Note: we can't use the HTTPOrigin if it was set from the DOM.
String token;
// There are two situations where v8 needs to do a full canAccess check,
// so set an empty security token instead:
// - document.domain was modified
// - the frame is remote
bool delaySet = m_frame->isRemoteFrame() ||
(m_world->isMainWorld() && origin->domainWasSetInDOM());
if (origin && !delaySet)
token = origin->toString();
// An empty or "null" token means we always have to call
// canAccess. The toString method on securityOrigins returns the
// string "null" for empty security origins and for security
// origins that should only allow access to themselves. In this
// case, we use the global object as the security token to avoid
// calling canAccess when a script accesses its own objects.
v8::HandleScope handleScope(m_isolate);
v8::Local<v8::Context> context = m_scriptState->context();
if (token.isEmpty() || token == "null") {
context->UseDefaultSecurityToken();
return;
}
if (m_world->isPrivateScriptIsolatedWorld()) {
token = "private-script://" + token;
} else if (m_world->isIsolatedWorld()) {
SecurityOrigin* frameSecurityOrigin =
m_frame->securityContext()->getSecurityOrigin();
String frameSecurityToken = frameSecurityOrigin->toString();
// We need to check the return value of domainWasSetInDOM() on the
// frame's SecurityOrigin because, if that's the case, only
// SecurityOrigin::m_domain would have been modified.
// m_domain is not used by SecurityOrigin::toString(), so we would end
// up generating the same token that was already set.
if (frameSecurityOrigin->domainWasSetInDOM() ||
frameSecurityToken.isEmpty() || frameSecurityToken == "null") {
context->UseDefaultSecurityToken();
return;
}
token = frameSecurityToken + token;
}
// NOTE: V8 does identity comparison in fast path, must use a symbol
// as the security token.
context->SetSecurityToken(v8AtomicString(m_isolate, token));
}
v8::Handle<v8::FunctionTemplate> V8TestInterfaceEmpty::domTemplate(v8::Isolate* isolate, WrapperWorldType currentWorldType)
{
V8PerIsolateData* data = V8PerIsolateData::from(isolate);
V8PerIsolateData::TemplateMap::iterator result = data->templateMap(currentWorldType).find(&wrapperTypeInfo);
if (result != data->templateMap(currentWorldType).end())
return result->value.newLocal(isolate);
TRACE_EVENT_SCOPED_SAMPLING_STATE("Blink", "BuildDOMTemplate");
v8::EscapableHandleScope handleScope(isolate);
v8::Local<v8::FunctionTemplate> templ = v8::FunctionTemplate::New(isolate, V8ObjectConstructor::isValidConstructorMode);
configureV8TestInterfaceEmptyTemplate(templ, isolate, currentWorldType);
data->templateMap(currentWorldType).add(&wrapperTypeInfo, UnsafePersistent<v8::FunctionTemplate>(isolate, templ));
return handleScope.Escape(templ);
}
bool WindowProxy::initialize()
{
TRACE_EVENT0("v8", "WindowProxy::initialize");
TRACE_EVENT_SCOPED_SAMPLING_STATE("blink", "InitializeWindow");
ScriptForbiddenScope::AllowUserAgentScript allowScript;
v8::HandleScope handleScope(m_isolate);
createContext();
if (!isContextInitialized())
return false;
ScriptState::Scope scope(m_scriptState.get());
v8::Local<v8::Context> context = m_scriptState->context();
if (m_global.isEmpty()) {
m_global.set(m_isolate, context->Global());
if (m_global.isEmpty()) {
disposeContext(DoNotDetachGlobal);
return false;
}
}
if (!setupWindowPrototypeChain()) {
disposeContext(DoNotDetachGlobal);
return false;
}
SecurityOrigin* origin = 0;
if (m_world->isMainWorld()) {
// ActivityLogger for main world is updated within updateDocument().
updateDocument();
origin = m_frame->securityContext()->getSecurityOrigin();
// FIXME: Can this be removed when CSP moves to browser?
ContentSecurityPolicy* csp = m_frame->securityContext()->contentSecurityPolicy();
context->AllowCodeGenerationFromStrings(csp->allowEval(0, ContentSecurityPolicy::SuppressReport));
context->SetErrorMessageForCodeGenerationFromStrings(v8String(m_isolate, csp->evalDisabledErrorMessage()));
} else {
updateActivityLogger();
origin = m_world->isolatedWorldSecurityOrigin();
setSecurityToken(origin);
}
if (m_frame->isLocalFrame()) {
LocalFrame* frame = toLocalFrame(m_frame);
MainThreadDebugger::instance()->contextCreated(m_scriptState.get(), frame, origin);
frame->loader().client()->didCreateScriptContext(context, m_world->extensionGroup(), m_world->worldId());
}
return true;
}
// The callback that is invoked by v8 whenever the JavaScript 'print'
// function is called. Prints its arguments on stdout separated by
// spaces and ending with a newline.
//
// JS: print("foo", "bar");
void Global::Print(const v8::FunctionCallbackInfo<v8::Value>& args) {
bool first = true;
HandleScope handleScope(args.GetIsolate());
for (int i = 0; i < args.Length(); i++) {
if (first) {
first = false;
} else {
printf(" ");
}
v8::String::Utf8Value str(args[i]);
printf("%s", to_cstring(str));
}
printf("\n");
fflush(stdout);
}
static PassRefPtr<IDBKey> createIDBKeyFromScriptValueAndKeyPath(const ScriptValue& value, const String& keyPath, v8::Isolate* isolate)
{
Vector<String> keyPathElements;
IDBKeyPathParseError error;
IDBParseKeyPath(keyPath, keyPathElements, error);
ASSERT(error == IDBKeyPathParseErrorNone);
ASSERT(isolate->InContext());
v8::HandleScope handleScope(isolate);
v8::Handle<v8::Value> v8Value(value.v8Value());
v8::Handle<v8::Value> v8Key(getNthValueOnKeyPath(v8Value, keyPathElements, keyPathElements.size(), isolate));
if (v8Key.IsEmpty())
return 0;
return createIDBKeyFromValue(v8Key, isolate);
}
void V8WindowShell::namedItemAdded(HTMLDocument* document, const AtomicString& name)
{
ASSERT(m_world->isMainWorld());
if (!m_contextHolder)
return;
v8::HandleScope handleScope(m_isolate);
v8::Context::Scope contextScope(m_contextHolder->context());
ASSERT(!m_document.isEmpty());
v8::Handle<v8::Object> documentHandle = m_document.newLocal(m_isolate);
checkDocumentWrapper(documentHandle, document);
documentHandle->SetAccessor(v8String(m_isolate, name), getter);
}
PassRefPtr<SharedPersistent<v8::Object>> ScriptController::createPluginWrapper(Widget* widget)
{
ASSERT(widget);
if (!widget->isPluginView())
return nullptr;
v8::HandleScope handleScope(isolate());
v8::Local<v8::Object> scriptableObject = toPluginView(widget)->scriptableObject(isolate());
if (scriptableObject.IsEmpty())
return nullptr;
return SharedPersistent<v8::Object>::create(scriptableObject, isolate());
}
v8::Handle<v8::ObjectTemplate> ConsoleWrapper::objectTemplate(v8::Isolate* pIsolate)
{
v8::EscapableHandleScope handleScope(pIsolate);
v8::Local<v8::ObjectTemplate> loggerTemplate = v8::ObjectTemplate::New();
loggerTemplate->SetInternalFieldCount(1);
loggerTemplate->Set(v8::String::NewFromUtf8(pIsolate, "trace"), v8::FunctionTemplate::New(pIsolate, trace));
loggerTemplate->Set(v8::String::NewFromUtf8(pIsolate, "assert"), v8::FunctionTemplate::New(pIsolate, assert));
loggerTemplate->Set(v8::String::NewFromUtf8(pIsolate, "log"), v8::FunctionTemplate::New(pIsolate, log));
loggerTemplate->Set(v8::String::NewFromUtf8(pIsolate, "debug"), v8::FunctionTemplate::New(pIsolate, debug));
loggerTemplate->Set(v8::String::NewFromUtf8(pIsolate, "info"), v8::FunctionTemplate::New(pIsolate, info));
loggerTemplate->Set(v8::String::NewFromUtf8(pIsolate, "warn"), v8::FunctionTemplate::New(pIsolate, warn));
loggerTemplate->Set(v8::String::NewFromUtf8(pIsolate, "error"), v8::FunctionTemplate::New(pIsolate, error));
loggerTemplate->Set(v8::String::NewFromUtf8(pIsolate, "dump"), v8::FunctionTemplate::New(pIsolate, dump));
return handleScope.Escape(loggerTemplate);
}
void ScriptPromisePropertyBase::clearWrappers()
{
checkThis();
checkWrappers();
v8::HandleScope handleScope(m_isolate);
for (WeakPersistentSet::iterator i = m_wrappers.begin(); i != m_wrappers.end(); ++i) {
v8::Local<v8::Object> wrapper = (*i)->newLocal(m_isolate);
if (!wrapper.IsEmpty()) {
ScriptState* scriptState = ScriptState::from(wrapper->CreationContext());
V8HiddenValue::deleteHiddenValue(scriptState, wrapper, resolverName());
V8HiddenValue::deleteHiddenValue(scriptState, wrapper, promiseName());
}
}
m_wrappers.clear();
}
v8::Local<v8::ObjectTemplate> BuilderWrapper::GetBuilderTemplate( v8::Isolate* isolate)
{
v8::EscapableHandleScope handleScope( isolate );
v8::Local<v8::ObjectTemplate> objectTemplate;
v8::Local<v8::ObjectTemplate> objTemplate = v8::ObjectTemplate::New();
objTemplate->SetInternalFieldCount( BaseWrappedObject::FIELD_COUNT );
// add our function properties
ObjectTemplateHelper::InstallFunctions( isolate, objTemplate, BuilderFunctionTable, BuilderFunctionTableCount );
return handleScope.Escape( objTemplate );
}
void BuilderWrapper::NewBuilder( const v8::FunctionCallbackInfo< v8::Value >& args)
{
v8::Isolate* isolate = args.GetIsolate();
v8::HandleScope handleScope( isolate);
if( !args.IsConstructCall() )
{
DALI_SCRIPT_EXCEPTION( isolate, "Builder constructor called without 'new'" );
return;
}
Dali::Toolkit::Builder builder = BuilderApi::New( args );
v8::Local<v8::Object> localObject = WrapBuilder( isolate, builder );
args.GetReturnValue().Set( localObject );
}
bool InjectedScriptManager::canAccessInspectedWindow(ScriptState* scriptState)
{
v8::HandleScope handleScope(scriptState->isolate());
v8::Local<v8::Context> context = scriptState->context();
v8::Local<v8::Object> global = context->Global();
if (global.IsEmpty())
return false;
v8::Handle<v8::Object> holder = V8Window::findInstanceInPrototypeChain(global, context->GetIsolate());
if (holder.IsEmpty())
return false;
LocalFrame* frame = V8Window::toNative(holder)->frame();
v8::Context::Scope contextScope(context);
return BindingSecurity::shouldAllowAccessToFrame(scriptState->isolate(), frame, DoNotReportSecurityError);
}
static IDBKey* createIDBKeyFromScriptValueAndKeyPathInternal(v8::Isolate* isolate, const ScriptValue& value, const String& keyPath, bool allowExperimentalTypes)
{
Vector<String> keyPathElements;
IDBKeyPathParseError error;
IDBParseKeyPath(keyPath, keyPathElements, error);
ASSERT(error == IDBKeyPathParseErrorNone);
ASSERT(isolate->InContext());
v8::HandleScope handleScope(isolate);
v8::Handle<v8::Value> v8Value(value.v8Value());
v8::Handle<v8::Value> v8Key(getNthValueOnKeyPath(isolate, v8Value, keyPathElements, keyPathElements.size()));
if (v8Key.IsEmpty())
return 0;
return createIDBKeyFromValue(isolate, v8Key, allowExperimentalTypes);
}
v8::Handle<v8::ObjectTemplate> RenderTaskWrapper::MakeRenderTaskTemplate( v8::Isolate* isolate )
{
v8::EscapableHandleScope handleScope( isolate );
v8::Local<v8::ObjectTemplate> objTemplate = v8::ObjectTemplate::New();
// property handle intercepts property getters and setters and signals
HandleWrapper::AddInterceptsToTemplate( isolate, objTemplate );
objTemplate->SetInternalFieldCount( BaseWrappedObject::FIELD_COUNT );
// add our function properties
ObjectTemplateHelper::InstallFunctions( isolate, objTemplate, RenderTaskFunctionTable, RenderTaskFunctionTableCount );
return handleScope.Escape( objTemplate );
}
void DataConsumerHandleTestUtil::Thread::initialize() {
if (m_initializationPolicy >= ScriptExecution) {
m_isolateHolder = wrapUnique(new gin::IsolateHolder());
isolate()->Enter();
}
m_thread->initialize();
if (m_initializationPolicy >= ScriptExecution) {
v8::HandleScope handleScope(isolate());
m_scriptState = ScriptState::create(v8::Context::New(isolate()),
DOMWrapperWorld::create(isolate()));
}
if (m_initializationPolicy >= WithExecutionContext) {
m_executionContext = new NullExecutionContext();
}
m_waitableEvent->signal();
}
bool V8TestCallbackInterface::booleanMethod()
{
if (!canInvokeCallback())
return true;
v8::HandleScope handleScope(m_isolate);
v8::Handle<v8::Context> v8Context = toV8Context(executionContext(), m_world.get());
if (v8Context.IsEmpty())
return true;
v8::Context::Scope scope(v8Context);
v8::Handle<v8::Value> *argv = 0;
return invokeCallback(m_callback.newLocal(m_isolate), 0, argv, executionContext(), m_isolate);
}
V8DOMActivityLogger* V8DOMActivityLogger::currentActivityLogger() {
v8::Isolate* isolate = v8::Isolate::GetCurrent();
if (!isolate->InContext())
return 0;
v8::HandleScope handleScope(isolate);
v8::Local<v8::Context> context = isolate->GetCurrentContext();
if (context.IsEmpty() || !toDOMWindow(context))
return 0;
V8PerContextData* contextData = ScriptState::from(context)->perContextData();
if (!contextData)
return 0;
return contextData->activityLogger();
}
// Create a V8 object with an interceptor of NPObjectPropertyGetter.
void ScriptController::bindToWindowObject(LocalFrame* frame, const String& key, NPObject* object)
{
v8::HandleScope handleScope(m_isolate);
v8::Handle<v8::Context> v8Context = toV8Context(m_isolate, frame, DOMWrapperWorld::mainWorld());
if (v8Context.IsEmpty())
return;
v8::Context::Scope scope(v8Context);
v8::Handle<v8::Object> value = createV8ObjectForNPObject(object, 0, m_isolate);
// Attach to the global object.
v8::Handle<v8::Object> global = v8Context->Global();
global->Set(v8String(m_isolate, key), value);
}
v8::Handle<v8::ObjectTemplate> ServiceListenerWrapper::objectTemplate(v8::Isolate* pIsolate)
{
v8::EscapableHandleScope handleScope(pIsolate);
Poco::JS::Core::PooledIsolate* pPooledIso = Poco::JS::Core::PooledIsolate::fromIsolate(pIsolate);
poco_check_ptr (pPooledIso);
v8::Persistent<v8::ObjectTemplate>& pooledObjectTemplate(pPooledIso->objectTemplate("OSP.ServiceListener"));
if (pooledObjectTemplate.IsEmpty())
{
v8::Handle<v8::ObjectTemplate> objectTemplate = v8::ObjectTemplate::New(pIsolate);
objectTemplate->SetInternalFieldCount(1);
objectTemplate->Set(v8::String::NewFromUtf8(pIsolate, "dispose"), v8::FunctionTemplate::New(pIsolate, dispose));
pooledObjectTemplate.Reset(pIsolate, objectTemplate);
}
v8::Local<v8::ObjectTemplate> serviceListenerTemplate = v8::Local<v8::ObjectTemplate>::New(pIsolate, pooledObjectTemplate);
return handleScope.Escape(serviceListenerTemplate);
}
int ScriptRegexp::match(const String& string, int startFrom, int* matchLength) const
{
if (matchLength)
*matchLength = 0;
if (m_regex.isEmpty() || string.isNull())
return -1;
// v8 strings are limited to int.
if (string.length() > INT_MAX)
return -1;
ScriptForbiddenScope::AllowUserAgentScript allowScript;
v8::Isolate* isolate = v8::Isolate::GetCurrent();
v8::HandleScope handleScope(isolate);
v8::Context::Scope contextScope(V8PerIsolateData::from(isolate)->ensureScriptRegexpContext());
v8::TryCatch tryCatch;
v8::Local<v8::RegExp> regex = m_regex.newLocal(isolate);
v8::Local<v8::Function> exec = regex->Get(v8AtomicString(isolate, "exec")).As<v8::Function>();
v8::Handle<v8::Value> argv[] = { v8String(isolate, string.substring(startFrom)) };
v8::Local<v8::Value> returnValue = V8ScriptRunner::callInternalFunction(exec, regex, WTF_ARRAY_LENGTH(argv), argv, isolate);
if (tryCatch.HasCaught())
return -1;
// RegExp#exec returns null if there's no match, otherwise it returns an
// Array of strings with the first being the whole match string and others
// being subgroups. The Array also has some random properties tacked on like
// "index" which is the offset of the match.
//
// https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/RegExp/exec
ASSERT(!returnValue.IsEmpty());
if (!returnValue->IsArray())
return -1;
v8::Local<v8::Array> result = returnValue.As<v8::Array>();
int matchOffset = result->Get(v8AtomicString(isolate, "index"))->ToInt32()->Value();
if (matchLength) {
v8::Local<v8::String> match = result->Get(0).As<v8::String>();
*matchLength = match->Length();
}
return matchOffset + startFrom;
}
v8::Handle<v8::ObjectTemplate> HTMLFormWrapper::objectTemplate(v8::Isolate* pIsolate)
{
v8::EscapableHandleScope handleScope(pIsolate);
Poco::JS::Core::PooledIsolate* pPooledIso = Poco::JS::Core::PooledIsolate::fromIsolate(pIsolate);
poco_check_ptr (pPooledIso);
v8::Persistent<v8::ObjectTemplate>& pooledObjectTemplate(pPooledIso->objectTemplate("Net.HTMLForm"));
if (pooledObjectTemplate.IsEmpty())
{
v8::Handle<v8::ObjectTemplate> objectTemplate = v8::ObjectTemplate::New();
objectTemplate->SetInternalFieldCount(1);
objectTemplate->Set(v8::String::NewFromUtf8(pIsolate, "hasField"), v8::FunctionTemplate::New(pIsolate, hasField));
objectTemplate->Set(v8::String::NewFromUtf8(pIsolate, "getField"), v8::FunctionTemplate::New(pIsolate, getField));
pooledObjectTemplate.Reset(pIsolate, objectTemplate);
}
v8::Local<v8::ObjectTemplate> formTemplate = v8::Local<v8::ObjectTemplate>::New(pIsolate, pooledObjectTemplate);
return handleScope.Escape(formTemplate);
}
v8::Local<v8::ObjectTemplate> MaterialWrapper::GetMaterialTemplate( v8::Isolate* isolate)
{
v8::EscapableHandleScope handleScope( isolate );
v8::Local<v8::ObjectTemplate> objectTemplate;
if( mMaterialTemplate.IsEmpty() )
{
objectTemplate = MakeMaterialTemplate( isolate );
mMaterialTemplate.Reset( isolate, objectTemplate );
}
else
{
// get the object template
objectTemplate = v8::Local<v8::ObjectTemplate>::New( isolate, mMaterialTemplate );
}
return handleScope.Escape( objectTemplate );
}
v8::Handle<v8::ObjectTemplate> StageWrapper::MakeStageTemplate( v8::Isolate* isolate )
{
v8::EscapableHandleScope handleScope( isolate );
v8::Local<v8::ObjectTemplate> objTemplate = v8::ObjectTemplate::New();
// add intercepts for Signals, we can't use HandleWrapper::AddIntercepts because Stage doesn't inherit
// from Handle ( just baseHandle)
ObjectTemplateHelper::AddSignalConnectAndDisconnect( isolate, objTemplate );
objTemplate->SetInternalFieldCount( BaseWrappedObject::FIELD_COUNT );
// add our function properties
ObjectTemplateHelper::InstallFunctions( isolate, objTemplate, StageFunctionTable, StageFunctionTableCount );
return handleScope.Escape( objTemplate );
}
v8::Handle<v8::ObjectTemplate> TimerWrapper::objectTemplate(v8::Isolate* pIsolate)
{
v8::EscapableHandleScope handleScope(pIsolate);
Poco::JS::Core::PooledIsolate* pPooledIso = Poco::JS::Core::PooledIsolate::fromIsolate(pIsolate);
poco_check_ptr (pPooledIso);
v8::Persistent<v8::ObjectTemplate>& pooledObjectTemplate(pPooledIso->objectTemplate("Core.Timer"));
if (pooledObjectTemplate.IsEmpty())
{
v8::Handle<v8::ObjectTemplate> objectTemplate = v8::ObjectTemplate::New();
objectTemplate->SetInternalFieldCount(1);
objectTemplate->SetAccessor(v8::String::NewFromUtf8(pIsolate, "cancelled"), cancelled);
objectTemplate->Set(v8::String::NewFromUtf8(pIsolate, "cancel"), v8::FunctionTemplate::New(pIsolate, cancel));
pooledObjectTemplate.Reset(pIsolate, objectTemplate);
}
v8::Local<v8::ObjectTemplate> timerTemplate = v8::Local<v8::ObjectTemplate>::New(pIsolate, pooledObjectTemplate);
return handleScope.Escape(timerTemplate);
}
void V8WindowShell::disposeContext()
{
m_perContextData.clear();
if (m_context.isEmpty())
return;
v8::HandleScope handleScope(m_isolate);
m_frame->loader().client()->willReleaseScriptContext(m_context.newLocal(m_isolate), m_world->worldId());
m_context.clear();
// It's likely that disposing the context has created a lot of
// garbage. Notify V8 about this so it'll have a chance of cleaning
// it up when idle.
V8GCForContextDispose::instance().notifyContextDisposed(m_frame->isMainFrame());
}
v8::Local<v8::ObjectTemplate> RenderTaskWrapper::GetRenderTaskTemplate( v8::Isolate* isolate)
{
v8::EscapableHandleScope handleScope( isolate );
v8::Local<v8::ObjectTemplate> objectTemplate;
if( mRenderTaskTemplate.IsEmpty() )
{
objectTemplate = MakeRenderTaskTemplate( isolate );
mRenderTaskTemplate.Reset( isolate, objectTemplate );
}
else
{
// get the object template
objectTemplate = v8::Local<v8::ObjectTemplate>::New( isolate, mRenderTaskTemplate );
}
return handleScope.Escape( objectTemplate );
}
ScriptValue WorkerScriptController::evaluate(const String& script, const String& fileName, const TextPosition& scriptStartPosition, WorkerGlobalScopeExecutionState* state)
{
v8::HandleScope handleScope(isolate());
if (!initializeContextIfNeeded())
return ScriptValue();
v8::Handle<v8::Context> context = m_contextHolder->context();
if (!m_disableEvalPending.isEmpty()) {
context->AllowCodeGenerationFromStrings(false);
context->SetErrorMessageForCodeGenerationFromStrings(v8String(isolate(), m_disableEvalPending));
m_disableEvalPending = String();
}
v8::Context::Scope scope(context);
v8::TryCatch block;
v8::Handle<v8::String> scriptString = v8String(isolate(), script);
v8::Handle<v8::Script> compiledScript = V8ScriptRunner::compileScript(scriptString, fileName, scriptStartPosition, 0, isolate());
v8::Local<v8::Value> result = V8ScriptRunner::runCompiledScript(compiledScript, &m_workerGlobalScope, isolate());
if (!block.CanContinue()) {
m_workerGlobalScope.script()->forbidExecution();
return ScriptValue();
}
if (block.HasCaught()) {
v8::Local<v8::Message> message = block.Message();
state->hadException = true;
state->errorMessage = toCoreString(message->Get());
state->lineNumber = message->GetLineNumber();
state->columnNumber = message->GetStartColumn() + 1;
V8TRYCATCH_FOR_V8STRINGRESOURCE_RETURN(V8StringResource<>, sourceURL, message->GetScriptResourceName(), ScriptValue());
state->sourceURL = sourceURL;
state->exception = ScriptValue(block.Exception(), isolate());
block.Reset();
} else
state->hadException = false;
if (result.IsEmpty() || result->IsUndefined())
return ScriptValue();
return ScriptValue(result, isolate());
}
void WindowProxy::takeGlobalFrom(WindowProxy* windowProxy)
{
v8::HandleScope handleScope(m_isolate);
ASSERT(!windowProxy->isContextInitialized());
// If a ScriptState was created, the context was initialized at some point.
// Make sure the global object was detached from the proxy by calling clearForNavigation().
if (windowProxy->m_scriptState)
ASSERT(windowProxy->m_scriptState->isGlobalObjectDetached());
m_global.set(m_isolate, windowProxy->m_global.newLocal(m_isolate));
windowProxy->m_global.clear();
// Initialize the window proxy now, to re-establish the connection between
// the global object and the v8::Context. This is really only needed for a
// RemoteDOMWindow, since it has no scripting environment of its own.
// Without this, existing script references to a swapped in RemoteDOMWindow
// would be broken until that RemoteDOMWindow was vended again through an
// interface like window.frames.
initializeIfNeeded();
}
void DaliWrapper::Shutdown()
{
// if we're running inside node then we don't have ownership of the context
if( mRunMode == RUNNING_IN_NODE_JS )
{
return;
}
DALI_LOG_WARNING("Destroying V8 DALi context\n");
if( !mContext.IsEmpty())
{
v8::HandleScope handleScope( mIsolate );
v8::Local<v8::Context> context = v8::Local<v8::Context>::New(mIsolate, mContext);
context->Exit(); // exit the context
mContext.Reset(); // destroys the context
}
}
v8::Handle<v8::Object> StageWrapper::WrapStage(v8::Isolate* isolate, const Dali::Stage& stage )
{
v8::EscapableHandleScope handleScope( isolate );
v8::Local<v8::ObjectTemplate> objectTemplate;
objectTemplate = GetStageTemplate( isolate);
// create an instance of the template
v8::Local<v8::Object> localObject = objectTemplate->NewInstance();
// create the Stage wrapper
StageWrapper* pointer = new StageWrapper( stage, Dali::V8Plugin::DaliWrapper::Get().GetDaliGarbageCollector() );
// assign the JavaScript object to the wrapper.
pointer->SetJavascriptObject( isolate, localObject );
return handleScope.Escape( localObject );
}
