#include "config.h"
#include "V8DOMWrapper.h"
#include <wtf/ArrayBufferView.h>
#include "DocumentLoader.h"
#include "EventTargetHeaders.h"
#include "EventTargetInterfaces.h"
#include "FrameLoaderClient.h"
#include "SafeAllocation.h"
#include "StylePropertySet.h"
#include "V8AbstractEventListener.h"
#include "V8Binding.h"
#include "V8BindingPerContextData.h"
#include "V8Collection.h"
#include "V8EventListener.h"
#include "V8EventListenerList.h"
#include "V8HTMLCollection.h"
#include "V8HTMLDocument.h"
#include "V8HiddenPropertyName.h"
#include "V8Location.h"
#include "V8NamedNodeMap.h"
#include "V8NodeFilterCondition.h"
#include "V8NodeList.h"
#include "V8Proxy.h"
#include "V8StyleSheet.h"
#include "V8WorkerContextEventListener.h"
#include "WebGLContextAttributes.h"
#include "WebGLUniformLocation.h"
#include "WorkerContextExecutionProxy.h"
#include "WrapperTypeInfo.h"
#include <algorithm>
#include <utility>
#include <v8-debug.h>
#include <wtf/Assertions.h>
#include <wtf/OwnArrayPtr.h>
#include <wtf/StdLibExtras.h>
#include <wtf/UnusedParam.h>
namespace WebCore {
void V8DOMWrapper::setJSWrapperForDOMNode(PassRefPtr<Node> node, v8::Persistent<v8::Object> wrapper, v8::Isolate* isolate)
{
ASSERT(maybeDOMWrapper(wrapper));
ASSERT(!node->isActiveNode());
getDOMNodeMap(isolate).set(node.leakRef(), wrapper);
}
void V8DOMWrapper::setJSWrapperForActiveDOMNode(PassRefPtr<Node> node, v8::Persistent<v8::Object> wrapper, v8::Isolate* isolate)
{
ASSERT(maybeDOMWrapper(wrapper));
ASSERT(node->isActiveNode());
getActiveDOMNodeMap(isolate).set(node.leakRef(), wrapper);
}
v8::Local<v8::Function> V8DOMWrapper::constructorForType(WrapperTypeInfo* type, DOMWindow* window)
{
Frame* frame = window->frame();
if (!frame)
return v8::Local<v8::Function>();
if (V8BindingPerContextData* contextData = V8Proxy::retrievePerContextData(frame))
return contextData->constructorForType(type);
return v8::Local<v8::Function>();
}
#if ENABLE(WORKERS)
v8::Local<v8::Function> V8DOMWrapper::constructorForType(WrapperTypeInfo* type, WorkerContext*)
{
WorkerScriptController* controller = WorkerScriptController::controllerForContext();
WorkerContextExecutionProxy* proxy = controller ? controller->proxy() : 0;
return proxy ? proxy->perContextData()->constructorForType(type) : v8::Local<v8::Function>();
}
#endif
V8BindingPerContextData* V8DOMWrapper::perContextData(V8Proxy* proxy)
{
V8DOMWindowShell* shell = proxy->windowShell();
return shell ? shell->perContextData() : 0;
}
#if ENABLE(WORKERS)
V8BindingPerContextData* V8DOMWrapper::perContextData(WorkerContext*)
{
WorkerScriptController* controller = WorkerScriptController::controllerForContext();
WorkerContextExecutionProxy* proxy = controller ? controller->proxy() : 0;
return proxy ? proxy->perContextData() : 0;
}
#endif
void V8DOMWrapper::setNamedHiddenReference(v8::Handle<v8::Object> parent, const char* name, v8::Handle<v8::Value> child)
{
parent->SetHiddenValue(V8HiddenPropertyName::hiddenReferenceName(name), child);
}
void V8DOMWrapper::setNamedHiddenWindowReference(Frame* frame, const char* name, v8::Handle<v8::Value> jsObject)
{
if (!frame)
return; v8::Handle<v8::Context> context = V8Proxy::context(frame);
if (context.IsEmpty())
return;
v8::Handle<v8::Object> global = context->Global();
global = V8DOMWrapper::lookupDOMWrapper(V8DOMWindow::GetTemplate(), global);
ASSERT(!global.IsEmpty());
setNamedHiddenReference(global, name, jsObject);
}
WrapperTypeInfo* V8DOMWrapper::domWrapperType(v8::Handle<v8::Object> object)
{
ASSERT(V8DOMWrapper::maybeDOMWrapper(object));
return static_cast<WrapperTypeInfo*>(object->GetPointerFromInternalField(v8DOMWrapperTypeIndex));
}
PassRefPtr<NodeFilter> V8DOMWrapper::wrapNativeNodeFilter(v8::Handle<v8::Value> filter)
{
return NodeFilter::create(V8NodeFilterCondition::create(filter));
}
v8::Local<v8::Object> V8DOMWrapper::instantiateV8Object(V8Proxy* proxy, WrapperTypeInfo* type, void* impl)
{
#if ENABLE(WORKERS)
WorkerContext* workerContext = 0;
#endif
V8BindingPerContextData* contextData = 0;
V8IsolatedContext* isolatedContext;
if (UNLIKELY(!!(isolatedContext = V8IsolatedContext::getEntered()))) {
contextData = isolatedContext->perContextData();
} else if (!proxy) {
v8::Handle<v8::Context> context = v8::Context::GetCurrent();
if (!context.IsEmpty()) {
v8::Handle<v8::Object> globalPrototype = v8::Handle<v8::Object>::Cast(context->Global()->GetPrototype());
if (isWrapperOfType(globalPrototype, &V8DOMWindow::info)) {
Frame* frame = V8DOMWindow::toNative(globalPrototype)->frame();
if (frame && frame->script()->canExecuteScripts(NotAboutToExecuteScript))
proxy = V8Proxy::retrieve(frame);
}
#if ENABLE(WORKERS)
else if (isWrapperOfType(globalPrototype, &V8WorkerContext::info))
workerContext = V8WorkerContext::toNative(lookupDOMWrapper(V8WorkerContext::GetTemplate(), context->Global()));
#endif
}
}
v8::Local<v8::Object> instance;
if (!contextData) {
if (proxy)
contextData = perContextData(proxy);
#if ENABLE(WORKERS)
else if (workerContext)
contextData = perContextData(workerContext);
#endif
}
if (contextData)
instance = contextData->createWrapperFromCache(type);
else {
v8::Local<v8::Function> function = type->getTemplate()->GetFunction();
instance = SafeAllocation::newInstance(function);
}
if (!instance.IsEmpty()) {
setDOMWrapper(instance, type, impl);
if (type == &V8HTMLDocument::info)
instance = V8HTMLDocument::WrapInShadowObject(instance, static_cast<Node*>(impl));
}
return instance;
}
#ifndef NDEBUG
bool V8DOMWrapper::maybeDOMWrapper(v8::Handle<v8::Value> value)
{
if (value.IsEmpty() || !value->IsObject())
return false;
v8::Handle<v8::Object> object = v8::Handle<v8::Object>::Cast(value);
if (!object->InternalFieldCount())
return false;
ASSERT(object->InternalFieldCount() >= v8DefaultWrapperInternalFieldCount);
v8::Handle<v8::Value> wrapper = object->GetInternalField(v8DOMWrapperObjectIndex);
ASSERT(wrapper->IsNumber() || wrapper->IsExternal());
return true;
}
#endif
bool V8DOMWrapper::isValidDOMObject(v8::Handle<v8::Value> value)
{
if (value.IsEmpty() || !value->IsObject())
return false;
return v8::Handle<v8::Object>::Cast(value)->InternalFieldCount();
}
bool V8DOMWrapper::isWrapperOfType(v8::Handle<v8::Value> value, WrapperTypeInfo* type)
{
if (!isValidDOMObject(value))
return false;
v8::Handle<v8::Object> object = v8::Handle<v8::Object>::Cast(value);
ASSERT(object->InternalFieldCount() >= v8DefaultWrapperInternalFieldCount);
v8::Handle<v8::Value> wrapper = object->GetInternalField(v8DOMWrapperObjectIndex);
ASSERT_UNUSED(wrapper, wrapper->IsNumber() || wrapper->IsExternal());
WrapperTypeInfo* typeInfo = static_cast<WrapperTypeInfo*>(object->GetPointerFromInternalField(v8DOMWrapperTypeIndex));
return typeInfo == type;
}
#define TRY_TO_WRAP_WITH_INTERFACE(interfaceName) \
if (eventNames().interfaceFor##interfaceName == desiredInterface) \
return toV8(static_cast<interfaceName*>(target));
v8::Handle<v8::Value> V8DOMWrapper::convertEventTargetToV8Object(EventTarget* target)
{
if (!target)
return v8::Null();
AtomicString desiredInterface = target->interfaceName();
DOM_EVENT_TARGET_INTERFACES_FOR_EACH(TRY_TO_WRAP_WITH_INTERFACE)
ASSERT_NOT_REACHED();
return notHandledByInterceptor();
}
PassRefPtr<EventListener> V8DOMWrapper::getEventListener(v8::Local<v8::Value> value, bool isAttribute, ListenerLookupType lookup)
{
v8::Handle<v8::Context> context = v8::Context::GetCurrent();
if (context.IsEmpty())
return 0;
if (lookup == ListenerFindOnly)
return V8EventListenerList::findWrapper(value, isAttribute);
v8::Handle<v8::Object> globalPrototype = v8::Handle<v8::Object>::Cast(context->Global()->GetPrototype());
if (isWrapperOfType(globalPrototype, &V8DOMWindow::info))
return V8EventListenerList::findOrCreateWrapper<V8EventListener>(value, isAttribute);
#if ENABLE(WORKERS)
return V8EventListenerList::findOrCreateWrapper<V8WorkerContextEventListener>(value, isAttribute);
#else
return 0;
#endif
}
RefPtr<XPathNSResolver> V8DOMWrapper::getXPathNSResolver(v8::Handle<v8::Value> value, V8Proxy* proxy)
{
RefPtr<XPathNSResolver> resolver;
if (V8XPathNSResolver::HasInstance(value))
resolver = V8XPathNSResolver::toNative(v8::Handle<v8::Object>::Cast(value));
else if (value->IsObject())
resolver = V8CustomXPathNSResolver::create(value->ToObject());
return resolver;
}
}