Removed all Webcore/DOM references; made it compile

phoboslab · phoboslab · commit 2695b7a2171d · 2012-12-08T03:38:49.000+01:00
diff --git a/JavaScriptCore/runtime/TypedArrays/JSArrayBuffer.cpp b/JavaScriptCore/runtime/TypedArrays/JSArrayBuffer.cpp
@@ -21,16 +21,23 @@
 #include "config.h"
 #include "JSArrayBuffer.h"
 
-#include "ExceptionCode.h"
 #include "JSArrayBuffer.h"
-#include "JSDOMBinding.h"
+#include "Lookup.h"
 #include <runtime/Error.h>
 #include <wtf/ArrayBuffer.h>
 #include <wtf/GetPtr.h>
 
 using namespace JSC;
 
-namespace WebCore {
+namespace JSC {
+
+enum ParameterDefaultPolicy {
+    DefaultIsUndefined,
+    DefaultIsNullString
+};
+
+#define MAYBE_MISSING_PARAMETER(exec, index, policy) (((policy) == DefaultIsNullString && (index) >= (exec)->argumentCount()) ? (JSValue()) : ((exec)->argument(index)))
+
 
 ASSERT_CLASS_FITS_IN_CELL(JSArrayBuffer);
 /* Hash table */
@@ -53,27 +60,28 @@ static const HashTableValue JSArrayBufferConstructorTableValues[] =
 static const HashTable JSArrayBufferConstructorTable = { 1, 0, JSArrayBufferConstructorTableValues, 0 };
 const ClassInfo JSArrayBufferConstructor::s_info = { "ArrayBufferConstructor", &Base::s_info, &JSArrayBufferConstructorTable, 0, CREATE_METHOD_TABLE(JSArrayBufferConstructor) };
 
-JSArrayBufferConstructor::JSArrayBufferConstructor(Structure* structure, JSDOMGlobalObject* globalObject)
-    : DOMConstructorObject(structure, globalObject)
+JSArrayBufferConstructor::JSArrayBufferConstructor(JSGlobalObject* globalObject, Structure* structure)
+    : InternalFunction(globalObject, structure)
 {
 }
 
-void JSArrayBufferConstructor::finishCreation(ExecState* exec, JSDOMGlobalObject* globalObject)
+void JSArrayBufferConstructor::finishCreation(ExecState* exec, JSGlobalObject* globalObject)
 {
-    Base::finishCreation(exec->globalData());
+	JSC::JSObject * proto = JSArrayBufferPrototype::self(exec, globalObject);
+    Base::finishCreation(exec->globalData(), Identifier(exec, proto->classInfo()->className));
     ASSERT(inherits(&s_info));
-    putDirect(exec->globalData(), exec->propertyNames().prototype, JSArrayBufferPrototype::self(exec, globalObject), DontDelete | ReadOnly);
+    putDirect(exec->globalData(), exec->propertyNames().prototype, proto, DontDelete | ReadOnly);
     putDirect(exec->globalData(), exec->propertyNames().length, jsNumber(1), ReadOnly | DontDelete | DontEnum);
 }
 
 bool JSArrayBufferConstructor::getOwnPropertySlot(JSCell* cell, ExecState* exec, const Identifier& propertyName, PropertySlot& slot)
 {
-    return getStaticValueSlot<JSArrayBufferConstructor, JSDOMWrapper>(exec, &JSArrayBufferConstructorTable, jsCast<JSArrayBufferConstructor*>(cell), propertyName, slot);
+    return getStaticFunctionSlot<InternalFunction>(exec, &JSArrayBufferConstructorTable, jsCast<JSArrayBufferConstructor*>(cell), propertyName, slot);
 }
 
 bool JSArrayBufferConstructor::getOwnPropertyDescriptor(JSObject* object, ExecState* exec, const Identifier& propertyName, PropertyDescriptor& descriptor)
 {
-    return getStaticValueDescriptor<JSArrayBufferConstructor, JSDOMWrapper>(exec, &JSArrayBufferConstructorTable, jsCast<JSArrayBufferConstructor*>(object), propertyName, descriptor);
+    return getStaticFunctionDescriptor<InternalFunction>(exec, &JSArrayBufferConstructorTable, jsCast<JSArrayBufferConstructor*>(object), propertyName, descriptor);
 }
 
 ConstructType JSArrayBufferConstructor::getConstructData(JSCell*, ConstructData& constructData)
@@ -93,14 +101,20 @@ static const HashTableValue JSArrayBufferPrototypeTableValues[] =
 static const HashTable JSArrayBufferPrototypeTable = { 2, 1, JSArrayBufferPrototypeTableValues, 0 };
 static const HashTable* getJSArrayBufferPrototypeTable(ExecState* exec)
 {
-    return getHashTableForGlobalData(exec->globalData(), &JSArrayBufferPrototypeTable);
+	ASSERT_UNUSED(exec, exec);
+	return &JSArrayBufferPrototypeTable; // PL FIXME: should be one instance per global data, not super global
 }
 
 const ClassInfo JSArrayBufferPrototype::s_info = { "ArrayBufferPrototype", &Base::s_info, 0, getJSArrayBufferPrototypeTable, CREATE_METHOD_TABLE(JSArrayBufferPrototype) };
 
+static JSObject * globalProto = NULL;
 JSObject* JSArrayBufferPrototype::self(ExecState* exec, JSGlobalObject* globalObject)
 {
-    return getDOMPrototype<JSArrayBuffer>(exec, globalObject);
+	// PL FIXME: dirty hack to provide one global prototype
+	if( !globalProto ) {
+		globalProto = JSArrayBuffer::createPrototype(exec, globalObject);
+	}
+	return globalProto;
 }
 
 bool JSArrayBufferPrototype::getOwnPropertySlot(JSCell* cell, ExecState* exec, const Identifier& propertyName, PropertySlot& slot)
@@ -117,13 +131,14 @@ bool JSArrayBufferPrototype::getOwnPropertyDescriptor(JSObject* object, ExecStat
 
 static const HashTable* getJSArrayBufferTable(ExecState* exec)
 {
-    return getHashTableForGlobalData(exec->globalData(), &JSArrayBufferTable);
+	ASSERT_UNUSED(exec, exec);
+	return &JSArrayBufferTable;
 }
 
 const ClassInfo JSArrayBuffer::s_info = { "ArrayBuffer", &Base::s_info, 0, getJSArrayBufferTable , CREATE_METHOD_TABLE(JSArrayBuffer) };
 
-JSArrayBuffer::JSArrayBuffer(Structure* structure, JSDOMGlobalObject* globalObject, PassRefPtr<ArrayBuffer> impl)
-    : JSDOMWrapper(structure, globalObject)
+JSArrayBuffer::JSArrayBuffer(Structure* structure, JSGlobalObject* globalObject, PassRefPtr<ArrayBuffer> impl)
+    : JSNonFinalObject(globalObject->globalData(), structure)
     , m_impl(impl.leakRef())
 {
 }
@@ -180,9 +195,14 @@ JSValue jsArrayBufferConstructor(ExecState* exec, JSValue slotBase, const Identi
     return JSArrayBuffer::getConstructor(exec, domObject->globalObject());
 }
 
+static JSObject * globalConstructor;
 JSValue JSArrayBuffer::getConstructor(ExecState* exec, JSGlobalObject* globalObject)
 {
-    return getDOMConstructor<JSArrayBufferConstructor>(exec, jsCast<JSDOMGlobalObject*>(globalObject));
+	if( !globalConstructor ) {
+		JSArrayBufferConstructor * constructor = JSArrayBufferConstructor::create(exec, JSArrayBufferConstructor::createStructure(exec->globalData(), globalObject, globalObject->objectPrototype()), globalObject);
+		globalConstructor = constructor;
+	}
+	return globalConstructor;
 }
 
 EncodedJSValue JSC_HOST_CALL jsArrayBufferPrototypeFunctionSlice(ExecState* exec)
@@ -232,15 +252,16 @@ bool JSArrayBufferOwner::isReachableFromOpaqueRoots(JSC::Handle<JSC::Unknown> ha
 
 void JSArrayBufferOwner::finalize(JSC::Handle<JSC::Unknown> handle, void* context)
 {
+	ASSERT_UNUSED(context, context);
     JSArrayBuffer* jsArrayBuffer = jsCast<JSArrayBuffer*>(handle.get().asCell());
-    DOMWrapperWorld* world = static_cast<DOMWrapperWorld*>(context);
-    uncacheWrapper(world, jsArrayBuffer->impl(), jsArrayBuffer);
     jsArrayBuffer->releaseImpl();
 }
 
-JSC::JSValue toJS(JSC::ExecState* exec, JSDOMGlobalObject* globalObject, ArrayBuffer* impl)
+JSC::JSValue toJS(JSC::ExecState* exec, JSGlobalObject* globalObject, ArrayBuffer* impl)
 {
-    return wrap<JSArrayBuffer>(exec, globalObject, impl);
+	JSArrayBuffer * buf = JSArrayBuffer::create( JSArrayBuffer::createStructure(exec->globalData(), globalObject, JSArrayBufferPrototype::self(exec, globalObject)), globalObject, impl);
+	JSC::JSCell* jsCell = reinterpret_cast<JSC::JSCell*>(buf);
+	return jsCell;
 }
 
 ArrayBuffer* toArrayBuffer(JSC::JSValue value)
diff --git a/JavaScriptCore/runtime/TypedArrays/JSArrayBuffer.h b/JavaScriptCore/runtime/TypedArrays/JSArrayBuffer.h
@@ -21,18 +21,20 @@
 #ifndef JSArrayBuffer_h
 #define JSArrayBuffer_h
 
-#include "JSDOMBinding.h"
+#include "JSObject.h"
+#include "InternalFunction.h"
+
 #include <runtime/JSGlobalObject.h>
 #include <runtime/JSObject.h>
 #include <runtime/ObjectPrototype.h>
 #include <wtf/ArrayBuffer.h>
 
-namespace WebCore {
+namespace JSC {
 
-class JSArrayBuffer : public JSDOMWrapper {
+class JSArrayBuffer : public JSNonFinalObject {
 public:
-    typedef JSDOMWrapper Base;
-    static JSArrayBuffer* create(JSC::Structure* structure, JSDOMGlobalObject* globalObject, PassRefPtr<ArrayBuffer> impl)
+    typedef JSNonFinalObject Base;
+    static JSArrayBuffer* create(JSC::Structure* structure, JSGlobalObject* globalObject, PassRefPtr<ArrayBuffer> impl)
     {
         JSArrayBuffer* ptr = new (NotNull, JSC::allocateCell<JSArrayBuffer>(globalObject->globalData().heap)) JSArrayBuffer(structure, globalObject, impl);
         ptr->finishCreation(globalObject->globalData());
@@ -60,7 +62,7 @@ class JSArrayBuffer : public JSDOMWrapper {
 private:
     ArrayBuffer* m_impl;
 protected:
-    JSArrayBuffer(JSC::Structure*, JSDOMGlobalObject*, PassRefPtr<ArrayBuffer>);
+    JSArrayBuffer(JSC::Structure*, JSGlobalObject*, PassRefPtr<ArrayBuffer>);
     void finishCreation(JSC::JSGlobalData&);
     static const unsigned StructureFlags = JSC::OverridesGetOwnPropertySlot | Base::StructureFlags;
 };
@@ -70,6 +72,7 @@ class JSArrayBufferOwner : public JSC::WeakHandleOwner {
     virtual void finalize(JSC::Handle<JSC::Unknown>, void* context);
 };
 
+/*
 inline JSC::WeakHandleOwner* wrapperOwner(DOMWrapperWorld*, ArrayBuffer*)
 {
     DEFINE_STATIC_LOCAL(JSArrayBufferOwner, jsArrayBufferOwner, ());
@@ -80,8 +83,9 @@ inline void* wrapperContext(DOMWrapperWorld* world, ArrayBuffer*)
 {
     return world;
 }
+*/
 
-JSC::JSValue toJS(JSC::ExecState*, JSDOMGlobalObject*, ArrayBuffer*);
+JSC::JSValue toJS(JSC::ExecState*, JSGlobalObject*, ArrayBuffer*);
 ArrayBuffer* toArrayBuffer(JSC::JSValue);
 
 class JSArrayBufferPrototype : public JSC::JSNonFinalObject {
@@ -109,16 +113,16 @@ class JSArrayBufferPrototype : public JSC::JSNonFinalObject {
     static const unsigned StructureFlags = JSC::OverridesGetOwnPropertySlot | Base::StructureFlags;
 };
 
-class JSArrayBufferConstructor : public DOMConstructorObject {
+class JSArrayBufferConstructor : public InternalFunction {
 private:
-    JSArrayBufferConstructor(JSC::Structure*, JSDOMGlobalObject*);
-    void finishCreation(JSC::ExecState*, JSDOMGlobalObject*);
+	JSArrayBufferConstructor(JSGlobalObject* globalObject, Structure* structure);
+    void finishCreation(JSC::ExecState*, JSGlobalObject*);
 
 public:
-    typedef DOMConstructorObject Base;
-    static JSArrayBufferConstructor* create(JSC::ExecState* exec, JSC::Structure* structure, JSDOMGlobalObject* globalObject)
+    typedef InternalFunction Base;
+    static JSArrayBufferConstructor* create(JSC::ExecState* exec, JSC::Structure* structure, JSGlobalObject* globalObject)
     {
-        JSArrayBufferConstructor* ptr = new (NotNull, JSC::allocateCell<JSArrayBufferConstructor>(*exec->heap())) JSArrayBufferConstructor(structure, globalObject);
+        JSArrayBufferConstructor* ptr = new (NotNull, JSC::allocateCell<JSArrayBufferConstructor>(*exec->heap())) JSArrayBufferConstructor(globalObject, structure);
         ptr->finishCreation(exec, globalObject);
         return ptr;
     }
@@ -131,7 +135,7 @@ class JSArrayBufferConstructor : public DOMConstructorObject {
         return JSC::Structure::create(globalData, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), &s_info);
     }
 protected:
-    static const unsigned StructureFlags = JSC::OverridesGetOwnPropertySlot | JSC::ImplementsHasInstance | DOMConstructorObject::StructureFlags;
+    static const unsigned StructureFlags = JSC::OverridesGetOwnPropertySlot | JSC::ImplementsHasInstance | InternalFunction::StructureFlags;
     static JSC::EncodedJSValue JSC_HOST_CALL constructJSArrayBuffer(JSC::ExecState*);
     static JSC::ConstructType getConstructData(JSC::JSCell*, JSC::ConstructData&);
 };
diff --git a/JavaScriptCore/runtime/TypedArrays/JSArrayBufferCustom.cpp b/JavaScriptCore/runtime/TypedArrays/JSArrayBufferCustom.cpp
@@ -26,13 +26,10 @@
 #include "config.h"
 #include "JSArrayBuffer.h"
 
-#include "ExceptionCode.h"
 #include <runtime/Error.h>
 #include <wtf/ArrayBuffer.h>
 
-namespace WebCore {
-
-using namespace JSC;
+namespace JSC {
 
 EncodedJSValue JSC_HOST_CALL JSArrayBufferConstructor::constructJSArrayBuffer(ExecState* exec)
 {
diff --git a/JavaScriptCore/runtime/TypedArrays/JSArrayBufferView.cpp b/JavaScriptCore/runtime/TypedArrays/JSArrayBufferView.cpp
@@ -21,14 +21,15 @@
 #include "config.h"
 #include "JSArrayBufferView.h"
 
+#include "Lookup.h"
 #include "JSArrayBuffer.h"
 #include <wtf/ArrayBuffer.h>
 #include <wtf/ArrayBufferView.h>
 #include <wtf/GetPtr.h>
 
 using namespace JSC;
 
-namespace WebCore {
+namespace JSC {
 
 ASSERT_CLASS_FITS_IN_CELL(JSArrayBufferView);
 /* Hash table */
@@ -52,25 +53,36 @@ static const HashTableValue JSArrayBufferViewPrototypeTableValues[] =
 static const HashTable JSArrayBufferViewPrototypeTable = { 1, 0, JSArrayBufferViewPrototypeTableValues, 0 };
 static const HashTable* getJSArrayBufferViewPrototypeTable(ExecState* exec)
 {
-    return getHashTableForGlobalData(exec->globalData(), &JSArrayBufferViewPrototypeTable);
+	ASSERT_UNUSED(exec, exec);
+	return &JSArrayBufferViewPrototypeTable; // PL FIXME: should be one instance per global data, not super global
 }
 
 const ClassInfo JSArrayBufferViewPrototype::s_info = { "ArrayBufferViewPrototype", &Base::s_info, 0, getJSArrayBufferViewPrototypeTable, CREATE_METHOD_TABLE(JSArrayBufferViewPrototype) };
 
+
+static JSObject * globalProto = NULL;
 JSObject* JSArrayBufferViewPrototype::self(ExecState* exec, JSGlobalObject* globalObject)
 {
-    return getDOMPrototype<JSArrayBufferView>(exec, globalObject);
+	// PL FIXME: dirty hack to provide one global prototype
+	if( !globalProto ) {
+		JSGlobalData &data = exec->globalData();
+			globalProto = JSArrayBufferViewPrototype::create(data, globalObject,
+				JSArrayBufferViewPrototype::createStructure(data, globalObject,
+					globalObject->objectPrototype()));
+	}
+	return globalProto;
 }
 
 static const HashTable* getJSArrayBufferViewTable(ExecState* exec)
 {
-    return getHashTableForGlobalData(exec->globalData(), &JSArrayBufferViewTable);
+	ASSERT_UNUSED(exec, exec);
+	return &JSArrayBufferViewTable;
 }
 
 const ClassInfo JSArrayBufferView::s_info = { "ArrayBufferView", &Base::s_info, 0, getJSArrayBufferViewTable , CREATE_METHOD_TABLE(JSArrayBufferView) };
 
-JSArrayBufferView::JSArrayBufferView(Structure* structure, JSDOMGlobalObject* globalObject, PassRefPtr<ArrayBufferView> impl)
-    : JSDOMWrapper(structure, globalObject)
+JSArrayBufferView::JSArrayBufferView(Structure* structure, JSGlobalObject* globalObject, PassRefPtr<ArrayBufferView> impl)
+    : JSNonFinalObject(globalObject->globalData(), structure)
     , m_impl(impl.leakRef())
 {
 }
@@ -159,9 +171,8 @@ bool JSArrayBufferViewOwner::isReachableFromOpaqueRoots(JSC::Handle<JSC::Unknown
 
 void JSArrayBufferViewOwner::finalize(JSC::Handle<JSC::Unknown> handle, void* context)
 {
+	ASSERT_UNUSED(context, context);
     JSArrayBufferView* jsArrayBufferView = jsCast<JSArrayBufferView*>(handle.get().asCell());
-    DOMWrapperWorld* world = static_cast<DOMWrapperWorld*>(context);
-    uncacheWrapper(world, jsArrayBufferView->impl(), jsArrayBufferView);
     jsArrayBufferView->releaseImpl();
 }
 
diff --git a/JavaScriptCore/runtime/TypedArrays/JSArrayBufferView.h b/JavaScriptCore/runtime/TypedArrays/JSArrayBufferView.h
@@ -21,18 +21,17 @@
 #ifndef JSArrayBufferView_h
 #define JSArrayBufferView_h
 
-#include "JSDOMBinding.h"
 #include <runtime/JSGlobalObject.h>
 #include <runtime/JSObject.h>
 #include <runtime/ObjectPrototype.h>
 #include <wtf/ArrayBufferView.h>
 
-namespace WebCore {
+namespace JSC {
 
-class JSArrayBufferView : public JSDOMWrapper {
+class JSArrayBufferView : public JSNonFinalObject {
 public:
-    typedef JSDOMWrapper Base;
-    static JSArrayBufferView* create(JSC::Structure* structure, JSDOMGlobalObject* globalObject, PassRefPtr<ArrayBufferView> impl)
+    typedef JSNonFinalObject Base;
+    static JSArrayBufferView* create(JSC::Structure* structure, JSGlobalObject* globalObject, PassRefPtr<ArrayBufferView> impl)
     {
         JSArrayBufferView* ptr = new (NotNull, JSC::allocateCell<JSArrayBufferView>(globalObject->globalData().heap)) JSArrayBufferView(structure, globalObject, impl);
         ptr->finishCreation(globalObject->globalData());
@@ -59,7 +58,7 @@ class JSArrayBufferView : public JSDOMWrapper {
 private:
     ArrayBufferView* m_impl;
 protected:
-    JSArrayBufferView(JSC::Structure*, JSDOMGlobalObject*, PassRefPtr<ArrayBufferView>);
+    JSArrayBufferView(JSC::Structure*, JSGlobalObject*, PassRefPtr<ArrayBufferView>);
     void finishCreation(JSC::JSGlobalData&);
     static const unsigned StructureFlags = JSC::OverridesGetOwnPropertySlot | Base::StructureFlags;
 };
@@ -69,18 +68,21 @@ class JSArrayBufferViewOwner : public JSC::WeakHandleOwner {
     virtual void finalize(JSC::Handle<JSC::Unknown>, void* context);
 };
 
+/*
 inline JSC::WeakHandleOwner* wrapperOwner(DOMWrapperWorld*, ArrayBufferView*)
 {
     DEFINE_STATIC_LOCAL(JSArrayBufferViewOwner, jsArrayBufferViewOwner, ());
     return &jsArrayBufferViewOwner;
 }
 
+
 inline void* wrapperContext(DOMWrapperWorld* world, ArrayBufferView*)
 {
     return world;
 }
+*/
 
-JSC::JSValue toJS(JSC::ExecState*, JSDOMGlobalObject*, ArrayBufferView*);
+JSC::JSValue toJS(JSC::ExecState*, JSGlobalObject*, ArrayBufferView*);
 ArrayBufferView* toArrayBufferView(JSC::JSValue);
 
 class JSArrayBufferViewPrototype : public JSC::JSNonFinalObject {
diff --git a/JavaScriptCore/runtime/TypedArrays/JSArrayBufferViewHelper.h b/JavaScriptCore/runtime/TypedArrays/JSArrayBufferViewHelper.h
@@ -37,7 +37,7 @@
 #include <runtime/JSValue.h>
 #include <wtf/ArrayBufferView.h>
 
-namespace WebCore {
+namespace JSC {
 
 template <class T>
 JSC::JSValue setWebGLArrayHelper(JSC::ExecState* exec, T* impl, T* (*conversionFunc)(JSC::JSValue))

Original file line number	Diff line number	Diff line change
`@@ -21,16 +21,23 @@`
`21`	`21`	`#include "config.h"`
`22`	`22`	`#include "JSArrayBuffer.h"`
`23`	`23`
`24`		`-#include "ExceptionCode.h"`
`25`	`24`	`#include "JSArrayBuffer.h"`
`26`		`-#include "JSDOMBinding.h"`
	`25`	`+#include "Lookup.h"`
`27`	`26`	`#include <runtime/Error.h>`
`28`	`27`	`#include <wtf/ArrayBuffer.h>`
`29`	`28`	`#include <wtf/GetPtr.h>`
`30`	`29`
`31`	`30`	`using namespace JSC;`
`32`	`31`
`33`		`-namespace WebCore {`
	`32`	`+namespace JSC {`
	`33`	`+`
	`34`	`+enum ParameterDefaultPolicy {`
	`35`	`+ DefaultIsUndefined,`
	`36`	`+ DefaultIsNullString`
	`37`	`+};`
	`38`	`+`
	`39`	`+#define MAYBE_MISSING_PARAMETER(exec, index, policy) (((policy) == DefaultIsNullString && (index) >= (exec)->argumentCount()) ? (JSValue()) : ((exec)->argument(index)))`
	`40`	`+`
`34`	`41`
`35`	`42`	`ASSERT_CLASS_FITS_IN_CELL(JSArrayBuffer);`
`36`	`43`	`/* Hash table */`
`@@ -53,27 +60,28 @@ static const HashTableValue JSArrayBufferConstructorTableValues[] =`
`53`	`60`	`static const HashTable JSArrayBufferConstructorTable = { 1, 0, JSArrayBufferConstructorTableValues, 0 };`
`54`	`61`	`const ClassInfo JSArrayBufferConstructor::s_info = { "ArrayBufferConstructor", &Base::s_info, &JSArrayBufferConstructorTable, 0, CREATE_METHOD_TABLE(JSArrayBufferConstructor) };`
`55`	`62`
`56`		`-JSArrayBufferConstructor::JSArrayBufferConstructor(Structure* structure, JSDOMGlobalObject* globalObject)`
`57`		`- : DOMConstructorObject(structure, globalObject)`
	`63`	`+JSArrayBufferConstructor::JSArrayBufferConstructor(JSGlobalObject* globalObject, Structure* structure)`
	`64`	`+ : InternalFunction(globalObject, structure)`
`58`	`65`	`{`
`59`	`66`	`}`
`60`	`67`
`61`		`-void JSArrayBufferConstructor::finishCreation(ExecState* exec, JSDOMGlobalObject* globalObject)`
	`68`	`+void JSArrayBufferConstructor::finishCreation(ExecState* exec, JSGlobalObject* globalObject)`
`62`	`69`	`{`
`63`		`- Base::finishCreation(exec->globalData());`
	`70`	`+ JSC::JSObject * proto = JSArrayBufferPrototype::self(exec, globalObject);`
	`71`	`+ Base::finishCreation(exec->globalData(), Identifier(exec, proto->classInfo()->className));`
`64`	`72`	`ASSERT(inherits(&s_info));`
`65`		`- putDirect(exec->globalData(), exec->propertyNames().prototype, JSArrayBufferPrototype::self(exec, globalObject), DontDelete \| ReadOnly);`
	`73`	`+ putDirect(exec->globalData(), exec->propertyNames().prototype, proto, DontDelete \| ReadOnly);`
`66`	`74`	`putDirect(exec->globalData(), exec->propertyNames().length, jsNumber(1), ReadOnly \| DontDelete \| DontEnum);`
`67`	`75`	`}`
`68`	`76`
`69`	`77`	`bool JSArrayBufferConstructor::getOwnPropertySlot(JSCell* cell, ExecState* exec, const Identifier& propertyName, PropertySlot& slot)`
`70`	`78`	`{`
`71`		`- return getStaticValueSlot<JSArrayBufferConstructor, JSDOMWrapper>(exec, &JSArrayBufferConstructorTable, jsCast<JSArrayBufferConstructor*>(cell), propertyName, slot);`
	`79`	`+ return getStaticFunctionSlot<InternalFunction>(exec, &JSArrayBufferConstructorTable, jsCast<JSArrayBufferConstructor*>(cell), propertyName, slot);`
`72`	`80`	`}`
`73`	`81`
`74`	`82`	`bool JSArrayBufferConstructor::getOwnPropertyDescriptor(JSObject* object, ExecState* exec, const Identifier& propertyName, PropertyDescriptor& descriptor)`
`75`	`83`	`{`
`76`		`- return getStaticValueDescriptor<JSArrayBufferConstructor, JSDOMWrapper>(exec, &JSArrayBufferConstructorTable, jsCast<JSArrayBufferConstructor*>(object), propertyName, descriptor);`
	`84`	`+ return getStaticFunctionDescriptor<InternalFunction>(exec, &JSArrayBufferConstructorTable, jsCast<JSArrayBufferConstructor*>(object), propertyName, descriptor);`
`77`	`85`	`}`
`78`	`86`
`79`	`87`	`ConstructType JSArrayBufferConstructor::getConstructData(JSCell*, ConstructData& constructData)`
`@@ -93,14 +101,20 @@ static const HashTableValue JSArrayBufferPrototypeTableValues[] =`
`93`	`101`	`static const HashTable JSArrayBufferPrototypeTable = { 2, 1, JSArrayBufferPrototypeTableValues, 0 };`
`94`	`102`	`static const HashTable* getJSArrayBufferPrototypeTable(ExecState* exec)`
`95`	`103`	`{`
`96`		`- return getHashTableForGlobalData(exec->globalData(), &JSArrayBufferPrototypeTable);`
	`104`	`+ ASSERT_UNUSED(exec, exec);`
	`105`	`+ return &JSArrayBufferPrototypeTable; // PL FIXME: should be one instance per global data, not super global`
`97`	`106`	`}`
`98`	`107`
`99`	`108`	`const ClassInfo JSArrayBufferPrototype::s_info = { "ArrayBufferPrototype", &Base::s_info, 0, getJSArrayBufferPrototypeTable, CREATE_METHOD_TABLE(JSArrayBufferPrototype) };`
`100`	`109`
	`110`	`+static JSObject * globalProto = NULL;`
`101`	`111`	`JSObject* JSArrayBufferPrototype::self(ExecState* exec, JSGlobalObject* globalObject)`
`102`	`112`	`{`
`103`		`- return getDOMPrototype<JSArrayBuffer>(exec, globalObject);`
	`113`	`+ // PL FIXME: dirty hack to provide one global prototype`
	`114`	`+ if( !globalProto ) {`
	`115`	`+ globalProto = JSArrayBuffer::createPrototype(exec, globalObject);`
	`116`	`+ }`
	`117`	`+ return globalProto;`
`104`	`118`	`}`
`105`	`119`
`106`	`120`	`bool JSArrayBufferPrototype::getOwnPropertySlot(JSCell* cell, ExecState* exec, const Identifier& propertyName, PropertySlot& slot)`
`@@ -117,13 +131,14 @@ bool JSArrayBufferPrototype::getOwnPropertyDescriptor(JSObject* object, ExecStat`
`117`	`131`
`118`	`132`	`static const HashTable* getJSArrayBufferTable(ExecState* exec)`
`119`	`133`	`{`
`120`		`- return getHashTableForGlobalData(exec->globalData(), &JSArrayBufferTable);`
	`134`	`+ ASSERT_UNUSED(exec, exec);`
	`135`	`+ return &JSArrayBufferTable;`
`121`	`136`	`}`
`122`	`137`
`123`	`138`	`const ClassInfo JSArrayBuffer::s_info = { "ArrayBuffer", &Base::s_info, 0, getJSArrayBufferTable , CREATE_METHOD_TABLE(JSArrayBuffer) };`
`124`	`139`
`125`		`-JSArrayBuffer::JSArrayBuffer(Structure* structure, JSDOMGlobalObject* globalObject, PassRefPtr<ArrayBuffer> impl)`
`126`		`- : JSDOMWrapper(structure, globalObject)`
	`140`	`+JSArrayBuffer::JSArrayBuffer(Structure* structure, JSGlobalObject* globalObject, PassRefPtr<ArrayBuffer> impl)`
	`141`	`+ : JSNonFinalObject(globalObject->globalData(), structure)`
`127`	`142`	`, m_impl(impl.leakRef())`
`128`	`143`	`{`
`129`	`144`	`}`
`@@ -180,9 +195,14 @@ JSValue jsArrayBufferConstructor(ExecState* exec, JSValue slotBase, const Identi`
`180`	`195`	`return JSArrayBuffer::getConstructor(exec, domObject->globalObject());`
`181`	`196`	`}`
`182`	`197`
	`198`	`+static JSObject * globalConstructor;`
`183`	`199`	`JSValue JSArrayBuffer::getConstructor(ExecState* exec, JSGlobalObject* globalObject)`
`184`	`200`	`{`
`185`		`- return getDOMConstructor<JSArrayBufferConstructor>(exec, jsCast<JSDOMGlobalObject*>(globalObject));`
	`201`	`+ if( !globalConstructor ) {`
	`202`	`+ JSArrayBufferConstructor * constructor = JSArrayBufferConstructor::create(exec, JSArrayBufferConstructor::createStructure(exec->globalData(), globalObject, globalObject->objectPrototype()), globalObject);`
	`203`	`+ globalConstructor = constructor;`
	`204`	`+ }`
	`205`	`+ return globalConstructor;`
`186`	`206`	`}`
`187`	`207`
`188`	`208`	`EncodedJSValue JSC_HOST_CALL jsArrayBufferPrototypeFunctionSlice(ExecState* exec)`
`@@ -232,15 +252,16 @@ bool JSArrayBufferOwner::isReachableFromOpaqueRoots(JSC::Handle<JSC::Unknown> ha`
`232`	`252`
`233`	`253`	`void JSArrayBufferOwner::finalize(JSC::Handle<JSC::Unknown> handle, void* context)`
`234`	`254`	`{`
	`255`	`+ ASSERT_UNUSED(context, context);`
`235`	`256`	`JSArrayBuffer* jsArrayBuffer = jsCast<JSArrayBuffer*>(handle.get().asCell());`
`236`		`- DOMWrapperWorld* world = static_cast<DOMWrapperWorld*>(context);`
`237`		`- uncacheWrapper(world, jsArrayBuffer->impl(), jsArrayBuffer);`
`238`	`257`	`jsArrayBuffer->releaseImpl();`
`239`	`258`	`}`
`240`	`259`
`241`		`-JSC::JSValue toJS(JSC::ExecState* exec, JSDOMGlobalObject* globalObject, ArrayBuffer* impl)`
	`260`	`+JSC::JSValue toJS(JSC::ExecState* exec, JSGlobalObject* globalObject, ArrayBuffer* impl)`
`242`	`261`	`{`
`243`		`- return wrap<JSArrayBuffer>(exec, globalObject, impl);`
	`262`	`+ JSArrayBuffer * buf = JSArrayBuffer::create( JSArrayBuffer::createStructure(exec->globalData(), globalObject, JSArrayBufferPrototype::self(exec, globalObject)), globalObject, impl);`
	`263`	`+ JSC::JSCell* jsCell = reinterpret_cast<JSC::JSCell*>(buf);`
	`264`	`+ return jsCell;`
`244`	`265`	`}`
`245`	`266`
`246`	`267`	`ArrayBuffer* toArrayBuffer(JSC::JSValue value)`