+2014-03-22 Andreas Kling <akling@apple.com>
+
+ CREATE_DOM_WRAPPER doesn't need the ExecState.
+ <https://webkit.org/b/130648>
+
+ Add a fast path from JSGlobalObject to the VM so we don't have
+ to dance via the Heap.
+
+ Reviewed by Darin Adler.
+
+ * runtime/JSGlobalObject.cpp:
+ (JSC::JSGlobalObject::JSGlobalObject):
+ * runtime/JSGlobalObject.h:
+ (JSC::JSGlobalObject::vm):
+
2014-03-22 Filip Pizlo <fpizlo@apple.com>
Unreviewed, fix FTL build.
JSGlobalObject::JSGlobalObject(VM& vm, Structure* structure, const GlobalObjectMethodTable* globalObjectMethodTable)
: Base(vm, structure, 0)
+ , m_vm(vm)
#if ENABLE(WEB_REPLAY)
, m_inputCursor(EmptyInputCursor::create())
#endif
Debugger* m_debugger;
+ VM& m_vm;
+
#if ENABLE(WEB_REPLAY)
RefPtr<InputCursor> m_inputCursor;
#endif
void resetPrototype(VM&, JSValue prototype);
- VM& vm() const { return *Heap::heap(this)->vm(); }
+ VM& vm() const { return m_vm; }
JSObject* globalThis() const;
static Structure* createStructure(VM& vm, JSValue prototype)
+2014-03-22 Andreas Kling <akling@apple.com>
+
+ CREATE_DOM_WRAPPER doesn't need the ExecState.
+ <https://webkit.org/b/130648>
+
+ Remove the ExecState parameter from CREATE_DOM_WRAPPER and get all
+ that we need from the global object instead.
+
+ toJS() and toJSNewlyCreated() still take an ExecState, that needs
+ to be dealt with separately since some of them have scary looking
+ currentWorld() checks.
+
+ Reviewed by Darin Adler.
+
+ * bindings/js/JSAudioContextCustom.cpp:
+ (WebCore::JSAudioContextConstructor::constructJSAudioContext):
+ * bindings/js/JSBlobCustom.cpp:
+ (WebCore::toJS):
+ (WebCore::JSBlobConstructor::constructJSBlob):
+ * bindings/js/JSCDATASectionCustom.cpp:
+ (WebCore::toJSNewlyCreated):
+ * bindings/js/JSCSSRuleCustom.cpp:
+ (WebCore::toJS):
+ * bindings/js/JSCSSValueCustom.cpp:
+ (WebCore::toJS):
+ * bindings/js/JSCanvasRenderingContextCustom.cpp:
+ (WebCore::toJS):
+ * bindings/js/JSDOMBinding.h:
+ (WebCore::createWrapper):
+ (WebCore::wrap):
+ (WebCore::createNewWrapper):
+ * bindings/js/JSDocumentCustom.cpp:
+ (WebCore::toJS):
+ * bindings/js/JSElementCustom.cpp:
+ (WebCore::toJSNewlyCreated):
+ * bindings/js/JSEventCustom.cpp:
+ (WebCore::toJS):
+ * bindings/js/JSHTMLCollectionCustom.cpp:
+ (WebCore::toJS):
+ * bindings/js/JSHTMLTemplateElementCustom.cpp:
+ (WebCore::JSHTMLTemplateElement::content):
+ * bindings/js/JSIDBAnyCustom.cpp:
+ (WebCore::toJS):
+ * bindings/js/JSImageDataCustom.cpp:
+ (WebCore::toJS):
+ * bindings/js/JSMediaStreamCapabilitiesCustom.cpp:
+ (WebCore::toJS):
+ * bindings/js/JSNodeCustom.cpp:
+ (WebCore::createWrapperInline):
+ * bindings/js/JSPerformanceEntryCustom.cpp:
+ (WebCore::toJS):
+ * bindings/js/JSRTCIceCandidateCustom.cpp:
+ (WebCore::JSRTCIceCandidateConstructor::constructJSRTCIceCandidate):
+ * bindings/js/JSRTCPeerConnectionCustom.cpp:
+ (WebCore::JSRTCPeerConnectionConstructor::constructJSRTCPeerConnection):
+ * bindings/js/JSRTCSessionDescriptionCustom.cpp:
+ (WebCore::JSRTCSessionDescriptionConstructor::constructJSRTCSessionDescription):
+ * bindings/js/JSSVGPathSegCustom.cpp:
+ (WebCore::toJS):
+ * bindings/js/JSStyleSheetCustom.cpp:
+ (WebCore::toJS):
+ * bindings/js/JSTextCustom.cpp:
+ (WebCore::toJSNewlyCreated):
+ * bindings/js/JSTextTrackCueCustom.cpp:
+ (WebCore::toJS):
+ * bindings/js/JSTouchCustom.cpp:
+ (WebCore::toJSNewlyCreated):
+ * bindings/js/JSTouchListCustom.cpp:
+ (WebCore::toJSNewlyCreated):
+ * bindings/js/JSTrackCustom.cpp:
+ (WebCore::toJS):
+ * bindings/scripts/CodeGeneratorJS.pm:
+ (GenerateImplementation):
+ * dom/make_names.pl:
+ (printWrapperFunctions):
+ (printWrapperFactoryCppFile):
+ (printWrapperFactoryHeaderFile):
+
2014-03-22 Michael Saboff <msaboff@apple.com>
toThis() on a JSWorkerGlobalScope should return a JSProxy and not undefined
if (!audioContext.get())
return throwVMError(exec, createReferenceError(exec, "Error creating AudioContext"));
- return JSValue::encode(CREATE_DOM_WRAPPER(exec, jsConstructor->globalObject(), AudioContext, audioContext.get()));
+ return JSValue::encode(CREATE_DOM_WRAPPER(jsConstructor->globalObject(), AudioContext, audioContext.get()));
}
} // namespace WebCore
namespace WebCore {
-JSValue toJS(ExecState* exec, JSDOMGlobalObject* globalObject, Blob* blob)
+JSValue toJS(ExecState*, JSDOMGlobalObject* globalObject, Blob* blob)
{
if (!blob)
return jsNull();
if (blob->isFile())
- return wrap<JSFile>(exec, globalObject, static_cast<File*>(blob));
+ return wrap<JSFile>(globalObject, static_cast<File*>(blob));
- return wrap<JSBlob>(exec, globalObject, blob);
+ return wrap<JSBlob>(globalObject, blob);
}
EncodedJSValue JSC_HOST_CALL JSBlobConstructor::constructJSBlob(ExecState* exec)
if (!exec->argumentCount()) {
RefPtr<Blob> blob = Blob::create();
- return JSValue::encode(CREATE_DOM_WRAPPER(exec, jsConstructor->globalObject(), Blob, blob.get()));
+ return JSValue::encode(CREATE_DOM_WRAPPER(jsConstructor->globalObject(), Blob, blob.get()));
}
unsigned blobPartsLength = 0;
}
RefPtr<Blob> blob = blobBuilder.getBlob(type);
- return JSValue::encode(CREATE_DOM_WRAPPER(exec, jsConstructor->globalObject(), Blob, blob.get()));
+ return JSValue::encode(CREATE_DOM_WRAPPER(jsConstructor->globalObject(), Blob, blob.get()));
}
} // namespace WebCore
namespace WebCore {
-JSValue toJSNewlyCreated(ExecState* exec, JSDOMGlobalObject* globalObject, CDATASection* section)
+JSValue toJSNewlyCreated(ExecState*, JSDOMGlobalObject* globalObject, CDATASection* section)
{
if (!section)
return jsNull();
- return CREATE_DOM_WRAPPER(exec, globalObject, CDATASection, section);
+ return CREATE_DOM_WRAPPER(globalObject, CDATASection, section);
}
} // namespace WebCore
visitor.addOpaqueRoot(root(&thisObject->impl()));
}
-JSValue toJS(ExecState* exec, JSDOMGlobalObject* globalObject, CSSRule* rule)
+JSValue toJS(ExecState*, JSDOMGlobalObject* globalObject, CSSRule* rule)
{
if (!rule)
return jsNull();
switch (rule->type()) {
case CSSRule::STYLE_RULE:
- wrapper = CREATE_DOM_WRAPPER(exec, globalObject, CSSStyleRule, rule);
+ wrapper = CREATE_DOM_WRAPPER(globalObject, CSSStyleRule, rule);
break;
case CSSRule::MEDIA_RULE:
- wrapper = CREATE_DOM_WRAPPER(exec, globalObject, CSSMediaRule, rule);
+ wrapper = CREATE_DOM_WRAPPER(globalObject, CSSMediaRule, rule);
break;
case CSSRule::FONT_FACE_RULE:
- wrapper = CREATE_DOM_WRAPPER(exec, globalObject, CSSFontFaceRule, rule);
+ wrapper = CREATE_DOM_WRAPPER(globalObject, CSSFontFaceRule, rule);
break;
case CSSRule::PAGE_RULE:
- wrapper = CREATE_DOM_WRAPPER(exec, globalObject, CSSPageRule, rule);
+ wrapper = CREATE_DOM_WRAPPER(globalObject, CSSPageRule, rule);
break;
case CSSRule::IMPORT_RULE:
- wrapper = CREATE_DOM_WRAPPER(exec, globalObject, CSSImportRule, rule);
+ wrapper = CREATE_DOM_WRAPPER(globalObject, CSSImportRule, rule);
break;
case CSSRule::CHARSET_RULE:
- wrapper = CREATE_DOM_WRAPPER(exec, globalObject, CSSCharsetRule, rule);
+ wrapper = CREATE_DOM_WRAPPER(globalObject, CSSCharsetRule, rule);
break;
case CSSRule::WEBKIT_KEYFRAME_RULE:
- wrapper = CREATE_DOM_WRAPPER(exec, globalObject, WebKitCSSKeyframeRule, rule);
+ wrapper = CREATE_DOM_WRAPPER(globalObject, WebKitCSSKeyframeRule, rule);
break;
case CSSRule::WEBKIT_KEYFRAMES_RULE:
- wrapper = CREATE_DOM_WRAPPER(exec, globalObject, WebKitCSSKeyframesRule, rule);
+ wrapper = CREATE_DOM_WRAPPER(globalObject, WebKitCSSKeyframesRule, rule);
break;
#if ENABLE(CSS3_CONDITIONAL_RULES)
case CSSRule::SUPPORTS_RULE:
- wrapper = CREATE_DOM_WRAPPER(exec, globalObject, CSSSupportsRule, rule);
+ wrapper = CREATE_DOM_WRAPPER(globalObject, CSSSupportsRule, rule);
break;
#endif
#if ENABLE(CSS_DEVICE_ADAPTATION)
case CSSRule::WEBKIT_VIEWPORT_RULE:
- wrapper = CREATE_DOM_WRAPPER(exec, globalObject, WebKitCSSViewportRule, rule);
+ wrapper = CREATE_DOM_WRAPPER(globalObject, WebKitCSSViewportRule, rule);
break;
#endif
#if ENABLE(CSS_REGIONS)
case CSSRule::WEBKIT_REGION_RULE:
- wrapper = CREATE_DOM_WRAPPER(exec, globalObject, WebKitCSSRegionRule, rule);
+ wrapper = CREATE_DOM_WRAPPER(globalObject, WebKitCSSRegionRule, rule);
break;
#endif
default:
- wrapper = CREATE_DOM_WRAPPER(exec, globalObject, CSSRule, rule);
+ wrapper = CREATE_DOM_WRAPPER(globalObject, CSSRule, rule);
}
return wrapper;
jsCSSValue->releaseImpl();
}
-JSValue toJS(ExecState* exec, JSDOMGlobalObject* globalObject, CSSValue* value)
+JSValue toJS(ExecState*, JSDOMGlobalObject* globalObject, CSSValue* value)
{
if (!value)
return jsNull();
return wrapper;
if (value->isWebKitCSSTransformValue())
- wrapper = CREATE_DOM_WRAPPER(exec, globalObject, WebKitCSSTransformValue, value);
+ wrapper = CREATE_DOM_WRAPPER(globalObject, WebKitCSSTransformValue, value);
#if ENABLE(CSS_FILTERS)
else if (value->isWebKitCSSFilterValue())
- wrapper = CREATE_DOM_WRAPPER(exec, globalObject, WebKitCSSFilterValue, value);
+ wrapper = CREATE_DOM_WRAPPER(globalObject, WebKitCSSFilterValue, value);
#endif
else if (value->isValueList())
- wrapper = CREATE_DOM_WRAPPER(exec, globalObject, CSSValueList, value);
+ wrapper = CREATE_DOM_WRAPPER(globalObject, CSSValueList, value);
else if (value->isSVGPaint())
- wrapper = CREATE_DOM_WRAPPER(exec, globalObject, SVGPaint, value);
+ wrapper = CREATE_DOM_WRAPPER(globalObject, SVGPaint, value);
else if (value->isSVGColor())
- wrapper = CREATE_DOM_WRAPPER(exec, globalObject, SVGColor, value);
+ wrapper = CREATE_DOM_WRAPPER(globalObject, SVGColor, value);
else if (value->isPrimitiveValue())
- wrapper = CREATE_DOM_WRAPPER(exec, globalObject, CSSPrimitiveValue, value);
+ wrapper = CREATE_DOM_WRAPPER(globalObject, CSSPrimitiveValue, value);
else
- wrapper = CREATE_DOM_WRAPPER(exec, globalObject, CSSValue, value);
+ wrapper = CREATE_DOM_WRAPPER(globalObject, CSSValue, value);
return wrapper;
}
visitor.addOpaqueRoot(root(thisObject->impl().canvas()));
}
-JSC::JSValue toJS(JSC::ExecState* exec, JSDOMGlobalObject* globalObject, CanvasRenderingContext* object)
+JSC::JSValue toJS(JSC::ExecState*, JSDOMGlobalObject* globalObject, CanvasRenderingContext* object)
{
if (!object)
return jsNull();
#if ENABLE(WEBGL)
if (object->is3d())
- return wrap<JSWebGLRenderingContext>(exec, globalObject, static_cast<WebGLRenderingContext*>(object));
+ return wrap<JSWebGLRenderingContext>(globalObject, static_cast<WebGLRenderingContext*>(object));
#endif
ASSERT_WITH_SECURITY_IMPLICATION(object->is2d());
- return wrap<JSCanvasRenderingContext2D>(exec, globalObject, static_cast<CanvasRenderingContext2D*>(object));
+ return wrap<JSCanvasRenderingContext2D>(globalObject, static_cast<CanvasRenderingContext2D*>(object));
}
} // namespace WebCore
weakRemove(world.m_wrappers, (void*)domObject, wrapper);
}
-#define CREATE_DOM_WRAPPER(exec, globalObject, className, object) createWrapper<JS##className>(exec, globalObject, static_cast<className*>(object))
-template<class WrapperClass, class DOMClass> inline JSDOMWrapper* createWrapper(JSC::ExecState* exec, JSDOMGlobalObject* globalObject, DOMClass* node)
+#define CREATE_DOM_WRAPPER(globalObject, className, object) createWrapper<JS##className>(globalObject, static_cast<className*>(object))
+template<class WrapperClass, class DOMClass> inline JSDOMWrapper* createWrapper(JSDOMGlobalObject* globalObject, DOMClass* node)
{
ASSERT(node);
- ASSERT(!getCachedWrapper(globalObject->world(), node));
- WrapperClass* wrapper = WrapperClass::create(getDOMStructure<WrapperClass>(exec->vm(), globalObject), globalObject, node);
+ ASSERT(!getCachedWrapper(globalObject.world(), node));
+ WrapperClass* wrapper = WrapperClass::create(getDOMStructure<WrapperClass>(globalObject->vm(), globalObject), globalObject, node);
cacheWrapper(globalObject->world(), node, wrapper);
return wrapper;
}
-template<class WrapperClass, class DOMClass> inline JSC::JSValue wrap(JSC::ExecState* exec, JSDOMGlobalObject* globalObject, DOMClass* domObject)
+template<class WrapperClass, class DOMClass> inline JSC::JSValue wrap(JSDOMGlobalObject* globalObject, DOMClass* domObject)
{
if (!domObject)
return JSC::jsNull();
if (JSC::JSObject* wrapper = getCachedWrapper(globalObject->world(), domObject))
return wrapper;
- return createWrapper<WrapperClass>(exec, globalObject, domObject);
+ return createWrapper<WrapperClass>(globalObject, domObject);
}
template<class WrapperClass, class DOMClass> inline JSC::JSValue getExistingWrapper(JSDOMGlobalObject* globalObject, DOMClass* domObject)
return getCachedWrapper(globalObject->world(), domObject);
}
-template<class WrapperClass, class DOMClass> inline JSC::JSValue createNewWrapper(JSC::ExecState* exec, JSDOMGlobalObject* globalObject, DOMClass* domObject)
+template<class WrapperClass, class DOMClass> inline JSC::JSValue createNewWrapper(JSDOMGlobalObject* globalObject, DOMClass* domObject)
{
ASSERT(domObject);
ASSERT(!getCachedWrapper(globalObject->world(), domObject));
- return createWrapper<WrapperClass>(exec, globalObject, domObject);
+ return createWrapper<WrapperClass>(globalObject, domObject);
}
inline JSC::JSValue argumentOrNull(JSC::ExecState* exec, unsigned index)
}
if (document->isHTMLDocument())
- wrapper = CREATE_DOM_WRAPPER(exec, globalObject, HTMLDocument, document);
+ wrapper = CREATE_DOM_WRAPPER(globalObject, HTMLDocument, document);
else if (document->isSVGDocument())
- wrapper = CREATE_DOM_WRAPPER(exec, globalObject, SVGDocument, document);
+ wrapper = CREATE_DOM_WRAPPER(globalObject, SVGDocument, document);
else
- wrapper = CREATE_DOM_WRAPPER(exec, globalObject, Document, document);
+ wrapper = CREATE_DOM_WRAPPER(globalObject, Document, document);
// Make sure the document is kept around by the window object, and works right with the
// back/forward cache.
using namespace HTMLNames;
-JSValue toJSNewlyCreated(ExecState* exec, JSDOMGlobalObject* globalObject, Element* element)
+JSValue toJSNewlyCreated(ExecState*, JSDOMGlobalObject* globalObject, Element* element)
{
if (!element)
return jsNull();
JSDOMWrapper* wrapper;
if (element->isHTMLElement())
- wrapper = createJSHTMLWrapper(exec, globalObject, toHTMLElement(element));
+ wrapper = createJSHTMLWrapper(globalObject, toHTMLElement(element));
else if (element->isSVGElement())
- wrapper = createJSSVGWrapper(exec, globalObject, toSVGElement(element));
+ wrapper = createJSSVGWrapper(globalObject, toSVGElement(element));
else
- wrapper = CREATE_DOM_WRAPPER(exec, globalObject, Element, element);
+ wrapper = CREATE_DOM_WRAPPER(globalObject, Element, element);
return wrapper;
}
#define TRY_TO_WRAP_WITH_INTERFACE(interfaceName) \
case interfaceName##InterfaceType: \
- return CREATE_DOM_WRAPPER(exec, globalObject, interfaceName, event);
+ return CREATE_DOM_WRAPPER(globalObject, interfaceName, event);
-JSValue toJS(ExecState* exec, JSDOMGlobalObject* globalObject, Event* event)
+JSValue toJS(ExecState*, JSDOMGlobalObject* globalObject, Event* event)
{
- JSLockHolder lock(exec);
+ JSLockHolder lock(globalObject->vm());
if (!event)
return jsNull();
DOM_EVENT_INTERFACES_FOR_EACH(TRY_TO_WRAP_WITH_INTERFACE)
}
- return CREATE_DOM_WRAPPER(exec, globalObject, Event, event);
+ return CREATE_DOM_WRAPPER(globalObject, Event, event);
}
#undef TRY_TO_WRAP_WITH_INTERFACE
return JSValue::encode(toJS(exec, collection->globalObject(), collection->impl().namedItem(name)));
}
-JSValue toJS(ExecState* exec, JSDOMGlobalObject* globalObject, HTMLCollection* collection)
+JSValue toJS(ExecState*, JSDOMGlobalObject* globalObject, HTMLCollection* collection)
{
if (!collection)
return jsNull();
switch (collection->type()) {
case FormControls:
- return CREATE_DOM_WRAPPER(exec, globalObject, HTMLFormControlsCollection, collection);
+ return CREATE_DOM_WRAPPER(globalObject, HTMLFormControlsCollection, collection);
case SelectOptions:
- return CREATE_DOM_WRAPPER(exec, globalObject, HTMLOptionsCollection, collection);
+ return CREATE_DOM_WRAPPER(globalObject, HTMLOptionsCollection, collection);
case DocAll:
- return CREATE_DOM_WRAPPER(exec, globalObject, HTMLAllCollection, collection);
+ return CREATE_DOM_WRAPPER(globalObject, HTMLAllCollection, collection);
default:
break;
}
- return CREATE_DOM_WRAPPER(exec, globalObject, HTMLCollection, collection);
+ return CREATE_DOM_WRAPPER(globalObject, HTMLCollection, collection);
}
} // namespace WebCore
if (wrapper)
return wrapper;
- wrapper = CREATE_DOM_WRAPPER(exec, globalObject(), DocumentFragment, content);
+ wrapper = CREATE_DOM_WRAPPER(globalObject(), DocumentFragment, content);
PrivateName propertyName;
const_cast<JSHTMLTemplateElement*>(this)->putDirect(globalObject()->vm(), propertyName, wrapper);
return wrapper;
case IDBAny::IDBCursorType:
return toJS(exec, globalObject, idbAny->idbCursor());
case IDBAny::IDBCursorWithValueType:
- return wrap<JSIDBCursorWithValue>(exec, globalObject, idbAny->idbCursorWithValue().get());
+ return wrap<JSIDBCursorWithValue>(globalObject, idbAny->idbCursorWithValue().get());
case IDBAny::IDBDatabaseType:
return toJS(exec, globalObject, idbAny->idbDatabase());
case IDBAny::IDBFactoryType:
if (wrapper)
return wrapper;
- wrapper = CREATE_DOM_WRAPPER(exec, globalObject, ImageData, imageData);
+ wrapper = CREATE_DOM_WRAPPER(globalObject, ImageData, imageData);
Identifier dataName(exec, "data");
wrapper->putDirect(exec->vm(), dataName, toJS(exec, globalObject, imageData->data()), DontDelete | ReadOnly);
exec->heap()->reportExtraMemoryCost(imageData->data()->length());
return jsNull();
if (object->hasVideoSource())
- return wrap<JSAllVideoCapabilities>(exec, globalObject, static_cast<AllVideoCapabilities*>(object));
+ return wrap<JSAllVideoCapabilities>(globalObject, static_cast<AllVideoCapabilities*>(object));
- return wrap<JSAllAudioCapabilities>(exec, globalObject, static_cast<AllAudioCapabilities*>(object));
+ return wrap<JSAllAudioCapabilities>(globalObject, static_cast<AllAudioCapabilities*>(object));
}
} // namespace WebCore
switch (node->nodeType()) {
case Node::ELEMENT_NODE:
if (node->isHTMLElement())
- wrapper = createJSHTMLWrapper(exec, globalObject, toHTMLElement(node));
+ wrapper = createJSHTMLWrapper(globalObject, toHTMLElement(node));
else if (node->isSVGElement())
- wrapper = createJSSVGWrapper(exec, globalObject, toSVGElement(node));
+ wrapper = createJSSVGWrapper(globalObject, toSVGElement(node));
else
- wrapper = CREATE_DOM_WRAPPER(exec, globalObject, Element, node);
+ wrapper = CREATE_DOM_WRAPPER(globalObject, Element, node);
break;
case Node::ATTRIBUTE_NODE:
- wrapper = CREATE_DOM_WRAPPER(exec, globalObject, Attr, node);
+ wrapper = CREATE_DOM_WRAPPER(globalObject, Attr, node);
break;
case Node::TEXT_NODE:
- wrapper = CREATE_DOM_WRAPPER(exec, globalObject, Text, node);
+ wrapper = CREATE_DOM_WRAPPER(globalObject, Text, node);
break;
case Node::CDATA_SECTION_NODE:
- wrapper = CREATE_DOM_WRAPPER(exec, globalObject, CDATASection, node);
+ wrapper = CREATE_DOM_WRAPPER(globalObject, CDATASection, node);
break;
case Node::ENTITY_NODE:
- wrapper = CREATE_DOM_WRAPPER(exec, globalObject, Entity, node);
+ wrapper = CREATE_DOM_WRAPPER(globalObject, Entity, node);
break;
case Node::PROCESSING_INSTRUCTION_NODE:
- wrapper = CREATE_DOM_WRAPPER(exec, globalObject, ProcessingInstruction, node);
+ wrapper = CREATE_DOM_WRAPPER(globalObject, ProcessingInstruction, node);
break;
case Node::COMMENT_NODE:
- wrapper = CREATE_DOM_WRAPPER(exec, globalObject, Comment, node);
+ wrapper = CREATE_DOM_WRAPPER(globalObject, Comment, node);
break;
case Node::DOCUMENT_NODE:
// we don't want to cache the document itself in the per-document dictionary
return toJS(exec, globalObject, toDocument(node));
case Node::DOCUMENT_TYPE_NODE:
- wrapper = CREATE_DOM_WRAPPER(exec, globalObject, DocumentType, node);
+ wrapper = CREATE_DOM_WRAPPER(globalObject, DocumentType, node);
break;
case Node::NOTATION_NODE:
- wrapper = CREATE_DOM_WRAPPER(exec, globalObject, Notation, node);
+ wrapper = CREATE_DOM_WRAPPER(globalObject, Notation, node);
break;
case Node::DOCUMENT_FRAGMENT_NODE:
- wrapper = CREATE_DOM_WRAPPER(exec, globalObject, DocumentFragment, node);
+ wrapper = CREATE_DOM_WRAPPER(globalObject, DocumentFragment, node);
break;
case Node::ENTITY_REFERENCE_NODE:
- wrapper = CREATE_DOM_WRAPPER(exec, globalObject, EntityReference, node);
+ wrapper = CREATE_DOM_WRAPPER(globalObject, EntityReference, node);
break;
default:
- wrapper = CREATE_DOM_WRAPPER(exec, globalObject, Node, node);
+ wrapper = CREATE_DOM_WRAPPER(globalObject, Node, node);
}
return wrapper;
namespace WebCore {
-JSValue toJS(ExecState* exec, JSDOMGlobalObject* globalObject, PerformanceEntry* entry)
+JSValue toJS(ExecState*, JSDOMGlobalObject* globalObject, PerformanceEntry* entry)
{
if (!entry)
return jsNull();
#if ENABLE(RESOURCE_TIMING)
if (entry->isResource())
- return wrap<JSPerformanceResourceTiming>(exec, globalObject, static_cast<PerformanceResourceTiming*>(entry));
+ return wrap<JSPerformanceResourceTiming>(globalObject, static_cast<PerformanceResourceTiming*>(entry));
#endif
#if ENABLE(USER_TIMING)
if (entry->isMark())
- return wrap<JSPerformanceMark>(exec, globalObject, static_cast<PerformanceMark*>(entry));
+ return wrap<JSPerformanceMark>(globalObject, static_cast<PerformanceMark*>(entry));
if (entry->isMeasure())
- return wrap<JSPerformanceMeasure>(exec, globalObject, static_cast<PerformanceMeasure*>(entry));
+ return wrap<JSPerformanceMeasure>(globalObject, static_cast<PerformanceMeasure*>(entry));
#endif
- return wrap<JSPerformanceEntry>(exec, globalObject, entry);
+ return wrap<JSPerformanceEntry>(globalObject, entry);
}
} // namespace WebCore
return throwVMError(exec, createTypeError(exec, "Error creating RTCIceCandidate"));
}
- return JSValue::encode(CREATE_DOM_WRAPPER(exec, jsConstructor->globalObject(), RTCIceCandidate, iceCandidate.get()));
+ return JSValue::encode(CREATE_DOM_WRAPPER(jsConstructor->globalObject(), RTCIceCandidate, iceCandidate.get()));
}
} // namespace WebCore
return throwVMError(exec, createTypeError(exec, "Error creating RTCPeerConnection"));
}
- return JSValue::encode(CREATE_DOM_WRAPPER(exec, jsConstructor->globalObject(), RTCPeerConnection, peerConnection.get()));
+ return JSValue::encode(CREATE_DOM_WRAPPER(jsConstructor->globalObject(), RTCPeerConnection, peerConnection.get()));
}
} // namespace WebCore
return throwVMError(exec, createTypeError(exec, "Error creating RTCSessionDescription"));
}
- return JSValue::encode(CREATE_DOM_WRAPPER(exec, jsConstructor->globalObject(), RTCSessionDescription, sessionDescription.get()));
+ return JSValue::encode(CREATE_DOM_WRAPPER(jsConstructor->globalObject(), RTCSessionDescription, sessionDescription.get()));
}
} // namespace WebCore
namespace WebCore {
-JSValue toJS(ExecState* exec, JSDOMGlobalObject* globalObject, SVGPathSeg* object)
+JSValue toJS(ExecState*, JSDOMGlobalObject* globalObject, SVGPathSeg* object)
{
if (!object)
return jsNull();
switch (object->pathSegType()) {
case SVGPathSeg::PATHSEG_CLOSEPATH:
- return CREATE_DOM_WRAPPER(exec, globalObject, SVGPathSegClosePath, object);
+ return CREATE_DOM_WRAPPER(globalObject, SVGPathSegClosePath, object);
case SVGPathSeg::PATHSEG_MOVETO_ABS:
- return CREATE_DOM_WRAPPER(exec, globalObject, SVGPathSegMovetoAbs, object);
+ return CREATE_DOM_WRAPPER(globalObject, SVGPathSegMovetoAbs, object);
case SVGPathSeg::PATHSEG_MOVETO_REL:
- return CREATE_DOM_WRAPPER(exec, globalObject, SVGPathSegMovetoRel, object);
+ return CREATE_DOM_WRAPPER(globalObject, SVGPathSegMovetoRel, object);
case SVGPathSeg::PATHSEG_LINETO_ABS:
- return CREATE_DOM_WRAPPER(exec, globalObject, SVGPathSegLinetoAbs, object);
+ return CREATE_DOM_WRAPPER(globalObject, SVGPathSegLinetoAbs, object);
case SVGPathSeg::PATHSEG_LINETO_REL:
- return CREATE_DOM_WRAPPER(exec, globalObject, SVGPathSegLinetoRel, object);
+ return CREATE_DOM_WRAPPER(globalObject, SVGPathSegLinetoRel, object);
case SVGPathSeg::PATHSEG_CURVETO_CUBIC_ABS:
- return CREATE_DOM_WRAPPER(exec, globalObject, SVGPathSegCurvetoCubicAbs, object);
+ return CREATE_DOM_WRAPPER(globalObject, SVGPathSegCurvetoCubicAbs, object);
case SVGPathSeg::PATHSEG_CURVETO_CUBIC_REL:
- return CREATE_DOM_WRAPPER(exec, globalObject, SVGPathSegCurvetoCubicRel, object);
+ return CREATE_DOM_WRAPPER(globalObject, SVGPathSegCurvetoCubicRel, object);
case SVGPathSeg::PATHSEG_CURVETO_QUADRATIC_ABS:
- return CREATE_DOM_WRAPPER(exec, globalObject, SVGPathSegCurvetoQuadraticAbs, object);
+ return CREATE_DOM_WRAPPER(globalObject, SVGPathSegCurvetoQuadraticAbs, object);
case SVGPathSeg::PATHSEG_CURVETO_QUADRATIC_REL:
- return CREATE_DOM_WRAPPER(exec, globalObject, SVGPathSegCurvetoQuadraticRel, object);
+ return CREATE_DOM_WRAPPER(globalObject, SVGPathSegCurvetoQuadraticRel, object);
case SVGPathSeg::PATHSEG_ARC_ABS:
- return CREATE_DOM_WRAPPER(exec, globalObject, SVGPathSegArcAbs, object);
+ return CREATE_DOM_WRAPPER(globalObject, SVGPathSegArcAbs, object);
case SVGPathSeg::PATHSEG_ARC_REL:
- return CREATE_DOM_WRAPPER(exec, globalObject, SVGPathSegArcRel, object);
+ return CREATE_DOM_WRAPPER(globalObject, SVGPathSegArcRel, object);
case SVGPathSeg::PATHSEG_LINETO_HORIZONTAL_ABS:
- return CREATE_DOM_WRAPPER(exec, globalObject, SVGPathSegLinetoHorizontalAbs, object);
+ return CREATE_DOM_WRAPPER(globalObject, SVGPathSegLinetoHorizontalAbs, object);
case SVGPathSeg::PATHSEG_LINETO_HORIZONTAL_REL:
- return CREATE_DOM_WRAPPER(exec, globalObject, SVGPathSegLinetoHorizontalRel, object);
+ return CREATE_DOM_WRAPPER(globalObject, SVGPathSegLinetoHorizontalRel, object);
case SVGPathSeg::PATHSEG_LINETO_VERTICAL_ABS:
- return CREATE_DOM_WRAPPER(exec, globalObject, SVGPathSegLinetoVerticalAbs, object);
+ return CREATE_DOM_WRAPPER(globalObject, SVGPathSegLinetoVerticalAbs, object);
case SVGPathSeg::PATHSEG_LINETO_VERTICAL_REL:
- return CREATE_DOM_WRAPPER(exec, globalObject, SVGPathSegLinetoVerticalRel, object);
+ return CREATE_DOM_WRAPPER(globalObject, SVGPathSegLinetoVerticalRel, object);
case SVGPathSeg::PATHSEG_CURVETO_CUBIC_SMOOTH_ABS:
- return CREATE_DOM_WRAPPER(exec, globalObject, SVGPathSegCurvetoCubicSmoothAbs, object);
+ return CREATE_DOM_WRAPPER(globalObject, SVGPathSegCurvetoCubicSmoothAbs, object);
case SVGPathSeg::PATHSEG_CURVETO_CUBIC_SMOOTH_REL:
- return CREATE_DOM_WRAPPER(exec, globalObject, SVGPathSegCurvetoCubicSmoothRel, object);
+ return CREATE_DOM_WRAPPER(globalObject, SVGPathSegCurvetoCubicSmoothRel, object);
case SVGPathSeg::PATHSEG_CURVETO_QUADRATIC_SMOOTH_ABS:
- return CREATE_DOM_WRAPPER(exec, globalObject, SVGPathSegCurvetoQuadraticSmoothAbs, object);
+ return CREATE_DOM_WRAPPER(globalObject, SVGPathSegCurvetoQuadraticSmoothAbs, object);
case SVGPathSeg::PATHSEG_CURVETO_QUADRATIC_SMOOTH_REL:
- return CREATE_DOM_WRAPPER(exec, globalObject, SVGPathSegCurvetoQuadraticSmoothRel, object);
+ return CREATE_DOM_WRAPPER(globalObject, SVGPathSegCurvetoQuadraticSmoothRel, object);
case SVGPathSeg::PATHSEG_UNKNOWN:
default:
- return CREATE_DOM_WRAPPER(exec, globalObject, SVGPathSeg, object);
+ return CREATE_DOM_WRAPPER(globalObject, SVGPathSeg, object);
}
}
visitor.addOpaqueRoot(root(&thisObject->impl()));
}
-JSValue toJS(ExecState* exec, JSDOMGlobalObject* globalObject, StyleSheet* styleSheet)
+JSValue toJS(ExecState*, JSDOMGlobalObject* globalObject, StyleSheet* styleSheet)
{
if (!styleSheet)
return jsNull();
return wrapper;
if (styleSheet->isCSSStyleSheet())
- wrapper = CREATE_DOM_WRAPPER(exec, globalObject, CSSStyleSheet, styleSheet);
+ wrapper = CREATE_DOM_WRAPPER(globalObject, CSSStyleSheet, styleSheet);
else
- wrapper = CREATE_DOM_WRAPPER(exec, globalObject, StyleSheet, styleSheet);
+ wrapper = CREATE_DOM_WRAPPER(globalObject, StyleSheet, styleSheet);
return wrapper;
}
namespace WebCore {
-JSValue toJSNewlyCreated(ExecState* exec, JSDOMGlobalObject* globalObject, Text* text)
+JSValue toJSNewlyCreated(ExecState*, JSDOMGlobalObject* globalObject, Text* text)
{
if (!text)
return jsNull();
- return CREATE_DOM_WRAPPER(exec, globalObject, Text, text);
+ return CREATE_DOM_WRAPPER(globalObject, Text, text);
}
} // namespace WebCore
return visitor.containsOpaqueRoot(root(textTrackCue.track()));
}
-JSValue toJS(ExecState* exec, JSDOMGlobalObject* globalObject, TextTrackCue* cue)
+JSValue toJS(ExecState*, JSDOMGlobalObject* globalObject, TextTrackCue* cue)
{
if (!cue)
return jsNull();
// This switch will make more sense once we support DataCue
switch (cue->cueType()) {
case TextTrackCue::Data:
- return CREATE_DOM_WRAPPER(exec, globalObject, DataCue, cue);
+ return CREATE_DOM_WRAPPER(globalObject, DataCue, cue);
case TextTrackCue::WebVTT:
case TextTrackCue::Generic:
- return CREATE_DOM_WRAPPER(exec, globalObject, VTTCue, cue);
+ return CREATE_DOM_WRAPPER(globalObject, VTTCue, cue);
default:
ASSERT_NOT_REACHED();
return jsNull();
namespace WebCore {
-JSValue toJSNewlyCreated(ExecState* exec, JSDOMGlobalObject* globalObject, Touch* touch)
+JSValue toJSNewlyCreated(ExecState*, JSDOMGlobalObject* globalObject, Touch* touch)
{
if (!touch)
return jsNull();
- return CREATE_DOM_WRAPPER(exec, globalObject, Touch, touch);
+ return CREATE_DOM_WRAPPER(globalObject, Touch, touch);
}
} // namespace WebCore
namespace WebCore {
-JSValue toJSNewlyCreated(ExecState* exec, JSDOMGlobalObject* globalObject, TouchList* touchList)
+JSValue toJSNewlyCreated(ExecState*, JSDOMGlobalObject* globalObject, TouchList* touchList)
{
if (!touchList)
return jsNull();
- return CREATE_DOM_WRAPPER(exec, globalObject, TouchList, touchList);
+ return CREATE_DOM_WRAPPER(globalObject, TouchList, touchList);
}
} // namespace WebCore
return 0;
}
-JSC::JSValue toJS(JSC::ExecState* exec, JSDOMGlobalObject* globalObject, TrackBase* track)
+JSC::JSValue toJS(JSC::ExecState*, JSDOMGlobalObject* globalObject, TrackBase* track)
{
if (!track)
return jsNull();
break;
case TrackBase::AudioTrack:
- return CREATE_DOM_WRAPPER(exec, globalObject, AudioTrack, track);
+ return CREATE_DOM_WRAPPER(globalObject, AudioTrack, track);
case TrackBase::VideoTrack:
- return CREATE_DOM_WRAPPER(exec, globalObject, VideoTrack, track);
+ return CREATE_DOM_WRAPPER(globalObject, VideoTrack, track);
case TrackBase::TextTrack:
- return CREATE_DOM_WRAPPER(exec, globalObject, TextTrack, track);
+ return CREATE_DOM_WRAPPER(globalObject, TextTrack, track);
}
return jsNull();
#endif
END
- push(@implContent, "JSC::JSValue toJS(JSC::ExecState* exec, JSDOMGlobalObject* globalObject, $implType* impl)\n");
+ push(@implContent, "JSC::JSValue toJS(JSC::ExecState*, JSDOMGlobalObject* globalObject, $implType* impl)\n");
push(@implContent, "{\n");
push(@implContent, <<END);
if (!impl)
#endif
END
push(@implContent, <<END) if $interface->extendedAttributes->{"ReportExtraMemoryCost"};
- exec->heap()->reportExtraMemoryCost(impl->memoryCost());
+ globalObject->vm().heap.reportExtraMemoryCost(impl->memoryCost());
END
if ($svgPropertyType) {
- push(@implContent, " return createNewWrapper<$className, $implType>(exec, globalObject, impl);\n");
+ push(@implContent, " return createNewWrapper<$className, $implType>(globalObject, impl);\n");
} else {
- push(@implContent, " return createNewWrapper<$className>(exec, globalObject, impl);\n");
+ push(@implContent, " return createNewWrapper<$className>(globalObject, impl);\n");
}
push(@implContent, "}\n\n");
extern "C" { extern void* _ZTVN7WebCore19TestActiveDOMObjectE[]; }
#endif
#endif
-JSC::JSValue toJS(JSC::ExecState* exec, JSDOMGlobalObject* globalObject, TestActiveDOMObject* impl)
+JSC::JSValue toJS(JSC::ExecState*, JSDOMGlobalObject* globalObject, TestActiveDOMObject* impl)
{
if (!impl)
return jsNull();
// by adding the SkipVTableValidation attribute to the interface IDL definition
RELEASE_ASSERT(actualVTablePointer == expectedVTablePointer);
#endif
- return createNewWrapper<JSTestActiveDOMObject>(exec, globalObject, impl);
+ return createNewWrapper<JSTestActiveDOMObject>(globalObject, impl);
}
TestActiveDOMObject* toTestActiveDOMObject(JSC::JSValue value)
extern "C" { extern void* _ZTVN7WebCore21TestCustomNamedGetterE[]; }
#endif
#endif
-JSC::JSValue toJS(JSC::ExecState* exec, JSDOMGlobalObject* globalObject, TestCustomNamedGetter* impl)
+JSC::JSValue toJS(JSC::ExecState*, JSDOMGlobalObject* globalObject, TestCustomNamedGetter* impl)
{
if (!impl)
return jsNull();
// by adding the SkipVTableValidation attribute to the interface IDL definition
RELEASE_ASSERT(actualVTablePointer == expectedVTablePointer);
#endif
- return createNewWrapper<JSTestCustomNamedGetter>(exec, globalObject, impl);
+ return createNewWrapper<JSTestCustomNamedGetter>(globalObject, impl);
}
TestCustomNamedGetter* toTestCustomNamedGetter(JSC::JSValue value)
extern "C" { extern void* _ZTVN7WebCore20TestEventConstructorE[]; }
#endif
#endif
-JSC::JSValue toJS(JSC::ExecState* exec, JSDOMGlobalObject* globalObject, TestEventConstructor* impl)
+JSC::JSValue toJS(JSC::ExecState*, JSDOMGlobalObject* globalObject, TestEventConstructor* impl)
{
if (!impl)
return jsNull();
// by adding the SkipVTableValidation attribute to the interface IDL definition
RELEASE_ASSERT(actualVTablePointer == expectedVTablePointer);
#endif
- return createNewWrapper<JSTestEventConstructor>(exec, globalObject, impl);
+ return createNewWrapper<JSTestEventConstructor>(globalObject, impl);
}
TestEventConstructor* toTestEventConstructor(JSC::JSValue value)
extern "C" { extern void* _ZTVN7WebCore15TestEventTargetE[]; }
#endif
#endif
-JSC::JSValue toJS(JSC::ExecState* exec, JSDOMGlobalObject* globalObject, TestEventTarget* impl)
+JSC::JSValue toJS(JSC::ExecState*, JSDOMGlobalObject* globalObject, TestEventTarget* impl)
{
if (!impl)
return jsNull();
// by adding the SkipVTableValidation attribute to the interface IDL definition
RELEASE_ASSERT(actualVTablePointer == expectedVTablePointer);
#endif
- return createNewWrapper<JSTestEventTarget>(exec, globalObject, impl);
+ return createNewWrapper<JSTestEventTarget>(globalObject, impl);
}
TestEventTarget* toTestEventTarget(JSC::JSValue value)
extern "C" { extern void* _ZTVN7WebCore13TestExceptionE[]; }
#endif
#endif
-JSC::JSValue toJS(JSC::ExecState* exec, JSDOMGlobalObject* globalObject, TestException* impl)
+JSC::JSValue toJS(JSC::ExecState*, JSDOMGlobalObject* globalObject, TestException* impl)
{
if (!impl)
return jsNull();
// by adding the SkipVTableValidation attribute to the interface IDL definition
RELEASE_ASSERT(actualVTablePointer == expectedVTablePointer);
#endif
- return createNewWrapper<JSTestException>(exec, globalObject, impl);
+ return createNewWrapper<JSTestException>(globalObject, impl);
}
TestException* toTestException(JSC::JSValue value)
extern "C" { extern void* _ZTVN7WebCore23TestGenerateIsReachableE[]; }
#endif
#endif
-JSC::JSValue toJS(JSC::ExecState* exec, JSDOMGlobalObject* globalObject, TestGenerateIsReachable* impl)
+JSC::JSValue toJS(JSC::ExecState*, JSDOMGlobalObject* globalObject, TestGenerateIsReachable* impl)
{
if (!impl)
return jsNull();
// by adding the SkipVTableValidation attribute to the interface IDL definition
RELEASE_ASSERT(actualVTablePointer == expectedVTablePointer);
#endif
- return createNewWrapper<JSTestGenerateIsReachable>(exec, globalObject, impl);
+ return createNewWrapper<JSTestGenerateIsReachable>(globalObject, impl);
}
TestGenerateIsReachable* toTestGenerateIsReachable(JSC::JSValue value)
jsTestInterface->releaseImpl();
}
-JSC::JSValue toJS(JSC::ExecState* exec, JSDOMGlobalObject* globalObject, TestInterface* impl)
+JSC::JSValue toJS(JSC::ExecState*, JSDOMGlobalObject* globalObject, TestInterface* impl)
{
if (!impl)
return jsNull();
// attribute to TestInterface.
COMPILE_ASSERT(!__is_polymorphic(TestInterface), TestInterface_is_polymorphic_but_idl_claims_not_to_be);
#endif
- return createNewWrapper<JSTestInterface>(exec, globalObject, impl);
+ return createNewWrapper<JSTestInterface>(globalObject, impl);
}
TestInterface* toTestInterface(JSC::JSValue value)
extern "C" { extern void* _ZTVN7WebCore26TestMediaQueryListListenerE[]; }
#endif
#endif
-JSC::JSValue toJS(JSC::ExecState* exec, JSDOMGlobalObject* globalObject, TestMediaQueryListListener* impl)
+JSC::JSValue toJS(JSC::ExecState*, JSDOMGlobalObject* globalObject, TestMediaQueryListListener* impl)
{
if (!impl)
return jsNull();
// by adding the SkipVTableValidation attribute to the interface IDL definition
RELEASE_ASSERT(actualVTablePointer == expectedVTablePointer);
#endif
- return createNewWrapper<JSTestMediaQueryListListener>(exec, globalObject, impl);
+ return createNewWrapper<JSTestMediaQueryListListener>(globalObject, impl);
}
TestMediaQueryListListener* toTestMediaQueryListListener(JSC::JSValue value)
extern "C" { extern void* _ZTVN7WebCore20TestNamedConstructorE[]; }
#endif
#endif
-JSC::JSValue toJS(JSC::ExecState* exec, JSDOMGlobalObject* globalObject, TestNamedConstructor* impl)
+JSC::JSValue toJS(JSC::ExecState*, JSDOMGlobalObject* globalObject, TestNamedConstructor* impl)
{
if (!impl)
return jsNull();
// by adding the SkipVTableValidation attribute to the interface IDL definition
RELEASE_ASSERT(actualVTablePointer == expectedVTablePointer);
#endif
- return createNewWrapper<JSTestNamedConstructor>(exec, globalObject, impl);
+ return createNewWrapper<JSTestNamedConstructor>(globalObject, impl);
}
TestNamedConstructor* toTestNamedConstructor(JSC::JSValue value)
extern "C" { extern void* _ZTVN7WebCore7TestObjE[]; }
#endif
#endif
-JSC::JSValue toJS(JSC::ExecState* exec, JSDOMGlobalObject* globalObject, TestObj* impl)
+JSC::JSValue toJS(JSC::ExecState*, JSDOMGlobalObject* globalObject, TestObj* impl)
{
if (!impl)
return jsNull();
// by adding the SkipVTableValidation attribute to the interface IDL definition
RELEASE_ASSERT(actualVTablePointer == expectedVTablePointer);
#endif
- return createNewWrapper<JSTestObj>(exec, globalObject, impl);
+ return createNewWrapper<JSTestObj>(globalObject, impl);
}
TestObj* toTestObj(JSC::JSValue value)
extern "C" { extern void* _ZTVN7WebCore26TestOverloadedConstructorsE[]; }
#endif
#endif
-JSC::JSValue toJS(JSC::ExecState* exec, JSDOMGlobalObject* globalObject, TestOverloadedConstructors* impl)
+JSC::JSValue toJS(JSC::ExecState*, JSDOMGlobalObject* globalObject, TestOverloadedConstructors* impl)
{
if (!impl)
return jsNull();
// by adding the SkipVTableValidation attribute to the interface IDL definition
RELEASE_ASSERT(actualVTablePointer == expectedVTablePointer);
#endif
- return createNewWrapper<JSTestOverloadedConstructors>(exec, globalObject, impl);
+ return createNewWrapper<JSTestOverloadedConstructors>(globalObject, impl);
}
TestOverloadedConstructors* toTestOverloadedConstructors(JSC::JSValue value)
extern "C" { extern void* _ZTVN7WebCore34TestSerializedScriptValueInterfaceE[]; }
#endif
#endif
-JSC::JSValue toJS(JSC::ExecState* exec, JSDOMGlobalObject* globalObject, TestSerializedScriptValueInterface* impl)
+JSC::JSValue toJS(JSC::ExecState*, JSDOMGlobalObject* globalObject, TestSerializedScriptValueInterface* impl)
{
if (!impl)
return jsNull();
// by adding the SkipVTableValidation attribute to the interface IDL definition
RELEASE_ASSERT(actualVTablePointer == expectedVTablePointer);
#endif
- return createNewWrapper<JSTestSerializedScriptValueInterface>(exec, globalObject, impl);
+ return createNewWrapper<JSTestSerializedScriptValueInterface>(globalObject, impl);
}
TestSerializedScriptValueInterface* toTestSerializedScriptValueInterface(JSC::JSValue value)
extern "C" { extern void* _ZTVN7WebCore12TestTypedefsE[]; }
#endif
#endif
-JSC::JSValue toJS(JSC::ExecState* exec, JSDOMGlobalObject* globalObject, TestTypedefs* impl)
+JSC::JSValue toJS(JSC::ExecState*, JSDOMGlobalObject* globalObject, TestTypedefs* impl)
{
if (!impl)
return jsNull();
// by adding the SkipVTableValidation attribute to the interface IDL definition
RELEASE_ASSERT(actualVTablePointer == expectedVTablePointer);
#endif
- return createNewWrapper<JSTestTypedefs>(exec, globalObject, impl);
+ return createNewWrapper<JSTestTypedefs>(globalObject, impl);
}
TestTypedefs* toTestTypedefs(JSC::JSValue value)
extern "C" { extern void* _ZTVN7WebCore9attributeE[]; }
#endif
#endif
-JSC::JSValue toJS(JSC::ExecState* exec, JSDOMGlobalObject* globalObject, attribute* impl)
+JSC::JSValue toJS(JSC::ExecState*, JSDOMGlobalObject* globalObject, attribute* impl)
{
if (!impl)
return jsNull();
// by adding the SkipVTableValidation attribute to the interface IDL definition
RELEASE_ASSERT(actualVTablePointer == expectedVTablePointer);
#endif
- return createNewWrapper<JSattribute>(exec, globalObject, impl);
+ return createNewWrapper<JSattribute>(globalObject, impl);
}
attribute* toattribute(JSC::JSValue value)
jsreadonly->releaseImpl();
}
-JSC::JSValue toJS(JSC::ExecState* exec, JSDOMGlobalObject* globalObject, readonly* impl)
+JSC::JSValue toJS(JSC::ExecState*, JSDOMGlobalObject* globalObject, readonly* impl)
{
if (!impl)
return jsNull();
// attribute to readonly.
COMPILE_ASSERT(!__is_polymorphic(readonly), readonly_is_polymorphic_but_idl_claims_not_to_be);
#endif
- return createNewWrapper<JSreadonly>(exec, globalObject, impl);
+ return createNewWrapper<JSreadonly>(globalObject, impl);
}
readonly* toreadonly(JSC::JSValue value)
if ($enabledTags{$tagName}{wrapperOnlyIfMediaIsAvailable}) {
print F <<END
-static JSDOMWrapper* create${JSInterfaceName}Wrapper(ExecState* exec, JSDOMGlobalObject* globalObject, PassRefPtr<$parameters{namespace}Element> element)
+static JSDOMWrapper* create${JSInterfaceName}Wrapper(JSDOMGlobalObject* globalObject, PassRefPtr<$parameters{namespace}Element> element)
{
if (element->isHTMLUnknownElement())
- return CREATE_DOM_WRAPPER(exec, globalObject, $parameters{namespace}Element, element.get());
- return CREATE_DOM_WRAPPER(exec, globalObject, ${JSInterfaceName}, element.get());
+ return CREATE_DOM_WRAPPER(globalObject, $parameters{namespace}Element, element.get());
+ return CREATE_DOM_WRAPPER(globalObject, ${JSInterfaceName}, element.get());
}
END
} elsif ($enabledTags{$tagName}{runtimeConditional}) {
my $runtimeConditional = $enabledTags{$tagName}{runtimeConditional};
print F <<END
-static JSDOMWrapper* create${JSInterfaceName}Wrapper(ExecState* exec, JSDOMGlobalObject* globalObject, PassRefPtr<$parameters{namespace}Element> element)
+static JSDOMWrapper* create${JSInterfaceName}Wrapper(JSDOMGlobalObject* globalObject, PassRefPtr<$parameters{namespace}Element> element)
{
if (!RuntimeEnabledFeatures::sharedFeatures().${runtimeConditional}Enabled()) {
ASSERT(!element || element->is$parameters{fallbackInterfaceName}());
- return CREATE_DOM_WRAPPER(exec, globalObject, $parameters{fallbackJSInterfaceName}, element.get());
+ return CREATE_DOM_WRAPPER(globalObject, $parameters{fallbackJSInterfaceName}, element.get());
}
- return CREATE_DOM_WRAPPER(exec, globalObject, ${JSInterfaceName}, element.get());
+ return CREATE_DOM_WRAPPER(globalObject, ${JSInterfaceName}, element.get());
}
END
;
} else {
print F <<END
-static JSDOMWrapper* create${JSInterfaceName}Wrapper(ExecState* exec, JSDOMGlobalObject* globalObject, PassRefPtr<$parameters{namespace}Element> element)
+static JSDOMWrapper* create${JSInterfaceName}Wrapper(JSDOMGlobalObject* globalObject, PassRefPtr<$parameters{namespace}Element> element)
{
- return CREATE_DOM_WRAPPER(exec, globalObject, ${JSInterfaceName}, element.get());
+ return CREATE_DOM_WRAPPER(globalObject, ${JSInterfaceName}, element.get());
}
END
using namespace $parameters{namespace}Names;
-typedef JSDOMWrapper* (*Create$parameters{namespace}ElementWrapperFunction)(ExecState*, JSDOMGlobalObject*, PassRefPtr<$parameters{namespace}Element>);
+typedef JSDOMWrapper* (*Create$parameters{namespace}ElementWrapperFunction)(JSDOMGlobalObject*, PassRefPtr<$parameters{namespace}Element>);
END
;
map.add(table[i].name.localName().impl(), table[i].function);
}
-JSDOMWrapper* createJS$parameters{namespace}Wrapper(ExecState* exec, JSDOMGlobalObject* globalObject, PassRefPtr<$parameters{namespace}Element> element)
+JSDOMWrapper* createJS$parameters{namespace}Wrapper(JSDOMGlobalObject* globalObject, PassRefPtr<$parameters{namespace}Element> element)
{
static NeverDestroyed<HashMap<AtomicStringImpl*, Create$parameters{namespace}ElementWrapperFunction>> functions;
if (functions.get().isEmpty())
populate$parameters{namespace}WrapperMap(functions);
if (auto function = functions.get().get(element->localName().impl()))
- return function(exec, globalObject, element);
- return CREATE_DOM_WRAPPER(exec, globalObject, $parameters{fallbackJSInterfaceName}, element.get());
+ return function(globalObject, element);
+ return CREATE_DOM_WRAPPER(globalObject, $parameters{fallbackJSInterfaceName}, element.get());
}
}
print F <<END
#include <wtf/Forward.h>
-namespace JSC {
- class ExecState;
-}
-
namespace WebCore {
class JSDOMWrapper;
class JSDOMGlobalObject;
class $parameters{namespace}Element;
- JSDOMWrapper* createJS$parameters{namespace}Wrapper(JSC::ExecState*, JSDOMGlobalObject*, PassRefPtr<$parameters{namespace}Element>);
+ JSDOMWrapper* createJS$parameters{namespace}Wrapper(JSDOMGlobalObject*, PassRefPtr<$parameters{namespace}Element>);
}
selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
shouldUseLaunchSchemeArgsEnv = "YES"
- buildConfiguration = "Debug">
+ buildConfiguration = "Release">
<Testables>
</Testables>
</TestAction>
selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
launchStyle = "0"
useCustomWorkingDirectory = "NO"
- buildConfiguration = "Debug"
+ buildConfiguration = "Release"
ignoresPersistentStateOnLaunch = "YES"
debugDocumentVersioning = "YES"
allowLocationSimulation = "YES">
buildConfiguration = "Release"
revealArchiveInOrganizer = "YES">
</ArchiveAction>
+ <InstallAction
+ buildConfiguration = "Release">
+ </InstallAction>
</Scheme>