GEN_DOMCSSValue* GEN_DOMCSSValue::createInstance(WebCore::CSSValue* value)
{
if (!value)
return 0;
if (GEN_DOMObject* cachedInstance = getDOMWrapper(value)) {
cachedInstance->AddRef();
return static_cast<GEN_DOMCSSValue*>(cachedInstance);
}
COMPtr<GEN_DOMCSSValue> domValue;
switch (value->cssValueType()) {
case WebCore::CSSValue::CSS_PRIMITIVE_VALUE:
domValue = new GEN_DOMCSSPrimitiveValue(static_cast<WebCore::CSSPrimitiveValue*>(value));
break;
case WebCore::CSSValue::CSS_VALUE_LIST:
domValue = new GEN_DOMCSSValueList(static_cast<WebCore::CSSValueList*>(value));
break;
case WebCore::CSSValue::CSS_INHERIT:
domValue = new GEN_DOMCSSValue(value);
break;
case WebCore::CSSValue::CSS_CUSTOM:
// FIXME: add support for SVGPaint and SVGColor
domValue = new GEN_DOMCSSValue(value);
break;
}
setDOMWrapper(value, domValue.get());
return domValue.releaseRef();
}
v8::Local<v8::Object> V8DOMWrapper::instantiateV8Object(Document* deprecatedDocument, WrapperTypeInfo* type, void* impl)
{
V8PerContextData* perContextData = 0;
// Please don't add any more uses of deprecatedDocument. We want to remove it.
// If we have a pointer to the frame, we cna get the V8PerContextData
// directly, which is faster than going through V8.
if (deprecatedDocument && deprecatedDocument->frame())
perContextData = perContextDataForCurrentWorld(deprecatedDocument->frame());
else
perContextData = V8PerContextData::from(v8::Context::GetCurrent());
v8::Local<v8::Object> instance = perContextData ? perContextData->createWrapperFromCache(type) : V8ObjectConstructor::newInstance(type->getTemplate()->GetFunction());
// Avoid setting the DOM wrapper for failed allocations.
if (instance.IsEmpty())
return instance;
setDOMWrapper(instance, type, impl);
if (type == &V8HTMLDocument::info)
instance = V8HTMLDocument::wrapInShadowObject(instance, static_cast<Node*>(impl));
return instance;
}
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()) {
// Avoid setting the DOM wrapper for failed allocations.
setDOMWrapper(instance, type, impl);
if (type == &V8HTMLDocument::info)
instance = V8HTMLDocument::WrapInShadowObject(instance, static_cast<Node*>(impl));
}
return instance;
}
GEN_DOMImplementation* GEN_DOMImplementation::createInstance(WebCore::DOMImplementation* impl)
{
if (!impl)
return 0;
if (GEN_DOMObject* cachedInstance = getDOMWrapper(impl)) {
cachedInstance->AddRef();
return static_cast<GEN_DOMImplementation*>(cachedInstance);
}
COMPtr<GEN_DOMImplementation> comDOMObject = new GEN_DOMImplementation(impl);
setDOMWrapper(impl, comDOMObject.get());
return comDOMObject.releaseRef();
}
v8::Local<v8::Object> V8DOMWrapper::instantiateV8Object(V8Proxy* proxy, WrapperTypeInfo* type, void* impl)
{
#if ENABLE(WORKERS)
WorkerContext* workerContext = 0;
#endif
if (V8IsolatedContext::getEntered()) {
// This effectively disables the wrapper cache for isolated worlds.
proxy = 0;
// FIXME: Do we need a wrapper cache for the isolated world? We should
// see if the performance gains are worth while.
// We'll get one once we give the isolated context a proper window shell.
} 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
workerContext = V8WorkerContext::toNative(lookupDOMWrapper(V8WorkerContext::GetTemplate(), context->Global()));
#endif
}
}
v8::Local<v8::Object> instance;
if (proxy)
// FIXME: Fix this to work properly with isolated worlds (see above).
instance = proxy->windowShell()->createWrapperFromCache(type);
else {
v8::Local<v8::Function> function;
#if ENABLE(WORKERS)
if (workerContext)
function = getConstructor(type, workerContext);
else
#endif
function = type->getTemplate()->GetFunction();
instance = SafeAllocation::newInstance(function);
}
if (!instance.IsEmpty()) {
// Avoid setting the DOM wrapper for failed allocations.
setDOMWrapper(instance, type, impl);
if (type == &V8HTMLDocument::info)
instance = V8HTMLDocument::WrapInShadowObject(instance, static_cast<Node*>(impl));
}
return instance;
}
GEN_DOMStyleSheet* GEN_DOMStyleSheet::createInstance(WebCore::StyleSheet* styleSheet)
{
if (!styleSheet)
return 0;
if (GEN_DOMObject* cachedInstance = getDOMWrapper(styleSheet)) {
cachedInstance->AddRef();
return static_cast<GEN_DOMStyleSheet*>(cachedInstance);
}
COMPtr<GEN_DOMStyleSheet> domStyleSheet;
if (styleSheet->isCSSStyleSheet())
domStyleSheet = new GEN_DOMCSSStyleSheet(static_cast<WebCore::CSSStyleSheet*>(styleSheet));
else
domStyleSheet = new GEN_DOMStyleSheet(styleSheet);
setDOMWrapper(styleSheet, domStyleSheet.get());
return domStyleSheet.releaseRef();
}
GEN_DOMCSSRule* GEN_DOMCSSRule::createInstance(WebCore::CSSRule* rule)
{
if (!rule)
return 0;
if (GEN_DOMObject* cachedInstance = getDOMWrapper(rule)) {
cachedInstance->AddRef();
return static_cast<GEN_DOMCSSRule*>(cachedInstance);
}
COMPtr<GEN_DOMCSSRule> domRule;
switch (rule->type()) {
case WebCore::CSSRule::STYLE_RULE:
domRule = new GEN_DOMCSSStyleRule(static_cast<WebCore::CSSStyleRule*>(rule));
break;
case WebCore::CSSRule::CHARSET_RULE:
domRule = new GEN_DOMCSSCharsetRule(static_cast<WebCore::CSSCharsetRule*>(rule));
break;
case WebCore::CSSRule::IMPORT_RULE:
domRule = new GEN_DOMCSSImportRule(static_cast<WebCore::CSSImportRule*>(rule));
break;
case WebCore::CSSRule::MEDIA_RULE:
domRule = new GEN_DOMCSSMediaRule(static_cast<WebCore::CSSMediaRule*>(rule));
break;
case WebCore::CSSRule::FONT_FACE_RULE:
domRule = new GEN_DOMCSSFontFaceRule(static_cast<WebCore::CSSFontFaceRule*>(rule));
break;
case WebCore::CSSRule::PAGE_RULE:
domRule = new GEN_DOMCSSPageRule(static_cast<WebCore::CSSPageRule*>(rule));
break;
case WebCore::CSSRule::UNKNOWN_RULE:
default:
domRule = new GEN_DOMCSSRule(rule);
break;
}
setDOMWrapper(rule, domRule.get());
return domRule.releaseRef();
}
v8::Local<v8::Object> V8DOMWrapper::instantiateV8Object(V8Proxy* proxy, V8ClassIndex::V8WrapperType type, void* impl)
{
WorkerContext* workerContext = 0;
if (V8IsolatedContext::getEntered()) {
// This effectively disables the wrapper cache for isolated worlds.
proxy = 0;
// FIXME: Do we need a wrapper cache for the isolated world? We should
// see if the performance gains are worth while.
// We'll get one once we give the isolated context a proper window shell.
} 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 (globalObjectPrototypeIsDOMWindow(globalPrototype))
proxy = V8Proxy::retrieve(V8DOMWindow::toNative(globalPrototype)->frame());
else
workerContext = V8WorkerContext::toNative(lookupDOMWrapper(V8WorkerContext::GetTemplate(), context->Global()));
}
}
v8::Local<v8::Object> instance;
if (proxy)
// FIXME: Fix this to work properly with isolated worlds (see above).
instance = proxy->windowShell()->createWrapperFromCache(type);
else {
v8::Local<v8::Function> function;
if (workerContext)
function = getConstructor(type, workerContext);
else
function = V8ClassIndex::getTemplate(type)->GetFunction();
instance = SafeAllocation::newInstance(function);
}
if (!instance.IsEmpty()) {
// Avoid setting the DOM wrapper for failed allocations.
setDOMWrapper(instance, V8ClassIndex::ToInt(type), impl);
}
return instance;
}
GEN_DOMNode* GEN_DOMNode::createInstance(WebCore::Node* node)
{
if (!node)
return 0;
if (GEN_DOMObject* cachedInstance = getDOMWrapper(node)) {
cachedInstance->AddRef();
return static_cast<GEN_DOMNode*>(cachedInstance);
}
COMPtr<GEN_DOMNode> domNode;
switch (node->nodeType()) {
case WebCore::Node::ELEMENT_NODE:
// FIXME: add support for creating subclasses of HTMLElement.
// FIXME: add support for creating SVGElements and its subclasses.
if (node->isHTMLElement())
domNode = new GEN_DOMHTMLElement(static_cast<WebCore::HTMLElement*>(node));
else
domNode = new GEN_DOMElement(static_cast<WebCore::Element*>(node));
break;
case WebCore::Node::ATTRIBUTE_NODE:
domNode = new GEN_DOMAttr(static_cast<WebCore::Attr*>(node));
break;
case WebCore::Node::TEXT_NODE:
domNode = new GEN_DOMText(static_cast<WebCore::Text*>(node));
break;
case WebCore::Node::CDATA_SECTION_NODE:
domNode = new GEN_DOMCDATASection(static_cast<WebCore::CDATASection*>(node));
break;
case WebCore::Node::ENTITY_REFERENCE_NODE:
domNode = new GEN_DOMEntityReference(static_cast<WebCore::EntityReference*>(node));
break;
case WebCore::Node::ENTITY_NODE:
domNode = new GEN_DOMEntity(static_cast<WebCore::Entity*>(node));
break;
case WebCore::Node::PROCESSING_INSTRUCTION_NODE:
domNode = new GEN_DOMProcessingInstruction(static_cast<WebCore::ProcessingInstruction*>(node));
break;
case WebCore::Node::COMMENT_NODE:
domNode = new GEN_DOMComment(static_cast<WebCore::Comment*>(node));
break;
case WebCore::Node::DOCUMENT_NODE:
// FIXME: add support for SVGDocument.
if (static_cast<WebCore::Document*>(node)->isHTMLDocument())
domNode = new GEN_DOMHTMLDocument(static_cast<WebCore::HTMLDocument*>(node));
else
domNode = new GEN_DOMDocument(static_cast<WebCore::Document*>(node));
break;
case WebCore::Node::DOCUMENT_TYPE_NODE:
domNode = new GEN_DOMDocumentType(static_cast<WebCore::DocumentType*>(node));
break;
case WebCore::Node::DOCUMENT_FRAGMENT_NODE:
domNode = new GEN_DOMDocumentFragment(static_cast<WebCore::DocumentFragment*>(node));
break;
case WebCore::Node::NOTATION_NODE:
domNode = new GEN_DOMNotation(static_cast<WebCore::Notation*>(node));
break;
default:
domNode = new GEN_DOMNode(node);
break;
}
setDOMWrapper(node, domNode.get());
return domNode.releaseRef();
}
