Merge webkit.org at r61121: Initial merge by git.

Change-Id: Icd6db395c62285be384d137164d95d7466c98760

153 files changed, 4601 insertions, 1387 deletions

diff --git a/WebCore/bindings/cpp/WebDOMCString.cpp b/WebCore/bindings/cpp/WebDOMCString.cpp
new file mode 100644
index 0000000..ab87ac8
--- /dev/null
+++ b/WebCore/bindings/cpp/WebDOMCString.cpp
@@ -0,0 +1,113 @@
+/*
+ * Copyright (C) Research In Motion Limited 2010. All rights reserved.
+ * Copyright (C) 2009 Google Inc. All rights reserved.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public License
+ * along with this library; see the file COPYING.LIB.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include "config.h"
+#include "WebDOMCString.h"
+
+#include "TextEncoding.h"
+#include "WebDOMString.h"
+#include <wtf/text/CString.h>
+
+class WebDOMCStringPrivate : public WTF::CStringBuffer {
+};
+
+void WebDOMCString::reset()
+{
+    if (m_private) {
+        m_private->deref();
+        m_private = 0;
+    }
+}
+
+void WebDOMCString::assign(const WebDOMCString& other)
+{
+    assign(const_cast<WebDOMCStringPrivate*>(other.m_private));
+}
+
+void WebDOMCString::assign(const char* data, size_t length)
+{
+    char* newData;
+    RefPtr<WTF::CStringBuffer> buffer =
+        WTF::CString::newUninitialized(length, newData).buffer();
+    memcpy(newData, data, length);
+    assign(static_cast<WebDOMCStringPrivate*>(buffer.get()));
+}
+
+size_t WebDOMCString::length() const
+{
+    if (!m_private)
+        return 0;
+    // NOTE: The buffer's length includes the null byte.
+    return const_cast<WebDOMCStringPrivate*>(m_private)->length() - 1;
+}
+
+const char* WebDOMCString::data() const
+{
+    if (!m_private)
+        return 0;
+    return const_cast<WebDOMCStringPrivate*>(m_private)->data();
+}
+
+WebDOMString WebDOMCString::utf16() const
+{
+    return WebCore::UTF8Encoding().decode(data(), length());
+}
+
+WebDOMCString WebDOMCString::fromUTF16(const WebUChar* data, size_t length)
+{
+    return WebCore::UTF8Encoding().encode(
+        data, length, WebCore::QuestionMarksForUnencodables);
+}
+
+WebDOMCString WebDOMCString::fromUTF16(const WebUChar* data)
+{
+    size_t len = 0;
+    while (data[len] != WebUChar(0))
+        len++;
+    return fromUTF16(data, len);
+}
+
+WebDOMCString::WebDOMCString(const WTF::CString& s)
+    : m_private(static_cast<WebDOMCStringPrivate*>(s.buffer()))
+{
+    if (m_private)
+        m_private->ref();
+}
+
+WebDOMCString& WebDOMCString::operator=(const WTF::CString& s)
+{
+    assign(static_cast<WebDOMCStringPrivate*>(s.buffer()));
+    return *this;
+}
+
+WebDOMCString::operator WTF::CString() const
+{
+    return m_private;
+}
+
+void WebDOMCString::assign(WebDOMCStringPrivate* p)
+{
+    // Take care to handle the case where m_private == p
+    if (p)
+        p->ref();
+    if (m_private)
+        m_private->deref();
+    m_private = p;
+}
diff --git a/WebCore/bindings/cpp/WebDOMCString.h b/WebCore/bindings/cpp/WebDOMCString.h
new file mode 100644
index 0000000..e02a587
--- /dev/null
+++ b/WebCore/bindings/cpp/WebDOMCString.h
@@ -0,0 +1,89 @@
+/*
+ * Copyright (C) Research In Motion Limited 2010. All rights reserved.
+ * Copyright (C) 2009 Google Inc. All rights reserved.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public License
+ * along with this library; see the file COPYING.LIB.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#ifndef WebDOMCString_h
+#define WebDOMCString_h
+
+#include <WebDOMObject.h>
+#include <stddef.h> // For size_t
+
+namespace WTF {
+class CString;
+};
+
+// UTF-16 character type
+#if defined(WIN32)
+typedef wchar_t WebUChar;
+#else
+typedef unsigned short WebUChar;
+#endif
+
+class WebDOMCStringPrivate;
+class WebDOMString;
+
+// A single-byte string container with unspecified encoding.  It is
+// inexpensive to copy a WebDOMCString object.
+//
+// WARNING: It is not safe to pass a WebDOMCString across threads!!!
+//
+class WebDOMCString {
+public:
+    ~WebDOMCString() { reset(); }
+
+    WebDOMCString() : m_private(0) { }
+
+    WebDOMCString(const char* data, size_t len) : m_private(0)
+    {
+        assign(data, len);
+    }
+
+    WebDOMCString(const WebDOMCString& s) : m_private(0) { assign(s); }
+
+    WebDOMCString& operator=(const WebDOMCString& s)
+    {
+        assign(s);
+        return *this;
+    }
+
+    void reset();
+    void assign(const WebDOMCString&);
+    void assign(const char* data, size_t len);
+
+    size_t length() const;
+    const char* data() const;
+
+    bool isEmpty() const { return !length(); }
+    bool isNull() const { return !m_private; }
+
+    WebDOMString utf16() const;
+
+    static WebDOMCString fromUTF16(const WebUChar* data, size_t length);
+    static WebDOMCString fromUTF16(const WebUChar* data);
+
+    WebDOMCString(const WTF::CString&);
+    WebDOMCString& operator=(const WTF::CString&);
+    operator WTF::CString() const;
+
+private:
+    void assign(WebDOMCStringPrivate*);
+    WebDOMCStringPrivate* m_private;
+};
+
+#endif
diff --git a/WebCore/bindings/cpp/WebDOMEventListenerCustom.cpp b/WebCore/bindings/cpp/WebDOMEventListenerCustom.cpp
new file mode 100644
index 0000000..db31b71
--- /dev/null
+++ b/WebCore/bindings/cpp/WebDOMEventListenerCustom.cpp
@@ -0,0 +1,39 @@
+/*
+ * Copyright (C) Research In Motion Limited 2010. All rights reserved.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public License
+ * along with this library; see the file COPYING.LIB.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include "config.h"
+#include "WebDOMEventListener.h"
+
+#include "WebDOMEvent.h"
+#include "WebNativeEventListener.h"
+#include <wtf/RefPtr.h>
+
+void WebDOMEventListener::handleEvent(const WebDOMEvent& evt)
+{
+    if (!impl())
+        return;
+
+    impl()->handleEvent(0, toWebCore(evt));
+}
+
+WebDOMEventListener toWebKit(WebUserEventListener* value)
+{
+    RefPtr<WebNativeEventListener> listener = WebNativeEventListener::create(value);
+    return WebDOMEventListener(listener.get());
+}
diff --git a/WebCore/bindings/cpp/WebDOMEventTarget.cpp b/WebCore/bindings/cpp/WebDOMEventTarget.cpp
new file mode 100644
index 0000000..2eaef00
--- /dev/null
+++ b/WebCore/bindings/cpp/WebDOMEventTarget.cpp
@@ -0,0 +1,155 @@
+/*
+ * Copyright (C) Research In Motion Limited 2010. All rights reserved.
+ * Copyright (C) 2008 Apple Inc. All Rights Reserved.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public License
+ * along with this library; see the file COPYING.LIB.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include "config.h"
+#include "WebDOMEventTarget.h"
+
+#include "DOMApplicationCache.h"
+#include "DedicatedWorkerContext.h"
+#include "EventSource.h"
+#include "MessagePort.h"
+#include "Node.h"
+#include "Notification.h"
+#include "SharedWorker.h"
+#include "SharedWorkerContext.h"
+#include "ThreadCheck.h"
+#include "WebDOMDOMApplicationCache.h"
+#include "WebDOMDedicatedWorkerContext.h"
+#include "WebDOMEventSource.h"
+#include "WebDOMMessagePort.h"
+#include "WebDOMNode.h"
+#include "WebDOMNotification.h"
+#include "WebDOMSharedWorker.h"
+#include "WebDOMSharedWorkerContext.h"
+#include "WebDOMWebSocket.h"
+#include "WebDOMWorker.h"
+#include "WebDOMXMLHttpRequest.h"
+#include "WebDOMXMLHttpRequestUpload.h"
+#include "WebExceptionHandler.h"
+#include "WebSocket.h"
+#include "Worker.h"
+#include "XMLHttpRequest.h"
+#include "XMLHttpRequestUpload.h"
+
+#include <wtf/RefPtr.h>
+
+struct WebDOMEventTarget::WebDOMEventTargetPrivate {
+    WebDOMEventTargetPrivate(WebCore::EventTarget* object = 0)
+        : impl(object)
+    {
+    }
+
+    RefPtr<WebCore::EventTarget> impl;
+};
+
+WebDOMEventTarget::WebDOMEventTarget()
+    : WebDOMObject()
+    , m_impl(0)
+{
+}
+
+WebDOMEventTarget::WebDOMEventTarget(WebCore::EventTarget* impl)
+    : WebDOMObject()
+    , m_impl(new WebDOMEventTargetPrivate(impl))
+{
+}
+
+WebDOMEventTarget::WebDOMEventTarget(const WebDOMEventTarget& copy)
+    : WebDOMObject()
+{
+    m_impl = copy.impl() ? new WebDOMEventTargetPrivate(copy.impl()) : 0;
+}
+
+WebDOMEventTarget::~WebDOMEventTarget()
+{
+    delete m_impl;
+    m_impl = 0;
+}
+
+WebCore::EventTarget* WebDOMEventTarget::impl() const
+{
+    return m_impl ? m_impl->impl.get() : 0;
+}
+
+WebCore::EventTarget* toWebCore(const WebDOMEventTarget& wrapper)
+{
+    return wrapper.impl();
+}
+
+WebDOMEventTarget toWebKit(WebCore::EventTarget* value)
+{
+#if ENABLE(EVENTSOURCE)
+    if (WebCore::EventSource* eventSource = value->toEventSource())
+        return toWebKit(eventSource);
+#endif
+
+#if ENABLE(SVG) && 0
+    // FIXME: Enable once SVG bindings are generated.
+    // SVGElementInstance supports both toSVGElementInstance and toNode since so much mouse handling code depends on toNode returning a valid node.
+    if (WebCore::SVGElementInstance* instance = value->toSVGElementInstance())
+        return toWebKit(instance);
+#endif
+
+    if (WebCore::Node* node = value->toNode())
+        return toWebKit(node);
+
+    if (WebCore::XMLHttpRequest* xhr = value->toXMLHttpRequest())
+        return toWebKit(xhr);
+
+    if (WebCore::XMLHttpRequestUpload* upload = value->toXMLHttpRequestUpload())
+        return toWebKit(upload);
+
+#if ENABLE(OFFLINE_WEB_APPLICATIONS)
+    if (WebCore::DOMApplicationCache* cache = value->toDOMApplicationCache())
+        return toWebKit(cache);
+#endif
+
+    if (WebCore::MessagePort* messagePort = value->toMessagePort())
+        return toWebKit(messagePort);
+
+#if ENABLE(WORKERS)
+    if (WebCore::Worker* worker = value->toWorker())
+        return toWebKit(worker);
+
+    if (WebCore::DedicatedWorkerContext* workerContext = value->toDedicatedWorkerContext())
+        return toWebKit(workerContext);
+#endif
+
+#if ENABLE(SHARED_WORKERS)
+    if (WebCore::SharedWorker* sharedWorker = value->toSharedWorker())
+        return toWebKit(sharedWorker);
+
+    if (WebCore::SharedWorkerContext* workerContext = value->toSharedWorkerContext())
+        return toWebKit(workerContext);
+#endif
+
+#if ENABLE(NOTIFICATIONS)
+    if (WebCore::Notification* notification = value->toNotification())
+        return toWebKit(notification);
+#endif
+
+#if ENABLE(WEB_SOCKETS)
+    if (WebCore::WebSocket* webSocket = value->toWebSocket())
+        return toWebKit(webSocket);
+#endif
+
+    ASSERT_NOT_REACHED();
+    return WebDOMEventTarget();
+}
diff --git a/WebCore/bindings/cpp/WebDOMEventTarget.h b/WebCore/bindings/cpp/WebDOMEventTarget.h
new file mode 100644
index 0000000..f5360ca
--- /dev/null
+++ b/WebCore/bindings/cpp/WebDOMEventTarget.h
@@ -0,0 +1,49 @@
+/*
+ * Copyright (C) Research In Motion Limited 2010. All rights reserved.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public License
+ * along with this library; see the file COPYING.LIB.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#ifndef WebDOMEventTarget_h
+#define WebDOMEventTarget_h
+
+#include <WebDOMObject.h>
+
+namespace WebCore {
+class EventTarget;
+};
+
+class WebDOMEventTarget : public WebDOMObject {
+public:
+    WebDOMEventTarget();
+    explicit WebDOMEventTarget(WebCore::EventTarget*);
+    WebDOMEventTarget(const WebDOMEventTarget&);
+    ~WebDOMEventTarget();
+
+    WebCore::EventTarget* impl() const;
+
+    // FIXME: Add a possibility to check what kind of EventTarget we have,
+    // to be able to cast eg. a WebDOMEventTarget to a WebDOMNode
+
+protected:
+    struct WebDOMEventTargetPrivate;
+    WebDOMEventTargetPrivate* m_impl;
+};
+
+WebCore::EventTarget* toWebCore(const WebDOMEventTarget&);
+WebDOMEventTarget toWebKit(WebCore::EventTarget*);
+
+#endif
diff --git a/WebCore/bindings/cpp/WebDOMHTMLDocumentCustom.cpp b/WebCore/bindings/cpp/WebDOMHTMLDocumentCustom.cpp
new file mode 100644
index 0000000..aa511ad
--- /dev/null
+++ b/WebCore/bindings/cpp/WebDOMHTMLDocumentCustom.cpp
@@ -0,0 +1,50 @@
+/*
+ * Copyright (C) Research In Motion Limited 2010. All rights reserved.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public License
+ * along with this library; see the file COPYING.LIB.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include "config.h"
+#include "WebDOMHTMLDocument.h"
+
+#include "CharacterNames.h"
+#include "HTMLDocument.h"
+#include "SegmentedString.h"
+#include "WebExceptionHandler.h"
+
+static inline void documentWrite(const WebDOMString& text, WebCore::HTMLDocument* document, bool addNewline)
+{
+    WebCore::SegmentedString segmentedString = WebCore::String(text);
+    if (addNewline)
+        segmentedString.append(WebCore::SegmentedString(&WebCore::newlineCharacter, 1));
+    document->write(segmentedString);
+}
+
+void WebDOMHTMLDocument::write(const WebDOMString& text)
+{
+    if (!impl())
+        return;
+
+    documentWrite(text, impl(), false);
+}
+
+void WebDOMHTMLDocument::writeln(const WebDOMString& text)
+{
+    if (!impl())
+        return;
+
+    documentWrite(text, impl(), true);
+}
diff --git a/WebCore/bindings/cpp/WebDOMNodeCustom.cpp b/WebCore/bindings/cpp/WebDOMNodeCustom.cpp
new file mode 100644
index 0000000..41abb0c
--- /dev/null
+++ b/WebCore/bindings/cpp/WebDOMNodeCustom.cpp
@@ -0,0 +1,96 @@
+/*
+ * Copyright (C) Research In Motion Limited 2010. All rights reserved.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public License
+ * along with this library; see the file COPYING.LIB.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include "config.h"
+#include "WebDOMNode.h"
+
+#include "Node.h"
+#include "WebDOMEventListener.h"
+#include "WebExceptionHandler.h"
+#include "WebNativeEventListener.h"
+
+WebDOMNode WebDOMNode::insertBefore(const WebDOMNode& newChild, const WebDOMNode& refChild)
+{
+    if (!impl())
+        return WebDOMNode();
+
+    WebCore::ExceptionCode ec = 0;
+    if (impl()->insertBefore(toWebCore(newChild), toWebCore(refChild), ec, true))
+        return newChild;
+
+    webDOMRaiseError(static_cast<WebDOMExceptionCode>(ec));
+    return WebDOMNode();
+}
+
+WebDOMNode WebDOMNode::replaceChild(const WebDOMNode& newChild, const WebDOMNode& oldChild)
+{
+    if (!impl())
+        return WebDOMNode();
+
+    WebCore::ExceptionCode ec = 0;
+    if (impl()->replaceChild(toWebCore(newChild), toWebCore(oldChild), ec, true))
+        return oldChild;
+
+    webDOMRaiseError(static_cast<WebDOMExceptionCode>(ec));
+    return WebDOMNode();
+}
+
+WebDOMNode WebDOMNode::removeChild(const WebDOMNode& oldChild)
+{
+    if (!impl())
+        return WebDOMNode();
+
+    WebCore::ExceptionCode ec = 0;
+    if (impl()->removeChild(toWebCore(oldChild), ec))
+        return oldChild;
+
+    webDOMRaiseError(static_cast<WebDOMExceptionCode>(ec));
+    return WebDOMNode();
+}
+
+WebDOMNode WebDOMNode::appendChild(const WebDOMNode& newChild)
+{
+    if (!impl())
+        return WebDOMNode();
+
+    WebCore::ExceptionCode ec = 0;
+    if (impl()->appendChild(toWebCore(newChild), ec, true))
+        return newChild;
+
+    webDOMRaiseError(static_cast<WebDOMExceptionCode>(ec));
+    return WebDOMNode();
+}
+
+void WebDOMNode::addEventListener(const WebDOMString& type, const WebDOMEventListener& listener, bool useCapture)
+{
+    if (!impl())
+        return;
+
+    if (toWebCore(listener))
+        impl()->addEventListener(type, toWebCore(listener), useCapture);
+}
+
+void WebDOMNode::removeEventListener(const WebDOMString& type, const WebDOMEventListener& listener, bool useCapture)
+{
+    if (!impl())
+        return;
+
+    if (toWebCore(listener))
+        impl()->removeEventListener(type, toWebCore(listener), useCapture);
+}
diff --git a/WebCore/bindings/cpp/WebDOMObject.h b/WebCore/bindings/cpp/WebDOMObject.h
new file mode 100644
index 0000000..4d1830b
--- /dev/null
+++ b/WebCore/bindings/cpp/WebDOMObject.h
@@ -0,0 +1,32 @@
+/*
+ * Copyright (C) Research In Motion Limited 2010. All rights reserved.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public License
+ * along with this library; see the file COPYING.LIB.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#ifndef WebDOMObject_h
+#define WebDOMObject_h
+
+class WebDOMObject {
+protected:
+    WebDOMObject() { }
+    ~WebDOMObject() { }
+};
+
+// Looks akward, though we prefix all classes with WebDOM
+typedef unsigned long long WebDOMDOMTimeStamp;
+
+#endif
diff --git a/WebCore/bindings/cpp/WebDOMString.cpp b/WebCore/bindings/cpp/WebDOMString.cpp
new file mode 100644
index 0000000..d87dedd
--- /dev/null
+++ b/WebCore/bindings/cpp/WebDOMString.cpp
@@ -0,0 +1,124 @@
+/*
+ * Copyright (C) Research In Motion Limited 2010. All rights reserved.
+ * Copyright (C) 2009 Google Inc. All rights reserved.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public License
+ * along with this library; see the file COPYING.LIB.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include "config.h"
+#include "WebDOMString.h"
+
+#include "WebDOMCString.h"
+#include <wtf/text/AtomicString.h>
+#include <wtf/text/CString.h>
+#include <wtf/text/WTFString.h>
+
+class WebDOMStringPrivate : public WebCore::StringImpl {
+};
+
+void WebDOMString::reset()
+{
+    if (m_private) {
+        m_private->deref();
+        m_private = 0;
+    }
+}
+
+void WebDOMString::assign(const WebDOMString& other)
+{
+    assign(const_cast<WebDOMStringPrivate*>(other.m_private));
+}
+
+void WebDOMString::assign(const WebUChar* data, size_t length)
+{
+    assign(static_cast<WebDOMStringPrivate*>(
+        WebCore::StringImpl::create(data, length).get()));
+}
+
+size_t WebDOMString::length() const
+{
+    return m_private ? const_cast<WebDOMStringPrivate*>(m_private)->length() : 0;
+}
+
+const WebUChar* WebDOMString::data() const
+{
+    return m_private ? const_cast<WebDOMStringPrivate*>(m_private)->characters() : 0;
+}
+
+WebDOMCString WebDOMString::utf8() const
+{
+    return WebCore::String(m_private).utf8();
+}
+
+WebDOMString WebDOMString::fromUTF8(const char* data, size_t length)
+{
+    return WebCore::String::fromUTF8(data, length);
+}
+
+WebDOMString WebDOMString::fromUTF8(const char* data)
+{
+    return WebCore::String::fromUTF8(data);
+}
+
+WebDOMString::WebDOMString(const WebCore::String& s)
+    : m_private(static_cast<WebDOMStringPrivate*>(s.impl()))
+{
+    if (m_private)
+        m_private->ref();
+}
+
+WebDOMString& WebDOMString::operator=(const WebCore::String& s)
+{
+    assign(static_cast<WebDOMStringPrivate*>(s.impl()));
+    return *this;
+}
+
+WebDOMString::operator WebCore::String() const
+{
+    return m_private;
+}
+
+WebDOMString::WebDOMString(const WebCore::AtomicString& s)
+    : m_private(0)
+{
+    assign(s.string());
+}
+
+WebDOMString& WebDOMString::operator=(const WebCore::AtomicString& s)
+{
+    assign(s.string());
+    return *this;
+}
+
+WebDOMString::operator WebCore::AtomicString() const
+{
+    return WebCore::AtomicString(static_cast<WebCore::StringImpl *>(m_private));
+}
+
+bool WebDOMString::equals(const char* string) const
+{
+    return WebCore::equal(m_private, string);
+}
+
+void WebDOMString::assign(WebDOMStringPrivate* p)
+{
+    // Take care to handle the case where m_private == p
+    if (p)
+        p->ref();
+    if (m_private)
+        m_private->deref();
+    m_private = p;
+}
diff --git a/WebCore/bindings/cpp/WebDOMString.h b/WebCore/bindings/cpp/WebDOMString.h
new file mode 100644
index 0000000..ca09ee8
--- /dev/null
+++ b/WebCore/bindings/cpp/WebDOMString.h
@@ -0,0 +1,99 @@
+/*
+ * Copyright (C) Research In Motion Limited 2010. All rights reserved.
+ * Copyright (C) 2009 Google Inc. All rights reserved.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public License
+ * along with this library; see the file COPYING.LIB.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#ifndef WebDOMString_h
+#define WebDOMString_h
+
+#include <WebDOMCString.h>
+
+namespace WebCore {
+class String;
+class AtomicString;
+}
+
+class WebDOMStringPrivate;
+
+// A UTF-16 string container.  It is inexpensive to copy a WebDOMString
+// object.
+//
+// WARNING: It is not safe to pass a WebDOMString across threads!!!
+//
+class WebDOMString {
+public:
+    ~WebDOMString() { reset(); }
+
+    WebDOMString() : m_private(0) { }
+
+    WebDOMString(const WebUChar* data, size_t len) : m_private(0)
+    {
+        assign(data, len);
+    }
+
+    WebDOMString(const WebDOMString& s) : m_private(0) { assign(s); }
+
+    WebDOMString& operator=(const WebDOMString& s)
+    {
+        assign(s);
+        return *this;
+    }
+
+    void reset();
+    void assign(const WebDOMString&);
+    void assign(const WebUChar* data, size_t len);
+
+    size_t length() const;
+    const WebUChar* data() const;
+
+    bool isEmpty() const { return !length(); }
+    bool isNull() const { return !m_private; }
+
+    WebDOMCString utf8() const;
+
+    static WebDOMString fromUTF8(const char* data, size_t length);
+    static WebDOMString fromUTF8(const char* data);
+
+    template <int N> WebDOMString(const char (&data)[N])
+        : m_private(0)
+    {
+        assign(fromUTF8(data, N - 1));
+    }
+
+    template <int N> WebDOMString& operator=(const char (&data)[N])
+    {
+        assign(fromUTF8(data, N - 1));
+        return *this;
+    }
+
+    WebDOMString(const WebCore::String&);
+    WebDOMString& operator=(const WebCore::String&);
+    operator WebCore::String() const;
+
+    WebDOMString(const WebCore::AtomicString&);
+    WebDOMString& operator=(const WebCore::AtomicString&);
+    operator WebCore::AtomicString() const;
+
+    bool equals(const char* string) const;
+
+private:
+    void assign(WebDOMStringPrivate*);
+    WebDOMStringPrivate* m_private;
+};
+
+#endif
diff --git a/WebCore/bindings/cpp/WebExceptionHandler.cpp b/WebCore/bindings/cpp/WebExceptionHandler.cpp
new file mode 100644
index 0000000..f285525
--- /dev/null
+++ b/WebCore/bindings/cpp/WebExceptionHandler.cpp
@@ -0,0 +1,41 @@
+/*
+ * Copyright (C) Research In Motion Limited 2010. All rights reserved.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public License
+ * along with this library; see the file COPYING.LIB.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include "config.h"
+#include "WebExceptionHandler.h"
+
+// To avoid a global static symbol, we declare it in a function
+static inline WebExceptionHandler& globalExceptionHandler()
+{
+    static WebExceptionHandler s_globalExceptionHandler;
+    return s_globalExceptionHandler;
+}
+
+void webInstallExceptionHandler(WebExceptionHandler handler)
+{
+    ASSERT(handler);
+    globalExceptionHandler() = handler;
+}
+
+void webRaiseDOMException(WebDOMExceptionCode ec)
+{
+    ASSERT(ec);
+    if (WebExceptionHandler& handler = globalExceptionHandler())
+        (*handler)(ec);
+}
diff --git a/WebCore/bindings/cpp/WebExceptionHandler.h b/WebCore/bindings/cpp/WebExceptionHandler.h
new file mode 100644
index 0000000..e679254
--- /dev/null
+++ b/WebCore/bindings/cpp/WebExceptionHandler.h
@@ -0,0 +1,40 @@
+/*
+ * Copyright (C) Research In Motion Limited 2010. All rights reserved.
+ * Copyright (C) 2004, 2005, 2006, 2007 Apple Inc. All rights reserved.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public License
+ * along with this library; see the file COPYING.LIB.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#ifndef WebExceptionHandler_h
+#define WebExceptionHandler_h
+
+typedef int WebDOMExceptionCode;
+typedef void (*WebExceptionHandler)(WebDOMExceptionCode);
+
+// Used from the outside to register a callback that gets fired whenever an exception is raised
+void webInstallExceptionHandler(WebExceptionHandler);
+
+// Never used by the bindings, only indirectly by webDOMRaiseError
+void webRaiseDOMException(WebDOMExceptionCode);
+
+// Used from the bindings
+inline void webDOMRaiseError(WebDOMExceptionCode ec) 
+{
+    if (ec)
+        webRaiseDOMException(ec);
+}
+
+#endif
diff --git a/WebCore/bindings/cpp/WebNativeEventListener.cpp b/WebCore/bindings/cpp/WebNativeEventListener.cpp
new file mode 100644
index 0000000..ddd7112
--- /dev/null
+++ b/WebCore/bindings/cpp/WebNativeEventListener.cpp
@@ -0,0 +1,53 @@
+/*
+ * Copyright (C) Research In Motion Limited 2010. All rights reserved.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public License
+ * along with this library; see the file COPYING.LIB.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include "config.h"
+#include "WebNativeEventListener.h"
+
+#include "WebDOMEvent.h"
+
+WebNativeEventListener::WebNativeEventListener(WebUserEventListener* listener)
+    : WebCore::EventListener(CPPEventListenerType),
+    m_listener(listener)
+{
+    ASSERT(m_listener);
+    m_listener->ref();
+}
+
+WebNativeEventListener::~WebNativeEventListener()
+{
+    m_listener->deref();
+}
+
+void WebNativeEventListener::handleEvent(WebCore::ScriptExecutionContext*, WebCore::Event* event)
+{
+    m_listener->handleEvent(toWebKit(event));
+}
+
+bool WebNativeEventListener::reportError(WebCore::ScriptExecutionContext*, const WebCore::String&, const WebCore::String&, int)
+{
+    // FIXME: Implement error handling
+    return false;
+}
+
+bool WebNativeEventListener::operator==(const WebCore::EventListener& other)
+{
+    const WebNativeEventListener* ptrOther = cast(&other);
+    return ptrOther && m_listener == ptrOther->m_listener;
+}
diff --git a/WebCore/bindings/cpp/WebNativeEventListener.h b/WebCore/bindings/cpp/WebNativeEventListener.h
new file mode 100644
index 0000000..fff1b1c
--- /dev/null
+++ b/WebCore/bindings/cpp/WebNativeEventListener.h
@@ -0,0 +1,54 @@
+/*
+ * Copyright (C) Research In Motion Limited 2010. All rights reserved.
+ * Copyright (C) 2001 Peter Kelly (pmk@post.com)
+ * Copyright (C) 2003, 2008, 2009 Apple Inc. All rights reserved.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public License
+ * along with this library; see the file COPYING.LIB.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#ifndef WebNativeEventListener_h
+#define WebNativeEventListener_h
+
+#include "EventListener.h"
+#include "WebDOMEventListener.h"
+
+class WebNativeEventListener : public WebCore::EventListener {
+public:
+    static PassRefPtr<WebNativeEventListener> create(WebUserEventListener* listener)
+    {
+        return adoptRef(new WebNativeEventListener(listener));
+    }
+
+    static const WebNativeEventListener* cast(const WebCore::EventListener* listener)
+    {
+        return listener->type() == CPPEventListenerType
+                ? static_cast<const WebNativeEventListener*>(listener)
+                : 0;
+    }
+
+    virtual ~WebNativeEventListener();
+    virtual bool operator==(const WebCore::EventListener& other);
+
+private:
+    virtual void handleEvent(WebCore::ScriptExecutionContext*, WebCore::Event*);
+    virtual bool reportError(WebCore::ScriptExecutionContext*, const WebCore::String& message, const WebCore::String& url, int lineNumber);
+
+protected:
+    WebNativeEventListener(WebUserEventListener*);
+    WebUserEventListener* m_listener;
+};
+
+#endif
diff --git a/WebCore/bindings/generic/BindingSecurity.h b/WebCore/bindings/generic/BindingSecurity.h
index 929b8f4..d7c9dfe 100644
--- a/WebCore/bindings/generic/BindingSecurity.h
+++ b/WebCore/bindings/generic/BindingSecurity.h
@@ -36,6 +36,7 @@
 #include "Element.h"
 #include "GenericBinding.h"
 #include "HTMLFrameElementBase.h"
+#include "HTMLNames.h"
 
 namespace WebCore {
 
diff --git a/WebCore/bindings/generic/RuntimeEnabledFeatures.h b/WebCore/bindings/generic/RuntimeEnabledFeatures.h
index c84465a..2d62a27 100644
--- a/WebCore/bindings/generic/RuntimeEnabledFeatures.h
+++ b/WebCore/bindings/generic/RuntimeEnabledFeatures.h
@@ -87,7 +87,7 @@ public:
     static bool uint16ArrayEnabled() { return isWebGLEnabled; }
     static bool int32ArrayEnabled() { return isWebGLEnabled; }
     static bool uint32ArrayEnabled() { return isWebGLEnabled; }
-    static bool floatArrayEnabled() { return isWebGLEnabled; }
+    static bool float32ArrayEnabled() { return isWebGLEnabled; }
     static bool webGLRenderingContextEnabled() { return isWebGLEnabled; }
     static bool webGLArrayBufferEnabled() { return isWebGLEnabled; }
     static bool webGLByteArrayEnabled() { return isWebGLEnabled; }
diff --git a/WebCore/bindings/js/JSArrayBufferConstructor.cpp b/WebCore/bindings/js/JSArrayBufferConstructor.cpp
index 2930be8..683f9d1 100644
--- a/WebCore/bindings/js/JSArrayBufferConstructor.cpp
+++ b/WebCore/bindings/js/JSArrayBufferConstructor.cpp
@@ -46,22 +46,22 @@ JSArrayBufferConstructor::JSArrayBufferConstructor(ExecState* exec, JSDOMGlobalO
     putDirect(exec->propertyNames().length, jsNumber(exec, 2), ReadOnly|DontDelete|DontEnum);
 }
 
-static JSObject* constructCanvasArrayBuffer(ExecState* exec, JSObject* constructor, const ArgList& args)
+static EncodedJSValue JSC_HOST_CALL constructCanvasArrayBuffer(ExecState* exec)
 {
-    JSArrayBufferConstructor* jsConstructor = static_cast<JSArrayBufferConstructor*>(constructor);
+    JSArrayBufferConstructor* jsConstructor = static_cast<JSArrayBufferConstructor*>(exec->callee());
 
     unsigned int size = 0;
-    if (args.size() == 1) {
-        size = (unsigned int)args.at(0).toInt32(exec);
+    if (exec->argumentCount() == 1) {
+        size = (unsigned int)exec->argument(0).toInt32(exec);
         if (isnan(size))
             size = 0;
     }
     RefPtr<ArrayBuffer> buffer = ArrayBuffer::create(size, 1);
     if (!buffer.get()){
         setDOMException(exec, INDEX_SIZE_ERR);
-        return 0;
+        return JSValue::encode(JSValue());
     }
-    return asObject(toJS(exec, jsConstructor->globalObject(), buffer.get()));
+    return JSValue::encode(asObject(toJS(exec, jsConstructor->globalObject(), buffer.get())));
 }
 
 JSC::ConstructType JSArrayBufferConstructor::getConstructData(JSC::ConstructData& constructData)
diff --git a/WebCore/bindings/js/JSArrayBufferConstructor.h b/WebCore/bindings/js/JSArrayBufferConstructor.h
index fd03815..fa07a55 100644
--- a/WebCore/bindings/js/JSArrayBufferConstructor.h
+++ b/WebCore/bindings/js/JSArrayBufferConstructor.h
@@ -70,7 +70,7 @@ namespace WebCore {
             unsigned length = array->get(exec, JSC::Identifier(exec, "length")).toUInt32(exec);
             void* tempValues;
             if (!tryFastCalloc(length, sizeof(T)).getValue(tempValues)) {
-                throwError(exec, JSC::GeneralError);
+                throwError(exec, createError(exec, "Error"));
                 return 0;
             }
             
diff --git a/WebCore/bindings/js/JSArrayBufferViewCustom.cpp b/WebCore/bindings/js/JSArrayBufferViewCustom.cpp
index a865a30..1fb6b49 100644
--- a/WebCore/bindings/js/JSArrayBufferViewCustom.cpp
+++ b/WebCore/bindings/js/JSArrayBufferViewCustom.cpp
@@ -35,7 +35,7 @@
 #include "JSUint16Array.h"
 #include "JSInt32Array.h"
 #include "JSUint32Array.h"
-#include "JSFloatArray.h"
+#include "JSFloat32Array.h"
 
 #include "ArrayBufferView.h"
 
@@ -50,7 +50,7 @@ JSC::JSValue toJS(JSC::ExecState* exec, JSDOMGlobalObject* globalObject, ArrayBu
         
     if (object) {
         if (object->isFloatArray())
-            return getDOMObjectWrapper<JSFloatArray>(exec, globalObject, static_cast<FloatArray*>(object));
+            return getDOMObjectWrapper<JSFloat32Array>(exec, globalObject, static_cast<Float32Array*>(object));
         if (object->isUnsignedByteArray())
             return getDOMObjectWrapper<JSUint8Array>(exec, globalObject, static_cast<Uint8Array*>(object));
         if (object->isByteArray())
diff --git a/WebCore/bindings/js/JSArrayBufferViewHelper.h b/WebCore/bindings/js/JSArrayBufferViewHelper.h
index 6b77c0c..f632f38 100644
--- a/WebCore/bindings/js/JSArrayBufferViewHelper.h
+++ b/WebCore/bindings/js/JSArrayBufferViewHelper.h
@@ -41,7 +41,7 @@ template <class T>
 JSC::JSValue setWebGLArrayHelper(JSC::ExecState* exec, T* impl, T* (*conversionFunc)(JSC::JSValue))
 {
     if (exec->argumentCount() < 1)
-        return throwError(exec, JSC::SyntaxError);
+        return JSC::throwSyntaxError(exec);
 
     T* array = (*conversionFunc)(exec->argument(0));
     if (array) {
@@ -78,7 +78,7 @@ JSC::JSValue setWebGLArrayHelper(JSC::ExecState* exec, T* impl, T* (*conversionF
         return JSC::jsUndefined();
     }
 
-    return JSC::throwError(exec, JSC::SyntaxError);
+    return JSC::throwSyntaxError(exec);
 }
 
 }
diff --git a/WebCore/bindings/js/JSAudioConstructor.cpp b/WebCore/bindings/js/JSAudioConstructor.cpp
index cc791d1..5bbaf41 100644
--- a/WebCore/bindings/js/JSAudioConstructor.cpp
+++ b/WebCore/bindings/js/JSAudioConstructor.cpp
@@ -46,13 +46,13 @@ JSAudioConstructor::JSAudioConstructor(ExecState* exec, JSDOMGlobalObject* globa
     putDirect(exec->propertyNames().length, jsNumber(exec, 1), ReadOnly | DontDelete | DontEnum);
 }
 
-static JSObject* constructAudio(ExecState* exec, JSObject* constructor, const ArgList& args)
+static EncodedJSValue JSC_HOST_CALL constructAudio(ExecState* exec)
 {
-    JSAudioConstructor* jsConstructor = static_cast<JSAudioConstructor*>(constructor);
+    JSAudioConstructor* jsConstructor = static_cast<JSAudioConstructor*>(exec->callee());
 
     Document* document = jsConstructor->document();
     if (!document)
-        return throwError(exec, ReferenceError, "Audio constructor associated document is unavailable");
+        return throwVMError(exec, createReferenceError(exec, "Audio constructor associated document is unavailable"));
 
     // Calling toJS on the document causes the JS document wrapper to be
     // added to the window object. This is done to ensure that JSDocument::markChildren
@@ -60,13 +60,13 @@ static JSObject* constructAudio(ExecState* exec, JSObject* constructor, const Ar
     toJS(exec, jsConstructor->globalObject(), document);
 
     // FIXME: This converts an undefined argument to the string "undefined", but possibly we
-    // should treat it as if no argument was passed instead, by checking the value of args.at
-    // rather than looking at args.size.
+    // should treat it as if no argument was passed instead, by checking the value of exec->argument
+    // rather than looking at exec->argumentCount.
     String src;
-    if (args.size() > 0)
-        src = ustringToString(args.at(0).toString(exec));
-    return asObject(toJS(exec, jsConstructor->globalObject(),
-        HTMLAudioElement::createForJSConstructor(document, src)));
+    if (exec->argumentCount() > 0)
+        src = ustringToString(exec->argument(0).toString(exec));
+    return JSValue::encode(asObject(toJS(exec, jsConstructor->globalObject(),
+        HTMLAudioElement::createForJSConstructor(document, src))));
 }
 
 ConstructType JSAudioConstructor::getConstructData(ConstructData& constructData)
diff --git a/WebCore/bindings/js/JSBindingsAllInOne.cpp b/WebCore/bindings/js/JSBindingsAllInOne.cpp
index 7a105ff..ae31608 100644
--- a/WebCore/bindings/js/JSBindingsAllInOne.cpp
+++ b/WebCore/bindings/js/JSBindingsAllInOne.cpp
@@ -127,12 +127,12 @@
 #include "JSWorkerContextCustom.cpp"
 #include "JSWorkerContextErrorHandler.cpp"
 #include "JSWorkerCustom.cpp"
-#include "JSXMLHttpRequestConstructor.cpp"
 #include "JSXMLHttpRequestCustom.cpp"
 #include "JSXMLHttpRequestUploadCustom.cpp"
 #include "JSXSLTProcessorConstructor.cpp"
 #include "JSXSLTProcessorCustom.cpp"
 #include "JavaScriptCallFrame.cpp"
+#include "MemoryInfo.cpp"
 #include "ScheduledAction.cpp"
 #include "ScriptArray.cpp"
 #include "ScriptCachedFrameData.cpp"
diff --git a/WebCore/bindings/js/JSCallbackData.cpp b/WebCore/bindings/js/JSCallbackData.cpp
index e813da2..6b19639 100644
--- a/WebCore/bindings/js/JSCallbackData.cpp
+++ b/WebCore/bindings/js/JSCallbackData.cpp
@@ -51,7 +51,7 @@ JSValue JSCallbackData::invokeCallback(MarkedArgumentBuffer& args, bool* raisedE
     JSValue function = callback()->get(exec, Identifier(exec, "handleEvent"));
 
     CallData callData;
-    CallType callType = function.getCallData(callData);
+    CallType callType = getCallData(function, callData);
     if (callType == CallTypeNone) {
         callType = callback()->getCallData(callData);
         if (callType == CallTypeNone)
@@ -60,7 +60,12 @@ JSValue JSCallbackData::invokeCallback(MarkedArgumentBuffer& args, bool* raisedE
     }
     
     globalObject()->globalData()->timeoutChecker.start();
-    JSValue result = globalObject()->scriptExecutionContext()->isDocument() 
+    ScriptExecutionContext* context = globalObject()->scriptExecutionContext();
+    // We will fail to get the context if the frame has been detached.
+    if (!context)
+        return JSValue();
+
+    JSValue result = context->isDocument() 
         ? JSMainThreadExecState::call(exec, function, callType, callData, callback(), args)
         : JSC::call(exec, function, callType, callData, callback(), args);
     globalObject()->globalData()->timeoutChecker.stop();
diff --git a/WebCore/bindings/js/JSCanvasRenderingContext2DCustom.cpp b/WebCore/bindings/js/JSCanvasRenderingContext2DCustom.cpp
index 416f976..914dea0 100644
--- a/WebCore/bindings/js/JSCanvasRenderingContext2DCustom.cpp
+++ b/WebCore/bindings/js/JSCanvasRenderingContext2DCustom.cpp
@@ -121,7 +121,7 @@ JSValue JSCanvasRenderingContext2D::setFillColor(ExecState* exec)
                                   exec->argument(2).toFloat(exec), exec->argument(3).toFloat(exec), exec->argument(4).toFloat(exec));
             break;
         default:
-            return throwError(exec, SyntaxError);
+            return throwSyntaxError(exec);
     }
     return jsUndefined();
 }    
@@ -158,7 +158,7 @@ JSValue JSCanvasRenderingContext2D::setStrokeColor(ExecState* exec)
                                     exec->argument(2).toFloat(exec), exec->argument(3).toFloat(exec), exec->argument(4).toFloat(exec));
             break;
         default:
-            return throwError(exec, SyntaxError);
+            return throwSyntaxError(exec);
     }
     
     return jsUndefined();
@@ -190,7 +190,7 @@ JSValue JSCanvasRenderingContext2D::drawImage(ExecState* exec)
     // The img parameter can be a <img> or <canvas> element.
     JSValue value = exec->argument(0);
     if (!value.isObject())
-        return throwError(exec, TypeError);
+        return throwTypeError(exec);
     JSObject* o = asObject(value);
     
     ExceptionCode ec = 0;
@@ -213,7 +213,7 @@ JSValue JSCanvasRenderingContext2D::drawImage(ExecState* exec)
                 setDOMException(exec, ec);
                 break;
             default:
-                return throwError(exec, SyntaxError);
+                return throwSyntaxError(exec);
         }
     } else if (o->inherits(&JSHTMLCanvasElement::s_info)) {
         HTMLCanvasElement* canvas = static_cast<HTMLCanvasElement*>(static_cast<JSHTMLElement*>(o)->impl());
@@ -234,7 +234,7 @@ JSValue JSCanvasRenderingContext2D::drawImage(ExecState* exec)
                 setDOMException(exec, ec);
                 break;
             default:
-                return throwError(exec, SyntaxError);
+                return throwSyntaxError(exec);
         }
 #if ENABLE(VIDEO)
     } else if (o->inherits(&JSHTMLVideoElement::s_info)) {
@@ -256,7 +256,7 @@ JSValue JSCanvasRenderingContext2D::drawImage(ExecState* exec)
                     setDOMException(exec, ec);
                     break;
                 default:
-                    return throwError(exec, SyntaxError);
+                    return throwSyntaxError(exec);
         }
 #endif
     } else {
@@ -272,11 +272,11 @@ JSValue JSCanvasRenderingContext2D::drawImageFromRect(ExecState* exec)
     
     JSValue value = exec->argument(0);
     if (!value.isObject())
-        return throwError(exec, TypeError);
+        return throwTypeError(exec);
     JSObject* o = asObject(value);
     
     if (!o->inherits(&JSHTMLImageElement::s_info))
-        return throwError(exec, TypeError);
+        return throwTypeError(exec);
     context->drawImageFromRect(static_cast<HTMLImageElement*>(static_cast<JSHTMLElement*>(o)->impl()),
                                exec->argument(1).toFloat(exec), exec->argument(2).toFloat(exec),
                                exec->argument(3).toFloat(exec), exec->argument(4).toFloat(exec),
@@ -326,7 +326,7 @@ JSValue JSCanvasRenderingContext2D::setShadow(ExecState* exec)
                                exec->argument(6).toFloat(exec), exec->argument(7).toFloat(exec));
             break;
         default:
-            return throwError(exec, SyntaxError);
+            return throwSyntaxError(exec);
     }
     
     return jsUndefined();    
@@ -338,7 +338,7 @@ JSValue JSCanvasRenderingContext2D::createPattern(ExecState* exec)
 
     JSValue value = exec->argument(0);
     if (!value.isObject())
-        return throwError(exec, TypeError);
+        return throwTypeError(exec);
     JSObject* o = asObject(value);
 
     if (o->inherits(&JSHTMLImageElement::s_info)) {
@@ -406,7 +406,7 @@ JSValue JSCanvasRenderingContext2D::fillText(ExecState* exec)
     // number arg = y
     // optional number arg = maxWidth
     if (exec->argumentCount() < 3 || exec->argumentCount() > 4)
-        return throwError(exec, SyntaxError);
+        return throwSyntaxError(exec);
     
     if (exec->argumentCount() == 4)
         context->fillText(ustringToString(exec->argument(0).toString(exec)), exec->argument(1).toFloat(exec), exec->argument(2).toFloat(exec), exec->argument(3).toFloat(exec));
@@ -424,7 +424,7 @@ JSValue JSCanvasRenderingContext2D::strokeText(ExecState* exec)
     // number arg = y
     // optional number arg = maxWidth
     if (exec->argumentCount() < 3 || exec->argumentCount() > 4)
-        return throwError(exec, SyntaxError);
+        return throwSyntaxError(exec);
     
     if (exec->argumentCount() == 4)
         context->strokeText(ustringToString(exec->argument(0).toString(exec)), exec->argument(1).toFloat(exec), exec->argument(2).toFloat(exec), exec->argument(3).toFloat(exec));
diff --git a/WebCore/bindings/js/JSClipboardCustom.cpp b/WebCore/bindings/js/JSClipboardCustom.cpp
index ad5e055..9bdffdb 100644
--- a/WebCore/bindings/js/JSClipboardCustom.cpp
+++ b/WebCore/bindings/js/JSClipboardCustom.cpp
@@ -78,14 +78,14 @@ JSValue JSClipboard::clearData(ExecState* exec)
     }
 
     // FIXME: It does not match the rest of the JS bindings to throw on invalid number of arguments. 
-    return throwError(exec, SyntaxError, "clearData: Invalid number of arguments");
+    return throwError(exec, createSyntaxError(exec, "clearData: Invalid number of arguments"));
 }
 
 JSValue JSClipboard::getData(ExecState* exec)
 {
     // FIXME: It does not match the rest of the JS bindings to throw on invalid number of arguments.
     if (exec->argumentCount() != 1)
-        return throwError(exec, SyntaxError, "getData: Invalid number of arguments");
+        return throwError(exec, createSyntaxError(exec, "getData: Invalid number of arguments"));
 
     Clipboard* clipboard = impl();
 
@@ -106,7 +106,7 @@ JSValue JSClipboard::setDragImage(ExecState* exec)
 
     // FIXME: It does not match the rest of the JS bindings to throw on invalid number of arguments. 
     if (exec->argumentCount() != 3)
-        return throwError(exec, SyntaxError, "setDragImage: Invalid number of arguments");
+        return throwError(exec, createSyntaxError(exec, "setDragImage: Invalid number of arguments"));
 
     int x = exec->argument(1).toInt32(exec);
     int y = exec->argument(2).toInt32(exec);
@@ -114,11 +114,11 @@ JSValue JSClipboard::setDragImage(ExecState* exec)
     // See if they passed us a node
     Node* node = toNode(exec->argument(0));
     if (!node)
-        return throwError(exec, TypeError);
+        return throwTypeError(exec);
 
     // FIXME: This should probably be a TypeError. 
     if (!node->isElementNode())
-        return throwError(exec, SyntaxError, "setDragImageFromElement: Invalid first argument");
+        return throwError(exec, createSyntaxError(exec, "setDragImageFromElement: Invalid first argument"));
 
     if (static_cast<Element*>(node)->hasLocalName(imgTag) && !node->inDocument())
         clipboard->setDragImage(static_cast<HTMLImageElement*>(node)->cachedImage(), IntPoint(x, y));
diff --git a/WebCore/bindings/js/JSConsoleCustom.cpp b/WebCore/bindings/js/JSConsoleCustom.cpp
index 3ad34a3..b9b407c 100644
--- a/WebCore/bindings/js/JSConsoleCustom.cpp
+++ b/WebCore/bindings/js/JSConsoleCustom.cpp
@@ -28,7 +28,9 @@
 #include "JSConsole.h"
 
 #include "Console.h"
+#include "JSMemoryInfo.h"
 #include "JSScriptProfile.h"
+#include "MemoryInfo.h"
 #include "ScriptCallStack.h"
 #include "ScriptProfile.h"
 #include <runtime/JSArray.h>
@@ -55,4 +57,9 @@ JSValue JSConsole::profiles(ExecState* exec) const
 
 #endif
 
+JSValue JSConsole::memory(ExecState* exec) const
+{
+    return toJS(exec, MemoryInfo::create());
+}
+
 } // namespace WebCore
diff --git a/WebCore/bindings/js/JSCustomPositionCallback.cpp b/WebCore/bindings/js/JSCustomPositionCallback.cpp
index cc6d45c..8990520 100644
--- a/WebCore/bindings/js/JSCustomPositionCallback.cpp
+++ b/WebCore/bindings/js/JSCustomPositionCallback.cpp
@@ -38,12 +38,17 @@ namespace WebCore {
 using namespace JSC;
 
 JSCustomPositionCallback::JSCustomPositionCallback(JSObject* callback, JSDOMGlobalObject* globalObject)
-    : m_data(callback, globalObject)
+    : PositionCallback(globalObject->scriptExecutionContext())
+    , m_data(callback, globalObject)
 {
 }
 
 void JSCustomPositionCallback::handleEvent(Geoposition* geoposition)
 {
+    // ActiveDOMObject will null our pointer to the ScriptExecutionContext when it goes away.
+    if (!scriptExecutionContext())
+        return;
+
     RefPtr<JSCustomPositionCallback> protect(this);
 
     JSC::JSLock lock(SilenceAssertionsOnly);
diff --git a/WebCore/bindings/js/JSCustomPositionErrorCallback.cpp b/WebCore/bindings/js/JSCustomPositionErrorCallback.cpp
index c94ae9a..1777387 100644
--- a/WebCore/bindings/js/JSCustomPositionErrorCallback.cpp
+++ b/WebCore/bindings/js/JSCustomPositionErrorCallback.cpp
@@ -38,12 +38,17 @@ namespace WebCore {
 using namespace JSC;
 
 JSCustomPositionErrorCallback::JSCustomPositionErrorCallback(JSObject* callback, JSDOMGlobalObject* globalObject)
-    : m_data(callback, globalObject)
+    : PositionErrorCallback(globalObject->scriptExecutionContext())
+    , m_data(callback, globalObject)
 {
 }
 
 void JSCustomPositionErrorCallback::handleEvent(PositionError* positionError)
 {
+    // ActiveDOMObject will null our pointer to the ScriptExecutionContext when it goes away.
+    if (!scriptExecutionContext())
+        return;
+
     RefPtr<JSCustomPositionErrorCallback> protect(this);
 
     JSC::JSLock lock(SilenceAssertionsOnly);
diff --git a/WebCore/bindings/js/JSCustomXPathNSResolver.cpp b/WebCore/bindings/js/JSCustomXPathNSResolver.cpp
index e7d174f..37f2512 100644
--- a/WebCore/bindings/js/JSCustomXPathNSResolver.cpp
+++ b/WebCore/bindings/js/JSCustomXPathNSResolver.cpp
@@ -73,7 +73,7 @@ String JSCustomXPathNSResolver::lookupNamespaceURI(const String& prefix)
         
     JSValue function = m_customResolver->get(exec, Identifier(exec, "lookupNamespaceURI"));
     CallData callData;
-    CallType callType = function.getCallData(callData);
+    CallType callType = getCallData(function, callData);
     if (callType == CallTypeNone) {
         callType = m_customResolver->getCallData(callData);
         if (callType == CallTypeNone) {
diff --git a/WebCore/bindings/js/JSDOMBinding.cpp b/WebCore/bindings/js/JSDOMBinding.cpp
index 87d8cf7..27ac9e4 100644
--- a/WebCore/bindings/js/JSDOMBinding.cpp
+++ b/WebCore/bindings/js/JSDOMBinding.cpp
@@ -603,7 +603,7 @@ void setDOMException(ExecState* exec, ExceptionCode ec)
     }
 
     ASSERT(errorObject);
-    exec->setException(errorObject);
+    throwError(exec, errorObject);
 }
 
 bool checkNodeSecurity(ExecState* exec, Node* node)
@@ -729,7 +729,7 @@ JSC::JSObject* toJSSequence(ExecState* exec, JSValue value, unsigned& length)
 {
     JSObject* object = value.getObject();
     if (!object) {
-        throwError(exec, TypeError);
+        throwTypeError(exec);
         return 0;
     }
     JSValue lengthValue = object->get(exec, exec->propertyNames().length);
@@ -737,7 +737,7 @@ JSC::JSObject* toJSSequence(ExecState* exec, JSValue value, unsigned& length)
         return 0;
 
     if (lengthValue.isUndefinedOrNull()) {
-        throwError(exec, TypeError);
+        throwTypeError(exec);
         return 0;
     }
 
diff --git a/WebCore/bindings/js/JSDOMWindowCustom.cpp b/WebCore/bindings/js/JSDOMWindowCustom.cpp
index eabf962..7e0a785 100644
--- a/WebCore/bindings/js/JSDOMWindowCustom.cpp
+++ b/WebCore/bindings/js/JSDOMWindowCustom.cpp
@@ -65,7 +65,7 @@
 #include "JSUint32ArrayConstructor.h"
 #include "JSInt16ArrayConstructor.h"
 #include "JSUint16ArrayConstructor.h"
-#include "JSFloatArrayConstructor.h"
+#include "JSFloat32ArrayConstructor.h"
 #endif
 #include "JSWebKitCSSMatrixConstructor.h"
 #include "JSWebKitPointConstructor.h"
@@ -73,7 +73,7 @@
 #include "JSWebSocketConstructor.h"
 #endif
 #include "JSWorkerConstructor.h"
-#include "JSXMLHttpRequestConstructor.h"
+#include "JSXMLHttpRequest.h"
 #include "JSXSLTProcessorConstructor.h"
 #include "Location.h"
 #include "MediaPlayer.h"
@@ -606,9 +606,9 @@ JSValue JSDOMWindow::uint16Array(ExecState* exec) const
     return getDOMConstructor<JSUint16ArrayConstructor>(exec, this);
 }
  
-JSValue JSDOMWindow::floatArray(ExecState* exec) const
+JSValue JSDOMWindow::float32Array(ExecState* exec) const
 {
-    return getDOMConstructor<JSFloatArrayConstructor>(exec, this);
+    return getDOMConstructor<JSFloat32ArrayConstructor>(exec, this);
 }
 
 // Temporary aliases to keep current WebGL content working during transition period to TypedArray spec.
@@ -650,7 +650,7 @@ JSValue JSDOMWindow::webGLUnsignedShortArray(ExecState* exec) const
 
 JSValue JSDOMWindow::webGLFloatArray(ExecState* exec) const
 {
-    return getDOMConstructor<JSFloatArrayConstructor>(exec, this);
+    return getDOMConstructor<JSFloat32ArrayConstructor>(exec, this);
 }
 #endif
  
diff --git a/WebCore/bindings/js/JSDOMWrapper.cpp b/WebCore/bindings/js/JSDOMWrapper.cpp
index 3fcdcc1..9548f2f 100644
--- a/WebCore/bindings/js/JSDOMWrapper.cpp
+++ b/WebCore/bindings/js/JSDOMWrapper.cpp
@@ -44,7 +44,7 @@ DOMObject::~DOMObject()
 
 bool DOMObject::defineOwnProperty(ExecState* exec, const Identifier&, PropertyDescriptor&, bool)
 {
-    throwError(exec, TypeError, "defineProperty is not supported on DOM Objects");
+    throwError(exec, createTypeError(exec, "defineProperty is not supported on DOM Objects"));
     return false;
 }
 
diff --git a/WebCore/bindings/js/JSDesktopNotificationsCustom.cpp b/WebCore/bindings/js/JSDesktopNotificationsCustom.cpp
index 3098752..6c4dfb4 100644
--- a/WebCore/bindings/js/JSDesktopNotificationsCustom.cpp
+++ b/WebCore/bindings/js/JSDesktopNotificationsCustom.cpp
@@ -50,10 +50,10 @@ JSValue JSNotificationCenter::requestPermission(ExecState* exec)
     // Permission request is only valid from page context.
     ScriptExecutionContext* context = impl()->context();
     if (context->isWorkerContext())
-        return throwError(exec, SyntaxError);
+        return throwSyntaxError(exec);
 
     if (!exec->argument(0).isObject())
-        return throwError(exec, TypeError);
+        return throwTypeError(exec);
 
     PassRefPtr<JSCustomVoidCallback> callback = JSCustomVoidCallback::create(exec->argument(0).getObject(), toJSDOMGlobalObject(static_cast<Document*>(context), exec));
 
diff --git a/WebCore/bindings/js/JSEventListener.cpp b/WebCore/bindings/js/JSEventListener.cpp
index e25a5d1..ceed445 100644
--- a/WebCore/bindings/js/JSEventListener.cpp
+++ b/WebCore/bindings/js/JSEventListener.cpp
@@ -93,7 +93,7 @@ void JSEventListener::handleEvent(ScriptExecutionContext* scriptExecutionContext
     JSValue handleEventFunction = jsFunction->get(exec, Identifier(exec, "handleEvent"));
 
     CallData callData;
-    CallType callType = handleEventFunction.getCallData(callData);
+    CallType callType = getCallData(handleEventFunction, callData);
     if (callType == CallTypeNone) {
         handleEventFunction = JSValue();
         callType = jsFunction->getCallData(callData);
diff --git a/WebCore/bindings/js/JSEventSourceConstructor.cpp b/WebCore/bindings/js/JSEventSourceConstructor.cpp
index e48489b..4524f70 100644
--- a/WebCore/bindings/js/JSEventSourceConstructor.cpp
+++ b/WebCore/bindings/js/JSEventSourceConstructor.cpp
@@ -56,28 +56,28 @@ JSEventSourceConstructor::JSEventSourceConstructor(ExecState* exec, JSDOMGlobalO
     putDirect(exec->propertyNames().length, jsNumber(exec, 1), ReadOnly|DontDelete|DontEnum);
 }
 
-static JSObject* constructEventSource(ExecState* exec, JSObject* constructor, const ArgList& args)
+static EncodedJSValue JSC_HOST_CALL constructEventSource(ExecState* exec)
 {
-    if (args.size() < 1)
-        return throwError(exec, SyntaxError, "Not enough arguments");
+    if (exec->argumentCount() < 1)
+        return throwVMError(exec, createSyntaxError(exec, "Not enough arguments"));
 
-    UString url = args.at(0).toString(exec);
+    UString url = exec->argument(0).toString(exec);
     if (exec->hadException())
-        return 0;
+        return JSValue::encode(JSValue());
 
-    JSEventSourceConstructor* jsConstructor =  static_cast<JSEventSourceConstructor*>(constructor);
+    JSEventSourceConstructor* jsConstructor =  static_cast<JSEventSourceConstructor*>(exec->callee());
     ScriptExecutionContext* context = jsConstructor->scriptExecutionContext();
     if (!context)
-        return throwError(exec, ReferenceError, "EventSource constructor associated document is unavailable");
+        return throwVMError(exec, createReferenceError(exec, "EventSource constructor associated document is unavailable"));
 
     ExceptionCode ec = 0;
     RefPtr<EventSource> eventSource = EventSource::create(ustringToString(url), context, ec);
     if (ec) {
         setDOMException(exec, ec);
-        return 0;
+        return JSValue::encode(JSValue());
     }
 
-    return asObject(toJS(exec, jsConstructor->globalObject(), eventSource.release()));
+    return JSValue::encode(asObject(toJS(exec, jsConstructor->globalObject(), eventSource.release())));
 }
 
 ConstructType JSEventSourceConstructor::getConstructData(ConstructData& constructData)
diff --git a/WebCore/bindings/js/JSFloat32ArrayConstructor.cpp b/WebCore/bindings/js/JSFloat32ArrayConstructor.cpp
new file mode 100644
index 0000000..08cffb5
--- /dev/null
+++ b/WebCore/bindings/js/JSFloat32ArrayConstructor.cpp
@@ -0,0 +1,86 @@
+/*
+ * Copyright (C) 2009 Apple Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
+ */
+
+#include "config.h"
+
+#if ENABLE(3D_CANVAS)
+
+#include "JSFloat32ArrayConstructor.h"
+
+#include "Document.h"
+#include "Float32Array.h"
+#include "JSArrayBuffer.h"
+#include "JSArrayBufferConstructor.h"
+#include "JSFloat32Array.h"
+#include <runtime/Error.h>
+
+namespace WebCore {
+
+using namespace JSC;
+
+const ClassInfo JSFloat32ArrayConstructor::s_info = { "Float32ArrayConstructor", &JSArrayBufferView::s_info, 0, 0 };
+
+JSFloat32ArrayConstructor::JSFloat32ArrayConstructor(ExecState* exec, JSDOMGlobalObject* globalObject)
+    : DOMConstructorObject(JSFloat32ArrayConstructor::createStructure(globalObject->objectPrototype()), globalObject)
+{
+    putDirect(exec->propertyNames().prototype, JSFloat32ArrayPrototype::self(exec, globalObject), DontDelete | ReadOnly);
+}
+
+JSObject* JSFloat32ArrayConstructor::createPrototype(ExecState* exec, JSGlobalObject* globalObject)
+{
+    return new (exec) JSFloat32ArrayPrototype(globalObject, JSFloat32ArrayPrototype::createStructure(globalObject->objectPrototype()));
+}
+
+bool JSFloat32ArrayConstructor::getOwnPropertySlot(ExecState* exec, const Identifier& propertyName, PropertySlot& slot)
+{
+    return getStaticValueSlot<JSFloat32ArrayConstructor, DOMObject>(exec, JSFloat32ArrayPrototype::s_info.staticPropHashTable, this, propertyName, slot);
+}
+
+bool JSFloat32ArrayConstructor::getOwnPropertyDescriptor(ExecState* exec, const Identifier& propertyName, PropertyDescriptor& descriptor)
+{
+    return getStaticValueDescriptor<JSFloat32ArrayConstructor, DOMObject>(exec, JSFloat32ArrayPrototype::s_info.staticPropHashTable, this, propertyName, descriptor);
+}
+
+static EncodedJSValue JSC_HOST_CALL constructCanvasFloatArray(ExecState* exec)
+{
+    ArgList args(exec);
+    JSFloat32ArrayConstructor* jsConstructor = static_cast<JSFloat32ArrayConstructor*>(exec->callee());
+    RefPtr<Float32Array> array = static_cast<Float32Array*>(construct<Float32Array, float>(exec, args).get());
+    if (!array.get()) {
+        setDOMException(exec, INDEX_SIZE_ERR);
+        return JSValue::encode(JSValue());
+    }
+    return JSValue::encode(asObject(toJS(exec, jsConstructor->globalObject(), array.get())));
+}
+
+JSC::ConstructType JSFloat32ArrayConstructor::getConstructData(JSC::ConstructData& constructData)
+{
+    constructData.native.function = constructCanvasFloatArray;
+    return ConstructTypeHost;
+}
+
+} // namespace WebCore
+
+#endif // ENABLE(3D_CANVAS)
diff --git a/WebCore/bindings/js/JSFloatArrayConstructor.h b/WebCore/bindings/js/JSFloat32ArrayConstructor.h
index 6d2dae7..c2f8b7e 100644
--- a/WebCore/bindings/js/JSFloatArrayConstructor.h
+++ b/WebCore/bindings/js/JSFloat32ArrayConstructor.h
@@ -23,24 +23,35 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
  */
 
-#ifndef JSFloatArrayConstructor_h
-#define JSFloatArrayConstructor_h
+#ifndef JSFloat32ArrayConstructor_h
+#define JSFloat32ArrayConstructor_h
 
 #include "JSDOMBinding.h"
 #include "JSDocument.h"
 
 namespace WebCore {
 
-    class JSFloatArrayConstructor : public DOMConstructorObject {
+    class JSFloat32ArrayConstructor : public DOMConstructorObject {
+        typedef DOMConstructorObject Base;
     public:
-        JSFloatArrayConstructor(JSC::ExecState*, JSDOMGlobalObject*);
+        JSFloat32ArrayConstructor(JSC::ExecState*, JSDOMGlobalObject*);
+        static JSC::JSObject* createPrototype(JSC::ExecState*, JSC::JSGlobalObject*);
+        virtual bool getOwnPropertySlot(JSC::ExecState*, const JSC::Identifier& propertyName, JSC::PropertySlot&);
+        virtual bool getOwnPropertyDescriptor(JSC::ExecState*, const JSC::Identifier& propertyName, JSC::PropertyDescriptor&);
         static const JSC::ClassInfo s_info;
 
+        static PassRefPtr<JSC::Structure> createStructure(JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), AnonymousSlotCount);
+        }
+
     private:
         virtual JSC::ConstructType getConstructData(JSC::ConstructData&);
         virtual const JSC::ClassInfo* classInfo() const { return &s_info; }
+    protected:
+        static const unsigned StructureFlags = JSC::OverridesGetOwnPropertySlot | Base::StructureFlags;
     };
 
 }
 
-#endif // JSFloatArrayConstructor_h
+#endif // JSFloat32ArrayConstructor_h
diff --git a/WebCore/bindings/js/JSFloatArrayCustom.cpp b/WebCore/bindings/js/JSFloat32ArrayCustom.cpp
index 8a82f98..7965274 100644
--- a/WebCore/bindings/js/JSFloatArrayCustom.cpp
+++ b/WebCore/bindings/js/JSFloat32ArrayCustom.cpp
@@ -28,27 +28,27 @@
 #if ENABLE(3D_CANVAS)
 
 #include "JSArrayBufferViewHelper.h"
-#include "JSFloatArray.h"
+#include "JSFloat32Array.h"
 
-#include "FloatArray.h"
+#include "Float32Array.h"
 
 using namespace JSC;
 
 namespace WebCore {
 
-void JSFloatArray::indexSetter(JSC::ExecState* exec, unsigned index, JSC::JSValue value)
+void JSFloat32Array::indexSetter(JSC::ExecState* exec, unsigned index, JSC::JSValue value)
 {
     impl()->set(index, static_cast<float>(value.toNumber(exec)));
 }
 
-JSC::JSValue toJS(JSC::ExecState* exec, JSDOMGlobalObject* globalObject, FloatArray* object)
+JSC::JSValue toJS(JSC::ExecState* exec, JSDOMGlobalObject* globalObject, Float32Array* object)
 {
-    return getDOMObjectWrapper<JSFloatArray>(exec, globalObject, object);
+    return getDOMObjectWrapper<JSFloat32Array>(exec, globalObject, object);
 }
 
-JSC::JSValue JSFloatArray::set(JSC::ExecState* exec)
+JSC::JSValue JSFloat32Array::set(JSC::ExecState* exec)
 {
-    return setWebGLArrayHelper(exec, impl(), toFloatArray);
+    return setWebGLArrayHelper(exec, impl(), toFloat32Array);
 }
 
 } // namespace WebCore
diff --git a/WebCore/bindings/js/JSFloatArrayConstructor.cpp b/WebCore/bindings/js/JSFloatArrayConstructor.cpp
deleted file mode 100644
index 57374af..0000000
--- a/WebCore/bindings/js/JSFloatArrayConstructor.cpp
+++ /dev/null
@@ -1,71 +0,0 @@
-/*
- * Copyright (C) 2009 Apple Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
- * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
- * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
- * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
- */
-
-#include "config.h"
-
-#if ENABLE(3D_CANVAS)
-
-#include "JSFloatArrayConstructor.h"
-
-#include "Document.h"
-#include "FloatArray.h"
-#include "JSArrayBuffer.h"
-#include "JSArrayBufferConstructor.h"
-#include "JSFloatArray.h"
-#include <runtime/Error.h>
-
-namespace WebCore {
-
-using namespace JSC;
-
-const ClassInfo JSFloatArrayConstructor::s_info = { "FloatArrayConstructor", &JSArrayBufferView::s_info, 0, 0 };
-
-JSFloatArrayConstructor::JSFloatArrayConstructor(ExecState* exec, JSDOMGlobalObject* globalObject)
-    : DOMConstructorObject(JSFloatArrayConstructor::createStructure(globalObject->objectPrototype()), globalObject)
-{
-    putDirect(exec->propertyNames().prototype, JSFloatArrayPrototype::self(exec, globalObject), None);
-    putDirect(exec->propertyNames().length, jsNumber(exec, 2), ReadOnly|DontDelete|DontEnum);
-}
-
-static JSObject* constructCanvasFloatArray(ExecState* exec, JSObject* constructor, const ArgList& args)
-{
-    JSFloatArrayConstructor* jsConstructor = static_cast<JSFloatArrayConstructor*>(constructor);
-    RefPtr<FloatArray> array = static_cast<FloatArray*>(construct<FloatArray, float>(exec, args).get());
-    if (!array.get()) {
-        setDOMException(exec, INDEX_SIZE_ERR);
-        return 0;
-    }
-    return asObject(toJS(exec, jsConstructor->globalObject(), array.get()));
-}
-
-JSC::ConstructType JSFloatArrayConstructor::getConstructData(JSC::ConstructData& constructData)
-{
-    constructData.native.function = constructCanvasFloatArray;
-    return ConstructTypeHost;
-}
-
-} // namespace WebCore
-
-#endif // ENABLE(3D_CANVAS)
diff --git a/WebCore/bindings/js/JSGeolocationCustom.cpp b/WebCore/bindings/js/JSGeolocationCustom.cpp
index 16849ec..bd36df8 100644
--- a/WebCore/bindings/js/JSGeolocationCustom.cpp
+++ b/WebCore/bindings/js/JSGeolocationCustom.cpp
@@ -31,12 +31,15 @@
 #include "DOMWindow.h"
 #include "ExceptionCode.h"
 #include "Geolocation.h"
-#include "GeolocationService.h"
 #include "JSCustomPositionCallback.h"
 #include "JSCustomPositionErrorCallback.h"
 #include "JSDOMWindow.h"
 #include "PositionOptions.h"
-#include <runtime/InternalFunction.h>
+#include <runtime/JSFunction.h>
+
+#if !ENABLE(CLIENT_BASED_GEOLOCATION)
+#include "GeolocationService.h"
+#endif
 
 using namespace JSC;
 using namespace std;
@@ -46,7 +49,8 @@ namespace WebCore {
 static PassRefPtr<PositionCallback> createPositionCallback(ExecState* exec, JSDOMGlobalObject* globalObject, JSValue value)
 {
     // The spec specifies 'FunctionOnly' for this object.
-    if (!value.inherits(&InternalFunction::info)) {
+    // FIXME: This check disallows callable objects created via JSC API. It's not clear what exactly the specification intends to allow.
+    if (!value.inherits(&JSFunction::info)) {
         setDOMException(exec, TYPE_MISMATCH_ERR);
         return 0;
     }
@@ -62,7 +66,8 @@ static PassRefPtr<PositionErrorCallback> createPositionErrorCallback(ExecState*
         return 0;
 
     // The spec specifies 'FunctionOnly' for this object.
-    if (!value.inherits(&InternalFunction::info)) {
+    // FIXME: This check disallows callable objects created via JSC API. It's not clear what exactly the specification intends to allow.
+    if (!value.inherits(&JSFunction::info)) {
         setDOMException(exec, TYPE_MISMATCH_ERR);
         return 0;
     }
diff --git a/WebCore/bindings/js/JSHTMLAllCollectionCustom.cpp b/WebCore/bindings/js/JSHTMLAllCollectionCustom.cpp
index 3d819ef..a504f25 100644
--- a/WebCore/bindings/js/JSHTMLAllCollectionCustom.cpp
+++ b/WebCore/bindings/js/JSHTMLAllCollectionCustom.cpp
@@ -34,6 +34,7 @@
 #include "JSNodeList.h"
 #include "Node.h"
 #include "StaticNodeList.h"
+#include <runtime/JSValue.h>
 #include <wtf/Vector.h>
 
 using namespace JSC;
@@ -58,10 +59,10 @@ static JSValue getNamedItems(ExecState* exec, JSHTMLAllCollection* collection, c
 
 // HTMLCollections are strange objects, they support both get and call,
 // so that document.forms.item(0) and document.forms(0) both work.
-static JSValue JSC_HOST_CALL callHTMLAllCollection(ExecState* exec)
+static EncodedJSValue JSC_HOST_CALL callHTMLAllCollection(ExecState* exec)
 {
     if (exec->argumentCount() < 1)
-        return jsUndefined();
+        return JSValue::encode(jsUndefined());
 
     // Do not use thisObj here. It can be the JSHTMLDocument, in the document.forms(i) case.
     JSHTMLAllCollection* jsCollection = static_cast<JSHTMLAllCollection*>(exec->callee());
@@ -75,10 +76,10 @@ static JSValue JSC_HOST_CALL callHTMLAllCollection(ExecState* exec)
         UString string = exec->argument(0).toString(exec);
         unsigned index = string.toUInt32(&ok, false);
         if (ok)
-            return toJS(exec, jsCollection->globalObject(), collection->item(index));
+            return JSValue::encode(toJS(exec, jsCollection->globalObject(), collection->item(index)));
 
         // Support for document.images('<name>') etc.
-        return getNamedItems(exec, jsCollection, Identifier(exec, string));
+        return JSValue::encode(getNamedItems(exec, jsCollection, Identifier(exec, string)));
     }
 
     // The second arg, if set, is the index of the item we want
@@ -90,13 +91,13 @@ static JSValue JSC_HOST_CALL callHTMLAllCollection(ExecState* exec)
         Node* node = collection->namedItem(pstr);
         while (node) {
             if (!index)
-                return toJS(exec, jsCollection->globalObject(), node);
+                return JSValue::encode(toJS(exec, jsCollection->globalObject(), node));
             node = collection->nextNamedItem(pstr);
             --index;
         }
     }
 
-    return jsUndefined();
+    return JSValue::encode(jsUndefined());
 }
 
 CallType JSHTMLAllCollection::getCallData(CallData& callData)
diff --git a/WebCore/bindings/js/JSHTMLCanvasElementCustom.cpp b/WebCore/bindings/js/JSHTMLCanvasElementCustom.cpp
index a69696a..ae9115e 100644
--- a/WebCore/bindings/js/JSHTMLCanvasElementCustom.cpp
+++ b/WebCore/bindings/js/JSHTMLCanvasElementCustom.cpp
@@ -88,17 +88,21 @@ JSValue JSHTMLCanvasElement::getContext(ExecState* exec)
 JSValue JSHTMLCanvasElement::toDataURL(ExecState* exec)
 {
     const String& type = valueToStringWithUndefinedOrNullCheck(exec, exec->argument(0));
-    double quality = 1.0;
+    HTMLCanvasElement* canvas = static_cast<HTMLCanvasElement*>(impl());
+    ExceptionCode ec = 0;
+    
+    JSC::JSValue result;
+    double quality;
+    double* qualityPtr = 0;
     if (exec->argumentCount() > 1) {
         JSValue v = exec->argument(1);
-        if (v.isNumber())
+        if (v.isNumber()) {
             quality = v.toNumber(exec);
-        if (!(0.0 <= quality && quality <= 1.0))
-            quality = 1.0;
+            qualityPtr = &quality;
+        }
     }
-    HTMLCanvasElement* canvas = static_cast<HTMLCanvasElement*>(impl());
-    ExceptionCode ec = 0;
-    JSC::JSValue result = jsString(exec, canvas->toDataURL(type, quality, ec));
+    
+    result = jsString(exec, canvas->toDataURL(type, qualityPtr, ec));
     setDOMException(exec, ec);
     return result;
 }
diff --git a/WebCore/bindings/js/JSHTMLCollectionCustom.cpp b/WebCore/bindings/js/JSHTMLCollectionCustom.cpp
index 24059b7..b0cfd99 100644
--- a/WebCore/bindings/js/JSHTMLCollectionCustom.cpp
+++ b/WebCore/bindings/js/JSHTMLCollectionCustom.cpp
@@ -55,10 +55,10 @@ static JSValue getNamedItems(ExecState* exec, JSHTMLCollection* collection, cons
 
 // HTMLCollections are strange objects, they support both get and call,
 // so that document.forms.item(0) and document.forms(0) both work.
-static JSValue JSC_HOST_CALL callHTMLCollection(ExecState* exec)
+static EncodedJSValue JSC_HOST_CALL callHTMLCollection(ExecState* exec)
 {
     if (exec->argumentCount() < 1)
-        return jsUndefined();
+        return JSValue::encode(jsUndefined());
 
     // Do not use thisObj here. It can be the JSHTMLDocument, in the document.forms(i) case.
     JSHTMLCollection* jsCollection = static_cast<JSHTMLCollection*>(exec->callee());
@@ -72,10 +72,10 @@ static JSValue JSC_HOST_CALL callHTMLCollection(ExecState* exec)
         UString string = exec->argument(0).toString(exec);
         unsigned index = string.toUInt32(&ok, false);
         if (ok)
-            return toJS(exec, jsCollection->globalObject(), collection->item(index));
+            return JSValue::encode(toJS(exec, jsCollection->globalObject(), collection->item(index)));
 
         // Support for document.images('<name>') etc.
-        return getNamedItems(exec, jsCollection, Identifier(exec, string));
+        return JSValue::encode(getNamedItems(exec, jsCollection, Identifier(exec, string)));
     }
 
     // The second arg, if set, is the index of the item we want
@@ -87,13 +87,13 @@ static JSValue JSC_HOST_CALL callHTMLCollection(ExecState* exec)
         Node* node = collection->namedItem(pstr);
         while (node) {
             if (!index)
-                return toJS(exec, jsCollection->globalObject(), node);
+                return JSValue::encode(toJS(exec, jsCollection->globalObject(), node));
             node = collection->nextNamedItem(pstr);
             --index;
         }
     }
 
-    return jsUndefined();
+    return JSValue::encode(jsUndefined());
 }
 
 CallType JSHTMLCollection::getCallData(CallData& callData)
diff --git a/WebCore/bindings/js/JSHTMLDocumentCustom.cpp b/WebCore/bindings/js/JSHTMLDocumentCustom.cpp
index 30cb3a2..a0e189e 100644
--- a/WebCore/bindings/js/JSHTMLDocumentCustom.cpp
+++ b/WebCore/bindings/js/JSHTMLDocumentCustom.cpp
@@ -40,8 +40,9 @@
 #include "JSDOMWindowShell.h"
 #include "JSHTMLCollection.h"
 #include "SegmentedString.h"
-#include "Tokenizer.h"
+#include "DocumentParser.h"
 #include <runtime/Error.h>
+#include <runtime/JSCell.h>
 
 using namespace JSC;
 
@@ -110,9 +111,9 @@ JSValue JSHTMLDocument::open(ExecState* exec)
             if (wrapper) {
                 JSValue function = wrapper->get(exec, Identifier(exec, "open"));
                 CallData callData;
-                CallType callType = function.getCallData(callData);
+                CallType callType = ::getCallData(function, callData);
                 if (callType == CallTypeNone)
-                    return throwError(exec, TypeError);
+                    return throwTypeError(exec);
                 return JSC::call(exec, function, callType, callData, wrapper, ArgList(exec));
             }
         }
diff --git a/WebCore/bindings/js/JSHTMLInputElementCustom.cpp b/WebCore/bindings/js/JSHTMLInputElementCustom.cpp
index d4be8dc..23db266 100644
--- a/WebCore/bindings/js/JSHTMLInputElementCustom.cpp
+++ b/WebCore/bindings/js/JSHTMLInputElementCustom.cpp
@@ -71,7 +71,7 @@ JSValue JSHTMLInputElement::selectionStart(ExecState* exec) const
 {
     HTMLInputElement* input = static_cast<HTMLInputElement*>(impl());
     if (!input->canHaveSelection())
-        return throwError(exec, TypeError);
+        return throwTypeError(exec);
 
     return jsNumber(exec, input->selectionStart());
 }
@@ -80,7 +80,7 @@ void JSHTMLInputElement::setSelectionStart(ExecState* exec, JSValue value)
 {
     HTMLInputElement* input = static_cast<HTMLInputElement*>(impl());
     if (!input->canHaveSelection())
-        throwError(exec, TypeError);
+        throwTypeError(exec);
 
     input->setSelectionStart(value.toInt32(exec));
 }
@@ -89,7 +89,7 @@ JSValue JSHTMLInputElement::selectionEnd(ExecState* exec) const
 {
     HTMLInputElement* input = static_cast<HTMLInputElement*>(impl());
     if (!input->canHaveSelection())
-        return throwError(exec, TypeError);
+        return throwTypeError(exec);
 
     return jsNumber(exec, input->selectionEnd());
 }
@@ -98,7 +98,7 @@ void JSHTMLInputElement::setSelectionEnd(ExecState* exec, JSValue value)
 {
     HTMLInputElement* input = static_cast<HTMLInputElement*>(impl());
     if (!input->canHaveSelection())
-        throwError(exec, TypeError);
+        throwTypeError(exec);
 
     input->setSelectionEnd(value.toInt32(exec));
 }
@@ -107,7 +107,7 @@ JSValue JSHTMLInputElement::setSelectionRange(ExecState* exec)
 {
     HTMLInputElement* input = static_cast<HTMLInputElement*>(impl());
     if (!input->canHaveSelection())
-        return throwError(exec, TypeError);
+        return throwTypeError(exec);
 
     int start = exec->argument(0).toInt32(exec);
     int end = exec->argument(1).toInt32(exec);
diff --git a/WebCore/bindings/js/JSImageConstructor.cpp b/WebCore/bindings/js/JSImageConstructor.cpp
index a574326..f2ad803 100644
--- a/WebCore/bindings/js/JSImageConstructor.cpp
+++ b/WebCore/bindings/js/JSImageConstructor.cpp
@@ -40,12 +40,12 @@ JSImageConstructor::JSImageConstructor(ExecState* exec, JSDOMGlobalObject* globa
     putDirect(exec->propertyNames().prototype, JSHTMLImageElementPrototype::self(exec, globalObject), None);
 }
 
-static JSObject* constructImage(ExecState* exec, JSObject* constructor, const ArgList& args)
+static EncodedJSValue JSC_HOST_CALL constructImage(ExecState* exec)
 {
-    JSImageConstructor* jsConstructor = static_cast<JSImageConstructor*>(constructor);
+    JSImageConstructor* jsConstructor = static_cast<JSImageConstructor*>(exec->callee());
     Document* document = jsConstructor->document();
     if (!document)
-        return throwError(exec, ReferenceError, "Image constructor associated document is unavailable");
+        return throwVMError(exec, createReferenceError(exec, "Image constructor associated document is unavailable"));
 
     // Calling toJS on the document causes the JS document wrapper to be
     // added to the window object. This is done to ensure that JSDocument::markChildren
@@ -55,17 +55,17 @@ static JSObject* constructImage(ExecState* exec, JSObject* constructor, const Ar
     int height;
     int* optionalWidth = 0;
     int* optionalHeight = 0;
-    if (args.size() > 0) {
-        width = args.at(0).toInt32(exec);
+    if (exec->argumentCount() > 0) {
+        width = exec->argument(0).toInt32(exec);
         optionalWidth = &width;
     }
-    if (args.size() > 1) {
-        height = args.at(1).toInt32(exec);
+    if (exec->argumentCount() > 1) {
+        height = exec->argument(1).toInt32(exec);
         optionalHeight = &height;
     }
 
-    return asObject(toJS(exec, jsConstructor->globalObject(),
-        HTMLImageElement::createForJSConstructor(document, optionalWidth, optionalHeight)));
+    return JSValue::encode(asObject(toJS(exec, jsConstructor->globalObject(),
+        HTMLImageElement::createForJSConstructor(document, optionalWidth, optionalHeight))));
 }
 
 ConstructType JSImageConstructor::getConstructData(ConstructData& constructData)
diff --git a/WebCore/bindings/js/JSInjectedScriptHostCustom.cpp b/WebCore/bindings/js/JSInjectedScriptHostCustom.cpp
index c13ea0c..a0d75f8 100644
--- a/WebCore/bindings/js/JSInjectedScriptHostCustom.cpp
+++ b/WebCore/bindings/js/JSInjectedScriptHostCustom.cpp
@@ -88,7 +88,7 @@ ScriptObject InjectedScriptHost::createInjectedScript(const String& source, Scri
         return ScriptObject();
     JSValue functionValue = comp.value();
     CallData callData;
-    CallType callType = functionValue.getCallData(callData);
+    CallType callType = getCallData(functionValue, callData);
     if (callType == CallTypeNone)
         return ScriptObject();
 
diff --git a/WebCore/bindings/js/JSInt16ArrayConstructor.cpp b/WebCore/bindings/js/JSInt16ArrayConstructor.cpp
index c8f725f..aaed578 100644
--- a/WebCore/bindings/js/JSInt16ArrayConstructor.cpp
+++ b/WebCore/bindings/js/JSInt16ArrayConstructor.cpp
@@ -46,19 +46,34 @@ const ClassInfo JSInt16ArrayConstructor::s_info = { "Int16ArrayConstructor", &JS
 JSInt16ArrayConstructor::JSInt16ArrayConstructor(ExecState* exec, JSDOMGlobalObject* globalObject)
     : DOMConstructorObject(JSInt16ArrayConstructor::createStructure(globalObject->objectPrototype()), globalObject)
 {
-    putDirect(exec->propertyNames().prototype, JSInt16ArrayPrototype::self(exec, globalObject), None);
-    putDirect(exec->propertyNames().length, jsNumber(exec, 2), ReadOnly|DontDelete|DontEnum);
+    putDirect(exec->propertyNames().prototype, JSInt16ArrayPrototype::self(exec, globalObject), DontDelete | ReadOnly);
 }
 
-static JSObject* constructCanvasShortArray(ExecState* exec, JSObject* constructor, const ArgList& args)
+JSObject* JSInt16ArrayConstructor::createPrototype(ExecState* exec, JSGlobalObject* globalObject)
 {
-    JSInt16ArrayConstructor* jsConstructor = static_cast<JSInt16ArrayConstructor*>(constructor);
+    return new (exec) JSInt16ArrayPrototype(globalObject, JSInt16ArrayPrototype::createStructure(globalObject->objectPrototype()));
+}
+
+bool JSInt16ArrayConstructor::getOwnPropertySlot(ExecState* exec, const Identifier& propertyName, PropertySlot& slot)
+{
+    return getStaticValueSlot<JSInt16ArrayConstructor, DOMObject>(exec, JSInt16ArrayPrototype::s_info.staticPropHashTable, this, propertyName, slot);
+}
+
+bool JSInt16ArrayConstructor::getOwnPropertyDescriptor(ExecState* exec, const Identifier& propertyName, PropertyDescriptor& descriptor)
+{
+    return getStaticValueDescriptor<JSInt16ArrayConstructor, DOMObject>(exec, JSInt16ArrayPrototype::s_info.staticPropHashTable, this, propertyName, descriptor);
+}
+
+static EncodedJSValue JSC_HOST_CALL constructCanvasShortArray(ExecState* exec)
+{
+    ArgList args(exec);
+    JSInt16ArrayConstructor* jsConstructor = static_cast<JSInt16ArrayConstructor*>(exec->callee());
     RefPtr<Int16Array> array = static_cast<Int16Array*>(construct<Int16Array, short>(exec, args).get());
     if (!array.get()) {
         setDOMException(exec, INDEX_SIZE_ERR);
-        return 0;
+        return JSValue::encode(JSValue());
     }
-    return asObject(toJS(exec, jsConstructor->globalObject(), array.get()));
+    return JSValue::encode(asObject(toJS(exec, jsConstructor->globalObject(), array.get())));
 }
 
 JSC::ConstructType JSInt16ArrayConstructor::getConstructData(JSC::ConstructData& constructData)
diff --git a/WebCore/bindings/js/JSInt16ArrayConstructor.h b/WebCore/bindings/js/JSInt16ArrayConstructor.h
index fb132e3..87908a0 100644
--- a/WebCore/bindings/js/JSInt16ArrayConstructor.h
+++ b/WebCore/bindings/js/JSInt16ArrayConstructor.h
@@ -32,13 +32,24 @@
 namespace WebCore {
 
     class JSInt16ArrayConstructor : public DOMConstructorObject {
+        typedef DOMConstructorObject Base;
     public:
         JSInt16ArrayConstructor(JSC::ExecState*, JSDOMGlobalObject*);
+        static JSC::JSObject* createPrototype(JSC::ExecState*, JSC::JSGlobalObject*);
+        virtual bool getOwnPropertySlot(JSC::ExecState*, const JSC::Identifier& propertyName, JSC::PropertySlot&);
+        virtual bool getOwnPropertyDescriptor(JSC::ExecState*, const JSC::Identifier& propertyName, JSC::PropertyDescriptor&);
         static const JSC::ClassInfo s_info;
 
+        static PassRefPtr<JSC::Structure> createStructure(JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), AnonymousSlotCount);
+        }
+
     private:
         virtual JSC::ConstructType getConstructData(JSC::ConstructData&);
         virtual const JSC::ClassInfo* classInfo() const { return &s_info; }
+    protected:
+        static const unsigned StructureFlags = JSC::OverridesGetOwnPropertySlot | Base::StructureFlags;
     };
 
 }
diff --git a/WebCore/bindings/js/JSInt32ArrayConstructor.cpp b/WebCore/bindings/js/JSInt32ArrayConstructor.cpp
index 5f79f1f..b44c9ca 100644
--- a/WebCore/bindings/js/JSInt32ArrayConstructor.cpp
+++ b/WebCore/bindings/js/JSInt32ArrayConstructor.cpp
@@ -45,19 +45,34 @@ const ClassInfo JSInt32ArrayConstructor::s_info = { "Int32ArrayConstructor", &JS
 JSInt32ArrayConstructor::JSInt32ArrayConstructor(ExecState* exec, JSDOMGlobalObject* globalObject)
     : DOMConstructorObject(JSInt32ArrayConstructor::createStructure(globalObject->objectPrototype()), globalObject)
 {
-    putDirect(exec->propertyNames().prototype, JSInt32ArrayPrototype::self(exec, globalObject), None);
-    putDirect(exec->propertyNames().length, jsNumber(exec, 2), ReadOnly|DontDelete|DontEnum);
+    putDirect(exec->propertyNames().prototype, JSInt32ArrayPrototype::self(exec, globalObject), DontDelete | ReadOnly);
 }
 
-static JSObject* constructCanvasIntArray(ExecState* exec, JSObject* constructor, const ArgList& args)
+JSObject* JSInt32ArrayConstructor::createPrototype(ExecState* exec, JSGlobalObject* globalObject)
 {
-    JSInt32ArrayConstructor* jsConstructor = static_cast<JSInt32ArrayConstructor*>(constructor);
+    return new (exec) JSInt32ArrayPrototype(globalObject, JSInt32ArrayPrototype::createStructure(globalObject->objectPrototype()));
+}
+
+bool JSInt32ArrayConstructor::getOwnPropertySlot(ExecState* exec, const Identifier& propertyName, PropertySlot& slot)
+{
+    return getStaticValueSlot<JSInt32ArrayConstructor, DOMObject>(exec, JSInt32ArrayPrototype::s_info.staticPropHashTable, this, propertyName, slot);
+}
+
+bool JSInt32ArrayConstructor::getOwnPropertyDescriptor(ExecState* exec, const Identifier& propertyName, PropertyDescriptor& descriptor)
+{
+    return getStaticValueDescriptor<JSInt32ArrayConstructor, DOMObject>(exec, JSInt32ArrayPrototype::s_info.staticPropHashTable, this, propertyName, descriptor);
+}
+
+static EncodedJSValue JSC_HOST_CALL constructCanvasIntArray(ExecState* exec)
+{
+    ArgList args(exec);
+    JSInt32ArrayConstructor* jsConstructor = static_cast<JSInt32ArrayConstructor*>(exec->callee());
     RefPtr<Int32Array> array = static_cast<Int32Array*>(construct<Int32Array, int>(exec, args).get());
     if (!array.get()) {
         setDOMException(exec, INDEX_SIZE_ERR);
-        return 0;
+        return JSValue::encode(JSValue());
     }
-    return asObject(toJS(exec, jsConstructor->globalObject(), array.get()));
+    return JSValue::encode(asObject(toJS(exec, jsConstructor->globalObject(), array.get())));
 }
 
 JSC::ConstructType JSInt32ArrayConstructor::getConstructData(JSC::ConstructData& constructData)
diff --git a/WebCore/bindings/js/JSInt32ArrayConstructor.h b/WebCore/bindings/js/JSInt32ArrayConstructor.h
index f15358c..6bed3c4 100644
--- a/WebCore/bindings/js/JSInt32ArrayConstructor.h
+++ b/WebCore/bindings/js/JSInt32ArrayConstructor.h
@@ -32,13 +32,24 @@
 namespace WebCore {
 
     class JSInt32ArrayConstructor : public DOMConstructorObject {
+        typedef DOMConstructorObject Base;
     public:
         JSInt32ArrayConstructor(JSC::ExecState*, JSDOMGlobalObject*);
+        static JSC::JSObject* createPrototype(JSC::ExecState*, JSC::JSGlobalObject*);
+        virtual bool getOwnPropertySlot(JSC::ExecState*, const JSC::Identifier& propertyName, JSC::PropertySlot&);
+        virtual bool getOwnPropertyDescriptor(JSC::ExecState*, const JSC::Identifier& propertyName, JSC::PropertyDescriptor&);
         static const JSC::ClassInfo s_info;
 
+        static PassRefPtr<JSC::Structure> createStructure(JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), AnonymousSlotCount);
+        }
+
     private:
         virtual JSC::ConstructType getConstructData(JSC::ConstructData&);
         virtual const JSC::ClassInfo* classInfo() const { return &s_info; }
+    protected:
+        static const unsigned StructureFlags = JSC::OverridesGetOwnPropertySlot | Base::StructureFlags;
     };
 
 }
diff --git a/WebCore/bindings/js/JSInt8ArrayConstructor.cpp b/WebCore/bindings/js/JSInt8ArrayConstructor.cpp
index ad922fe..e4c5688 100644
--- a/WebCore/bindings/js/JSInt8ArrayConstructor.cpp
+++ b/WebCore/bindings/js/JSInt8ArrayConstructor.cpp
@@ -45,19 +45,34 @@ const ClassInfo JSInt8ArrayConstructor::s_info = { "Int8ArrayConstructor", &JSAr
 JSInt8ArrayConstructor::JSInt8ArrayConstructor(ExecState* exec, JSDOMGlobalObject* globalObject)
     : DOMConstructorObject(JSInt8ArrayConstructor::createStructure(globalObject->objectPrototype()), globalObject)
 {
-    putDirect(exec->propertyNames().prototype, JSInt8ArrayPrototype::self(exec, globalObject), None);
-    putDirect(exec->propertyNames().length, jsNumber(exec, 2), ReadOnly|DontDelete|DontEnum);
+    putDirect(exec->propertyNames().prototype, JSInt8ArrayPrototype::self(exec, globalObject), DontDelete | ReadOnly);
 }
 
-static JSObject* constructCanvasByteArray(ExecState* exec, JSObject* constructor, const ArgList& args)
+JSObject* JSInt8ArrayConstructor::createPrototype(ExecState* exec, JSGlobalObject* globalObject)
 {
-    JSInt8ArrayConstructor* jsConstructor = static_cast<JSInt8ArrayConstructor*>(constructor);
+    return new (exec) JSInt8ArrayPrototype(globalObject, JSInt8ArrayPrototype::createStructure(globalObject->objectPrototype()));
+}
+
+bool JSInt8ArrayConstructor::getOwnPropertySlot(ExecState* exec, const Identifier& propertyName, PropertySlot& slot)
+{
+    return getStaticValueSlot<JSInt8ArrayConstructor, DOMObject>(exec, JSInt8ArrayPrototype::s_info.staticPropHashTable, this, propertyName, slot);
+}
+
+bool JSInt8ArrayConstructor::getOwnPropertyDescriptor(ExecState* exec, const Identifier& propertyName, PropertyDescriptor& descriptor)
+{
+    return getStaticValueDescriptor<JSInt8ArrayConstructor, DOMObject>(exec, JSInt8ArrayPrototype::s_info.staticPropHashTable, this, propertyName, descriptor);
+}
+
+static EncodedJSValue JSC_HOST_CALL constructCanvasByteArray(ExecState* exec)
+{
+    ArgList args(exec);
+    JSInt8ArrayConstructor* jsConstructor = static_cast<JSInt8ArrayConstructor*>(exec->callee());
     RefPtr<Int8Array> array = static_cast<Int8Array*>(construct<Int8Array, signed char>(exec, args).get());
     if (!array.get()) {
         setDOMException(exec, INDEX_SIZE_ERR);
-        return 0;
+        return JSValue::encode(JSValue());
     }
-    return asObject(toJS(exec, jsConstructor->globalObject(), array.get()));
+    return JSValue::encode(asObject(toJS(exec, jsConstructor->globalObject(), array.get())));
 }
 
 JSC::ConstructType JSInt8ArrayConstructor::getConstructData(JSC::ConstructData& constructData)
diff --git a/WebCore/bindings/js/JSInt8ArrayConstructor.h b/WebCore/bindings/js/JSInt8ArrayConstructor.h
index 4a9bd3a..96482fc 100644
--- a/WebCore/bindings/js/JSInt8ArrayConstructor.h
+++ b/WebCore/bindings/js/JSInt8ArrayConstructor.h
@@ -32,13 +32,24 @@
 namespace WebCore {
 
     class JSInt8ArrayConstructor : public DOMConstructorObject {
+        typedef DOMConstructorObject Base;
     public:
         JSInt8ArrayConstructor(JSC::ExecState*, JSDOMGlobalObject*);
+        static JSC::JSObject* createPrototype(JSC::ExecState*, JSC::JSGlobalObject*);
+        virtual bool getOwnPropertySlot(JSC::ExecState*, const JSC::Identifier& propertyName, JSC::PropertySlot&);
+        virtual bool getOwnPropertyDescriptor(JSC::ExecState*, const JSC::Identifier& propertyName, JSC::PropertyDescriptor&);
         static const JSC::ClassInfo s_info;
 
+        static PassRefPtr<JSC::Structure> createStructure(JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), AnonymousSlotCount);
+        }
+
     private:
         virtual JSC::ConstructType getConstructData(JSC::ConstructData&);
         virtual const JSC::ClassInfo* classInfo() const { return &s_info; }
+    protected:
+        static const unsigned StructureFlags = JSC::OverridesGetOwnPropertySlot | Base::StructureFlags;
     };
 
 }
diff --git a/WebCore/bindings/js/JSJavaScriptCallFrameCustom.cpp b/WebCore/bindings/js/JSJavaScriptCallFrameCustom.cpp
index 6c04930..0f47b7b 100644
--- a/WebCore/bindings/js/JSJavaScriptCallFrameCustom.cpp
+++ b/WebCore/bindings/js/JSJavaScriptCallFrameCustom.cpp
@@ -30,6 +30,7 @@
 
 #include "JavaScriptCallFrame.h"
 #include <runtime/ArrayPrototype.h>
+#include <runtime/Error.h>
 
 using namespace JSC;
 
@@ -41,7 +42,7 @@ JSValue JSJavaScriptCallFrame::evaluate(ExecState* exec)
     JSValue result = impl()->evaluate(exec->argument(0).toString(exec), exception);
 
     if (exception)
-        exec->setException(exception);
+        throwError(exec, exception);
 
     return result;
 }
diff --git a/WebCore/bindings/js/JSMessageChannelConstructor.cpp b/WebCore/bindings/js/JSMessageChannelConstructor.cpp
index 9721ba3..b188ed5 100644
--- a/WebCore/bindings/js/JSMessageChannelConstructor.cpp
+++ b/WebCore/bindings/js/JSMessageChannelConstructor.cpp
@@ -54,14 +54,14 @@ ConstructType JSMessageChannelConstructor::getConstructData(ConstructData& const
     return ConstructTypeHost;
 }
 
-JSObject* JSMessageChannelConstructor::construct(ExecState* exec, JSObject* constructor, const ArgList&)
+EncodedJSValue JSC_HOST_CALL JSMessageChannelConstructor::construct(ExecState* exec)
 {
-    JSMessageChannelConstructor* jsConstructor = static_cast<JSMessageChannelConstructor*>(constructor);
+    JSMessageChannelConstructor* jsConstructor = static_cast<JSMessageChannelConstructor*>(exec->callee());
     ScriptExecutionContext* context = jsConstructor->scriptExecutionContext();
     if (!context)
-        return throwError(exec, ReferenceError, "MessageChannel constructor associated document is unavailable");
+        return throwVMError(exec, createReferenceError(exec, "MessageChannel constructor associated document is unavailable"));
 
-    return asObject(toJS(exec, jsConstructor->globalObject(), MessageChannel::create(context)));
+    return JSValue::encode(asObject(toJS(exec, jsConstructor->globalObject(), MessageChannel::create(context))));
 }
 
 } // namespace WebCore
diff --git a/WebCore/bindings/js/JSMessageChannelConstructor.h b/WebCore/bindings/js/JSMessageChannelConstructor.h
index d958760..decf05b 100644
--- a/WebCore/bindings/js/JSMessageChannelConstructor.h
+++ b/WebCore/bindings/js/JSMessageChannelConstructor.h
@@ -38,7 +38,7 @@ namespace WebCore {
         static const JSC::ClassInfo s_info;
 
         virtual bool implementsHasInstance() const { return true; }
-        static JSC::JSObject* construct(JSC::ExecState*, JSC::JSObject*, const JSC::ArgList&);
+        static JSC::EncodedJSValue JSC_HOST_CALL construct(JSC::ExecState*);
         virtual JSC::ConstructType getConstructData(JSC::ConstructData&);
     };
 
diff --git a/WebCore/bindings/js/JSMessagePortCustom.cpp b/WebCore/bindings/js/JSMessagePortCustom.cpp
index 79c1811..227d6ed 100644
--- a/WebCore/bindings/js/JSMessagePortCustom.cpp
+++ b/WebCore/bindings/js/JSMessagePortCustom.cpp
@@ -86,7 +86,7 @@ void fillMessagePortArray(JSC::ExecState* exec, JSC::JSValue value, MessagePortA
         // Validation of Objects implementing an interface, per WebIDL spec 4.1.15.
         RefPtr<MessagePort> port = toMessagePort(value);
         if (!port) {
-            throwError(exec, TypeError);
+            throwTypeError(exec);
             return;
         }
         portArray[i] = port.release();
diff --git a/WebCore/bindings/js/JSNodeFilterCondition.cpp b/WebCore/bindings/js/JSNodeFilterCondition.cpp
index d34f5c1..b723286 100644
--- a/WebCore/bindings/js/JSNodeFilterCondition.cpp
+++ b/WebCore/bindings/js/JSNodeFilterCondition.cpp
@@ -46,7 +46,7 @@ short JSNodeFilterCondition::acceptNode(JSC::ExecState* exec, Node* filterNode)
     JSLock lock(SilenceAssertionsOnly);
 
     CallData callData;
-    CallType callType = m_filter.getCallData(callData);
+    CallType callType = getCallData(m_filter, callData);
     if (callType == CallTypeNone)
         return NodeFilter::FILTER_ACCEPT;
 
diff --git a/WebCore/bindings/js/JSNodeListCustom.cpp b/WebCore/bindings/js/JSNodeListCustom.cpp
index 6d51943..dd59c15 100644
--- a/WebCore/bindings/js/JSNodeListCustom.cpp
+++ b/WebCore/bindings/js/JSNodeListCustom.cpp
@@ -36,13 +36,13 @@ using namespace JSC;
 namespace WebCore {
 
 // Need to support call so that list(0) works.
-static JSValue JSC_HOST_CALL callNodeList(ExecState* exec)
+static EncodedJSValue JSC_HOST_CALL callNodeList(ExecState* exec)
 {
     bool ok;
     unsigned index = exec->argument(0).toString(exec).toUInt32(&ok);
     if (!ok)
-        return jsUndefined();
-    return toJS(exec, static_cast<JSNodeList*>(exec->callee())->impl()->item(index));
+        return JSValue::encode(jsUndefined());
+    return JSValue::encode(toJS(exec, static_cast<JSNodeList*>(exec->callee())->impl()->item(index)));
 }
 
 CallType JSNodeList::getCallData(CallData& callData)
diff --git a/WebCore/bindings/js/JSOptionConstructor.cpp b/WebCore/bindings/js/JSOptionConstructor.cpp
index 8b29136..d0a51cd 100644
--- a/WebCore/bindings/js/JSOptionConstructor.cpp
+++ b/WebCore/bindings/js/JSOptionConstructor.cpp
@@ -42,31 +42,31 @@ JSOptionConstructor::JSOptionConstructor(ExecState* exec, JSDOMGlobalObject* glo
     putDirect(exec->propertyNames().length, jsNumber(exec, 4), ReadOnly|DontDelete|DontEnum);
 }
 
-static JSObject* constructHTMLOptionElement(ExecState* exec, JSObject* constructor, const ArgList& args)
+static EncodedJSValue JSC_HOST_CALL constructHTMLOptionElement(ExecState* exec)
 {
-    JSOptionConstructor* jsConstructor = static_cast<JSOptionConstructor*>(constructor);
+    JSOptionConstructor* jsConstructor = static_cast<JSOptionConstructor*>(exec->callee());
     Document* document = jsConstructor->document();
     if (!document)
-        return throwError(exec, ReferenceError, "Option constructor associated document is unavailable");
+        return throwVMError(exec, createReferenceError(exec, "Option constructor associated document is unavailable"));
 
     String data;
-    if (!args.at(0).isUndefined())
-        data = ustringToString(args.at(0).toString(exec));
+    if ((exec->argumentCount() >= 1) && !exec->argument(0).isUndefined())
+        data = ustringToString(exec->argument(0).toString(exec));
 
     String value;
-    if (!args.at(1).isUndefined())
-        value = ustringToString(args.at(1).toString(exec));
-    bool defaultSelected = args.at(2).toBoolean(exec);
-    bool selected = args.at(3).toBoolean(exec);
+    if ((exec->argumentCount() >= 2)  && !exec->argument(1).isUndefined())
+        value = ustringToString(exec->argument(1).toString(exec));
+    bool defaultSelected = (exec->argumentCount() >= 3) && exec->argument(2).toBoolean(exec);
+    bool selected = (exec->argumentCount() >= 4) && exec->argument(3).toBoolean(exec);
 
     ExceptionCode ec = 0;
     RefPtr<HTMLOptionElement> element = HTMLOptionElement::createForJSConstructor(document, data, value, defaultSelected, selected, ec);
     if (ec) {
         setDOMException(exec, ec);
-        return 0;
+        return JSValue::encode(JSValue());
     }
 
-    return asObject(toJS(exec, jsConstructor->globalObject(), element.release()));
+    return JSValue::encode(asObject(toJS(exec, jsConstructor->globalObject(), element.release())));
 }
 
 ConstructType JSOptionConstructor::getConstructData(ConstructData& constructData)
diff --git a/WebCore/bindings/js/JSPluginElementFunctions.cpp b/WebCore/bindings/js/JSPluginElementFunctions.cpp
index a260782..7cc2e65 100644
--- a/WebCore/bindings/js/JSPluginElementFunctions.cpp
+++ b/WebCore/bindings/js/JSPluginElementFunctions.cpp
@@ -105,13 +105,13 @@ bool runtimeObjectCustomPut(ExecState* exec, const Identifier& propertyName, JSV
     return true;
 }
 
-static JSValue JSC_HOST_CALL callPlugin(ExecState* exec)
+static EncodedJSValue JSC_HOST_CALL callPlugin(ExecState* exec)
 {
     Instance* instance = pluginInstance(static_cast<JSHTMLElement*>(exec->callee())->impl());
     instance->begin();
     JSValue result = instance->invokeDefaultMethod(exec);
     instance->end();
-    return result;
+    return JSValue::encode(result);
 }
 
 CallType runtimeObjectGetCallData(HTMLElement* element, CallData& callData)
diff --git a/WebCore/bindings/js/JSSVGMatrixCustom.cpp b/WebCore/bindings/js/JSSVGMatrixCustom.cpp
index 149da8a..56f735e 100644
--- a/WebCore/bindings/js/JSSVGMatrixCustom.cpp
+++ b/WebCore/bindings/js/JSSVGMatrixCustom.cpp
@@ -34,10 +34,10 @@ namespace WebCore {
 JSValue JSSVGMatrix::multiply(ExecState* exec)
 {
     if (exec->argumentCount() < 1)
-        return throwError(exec, SyntaxError, "Not enough arguments");
+        return throwError(exec, createSyntaxError(exec, "Not enough arguments"));
 
     if (!exec->argument(0).inherits(&JSSVGMatrix::s_info))
-        return throwError(exec, TypeError, "secondMatrix argument was not a SVGMatrix");
+        return throwError(exec, createTypeError(exec, "secondMatrix argument was not a SVGMatrix"));
 
     JSSVGMatrix* matrixObj = static_cast<JSSVGMatrix*>(asObject(exec->argument(0)));
 
diff --git a/WebCore/bindings/js/JSSharedWorkerConstructor.cpp b/WebCore/bindings/js/JSSharedWorkerConstructor.cpp
index a66b1f7..f2bf6de 100644
--- a/WebCore/bindings/js/JSSharedWorkerConstructor.cpp
+++ b/WebCore/bindings/js/JSSharedWorkerConstructor.cpp
@@ -53,20 +53,20 @@ JSSharedWorkerConstructor::JSSharedWorkerConstructor(ExecState* exec, JSDOMGloba
     putDirect(exec->propertyNames().length, jsNumber(exec, 2), ReadOnly|DontDelete|DontEnum);
 }
 
-static JSObject* constructSharedWorker(ExecState* exec, JSObject* constructor, const ArgList& args)
+static EncodedJSValue JSC_HOST_CALL constructSharedWorker(ExecState* exec)
 {
-    JSSharedWorkerConstructor* jsConstructor = static_cast<JSSharedWorkerConstructor*>(constructor);
+    JSSharedWorkerConstructor* jsConstructor = static_cast<JSSharedWorkerConstructor*>(exec->callee());
 
-    if (args.size() < 1)
-        return throwError(exec, SyntaxError, "Not enough arguments");
+    if (exec->argumentCount() < 1)
+        return throwVMError(exec, createSyntaxError(exec, "Not enough arguments"));
 
-    UString scriptURL = args.at(0).toString(exec);
+    UString scriptURL = exec->argument(0).toString(exec);
     UString name;
-    if (args.size() > 1)
-        name = args.at(1).toString(exec);
+    if (exec->argumentCount() > 1)
+        name = exec->argument(1).toString(exec);
 
     if (exec->hadException())
-        return 0;
+        return JSValue::encode(JSValue());
 
     // FIXME: We need to use both the dynamic scope and the lexical scope (dynamic scope for resolving the worker URL)
     DOMWindow* window = asJSDOMWindow(exec->lexicalGlobalObject())->impl();
@@ -74,7 +74,7 @@ static JSObject* constructSharedWorker(ExecState* exec, JSObject* constructor, c
     RefPtr<SharedWorker> worker = SharedWorker::create(ustringToString(scriptURL), ustringToString(name), window->document(), ec);
     setDOMException(exec, ec);
 
-    return asObject(toJS(exec, jsConstructor->globalObject(), worker.release()));
+    return JSValue::encode(asObject(toJS(exec, jsConstructor->globalObject(), worker.release())));
 }
 
 ConstructType JSSharedWorkerConstructor::getConstructData(ConstructData& constructData)
diff --git a/WebCore/bindings/js/JSUint16ArrayConstructor.cpp b/WebCore/bindings/js/JSUint16ArrayConstructor.cpp
index 243c3a1..b1770c5 100644
--- a/WebCore/bindings/js/JSUint16ArrayConstructor.cpp
+++ b/WebCore/bindings/js/JSUint16ArrayConstructor.cpp
@@ -45,19 +45,34 @@ const ClassInfo JSUint16ArrayConstructor::s_info = { "Uint16ArrayConstructor", &
 JSUint16ArrayConstructor::JSUint16ArrayConstructor(ExecState* exec, JSDOMGlobalObject* globalObject)
     : DOMConstructorObject(JSUint16ArrayConstructor::createStructure(globalObject->objectPrototype()), globalObject)
 {
-    putDirect(exec->propertyNames().prototype, JSUint16ArrayPrototype::self(exec, globalObject), None);
-    putDirect(exec->propertyNames().length, jsNumber(exec, 2), ReadOnly|DontDelete|DontEnum);
+    putDirect(exec->propertyNames().prototype, JSUint16ArrayPrototype::self(exec, globalObject), DontDelete | ReadOnly);
 }
 
-static JSObject* constructCanvasUnsignedShortArray(ExecState* exec, JSObject* constructor, const ArgList& args)
+JSObject* JSUint16ArrayConstructor::createPrototype(ExecState* exec, JSGlobalObject* globalObject)
 {
-    JSUint16ArrayConstructor* jsConstructor = static_cast<JSUint16ArrayConstructor*>(constructor);
+    return new (exec) JSUint16ArrayPrototype(globalObject, JSUint16ArrayPrototype::createStructure(globalObject->objectPrototype()));
+}
+
+bool JSUint16ArrayConstructor::getOwnPropertySlot(ExecState* exec, const Identifier& propertyName, PropertySlot& slot)
+{
+    return getStaticValueSlot<JSUint16ArrayConstructor, DOMObject>(exec, JSUint16ArrayPrototype::s_info.staticPropHashTable, this, propertyName, slot);
+}
+
+bool JSUint16ArrayConstructor::getOwnPropertyDescriptor(ExecState* exec, const Identifier& propertyName, PropertyDescriptor& descriptor)
+{
+    return getStaticValueDescriptor<JSUint16ArrayConstructor, DOMObject>(exec, JSUint16ArrayPrototype::s_info.staticPropHashTable, this, propertyName, descriptor);
+}
+
+static EncodedJSValue JSC_HOST_CALL constructCanvasUnsignedShortArray(ExecState* exec)
+{
+    ArgList args(exec);
+    JSUint16ArrayConstructor* jsConstructor = static_cast<JSUint16ArrayConstructor*>(exec->callee());
     RefPtr<Uint16Array> array = static_cast<Uint16Array*>(construct<Uint16Array, unsigned short>(exec, args).get());
     if (!array.get()) {
         setDOMException(exec, INDEX_SIZE_ERR);
-        return 0;
+        return JSValue::encode(JSValue());
     }
-    return asObject(toJS(exec, jsConstructor->globalObject(), array.get()));
+    return JSValue::encode(asObject(toJS(exec, jsConstructor->globalObject(), array.get())));
 }
 
 JSC::ConstructType JSUint16ArrayConstructor::getConstructData(JSC::ConstructData& constructData)
diff --git a/WebCore/bindings/js/JSUint16ArrayConstructor.h b/WebCore/bindings/js/JSUint16ArrayConstructor.h
index a146d00..b950791 100644
--- a/WebCore/bindings/js/JSUint16ArrayConstructor.h
+++ b/WebCore/bindings/js/JSUint16ArrayConstructor.h
@@ -32,13 +32,24 @@
 namespace WebCore {
 
     class JSUint16ArrayConstructor : public DOMConstructorObject {
+        typedef DOMConstructorObject Base;
     public:
         JSUint16ArrayConstructor(JSC::ExecState*, JSDOMGlobalObject*);
+        static JSC::JSObject* createPrototype(JSC::ExecState*, JSC::JSGlobalObject*);
+        virtual bool getOwnPropertySlot(JSC::ExecState*, const JSC::Identifier& propertyName, JSC::PropertySlot&);
+        virtual bool getOwnPropertyDescriptor(JSC::ExecState*, const JSC::Identifier& propertyName, JSC::PropertyDescriptor&);
         static const JSC::ClassInfo s_info;
 
+        static PassRefPtr<JSC::Structure> createStructure(JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), AnonymousSlotCount);
+        }
+
     private:
         virtual JSC::ConstructType getConstructData(JSC::ConstructData&);
         virtual const JSC::ClassInfo* classInfo() const { return &s_info; }
+    protected:
+        static const unsigned StructureFlags = JSC::OverridesGetOwnPropertySlot | Base::StructureFlags;
     };
 
 }
diff --git a/WebCore/bindings/js/JSUint32ArrayConstructor.cpp b/WebCore/bindings/js/JSUint32ArrayConstructor.cpp
index b03f093..46ec9da 100644
--- a/WebCore/bindings/js/JSUint32ArrayConstructor.cpp
+++ b/WebCore/bindings/js/JSUint32ArrayConstructor.cpp
@@ -45,19 +45,34 @@ const ClassInfo JSUint32ArrayConstructor::s_info = { "Uint32ArrayConstructor", &
 JSUint32ArrayConstructor::JSUint32ArrayConstructor(ExecState* exec, JSDOMGlobalObject* globalObject)
     : DOMConstructorObject(JSUint32ArrayConstructor::createStructure(globalObject->objectPrototype()), globalObject)
 {
-    putDirect(exec->propertyNames().prototype, JSUint32ArrayPrototype::self(exec, globalObject), None);
-    putDirect(exec->propertyNames().length, jsNumber(exec, 2), ReadOnly|DontDelete|DontEnum);
+    putDirect(exec->propertyNames().prototype, JSUint32ArrayPrototype::self(exec, globalObject), DontDelete | ReadOnly);
 }
 
-static JSObject* constructCanvasUnsignedIntArray(ExecState* exec, JSObject* constructor, const ArgList& args)
+JSObject* JSUint32ArrayConstructor::createPrototype(ExecState* exec, JSGlobalObject* globalObject)
 {
-    JSUint32ArrayConstructor* jsConstructor = static_cast<JSUint32ArrayConstructor*>(constructor);
+    return new (exec) JSUint32ArrayPrototype(globalObject, JSUint32ArrayPrototype::createStructure(globalObject->objectPrototype()));
+}
+
+bool JSUint32ArrayConstructor::getOwnPropertySlot(ExecState* exec, const Identifier& propertyName, PropertySlot& slot)
+{
+    return getStaticValueSlot<JSUint32ArrayConstructor, DOMObject>(exec, JSUint32ArrayPrototype::s_info.staticPropHashTable, this, propertyName, slot);
+}
+
+bool JSUint32ArrayConstructor::getOwnPropertyDescriptor(ExecState* exec, const Identifier& propertyName, PropertyDescriptor& descriptor)
+{
+    return getStaticValueDescriptor<JSUint32ArrayConstructor, DOMObject>(exec, JSUint32ArrayPrototype::s_info.staticPropHashTable, this, propertyName, descriptor);
+}
+
+static EncodedJSValue JSC_HOST_CALL constructCanvasUnsignedIntArray(ExecState* exec)
+{
+    ArgList args(exec);
+    JSUint32ArrayConstructor* jsConstructor = static_cast<JSUint32ArrayConstructor*>(exec->callee());
     RefPtr<Uint32Array> array = static_cast<Uint32Array*>(construct<Uint32Array, unsigned int>(exec, args).get());
     if (!array.get()) {
         setDOMException(exec, INDEX_SIZE_ERR);
-        return 0;
+        return JSValue::encode(JSValue());
     }
-    return asObject(toJS(exec, jsConstructor->globalObject(), array.get()));
+    return JSValue::encode(asObject(toJS(exec, jsConstructor->globalObject(), array.get())));
 }
 
 JSC::ConstructType JSUint32ArrayConstructor::getConstructData(JSC::ConstructData& constructData)
diff --git a/WebCore/bindings/js/JSUint32ArrayConstructor.h b/WebCore/bindings/js/JSUint32ArrayConstructor.h
index a00c071..7cad849 100644
--- a/WebCore/bindings/js/JSUint32ArrayConstructor.h
+++ b/WebCore/bindings/js/JSUint32ArrayConstructor.h
@@ -32,13 +32,24 @@
 namespace WebCore {
 
     class JSUint32ArrayConstructor : public DOMConstructorObject {
+        typedef DOMConstructorObject Base;
     public:
         JSUint32ArrayConstructor(JSC::ExecState*, JSDOMGlobalObject*);
+        static JSC::JSObject* createPrototype(JSC::ExecState*, JSC::JSGlobalObject*);
+        virtual bool getOwnPropertySlot(JSC::ExecState*, const JSC::Identifier& propertyName, JSC::PropertySlot&);
+        virtual bool getOwnPropertyDescriptor(JSC::ExecState*, const JSC::Identifier& propertyName, JSC::PropertyDescriptor&);
         static const JSC::ClassInfo s_info;
 
+        static PassRefPtr<JSC::Structure> createStructure(JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), AnonymousSlotCount);
+        }
+
     private:
         virtual JSC::ConstructType getConstructData(JSC::ConstructData&);
         virtual const JSC::ClassInfo* classInfo() const { return &s_info; }
+    protected:
+        static const unsigned StructureFlags = JSC::OverridesGetOwnPropertySlot | Base::StructureFlags;
     };
 
 }
diff --git a/WebCore/bindings/js/JSUint8ArrayConstructor.cpp b/WebCore/bindings/js/JSUint8ArrayConstructor.cpp
index 531b860..0d47b51 100644
--- a/WebCore/bindings/js/JSUint8ArrayConstructor.cpp
+++ b/WebCore/bindings/js/JSUint8ArrayConstructor.cpp
@@ -46,19 +46,34 @@ const ClassInfo JSUint8ArrayConstructor::s_info = { "Uint8ArrayConstructor", &JS
 JSUint8ArrayConstructor::JSUint8ArrayConstructor(ExecState* exec, JSDOMGlobalObject* globalObject)
     : DOMConstructorObject(JSUint8ArrayConstructor::createStructure(globalObject->objectPrototype()), globalObject)
 {
-    putDirect(exec->propertyNames().prototype, JSUint8ArrayPrototype::self(exec, globalObject), None);
-    putDirect(exec->propertyNames().length, jsNumber(exec, 2), ReadOnly|DontDelete|DontEnum);
+    putDirect(exec->propertyNames().prototype, JSUint8ArrayPrototype::self(exec, globalObject), DontDelete | ReadOnly);
 }
 
-static JSObject* constructCanvasUnsignedByteArray(ExecState* exec, JSObject* constructor, const ArgList& args)
+JSObject* JSUint8ArrayConstructor::createPrototype(ExecState* exec, JSGlobalObject* globalObject)
 {
-    JSUint8ArrayConstructor* jsConstructor = static_cast<JSUint8ArrayConstructor*>(constructor);
+    return new (exec) JSUint8ArrayPrototype(globalObject, JSUint8ArrayPrototype::createStructure(globalObject->objectPrototype()));
+}
+
+bool JSUint8ArrayConstructor::getOwnPropertySlot(ExecState* exec, const Identifier& propertyName, PropertySlot& slot)
+{
+    return getStaticValueSlot<JSUint8ArrayConstructor, DOMObject>(exec, JSUint8ArrayPrototype::s_info.staticPropHashTable, this, propertyName, slot);
+}
+
+bool JSUint8ArrayConstructor::getOwnPropertyDescriptor(ExecState* exec, const Identifier& propertyName, PropertyDescriptor& descriptor)
+{
+    return getStaticValueDescriptor<JSUint8ArrayConstructor, DOMObject>(exec, JSUint8ArrayPrototype::s_info.staticPropHashTable, this, propertyName, descriptor);
+}
+
+static EncodedJSValue JSC_HOST_CALL constructCanvasUnsignedByteArray(ExecState* exec)
+{
+    ArgList args(exec);
+    JSUint8ArrayConstructor* jsConstructor = static_cast<JSUint8ArrayConstructor*>(exec->callee());
     RefPtr<Uint8Array> array = static_cast<Uint8Array*>(construct<Uint8Array, unsigned char>(exec, args).get());
     if (!array.get()) {
         setDOMException(exec, INDEX_SIZE_ERR);
-        return 0;
+        return JSValue::encode(JSValue());
     }
-    return asObject(toJS(exec, jsConstructor->globalObject(), array.get()));
+    return JSValue::encode(asObject(toJS(exec, jsConstructor->globalObject(), array.get())));
 }
 
 JSC::ConstructType JSUint8ArrayConstructor::getConstructData(JSC::ConstructData& constructData)
diff --git a/WebCore/bindings/js/JSUint8ArrayConstructor.h b/WebCore/bindings/js/JSUint8ArrayConstructor.h
index 05db4ee..644cf86 100644
--- a/WebCore/bindings/js/JSUint8ArrayConstructor.h
+++ b/WebCore/bindings/js/JSUint8ArrayConstructor.h
@@ -32,13 +32,24 @@
 namespace WebCore {
 
     class JSUint8ArrayConstructor : public DOMConstructorObject {
+        typedef DOMConstructorObject Base;
     public:
         JSUint8ArrayConstructor(JSC::ExecState*, JSDOMGlobalObject*);
+        static JSC::JSObject* createPrototype(JSC::ExecState*, JSC::JSGlobalObject*);
+        virtual bool getOwnPropertySlot(JSC::ExecState*, const JSC::Identifier& propertyName, JSC::PropertySlot&);
+        virtual bool getOwnPropertyDescriptor(JSC::ExecState*, const JSC::Identifier& propertyName, JSC::PropertyDescriptor&);
         static const JSC::ClassInfo s_info;
 
+        static PassRefPtr<JSC::Structure> createStructure(JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), AnonymousSlotCount);
+        }
+
     private:
         virtual JSC::ConstructType getConstructData(JSC::ConstructData&);
         virtual const JSC::ClassInfo* classInfo() const { return &s_info; }
+    protected:
+        static const unsigned StructureFlags = JSC::OverridesGetOwnPropertySlot | Base::StructureFlags;
     };
 
 }
diff --git a/WebCore/bindings/js/JSWebGLRenderingContextCustom.cpp b/WebCore/bindings/js/JSWebGLRenderingContextCustom.cpp
index 02dae08..eb4f549 100644
--- a/WebCore/bindings/js/JSWebGLRenderingContextCustom.cpp
+++ b/WebCore/bindings/js/JSWebGLRenderingContextCustom.cpp
@@ -36,7 +36,7 @@
 #include "JSHTMLImageElement.h"
 #include "JSImageData.h"
 #include "JSWebGLBuffer.h"
-#include "JSFloatArray.h"
+#include "JSFloat32Array.h"
 #include "JSWebGLFramebuffer.h"
 #include "JSInt32Array.h"
 #include "JSWebGLProgram.h"
@@ -48,7 +48,7 @@
 #include "JSWebKitCSSMatrix.h"
 #include "NotImplemented.h"
 #include "WebGLBuffer.h"
-#include "FloatArray.h"
+#include "Float32Array.h"
 #include "WebGLFramebuffer.h"
 #include "WebGLGetInfo.h"
 #include "Int32Array.h"
@@ -67,45 +67,6 @@ using namespace JSC;
 
 namespace WebCore {
 
-JSValue JSWebGLRenderingContext::bufferData(JSC::ExecState* exec)
-{
-    if (exec->argumentCount() != 3)
-        return throwError(exec, SyntaxError);
-
-    unsigned target = exec->argument(0).toInt32(exec);
-    unsigned usage = exec->argument(2).toInt32(exec);
-    ExceptionCode ec = 0;
-
-    // If argument 1 is a number, we are initializing this buffer to that size
-    if (!exec->argument(1).isObject()) {
-        unsigned int count = exec->argument(1).toInt32(exec);
-        static_cast<WebGLRenderingContext*>(impl())->bufferData(target, count, usage, ec);
-    } else {
-        ArrayBufferView* array = toArrayBufferView(exec->argument(1));
-        static_cast<WebGLRenderingContext*>(impl())->bufferData(target, array, usage, ec);
-    }
-
-    setDOMException(exec, ec);
-    return jsUndefined();
-}
-
-JSValue JSWebGLRenderingContext::bufferSubData(JSC::ExecState* exec)
-{
-    if (exec->argumentCount() != 3)
-        return throwError(exec, SyntaxError);
-
-    unsigned target = exec->argument(0).toInt32(exec);
-    unsigned offset = exec->argument(1).toInt32(exec);
-    ExceptionCode ec = 0;
-    
-    ArrayBufferView* array = toArrayBufferView(exec->argument(2));
-    
-    static_cast<WebGLRenderingContext*>(impl())->bufferSubData(target, offset, array, ec);
-
-    setDOMException(exec, ec);
-    return jsUndefined();
-}
-
 static JSValue toJS(ExecState* exec, JSDOMGlobalObject* globalObject, const WebGLGetInfo& info)
 {
     switch (info.getType()) {
@@ -152,7 +113,7 @@ enum ObjectType {
 static JSValue getObjectParameter(JSWebGLRenderingContext* obj, ExecState* exec, ObjectType objectType)
 {
     if (exec->argumentCount() != 2)
-        return throwError(exec, SyntaxError);
+        return throwSyntaxError(exec);
 
     ExceptionCode ec = 0;
     WebGLRenderingContext* context = static_cast<WebGLRenderingContext*>(obj->impl());
@@ -200,7 +161,7 @@ JSValue JSWebGLRenderingContext::getBufferParameter(ExecState* exec)
 JSValue JSWebGLRenderingContext::getFramebufferAttachmentParameter(ExecState* exec)
 {
     if (exec->argumentCount() != 3)
-        return throwError(exec, SyntaxError);
+        return throwSyntaxError(exec);
 
     ExceptionCode ec = 0;
     WebGLRenderingContext* context = static_cast<WebGLRenderingContext*>(impl());
@@ -224,7 +185,7 @@ JSValue JSWebGLRenderingContext::getFramebufferAttachmentParameter(ExecState* ex
 JSValue JSWebGLRenderingContext::getParameter(ExecState* exec)
 {
     if (exec->argumentCount() != 1)
-        return throwError(exec, SyntaxError);
+        return throwSyntaxError(exec);
 
     ExceptionCode ec = 0;
     WebGLRenderingContext* context = static_cast<WebGLRenderingContext*>(impl());
@@ -242,7 +203,7 @@ JSValue JSWebGLRenderingContext::getParameter(ExecState* exec)
 JSValue JSWebGLRenderingContext::getProgramParameter(ExecState* exec)
 {
     if (exec->argumentCount() != 2)
-        return throwError(exec, SyntaxError);
+        return throwSyntaxError(exec);
 
     ExceptionCode ec = 0;
     WebGLRenderingContext* context = static_cast<WebGLRenderingContext*>(impl());
@@ -266,7 +227,7 @@ JSValue JSWebGLRenderingContext::getRenderbufferParameter(ExecState* exec)
 JSValue JSWebGLRenderingContext::getShaderParameter(ExecState* exec)
 {
     if (exec->argumentCount() != 2)
-        return throwError(exec, SyntaxError);
+        return throwSyntaxError(exec);
 
     ExceptionCode ec = 0;
     WebGLRenderingContext* context = static_cast<WebGLRenderingContext*>(impl());
@@ -290,7 +251,7 @@ JSValue JSWebGLRenderingContext::getTexParameter(ExecState* exec)
 JSValue JSWebGLRenderingContext::getUniform(ExecState* exec)
 {
     if (exec->argumentCount() != 2)
-        return throwError(exec, SyntaxError);
+        return throwSyntaxError(exec);
 
     ExceptionCode ec = 0;
     WebGLRenderingContext* context = static_cast<WebGLRenderingContext*>(impl());
@@ -311,207 +272,6 @@ JSValue JSWebGLRenderingContext::getVertexAttrib(ExecState* exec)
     return getObjectParameter(this, exec, kVertexAttrib);
 }
 
-//   void texImage2D(in GLenum target, in GLint level, in GLenum internalformat, in GLsizei width, in GLsizei height, in GLint border, in GLenum format, in GLenum type, in ArrayBufferView pixels);
-//   void texImage2D(in GLenum target, in GLint level, in ImageData pixels, [Optional] GLboolean flipY, [Optional] in premultiplyAlpha);
-//   void texImage2D(in GLenum target, in GLint level, in HTMLImageElement image, [Optional] in GLboolean flipY, [Optional] in premultiplyAlpha);
-//   void texImage2D(in GLenum target, in GLint level, in HTMLCanvasElement canvas, [Optional] in GLboolean flipY, [Optional] in premultiplyAlpha);
-//   void texImage2D(in GLenum target, in GLint level, in HTMLVideoElement video, [Optional] in GLboolean flipY, [Optional] in premultiplyAlpha);
-JSValue JSWebGLRenderingContext::texImage2D(ExecState* exec)
-{ 
-    if (exec->argumentCount() < 3 || exec->argumentCount() > 9)
-        return throwError(exec, SyntaxError);
-
-    ExceptionCode ec = 0;
-    
-    WebGLRenderingContext* context = static_cast<WebGLRenderingContext*>(impl());    
-    unsigned target = exec->argument(0).toInt32(exec);
-    if (exec->hadException())    
-        return jsUndefined();
-    
-    unsigned level = exec->argument(1).toInt32(exec);
-    if (exec->hadException())    
-        return jsUndefined();
-
-    JSObject* o = 0;
-    
-    if (exec->argumentCount() <= 5) {
-        // This is one of the last 4 forms. Param 2 can be ImageData or <img>, <canvas> or <video> element.
-        JSValue value = exec->argument(2);
-    
-        if (!value.isObject())
-            return throwError(exec, TypeError);
-        
-        o = asObject(value);
-        
-        bool flipY = exec->argument(3).toBoolean(exec);
-        bool premultiplyAlpha = exec->argument(4).toBoolean(exec);
-        
-        if (o->inherits(&JSImageData::s_info)) {
-            ImageData* data = static_cast<ImageData*>(static_cast<JSImageData*>(o)->impl());
-            context->texImage2D(target, level, data, flipY, premultiplyAlpha, ec);
-        } else if (o->inherits(&JSHTMLImageElement::s_info)) {
-            HTMLImageElement* element = static_cast<HTMLImageElement*>(static_cast<JSHTMLImageElement*>(o)->impl());
-            context->texImage2D(target, level, element, flipY, premultiplyAlpha, ec);
-        } else if (o->inherits(&JSHTMLCanvasElement::s_info)) {
-            HTMLCanvasElement* element = static_cast<HTMLCanvasElement*>(static_cast<JSHTMLCanvasElement*>(o)->impl());
-            context->texImage2D(target, level, element, flipY, premultiplyAlpha, ec);
-#if ENABLE(VIDEO)
-        } else if (o->inherits(&JSHTMLVideoElement::s_info)) {
-            HTMLVideoElement* element = static_cast<HTMLVideoElement*>(static_cast<JSHTMLVideoElement*>(o)->impl());
-            context->texImage2D(target, level, element, flipY, premultiplyAlpha, ec);
-#endif
-        } else
-            ec = TYPE_MISMATCH_ERR;
-    } else {
-        if (exec->argumentCount() != 9)
-            return throwError(exec, SyntaxError);
-
-        // This must be the ArrayBufferView case
-        unsigned internalformat = exec->argument(2).toInt32(exec);
-        if (exec->hadException())    
-            return jsUndefined();
-
-        unsigned width = exec->argument(3).toInt32(exec);
-        if (exec->hadException())    
-            return jsUndefined();
-
-        unsigned height = exec->argument(4).toInt32(exec);
-        if (exec->hadException())    
-            return jsUndefined();
-
-        unsigned border = exec->argument(5).toInt32(exec);
-        if (exec->hadException())    
-            return jsUndefined();
-
-        unsigned format = exec->argument(6).toInt32(exec);
-        if (exec->hadException())    
-            return jsUndefined();
-
-        unsigned type = exec->argument(7).toInt32(exec);
-        if (exec->hadException())    
-            return jsUndefined();
-
-        JSValue value = exec->argument(8);
-            
-        // For this case passing 0 (for a null array) is allowed
-        if (value.isNull())
-            context->texImage2D(target, level, internalformat, width, height, border, format, type, 0, ec);
-        else if (value.isObject()) {
-            o = asObject(value);
-            
-            if (o->inherits(&JSArrayBufferView::s_info)) {
-                // FIXME: Need to check to make sure ArrayBufferView is a Int8Array or Int16Array,
-                // depending on the passed type parameter.
-                ArrayBufferView* obj = static_cast<ArrayBufferView*>(static_cast<JSArrayBufferView*>(o)->impl());
-                context->texImage2D(target, level, internalformat, width, height, border, format, type, obj, ec);
-            } else
-                return throwError(exec, TypeError);
-        } else 
-            return throwError(exec, TypeError);
-    }
-    
-    setDOMException(exec, ec);
-    return jsUndefined();    
-}
-
-//   void texSubImage2D(in GLenum target, in GLint level, in GLint xoffset, in GLint yoffset, in GLsizei width, in GLsizei height, in GLenum format, in GLenum type, in ArrayBufferView pixels);
-//   void texSubImage2D(in GLenum target, in GLint level, in GLint xoffset, in GLint yoffset, in ImageData pixels, [Optional] GLboolean flipY, [Optional] in premultiplyAlpha);
-//   void texSubImage2D(in GLenum target, in GLint level, in GLint xoffset, in GLint yoffset, in HTMLImageElement image, [Optional] GLboolean flipY, [Optional] in premultiplyAlpha);
-//   void texSubImage2D(in GLenum target, in GLint level, in GLint xoffset, in GLint yoffset, in HTMLCanvasElement canvas, [Optional] GLboolean flipY, [Optional] in premultiplyAlpha);
-//   void texSubImage2D(in GLenum target, in GLint level, in GLint xoffset, in GLint yoffset, in HTMLVideoElement video, [Optional] GLboolean flipY, [Optional] in premultiplyAlpha);
-JSValue JSWebGLRenderingContext::texSubImage2D(ExecState* exec)
-{ 
-    if (exec->argumentCount() < 5 || exec->argumentCount() > 9)
-        return throwError(exec, SyntaxError);
-
-    ExceptionCode ec = 0;
-
-    WebGLRenderingContext* context = static_cast<WebGLRenderingContext*>(impl());    
-    unsigned target = exec->argument(0).toInt32(exec);
-    if (exec->hadException())    
-        return jsUndefined();
-
-    unsigned level = exec->argument(1).toInt32(exec);
-    if (exec->hadException())    
-        return jsUndefined();
-    
-    unsigned xoff = exec->argument(2).toInt32(exec);
-    if (exec->hadException())    
-        return jsUndefined();
-    
-    unsigned yoff = exec->argument(3).toInt32(exec);
-    if (exec->hadException())    
-        return jsUndefined();
-    
-    JSObject* o = 0;
-        
-    if (exec->argumentCount() <= 7) {
-        // This is one of the last 4 forms. Param 4 can be <img>, <canvas> or <video> element, of the format param.
-        JSValue value = exec->argument(4);
-
-        if (!value.isObject())
-            return throwError(exec, SyntaxError);
-
-        o = asObject(value);
-
-        bool flipY = exec->argument(5).toBoolean(exec);
-        bool premultiplyAlpha = exec->argument(6).toBoolean(exec);
-        
-        if (o->inherits(&JSImageData::s_info)) {
-            ImageData* data = static_cast<ImageData*>(static_cast<JSImageData*>(o)->impl());
-            context->texSubImage2D(target, level, xoff, yoff, data, flipY, premultiplyAlpha, ec);
-        } else if (o->inherits(&JSHTMLImageElement::s_info)) {
-            HTMLImageElement* element = static_cast<HTMLImageElement*>(static_cast<JSHTMLImageElement*>(o)->impl());
-            context->texSubImage2D(target, level, xoff, yoff, element, flipY, premultiplyAlpha, ec);
-        } else if (o->inherits(&JSHTMLCanvasElement::s_info)) {
-            HTMLCanvasElement* element = static_cast<HTMLCanvasElement*>(static_cast<JSHTMLCanvasElement*>(o)->impl());
-            context->texSubImage2D(target, level, xoff, yoff, element, flipY, premultiplyAlpha, ec);
-#if ENABLE(VIDEO)
-        } else if (o->inherits(&JSHTMLVideoElement::s_info)) {
-            HTMLVideoElement* element = static_cast<HTMLVideoElement*>(static_cast<JSHTMLVideoElement*>(o)->impl());
-            context->texSubImage2D(target, level, xoff, yoff, element, flipY, premultiplyAlpha, ec);
-#endif
-        } else
-            ec = TYPE_MISMATCH_ERR;
-    } else {
-        // This must be the ArrayBufferView form
-        if (exec->argumentCount() != 9)
-            return throwError(exec, SyntaxError);
-
-        unsigned width = exec->argument(4).toInt32(exec);
-        if (exec->hadException())    
-            return jsUndefined();
-        
-        unsigned height = exec->argument(5).toInt32(exec);
-        if (exec->hadException())    
-            return jsUndefined();
-        
-        unsigned format = exec->argument(6).toInt32(exec);
-        if (exec->hadException())    
-            return jsUndefined();
-        
-        unsigned type = exec->argument(7).toInt32(exec);
-        if (exec->hadException())    
-            return jsUndefined();
-        
-        JSValue value = exec->argument(8);
-        if (!value.isObject())
-            context->texSubImage2D(target, level, xoff, yoff, width, height, format, type, 0, ec);
-        else {
-            o = asObject(value);
-        
-            if (o->inherits(&JSArrayBufferView::s_info)) {
-                ArrayBufferView* obj = static_cast<ArrayBufferView*>(static_cast<JSArrayBufferView*>(o)->impl());
-                context->texSubImage2D(target, level, xoff, yoff, width, height, format, type, obj, ec);
-            } else
-                return throwError(exec, TypeError);
-        }
-    }
-    
-    setDOMException(exec, ec);
-    return jsUndefined();
-}
-
 template<typename T, size_t inlineCapacity>
 bool toVector(JSC::ExecState* exec, JSC::JSValue value, Vector<T, inlineCapacity>& vector)
 {
@@ -558,7 +318,7 @@ static bool functionForUniform(DataFunctionToCall f)
 static JSC::JSValue dataFunctionf(DataFunctionToCall f, JSC::ExecState* exec, WebGLRenderingContext* context)
 {
     if (exec->argumentCount() != 2)
-        return throwError(exec, SyntaxError);
+        return throwSyntaxError(exec);
     
     WebGLUniformLocation* location = 0;
     long index = -1;
@@ -571,7 +331,7 @@ static JSC::JSValue dataFunctionf(DataFunctionToCall f, JSC::ExecState* exec, We
     if (exec->hadException())
         return jsUndefined();
         
-    RefPtr<FloatArray> webGLArray = toFloatArray(exec->argument(1));
+    RefPtr<Float32Array> webGLArray = toFloat32Array(exec->argument(1));
     if (exec->hadException())    
         return jsUndefined();
         
@@ -610,7 +370,7 @@ static JSC::JSValue dataFunctionf(DataFunctionToCall f, JSC::ExecState* exec, We
 
     Vector<float, 64> array;
     if (!toVector(exec, exec->argument(1), array))
-        return throwError(exec, TypeError);
+        return throwTypeError(exec);
 
     switch (f) {
     case f_uniform1v:
@@ -646,7 +406,7 @@ static JSC::JSValue dataFunctionf(DataFunctionToCall f, JSC::ExecState* exec, We
 static JSC::JSValue dataFunctioni(DataFunctionToCall f, JSC::ExecState* exec, WebGLRenderingContext* context)
 {
     if (exec->argumentCount() != 2)
-        return throwError(exec, SyntaxError);
+        return throwSyntaxError(exec);
 
     WebGLUniformLocation* location = toWebGLUniformLocation(exec->argument(0));
   
@@ -683,7 +443,7 @@ static JSC::JSValue dataFunctioni(DataFunctionToCall f, JSC::ExecState* exec, We
 
     Vector<int, 64> array;
     if (!toVector(exec, exec->argument(1), array))
-        return throwError(exec, TypeError);
+        return throwTypeError(exec);
 
     switch (f) {
     case f_uniform1v:
@@ -709,7 +469,7 @@ static JSC::JSValue dataFunctioni(DataFunctionToCall f, JSC::ExecState* exec, We
 static JSC::JSValue dataFunctionMatrix(DataFunctionMatrixToCall f, JSC::ExecState* exec, WebGLRenderingContext* context)
 {
     if (exec->argumentCount() != 3)
-        return throwError(exec, SyntaxError);
+        return throwSyntaxError(exec);
 
     WebGLUniformLocation* location = toWebGLUniformLocation(exec->argument(0));
 
@@ -720,7 +480,7 @@ static JSC::JSValue dataFunctionMatrix(DataFunctionMatrixToCall f, JSC::ExecStat
     if (exec->hadException())    
         return jsUndefined();
         
-    RefPtr<FloatArray> webGLArray = toFloatArray(exec->argument(2));
+    RefPtr<Float32Array> webGLArray = toFloat32Array(exec->argument(2));
     if (exec->hadException())    
         return jsUndefined();
         
@@ -744,7 +504,7 @@ static JSC::JSValue dataFunctionMatrix(DataFunctionMatrixToCall f, JSC::ExecStat
 
     Vector<float, 64> array;
     if (!toVector(exec, exec->argument(2), array))
-        return throwError(exec, TypeError);
+        return throwTypeError(exec);
 
     switch (f) {
     case f_uniformMatrix2fv:
diff --git a/WebCore/bindings/js/JSWebKitCSSMatrixConstructor.cpp b/WebCore/bindings/js/JSWebKitCSSMatrixConstructor.cpp
index baf174e..5013a6d 100644
--- a/WebCore/bindings/js/JSWebKitCSSMatrixConstructor.cpp
+++ b/WebCore/bindings/js/JSWebKitCSSMatrixConstructor.cpp
@@ -42,17 +42,17 @@ JSWebKitCSSMatrixConstructor::JSWebKitCSSMatrixConstructor(ExecState* exec, JSDO
     putDirect(exec->propertyNames().length, jsNumber(exec, 1), ReadOnly|DontDelete|DontEnum);
 }
 
-static JSObject* constructWebKitCSSMatrix(ExecState* exec, JSObject* constructor, const ArgList& args)
+static EncodedJSValue JSC_HOST_CALL constructWebKitCSSMatrix(ExecState* exec)
 {
-    JSWebKitCSSMatrixConstructor* jsConstructor = static_cast<JSWebKitCSSMatrixConstructor*>(constructor);
+    JSWebKitCSSMatrixConstructor* jsConstructor = static_cast<JSWebKitCSSMatrixConstructor*>(exec->callee());
     String s;
-    if (args.size() >= 1)
-        s = ustringToString(args.at(0).toString(exec));
+    if (exec->argumentCount() >= 1)
+        s = ustringToString(exec->argument(0).toString(exec));
     
     ExceptionCode ec = 0;
     RefPtr<WebKitCSSMatrix> matrix = WebKitCSSMatrix::create(s, ec);
     setDOMException(exec, ec);
-    return CREATE_DOM_OBJECT_WRAPPER(exec, jsConstructor->globalObject(), WebKitCSSMatrix, matrix.get());
+    return JSValue::encode(CREATE_DOM_OBJECT_WRAPPER(exec, jsConstructor->globalObject(), WebKitCSSMatrix, matrix.get()));
 }
 
 ConstructType JSWebKitCSSMatrixConstructor::getConstructData(ConstructData& constructData)
diff --git a/WebCore/bindings/js/JSWebKitPointConstructor.cpp b/WebCore/bindings/js/JSWebKitPointConstructor.cpp
index 27cc1db..c62f5b6 100644
--- a/WebCore/bindings/js/JSWebKitPointConstructor.cpp
+++ b/WebCore/bindings/js/JSWebKitPointConstructor.cpp
@@ -43,21 +43,21 @@ JSWebKitPointConstructor::JSWebKitPointConstructor(ExecState* exec, JSDOMGlobalO
     putDirect(exec->propertyNames().length, jsNumber(exec, 2), ReadOnly|DontDelete|DontEnum);
 }
 
-static JSObject* constructWebKitPoint(ExecState* exec, JSObject* constructor, const ArgList& args)
+static EncodedJSValue JSC_HOST_CALL constructWebKitPoint(ExecState* exec)
 {
-    JSWebKitPointConstructor* jsConstructor = static_cast<JSWebKitPointConstructor*>(constructor);
+    JSWebKitPointConstructor* jsConstructor = static_cast<JSWebKitPointConstructor*>(exec->callee());
 
     float x = 0;
     float y = 0;
-    if (args.size() >= 2) {
-        x = (float)args.at(0).toNumber(exec);
-        y = (float)args.at(1).toNumber(exec);
+    if (exec->argumentCount() >= 2) {
+        x = (float)exec->argument(0).toNumber(exec);
+        y = (float)exec->argument(1).toNumber(exec);
         if (isnan(x))
             x = 0;
         if (isnan(y))
             y = 0;
     }
-    return asObject(toJS(exec, jsConstructor->globalObject(), WebKitPoint::create(x, y)));
+    return JSValue::encode(asObject(toJS(exec, jsConstructor->globalObject(), WebKitPoint::create(x, y))));
 }
 
 JSC::ConstructType JSWebKitPointConstructor::getConstructData(JSC::ConstructData& constructData)
diff --git a/WebCore/bindings/js/JSWebSocketConstructor.cpp b/WebCore/bindings/js/JSWebSocketConstructor.cpp
index 57b7477..2384c7b 100644
--- a/WebCore/bindings/js/JSWebSocketConstructor.cpp
+++ b/WebCore/bindings/js/JSWebSocketConstructor.cpp
@@ -54,32 +54,32 @@ JSWebSocketConstructor::JSWebSocketConstructor(ExecState* exec, JSDOMGlobalObjec
     putDirect(exec->propertyNames().length, jsNumber(exec, 1), ReadOnly | DontDelete | DontEnum);
 }
 
-static JSObject* constructWebSocket(ExecState* exec, JSObject* constructor, const ArgList& args)
+static EncodedJSValue JSC_HOST_CALL constructWebSocket(ExecState* exec)
 {
-    JSWebSocketConstructor* jsConstructor = static_cast<JSWebSocketConstructor*>(constructor);
+    JSWebSocketConstructor* jsConstructor = static_cast<JSWebSocketConstructor*>(exec->callee());
     ScriptExecutionContext* context = jsConstructor->scriptExecutionContext();
     if (!context)
-        return throwError(exec, ReferenceError, "WebSocket constructor associated document is unavailable");
+        return throwVMError(exec, createReferenceError(exec, "WebSocket constructor associated document is unavailable"));
 
-    if (args.size() == 0)
-        return throwError(exec, SyntaxError, "Not enough arguments");
+    if (!exec->argumentCount())
+        return throwVMError(exec, createSyntaxError(exec, "Not enough arguments"));
 
-    const String& urlString = ustringToString(args.at(0).toString(exec));
+    const String& urlString = ustringToString(exec->argument(0).toString(exec));
     if (exec->hadException())
-        return throwError(exec, SyntaxError, "wrong URL");
+        return throwVMError(exec, createSyntaxError(exec, "wrong URL"));
     const KURL& url = context->completeURL(urlString);
     RefPtr<WebSocket> webSocket = WebSocket::create(context);
     ExceptionCode ec = 0;
-    if (args.size() < 2)
+    if (exec->argumentCount() < 2)
         webSocket->connect(url, ec);
     else {
-        const String& protocol = ustringToString(args.at(1).toString(exec));
+        const String& protocol = ustringToString(exec->argument(1).toString(exec));
         if (exec->hadException())
-            return 0;
+            return JSValue::encode(JSValue());
         webSocket->connect(url, protocol, ec);
     }
     setDOMException(exec, ec);
-    return CREATE_DOM_OBJECT_WRAPPER(exec, jsConstructor->globalObject(), WebSocket, webSocket.get());
+    return JSValue::encode(CREATE_DOM_OBJECT_WRAPPER(exec, jsConstructor->globalObject(), WebSocket, webSocket.get()));
 }
 
 ConstructType JSWebSocketConstructor::getConstructData(ConstructData& constructData)
diff --git a/WebCore/bindings/js/JSWebSocketCustom.cpp b/WebCore/bindings/js/JSWebSocketCustom.cpp
index 81b5b9e..eb0fda0 100644
--- a/WebCore/bindings/js/JSWebSocketCustom.cpp
+++ b/WebCore/bindings/js/JSWebSocketCustom.cpp
@@ -48,11 +48,11 @@ namespace WebCore {
 JSValue JSWebSocket::send(ExecState* exec)
 {
     if (exec->argumentCount() < 1)
-        return throwError(exec, SyntaxError, "Not enough arguments");
+        return throwError(exec, createSyntaxError(exec, "Not enough arguments"));
 
     const String& msg = ustringToString(exec->argument(0).toString(exec));
     if (exec->hadException())
-        return throwError(exec, SyntaxError, "bad message data.");
+        return throwError(exec, createSyntaxError(exec, "bad message data."));
     ExceptionCode ec = 0;
     JSValue ret = jsBoolean(impl()->send(msg, ec));
     setDOMException(exec, ec);
diff --git a/WebCore/bindings/js/JSWorkerConstructor.cpp b/WebCore/bindings/js/JSWorkerConstructor.cpp
index 43c685e..13d8ddc 100644
--- a/WebCore/bindings/js/JSWorkerConstructor.cpp
+++ b/WebCore/bindings/js/JSWorkerConstructor.cpp
@@ -49,16 +49,16 @@ JSWorkerConstructor::JSWorkerConstructor(ExecState* exec, JSDOMGlobalObject* glo
     putDirect(exec->propertyNames().length, jsNumber(exec, 1), ReadOnly|DontDelete|DontEnum);
 }
 
-static JSObject* constructWorker(ExecState* exec, JSObject* constructor, const ArgList& args)
+static EncodedJSValue JSC_HOST_CALL constructWorker(ExecState* exec)
 {
-    JSWorkerConstructor* jsConstructor = static_cast<JSWorkerConstructor*>(constructor);
+    JSWorkerConstructor* jsConstructor = static_cast<JSWorkerConstructor*>(exec->callee());
 
-    if (args.size() == 0)
-        return throwError(exec, SyntaxError, "Not enough arguments");
+    if (!exec->argumentCount())
+        return throwVMError(exec, createSyntaxError(exec, "Not enough arguments"));
 
-    UString scriptURL = args.at(0).toString(exec);
+    UString scriptURL = exec->argument(0).toString(exec);
     if (exec->hadException())
-        return 0;
+        return JSValue::encode(JSValue());
 
     // See section 4.8.2 step 14 of WebWorkers for why this is the lexicalGlobalObject. 
     DOMWindow* window = asJSDOMWindow(exec->lexicalGlobalObject())->impl();
@@ -67,10 +67,10 @@ static JSObject* constructWorker(ExecState* exec, JSObject* constructor, const A
     RefPtr<Worker> worker = Worker::create(ustringToString(scriptURL), window->document(), ec);
     if (ec) {
         setDOMException(exec, ec);
-        return 0;
+        return JSValue::encode(JSValue());
     }
 
-    return asObject(toJS(exec, jsConstructor->globalObject(), worker.release()));
+    return JSValue::encode(asObject(toJS(exec, jsConstructor->globalObject(), worker.release())));
 }
 
 ConstructType JSWorkerConstructor::getConstructData(ConstructData& constructData)
diff --git a/WebCore/bindings/js/JSWorkerContextCustom.cpp b/WebCore/bindings/js/JSWorkerContextCustom.cpp
index 47a867e..2bde58b 100644
--- a/WebCore/bindings/js/JSWorkerContextCustom.cpp
+++ b/WebCore/bindings/js/JSWorkerContextCustom.cpp
@@ -45,7 +45,7 @@
 #include "JSWebSocketConstructor.h"
 #include "JSWorkerLocation.h"
 #include "JSWorkerNavigator.h"
-#include "JSXMLHttpRequestConstructor.h"
+#include "JSXMLHttpRequest.h"
 #include "ScheduledAction.h"
 #include "WorkerContext.h"
 #include "WorkerLocation.h"
diff --git a/WebCore/bindings/js/JSXMLHttpRequestConstructor.cpp b/WebCore/bindings/js/JSXMLHttpRequestConstructor.cpp
deleted file mode 100644
index 91fff9a..0000000
--- a/WebCore/bindings/js/JSXMLHttpRequestConstructor.cpp
+++ /dev/null
@@ -1,59 +0,0 @@
-/*
- *  Copyright (C) 2004, 2007, 2008 Apple Inc. All rights reserved.
- *  Copyright (C) 2005, 2006 Alexey Proskuryakov <ap@nypop.com>
- *
- *  This library is free software; you can redistribute it and/or
- *  modify it under the terms of the GNU Lesser General Public
- *  License as published by the Free Software Foundation; either
- *  version 2 of the License, or (at your option) any later version.
- *
- *  This library is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- *  Lesser General Public License for more details.
- *
- *  You should have received a copy of the GNU Lesser General Public
- *  License along with this library; if not, write to the Free Software
- *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- */
-
-#include "config.h"
-#include "JSXMLHttpRequestConstructor.h"
-
-#include "JSXMLHttpRequest.h"
-#include "ScriptExecutionContext.h"
-#include "XMLHttpRequest.h"
-#include <runtime/Error.h>
-
-using namespace JSC;
-
-namespace WebCore {
-
-ASSERT_CLASS_FITS_IN_CELL(JSXMLHttpRequestConstructor);
-
-const ClassInfo JSXMLHttpRequestConstructor::s_info = { "XMLHttpRequestConstructor", 0, 0, 0 };
-
-JSXMLHttpRequestConstructor::JSXMLHttpRequestConstructor(ExecState* exec, JSDOMGlobalObject* globalObject)
-    : DOMConstructorObject(JSXMLHttpRequestConstructor::createStructure(globalObject->objectPrototype()), globalObject)
-{
-    putDirect(exec->propertyNames().prototype, JSXMLHttpRequestPrototype::self(exec, globalObject), None);
-}
-
-static JSObject* constructXMLHttpRequest(ExecState* exec, JSObject* constructor, const ArgList&)
-{
-    JSXMLHttpRequestConstructor* jsConstructor = static_cast<JSXMLHttpRequestConstructor*>(constructor);
-    ScriptExecutionContext* context = jsConstructor->scriptExecutionContext();
-    if (!context)
-        return throwError(exec, ReferenceError, "XMLHttpRequest constructor associated document is unavailable");
-
-    RefPtr<XMLHttpRequest> xmlHttpRequest = XMLHttpRequest::create(context);
-    return CREATE_DOM_OBJECT_WRAPPER(exec, jsConstructor->globalObject(), XMLHttpRequest, xmlHttpRequest.get());
-}
-
-ConstructType JSXMLHttpRequestConstructor::getConstructData(ConstructData& constructData)
-{
-    constructData.native.function = constructXMLHttpRequest;
-    return ConstructTypeHost;
-}
-
-} // namespace WebCore
diff --git a/WebCore/bindings/js/JSXMLHttpRequestConstructor.h b/WebCore/bindings/js/JSXMLHttpRequestConstructor.h
deleted file mode 100644
index 2cc4fcf..0000000
--- a/WebCore/bindings/js/JSXMLHttpRequestConstructor.h
+++ /dev/null
@@ -1,38 +0,0 @@
-/*
- *  Copyright (C) 2003, 2008 Apple Inc. All rights reserved.
- *  Copyright (C) 2005, 2006 Alexey Proskuryakov <ap@nypop.com>
- *
- *  This library is free software; you can redistribute it and/or
- *  modify it under the terms of the GNU Lesser General Public
- *  License as published by the Free Software Foundation; either
- *  version 2 of the License, or (at your option) any later version.
- *
- *  This library is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- *  Lesser General Public License for more details.
- *
- *  You should have received a copy of the GNU Lesser General Public
- *  License along with this library; if not, write to the Free Software
- *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- */
-
-#ifndef JSXMLHttpRequestConstructor_h
-#define JSXMLHttpRequestConstructor_h
-
-#include "JSDOMBinding.h"
-
-namespace WebCore {
-
-class JSXMLHttpRequestConstructor : public DOMConstructorObject {
-public:
-    JSXMLHttpRequestConstructor(JSC::ExecState*, JSDOMGlobalObject*);
-    static const JSC::ClassInfo s_info;
-private:
-    virtual JSC::ConstructType getConstructData(JSC::ConstructData&);
-    virtual const JSC::ClassInfo* classInfo() const { return &s_info; }
-};
-
-} // namespace WebCore
-
-#endif // JSXMLHttpRequestConstructor_h
diff --git a/WebCore/bindings/js/JSXMLHttpRequestCustom.cpp b/WebCore/bindings/js/JSXMLHttpRequestCustom.cpp
index 420bf37..da75139 100644
--- a/WebCore/bindings/js/JSXMLHttpRequestCustom.cpp
+++ b/WebCore/bindings/js/JSXMLHttpRequestCustom.cpp
@@ -65,7 +65,7 @@ void JSXMLHttpRequest::markChildren(MarkStack& markStack)
 JSValue JSXMLHttpRequest::open(ExecState* exec)
 {
     if (exec->argumentCount() < 2)
-        return throwError(exec, SyntaxError, "Not enough arguments");
+        return throwError(exec, createSyntaxError(exec, "Not enough arguments"));
 
     const KURL& url = impl()->scriptExecutionContext()->completeURL(ustringToString(exec->argument(1).toString(exec)));
     String method = ustringToString(exec->argument(0).toString(exec));
@@ -127,4 +127,15 @@ JSValue JSXMLHttpRequest::responseText(ExecState* exec) const
     return jsOwnedStringOrNull(exec, impl()->responseText());
 }
 
+EncodedJSValue JSC_HOST_CALL JSXMLHttpRequestConstructor::constructJSXMLHttpRequest(ExecState* exec)
+{
+    JSXMLHttpRequestConstructor* jsConstructor = static_cast<JSXMLHttpRequestConstructor*>(exec->callee());
+    ScriptExecutionContext* context = jsConstructor->scriptExecutionContext();
+    if (!context)
+        return throwVMError(exec, createReferenceError(exec, "XMLHttpRequest constructor associated document is unavailable"));
+
+    RefPtr<XMLHttpRequest> xmlHttpRequest = XMLHttpRequest::create(context);
+    return JSValue::encode(CREATE_DOM_OBJECT_WRAPPER(exec, jsConstructor->globalObject(), XMLHttpRequest, xmlHttpRequest.get()));
+}
+
 } // namespace WebCore
diff --git a/WebCore/bindings/js/JSXSLTProcessorConstructor.cpp b/WebCore/bindings/js/JSXSLTProcessorConstructor.cpp
index 07fec72..b2ebef3 100644
--- a/WebCore/bindings/js/JSXSLTProcessorConstructor.cpp
+++ b/WebCore/bindings/js/JSXSLTProcessorConstructor.cpp
@@ -47,10 +47,10 @@ JSXSLTProcessorConstructor::JSXSLTProcessorConstructor(ExecState* exec, JSDOMGlo
     putDirect(exec->propertyNames().prototype, JSXSLTProcessorPrototype::self(exec, globalObject), None);
 }
 
-static JSObject* constructXSLTProcessor(ExecState* exec, JSObject* constructor, const ArgList&)
+static EncodedJSValue JSC_HOST_CALL constructXSLTProcessor(ExecState* exec)
 {
-    JSXSLTProcessorConstructor* jsConstructor = static_cast<JSXSLTProcessorConstructor*>(constructor);
-    return CREATE_DOM_OBJECT_WRAPPER(exec, jsConstructor->globalObject(), XSLTProcessor, XSLTProcessor::create().get());
+    JSXSLTProcessorConstructor* jsConstructor = static_cast<JSXSLTProcessorConstructor*>(exec->callee());
+    return JSValue::encode(CREATE_DOM_OBJECT_WRAPPER(exec, jsConstructor->globalObject(), XSLTProcessor, XSLTProcessor::create().get()));
 }
 
 ConstructType JSXSLTProcessorConstructor::getConstructData(ConstructData& constructData)
diff --git a/WebCore/bindings/js/ScheduledAction.cpp b/WebCore/bindings/js/ScheduledAction.cpp
index 5a45e87..f69f8bd 100644
--- a/WebCore/bindings/js/ScheduledAction.cpp
+++ b/WebCore/bindings/js/ScheduledAction.cpp
@@ -51,7 +51,7 @@ PassOwnPtr<ScheduledAction> ScheduledAction::create(ExecState* exec, DOMWrapperW
 {
     JSValue v = exec->argument(0);
     CallData callData;
-    if (v.getCallData(callData) == CallTypeNone) {
+    if (getCallData(v, callData) == CallTypeNone) {
         UString string = v.toString(exec);
         if (exec->hadException())
             return 0;
@@ -91,7 +91,7 @@ void ScheduledAction::executeFunctionInContext(JSGlobalObject* globalObject, JSV
     JSLock lock(SilenceAssertionsOnly);
 
     CallData callData;
-    CallType callType = m_function.get().getCallData(callData);
+    CallType callType = getCallData(m_function.get(), callData);
     if (callType == CallTypeNone)
         return;
 
diff --git a/WebCore/bindings/js/ScriptController.cpp b/WebCore/bindings/js/ScriptController.cpp
index 3dcbb0b..5c4bd4c 100644
--- a/WebCore/bindings/js/ScriptController.cpp
+++ b/WebCore/bindings/js/ScriptController.cpp
@@ -87,6 +87,11 @@ ScriptController::~ScriptController()
 {
     disconnectPlatformScriptObjects();
 
+    if (m_cacheableBindingRootObject) {
+        m_cacheableBindingRootObject->invalidate();
+        m_cacheableBindingRootObject = 0;
+    }
+
     // It's likely that destroying m_windowShells will create a lot of garbage.
     if (!m_windowShells.isEmpty()) {
         while (!m_windowShells.isEmpty())
@@ -329,6 +334,18 @@ void ScriptController::updateSecurityOrigin()
     // Our bindings do not do anything in this case.
 }
 
+Bindings::RootObject* ScriptController::cacheableBindingRootObject()
+{
+    if (!canExecuteScripts(NotAboutToExecuteScript))
+        return 0;
+
+    if (!m_cacheableBindingRootObject) {
+        JSLock lock(SilenceAssertionsOnly);
+        m_cacheableBindingRootObject = Bindings::RootObject::create(0, globalObject(pluginWorld()));
+    }
+    return m_cacheableBindingRootObject.get();
+}
+
 Bindings::RootObject* ScriptController::bindingRootObject()
 {
     if (!canExecuteScripts(NotAboutToExecuteScript))
diff --git a/WebCore/bindings/js/ScriptController.h b/WebCore/bindings/js/ScriptController.h
index 16fe4f2..ee7cc7d 100644
--- a/WebCore/bindings/js/ScriptController.h
+++ b/WebCore/bindings/js/ScriptController.h
@@ -158,6 +158,7 @@ public:
 
     PassScriptInstance createScriptInstanceForWidget(Widget*);
     JSC::Bindings::RootObject* bindingRootObject();
+    JSC::Bindings::RootObject* cacheableBindingRootObject();
 
     PassRefPtr<JSC::Bindings::RootObject> createRootObject(void* nativeHandle);
 
@@ -195,8 +196,13 @@ private:
     bool m_paused;
     bool m_allowPopupsFromPlugin;
 
-    // The root object used for objects bound outside the context of a plugin.
+    // The root object used for objects bound outside the context of a plugin, such
+    // as NPAPI plugins. The plugins using these objects prevent a page from being cached so they
+    // are safe to invalidate() when WebKit navigates away from the page that contains them.
     RefPtr<JSC::Bindings::RootObject> m_bindingRootObject;
+    // Unlike m_bindingRootObject these objects are used in pages that are cached, so they are not invalidate()'d.
+    // This ensures they are still available when the page is restored.
+    RefPtr<JSC::Bindings::RootObject> m_cacheableBindingRootObject;
     RootObjectMap m_rootObjects;
 #if ENABLE(NETSCAPE_PLUGIN_API)
     NPObject* m_windowScriptNPObject;
diff --git a/WebCore/bindings/js/ScriptDebugServer.cpp b/WebCore/bindings/js/ScriptDebugServer.cpp
index 94d7e73..eb0923b 100644
--- a/WebCore/bindings/js/ScriptDebugServer.cpp
+++ b/WebCore/bindings/js/ScriptDebugServer.cpp
@@ -126,13 +126,15 @@ void ScriptDebugServer::pageCreated(Page* page)
     page->setDebugger(this);
 }
 
+bool ScriptDebugServer::isDebuggerAlwaysEnabled()
+{
+    return false;
+}
+
 bool ScriptDebugServer::hasListenersInterestedInPage(Page* page)
 {
     ASSERT_ARG(page, page);
 
-    if (hasGlobalListeners())
-        return true;
-
     return m_pageListenersMap.contains(page);
 }
 
@@ -238,6 +240,12 @@ void ScriptDebugServer::stepOutOfFunction()
     m_doneProcessingDebuggerEvents = true;
 }
 
+bool ScriptDebugServer::editScriptSource(const String&, const String&, String&)
+{
+    // FIXME(40300): implement this.
+    return false;
+}
+
 JavaScriptCallFrame* ScriptDebugServer::currentCallFrame()
 {
     if (!m_paused)
@@ -257,7 +265,7 @@ void ScriptDebugServer::dispatchDidContinue(ScriptDebugListener* listener)
     listener->didContinue();
 }
 
-void ScriptDebugServer::dispatchDidParseSource(const ListenerSet& listeners, const JSC::SourceCode& source)
+void ScriptDebugServer::dispatchDidParseSource(const ListenerSet& listeners, const JSC::SourceCode& source, ScriptWorldType worldType)
 {
     String sourceID = ustringToString(JSC::UString::from(source.provider()->asID()));
     String url = ustringToString(source.provider()->url());
@@ -267,7 +275,7 @@ void ScriptDebugServer::dispatchDidParseSource(const ListenerSet& listeners, con
     Vector<ScriptDebugListener*> copy;
     copyToVector(listeners, copy);
     for (size_t i = 0; i < copy.size(); ++i)
-        copy[i]->didParseSource(sourceID, url, data, firstLine);
+        copy[i]->didParseSource(sourceID, url, data, firstLine, worldType);
 }
 
 void ScriptDebugServer::dispatchFailedToParseSource(const ListenerSet& listeners, const SourceCode& source, int errorLine, const String& errorMessage)
@@ -291,6 +299,13 @@ static Page* toPage(JSGlobalObject* globalObject)
     return frame ? frame->page() : 0;
 }
 
+static ScriptWorldType currentWorldType(ExecState* exec)
+{
+    if (currentWorld(exec) == mainThreadNormalWorld())
+        return MAIN_WORLD;
+    return EXTENSIONS_WORLD;
+}
+
 void ScriptDebugServer::detach(JSGlobalObject* globalObject)
 {
     // If we're detaching from the currently executing global object, manually tear down our
@@ -313,23 +328,18 @@ void ScriptDebugServer::sourceParsed(ExecState* exec, const SourceCode& source,
     if (!page)
         return;
 
+    ScriptWorldType worldType = currentWorldType(exec);
+
     m_callingListeners = true;
 
     bool isError = errorLine != -1;
 
-    if (hasGlobalListeners()) {
-        if (isError)
-            dispatchFailedToParseSource(m_listeners, source, errorLine, ustringToString(errorMessage));
-        else
-            dispatchDidParseSource(m_listeners, source);
-    }
-
     if (ListenerSet* pageListeners = m_pageListenersMap.get(page)) {
         ASSERT(!pageListeners->isEmpty());
         if (isError)
             dispatchFailedToParseSource(*pageListeners, source, errorLine, ustringToString(errorMessage));
         else
-            dispatchDidParseSource(*pageListeners, source);
+            dispatchDidParseSource(*pageListeners, source, worldType);
     }
 
     m_callingListeners = false;
@@ -352,8 +362,6 @@ void ScriptDebugServer::dispatchFunctionToListeners(JavaScriptExecutionCallback
 
     ASSERT(hasListeners());
 
-    dispatchFunctionToListeners(m_listeners, callback);
-
     if (ListenerSet* pageListeners = m_pageListenersMap.get(page)) {
         ASSERT(!pageListeners->isEmpty());
         dispatchFunctionToListeners(*pageListeners, callback);
@@ -574,7 +582,7 @@ void ScriptDebugServer::didAddListener(Page* page)
 
 void ScriptDebugServer::didRemoveListener(Page* page)
 {
-    if (hasGlobalListeners() || (page && hasListenersInterestedInPage(page)))
+    if (page && hasListenersInterestedInPage(page))
         return;
 
     recompileAllJSFunctionsSoon();
diff --git a/WebCore/bindings/js/ScriptDebugServer.h b/WebCore/bindings/js/ScriptDebugServer.h
index cfada27..a45fae4 100644
--- a/WebCore/bindings/js/ScriptDebugServer.h
+++ b/WebCore/bindings/js/ScriptDebugServer.h
@@ -32,6 +32,7 @@
 
 #if ENABLE(JAVASCRIPT_DEBUGGER)
 
+#include "ScriptDebugListener.h"
 #include "PlatformString.h"
 #include "ScriptBreakpoint.h"
 #include "Timer.h"
@@ -81,6 +82,8 @@ public:
     void stepOverStatement();
     void stepOutOfFunction();
 
+    bool editScriptSource(const String& sourceID, const String& newContent, String& newSourceOrErrorMessage);
+
     void recompileAllJSFunctionsSoon();
     void recompileAllJSFunctions(Timer<ScriptDebugServer>* = 0);
 
@@ -88,6 +91,8 @@ public:
 
     void pageCreated(Page*);
 
+    bool isDebuggerAlwaysEnabled();
+
 private:
     typedef HashSet<ScriptDebugListener*> ListenerSet;
     typedef void (ScriptDebugServer::*JavaScriptExecutionCallback)(ScriptDebugListener*);
@@ -96,8 +101,7 @@ private:
     ~ScriptDebugServer();
 
     bool hasBreakpoint(intptr_t sourceID, unsigned lineNumber) const;
-    bool hasListeners() const { return !m_listeners.isEmpty() || !m_pageListenersMap.isEmpty(); }
-    bool hasGlobalListeners() const { return !m_listeners.isEmpty(); }
+    bool hasListeners() const { return !m_pageListenersMap.isEmpty(); }
     bool hasListenersInterestedInPage(Page*);
 
     void setJavaScriptPaused(const PageGroup&, bool paused);
@@ -109,7 +113,7 @@ private:
     void dispatchFunctionToListeners(const ListenerSet& listeners, JavaScriptExecutionCallback callback);
     void dispatchDidPause(ScriptDebugListener*);
     void dispatchDidContinue(ScriptDebugListener*);
-    void dispatchDidParseSource(const ListenerSet& listeners, const JSC::SourceCode& source);
+    void dispatchDidParseSource(const ListenerSet& listeners, const JSC::SourceCode& source, enum ScriptWorldType);
     void dispatchFailedToParseSource(const ListenerSet& listeners, const JSC::SourceCode& source, int errorLine, const String& errorMessage);
 
     void pauseIfNeeded(Page*);
@@ -133,7 +137,6 @@ private:
     typedef HashMap<intptr_t, SourceBreakpoints> BreakpointsMap;
 
     PageListenersMap m_pageListenersMap;
-    ListenerSet m_listeners;
     bool m_callingListeners;
     PauseOnExceptionsState m_pauseOnExceptionsState;
     bool m_pauseOnNextStatement;
diff --git a/WebCore/bindings/js/ScriptFunctionCall.cpp b/WebCore/bindings/js/ScriptFunctionCall.cpp
index 3784457..9baf809 100644
--- a/WebCore/bindings/js/ScriptFunctionCall.cpp
+++ b/WebCore/bindings/js/ScriptFunctionCall.cpp
@@ -143,7 +143,7 @@ ScriptValue ScriptFunctionCall::call(bool& hadException, bool reportExceptions)
     }
 
     CallData callData;
-    CallType callType = function.getCallData(callData);
+    CallType callType = getCallData(function, callData);
     if (callType == CallTypeNone)
         return ScriptValue();
 
diff --git a/WebCore/bindings/js/SerializedScriptValue.cpp b/WebCore/bindings/js/SerializedScriptValue.cpp
index e761480..90f8d7c 100644
--- a/WebCore/bindings/js/SerializedScriptValue.cpp
+++ b/WebCore/bindings/js/SerializedScriptValue.cpp
@@ -36,6 +36,7 @@
 #include "JSImageData.h"
 #include <JavaScriptCore/APICast.h>
 #include <runtime/DateInstance.h>
+#include <runtime/Error.h>
 #include <runtime/ExceptionHelpers.h>
 #include <runtime/JSLock.h>
 #include <runtime/PropertyNameArray.h>
@@ -454,12 +455,12 @@ struct BaseWalker {
 
     void throwStackOverflow()
     {
-        m_exec->setException(createStackOverflowError(m_exec));
+        throwError(m_exec, createStackOverflowError(m_exec));
     }
 
     void throwInterruptedException()
     {
-        m_exec->setException(createInterruptedExecutionException(&m_exec->globalData()));
+        throwError(m_exec, createInterruptedExecutionException(&m_exec->globalData()));
     }
 };
 
@@ -575,7 +576,7 @@ struct SerializingTreeWalker : public BaseWalker {
                 return SerializedScriptValueData(toImageData(obj));
                 
             CallData unusedData;
-            if (value.getCallData(unusedData) == CallTypeNone)
+            if (getCallData(value, unusedData) == CallTypeNone)
                 return SerializedScriptValueData();
         }
         // Any other types are expected to serialize as null.
@@ -602,7 +603,7 @@ struct SerializingTreeWalker : public BaseWalker {
     {
         // Cycle detection
         if (!m_cycleDetector.add(inArray).second) {
-            m_exec->setException(createTypeError(m_exec, "Cannot post cyclic structures."));
+            throwError(m_exec, createTypeError(m_exec, "Cannot post cyclic structures."));
             return false;
         }
         m_gcBuffer.append(inArray);
@@ -619,7 +620,7 @@ struct SerializingTreeWalker : public BaseWalker {
     {
         // Cycle detection
         if (!m_cycleDetector.add(inObject).second) {
-            m_exec->setException(createTypeError(m_exec, "Cannot post cyclic structures."));
+            throwError(m_exec, createTypeError(m_exec, "Cannot post cyclic structures."));
             return false;
         }
         m_gcBuffer.append(inObject);
diff --git a/WebCore/bindings/js/WorkerScriptController.cpp b/WebCore/bindings/js/WorkerScriptController.cpp
index 1d45dfa..6ff8a69 100644
--- a/WebCore/bindings/js/WorkerScriptController.cpp
+++ b/WebCore/bindings/js/WorkerScriptController.cpp
@@ -41,6 +41,7 @@
 #include <interpreter/Interpreter.h>
 #include <runtime/Completion.h>
 #include <runtime/Completion.h>
+#include <runtime/Error.h>
 #include <runtime/JSLock.h>
 
 using namespace JSC;
@@ -137,7 +138,7 @@ ScriptValue WorkerScriptController::evaluate(const ScriptSourceCode& sourceCode,
 
 void WorkerScriptController::setException(ScriptValue exception)
 {
-    m_workerContextWrapper->globalExec()->setException(exception.jsValue());
+    throwError(m_workerContextWrapper->globalExec(), exception.jsValue());
 }
 
 void WorkerScriptController::forbidExecution(ForbidExecutionOption option)
diff --git a/WebCore/bindings/objc/WebScriptObject.mm b/WebCore/bindings/objc/WebScriptObject.mm
index 794fc69..3f224f1 100644
--- a/WebCore/bindings/objc/WebScriptObject.mm
+++ b/WebCore/bindings/objc/WebScriptObject.mm
@@ -294,7 +294,7 @@ static void getListFromNSArray(ExecState *exec, NSArray *array, RootObject* root
 
     JSValue function = [self _imp]->get(exec, Identifier(exec, stringToUString(String(name))));
     CallData callData;
-    CallType callType = function.getCallData(callData);
+    CallType callType = getCallData(function, callData);
     if (callType == CallTypeNone)
         return nil;
 
diff --git a/WebCore/bindings/scripts/CodeGenerator.pm b/WebCore/bindings/scripts/CodeGenerator.pm
index b8f23dd..7c0f427 100644
--- a/WebCore/bindings/scripts/CodeGenerator.pm
+++ b/WebCore/bindings/scripts/CodeGenerator.pm
@@ -24,6 +24,8 @@
 
 package CodeGenerator;
 
+use strict;
+
 use File::Find;
 
 my $useDocument = "";
@@ -272,7 +274,7 @@ sub ParseInterface
         return $interface if $interface->name eq $interfaceName;
     }
 
-    die("Could NOT find interface definition for $interface in $filename");
+    die("Could NOT find interface definition for $interfaceName in $filename");
 }
 
 # Helpers for all CodeGenerator***.pm modules
diff --git a/WebCore/bindings/scripts/CodeGeneratorCPP.pm b/WebCore/bindings/scripts/CodeGeneratorCPP.pm
new file mode 100644
index 0000000..f441b0e
--- /dev/null
+++ b/WebCore/bindings/scripts/CodeGeneratorCPP.pm
@@ -0,0 +1,975 @@
+
+# Copyright (C) 2005, 2006 Nikolas Zimmermann <zimmermann@kde.org>
+# Copyright (C) 2006 Anders Carlsson <andersca@mac.com> 
+# Copyright (C) 2006, 2007 Samuel Weinig <sam@webkit.org>
+# Copyright (C) 2006 Alexey Proskuryakov <ap@webkit.org>
+# Copyright (C) 2006, 2007, 2008, 2009 Apple Inc. All rights reserved.
+# Copyright (C) 2009 Cameron McCormack <cam@mcc.id.au>
+# Copyright (C) Research In Motion Limited 2010. All rights reserved.
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Library General Public
+# License as published by the Free Software Foundation; either
+# version 2 of the License, or (at your option) any later version.
+# 
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Library General Public License for more details.
+# 
+# You should have received a copy of the GNU Library General Public License
+# aint with this library; see the file COPYING.LIB.  If not, write to
+# the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+# Boston, MA 02110-1301, USA.
+#
+
+package CodeGeneratorCPP;
+
+use File::stat;
+
+# Global Variables
+my $module = "";
+my $outputDir = "";
+
+my @headerContentHeader = ();
+my @headerContent = ();
+my %headerForwardDeclarations = ();
+
+my @implContentHeader = ();
+my @implContent = ();
+my %implIncludes = ();
+
+# Constants
+my $exceptionInit = "WebCore::ExceptionCode ec = 0;";
+my $exceptionRaiseOnError = "webDOMRaiseError(static_cast<WebDOMExceptionCode>(ec));";
+
+# Default License Templates
+my $headerLicenseTemplate = << "EOF";
+/*
+ * Copyright (C) Research In Motion Limited 2010. All rights reserved.
+ * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009 Apple Inc. All rights reserved.
+ * Copyright (C) 2006 Samuel Weinig <sam.weinig\@gmail.com>
+ * Copyright (C) Research In Motion Limited 2010. All rights reserved.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public License
+ * along with this library; see the file COPYING.LIB.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+EOF
+
+my $implementationLicenseTemplate = << "EOF";
+/*
+ * This file is part of the WebKit open source project.
+ * This file has been generated by generate-bindings.pl. DO NOT MODIFY!
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public License
+ * along with this library; see the file COPYING.LIB.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+EOF
+
+# Default constructor
+sub new
+{
+    my $object = shift;
+    my $reference = { };
+
+    $codeGenerator = shift;
+    $outputDir = shift;
+    shift; # $useLayerOnTop
+    shift; # $preprocessor
+    shift; # $writeDependencies
+
+    bless($reference, $object);
+    return $reference;
+}
+
+sub finish
+{
+    my $object = shift;
+}
+
+# Params: 'domClass' struct
+sub GenerateInterface
+{
+    my $object = shift;
+    my $dataNode = shift;
+    my $defines = shift;
+
+    my $name = $dataNode->name;
+    my $className = GetClassName($name);
+    my $parentClassName = "WebDOM" . GetParentImplClassName($dataNode);
+
+    # Start actual generation.
+    $object->GenerateHeader($dataNode);
+    $object->GenerateImplementation($dataNode);
+
+    # Write changes.
+    $object->WriteData("WebDOM" . $name);
+}
+
+# Params: 'idlDocument' struct
+sub GenerateModule
+{
+    my $object = shift;
+    my $dataNode = shift;
+
+    $module = $dataNode->module;
+}
+
+sub GetClassName
+{
+    my $name = $codeGenerator->StripModule(shift);
+
+    # special cases
+    return "WebDOMString" if $codeGenerator->IsStringType($name) or $name eq "SerializedScriptValue";
+    return "WebDOMAbstractView" if $name eq "DOMWindow";
+    return "WebDOMObject" if $name eq "DOMObject";
+    return "bool" if $name eq "boolean";
+    return $name if $codeGenerator->IsPrimitiveType($name);
+
+    return "WebDOM$name";
+}
+
+sub GetImplClassName
+{
+    my $name = $codeGenerator->StripModule(shift);
+
+    return "DOMWindow" if $name eq "AbstractView";
+    return $name;
+}
+
+sub GetParentImplClassName
+{
+    my $dataNode = shift;
+
+    if (@{$dataNode->parents} eq 0) {
+        return "EventTarget" if $dataNode->extendedAttributes->{"EventTarget"};
+        return "Object";
+    }
+
+    return $codeGenerator->StripModule($dataNode->parents(0));
+}
+
+sub GetParent
+{
+    my $dataNode = shift;
+    my $numParents = @{$dataNode->parents};
+
+    my $parent = "";
+    if ($numParents eq 0) {
+        $parent = "WebDOMObject";
+        $parent = "WebDOMEventTarget" if $dataNode->extendedAttributes->{"EventTarget"};
+    } elsif ($numParents eq 1) {
+        my $parentName = $codeGenerator->StripModule($dataNode->parents(0));
+        $parent = "WebDOM" . $parentName;
+    } else {
+        my @parents = @{$dataNode->parents};
+        my $firstParent = $codeGenerator->StripModule(shift(@parents));
+        $parent = "WebDOM" . $firstParent;
+    }
+
+    return $parent;
+}
+
+sub ShouldSkipTypeInImplementation
+{
+    my $typeInfo = shift;
+
+    return 1 if $typeInfo->signature->extendedAttributes->{"Custom"}
+             and !$typeInfo->signature->extendedAttributes->{"NoCPPCustom"};
+
+    return 1 if $typeInfo->signature->extendedAttributes->{"CustomArgumentHandling"}
+             or $typeInfo->signature->extendedAttributes->{"CustomGetter"}
+             or $typeInfo->signature->extendedAttributes->{"NeedsUserGestureCheck"};
+
+    # FIXME: We don't generate bindings for SVG related interfaces yet
+    return 1 if $typeInfo->signature->name =~ /getSVGDocument/;
+
+    return 1 if $typeInfo->signature->name =~ /Constructor/;
+    return 0;
+}
+
+sub ShouldSkipTypeInHeader
+{
+    my $typeInfo = shift;
+
+    # FIXME: We currently ignore any attribute/function needing custom code
+    return 1 if $typeInfo->signature->extendedAttributes->{"CustomArgumentHandling"}
+             or $typeInfo->signature->extendedAttributes->{"CustomGetter"};
+
+    # FIXME: We don't generate bindings for SVG related interfaces yet
+    return 1 if $typeInfo->signature->name =~ /getSVGDocument/;
+
+    return 1 if $typeInfo->signature->name =~ /Constructor/;
+    return 0;
+}
+
+sub GetCPPType
+{
+    my $type = shift;
+    my $useConstReference = shift;
+    my $name = GetClassName($type);
+
+    return "int" if $type eq "long";
+    return "unsigned" if $name eq "unsigned long";
+    return "unsigned short" if $type eq "CompareHow";
+
+    if ($codeGenerator->IsStringType($type)) {
+        if ($useConstReference) {
+            return "const $name&";
+        }
+
+        return $name;
+    }
+
+    return $name if $codeGenerator->IsPrimitiveType($type) or $type eq "DOMTimeStamp";
+    return "const $name&" if $useConstReference;
+    return $name;
+}
+
+sub ConversionNeeded
+{
+    my $type = $codeGenerator->StripModule(shift);
+    return !$codeGenerator->IsNonPointerType($type) && !$codeGenerator->IsStringType($type);
+}
+
+sub GetCPPTypeGetter
+{
+    my $argName = shift;
+    my $type = $codeGenerator->StripModule(shift);
+
+    return $argName if $codeGenerator->IsPrimitiveType($type) or $codeGenerator->IsStringType($type);
+    return "static_cast<WebCore::Range::CompareHow>($argName)" if $type eq "CompareHow";
+    return "WebCore::SerializedScriptValue::create(WebCore::String($argName))" if $type eq "SerializedScriptValue";
+    return "toWebCore($argName)";
+}
+
+sub AddForwardDeclarationsForType
+{
+    my $type = $codeGenerator->StripModule(shift);
+    my $public = shift;
+
+    return if $codeGenerator->IsNonPointerType($type) or $codeGenerator->IsStringType($type);
+
+    my $class = GetClassName($type);
+    $headerForwardDeclarations{$class} = 1 if $public;
+}
+
+sub AddIncludesForType
+{
+    my $type = $codeGenerator->StripModule(shift);
+
+    return if $codeGenerator->IsNonPointerType($type);
+    return if $type =~ /cconstructor/;
+
+    if ($codeGenerator->IsStringType($type)) {
+        $implIncludes{"AtomicString.h"} = 1;
+        $implIncludes{"KURL.h"} = 1;
+        $implIncludes{"WebDOMString.h"} = 1;
+        return;
+    }
+
+    if ($type eq "DOMObject") {
+        $implIncludes{"WebDOMObject.h"} = 1;
+        return;
+    }
+
+    if ($type eq "DOMWindow") {
+        $implIncludes{"DOMWindow.h"} = 1;
+        $implIncludes{"WebDOMAbstractView.h"} = 1;
+        return;
+    }
+
+    if ($type eq "EventListener") {
+        $implIncludes{"WebNativeEventListener.h"} = 1;
+        return;
+    }
+
+    if ($type eq "SerializedScriptValue") {
+        $implIncludes{"SerializedScriptValue.h"} = 1;
+        return;
+    }
+
+    $implIncludes{"Node.h"} = 1 if $type eq "NodeList";
+    $implIncludes{"CSSMutableStyleDeclaration.h"} = 1 if $type eq "CSSStyleDeclaration";
+
+    # Default, include the same named file (the implementation) and the same name prefixed with "WebDOM". 
+    $implIncludes{"$type.h"} = 1 unless $type eq "DOMObject";
+    $implIncludes{"WebDOM$type.h"} = 1;
+}
+
+sub GenerateConditionalStringFromAttributeValue
+{
+    my $conditional = shift;
+    if ($conditional =~ /&/) {
+        return "ENABLE(" . join(") && ENABLE(", split(/&/, $conditional)) . ")";
+    } elsif ($conditional =~ /\|/) {
+        return "ENABLE(" . join(") || ENABLE(", split(/\|/, $conditional)) . ")";
+    } else {
+        return "ENABLE(" . $conditional . ")";
+    }
+}
+
+sub GenerateConditionalString
+{
+    my $node = shift;
+    my $conditional = $node->extendedAttributes->{"Conditional"};
+    if ($conditional) {
+        return GenerateConditionalStringFromAttributeValue($conditional);
+    } else {
+        return "";
+    }
+}
+
+sub GenerateHeader
+{
+    my $object = shift;
+    my $dataNode = shift;
+
+    my $interfaceName = $dataNode->name;
+    my $className = GetClassName($interfaceName);
+    my $implClassName = GetImplClassName($interfaceName);
+    my $implClassNameWithNamespace = "WebCore::" . $implClassName;
+
+    my $parentName = "";
+    $parentName = GetParent($dataNode);
+
+    my $numConstants = @{$dataNode->constants};
+    my $numAttributes = @{$dataNode->attributes};
+    my $numFunctions = @{$dataNode->functions};
+
+    # - Add default header template
+    @headerContentHeader = split("\r", $headerLicenseTemplate);
+    push(@headerContentHeader, "\n#ifndef $className" . "_h");
+    push(@headerContentHeader, "\n#define $className" . "_h\n\n");
+
+    my $conditionalString = GenerateConditionalString($dataNode);
+    push(@headerContentHeader, "#if ${conditionalString}\n\n") if $conditionalString;
+
+    # - INCLUDES -
+
+    my %headerIncludes = ();
+    $headerIncludes{"WebDOMString.h"} = 1;
+    $headerIncludes{"$parentName.h"} = 1;
+    foreach my $include (sort keys(%headerIncludes)) {
+        push(@headerContentHeader, "#include <$include>\n");
+    }
+
+    push(@headerContent, "class $className");
+    push(@headerContent, " : public $parentName") if $parentName;
+    push(@headerContent, " {\n");
+    push(@headerContent, "public:\n");
+
+    # Constructor
+    push(@headerContent, "    $className();\n");
+    push(@headerContent, "    explicit $className($implClassNameWithNamespace*);\n");
+
+    # Copy constructor on classes which have the d-ptr
+    if (@{$dataNode->parents} eq 0) {
+        push(@headerContent, "    $className(const $className&);\n");
+    }
+
+    # Destructor
+    if (@{$dataNode->parents} eq 0) {
+        push(@headerContent, "    ~$className();\n");
+    }
+
+    push(@headerContent, "\n");
+    $headerForwardDeclarations{$implClassNameWithNamespace} = 1;
+
+    # - Add constants.
+    if ($numConstants > 0) {
+        my @headerConstants = ();
+
+        # FIXME: we need a way to include multiple enums.
+        foreach my $constant (@{$dataNode->constants}) {
+            my $constantName = $constant->name;
+            my $constantValue = $constant->value;
+
+            my $output = "WEBDOM_" . $constantName . " = " . $constantValue;
+            push(@headerConstants, "        " . $output);
+        }
+
+        my $combinedConstants = join(",\n", @headerConstants);
+
+        push(@headerContent, "    ");
+        push(@headerContent, "enum {\n");
+        push(@headerContent, $combinedConstants);
+        push(@headerContent, "\n    ");
+        push(@headerContent, "};\n\n");
+    }
+
+    my @headerAttributes = ();
+
+    # - Add attribute getters/setters.
+    if ($numAttributes > 0) {
+        foreach my $attribute (@{$dataNode->attributes}) {
+            next if ShouldSkipTypeInHeader($attribute);
+
+            my $attributeName = $attribute->signature->name;
+            my $attributeType = GetCPPType($attribute->signature->type, 0);
+            my $attributeIsReadonly = ($attribute->type =~ /^readonly/);
+            my $property = "    " . $attributeType . ($attributeType =~ /\*$/ ? "" : " ") . $attributeName . "() const";
+
+            my $availabilityMacro = "";
+            my $declarationSuffix = ";\n";
+
+            AddForwardDeclarationsForType($attribute->signature->type, 1);
+
+            $attributeType = GetCPPType($attribute->signature->type, 1);
+            my $setterName = "set" . ucfirst($attributeName);
+
+            $property .= $declarationSuffix;
+            push(@headerAttributes, $property);
+            if (!$attributeIsReadonly and !$attribute->signature->extendedAttributes->{"Replaceable"}) {
+                $property = "    void $setterName($attributeType)";
+                $property .= $declarationSuffix;
+                push(@headerAttributes, $property);
+            }
+        }
+
+        push(@headerContent, @headerAttributes) if @headerAttributes > 0;
+    }
+
+    my @headerFunctions = ();
+    my @deprecatedHeaderFunctions = ();
+    my @interfaceFunctions = ();
+
+    # - Add functions.
+    if ($numFunctions > 0) {
+        foreach my $function (@{$dataNode->functions}) {
+            next if ShouldSkipTypeInHeader($function);
+            my $functionName = $function->signature->name;
+
+            my $returnType = GetCPPType($function->signature->type, 0);
+            my $numberOfParameters = @{$function->parameters};
+            my %typesToForwardDeclare = ($function->signature->type => 1);
+
+            my $parameterIndex = 0;
+            my $functionSig = "$returnType $functionName(";
+            my $methodName = $functionName;
+            foreach my $param (@{$function->parameters}) {
+                my $paramName = $param->name;
+                my $paramType = GetCPPType($param->type, 1);
+                $typesToForwardDeclare{$param->type} = 1;
+
+                $functionSig .= ", " if $parameterIndex >= 1;
+                $functionSig .= "$paramType $paramName";
+                $parameterIndex++;
+            }
+            $functionSig .= ")";
+            if ($dataNode->extendedAttributes->{"PureInterface"}) {
+                push(@interfaceFunctions, "    virtual " . $functionSig . " = 0;\n");
+            }
+            my $functionDeclaration = $functionSig;
+            $functionDeclaration .= ";\n";
+
+            foreach my $type (keys %typesToForwardDeclare) {
+                # add any forward declarations to the public header if a deprecated version will be generated
+                AddForwardDeclarationsForType($type, 1);
+            }
+
+            push(@headerFunctions, "    ");
+            push(@headerFunctions, $functionDeclaration);
+        }
+
+        if (@headerFunctions > 0) {
+            push(@headerContent, "\n") if @headerAttributes > 0;
+            push(@headerContent, @headerFunctions);
+        }
+    }
+
+    push(@headerContent, "\n");
+    push(@headerContent, "    $implClassNameWithNamespace* impl() const;\n");
+
+    if (@{$dataNode->parents} eq 0) {
+        push(@headerContent, "\nprotected:\n");
+        push(@headerContent, "    struct ${className}Private;\n");
+        push(@headerContent, "    ${className}Private* m_impl;\n");
+    }
+
+    push(@headerContent, "};\n\n");
+
+    # for PureInterface classes also add the interface that the client code needs to
+    # implement
+    if ($dataNode->extendedAttributes->{"PureInterface"}) {
+        push(@headerContent, "class WebUser$interfaceName {\n");
+        push(@headerContent, "public:\n");
+        push(@headerContent, "    virtual void ref() = 0;\n");
+        push(@headerContent, "    virtual void deref() = 0;\n\n");
+        push(@headerContent, @interfaceFunctions);
+        push(@headerContent, "\nprotected:\n");
+        push(@headerContent, "    virtual ~WebUser$interfaceName() {}\n");
+        push(@headerContent, "};\n\n");
+    }
+
+    push(@headerContent, "WebCore::$implClassName* toWebCore(const $className&);\n");
+    push(@headerContent, "$className toWebKit(WebCore::$implClassName*);\n");
+    if ($dataNode->extendedAttributes->{"PureInterface"}) {
+        push(@headerContent, "$className toWebKit(WebUser$interfaceName*);\n");
+    }
+    push(@headerContent, "\n#endif\n");
+    push(@headerContent, "#endif // ${conditionalString}\n\n") if $conditionalString;
+}
+
+sub AddEarlyReturnStatement
+{
+    my $returnType = shift;
+
+    if (!defined($returnType) or $returnType eq "void") {
+        $returnType = "";
+    } elsif ($codeGenerator->IsPrimitiveType($returnType)) {
+        $returnType = " 0";
+    } elsif ($returnType eq "bool") {
+        $returnType = " false";
+    } else {
+        $returnType = " $returnType()";
+    }
+
+    # TODO: We could set exceptions here, if we want that
+    my $statement = "    if (!impl())\n";
+    $statement .=   "        return$returnType;\n\n";
+    return $statement;
+}
+
+sub AddReturnStatement
+{
+    my $typeInfo = shift;
+    my $returnValue = shift;
+
+    # Used to invoke KURLs "const String&" operator
+    if ($codeGenerator->IsStringType($typeInfo->signature->type)) {
+        return "    return static_cast<const WebCore::String&>($returnValue);\n";
+    }
+
+    return "    return $returnValue;\n";
+}
+
+sub GenerateImplementation
+{
+    my $object = shift;
+    my $dataNode = shift;
+
+    my @ancestorInterfaceNames = ();
+
+    if (@{$dataNode->parents} > 1) {
+        $codeGenerator->AddMethodsConstantsAndAttributesFromParentClasses($dataNode, \@ancestorInterfaceNames);
+    }
+
+    my $interfaceName = $dataNode->name;
+    my $className = GetClassName($interfaceName);
+    my $implClassName = GetImplClassName($interfaceName);
+    my $parentImplClassName = GetParentImplClassName($dataNode);
+    my $implClassNameWithNamespace = "WebCore::" . $implClassName;
+    my $baseClass = "WebDOM$parentImplClassName";
+    my $conditional = $dataNode->extendedAttributes->{"Conditional"};
+
+    my $numAttributes = @{$dataNode->attributes};
+    my $numFunctions = @{$dataNode->functions};
+
+    # - Add default header template.
+    @implContentHeader = split("\r", $implementationLicenseTemplate);
+
+    # - INCLUDES -
+    push(@implContentHeader, "\n#include \"config.h\"\n");
+    my $conditionalString = GenerateConditionalString($dataNode);
+    push(@implContentHeader, "\n#if ${conditionalString}\n\n") if $conditionalString;
+    push(@implContentHeader, "#include \"$className.h\"\n\n");
+
+    $implIncludes{"WebExceptionHandler.h"} = 1;
+    $implIncludes{"$implClassName.h"} = 1;
+    @implContent = ();
+
+    push(@implContent, "#include <wtf/GetPtr.h>\n");
+    push(@implContent, "#include <wtf/RefPtr.h>\n\n");
+
+    # Private datastructure, encapsulating WebCore types
+    if (@{$dataNode->parents} eq 0) {
+        push(@implContent, "struct ${className}::${className}Private {\n");
+        push(@implContent, "    ${className}Private($implClassNameWithNamespace* object = 0)\n");
+        push(@implContent, "        : impl(object)\n");
+        push(@implContent, "    {\n");
+        push(@implContent, "    }\n\n");
+        push(@implContent, "    RefPtr<$implClassNameWithNamespace> impl;\n");
+        push(@implContent, "};\n\n");
+    }
+
+    # Constructor
+    push(@implContent, "${className}::$className()\n");
+    push(@implContent, "    : ${baseClass}()\n");
+    push(@implContent, "    , m_impl(0)\n") if (@{$dataNode->parents} eq 0);
+    push(@implContent, "{\n");
+    push(@implContent, "}\n\n");
+
+    push(@implContent, "${className}::$className($implClassNameWithNamespace* impl)\n");
+    if (@{$dataNode->parents} eq 0) {
+        push(@implContent, "    : ${baseClass}()\n");
+        push(@implContent, "    , m_impl(new ${className}Private(impl))\n");
+        push(@implContent, "{\n");
+        push(@implContent, "}\n\n");
+
+        push(@implContent, "${className}::${className}(const ${className}& copy)\n");
+        push(@implContent, "    : ${baseClass}()\n");
+        push(@implContent, "{\n");
+        push(@implContent, "    m_impl = copy.impl() ? new ${className}Private(copy.impl()) : 0;\n");
+        push(@implContent, "}\n\n");
+
+        push(@implContent, "$implClassNameWithNamespace* ${className}::impl() const\n");
+        push(@implContent, "{\n");
+        push(@implContent, "    return m_impl ? m_impl->impl.get() : 0;\n");
+        push(@implContent, "}\n\n");
+
+        # Destructor
+        push(@implContent, "${className}::~$className()\n");
+        push(@implContent, "{\n");
+        push(@implContent, "    delete m_impl;\n");
+        push(@implContent, "    m_impl = 0;\n");
+        push(@implContent, "}\n\n");
+    } else {
+        push(@implContent, "    : ${baseClass}(impl)\n");
+        push(@implContent, "{\n");
+        push(@implContent, "}\n\n");
+
+        push(@implContent, "$implClassNameWithNamespace* ${className}::impl() const\n");
+        push(@implContent, "{\n");
+        push(@implContent, "    return static_cast<$implClassNameWithNamespace*>(${baseClass}::impl());\n");
+        push(@implContent, "}\n\n");
+    }
+
+    # START implementation
+    %attributeNames = ();
+
+    # - Attributes
+    if ($numAttributes > 0) {
+        foreach my $attribute (@{$dataNode->attributes}) {
+            next if ShouldSkipTypeInImplementation($attribute);
+            AddIncludesForType($attribute->signature->type);
+
+            my $idlType = $codeGenerator->StripModule($attribute->signature->type);
+
+            my $attributeName = $attribute->signature->name;
+            my $attributeType = GetCPPType($attribute->signature->type, 0);
+            my $attributeIsReadonly = ($attribute->type =~ /^readonly/);
+
+            $attributeNames{$attributeName} = 1;
+
+            # - GETTER
+            my $getterSig = "$attributeType $className\:\:$attributeName() const\n";
+            my $hasGetterException = @{$attribute->getterExceptions};
+            my $getterContentHead;
+            my $reflect = $attribute->signature->extendedAttributes->{"Reflect"};
+            my $reflectURL = $attribute->signature->extendedAttributes->{"ReflectURL"};
+            if ($reflect || $reflectURL) {
+                my $contentAttributeName = (($reflect || $reflectURL) eq "1") ? $attributeName : ($reflect || $reflectURL);
+                my $namespace = $codeGenerator->NamespaceForAttributeName($interfaceName, $contentAttributeName);
+                $implIncludes{"${namespace}.h"} = 1;
+                my $getAttributeFunctionName = $reflectURL ? "getURLAttribute" : "getAttribute";
+                $getterContentHead = "impl()->${getAttributeFunctionName}(WebCore::${namespace}::${contentAttributeName}Attr";
+            } else {
+                $getterContentHead = "impl()->" . $codeGenerator->WK_lcfirst($attributeName) . "(";
+            }
+            my $getterContentTail = ")";
+
+            # Special cases
+            my @customGetterContent = (); 
+            if ($attribute->signature->extendedAttributes->{"ConvertToString"}) {
+                $getterContentHead = "WebCore::String::number(" . $getterContentHead;
+                $getterContentTail .= ")";
+            } elsif ($attribute->signature->extendedAttributes->{"ConvertFromString"}) {
+                $getterContentTail .= ".toInt()";
+            } elsif ($attribute->signature->type eq "SerializedScriptValue") {
+                $getterContentHead = "$getterContentHead";
+                $getterContentTail .= "->toString()";                
+            } elsif (ConversionNeeded($attribute->signature->type)) {
+                $getterContentHead = "toWebKit(WTF::getPtr($getterContentHead";
+                $getterContentTail .= "))";
+            }
+
+            my $getterContent;
+            if ($hasGetterException) {
+                $getterContent = $getterContentHead . "ec" . $getterContentTail;
+            } else {
+                $getterContent = $getterContentHead . $getterContentTail;
+            }
+
+            my $attributeConditionalString = GenerateConditionalString($attribute->signature);
+            push(@implContent, "#if ${attributeConditionalString}\n") if $attributeConditionalString;
+
+            push(@implContent, $getterSig);
+            push(@implContent, "{\n");
+            push(@implContent, AddEarlyReturnStatement($attributeType));
+            push(@implContent, @customGetterContent);
+            if ($hasGetterException) {
+                # Differentiated between when the return type is a pointer and
+                # not for white space issue (ie. Foo *result vs. int result).
+                if ($attributeType =~ /\*$/) {
+                    $getterContent = $attributeType . "result = " . $getterContent;
+                } else {
+                    $getterContent = $attributeType . " result = " . $getterContent;
+                }
+
+                push(@implContent, "    $exceptionInit\n");
+                push(@implContent, "    $getterContent;\n");
+                push(@implContent, "    $exceptionRaiseOnError\n");
+                push(@implContent, AddReturnStatement($attribute, "result"));
+            } else {
+                push(@implContent, AddReturnStatement($attribute, $getterContent));
+            }
+            push(@implContent, "}\n\n");
+
+            # - SETTER
+            if (!$attributeIsReadonly and !$attribute->signature->extendedAttributes->{"Replaceable"}) {
+                # Exception handling
+                my $hasSetterException = @{$attribute->setterExceptions};
+
+                my $coreSetterName = "set" . $codeGenerator->WK_ucfirst($attributeName);
+                my $setterName = "set" . ucfirst($attributeName);
+                my $argName = "new" . ucfirst($attributeName);
+                my $arg = GetCPPTypeGetter($argName, $idlType);
+
+                # The definition of ConvertFromString and ConvertToString is flipped for the setter
+                if ($attribute->signature->extendedAttributes->{"ConvertFromString"}) {
+                    $arg = "WebCore::String::number($arg)";
+                } elsif ($attribute->signature->extendedAttributes->{"ConvertToString"}) {
+                    $arg = "WebCore::String($arg).toInt()";
+                }
+
+                my $attributeType = GetCPPType($attribute->signature->type, 1);
+                push(@implContent, "void $className\:\:$setterName($attributeType $argName)\n");
+                push(@implContent, "{\n");
+                push(@implContent, AddEarlyReturnStatement());
+
+                my $reflect = $attribute->signature->extendedAttributes->{"Reflect"};
+                my $reflectURL = $attribute->signature->extendedAttributes->{"ReflectURL"};
+                push(@implContent, "    $exceptionInit\n") if $hasSetterException;
+                my $ec = $hasSetterException ? ", ec" : "";
+                if ($reflect || $reflectURL) {
+                    my $contentAttributeName = (($reflect || $reflectURL) eq "1") ? $attributeName : ($reflect || $reflectURL);
+                    my $namespace = $codeGenerator->NamespaceForAttributeName($interfaceName, $contentAttributeName);
+                    $implIncludes{"${namespace}.h"} = 1;
+                    push(@implContent, "    impl()->setAttribute(WebCore::${namespace}::${contentAttributeName}Attr, $arg$ec);\n");
+                } else {
+                    push(@implContent, "    impl()->$coreSetterName($arg$ec);\n");
+                }
+                push(@implContent, "    $exceptionRaiseOnError\n") if $hasSetterException;
+                push(@implContent, "}\n\n");
+            }
+
+            push(@implContent, "#endif\n") if $attributeConditionalString;
+        }
+    }
+
+    # - Functions
+    if ($numFunctions > 0) {
+        foreach my $function (@{$dataNode->functions}) {
+            # Treat PureInterface as Custom as well, since the WebCore versions will take a script context as well
+            next if ShouldSkipTypeInImplementation($function) || $dataNode->extendedAttributes->{"PureInterface"};
+            AddIncludesForType($function->signature->type);
+
+            my $functionName = $function->signature->name;
+            my $returnType = GetCPPType($function->signature->type, 0);
+            my $hasParameters = @{$function->parameters};
+            my $raisesExceptions = @{$function->raisesExceptions};
+
+            my @parameterNames = ();
+            my @needsAssert = ();
+            my %needsCustom = ();
+
+            my $parameterIndex = 0;
+
+            # FIXME: Handle Callback support, we're just passing 0 as ScriptExecutionContext for now.
+            push(@parameterNames, "0") if ($dataNode->extendedAttributes->{"Callback"});
+
+            my $functionSig = "$returnType $className\:\:$functionName(";
+            foreach my $param (@{$function->parameters}) {
+                my $paramName = $param->name;
+                my $paramType = GetCPPType($param->type, 1);
+
+                # make a new parameter name if the original conflicts with a property name
+                $paramName = "in" . ucfirst($paramName) if $attributeNames{$paramName};
+
+                AddIncludesForType($param->type);
+
+                my $idlType = $codeGenerator->StripModule($param->type);
+                my $implGetter = GetCPPTypeGetter($paramName, $idlType);
+
+                push(@parameterNames, $implGetter);
+                $needsCustom{"NodeToReturn"} = $paramName if $param->extendedAttributes->{"Return"};
+
+                unless ($codeGenerator->IsPrimitiveType($idlType) or $codeGenerator->IsStringType($idlType)) {
+                    push(@needsAssert, "    ASSERT($paramName);\n");
+                }
+
+                $functionSig .= ", " if $parameterIndex >= 1;
+                $functionSig .= "$paramType $paramName";
+                $parameterIndex++;
+            }
+
+            $functionSig .= ")";
+
+            my @functionContent = ();
+            push(@parameterNames, "ec") if $raisesExceptions;
+            my $content = "impl()->" . $codeGenerator->WK_lcfirst($functionName) . "(" . join(", ", @parameterNames) . ")"; 
+
+            if ($returnType eq "void") {
+                # Special case 'void' return type.
+                if ($raisesExceptions) {
+                    push(@functionContent, "    $exceptionInit\n");
+                    push(@functionContent, "    $content;\n");
+                    push(@functionContent, "    $exceptionRaiseOnError\n");
+                } else {
+                    push(@functionContent, "    $content;\n");
+                }
+            } elsif (defined $needsCustom{"NodeToReturn"}) {
+                # TODO: This is important to enable, once we care about custom code!
+
+                # Special case the insertBefore, replaceChild, removeChild 
+                # and appendChild functions from DOMNode 
+                my $toReturn = $needsCustom{"NodeToReturn"};
+                if ($raisesExceptions) {
+                    push(@functionContent, "    $exceptionInit\n");
+                    push(@functionContent, "    if ($content)\n");
+                    push(@functionContent, "        return $toReturn;\n");
+                    push(@functionContent, "    $exceptionRaiseOnError\n");
+                    push(@functionContent, "    return $className();\n");
+                } else {
+                    push(@functionContent, "    if ($content)\n");
+                    push(@functionContent, "        return $toReturn;\n");
+                    push(@functionContent, "    return NULL;\n");
+                }
+            } else {
+                if (ConversionNeeded($function->signature->type)) {
+                    $content = "toWebKit(WTF::getPtr($content))";
+                }
+
+                if ($raisesExceptions) {
+                    # Differentiated between when the return type is a pointer and
+                    # not for white space issue (ie. Foo *result vs. int result).
+                    if ($returnType =~ /\*$/) {
+                        $content = $returnType . "result = " . $content;
+                    } else {
+                        $content = $returnType . " result = " . $content;
+                    }
+
+                    push(@functionContent, "    $exceptionInit\n");
+                    push(@functionContent, "    $content;\n");
+                    push(@functionContent, "    $exceptionRaiseOnError\n");
+                    push(@functionContent, "    return result;\n");
+                } else {
+                    push(@functionContent, "    return $content;\n");
+                }
+            }
+
+            push(@implContent, "$functionSig\n");
+            push(@implContent, "{\n");
+            push(@implContent, AddEarlyReturnStatement($returnType));
+            push(@implContent, @functionContent);
+            push(@implContent, "}\n\n");
+
+            # Clear the hash
+            %needsCustom = ();
+        }
+    }
+
+    # END implementation
+
+    # Generate internal interfaces
+    push(@implContent, "WebCore::$implClassName* toWebCore(const $className& wrapper)\n");
+    push(@implContent, "{\n");
+    push(@implContent, "    return wrapper.impl();\n");
+    push(@implContent, "}\n\n");
+
+    push(@implContent, "$className toWebKit(WebCore::$implClassName* value)\n");
+    push(@implContent, "{\n");
+    push(@implContent, "    return $className(value);\n");
+    push(@implContent, "}\n");
+
+    # - End the ifdef conditional if necessary
+    push(@implContent, "\n#endif // ${conditionalString}\n") if $conditionalString;
+}
+
+# Internal helper
+sub WriteData
+{
+    my $object = shift;
+    my $name = shift;
+
+    # Open files for writing...
+    my $headerFileName = "$outputDir/" . $name . ".h";
+    my $implFileName = "$outputDir/" . $name . ".cpp";
+
+    # Remove old files.
+    unlink($headerFileName);
+    unlink($implFileName);
+
+    # Write public header.
+    open(HEADER, ">$headerFileName") or die "Couldn't open file $headerFileName";
+    
+    print HEADER @headerContentHeader;
+    print HEADER "\n";
+    foreach my $class (sort keys(%headerForwardDeclarations)) {
+        if ($class =~ /::/) {
+            my $namespacePart = $class;
+            $namespacePart =~ s/::.*//;
+
+            my $classPart = $class;
+            $classPart =~ s/${namespacePart}:://;
+
+            print HEADER "namespace $namespacePart {\nclass $classPart;\n};\n\n";
+        } else {
+            print HEADER "class $class;\n"
+        }
+    }
+
+    my $hasForwardDeclarations = keys(%headerForwardDeclarations);
+    print HEADER "\n" if $hasForwardDeclarations;
+    print HEADER @headerContent;
+    close(HEADER);
+
+    @headerContentHeader = ();
+    @headerContent = ();
+    %headerForwardDeclarations = ();
+
+    # Write implementation file.
+    open(IMPL, ">$implFileName") or die "Couldn't open file $implFileName";
+
+    print IMPL @implContentHeader;
+
+    foreach my $include (sort keys(%implIncludes)) {
+        # "className.h" is already included right after config.h, silence check-webkit-style
+        next if $include eq "$name.h";
+        print IMPL "#include \"$include\"\n";
+    }
+
+    print IMPL @implContent;
+    close(IMPL);
+
+    @implContentHeader = ();
+    @implContent = ();
+    %implIncludes = ();
+}
+
+1;
diff --git a/WebCore/bindings/scripts/CodeGeneratorGObject.pm b/WebCore/bindings/scripts/CodeGeneratorGObject.pm
index b331f97..e98c661 100644
--- a/WebCore/bindings/scripts/CodeGeneratorGObject.pm
+++ b/WebCore/bindings/scripts/CodeGeneratorGObject.pm
@@ -362,7 +362,7 @@ sub GenerateProperty {
     }
 
     if (grep {$_ eq $attribute} @writeableProperties) {
-        push(@txtSetProps, "   case ${propEnum}:\n    {\n");
+        push(@txtSetProps, "    case ${propEnum}:\n    {\n");
         push(@txtSetProps, "        WebCore::ExceptionCode ec = 0;\n") if @{$attribute->setterExceptions};
         push(@txtSetProps, "        ${setterContentHead}");
         push(@txtSetProps, ", ec") if @{$attribute->setterExceptions};
@@ -370,7 +370,7 @@ sub GenerateProperty {
         push(@txtSetProps, "        break;\n    }\n");
     }
 
-    push(@txtGetProps, "   case ${propEnum}:\n    {\n");
+    push(@txtGetProps, "    case ${propEnum}:\n    {\n");
 
     my $exception = "";
     if (@{$attribute->getterExceptions}) {
@@ -471,6 +471,16 @@ sub GenerateEventListener {
     my $object = shift;
     my $interfaceName = shift;
 
+    # This marks event listeners in some subclasses of Element. We
+    # cannot add them, otherwise we'll get runtime errors because of
+    # duplicated signal definitions between a class and some ancestor.
+
+    # FIXME: it would be very good to be a lot more precise in how we
+    # do this...
+    if ($attribute->signature->extendedAttributes->{"WindowEventListener"}) {
+        return;
+    }
+
     my $name = $attribute->signature->name;
     my $domSignalName = substr($name, 2);
     my $gobjectSignalName = EventSignalName($domSignalName);
@@ -548,7 +558,7 @@ EOF
 
     if (scalar @writeableProperties > 0) {
         $txtSetProps = << "EOF";
-    ${className} *self = WEBKIT_DOM_${clsCaps}(object);
+    ${className}* self = WEBKIT_DOM_${clsCaps}(object);
     $privFunction
 EOF
         push(@txtSetProps, $txtSetProps);
@@ -587,6 +597,9 @@ EOF
 EOF
     push(@txtSetProps, $txtSetProps);
 
+    # Do not insert extra spaces when interpolating array variables
+    $" = "";
+
     $implContent = << "EOF";
 
 static void ${lowerCaseIfaceName}_finalize(GObject* object)
@@ -747,7 +760,7 @@ sub GenerateFunction {
     my $returnType = GetGlibTypeName($functionSigType);
     my $returnValueIsGDOMType = IsGDOMClassType($functionSigType);
 
-    my $functionSig = "$className *self";
+    my $functionSig = "${className}* self";
 
     my $callImplParams = "";
 
@@ -799,8 +812,8 @@ sub GenerateFunction {
         $functionSig .= ", GError **error";
     }
 
-    push(@hBody, "WEBKIT_API $returnType\n$functionName ($functionSig);\n\n");
-    push(@cBody, "$returnType\n$functionName ($functionSig)\n{\n");
+    push(@hBody, "WEBKIT_API $returnType\n$functionName($functionSig);\n\n");
+    push(@cBody, "$returnType\n$functionName($functionSig)\n{\n");
 
     if ($conditionalMethods{$functionName}) {
         push(@cBody, "#if ENABLE($conditionalMethods{$functionName})\n");
@@ -969,7 +982,7 @@ EOF
         push(@cBody, "#endif\n");
     }
 
-    push(@cBody, "\n}\n\n");
+    push(@cBody, "}\n\n");
 }
 
 sub ClassHasFunction {
diff --git a/WebCore/bindings/scripts/CodeGeneratorJS.pm b/WebCore/bindings/scripts/CodeGeneratorJS.pm
index bffd046..c3521bf 100644
--- a/WebCore/bindings/scripts/CodeGeneratorJS.pm
+++ b/WebCore/bindings/scripts/CodeGeneratorJS.pm
@@ -172,16 +172,16 @@ sub GenerateEventListenerCall
         push(@GenerateEventListenerImpl, <<END);
     JSValue correspondingElementWrapper = toJS(exec, imp->correspondingElement());
     if (!correspondingElementWrapper.isObject())
-        return jsUndefined();
+        return JSValue::encode(jsUndefined());
 END
     }
 
     push(@GenerateEventListenerImpl, <<END);
     JSValue listener = exec->argument(1);
     if (!listener.isObject())
-        return jsUndefined();
+        return JSValue::encode(jsUndefined());
     imp->${functionName}EventListener(ustringToAtomicString(exec->argument(0).toString(exec)), JSEventListener::create(asObject(listener), $wrapperObject, false, currentWorld(exec))$passRefPtrHandling, exec->argument(2).toBoolean(exec));
-    return jsUndefined();
+    return JSValue::encode(jsUndefined());
 END
     return @GenerateEventListenerImpl;
 }
@@ -984,12 +984,18 @@ sub GenerateHeader
 
     push(@headerContent, "};\n\n");
 
+    # Conditionally emit the constructor object's declaration
+    if ($dataNode->extendedAttributes->{"CustomConstructFunction"}) {
+        GenerateConstructorDeclaration(\@headerContent, $className, $dataNode);
+    }
+
+
     if ($numFunctions > 0) {
         push(@headerContent,"// Functions\n\n");
         foreach my $function (@{$dataNode->functions}) {
             next if $function->{overloadIndex} && $function->{overloadIndex} > 1;
             my $functionName = $codeGenerator->WK_lcfirst($className) . "PrototypeFunction" . $codeGenerator->WK_ucfirst($function->signature->name);
-            push(@headerContent, "JSC::JSValue JSC_HOST_CALL ${functionName}(JSC::ExecState*);\n");
+            push(@headerContent, "JSC::EncodedJSValue JSC_HOST_CALL ${functionName}(JSC::ExecState*);\n");
         }
     }
 
@@ -1115,7 +1121,7 @@ sub GenerateParametersCheckExpression
         # these are acceptable values for a DOMString argument (any Object can
         # be converted to a string via .toString).
         push(@andExpression, "(${value}.isNull() || ${value}.isUndefined() || ${value}.isString() || ${value}.isObject())") if $codeGenerator->IsStringType($type);
-        push(@andExpression, "(${value}.isNull() || asObject(${value})->inherits(JS${type}::s_info)") unless IsNativeType($type);
+        push(@andExpression, "(${value}.isNull() || ${value}.isObject() && asObject(${value})->inherits(&JS${type}::s_info))") unless IsNativeType($type);
 
         $parameterIndex++;
     }
@@ -1154,7 +1160,7 @@ sub GenerateOverloadedPrototypeFunction
 
     my $functionName = "js${implClassName}PrototypeFunction" . $codeGenerator->WK_ucfirst($function->signature->name);
 
-    push(@implContent, "JSValue JSC_HOST_CALL ${functionName}(ExecState* exec)\n");
+    push(@implContent, "EncodedJSValue JSC_HOST_CALL ${functionName}(ExecState* exec)\n");
     push(@implContent, <<END);
 {
 END
@@ -1164,7 +1170,7 @@ END
         push(@implContent, "        return ${functionName}$overload->{overloadIndex}(exec);\n");
     }
     push(@implContent, <<END);
-    return throwError(exec, TypeError);
+    return JSValue::encode(throwTypeError(exec));
 }
 
 END
@@ -1231,10 +1237,10 @@ sub GenerateImplementation
                                    \@hashKeys, \@hashSpecials,
                                    \@hashValue1, \@hashValue2);
 
-        my $protoClassName;
-        $protoClassName = "${className}Prototype";
+        my $protoClassName = "${className}Prototype";
 
-        push(@implContent, constructorFor($className, $protoClassName, $interfaceName, $visibleClassName, $dataNode));
+        GenerateConstructorDeclaration(\@implContent, $className, $dataNode) unless $dataNode->extendedAttributes->{"CustomConstructFunction"};
+        GenerateConstructorDefinition(\@implContent, $className, $protoClassName, $interfaceName, $visibleClassName, $dataNode);
     }
 
     # - Add functions and constants to a hashtable definition
@@ -1786,11 +1792,14 @@ sub GenerateImplementation
             if ($function->{overloads} && @{$function->{overloads}} > 1) {
                 # Append a number to an overloaded method's name to make it unique:
                 $functionName = $functionName . $function->{overloadIndex};
+                # Make this function static to avoid compiler warnings, since we
+                # don't generate a prototype for it in the header.
+                push(@implContent, "static ");
             }
             
             my $functionImplementationName = $function->signature->extendedAttributes->{"ImplementationFunction"} || $codeGenerator->WK_lcfirst($function->signature->name);
 
-            push(@implContent, "JSValue JSC_HOST_CALL ${functionName}(ExecState* exec)\n");
+            push(@implContent, "EncodedJSValue JSC_HOST_CALL ${functionName}(ExecState* exec)\n");
             push(@implContent, "{\n");
 
             $implIncludes{"<runtime/Error.h>"} = 1;
@@ -1798,22 +1807,22 @@ sub GenerateImplementation
             if ($interfaceName eq "DOMWindow") {
                 push(@implContent, "    $className* castedThis = toJSDOMWindow(exec->hostThisValue().toThisObject(exec));\n");
                 push(@implContent, "    if (!castedThis)\n");
-                push(@implContent, "        return throwError(exec, TypeError);\n");
+                push(@implContent, "        return throwVMTypeError(exec);\n");
             } elsif ($dataNode->extendedAttributes->{"IsWorkerContext"}) {
                 push(@implContent, "    $className* castedThis = to${className}(exec->hostThisValue().toThisObject(exec));\n");
                 push(@implContent, "    if (!castedThis)\n");
-                push(@implContent, "        return throwError(exec, TypeError);\n");
+                push(@implContent, "        return throwVMTypeError(exec);\n");
             } else {
                 push(@implContent, "    JSValue thisValue = exec->hostThisValue();\n");
                 push(@implContent, "    if (!thisValue.inherits(&${className}::s_info))\n");
-                push(@implContent, "        return throwError(exec, TypeError);\n");
+                push(@implContent, "        return throwVMTypeError(exec);\n");
                 push(@implContent, "    $className* castedThis = static_cast<$className*>(asObject(thisValue));\n");
             }
 
             if ($dataNode->extendedAttributes->{"CheckDomainSecurity"} && 
                 !$function->signature->extendedAttributes->{"DoNotCheckDomainSecurity"}) {
                 push(@implContent, "    if (!castedThis->allowsAccessFrom(exec))\n");
-                push(@implContent, "        return jsUndefined();\n");
+                push(@implContent, "        return JSValue::encode(jsUndefined());\n");
             }
 
             # Special case for JSSVGLengthList / JSSVGTransformList / JSSVGPointList / JSSVGNumberList
@@ -1832,12 +1841,12 @@ sub GenerateImplementation
             }
 
             if ($function->signature->extendedAttributes->{"Custom"} || $function->signature->extendedAttributes->{"JSCCustom"}) {
-                push(@implContent, "    return castedThis->" . $functionImplementationName . "(exec);\n");
+                push(@implContent, "    return JSValue::encode(castedThis->" . $functionImplementationName . "(exec));\n");
             } elsif ($svgPODListType) {
                 $implIncludes{"JS${svgPODListType}.h"} = 1;
                 $implIncludes{"JSSVGPODListCustom.h"} = 1;
-                push(@implContent, "    return JSSVGPODListCustom::$functionImplementationName<$className, " . GetNativeType($svgPODListType)
-                                 . ">(castedThis, exec, to" . $svgPODListType . ");\n");
+                push(@implContent, "    return JSValue::encode(JSSVGPODListCustom::$functionImplementationName<$className, " . GetNativeType($svgPODListType)
+                                 . ">(castedThis, exec, to" . $svgPODListType . "));\n");
             } else {
                 push(@implContent, "    $implType* imp = static_cast<$implType*>(castedThis->impl());\n");
                 push(@implContent, "    $podType podImp(*imp);\n") if $podType;
@@ -1848,9 +1857,9 @@ sub GenerateImplementation
                 if ($requiresAllArguments) {
                         push(@implContent, "    if (exec->argumentCount() < $numParameters)\n");
                         if ($requiresAllArguments eq "Raise") {
-                            push(@implContent, "        return throwError(exec, SyntaxError, \"Not enough arguments\");\n");
+                            push(@implContent, "        return throwVMError(exec, createSyntaxError(exec, \"Not enough arguments\"));\n");
                         } else {
-                            push(@implContent, "        return jsUndefined();\n");
+                            push(@implContent, "        return JSValue::encode(jsUndefined());\n");
                         }
                 }
 
@@ -1860,7 +1869,7 @@ sub GenerateImplementation
 
                 if ($function->signature->extendedAttributes->{"SVGCheckSecurityDocument"}) {
                     push(@implContent, "    if (!checkNodeSecurity(exec, imp->getSVGDocument(" . (@{$function->raisesExceptions} ? "ec" : "") .")))\n");
-                    push(@implContent, "        return jsUndefined();\n");
+                    push(@implContent, "        return JSValue::encode(jsUndefined());\n");
                     $implIncludes{"JSDOMBinding.h"} = 1;
                 }
 
@@ -1869,6 +1878,7 @@ sub GenerateImplementation
                 } elsif ($function->signature->name eq "removeEventListener") {
                     push(@implContent, GenerateEventListenerCall($className, "remove"));
                 } else {
+                    my $argsIndex = 0;
                     my $paramIndex = 0;
                     my $functionString = ($podType ? "podImp." : "imp->") . $functionImplementationName . "(";
 
@@ -1885,10 +1895,15 @@ sub GenerateImplementation
                         if ($callWith eq "DynamicFrame") {
                             push(@implContent, "    Frame* dynamicFrame = toDynamicFrame(exec);\n");
                             push(@implContent, "    if (!dynamicFrame)\n");
-                            push(@implContent, "        return jsUndefined();\n");
+                            push(@implContent, "        return JSValue::encode(jsUndefined());\n");
                             $callWithArg = "dynamicFrame";
                         } elsif ($callWith eq "ScriptState") {
                             $callWithArg = "exec";
+                        } elsif ($callWith eq "ScriptExecutionContext") {
+                            push(@implContent, "    ScriptExecutionContext* scriptContext = static_cast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();\n");
+                            push(@implContent, "    if (!scriptContext)\n");
+                            push(@implContent, "        return JSValue::encode(jsUndefined());\n");
+                            $callWithArg = "scriptContext"; 
                         }
                         $functionString .= ", " if $paramIndex;
                         $functionString .= $callWithArg;
@@ -1902,7 +1917,7 @@ sub GenerateImplementation
                                 push(@implContent, "\n    int argsCount = exec->argumentCount();\n");
                                 $hasOptionalArguments = 1;
                             }
-                            push(@implContent, "    if (argsCount < " . ($paramIndex + 1) . ") {\n");
+                            push(@implContent, "    if (argsCount < " . ($argsIndex + 1) . ") {\n");
                             GenerateImplementationFunctionCall($function, $functionString, $paramIndex, "    " x 2, $podType, $implClassName);
                             push(@implContent, "    }\n\n");
                         }
@@ -1911,15 +1926,15 @@ sub GenerateImplementation
                     
                         if ($parameter->type eq "XPathNSResolver") {
                             push(@implContent, "    RefPtr<XPathNSResolver> customResolver;\n");
-                            push(@implContent, "    XPathNSResolver* resolver = toXPathNSResolver(exec->argument($paramIndex));\n");
+                            push(@implContent, "    XPathNSResolver* resolver = toXPathNSResolver(exec->argument($argsIndex));\n");
                             push(@implContent, "    if (!resolver) {\n");
-                            push(@implContent, "        customResolver = JSCustomXPathNSResolver::create(exec, exec->argument($paramIndex));\n");
+                            push(@implContent, "        customResolver = JSCustomXPathNSResolver::create(exec, exec->argument($argsIndex));\n");
                             push(@implContent, "        if (exec->hadException())\n");
-                            push(@implContent, "            return jsUndefined();\n");
+                            push(@implContent, "            return JSValue::encode(jsUndefined());\n");
                             push(@implContent, "        resolver = customResolver.get();\n");
                             push(@implContent, "    }\n");
                         } else {
-                            push(@implContent, "    " . GetNativeTypeFromSignature($parameter) . " $name = " . JSValueToNative($parameter, "exec->argument($paramIndex)") . ";\n");
+                            push(@implContent, "    " . GetNativeTypeFromSignature($parameter) . " $name = " . JSValueToNative($parameter, "exec->argument($argsIndex)") . ";\n");
 
                             # If a parameter is "an index" and it's negative it should throw an INDEX_SIZE_ERR exception.
                             # But this needs to be done in the bindings, because the type is unsigned and the fact that it
@@ -1928,7 +1943,7 @@ sub GenerateImplementation
                                 $implIncludes{"ExceptionCode.h"} = 1;
                                 push(@implContent, "    if ($name < 0) {\n");
                                 push(@implContent, "        setDOMException(exec, INDEX_SIZE_ERR);\n");
-                                push(@implContent, "        return jsUndefined();\n");
+                                push(@implContent, "        return JSValue::encode(jsUndefined());\n");
                                 push(@implContent, "    }\n");
                             }
                         }
@@ -1940,6 +1955,7 @@ sub GenerateImplementation
                         } else {
                             $functionString .= $name;
                         }
+                        $argsIndex++;
                         $paramIndex++;
                     }
 
@@ -2221,7 +2237,7 @@ sub GenerateImplementationFunctionCall()
         push(@implContent, $indent . "$functionString;\n");
         push(@implContent, $indent . "setDOMException(exec, ec);\n") if @{$function->raisesExceptions};
         push(@implContent, $indent . "imp->commitChange(podImp, castedThis);\n") if $podType;
-        push(@implContent, $indent . "return jsUndefined();\n");
+        push(@implContent, $indent . "return JSValue::encode(jsUndefined());\n");
     } else {
         push(@implContent, "\n" . $indent . "JSC::JSValue result = " . NativeToJSValue($function->signature, 1, $implClassName, "", $functionString, "castedThis") . ";\n");
         push(@implContent, $indent . "setDOMException(exec, ec);\n") if @{$function->raisesExceptions};
@@ -2229,7 +2245,7 @@ sub GenerateImplementationFunctionCall()
         $callWith = $function->signature->extendedAttributes->{"CallWith"};
         if ($callWith and $callWith eq "ScriptState") {
             push(@implContent, $indent . "if (exec->hadException())\n");
-            push(@implContent, $indent . "    return jsUndefined();\n");
+            push(@implContent, $indent . "    return JSValue::encode(jsUndefined());\n");
         }
 
         if ($podType and not $function->signature->extendedAttributes->{"Immutable"}) {
@@ -2238,7 +2254,7 @@ sub GenerateImplementationFunctionCall()
             push(@implContent, $indent . "imp->commitChange(podImp, castedThis);\n");
         }
 
-        push(@implContent, $indent . "return result;\n");
+        push(@implContent, $indent . "return JSValue::encode(result);\n");
     }
 }
 
@@ -2702,86 +2718,94 @@ sub WriteData
     }
 }
 
-sub constructorFor
+sub GenerateConstructorDeclaration
 {
+    my $outputArray = shift;
     my $className = shift;
-    my $protoClassName = shift;
-    my $interfaceName = shift;
-    my $visibleClassName = shift;
     my $dataNode = shift;
+
     my $constructorClassName = "${className}Constructor";
     my $canConstruct = $dataNode->extendedAttributes->{"CanBeConstructed"};
     my $callWith = $dataNode->extendedAttributes->{"CallWith"};
 
-my $implContent = << "EOF";
-class ${constructorClassName} : public DOMConstructorObject {
-public:
-    ${constructorClassName}(ExecState* exec, JSDOMGlobalObject* globalObject)
-        : DOMConstructorObject(${constructorClassName}::createStructure(globalObject->objectPrototype()), globalObject)
-    {
-        putDirect(exec->propertyNames().prototype, ${protoClassName}::self(exec, globalObject), DontDelete | ReadOnly);
-    }
-    virtual bool getOwnPropertySlot(ExecState*, const Identifier&, PropertySlot&);
-    virtual bool getOwnPropertyDescriptor(ExecState*, const Identifier&, PropertyDescriptor&);
-    virtual const ClassInfo* classInfo() const { return &s_info; }
-    static const ClassInfo s_info;
+    push(@$outputArray, "class ${constructorClassName} : public DOMConstructorObject {\n");
+    push(@$outputArray, "public:\n");
+    push(@$outputArray, "    ${constructorClassName}(JSC::ExecState*, JSDOMGlobalObject*);\n\n");
 
-    static PassRefPtr<Structure> createStructure(JSValue proto) 
-    { 
-        return Structure::create(proto, TypeInfo(ObjectType, StructureFlags), AnonymousSlotCount); 
-    }
-    
-protected:
-    static const unsigned StructureFlags = OverridesGetOwnPropertySlot | ImplementsHasInstance | DOMConstructorObject::StructureFlags;
-EOF
+    push(@$outputArray, "    virtual bool getOwnPropertySlot(JSC::ExecState*, const JSC::Identifier&, JSC::PropertySlot&);\n");
+    push(@$outputArray, "    virtual bool getOwnPropertyDescriptor(JSC::ExecState*, const JSC::Identifier&, JSC::PropertyDescriptor&);\n");
+    push(@$outputArray, "    virtual const JSC::ClassInfo* classInfo() const { return &s_info; }\n");
+    push(@$outputArray, "    static const JSC::ClassInfo s_info;\n");
 
-    if ($canConstruct) {
-$implContent .= << "EOF";
-    static JSObject* construct${interfaceName}(ExecState* exec, JSObject* constructor, const ArgList&)
-    {
-EOF
+    push(@$outputArray, "    static PassRefPtr<JSC::Structure> createStructure(JSC::JSValue prototype)\n");
+    push(@$outputArray, "    {\n");
+    push(@$outputArray, "        return JSC::Structure::create(prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), AnonymousSlotCount);\n");
+    push(@$outputArray, "    }\n");
 
-    my $constructorArg = "";
-    if ($callWith and $callWith eq "ScriptExecutionContext") {
-        $constructorArg = "context";
-$implContent .= << "EOF";
-        ScriptExecutionContext* context = static_cast<${constructorClassName}*>(constructor)->scriptExecutionContext();
-        if (!context)
-            return throwError(exec, ReferenceError);
-EOF
-    }
+    push(@$outputArray, "protected:\n");
+    push(@$outputArray, "    static const unsigned StructureFlags = JSC::OverridesGetOwnPropertySlot | JSC::ImplementsHasInstance | DOMConstructorObject::StructureFlags;\n");
 
-$implContent .= << "EOF";
-        return asObject(toJS(exec, static_cast<${constructorClassName}*>(constructor)->globalObject(), ${interfaceName}::create(${constructorArg})));
-    }
-    virtual ConstructType getConstructData(ConstructData& constructData)
-    {
-        constructData.native.function = construct${interfaceName};
-        return ConstructTypeHost;
-    }
-EOF
+    if ($canConstruct) {
+        push(@$outputArray, "    static JSC::EncodedJSValue JSC_HOST_CALL construct${className}(JSC::ExecState*);\n");
+        push(@$outputArray, "    virtual JSC::ConstructType getConstructData(JSC::ConstructData&);\n");
     }
+    push(@$outputArray, "};\n\n");
+}
 
-$implContent .= << "EOF";
-};
+sub GenerateConstructorDefinition
+{
+    my $outputArray = shift;
 
-const ClassInfo ${constructorClassName}::s_info = { "${visibleClassName}Constructor", 0, &${constructorClassName}Table, 0 };
+    my $className = shift;
+    my $protoClassName = shift;
+    my $interfaceName = shift;
+    my $visibleClassName = shift;
+    my $dataNode = shift;
 
-bool ${constructorClassName}::getOwnPropertySlot(ExecState* exec, const Identifier& propertyName, PropertySlot& slot)
-{
-    return getStaticValueSlot<${constructorClassName}, DOMObject>(exec, &${constructorClassName}Table, this, propertyName, slot);
-}
+    my $constructorClassName = "${className}Constructor";
+    my $canConstruct = $dataNode->extendedAttributes->{"CanBeConstructed"};
+    my $customConstructFunction = $dataNode->extendedAttributes->{"CustomConstructFunction"};
+    my $callWith = $dataNode->extendedAttributes->{"CallWith"};
 
-bool ${constructorClassName}::getOwnPropertyDescriptor(ExecState* exec, const Identifier& propertyName, PropertyDescriptor& descriptor)
-{
-    return getStaticValueDescriptor<${constructorClassName}, DOMObject>(exec, &${constructorClassName}Table, this, propertyName, descriptor);
-}
+    push(@$outputArray, "const ClassInfo ${constructorClassName}::s_info = { \"${visibleClassName}Constructor\", 0, &${constructorClassName}Table, 0 };\n\n");
 
-EOF
+    push(@$outputArray, "${constructorClassName}::${constructorClassName}(ExecState* exec, JSDOMGlobalObject* globalObject)\n");
+    push(@$outputArray, "    : DOMConstructorObject(${constructorClassName}::createStructure(globalObject->objectPrototype()), globalObject)\n");
+    push(@$outputArray, "{\n");
+    push(@$outputArray, "    putDirect(exec->propertyNames().prototype, ${protoClassName}::self(exec, globalObject), DontDelete | ReadOnly);\n");
+    push(@$outputArray, "}\n\n");
+
+    push(@$outputArray, "bool ${constructorClassName}::getOwnPropertySlot(ExecState* exec, const Identifier& propertyName, PropertySlot& slot)\n");
+    push(@$outputArray, "{\n");
+    push(@$outputArray, "    return getStaticValueSlot<${constructorClassName}, DOMObject>(exec, &${constructorClassName}Table, this, propertyName, slot);\n");
+    push(@$outputArray, "}\n\n");
 
-    $implJSCInclude{"JSNumberCell.h"} = 1; # FIXME: What is this for?
+    push(@$outputArray, "bool ${constructorClassName}::getOwnPropertyDescriptor(ExecState* exec, const Identifier& propertyName, PropertyDescriptor& descriptor)\n");
+    push(@$outputArray, "{\n");
+    push(@$outputArray, "    return getStaticValueDescriptor<${constructorClassName}, DOMObject>(exec, &${constructorClassName}Table, this, propertyName, descriptor);\n");
+    push(@$outputArray, "}\n\n");
 
-    return $implContent;
+    if ($canConstruct) {
+        if (!$customConstructFunction) {
+            push(@$outputArray, "EncodedJSValue JSC_HOST_CALL ${constructorClassName}::construct${className}(ExecState* exec)\n");
+            push(@$outputArray, "{\n");
+            my $constructorArg = "";
+            if ($callWith and $callWith eq "ScriptExecutionContext") {
+                $constructorArg = "context";
+                push(@$outputArray, "    ScriptExecutionContext* context = static_cast<${constructorClassName}*>(exec->callee())->scriptExecutionContext();\n");
+                push(@$outputArray, "    if (!context)\n");
+                push(@$outputArray, "        return throwVMError(exec, createReferenceError(exec, \"Reference error\"));\n");
+            }
+            push(@$outputArray, "    return JSValue::encode(asObject(toJS(exec, static_cast<${constructorClassName}*>(exec->callee())->globalObject(), ${interfaceName}::create(${constructorArg}))));\n");
+            push(@$outputArray, "}\n\n");
+        }
+
+        push(@$outputArray, "ConstructType ${constructorClassName}::getConstructData(ConstructData& constructData)\n");
+        push(@$outputArray, "{\n");
+        push(@$outputArray, "    constructData.native.function = construct${className};\n");
+        push(@$outputArray, "    return ConstructTypeHost;\n");
+        push(@$outputArray, "}\n\n");
+    }
 }
 
 1;
diff --git a/WebCore/bindings/scripts/CodeGeneratorObjC.pm b/WebCore/bindings/scripts/CodeGeneratorObjC.pm
index 89da48d..daead72 100644
--- a/WebCore/bindings/scripts/CodeGeneratorObjC.pm
+++ b/WebCore/bindings/scripts/CodeGeneratorObjC.pm
@@ -5,6 +5,7 @@
 # Copyright (C) 2006 Alexey Proskuryakov <ap@webkit.org>
 # Copyright (C) 2006, 2007, 2008, 2009 Apple Inc. All rights reserved.
 # Copyright (C) 2009 Cameron McCormack <cam@mcc.id.au>
+# Copyright (C) 2010 Google Inc.
 #
 # This library is free software; you can redistribute it and/or
 # modify it under the terms of the GNU Library General Public
@@ -740,8 +741,8 @@ sub GenerateHeader
         foreach my $attribute (@{$dataNode->attributes}) {
             my $attributeName = $attribute->signature->name;
 
-            if ($attributeName eq "id" or $attributeName eq "hash") {
-                # Special case attributes id and hash to be idName and hashName to avoid ObjC naming conflict.
+            if ($attributeName eq "id" or $attributeName eq "hash" or $attributeName eq "description") {
+                # Special case some attributes (like id and hash) to have a "Name" suffix to avoid ObjC naming conflicts.
                 $attributeName .= "Name";
             } elsif ($attributeName eq "frame") {
                 # Special case attribute frame to be frameBorders.
@@ -1157,8 +1158,8 @@ sub GenerateImplementation
             my $attributeClassName = GetClassName($attribute->signature->type);
 
             my $attributeInterfaceName = $attributeName;
-            if ($attributeName eq "id" or $attributeName eq "hash") {
-                # Special case attributes id and hash to be idName and hashName to avoid ObjC naming conflict.
+            if ($attributeName eq "id" or $attributeName eq "hash" or $attributeName eq "description") {
+                # Special case some attributes (like id and hash) to have a "Name" suffix to avoid ObjC naming conflicts.
                 $attributeInterfaceName .= "Name";
             } elsif ($attributeName eq "frame") {
                 # Special case attribute frame to be frameBorders.
diff --git a/WebCore/bindings/scripts/CodeGeneratorV8.pm b/WebCore/bindings/scripts/CodeGeneratorV8.pm
index 058d1cc..e471500 100644
--- a/WebCore/bindings/scripts/CodeGeneratorV8.pm
+++ b/WebCore/bindings/scripts/CodeGeneratorV8.pm
@@ -273,6 +273,13 @@ END
 END
     }
 
+    if ($implClassName eq "HTMLDocument") {
+      push(@headerContent, <<END);
+  static v8::Local<v8::Object> WrapInShadowObject(v8::Local<v8::Object> wrapper, Node* impl);
+  static v8::Handle<v8::Value> GetNamedProperty(HTMLDocument* htmlDocument, const AtomicString& key);
+END
+    }
+
     my @enabledAtRuntime;
     foreach my $function (@{$dataNode->functions}) {
         my $name = $function->signature->name;
@@ -289,7 +296,7 @@ END
         }
     }
 
-    if ($dataNode->extendedAttributes->{"CustomConstructor"} || $dataNode->extendedAttributes->{"CanBeConstructed"}) {
+    if ($dataNode->extendedAttributes->{"CustomConstructor"} || $dataNode->extendedAttributes->{"V8CustomConstructor"} || $dataNode->extendedAttributes->{"CanBeConstructed"}) {
         push(@headerContent, <<END);
     static v8::Handle<v8::Value> constructorCallback(const v8::Arguments& args);
 END
@@ -360,9 +367,6 @@ sub GetInternalFields
 
     if (IsSubType($dataNode, "Document")) {
         push(@customInternalFields, "implementationIndex");
-        if ($name eq "HTMLDocument") {
-            push(@customInternalFields, ("markerIndex", "shadowIndex"));
-        }
     } elsif ($name eq "DOMWindow") {
         push(@customInternalFields, "enteredIsolatedWorldIndex");
     }
@@ -399,7 +403,6 @@ END
 my %indexerSpecialCases = (
     "Storage" => 1,
     "HTMLAppletElement" => 1,
-    "HTMLDocument" => 1,
     "HTMLEmbedElement" => 1,
     "HTMLObjectElement" => 1
 );
@@ -426,42 +429,47 @@ sub GenerateHeaderNamedAndIndexedPropertyAccessors
     if ($interfaceName eq "HTMLSelectElement" || $interfaceName eq "HTMLAppletElement" || $interfaceName eq "HTMLEmbedElement" || $interfaceName eq "HTMLObjectElement") {
         $hasCustomNamedGetter = 1;
     }
+    if ($interfaceName eq "HTMLDocument") {
+        $hasCustomNamedGetter = 0;
+        $hasCustomIndexedGetter = 0;
+    }
     my $isIndexerSpecialCase = exists $indexerSpecialCases{$interfaceName};
 
     if ($hasCustomIndexedGetter || $isIndexerSpecialCase) {
         push(@headerContent, <<END);
-    static v8::Handle<v8::Value> indexedPropertyGetter(uint32_t index, const v8::AccessorInfo& info);
+    static v8::Handle<v8::Value> indexedPropertyGetter(uint32_t, const v8::AccessorInfo&);
 END
     }
 
     if ($isIndexerSpecialCase || $hasCustomIndexedSetter) {
         push(@headerContent, <<END);
-    static v8::Handle<v8::Value> indexedPropertySetter(uint32_t index, v8::Local<v8::Value> value, const v8::AccessorInfo& info);
+    static v8::Handle<v8::Value> indexedPropertySetter(uint32_t, v8::Local<v8::Value>, const v8::AccessorInfo&);
 END
     }
     if ($hasCustomDeleters) {
         push(@headerContent, <<END);
-    static v8::Handle<v8::Boolean> indexedPropertyDeleter(uint32_t index, const v8::AccessorInfo& info);
+    static v8::Handle<v8::Boolean> indexedPropertyDeleter(uint32_t, const v8::AccessorInfo&);
 END
     }
     if ($hasCustomNamedGetter) {
         push(@headerContent, <<END);
-    static v8::Handle<v8::Value> namedPropertyGetter(v8::Local<v8::String> name, const v8::AccessorInfo& info);
+    static v8::Handle<v8::Value> namedPropertyGetter(v8::Local<v8::String>, const v8::AccessorInfo&);
 END
     }
     if ($hasCustomNamedSetter) {
         push(@headerContent, <<END);
-    static v8::Handle<v8::Value> namedPropertySetter(v8::Local<v8::String> name, v8::Local<v8::Value> value, const v8::AccessorInfo& info);
+    static v8::Handle<v8::Value> namedPropertySetter(v8::Local<v8::String>, v8::Local<v8::Value>, const v8::AccessorInfo&);
 END
     }
-    if ($hasCustomDeleters || $interfaceName eq "HTMLDocument") {
+    if ($hasCustomDeleters) {
         push(@headerContent, <<END);
-    static v8::Handle<v8::Boolean> namedPropertyDeleter(v8::Local<v8::String> name, const v8::AccessorInfo& info);
+    static v8::Handle<v8::Boolean> namedPropertyDeleter(v8::Local<v8::String>, const v8::AccessorInfo&);
 END
     }
     if ($hasCustomEnumerator) {
         push(@headerContent, <<END);
-    static v8::Handle<v8::Array> namedPropertyEnumerator(const v8::AccessorInfo& info);
+    static v8::Handle<v8::Array> namedPropertyEnumerator(const v8::AccessorInfo&);
+    static v8::Handle<v8::Integer> namedPropertyQuery(v8::Local<v8::String>, const v8::AccessorInfo&);
 END
     }
 }
@@ -1504,6 +1512,10 @@ sub GenerateImplementationNamedPropertyGetter
         $hasCustomGetter = 1;
     }
 
+    if ($interfaceName eq "HTMLDocument") {
+        $hasCustomGetter = 0;
+    }
+
     my $hasGetter = $dataNode->extendedAttributes->{"HasNameGetter"} || $hasCustomGetter || $namedPropertyGetter;
     if (!$hasGetter) {
         return;
@@ -1519,8 +1531,7 @@ END
     }
 
     my $hasSetter = $dataNode->extendedAttributes->{"DelegatingPutFunction"};
-    # FIXME: Try to remove hard-coded HTMLDocument reference by aligning handling of document.all with JSC bindings.
-    my $hasDeleter = $dataNode->extendedAttributes->{"CustomDeleteProperty"} || $interfaceName eq "HTMLDocument";
+    my $hasDeleter = $dataNode->extendedAttributes->{"CustomDeleteProperty"};
     my $hasEnumerator = $dataNode->extendedAttributes->{"CustomGetPropertyNames"};
     my $setOn = "Instance";
 
@@ -1536,7 +1547,8 @@ END
 
     push(@implContent, "    desc->${setOn}Template()->SetNamedPropertyHandler(V8${interfaceName}::namedPropertyGetter, ");
     push(@implContent, $hasSetter ? "V8${interfaceName}::namedPropertySetter, " : "0, ");
-    push(@implContent, "0, "); # NamedPropertyQuery -- not being used at the moment.
+    # If there is a custom enumerator, there MUST be custom query to properly communicate property attributes.
+    push(@implContent, $hasEnumerator ? "V8${interfaceName}::namedPropertyQuery, " : "0, ");
     push(@implContent, $hasDeleter ? "V8${interfaceName}::namedPropertyDeleter, " : "0, ");
     push(@implContent, $hasEnumerator ? "V8${interfaceName}::namedPropertyEnumerator" : "0");
     push(@implContent, ");\n");
@@ -1780,7 +1792,7 @@ END
     push(@implContentDecls, "} // namespace ${interfaceName}Internal\n\n");
 
     # In namespace WebCore, add generated implementation for 'CanBeConstructed'.
-    if ($dataNode->extendedAttributes->{"CanBeConstructed"} && !$dataNode->extendedAttributes->{"CustomConstructor"}) {
+    if ($dataNode->extendedAttributes->{"CanBeConstructed"} && !$dataNode->extendedAttributes->{"CustomConstructor"} && !$dataNode->extendedAttributes->{"V8CustomConstructor"}) {
         my $v8ConstructFunction;
         my $callWith = $dataNode->extendedAttributes->{"CallWith"};
         if ($callWith and $callWith eq "ScriptExecutionContext") {
@@ -1858,7 +1870,7 @@ END
 END
     }
 
-    if ($dataNode->extendedAttributes->{"CustomConstructor"} || $dataNode->extendedAttributes->{"CanBeConstructed"}) {
+    if ($dataNode->extendedAttributes->{"CustomConstructor"} || $dataNode->extendedAttributes->{"V8CustomConstructor"} || $dataNode->extendedAttributes->{"CanBeConstructed"}) {
         push(@implContent, <<END);
         desc->SetCallHandler(V8${interfaceName}::constructorCallback);
 END
@@ -2003,6 +2015,11 @@ END
     instance->SetAccessCheckCallbacks(V8DOMWindow::namedSecurityCheck, V8DOMWindow::indexedSecurityCheck, v8::External::Wrap(&V8DOMWindow::info), false);
 END
     }
+    if ($interfaceName eq "HTMLDocument") {
+        push(@implContent, <<END);
+    desc->SetHiddenPrototype(true);
+END
+    }
     if ($interfaceName eq "Location") {
         push(@implContent, <<END);
 
@@ -2220,6 +2237,7 @@ sub GenerateCallbackImplementation
     $implIncludes{"V8CustomVoidCallback.h"} = 1;
     $implIncludes{"V8Proxy.h"} = 1;
 
+    push(@implContent, "#include <wtf/Assertions.h>\n\n");
     push(@implContent, "namespace WebCore {\n\n");
     push(@implContent, <<END);
 ${className}::${className}(v8::Local<v8::Object> callback)
@@ -2261,15 +2279,20 @@ END
             push(@implContent, "    if (v8Context.IsEmpty())\n");
             push(@implContent, "        return true;\n\n");
             push(@implContent, "    v8::Context::Scope scope(v8Context);\n\n");
-            push(@implContent, "    v8::Handle<v8::Value> argv[] = {\n");
 
             my @argvs = ();
             foreach my $param (@params) {
                 my $paramName = $param->name;
-                push(@argvs, "        toV8(${paramName})");
+                push(@implContent, "    v8::Handle<v8::Value> ${paramName}Handle = toV8(${paramName});\n");
+                push(@implContent, "    if (${paramName}Handle.IsEmpty()) {\n");
+                push(@implContent, "        CRASH();\n");
+                push(@implContent, "        return true;\n");
+                push(@implContent, "    }\n");
+                push(@argvs, "        ${paramName}Handle");
             }
-            push(@implContent, join(",\n", @argvs));
 
+            push(@implContent, "\n    v8::Handle<v8::Value> argv[] = {\n");
+            push(@implContent, join(",\n", @argvs));
             push(@implContent, "\n    };\n\n");
             push(@implContent, "    bool callbackReturnValue = false;\n");
             push(@implContent, "    return !invokeCallback(m_callback, " . scalar(@params) . ", argv, callbackReturnValue, context);\n");
@@ -2531,6 +2554,11 @@ sub GenerateFunctionCallString()
             $result .= $indent . "EmptyScriptState state;\n";
             $callWithArg = "&state";
             $hasScriptState = 1;
+        } elsif ($callWith eq "ScriptExecutionContext") {
+            $result .= $indent . "ScriptExecutionContext* scriptContext = getScriptExecutionContext();\n";
+            $result .= $indent . "if (!scriptContext)\n";
+            $result .= $indent . "    return v8::Undefined();\n";
+            $callWithArg = "scriptContext";
         }
         $functionString .= ", " if $index;
         $functionString .= $callWithArg;
diff --git a/WebCore/bindings/scripts/IDLParser.pm b/WebCore/bindings/scripts/IDLParser.pm
index 5b7beb3..3df96ab 100644
--- a/WebCore/bindings/scripts/IDLParser.pm
+++ b/WebCore/bindings/scripts/IDLParser.pm
@@ -21,6 +21,8 @@
 
 package IDLParser;
 
+use strict;
+
 use IPC::Open2;
 use IDLStructure;
 
@@ -82,7 +84,7 @@ sub Parse
 
     print " | *** Starting to parse $fileName...\n |\n" unless $beQuiet;
 
-    $pid = open2(\*PP_OUT, \*PP_IN, split(' ', $preprocessor), (map { "-D$_" } split(' ', $defines)), $fileName);
+    my $pid = open2(\*PP_OUT, \*PP_IN, split(' ', $preprocessor), (map { "-D$_" } split(' ', $defines)), $fileName);
     close PP_IN;
     my @documentContent = <PP_OUT>;
     close PP_OUT;
@@ -148,7 +150,7 @@ sub dumpExtendedAttributes
     }
 
     my @temp;
-    while (($name, $value) = each(%{$attrs})) {
+    while ((my $name, my $value) = each(%{$attrs})) {
         push(@temp, "$name=$value");
     }
 
@@ -163,11 +165,11 @@ sub parseExtendedAttributes
     my %attrs = ();
 
     foreach my $value (split(/\s*,\s*/, $str)) {
-        ($name,$value) = split(/\s*=\s*/, $value, 2);
+        (my $name, my $val) = split(/\s*=\s*/, $value, 2);
 
         # Attributes with no value are set to be true
-        $value = 1 unless defined $value;
-        $attrs{$name} = $value;
+        $val = 1 unless defined $val;
+        $attrs{$name} = $val;
         die("Invalid extended attribute name: '$name'\n") if $name =~ /\s/;
     }
 
@@ -232,9 +234,9 @@ sub ParseInterface
         # Match identifier of the interface, and enclosed data...
         $data =~ /$IDLStructure::interfaceSelector/;
 
-        $interfaceExtendedAttributes = (defined($1) ? $1 : " "); chop($interfaceExtendedAttributes);
+        my $interfaceExtendedAttributes = (defined($1) ? $1 : " "); chop($interfaceExtendedAttributes);
         $interfaceName = (defined($2) ? $2 : die("Parsing error!\nSource:\n$data\n)"));
-        $interfaceBase = (defined($3) ? $3 : "");
+        my $interfaceBase = (defined($3) ? $3 : "");
         $interfaceData = (defined($4) ? $4 : die("Parsing error!\nSource:\n$data\n)"));
 
         # Fill in known parts of the domClass datastructure now...
diff --git a/WebCore/bindings/scripts/IDLStructure.pm b/WebCore/bindings/scripts/IDLStructure.pm
index e060252..d61fce1 100644
--- a/WebCore/bindings/scripts/IDLStructure.pm
+++ b/WebCore/bindings/scripts/IDLStructure.pm
@@ -21,6 +21,8 @@
 
 package IDLStructure;
 
+use strict;
+
 use Class::Struct;
 
 # Used to represent a parsed IDL document
@@ -70,36 +72,36 @@ struct( domConstant => {
 });
 
 # Helpers
-$idlId = '[a-zA-Z0-9]';        # Generic identifier
-$idlIdNs = '[a-zA-Z0-9:]';      # Generic identifier including namespace
-$idlIdNsList = '[a-zA-Z0-9:,\ ]';  # List of Generic identifiers including namespace
+our $idlId = '[a-zA-Z0-9]';        # Generic identifier
+our $idlIdNs = '[a-zA-Z0-9:]';      # Generic identifier including namespace
+our $idlIdNsList = '[a-zA-Z0-9:,\ ]';  # List of Generic identifiers including namespace
 
-$idlType = '[a-zA-Z0-9_]';      # Generic type/"value string" identifier
-$idlDataType = '[a-zA-Z0-9\ ]';   # Generic data type identifier
+our $idlType = '[a-zA-Z0-9_]';      # Generic type/"value string" identifier
+our $idlDataType = '[a-zA-Z0-9\ ]';   # Generic data type identifier
 
 # Magic IDL parsing regular expressions
 my $supportedTypes = "((?:unsigned )?(?:int|short|(?:long )?long)|(?:$idlIdNs*))";
 
 # Special IDL notations
-$extendedAttributeSyntax = '\[[^]]*\]'; # Used for extended attributes
+our $extendedAttributeSyntax = '\[[^]]*\]'; # Used for extended attributes
 
 # Regular expression based IDL 'syntactical tokenizer' used in the IDLParser
-$moduleSelector = 'module\s*(' . $idlId . '*)\s*{';
-$moduleNSSelector = 'module\s*(' . $idlId . '*)\s*\[ns\s*(' . $idlIdNs . '*)\s*(' . $idlIdNs . '*)\]\s*;';
-$constantSelector = 'const\s*' . $supportedTypes . '\s*(' . $idlType . '*)\s*=\s*(' . $idlType . '*)';
-$raisesSelector = 'raises\s*\((' . $idlIdNsList . '*)\s*\)';
-$getterRaisesSelector = '\bgetter\s+raises\s*\((' . $idlIdNsList . '*)\s*\)';
-$setterRaisesSelector = '\bsetter\s+raises\s*\((' . $idlIdNsList . '*)\s*\)';
+our $moduleSelector = 'module\s*(' . $idlId . '*)\s*{';
+our $moduleNSSelector = 'module\s*(' . $idlId . '*)\s*\[ns\s*(' . $idlIdNs . '*)\s*(' . $idlIdNs . '*)\]\s*;';
+our $constantSelector = 'const\s*' . $supportedTypes . '\s*(' . $idlType . '*)\s*=\s*(' . $idlType . '*)';
+our $raisesSelector = 'raises\s*\((' . $idlIdNsList . '*)\s*\)';
+our $getterRaisesSelector = '\bgetter\s+raises\s*\((' . $idlIdNsList . '*)\s*\)';
+our $setterRaisesSelector = '\bsetter\s+raises\s*\((' . $idlIdNsList . '*)\s*\)';
 
-$typeNamespaceSelector = '((?:' . $idlId . '*::)*)\s*(' . $idlDataType . '*)';
+our $typeNamespaceSelector = '((?:' . $idlId . '*::)*)\s*(' . $idlDataType . '*)';
 
-$exceptionSelector = 'exception\s*(' . $idlIdNs . '*)\s*([a-zA-Z\s{;]*};)';
-$exceptionSubSelector = '{\s*' . $supportedTypes . '\s*(' . $idlType . '*)\s*;\s*}';
+our $exceptionSelector = 'exception\s*(' . $idlIdNs . '*)\s*([a-zA-Z\s{;]*};)';
+our $exceptionSubSelector = '{\s*' . $supportedTypes . '\s*(' . $idlType . '*)\s*;\s*}';
 
-$interfaceSelector = 'interface\s*((?:' . $extendedAttributeSyntax . ' )?)(' . $idlIdNs . '*)\s*(?::(\s*[^{]*))?{([a-zA-Z0-9_=\s(),;:\[\]&\|]*)';
-$interfaceMethodSelector = '\s*((?:' . $extendedAttributeSyntax . ' )?)' . $supportedTypes . '\s*(' . $idlIdNs . '*)\s*\(\s*([a-zA-Z0-9:\s,=\[\]]*)';
-$interfaceParameterSelector = 'in\s*((?:' . $extendedAttributeSyntax . ' )?)' . $supportedTypes . '\s*(' . $idlIdNs . '*)';
+our $interfaceSelector = 'interface\s*((?:' . $extendedAttributeSyntax . ' )?)(' . $idlIdNs . '*)\s*(?::(\s*[^{]*))?{([a-zA-Z0-9_=\s(),;:\[\]&\|]*)';
+our $interfaceMethodSelector = '\s*((?:' . $extendedAttributeSyntax . ' )?)' . $supportedTypes . '\s*(' . $idlIdNs . '*)\s*\(\s*([a-zA-Z0-9:\s,=\[\]]*)';
+our $interfaceParameterSelector = 'in\s*((?:' . $extendedAttributeSyntax . ' )?)' . $supportedTypes . '\s*(' . $idlIdNs . '*)';
 
-$interfaceAttributeSelector = '\s*(readonly attribute|attribute)\s*(' . $extendedAttributeSyntax . ' )?' . $supportedTypes . '\s*(' . $idlType . '*)';
+our $interfaceAttributeSelector = '\s*(readonly attribute|attribute)\s*(' . $extendedAttributeSyntax . ' )?' . $supportedTypes . '\s*(' . $idlType . '*)';
 
 1;
diff --git a/WebCore/bindings/scripts/test/CPP/WebDOMTestCallback.cpp b/WebCore/bindings/scripts/test/CPP/WebDOMTestCallback.cpp
new file mode 100644
index 0000000..7235793
--- /dev/null
+++ b/WebCore/bindings/scripts/test/CPP/WebDOMTestCallback.cpp
@@ -0,0 +1,113 @@
+/*
+ * This file is part of the WebKit open source project.
+ * This file has been generated by generate-bindings.pl. DO NOT MODIFY!
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public License
+ * along with this library; see the file COPYING.LIB.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include "config.h"
+
+#if ENABLE(DATABASE)
+
+#include "WebDOMTestCallback.h"
+
+#include "AtomicString.h"
+#include "Class1.h"
+#include "Class2.h"
+#include "Class3.h"
+#include "KURL.h"
+#include "TestCallback.h"
+#include "WebDOMClass1.h"
+#include "WebDOMClass2.h"
+#include "WebDOMClass3.h"
+#include "WebDOMString.h"
+#include "WebExceptionHandler.h"
+#include <wtf/GetPtr.h>
+#include <wtf/RefPtr.h>
+
+struct WebDOMTestCallback::WebDOMTestCallbackPrivate {
+    WebDOMTestCallbackPrivate(WebCore::TestCallback* object = 0)
+        : impl(object)
+    {
+    }
+
+    RefPtr<WebCore::TestCallback> impl;
+};
+
+WebDOMTestCallback::WebDOMTestCallback()
+    : WebDOMObject()
+    , m_impl(0)
+{
+}
+
+WebDOMTestCallback::WebDOMTestCallback(WebCore::TestCallback* impl)
+    : WebDOMObject()
+    , m_impl(new WebDOMTestCallbackPrivate(impl))
+{
+}
+
+WebDOMTestCallback::WebDOMTestCallback(const WebDOMTestCallback& copy)
+    : WebDOMObject()
+{
+    m_impl = copy.impl() ? new WebDOMTestCallbackPrivate(copy.impl()) : 0;
+}
+
+WebCore::TestCallback* WebDOMTestCallback::impl() const
+{
+    return m_impl ? m_impl->impl.get() : 0;
+}
+
+WebDOMTestCallback::~WebDOMTestCallback()
+{
+    delete m_impl;
+    m_impl = 0;
+}
+
+bool WebDOMTestCallback::callbackWithClass1Param(const WebDOMClass1& class1Param)
+{
+    if (!impl())
+        return false;
+
+    return impl()->callbackWithClass1Param(0, toWebCore(class1Param));
+}
+
+bool WebDOMTestCallback::callbackWithClass2Param(const WebDOMClass2& class2Param, const WebDOMString& strArg)
+{
+    if (!impl())
+        return false;
+
+    return impl()->callbackWithClass2Param(0, toWebCore(class2Param), strArg);
+}
+
+int WebDOMTestCallback::callbackWithNonBoolReturnType(const WebDOMClass3& class3Param)
+{
+    if (!impl())
+        return 0;
+
+    return impl()->callbackWithNonBoolReturnType(0, toWebCore(class3Param));
+}
+
+WebCore::TestCallback* toWebCore(const WebDOMTestCallback& wrapper)
+{
+    return wrapper.impl();
+}
+
+WebDOMTestCallback toWebKit(WebCore::TestCallback* value)
+{
+    return WebDOMTestCallback(value);
+}
+
+#endif // ENABLE(DATABASE)
diff --git a/WebCore/bindings/scripts/test/CPP/WebDOMTestCallback.h b/WebCore/bindings/scripts/test/CPP/WebDOMTestCallback.h
new file mode 100644
index 0000000..3fe6837
--- /dev/null
+++ b/WebCore/bindings/scripts/test/CPP/WebDOMTestCallback.h
@@ -0,0 +1,65 @@
+/*
+ * Copyright (C) Research In Motion Limited 2010. All rights reserved.
+ * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009 Apple Inc. All rights reserved.
+ * Copyright (C) 2006 Samuel Weinig <sam.weinig@gmail.com>
+ * Copyright (C) Research In Motion Limited 2010. All rights reserved.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public License
+ * along with this library; see the file COPYING.LIB.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#ifndef WebDOMTestCallback_h
+#define WebDOMTestCallback_h
+
+#if ENABLE(DATABASE)
+
+#include <WebDOMObject.h>
+#include <WebDOMString.h>
+
+namespace WebCore {
+class TestCallback;
+};
+
+class WebDOMClass1;
+class WebDOMClass2;
+class WebDOMClass3;
+class WebDOMClass5;
+class WebDOMClass6;
+
+class WebDOMTestCallback : public WebDOMObject {
+public:
+    WebDOMTestCallback();
+    explicit WebDOMTestCallback(WebCore::TestCallback*);
+    WebDOMTestCallback(const WebDOMTestCallback&);
+    ~WebDOMTestCallback();
+
+    bool callbackWithClass1Param(const WebDOMClass1& class1Param);
+    bool callbackWithClass2Param(const WebDOMClass2& class2Param, const WebDOMString& strArg);
+    int callbackWithNonBoolReturnType(const WebDOMClass3& class3Param);
+    int customCallback(const WebDOMClass5& class5Param, const WebDOMClass6& class6Param);
+
+    WebCore::TestCallback* impl() const;
+
+protected:
+    struct WebDOMTestCallbackPrivate;
+    WebDOMTestCallbackPrivate* m_impl;
+};
+
+WebCore::TestCallback* toWebCore(const WebDOMTestCallback&);
+WebDOMTestCallback toWebKit(WebCore::TestCallback*);
+
+#endif
+#endif // ENABLE(DATABASE)
+
diff --git a/WebCore/bindings/scripts/test/CPP/WebDOMTestInterface.cpp b/WebCore/bindings/scripts/test/CPP/WebDOMTestInterface.cpp
new file mode 100644
index 0000000..0b20841
--- /dev/null
+++ b/WebCore/bindings/scripts/test/CPP/WebDOMTestInterface.cpp
@@ -0,0 +1,75 @@
+/*
+ * This file is part of the WebKit open source project.
+ * This file has been generated by generate-bindings.pl. DO NOT MODIFY!
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public License
+ * along with this library; see the file COPYING.LIB.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include "config.h"
+#include "WebDOMTestInterface.h"
+
+#include "TestInterface.h"
+#include "WebExceptionHandler.h"
+#include <wtf/GetPtr.h>
+#include <wtf/RefPtr.h>
+
+struct WebDOMTestInterface::WebDOMTestInterfacePrivate {
+    WebDOMTestInterfacePrivate(WebCore::TestInterface* object = 0)
+        : impl(object)
+    {
+    }
+
+    RefPtr<WebCore::TestInterface> impl;
+};
+
+WebDOMTestInterface::WebDOMTestInterface()
+    : WebDOMObject()
+    , m_impl(0)
+{
+}
+
+WebDOMTestInterface::WebDOMTestInterface(WebCore::TestInterface* impl)
+    : WebDOMObject()
+    , m_impl(new WebDOMTestInterfacePrivate(impl))
+{
+}
+
+WebDOMTestInterface::WebDOMTestInterface(const WebDOMTestInterface& copy)
+    : WebDOMObject()
+{
+    m_impl = copy.impl() ? new WebDOMTestInterfacePrivate(copy.impl()) : 0;
+}
+
+WebCore::TestInterface* WebDOMTestInterface::impl() const
+{
+    return m_impl ? m_impl->impl.get() : 0;
+}
+
+WebDOMTestInterface::~WebDOMTestInterface()
+{
+    delete m_impl;
+    m_impl = 0;
+}
+
+WebCore::TestInterface* toWebCore(const WebDOMTestInterface& wrapper)
+{
+    return wrapper.impl();
+}
+
+WebDOMTestInterface toWebKit(WebCore::TestInterface* value)
+{
+    return WebDOMTestInterface(value);
+}
diff --git a/WebCore/bindings/scripts/test/CPP/WebDOMTestInterface.h b/WebCore/bindings/scripts/test/CPP/WebDOMTestInterface.h
new file mode 100644
index 0000000..d0cee5b
--- /dev/null
+++ b/WebCore/bindings/scripts/test/CPP/WebDOMTestInterface.h
@@ -0,0 +1,52 @@
+/*
+ * Copyright (C) Research In Motion Limited 2010. All rights reserved.
+ * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009 Apple Inc. All rights reserved.
+ * Copyright (C) 2006 Samuel Weinig <sam.weinig@gmail.com>
+ * Copyright (C) Research In Motion Limited 2010. All rights reserved.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public License
+ * along with this library; see the file COPYING.LIB.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#ifndef WebDOMTestInterface_h
+#define WebDOMTestInterface_h
+
+#include <WebDOMObject.h>
+#include <WebDOMString.h>
+
+namespace WebCore {
+class TestInterface;
+};
+
+
+class WebDOMTestInterface : public WebDOMObject {
+public:
+    WebDOMTestInterface();
+    explicit WebDOMTestInterface(WebCore::TestInterface*);
+    WebDOMTestInterface(const WebDOMTestInterface&);
+    ~WebDOMTestInterface();
+
+
+    WebCore::TestInterface* impl() const;
+
+protected:
+    struct WebDOMTestInterfacePrivate;
+    WebDOMTestInterfacePrivate* m_impl;
+};
+
+WebCore::TestInterface* toWebCore(const WebDOMTestInterface&);
+WebDOMTestInterface toWebKit(WebCore::TestInterface*);
+
+#endif
diff --git a/WebCore/bindings/scripts/test/CPP/WebDOMTestObj.cpp b/WebCore/bindings/scripts/test/CPP/WebDOMTestObj.cpp
new file mode 100644
index 0000000..e540a57
--- /dev/null
+++ b/WebCore/bindings/scripts/test/CPP/WebDOMTestObj.cpp
@@ -0,0 +1,441 @@
+/*
+ * This file is part of the WebKit open source project.
+ * This file has been generated by generate-bindings.pl. DO NOT MODIFY!
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public License
+ * along with this library; see the file COPYING.LIB.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include "config.h"
+#include "WebDOMTestObj.h"
+
+#include "AtomicString.h"
+#include "KURL.h"
+#include "SerializedScriptValue.h"
+#include "TestObj.h"
+#include "WebDOMString.h"
+#include "WebExceptionHandler.h"
+#include "WebNativeEventListener.h"
+#include <wtf/GetPtr.h>
+#include <wtf/RefPtr.h>
+
+struct WebDOMTestObj::WebDOMTestObjPrivate {
+    WebDOMTestObjPrivate(WebCore::TestObj* object = 0)
+        : impl(object)
+    {
+    }
+
+    RefPtr<WebCore::TestObj> impl;
+};
+
+WebDOMTestObj::WebDOMTestObj()
+    : WebDOMObject()
+    , m_impl(0)
+{
+}
+
+WebDOMTestObj::WebDOMTestObj(WebCore::TestObj* impl)
+    : WebDOMObject()
+    , m_impl(new WebDOMTestObjPrivate(impl))
+{
+}
+
+WebDOMTestObj::WebDOMTestObj(const WebDOMTestObj& copy)
+    : WebDOMObject()
+{
+    m_impl = copy.impl() ? new WebDOMTestObjPrivate(copy.impl()) : 0;
+}
+
+WebCore::TestObj* WebDOMTestObj::impl() const
+{
+    return m_impl ? m_impl->impl.get() : 0;
+}
+
+WebDOMTestObj::~WebDOMTestObj()
+{
+    delete m_impl;
+    m_impl = 0;
+}
+
+int WebDOMTestObj::readOnlyIntAttr() const
+{
+    if (!impl())
+        return 0;
+
+    return impl()->readOnlyIntAttr();
+}
+
+WebDOMString WebDOMTestObj::readOnlyStringAttr() const
+{
+    if (!impl())
+        return WebDOMString();
+
+    return static_cast<const WebCore::String&>(impl()->readOnlyStringAttr());
+}
+
+WebDOMTestObj WebDOMTestObj::readOnlyTestObjAttr() const
+{
+    if (!impl())
+        return WebDOMTestObj();
+
+    return toWebKit(WTF::getPtr(impl()->readOnlyTestObjAttr()));
+}
+
+int WebDOMTestObj::intAttr() const
+{
+    if (!impl())
+        return 0;
+
+    return impl()->intAttr();
+}
+
+void WebDOMTestObj::setIntAttr(int newIntAttr)
+{
+    if (!impl())
+        return;
+
+    impl()->setIntAttr(newIntAttr);
+}
+
+long long WebDOMTestObj::longLongAttr() const
+{
+    if (!impl())
+        return 0;
+
+    return impl()->longLongAttr();
+}
+
+void WebDOMTestObj::setLongLongAttr(long long newLongLongAttr)
+{
+    if (!impl())
+        return;
+
+    impl()->setLongLongAttr(newLongLongAttr);
+}
+
+unsigned long long WebDOMTestObj::unsignedLongLongAttr() const
+{
+    if (!impl())
+        return 0;
+
+    return impl()->unsignedLongLongAttr();
+}
+
+void WebDOMTestObj::setUnsignedLongLongAttr(unsigned long long newUnsignedLongLongAttr)
+{
+    if (!impl())
+        return;
+
+    impl()->setUnsignedLongLongAttr(newUnsignedLongLongAttr);
+}
+
+WebDOMString WebDOMTestObj::stringAttr() const
+{
+    if (!impl())
+        return WebDOMString();
+
+    return static_cast<const WebCore::String&>(impl()->stringAttr());
+}
+
+void WebDOMTestObj::setStringAttr(const WebDOMString& newStringAttr)
+{
+    if (!impl())
+        return;
+
+    impl()->setStringAttr(newStringAttr);
+}
+
+WebDOMTestObj WebDOMTestObj::testObjAttr() const
+{
+    if (!impl())
+        return WebDOMTestObj();
+
+    return toWebKit(WTF::getPtr(impl()->testObjAttr()));
+}
+
+void WebDOMTestObj::setTestObjAttr(const WebDOMTestObj& newTestObjAttr)
+{
+    if (!impl())
+        return;
+
+    impl()->setTestObjAttr(toWebCore(newTestObjAttr));
+}
+
+int WebDOMTestObj::attrWithException() const
+{
+    if (!impl())
+        return 0;
+
+    return impl()->attrWithException();
+}
+
+void WebDOMTestObj::setAttrWithException(int newAttrWithException)
+{
+    if (!impl())
+        return;
+
+    impl()->setAttrWithException(newAttrWithException);
+}
+
+int WebDOMTestObj::attrWithSetterException() const
+{
+    if (!impl())
+        return 0;
+
+    WebCore::ExceptionCode ec = 0;
+    int result = impl()->attrWithSetterException(ec);
+    webDOMRaiseError(static_cast<WebDOMExceptionCode>(ec));
+    return result;
+}
+
+void WebDOMTestObj::setAttrWithSetterException(int newAttrWithSetterException)
+{
+    if (!impl())
+        return;
+
+    WebCore::ExceptionCode ec = 0;
+    impl()->setAttrWithSetterException(newAttrWithSetterException, ec);
+    webDOMRaiseError(static_cast<WebDOMExceptionCode>(ec));
+}
+
+int WebDOMTestObj::attrWithGetterException() const
+{
+    if (!impl())
+        return 0;
+
+    return impl()->attrWithGetterException();
+}
+
+void WebDOMTestObj::setAttrWithGetterException(int newAttrWithGetterException)
+{
+    if (!impl())
+        return;
+
+    WebCore::ExceptionCode ec = 0;
+    impl()->setAttrWithGetterException(newAttrWithGetterException, ec);
+    webDOMRaiseError(static_cast<WebDOMExceptionCode>(ec));
+}
+
+WebDOMString WebDOMTestObj::scriptStringAttr() const
+{
+    if (!impl())
+        return WebDOMString();
+
+    return static_cast<const WebCore::String&>(impl()->scriptStringAttr());
+}
+
+void WebDOMTestObj::voidMethod()
+{
+    if (!impl())
+        return;
+
+    impl()->voidMethod();
+}
+
+void WebDOMTestObj::voidMethodWithArgs(int intArg, const WebDOMString& strArg, const WebDOMTestObj& objArg)
+{
+    if (!impl())
+        return;
+
+    impl()->voidMethodWithArgs(intArg, strArg, toWebCore(objArg));
+}
+
+int WebDOMTestObj::intMethod()
+{
+    if (!impl())
+        return 0;
+
+    return impl()->intMethod();
+}
+
+int WebDOMTestObj::intMethodWithArgs(int intArg, const WebDOMString& strArg, const WebDOMTestObj& objArg)
+{
+    if (!impl())
+        return 0;
+
+    return impl()->intMethodWithArgs(intArg, strArg, toWebCore(objArg));
+}
+
+WebDOMTestObj WebDOMTestObj::objMethod()
+{
+    if (!impl())
+        return WebDOMTestObj();
+
+    return toWebKit(WTF::getPtr(impl()->objMethod()));
+}
+
+WebDOMTestObj WebDOMTestObj::objMethodWithArgs(int intArg, const WebDOMString& strArg, const WebDOMTestObj& objArg)
+{
+    if (!impl())
+        return WebDOMTestObj();
+
+    return toWebKit(WTF::getPtr(impl()->objMethodWithArgs(intArg, strArg, toWebCore(objArg))));
+}
+
+WebDOMTestObj WebDOMTestObj::methodThatRequiresAllArgs(const WebDOMString& strArg, const WebDOMTestObj& objArg)
+{
+    if (!impl())
+        return WebDOMTestObj();
+
+    return toWebKit(WTF::getPtr(impl()->methodThatRequiresAllArgs(strArg, toWebCore(objArg))));
+}
+
+WebDOMTestObj WebDOMTestObj::methodThatRequiresAllArgsAndThrows(const WebDOMString& strArg, const WebDOMTestObj& objArg)
+{
+    if (!impl())
+        return WebDOMTestObj();
+
+    WebCore::ExceptionCode ec = 0;
+    WebDOMTestObj result = toWebKit(WTF::getPtr(impl()->methodThatRequiresAllArgsAndThrows(strArg, toWebCore(objArg), ec)));
+    webDOMRaiseError(static_cast<WebDOMExceptionCode>(ec));
+    return result;
+}
+
+void WebDOMTestObj::serializedValue(const WebDOMString& serializedArg)
+{
+    if (!impl())
+        return;
+
+    impl()->serializedValue(WebCore::SerializedScriptValue::create(WebCore::String(serializedArg)));
+}
+
+void WebDOMTestObj::methodWithException()
+{
+    if (!impl())
+        return;
+
+    WebCore::ExceptionCode ec = 0;
+    impl()->methodWithException(ec);
+    webDOMRaiseError(static_cast<WebDOMExceptionCode>(ec));
+}
+
+void WebDOMTestObj::addEventListener(const WebDOMString& type, const WebDOMEventListener& listener, bool useCapture)
+{
+    if (!impl())
+        return;
+
+    impl()->addEventListener(type, toWebCore(listener), useCapture);
+}
+
+void WebDOMTestObj::removeEventListener(const WebDOMString& type, const WebDOMEventListener& listener, bool useCapture)
+{
+    if (!impl())
+        return;
+
+    impl()->removeEventListener(type, toWebCore(listener), useCapture);
+}
+
+void WebDOMTestObj::withDynamicFrame()
+{
+    if (!impl())
+        return;
+
+    impl()->withDynamicFrame();
+}
+
+void WebDOMTestObj::withDynamicFrameAndArg(int intArg)
+{
+    if (!impl())
+        return;
+
+    impl()->withDynamicFrameAndArg(intArg);
+}
+
+void WebDOMTestObj::withDynamicFrameAndOptionalArg(int intArg, int optionalArg)
+{
+    if (!impl())
+        return;
+
+    impl()->withDynamicFrameAndOptionalArg(intArg, optionalArg);
+}
+
+void WebDOMTestObj::withScriptStateVoid()
+{
+    if (!impl())
+        return;
+
+    impl()->withScriptStateVoid();
+}
+
+WebDOMTestObj WebDOMTestObj::withScriptStateObj()
+{
+    if (!impl())
+        return WebDOMTestObj();
+
+    return toWebKit(WTF::getPtr(impl()->withScriptStateObj()));
+}
+
+void WebDOMTestObj::withScriptStateVoidException()
+{
+    if (!impl())
+        return;
+
+    WebCore::ExceptionCode ec = 0;
+    impl()->withScriptStateVoidException(ec);
+    webDOMRaiseError(static_cast<WebDOMExceptionCode>(ec));
+}
+
+WebDOMTestObj WebDOMTestObj::withScriptStateObjException()
+{
+    if (!impl())
+        return WebDOMTestObj();
+
+    WebCore::ExceptionCode ec = 0;
+    WebDOMTestObj result = toWebKit(WTF::getPtr(impl()->withScriptStateObjException(ec)));
+    webDOMRaiseError(static_cast<WebDOMExceptionCode>(ec));
+    return result;
+}
+
+void WebDOMTestObj::withScriptExecutionContext()
+{
+    if (!impl())
+        return;
+
+    impl()->withScriptExecutionContext();
+}
+
+void WebDOMTestObj::methodWithOptionalArg(int opt)
+{
+    if (!impl())
+        return;
+
+    impl()->methodWithOptionalArg(opt);
+}
+
+void WebDOMTestObj::methodWithNonOptionalArgAndOptionalArg(int nonOpt, int opt)
+{
+    if (!impl())
+        return;
+
+    impl()->methodWithNonOptionalArgAndOptionalArg(nonOpt, opt);
+}
+
+void WebDOMTestObj::methodWithNonOptionalArgAndTwoOptionalArgs(int nonOpt, int opt1, int opt2)
+{
+    if (!impl())
+        return;
+
+    impl()->methodWithNonOptionalArgAndTwoOptionalArgs(nonOpt, opt1, opt2);
+}
+
+WebCore::TestObj* toWebCore(const WebDOMTestObj& wrapper)
+{
+    return wrapper.impl();
+}
+
+WebDOMTestObj toWebKit(WebCore::TestObj* value)
+{
+    return WebDOMTestObj(value);
+}
diff --git a/WebCore/bindings/scripts/test/CPP/WebDOMTestObj.h b/WebCore/bindings/scripts/test/CPP/WebDOMTestObj.h
new file mode 100644
index 0000000..7bcd988
--- /dev/null
+++ b/WebCore/bindings/scripts/test/CPP/WebDOMTestObj.h
@@ -0,0 +1,105 @@
+/*
+ * Copyright (C) Research In Motion Limited 2010. All rights reserved.
+ * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009 Apple Inc. All rights reserved.
+ * Copyright (C) 2006 Samuel Weinig <sam.weinig@gmail.com>
+ * Copyright (C) Research In Motion Limited 2010. All rights reserved.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public License
+ * along with this library; see the file COPYING.LIB.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#ifndef WebDOMTestObj_h
+#define WebDOMTestObj_h
+
+#include <WebDOMObject.h>
+#include <WebDOMString.h>
+
+namespace WebCore {
+class TestObj;
+};
+
+class WebDOMEventListener;
+class WebDOMString;
+class WebDOMTestObj;
+
+class WebDOMTestObj : public WebDOMObject {
+public:
+    WebDOMTestObj();
+    explicit WebDOMTestObj(WebCore::TestObj*);
+    WebDOMTestObj(const WebDOMTestObj&);
+    ~WebDOMTestObj();
+
+    int readOnlyIntAttr() const;
+    WebDOMString readOnlyStringAttr() const;
+    WebDOMTestObj readOnlyTestObjAttr() const;
+    int intAttr() const;
+    void setIntAttr(int);
+    long long longLongAttr() const;
+    void setLongLongAttr(long long);
+    unsigned long long unsignedLongLongAttr() const;
+    void setUnsignedLongLongAttr(unsigned long long);
+    WebDOMString stringAttr() const;
+    void setStringAttr(const WebDOMString&);
+    WebDOMTestObj testObjAttr() const;
+    void setTestObjAttr(const WebDOMTestObj&);
+    int attrWithException() const;
+    void setAttrWithException(int);
+    int attrWithSetterException() const;
+    void setAttrWithSetterException(int);
+    int attrWithGetterException() const;
+    void setAttrWithGetterException(int);
+    int customAttr() const;
+    void setCustomAttr(int);
+    WebDOMString scriptStringAttr() const;
+
+    void voidMethod();
+    void voidMethodWithArgs(int intArg, const WebDOMString& strArg, const WebDOMTestObj& objArg);
+    int intMethod();
+    int intMethodWithArgs(int intArg, const WebDOMString& strArg, const WebDOMTestObj& objArg);
+    WebDOMTestObj objMethod();
+    WebDOMTestObj objMethodWithArgs(int intArg, const WebDOMString& strArg, const WebDOMTestObj& objArg);
+    WebDOMTestObj methodThatRequiresAllArgs(const WebDOMString& strArg, const WebDOMTestObj& objArg);
+    WebDOMTestObj methodThatRequiresAllArgsAndThrows(const WebDOMString& strArg, const WebDOMTestObj& objArg);
+    void serializedValue(const WebDOMString& serializedArg);
+    void methodWithException();
+    void customMethod();
+    void customMethodWithArgs(int intArg, const WebDOMString& strArg, const WebDOMTestObj& objArg);
+    void addEventListener(const WebDOMString& type, const WebDOMEventListener& listener, bool useCapture);
+    void removeEventListener(const WebDOMString& type, const WebDOMEventListener& listener, bool useCapture);
+    void withDynamicFrame();
+    void withDynamicFrameAndArg(int intArg);
+    void withDynamicFrameAndOptionalArg(int intArg, int optionalArg);
+    void withDynamicFrameAndUserGesture(int intArg);
+    void withDynamicFrameAndUserGestureASAD(int intArg, int optionalArg);
+    void withScriptStateVoid();
+    WebDOMTestObj withScriptStateObj();
+    void withScriptStateVoidException();
+    WebDOMTestObj withScriptStateObjException();
+    void withScriptExecutionContext();
+    void methodWithOptionalArg(int opt);
+    void methodWithNonOptionalArgAndOptionalArg(int nonOpt, int opt);
+    void methodWithNonOptionalArgAndTwoOptionalArgs(int nonOpt, int opt1, int opt2);
+
+    WebCore::TestObj* impl() const;
+
+protected:
+    struct WebDOMTestObjPrivate;
+    WebDOMTestObjPrivate* m_impl;
+};
+
+WebCore::TestObj* toWebCore(const WebDOMTestObj&);
+WebDOMTestObj toWebKit(WebCore::TestObj*);
+
+#endif
diff --git a/WebCore/bindings/scripts/test/GObject/WebKitDOMTestCallback.cpp b/WebCore/bindings/scripts/test/GObject/WebKitDOMTestCallback.cpp
index 505b59b..a67b6ac 100644
--- a/WebCore/bindings/scripts/test/GObject/WebKitDOMTestCallback.cpp
+++ b/WebCore/bindings/scripts/test/GObject/WebKitDOMTestCallback.cpp
@@ -53,7 +53,7 @@ gpointer kit(WebCore::TestCallback* obj)
 } // namespace WebKit //
 
 gboolean
-webkit_dom_test_callback_callback_with_class1param (WebKitDOMTestCallback *self, WebKitDOMClass1*  class1param)
+webkit_dom_test_callback_callback_with_class1param(WebKitDOMTestCallback* self, WebKitDOMClass1*  class1param)
 {
     g_return_val_if_fail (self, 0);
     WebCore::TestCallback * item = WebKit::core(self);
@@ -62,11 +62,10 @@ webkit_dom_test_callback_callback_with_class1param (WebKitDOMTestCallback *self,
     g_return_val_if_fail (_g_class1param, 0);
     gboolean res = item->callbackWithClass1Param(_g_class1param);
     return res;
-
 }
 
 gboolean
-webkit_dom_test_callback_callback_with_class2param (WebKitDOMTestCallback *self, WebKitDOMClass2*  class2param, gchar*  str_arg)
+webkit_dom_test_callback_callback_with_class2param(WebKitDOMTestCallback* self, WebKitDOMClass2*  class2param, gchar*  str_arg)
 {
     g_return_val_if_fail (self, 0);
     WebCore::TestCallback * item = WebKit::core(self);
@@ -77,11 +76,10 @@ webkit_dom_test_callback_callback_with_class2param (WebKitDOMTestCallback *self,
     WebCore::String _g_str_arg = WebCore::String::fromUTF8(str_arg);
     gboolean res = item->callbackWithClass2Param(_g_class2param, _g_str_arg);
     return res;
-
 }
 
 glong
-webkit_dom_test_callback_callback_with_non_bool_return_type (WebKitDOMTestCallback *self, WebKitDOMClass3*  class3param)
+webkit_dom_test_callback_callback_with_non_bool_return_type(WebKitDOMTestCallback* self, WebKitDOMClass3*  class3param)
 {
     g_return_val_if_fail (self, 0);
     WebCore::TestCallback * item = WebKit::core(self);
@@ -90,7 +88,6 @@ webkit_dom_test_callback_callback_with_non_bool_return_type (WebKitDOMTestCallba
     g_return_val_if_fail (_g_class3param, 0);
     glong res = item->callbackWithNonBoolReturnType(_g_class3param);
     return res;
-
 }
 
 
@@ -132,8 +129,8 @@ static void webkit_dom_test_callback_finalize(GObject* object)
 
 static void webkit_dom_test_callback_set_property(GObject* object, guint prop_id, const GValue* value, GParamSpec* pspec)
 {
-     switch (prop_id) {
-     default:
+    switch (prop_id) {
+    default:
         G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
         break;
     }
@@ -142,8 +139,8 @@ static void webkit_dom_test_callback_set_property(GObject* object, guint prop_id
 
 static void webkit_dom_test_callback_get_property(GObject* object, guint prop_id, GValue* value, GParamSpec* pspec)
 {
-     switch (prop_id) {
-     default:
+    switch (prop_id) {
+    default:
         G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
         break;
     }
diff --git a/WebCore/bindings/scripts/test/GObject/WebKitDOMTestCallback.h b/WebCore/bindings/scripts/test/GObject/WebKitDOMTestCallback.h
index 088c457..cfc883d 100644
--- a/WebCore/bindings/scripts/test/GObject/WebKitDOMTestCallback.h
+++ b/WebCore/bindings/scripts/test/GObject/WebKitDOMTestCallback.h
@@ -47,13 +47,13 @@ WEBKIT_API GType
 webkit_dom_test_callback_get_type (void);
 
 WEBKIT_API gboolean
-webkit_dom_test_callback_callback_with_class1param (WebKitDOMTestCallback *self, WebKitDOMClass1*  class1param);
+webkit_dom_test_callback_callback_with_class1param(WebKitDOMTestCallback* self, WebKitDOMClass1*  class1param);
 
 WEBKIT_API gboolean
-webkit_dom_test_callback_callback_with_class2param (WebKitDOMTestCallback *self, WebKitDOMClass2*  class2param, gchar*  str_arg);
+webkit_dom_test_callback_callback_with_class2param(WebKitDOMTestCallback* self, WebKitDOMClass2*  class2param, gchar*  str_arg);
 
 WEBKIT_API glong
-webkit_dom_test_callback_callback_with_non_bool_return_type (WebKitDOMTestCallback *self, WebKitDOMClass3*  class3param);
+webkit_dom_test_callback_callback_with_non_bool_return_type(WebKitDOMTestCallback* self, WebKitDOMClass3*  class3param);
 
 G_END_DECLS
 
diff --git a/WebCore/bindings/scripts/test/GObject/WebKitDOMTestInterface.cpp b/WebCore/bindings/scripts/test/GObject/WebKitDOMTestInterface.cpp
index 17548d9..0d0021d 100644
--- a/WebCore/bindings/scripts/test/GObject/WebKitDOMTestInterface.cpp
+++ b/WebCore/bindings/scripts/test/GObject/WebKitDOMTestInterface.cpp
@@ -85,8 +85,8 @@ static void webkit_dom_test_interface_finalize(GObject* object)
 
 static void webkit_dom_test_interface_set_property(GObject* object, guint prop_id, const GValue* value, GParamSpec* pspec)
 {
-     switch (prop_id) {
-     default:
+    switch (prop_id) {
+    default:
         G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
         break;
     }
@@ -95,8 +95,8 @@ static void webkit_dom_test_interface_set_property(GObject* object, guint prop_i
 
 static void webkit_dom_test_interface_get_property(GObject* object, guint prop_id, GValue* value, GParamSpec* pspec)
 {
-     switch (prop_id) {
-     default:
+    switch (prop_id) {
+    default:
         G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
         break;
     }
diff --git a/WebCore/bindings/scripts/test/GObject/WebKitDOMTestObj.cpp b/WebCore/bindings/scripts/test/GObject/WebKitDOMTestObj.cpp
index 2fa8c00..5dfb255 100644
--- a/WebCore/bindings/scripts/test/GObject/WebKitDOMTestObj.cpp
+++ b/WebCore/bindings/scripts/test/GObject/WebKitDOMTestObj.cpp
@@ -49,16 +49,15 @@ gpointer kit(WebCore::TestObj* obj)
 } // namespace WebKit //
 
 void
-webkit_dom_test_obj_void_method (WebKitDOMTestObj *self)
+webkit_dom_test_obj_void_method(WebKitDOMTestObj* self)
 {
     g_return_if_fail (self);
     WebCore::TestObj * item = WebKit::core(self);
     item->voidMethod();
-
 }
 
 void
-webkit_dom_test_obj_void_method_with_args (WebKitDOMTestObj *self, glong int_arg, gchar*  str_arg, WebKitDOMTestObj*  obj_arg)
+webkit_dom_test_obj_void_method_with_args(WebKitDOMTestObj* self, glong int_arg, gchar*  str_arg, WebKitDOMTestObj*  obj_arg)
 {
     g_return_if_fail (self);
     WebCore::TestObj * item = WebKit::core(self);
@@ -68,21 +67,19 @@ webkit_dom_test_obj_void_method_with_args (WebKitDOMTestObj *self, glong int_arg
     WebCore::TestObj * _g_obj_arg = WebKit::core(obj_arg);
     g_return_if_fail (_g_obj_arg);
     item->voidMethodWithArgs(int_arg, _g_str_arg, _g_obj_arg);
-
 }
 
 glong
-webkit_dom_test_obj_int_method (WebKitDOMTestObj *self)
+webkit_dom_test_obj_int_method(WebKitDOMTestObj* self)
 {
     g_return_val_if_fail (self, 0);
     WebCore::TestObj * item = WebKit::core(self);
     glong res = item->intMethod();
     return res;
-
 }
 
 glong
-webkit_dom_test_obj_int_method_with_args (WebKitDOMTestObj *self, glong int_arg, gchar*  str_arg, WebKitDOMTestObj*  obj_arg)
+webkit_dom_test_obj_int_method_with_args(WebKitDOMTestObj* self, glong int_arg, gchar*  str_arg, WebKitDOMTestObj*  obj_arg)
 {
     g_return_val_if_fail (self, 0);
     WebCore::TestObj * item = WebKit::core(self);
@@ -93,22 +90,20 @@ webkit_dom_test_obj_int_method_with_args (WebKitDOMTestObj *self, glong int_arg,
     g_return_val_if_fail (_g_obj_arg, 0);
     glong res = item->intMethodWithArgs(int_arg, _g_str_arg, _g_obj_arg);
     return res;
-
 }
 
 WebKitDOMTestObj* 
-webkit_dom_test_obj_obj_method (WebKitDOMTestObj *self)
+webkit_dom_test_obj_obj_method(WebKitDOMTestObj* self)
 {
     g_return_val_if_fail (self, 0);
     WebCore::TestObj * item = WebKit::core(self);
     PassRefPtr<WebCore::TestObj> g_res = WTF::getPtr(item->objMethod());
     WebKitDOMTestObj*  res = static_cast<WebKitDOMTestObj* >(WebKit::kit(g_res.get()));
     return res;
-
 }
 
 WebKitDOMTestObj* 
-webkit_dom_test_obj_obj_method_with_args (WebKitDOMTestObj *self, glong int_arg, gchar*  str_arg, WebKitDOMTestObj*  obj_arg)
+webkit_dom_test_obj_obj_method_with_args(WebKitDOMTestObj* self, glong int_arg, gchar*  str_arg, WebKitDOMTestObj*  obj_arg)
 {
     g_return_val_if_fail (self, 0);
     WebCore::TestObj * item = WebKit::core(self);
@@ -120,11 +115,10 @@ webkit_dom_test_obj_obj_method_with_args (WebKitDOMTestObj *self, glong int_arg,
     PassRefPtr<WebCore::TestObj> g_res = WTF::getPtr(item->objMethodWithArgs(int_arg, _g_str_arg, _g_obj_arg));
     WebKitDOMTestObj*  res = static_cast<WebKitDOMTestObj* >(WebKit::kit(g_res.get()));
     return res;
-
 }
 
 WebKitDOMTestObj* 
-webkit_dom_test_obj_method_that_requires_all_args (WebKitDOMTestObj *self, gchar*  str_arg, WebKitDOMTestObj*  obj_arg)
+webkit_dom_test_obj_method_that_requires_all_args(WebKitDOMTestObj* self, gchar*  str_arg, WebKitDOMTestObj*  obj_arg)
 {
     g_return_val_if_fail (self, 0);
     WebCore::TestObj * item = WebKit::core(self);
@@ -136,11 +130,10 @@ webkit_dom_test_obj_method_that_requires_all_args (WebKitDOMTestObj *self, gchar
     PassRefPtr<WebCore::TestObj> g_res = WTF::getPtr(item->methodThatRequiresAllArgs(_g_str_arg, _g_obj_arg));
     WebKitDOMTestObj*  res = static_cast<WebKitDOMTestObj* >(WebKit::kit(g_res.get()));
     return res;
-
 }
 
 WebKitDOMTestObj* 
-webkit_dom_test_obj_method_that_requires_all_args_and_throws (WebKitDOMTestObj *self, gchar*  str_arg, WebKitDOMTestObj*  obj_arg, GError **error)
+webkit_dom_test_obj_method_that_requires_all_args_and_throws(WebKitDOMTestObj* self, gchar*  str_arg, WebKitDOMTestObj*  obj_arg, GError **error)
 {
     g_return_val_if_fail (self, 0);
     WebCore::TestObj * item = WebKit::core(self);
@@ -158,11 +151,10 @@ webkit_dom_test_obj_method_that_requires_all_args_and_throws (WebKitDOMTestObj *
     }
     WebKitDOMTestObj*  res = static_cast<WebKitDOMTestObj* >(WebKit::kit(g_res.get()));
     return res;
-
 }
 
 void
-webkit_dom_test_obj_serialized_value (WebKitDOMTestObj *self, WebKitDOMSerializedScriptValue*  serialized_arg)
+webkit_dom_test_obj_serialized_value(WebKitDOMTestObj* self, WebKitDOMSerializedScriptValue*  serialized_arg)
 {
     g_return_if_fail (self);
     WebCore::TestObj * item = WebKit::core(self);
@@ -170,11 +162,10 @@ webkit_dom_test_obj_serialized_value (WebKitDOMTestObj *self, WebKitDOMSerialize
     WebCore::SerializedScriptValue * _g_serialized_arg = WebKit::core(serialized_arg);
     g_return_if_fail (_g_serialized_arg);
     item->serializedValue(_g_serialized_arg);
-
 }
 
 void
-webkit_dom_test_obj_method_with_exception (WebKitDOMTestObj *self, GError **error)
+webkit_dom_test_obj_method_with_exception(WebKitDOMTestObj* self, GError **error)
 {
     g_return_if_fail (self);
     WebCore::TestObj * item = WebKit::core(self);
@@ -185,7 +176,6 @@ webkit_dom_test_obj_method_with_exception (WebKitDOMTestObj *self, GError **erro
         WebCore::getExceptionCodeDescription(ec, ecdesc);
         g_set_error_literal(error, g_quark_from_string("WEBKIT_DOM"), ecdesc.code, ecdesc.name);
     }
-
 }
 
 
@@ -195,72 +185,65 @@ webkit_dom_test_obj_method_with_exception (WebKitDOMTestObj *self, GError **erro
 /* TODO: event function webkit_dom_test_obj_remove_event_listener */
 
 void
-webkit_dom_test_obj_with_dynamic_frame (WebKitDOMTestObj *self)
+webkit_dom_test_obj_with_dynamic_frame(WebKitDOMTestObj* self)
 {
     g_return_if_fail (self);
     WebCore::TestObj * item = WebKit::core(self);
     item->withDynamicFrame();
-
 }
 
 void
-webkit_dom_test_obj_with_dynamic_frame_and_arg (WebKitDOMTestObj *self, glong int_arg)
+webkit_dom_test_obj_with_dynamic_frame_and_arg(WebKitDOMTestObj* self, glong int_arg)
 {
     g_return_if_fail (self);
     WebCore::TestObj * item = WebKit::core(self);
     item->withDynamicFrameAndArg(int_arg);
-
 }
 
 void
-webkit_dom_test_obj_with_dynamic_frame_and_optional_arg (WebKitDOMTestObj *self, glong int_arg, glong optional_arg)
+webkit_dom_test_obj_with_dynamic_frame_and_optional_arg(WebKitDOMTestObj* self, glong int_arg, glong optional_arg)
 {
     g_return_if_fail (self);
     WebCore::TestObj * item = WebKit::core(self);
     item->withDynamicFrameAndOptionalArg(int_arg, optional_arg);
-
 }
 
 void
-webkit_dom_test_obj_with_dynamic_frame_and_user_gesture (WebKitDOMTestObj *self, glong int_arg)
+webkit_dom_test_obj_with_dynamic_frame_and_user_gesture(WebKitDOMTestObj* self, glong int_arg)
 {
     g_return_if_fail (self);
     WebCore::TestObj * item = WebKit::core(self);
     item->withDynamicFrameAndUserGesture(int_arg);
-
 }
 
 void
-webkit_dom_test_obj_with_dynamic_frame_and_user_gesture_asad (WebKitDOMTestObj *self, glong int_arg, glong optional_arg)
+webkit_dom_test_obj_with_dynamic_frame_and_user_gesture_asad(WebKitDOMTestObj* self, glong int_arg, glong optional_arg)
 {
     g_return_if_fail (self);
     WebCore::TestObj * item = WebKit::core(self);
     item->withDynamicFrameAndUserGestureASAD(int_arg, optional_arg);
-
 }
 
 void
-webkit_dom_test_obj_with_script_state_void (WebKitDOMTestObj *self)
+webkit_dom_test_obj_with_script_state_void(WebKitDOMTestObj* self)
 {
     g_return_if_fail (self);
     WebCore::TestObj * item = WebKit::core(self);
     item->withScriptStateVoid();
-
 }
 
 WebKitDOMTestObj* 
-webkit_dom_test_obj_with_script_state_obj (WebKitDOMTestObj *self)
+webkit_dom_test_obj_with_script_state_obj(WebKitDOMTestObj* self)
 {
     g_return_val_if_fail (self, 0);
     WebCore::TestObj * item = WebKit::core(self);
     PassRefPtr<WebCore::TestObj> g_res = WTF::getPtr(item->withScriptStateObj());
     WebKitDOMTestObj*  res = static_cast<WebKitDOMTestObj* >(WebKit::kit(g_res.get()));
     return res;
-
 }
 
 void
-webkit_dom_test_obj_with_script_state_void_exception (WebKitDOMTestObj *self, GError **error)
+webkit_dom_test_obj_with_script_state_void_exception(WebKitDOMTestObj* self, GError **error)
 {
     g_return_if_fail (self);
     WebCore::TestObj * item = WebKit::core(self);
@@ -271,11 +254,10 @@ webkit_dom_test_obj_with_script_state_void_exception (WebKitDOMTestObj *self, GE
         WebCore::getExceptionCodeDescription(ec, ecdesc);
         g_set_error_literal(error, g_quark_from_string("WEBKIT_DOM"), ecdesc.code, ecdesc.name);
     }
-
 }
 
 WebKitDOMTestObj* 
-webkit_dom_test_obj_with_script_state_obj_exception (WebKitDOMTestObj *self, GError **error)
+webkit_dom_test_obj_with_script_state_obj_exception(WebKitDOMTestObj* self, GError **error)
 {
     g_return_val_if_fail (self, 0);
     WebCore::TestObj * item = WebKit::core(self);
@@ -288,158 +270,150 @@ webkit_dom_test_obj_with_script_state_obj_exception (WebKitDOMTestObj *self, GEr
     }
     WebKitDOMTestObj*  res = static_cast<WebKitDOMTestObj* >(WebKit::kit(g_res.get()));
     return res;
+}
 
+void
+webkit_dom_test_obj_with_script_execution_context(WebKitDOMTestObj* self)
+{
+    g_return_if_fail (self);
+    WebCore::TestObj * item = WebKit::core(self);
+    item->withScriptExecutionContext();
 }
 
 void
-webkit_dom_test_obj_method_with_optional_arg (WebKitDOMTestObj *self, glong opt)
+webkit_dom_test_obj_method_with_optional_arg(WebKitDOMTestObj* self, glong opt)
 {
     g_return_if_fail (self);
     WebCore::TestObj * item = WebKit::core(self);
     item->methodWithOptionalArg(opt);
-
 }
 
 void
-webkit_dom_test_obj_method_with_non_optional_arg_and_optional_arg (WebKitDOMTestObj *self, glong non_opt, glong opt)
+webkit_dom_test_obj_method_with_non_optional_arg_and_optional_arg(WebKitDOMTestObj* self, glong non_opt, glong opt)
 {
     g_return_if_fail (self);
     WebCore::TestObj * item = WebKit::core(self);
     item->methodWithNonOptionalArgAndOptionalArg(non_opt, opt);
-
 }
 
 void
-webkit_dom_test_obj_method_with_non_optional_arg_and_two_optional_args (WebKitDOMTestObj *self, glong non_opt, glong opt1, glong opt2)
+webkit_dom_test_obj_method_with_non_optional_arg_and_two_optional_args(WebKitDOMTestObj* self, glong non_opt, glong opt1, glong opt2)
 {
     g_return_if_fail (self);
     WebCore::TestObj * item = WebKit::core(self);
     item->methodWithNonOptionalArgAndTwoOptionalArgs(non_opt, opt1, opt2);
-
 }
 
 glong
-webkit_dom_test_obj_get_read_only_int_attr (WebKitDOMTestObj *self)
+webkit_dom_test_obj_get_read_only_int_attr(WebKitDOMTestObj* self)
 {
     g_return_val_if_fail (self, 0);
     WebCore::TestObj * item = WebKit::core(self);
     glong res = item->readOnlyIntAttr();
     return res;
-
 }
 
 gchar* 
-webkit_dom_test_obj_get_read_only_string_attr (WebKitDOMTestObj *self)
+webkit_dom_test_obj_get_read_only_string_attr(WebKitDOMTestObj* self)
 {
     g_return_val_if_fail (self, 0);
     WebCore::TestObj * item = WebKit::core(self);
     gchar*  res = convertToUTF8String(item->readOnlyStringAttr());
     return res;
-
 }
 
 WebKitDOMTestObj* 
-webkit_dom_test_obj_get_read_only_test_obj_attr (WebKitDOMTestObj *self)
+webkit_dom_test_obj_get_read_only_test_obj_attr(WebKitDOMTestObj* self)
 {
     g_return_val_if_fail (self, 0);
     WebCore::TestObj * item = WebKit::core(self);
     PassRefPtr<WebCore::TestObj> g_res = WTF::getPtr(item->readOnlyTestObjAttr());
     WebKitDOMTestObj*  res = static_cast<WebKitDOMTestObj* >(WebKit::kit(g_res.get()));
     return res;
-
 }
 
 glong
-webkit_dom_test_obj_get_int_attr (WebKitDOMTestObj *self)
+webkit_dom_test_obj_get_int_attr(WebKitDOMTestObj* self)
 {
     g_return_val_if_fail (self, 0);
     WebCore::TestObj * item = WebKit::core(self);
     glong res = item->intAttr();
     return res;
-
 }
 
 void
-webkit_dom_test_obj_set_int_attr (WebKitDOMTestObj *self, glong value)
+webkit_dom_test_obj_set_int_attr(WebKitDOMTestObj* self, glong value)
 {
     g_return_if_fail (self);
     WebCore::TestObj * item = WebKit::core(self);
     item->setIntAttr(value);
-
 }
 
 gint64
-webkit_dom_test_obj_get_long_long_attr (WebKitDOMTestObj *self)
+webkit_dom_test_obj_get_long_long_attr(WebKitDOMTestObj* self)
 {
     g_return_val_if_fail (self, 0);
     WebCore::TestObj * item = WebKit::core(self);
     gint64 res = item->longLongAttr();
     return res;
-
 }
 
 void
-webkit_dom_test_obj_set_long_long_attr (WebKitDOMTestObj *self, gint64 value)
+webkit_dom_test_obj_set_long_long_attr(WebKitDOMTestObj* self, gint64 value)
 {
     g_return_if_fail (self);
     WebCore::TestObj * item = WebKit::core(self);
     item->setLongLongAttr(value);
-
 }
 
 guint64
-webkit_dom_test_obj_get_unsigned_long_long_attr (WebKitDOMTestObj *self)
+webkit_dom_test_obj_get_unsigned_long_long_attr(WebKitDOMTestObj* self)
 {
     g_return_val_if_fail (self, 0);
     WebCore::TestObj * item = WebKit::core(self);
     guint64 res = item->unsignedLongLongAttr();
     return res;
-
 }
 
 void
-webkit_dom_test_obj_set_unsigned_long_long_attr (WebKitDOMTestObj *self, guint64 value)
+webkit_dom_test_obj_set_unsigned_long_long_attr(WebKitDOMTestObj* self, guint64 value)
 {
     g_return_if_fail (self);
     WebCore::TestObj * item = WebKit::core(self);
     item->setUnsignedLongLongAttr(value);
-
 }
 
 gchar* 
-webkit_dom_test_obj_get_string_attr (WebKitDOMTestObj *self)
+webkit_dom_test_obj_get_string_attr(WebKitDOMTestObj* self)
 {
     g_return_val_if_fail (self, 0);
     WebCore::TestObj * item = WebKit::core(self);
     gchar*  res = convertToUTF8String(item->stringAttr());
     return res;
-
 }
 
 void
-webkit_dom_test_obj_set_string_attr (WebKitDOMTestObj *self, gchar*  value)
+webkit_dom_test_obj_set_string_attr(WebKitDOMTestObj* self, gchar*  value)
 {
     g_return_if_fail (self);
     WebCore::TestObj * item = WebKit::core(self);
     g_return_if_fail (value);
     WebCore::String _g_value = WebCore::String::fromUTF8(value);
     item->setStringAttr(_g_value);
-
 }
 
 WebKitDOMTestObj* 
-webkit_dom_test_obj_get_test_obj_attr (WebKitDOMTestObj *self)
+webkit_dom_test_obj_get_test_obj_attr(WebKitDOMTestObj* self)
 {
     g_return_val_if_fail (self, 0);
     WebCore::TestObj * item = WebKit::core(self);
     PassRefPtr<WebCore::TestObj> g_res = WTF::getPtr(item->testObjAttr());
     WebKitDOMTestObj*  res = static_cast<WebKitDOMTestObj* >(WebKit::kit(g_res.get()));
     return res;
-
 }
 
 void
-webkit_dom_test_obj_set_test_obj_attr (WebKitDOMTestObj *self, WebKitDOMTestObj*  value)
+webkit_dom_test_obj_set_test_obj_attr(WebKitDOMTestObj* self, WebKitDOMTestObj*  value)
 {
     g_return_if_fail (self);
     WebCore::TestObj * item = WebKit::core(self);
@@ -447,30 +421,27 @@ webkit_dom_test_obj_set_test_obj_attr (WebKitDOMTestObj *self, WebKitDOMTestObj*
     WebCore::TestObj * _g_value = WebKit::core(value);
     g_return_if_fail (_g_value);
     item->setTestObjAttr(_g_value);
-
 }
 
 glong
-webkit_dom_test_obj_get_attr_with_exception (WebKitDOMTestObj *self)
+webkit_dom_test_obj_get_attr_with_exception(WebKitDOMTestObj* self)
 {
     g_return_val_if_fail (self, 0);
     WebCore::TestObj * item = WebKit::core(self);
     glong res = item->attrWithException();
     return res;
-
 }
 
 void
-webkit_dom_test_obj_set_attr_with_exception (WebKitDOMTestObj *self, glong value)
+webkit_dom_test_obj_set_attr_with_exception(WebKitDOMTestObj* self, glong value)
 {
     g_return_if_fail (self);
     WebCore::TestObj * item = WebKit::core(self);
     item->setAttrWithException(value);
-
 }
 
 glong
-webkit_dom_test_obj_get_attr_with_setter_exception (WebKitDOMTestObj *self, GError **error)
+webkit_dom_test_obj_get_attr_with_setter_exception(WebKitDOMTestObj* self, GError **error)
 {
     g_return_val_if_fail (self, 0);
     WebCore::TestObj * item = WebKit::core(self);
@@ -482,11 +453,10 @@ webkit_dom_test_obj_get_attr_with_setter_exception (WebKitDOMTestObj *self, GErr
         g_set_error_literal(error, g_quark_from_string("WEBKIT_DOM"), ecdesc.code, ecdesc.name);
     }
     return res;
-
 }
 
 void
-webkit_dom_test_obj_set_attr_with_setter_exception (WebKitDOMTestObj *self, glong value, GError **error)
+webkit_dom_test_obj_set_attr_with_setter_exception(WebKitDOMTestObj* self, glong value, GError **error)
 {
     g_return_if_fail (self);
     WebCore::TestObj * item = WebKit::core(self);
@@ -497,21 +467,19 @@ webkit_dom_test_obj_set_attr_with_setter_exception (WebKitDOMTestObj *self, glon
         WebCore::getExceptionCodeDescription(ec, ecdesc);
         g_set_error_literal(error, g_quark_from_string("WEBKIT_DOM"), ecdesc.code, ecdesc.name);
     }
-
 }
 
 glong
-webkit_dom_test_obj_get_attr_with_getter_exception (WebKitDOMTestObj *self)
+webkit_dom_test_obj_get_attr_with_getter_exception(WebKitDOMTestObj* self)
 {
     g_return_val_if_fail (self, 0);
     WebCore::TestObj * item = WebKit::core(self);
     glong res = item->attrWithGetterException();
     return res;
-
 }
 
 void
-webkit_dom_test_obj_set_attr_with_getter_exception (WebKitDOMTestObj *self, glong value, GError **error)
+webkit_dom_test_obj_set_attr_with_getter_exception(WebKitDOMTestObj* self, glong value, GError **error)
 {
     g_return_if_fail (self);
     WebCore::TestObj * item = WebKit::core(self);
@@ -522,17 +490,50 @@ webkit_dom_test_obj_set_attr_with_getter_exception (WebKitDOMTestObj *self, glon
         WebCore::getExceptionCodeDescription(ec, ecdesc);
         g_set_error_literal(error, g_quark_from_string("WEBKIT_DOM"), ecdesc.code, ecdesc.name);
     }
-
 }
 
 gchar* 
-webkit_dom_test_obj_get_script_string_attr (WebKitDOMTestObj *self)
+webkit_dom_test_obj_get_script_string_attr(WebKitDOMTestObj* self)
 {
     g_return_val_if_fail (self, 0);
     WebCore::TestObj * item = WebKit::core(self);
     gchar*  res = convertToUTF8String(item->scriptStringAttr());
     return res;
+}
 
+glong
+webkit_dom_test_obj_get_description(WebKitDOMTestObj* self)
+{
+    g_return_val_if_fail (self, 0);
+    WebCore::TestObj * item = WebKit::core(self);
+    glong res = item->description();
+    return res;
+}
+
+glong
+webkit_dom_test_obj_get_id(WebKitDOMTestObj* self)
+{
+    g_return_val_if_fail (self, 0);
+    WebCore::TestObj * item = WebKit::core(self);
+    glong res = item->id();
+    return res;
+}
+
+void
+webkit_dom_test_obj_set_id(WebKitDOMTestObj* self, glong value)
+{
+    g_return_if_fail (self);
+    WebCore::TestObj * item = WebKit::core(self);
+    item->setId(value);
+}
+
+gchar* 
+webkit_dom_test_obj_get_hash(WebKitDOMTestObj* self)
+{
+    g_return_val_if_fail (self, 0);
+    WebCore::TestObj * item = WebKit::core(self);
+    gchar*  res = convertToUTF8String(item->hash());
+    return res;
 }
 
 
@@ -566,6 +567,9 @@ enum {
     PROP_ATTR_WITH_GETTER_EXCEPTION,
     PROP_CUSTOM_ATTR,
     PROP_SCRIPT_STRING_ATTR,
+    PROP_DESCRIPTION,
+    PROP_ID,
+    PROP_HASH,
 };
 
 
@@ -587,42 +591,47 @@ static void webkit_dom_test_obj_finalize(GObject* object)
 
 static void webkit_dom_test_obj_set_property(GObject* object, guint prop_id, const GValue* value, GParamSpec* pspec)
 {
-     WebKitDOMTestObj *self = WEBKIT_DOM_TEST_OBJ(object);
+    WebKitDOMTestObj* self = WEBKIT_DOM_TEST_OBJ(object);
     WebCore::TestObj* coreSelf = WebKit::core(self);
-     switch (prop_id) {
+    switch (prop_id) {
     case PROP_INT_ATTR:
     {
-         coreSelf->setIntAttr((g_value_get_long(value)) );
-         break;
+        coreSelf->setIntAttr((g_value_get_long(value)));
+        break;
     }
     case PROP_UNSIGNED_LONG_LONG_ATTR:
     {
-         coreSelf->setUnsignedLongLongAttr((g_value_get_uint64(value)) );
-         break;
+        coreSelf->setUnsignedLongLongAttr((g_value_get_uint64(value)));
+        break;
     }
     case PROP_STRING_ATTR:
     {
-         coreSelf->setStringAttr(WebCore::String::fromUTF8(g_value_get_string(value)) );
-         break;
+        coreSelf->setStringAttr(WebCore::String::fromUTF8(g_value_get_string(value)));
+        break;
     }
     case PROP_ATTR_WITH_EXCEPTION:
     {
-         coreSelf->setAttrWithException((g_value_get_long(value)) );
-         break;
+        coreSelf->setAttrWithException((g_value_get_long(value)));
+        break;
     }
     case PROP_ATTR_WITH_SETTER_EXCEPTION:
     {
-         WebCore::ExceptionCode ec = 0;
-         coreSelf->setAttrWithSetterException((g_value_get_long(value)) , ec );
-         break;
+        WebCore::ExceptionCode ec = 0;
+        coreSelf->setAttrWithSetterException((g_value_get_long(value)), ec);
+        break;
     }
     case PROP_ATTR_WITH_GETTER_EXCEPTION:
     {
-         WebCore::ExceptionCode ec = 0;
-         coreSelf->setAttrWithGetterException((g_value_get_long(value)) , ec );
-         break;
+        WebCore::ExceptionCode ec = 0;
+        coreSelf->setAttrWithGetterException((g_value_get_long(value)), ec);
+        break;
     }
-     default:
+    case PROP_ID:
+    {
+        coreSelf->setId((g_value_get_long(value)));
+        break;
+    }
+    default:
         G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
         break;
     }
@@ -631,73 +640,88 @@ static void webkit_dom_test_obj_set_property(GObject* object, guint prop_id, con
 
 static void webkit_dom_test_obj_get_property(GObject* object, guint prop_id, GValue* value, GParamSpec* pspec)
 {
-     WebKitDOMTestObj* self = WEBKIT_DOM_TEST_OBJ(object);
+    WebKitDOMTestObj* self = WEBKIT_DOM_TEST_OBJ(object);
     WebCore::TestObj* coreSelf = WebKit::core(self);
-     switch (prop_id) {
+    switch (prop_id) {
     case PROP_READ_ONLY_INT_ATTR:
     {
-         g_value_set_long(value, coreSelf->readOnlyIntAttr());
-         break;
+        g_value_set_long(value, coreSelf->readOnlyIntAttr());
+        break;
     }
     case PROP_READ_ONLY_STRING_ATTR:
     {
-         g_value_take_string(value, convertToUTF8String(coreSelf->readOnlyStringAttr()));
-         break;
+        g_value_take_string(value, convertToUTF8String(coreSelf->readOnlyStringAttr()));
+        break;
     }
     case PROP_READ_ONLY_TEST_OBJ_ATTR:
     {
-         RefPtr<WebCore::TestObj> ptr = coreSelf->readOnlyTestObjAttr();
+        RefPtr<WebCore::TestObj> ptr = coreSelf->readOnlyTestObjAttr();
         g_value_set_object(value, WebKit::kit(ptr.get()));
-         break;
+        break;
     }
     case PROP_INT_ATTR:
     {
-         g_value_set_long(value, coreSelf->intAttr());
-         break;
+        g_value_set_long(value, coreSelf->intAttr());
+        break;
     }
     case PROP_LONG_LONG_ATTR:
     {
-         g_value_set_int64(value, coreSelf->longLongAttr());
-         break;
+        g_value_set_int64(value, coreSelf->longLongAttr());
+        break;
     }
     case PROP_UNSIGNED_LONG_LONG_ATTR:
     {
-         g_value_set_uint64(value, coreSelf->unsignedLongLongAttr());
-         break;
+        g_value_set_uint64(value, coreSelf->unsignedLongLongAttr());
+        break;
     }
     case PROP_STRING_ATTR:
     {
-         g_value_take_string(value, convertToUTF8String(coreSelf->stringAttr()));
-         break;
+        g_value_take_string(value, convertToUTF8String(coreSelf->stringAttr()));
+        break;
     }
     case PROP_TEST_OBJ_ATTR:
     {
-         RefPtr<WebCore::TestObj> ptr = coreSelf->testObjAttr();
+        RefPtr<WebCore::TestObj> ptr = coreSelf->testObjAttr();
         g_value_set_object(value, WebKit::kit(ptr.get()));
-         break;
+        break;
     }
     case PROP_ATTR_WITH_EXCEPTION:
     {
-         g_value_set_long(value, coreSelf->attrWithException());
-         break;
+        g_value_set_long(value, coreSelf->attrWithException());
+        break;
     }
     case PROP_ATTR_WITH_SETTER_EXCEPTION:
     {
-         WebCore::ExceptionCode ec = 0;
-         g_value_set_long(value, coreSelf->attrWithSetterException(ec));
-         break;
+        WebCore::ExceptionCode ec = 0;
+        g_value_set_long(value, coreSelf->attrWithSetterException(ec));
+        break;
     }
     case PROP_ATTR_WITH_GETTER_EXCEPTION:
     {
-         g_value_set_long(value, coreSelf->attrWithGetterException());
-         break;
+        g_value_set_long(value, coreSelf->attrWithGetterException());
+        break;
     }
     case PROP_SCRIPT_STRING_ATTR:
     {
-         g_value_take_string(value, convertToUTF8String(coreSelf->scriptStringAttr()));
-         break;
+        g_value_take_string(value, convertToUTF8String(coreSelf->scriptStringAttr()));
+        break;
+    }
+    case PROP_DESCRIPTION:
+    {
+        g_value_set_long(value, coreSelf->description());
+        break;
+    }
+    case PROP_ID:
+    {
+        g_value_set_long(value, coreSelf->id());
+        break;
     }
-     default:
+    case PROP_HASH:
+    {
+        g_value_take_string(value, convertToUTF8String(coreSelf->hash()));
+        break;
+    }
+    default:
         G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
         break;
     }
@@ -720,21 +744,21 @@ static void webkit_dom_test_obj_class_init(WebKitDOMTestObjClass* requestClass)
 G_MAXLONG, /* max */
 0, /* default */
                                                            WEBKIT_PARAM_READABLE));
-     g_object_class_install_property(gobjectClass,
+    g_object_class_install_property(gobjectClass,
                                     PROP_READ_ONLY_STRING_ATTR,
                                     g_param_spec_string("read-only-string-attr", /* name */
                                                            "test_obj_read-only-string-attr", /* short description */
                                                            "read-only  gchar*  TestObj.read-only-string-attr", /* longer - could do with some extra doc stuff here */
                                                            "", /* default */
                                                            WEBKIT_PARAM_READABLE));
-     g_object_class_install_property(gobjectClass,
+    g_object_class_install_property(gobjectClass,
                                     PROP_READ_ONLY_TEST_OBJ_ATTR,
                                     g_param_spec_object("read-only-test-obj-attr", /* name */
                                                            "test_obj_read-only-test-obj-attr", /* short description */
                                                            "read-only  WebKitDOMTestObj*  TestObj.read-only-test-obj-attr", /* longer - could do with some extra doc stuff here */
                                                            WEBKIT_TYPE_DOM_TEST_OBJ, /* gobject type */
                                                            WEBKIT_PARAM_READABLE));
-     g_object_class_install_property(gobjectClass,
+    g_object_class_install_property(gobjectClass,
                                     PROP_INT_ATTR,
                                     g_param_spec_long("int-attr", /* name */
                                                            "test_obj_int-attr", /* short description */
@@ -743,7 +767,7 @@ G_MAXLONG, /* max */
 G_MAXLONG, /* max */
 0, /* default */
                                                            WEBKIT_PARAM_READWRITE));
-     g_object_class_install_property(gobjectClass,
+    g_object_class_install_property(gobjectClass,
                                     PROP_LONG_LONG_ATTR,
                                     g_param_spec_int64("long-long-attr", /* name */
                                                            "test_obj_long-long-attr", /* short description */
@@ -752,7 +776,7 @@ G_MAXLONG, /* max */
 G_MAXINT64, /* max */
 0, /* default */
                                                            WEBKIT_PARAM_READWRITE));
-     g_object_class_install_property(gobjectClass,
+    g_object_class_install_property(gobjectClass,
                                     PROP_UNSIGNED_LONG_LONG_ATTR,
                                     g_param_spec_uint64("unsigned-long-long-attr", /* name */
                                                            "test_obj_unsigned-long-long-attr", /* short description */
@@ -761,21 +785,21 @@ G_MAXINT64, /* max */
 G_MAXUINT64, /* min */
 0, /* default */
                                                            WEBKIT_PARAM_READWRITE));
-     g_object_class_install_property(gobjectClass,
+    g_object_class_install_property(gobjectClass,
                                     PROP_STRING_ATTR,
                                     g_param_spec_string("string-attr", /* name */
                                                            "test_obj_string-attr", /* short description */
                                                            "read-write  gchar*  TestObj.string-attr", /* longer - could do with some extra doc stuff here */
                                                            "", /* default */
                                                            WEBKIT_PARAM_READWRITE));
-     g_object_class_install_property(gobjectClass,
+    g_object_class_install_property(gobjectClass,
                                     PROP_TEST_OBJ_ATTR,
                                     g_param_spec_object("test-obj-attr", /* name */
                                                            "test_obj_test-obj-attr", /* short description */
                                                            "read-write  WebKitDOMTestObj*  TestObj.test-obj-attr", /* longer - could do with some extra doc stuff here */
                                                            WEBKIT_TYPE_DOM_TEST_OBJ, /* gobject type */
                                                            WEBKIT_PARAM_READWRITE));
-     g_object_class_install_property(gobjectClass,
+    g_object_class_install_property(gobjectClass,
                                     PROP_ATTR_WITH_EXCEPTION,
                                     g_param_spec_long("attr-with-exception", /* name */
                                                            "test_obj_attr-with-exception", /* short description */
@@ -784,7 +808,7 @@ G_MAXUINT64, /* min */
 G_MAXLONG, /* max */
 0, /* default */
                                                            WEBKIT_PARAM_READWRITE));
-     g_object_class_install_property(gobjectClass,
+    g_object_class_install_property(gobjectClass,
                                     PROP_ATTR_WITH_SETTER_EXCEPTION,
                                     g_param_spec_long("attr-with-setter-exception", /* name */
                                                            "test_obj_attr-with-setter-exception", /* short description */
@@ -793,7 +817,7 @@ G_MAXLONG, /* max */
 G_MAXLONG, /* max */
 0, /* default */
                                                            WEBKIT_PARAM_READWRITE));
-     g_object_class_install_property(gobjectClass,
+    g_object_class_install_property(gobjectClass,
                                     PROP_ATTR_WITH_GETTER_EXCEPTION,
                                     g_param_spec_long("attr-with-getter-exception", /* name */
                                                            "test_obj_attr-with-getter-exception", /* short description */
@@ -802,13 +826,38 @@ G_MAXLONG, /* max */
 G_MAXLONG, /* max */
 0, /* default */
                                                            WEBKIT_PARAM_READWRITE));
-     g_object_class_install_property(gobjectClass,
+    g_object_class_install_property(gobjectClass,
                                     PROP_SCRIPT_STRING_ATTR,
                                     g_param_spec_string("script-string-attr", /* name */
                                                            "test_obj_script-string-attr", /* short description */
                                                            "read-only  gchar*  TestObj.script-string-attr", /* longer - could do with some extra doc stuff here */
                                                            "", /* default */
                                                            WEBKIT_PARAM_READABLE));
+    g_object_class_install_property(gobjectClass,
+                                    PROP_DESCRIPTION,
+                                    g_param_spec_long("description", /* name */
+                                                           "test_obj_description", /* short description */
+                                                           "read-only  glong TestObj.description", /* longer - could do with some extra doc stuff here */
+                                                           G_MINLONG, /* min */
+G_MAXLONG, /* max */
+0, /* default */
+                                                           WEBKIT_PARAM_READABLE));
+    g_object_class_install_property(gobjectClass,
+                                    PROP_ID,
+                                    g_param_spec_long("id", /* name */
+                                                           "test_obj_id", /* short description */
+                                                           "read-write  glong TestObj.id", /* longer - could do with some extra doc stuff here */
+                                                           G_MINLONG, /* min */
+G_MAXLONG, /* max */
+0, /* default */
+                                                           WEBKIT_PARAM_READWRITE));
+    g_object_class_install_property(gobjectClass,
+                                    PROP_HASH,
+                                    g_param_spec_string("hash", /* name */
+                                                           "test_obj_hash", /* short description */
+                                                           "read-only  gchar*  TestObj.hash", /* longer - could do with some extra doc stuff here */
+                                                           "", /* default */
+                                                           WEBKIT_PARAM_READABLE));
 
 
 }
diff --git a/WebCore/bindings/scripts/test/GObject/WebKitDOMTestObj.h b/WebCore/bindings/scripts/test/GObject/WebKitDOMTestObj.h
index 282edb8..ef5ccb8 100644
--- a/WebCore/bindings/scripts/test/GObject/WebKitDOMTestObj.h
+++ b/WebCore/bindings/scripts/test/GObject/WebKitDOMTestObj.h
@@ -47,34 +47,34 @@ WEBKIT_API GType
 webkit_dom_test_obj_get_type (void);
 
 WEBKIT_API void
-webkit_dom_test_obj_void_method (WebKitDOMTestObj *self);
+webkit_dom_test_obj_void_method(WebKitDOMTestObj* self);
 
 WEBKIT_API void
-webkit_dom_test_obj_void_method_with_args (WebKitDOMTestObj *self, glong int_arg, gchar*  str_arg, WebKitDOMTestObj*  obj_arg);
+webkit_dom_test_obj_void_method_with_args(WebKitDOMTestObj* self, glong int_arg, gchar*  str_arg, WebKitDOMTestObj*  obj_arg);
 
 WEBKIT_API glong
-webkit_dom_test_obj_int_method (WebKitDOMTestObj *self);
+webkit_dom_test_obj_int_method(WebKitDOMTestObj* self);
 
 WEBKIT_API glong
-webkit_dom_test_obj_int_method_with_args (WebKitDOMTestObj *self, glong int_arg, gchar*  str_arg, WebKitDOMTestObj*  obj_arg);
+webkit_dom_test_obj_int_method_with_args(WebKitDOMTestObj* self, glong int_arg, gchar*  str_arg, WebKitDOMTestObj*  obj_arg);
 
 WEBKIT_API WebKitDOMTestObj* 
-webkit_dom_test_obj_obj_method (WebKitDOMTestObj *self);
+webkit_dom_test_obj_obj_method(WebKitDOMTestObj* self);
 
 WEBKIT_API WebKitDOMTestObj* 
-webkit_dom_test_obj_obj_method_with_args (WebKitDOMTestObj *self, glong int_arg, gchar*  str_arg, WebKitDOMTestObj*  obj_arg);
+webkit_dom_test_obj_obj_method_with_args(WebKitDOMTestObj* self, glong int_arg, gchar*  str_arg, WebKitDOMTestObj*  obj_arg);
 
 WEBKIT_API WebKitDOMTestObj* 
-webkit_dom_test_obj_method_that_requires_all_args (WebKitDOMTestObj *self, gchar*  str_arg, WebKitDOMTestObj*  obj_arg);
+webkit_dom_test_obj_method_that_requires_all_args(WebKitDOMTestObj* self, gchar*  str_arg, WebKitDOMTestObj*  obj_arg);
 
 WEBKIT_API WebKitDOMTestObj* 
-webkit_dom_test_obj_method_that_requires_all_args_and_throws (WebKitDOMTestObj *self, gchar*  str_arg, WebKitDOMTestObj*  obj_arg, GError **error);
+webkit_dom_test_obj_method_that_requires_all_args_and_throws(WebKitDOMTestObj* self, gchar*  str_arg, WebKitDOMTestObj*  obj_arg, GError **error);
 
 WEBKIT_API void
-webkit_dom_test_obj_serialized_value (WebKitDOMTestObj *self, WebKitDOMSerializedScriptValue*  serialized_arg);
+webkit_dom_test_obj_serialized_value(WebKitDOMTestObj* self, WebKitDOMSerializedScriptValue*  serialized_arg);
 
 WEBKIT_API void
-webkit_dom_test_obj_method_with_exception (WebKitDOMTestObj *self, GError **error);
+webkit_dom_test_obj_method_with_exception(WebKitDOMTestObj* self, GError **error);
 
 
 /* TODO: event function webkit_dom_test_obj_add_event_listener */
@@ -83,100 +83,115 @@ webkit_dom_test_obj_method_with_exception (WebKitDOMTestObj *self, GError **erro
 /* TODO: event function webkit_dom_test_obj_remove_event_listener */
 
 WEBKIT_API void
-webkit_dom_test_obj_with_dynamic_frame (WebKitDOMTestObj *self);
+webkit_dom_test_obj_with_dynamic_frame(WebKitDOMTestObj* self);
 
 WEBKIT_API void
-webkit_dom_test_obj_with_dynamic_frame_and_arg (WebKitDOMTestObj *self, glong int_arg);
+webkit_dom_test_obj_with_dynamic_frame_and_arg(WebKitDOMTestObj* self, glong int_arg);
 
 WEBKIT_API void
-webkit_dom_test_obj_with_dynamic_frame_and_optional_arg (WebKitDOMTestObj *self, glong int_arg, glong optional_arg);
+webkit_dom_test_obj_with_dynamic_frame_and_optional_arg(WebKitDOMTestObj* self, glong int_arg, glong optional_arg);
 
 WEBKIT_API void
-webkit_dom_test_obj_with_dynamic_frame_and_user_gesture (WebKitDOMTestObj *self, glong int_arg);
+webkit_dom_test_obj_with_dynamic_frame_and_user_gesture(WebKitDOMTestObj* self, glong int_arg);
 
 WEBKIT_API void
-webkit_dom_test_obj_with_dynamic_frame_and_user_gesture_asad (WebKitDOMTestObj *self, glong int_arg, glong optional_arg);
+webkit_dom_test_obj_with_dynamic_frame_and_user_gesture_asad(WebKitDOMTestObj* self, glong int_arg, glong optional_arg);
 
 WEBKIT_API void
-webkit_dom_test_obj_with_script_state_void (WebKitDOMTestObj *self);
+webkit_dom_test_obj_with_script_state_void(WebKitDOMTestObj* self);
 
 WEBKIT_API WebKitDOMTestObj* 
-webkit_dom_test_obj_with_script_state_obj (WebKitDOMTestObj *self);
+webkit_dom_test_obj_with_script_state_obj(WebKitDOMTestObj* self);
 
 WEBKIT_API void
-webkit_dom_test_obj_with_script_state_void_exception (WebKitDOMTestObj *self, GError **error);
+webkit_dom_test_obj_with_script_state_void_exception(WebKitDOMTestObj* self, GError **error);
 
 WEBKIT_API WebKitDOMTestObj* 
-webkit_dom_test_obj_with_script_state_obj_exception (WebKitDOMTestObj *self, GError **error);
+webkit_dom_test_obj_with_script_state_obj_exception(WebKitDOMTestObj* self, GError **error);
 
 WEBKIT_API void
-webkit_dom_test_obj_method_with_optional_arg (WebKitDOMTestObj *self, glong opt);
+webkit_dom_test_obj_with_script_execution_context(WebKitDOMTestObj* self);
 
 WEBKIT_API void
-webkit_dom_test_obj_method_with_non_optional_arg_and_optional_arg (WebKitDOMTestObj *self, glong non_opt, glong opt);
+webkit_dom_test_obj_method_with_optional_arg(WebKitDOMTestObj* self, glong opt);
 
 WEBKIT_API void
-webkit_dom_test_obj_method_with_non_optional_arg_and_two_optional_args (WebKitDOMTestObj *self, glong non_opt, glong opt1, glong opt2);
+webkit_dom_test_obj_method_with_non_optional_arg_and_optional_arg(WebKitDOMTestObj* self, glong non_opt, glong opt);
+
+WEBKIT_API void
+webkit_dom_test_obj_method_with_non_optional_arg_and_two_optional_args(WebKitDOMTestObj* self, glong non_opt, glong opt1, glong opt2);
 
 WEBKIT_API glong
-webkit_dom_test_obj_get_read_only_int_attr (WebKitDOMTestObj *self);
+webkit_dom_test_obj_get_read_only_int_attr(WebKitDOMTestObj* self);
 
 WEBKIT_API gchar* 
-webkit_dom_test_obj_get_read_only_string_attr (WebKitDOMTestObj *self);
+webkit_dom_test_obj_get_read_only_string_attr(WebKitDOMTestObj* self);
 
 WEBKIT_API WebKitDOMTestObj* 
-webkit_dom_test_obj_get_read_only_test_obj_attr (WebKitDOMTestObj *self);
+webkit_dom_test_obj_get_read_only_test_obj_attr(WebKitDOMTestObj* self);
 
 WEBKIT_API glong
-webkit_dom_test_obj_get_int_attr (WebKitDOMTestObj *self);
+webkit_dom_test_obj_get_int_attr(WebKitDOMTestObj* self);
 
 WEBKIT_API void
-webkit_dom_test_obj_set_int_attr (WebKitDOMTestObj *self, glong value);
+webkit_dom_test_obj_set_int_attr(WebKitDOMTestObj* self, glong value);
 
 WEBKIT_API gint64
-webkit_dom_test_obj_get_long_long_attr (WebKitDOMTestObj *self);
+webkit_dom_test_obj_get_long_long_attr(WebKitDOMTestObj* self);
 
 WEBKIT_API void
-webkit_dom_test_obj_set_long_long_attr (WebKitDOMTestObj *self, gint64 value);
+webkit_dom_test_obj_set_long_long_attr(WebKitDOMTestObj* self, gint64 value);
 
 WEBKIT_API guint64
-webkit_dom_test_obj_get_unsigned_long_long_attr (WebKitDOMTestObj *self);
+webkit_dom_test_obj_get_unsigned_long_long_attr(WebKitDOMTestObj* self);
 
 WEBKIT_API void
-webkit_dom_test_obj_set_unsigned_long_long_attr (WebKitDOMTestObj *self, guint64 value);
+webkit_dom_test_obj_set_unsigned_long_long_attr(WebKitDOMTestObj* self, guint64 value);
 
 WEBKIT_API gchar* 
-webkit_dom_test_obj_get_string_attr (WebKitDOMTestObj *self);
+webkit_dom_test_obj_get_string_attr(WebKitDOMTestObj* self);
 
 WEBKIT_API void
-webkit_dom_test_obj_set_string_attr (WebKitDOMTestObj *self, gchar*  value);
+webkit_dom_test_obj_set_string_attr(WebKitDOMTestObj* self, gchar*  value);
 
 WEBKIT_API WebKitDOMTestObj* 
-webkit_dom_test_obj_get_test_obj_attr (WebKitDOMTestObj *self);
+webkit_dom_test_obj_get_test_obj_attr(WebKitDOMTestObj* self);
+
+WEBKIT_API void
+webkit_dom_test_obj_set_test_obj_attr(WebKitDOMTestObj* self, WebKitDOMTestObj*  value);
+
+WEBKIT_API glong
+webkit_dom_test_obj_get_attr_with_exception(WebKitDOMTestObj* self);
 
 WEBKIT_API void
-webkit_dom_test_obj_set_test_obj_attr (WebKitDOMTestObj *self, WebKitDOMTestObj*  value);
+webkit_dom_test_obj_set_attr_with_exception(WebKitDOMTestObj* self, glong value);
 
 WEBKIT_API glong
-webkit_dom_test_obj_get_attr_with_exception (WebKitDOMTestObj *self);
+webkit_dom_test_obj_get_attr_with_setter_exception(WebKitDOMTestObj* self, GError **error);
 
 WEBKIT_API void
-webkit_dom_test_obj_set_attr_with_exception (WebKitDOMTestObj *self, glong value);
+webkit_dom_test_obj_set_attr_with_setter_exception(WebKitDOMTestObj* self, glong value, GError **error);
 
 WEBKIT_API glong
-webkit_dom_test_obj_get_attr_with_setter_exception (WebKitDOMTestObj *self, GError **error);
+webkit_dom_test_obj_get_attr_with_getter_exception(WebKitDOMTestObj* self);
 
 WEBKIT_API void
-webkit_dom_test_obj_set_attr_with_setter_exception (WebKitDOMTestObj *self, glong value, GError **error);
+webkit_dom_test_obj_set_attr_with_getter_exception(WebKitDOMTestObj* self, glong value, GError **error);
+
+WEBKIT_API gchar* 
+webkit_dom_test_obj_get_script_string_attr(WebKitDOMTestObj* self);
+
+WEBKIT_API glong
+webkit_dom_test_obj_get_description(WebKitDOMTestObj* self);
 
 WEBKIT_API glong
-webkit_dom_test_obj_get_attr_with_getter_exception (WebKitDOMTestObj *self);
+webkit_dom_test_obj_get_id(WebKitDOMTestObj* self);
 
 WEBKIT_API void
-webkit_dom_test_obj_set_attr_with_getter_exception (WebKitDOMTestObj *self, glong value, GError **error);
+webkit_dom_test_obj_set_id(WebKitDOMTestObj* self, glong value);
 
 WEBKIT_API gchar* 
-webkit_dom_test_obj_get_script_string_attr (WebKitDOMTestObj *self);
+webkit_dom_test_obj_get_hash(WebKitDOMTestObj* self);
 
 G_END_DECLS
 
diff --git a/WebCore/bindings/scripts/test/JS/JSTestInterface.cpp b/WebCore/bindings/scripts/test/JS/JSTestInterface.cpp
index a230aef..693a48b 100644
--- a/WebCore/bindings/scripts/test/JS/JSTestInterface.cpp
+++ b/WebCore/bindings/scripts/test/JS/JSTestInterface.cpp
@@ -78,12 +78,12 @@ public:
     
 protected:
     static const unsigned StructureFlags = OverridesGetOwnPropertySlot | ImplementsHasInstance | DOMConstructorObject::StructureFlags;
-    static JSObject* constructTestInterface(ExecState* exec, JSObject* constructor, const ArgList&)
+    static EncodedJSValue JSC_HOST_CALL constructTestInterface(ExecState* exec)
     {
-        ScriptExecutionContext* context = static_cast<JSTestInterfaceConstructor*>(constructor)->scriptExecutionContext();
+        ScriptExecutionContext* context = static_cast<JSTestInterfaceConstructor*>(exec->callee())->scriptExecutionContext();
         if (!context)
-            return throwError(exec, ReferenceError);
-        return asObject(toJS(exec, static_cast<JSTestInterfaceConstructor*>(constructor)->globalObject(), TestInterface::create(context)));
+            return throwVMError(exec, createReferenceError(exec, "Reference error"));
+        return JSValue::encode(asObject(toJS(exec, static_cast<JSTestInterfaceConstructor*>(exec->callee())->globalObject(), TestInterface::create(context))));
     }
     virtual ConstructType getConstructData(ConstructData& constructData)
     {
diff --git a/WebCore/bindings/scripts/test/JS/JSTestObj.cpp b/WebCore/bindings/scripts/test/JS/JSTestObj.cpp
index 1e563c6..09b69cd 100644
--- a/WebCore/bindings/scripts/test/JS/JSTestObj.cpp
+++ b/WebCore/bindings/scripts/test/JS/JSTestObj.cpp
@@ -46,7 +46,7 @@ ASSERT_CLASS_FITS_IN_CELL(JSTestObj);
 #define THUNK_GENERATOR(generator)
 #endif
 
-static const HashTableValue JSTestObjTableValues[15] =
+static const HashTableValue JSTestObjTableValues[18] =
 {
     { "readOnlyIntAttr", DontDelete | ReadOnly, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjReadOnlyIntAttr), (intptr_t)0 THUNK_GENERATOR(0) },
     { "readOnlyStringAttr", DontDelete | ReadOnly, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjReadOnlyStringAttr), (intptr_t)0 THUNK_GENERATOR(0) },
@@ -61,12 +61,15 @@ static const HashTableValue JSTestObjTableValues[15] =
     { "attrWithGetterException", DontDelete, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjAttrWithGetterException), (intptr_t)setJSTestObjAttrWithGetterException THUNK_GENERATOR(0) },
     { "customAttr", DontDelete, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjCustomAttr), (intptr_t)setJSTestObjCustomAttr THUNK_GENERATOR(0) },
     { "scriptStringAttr", DontDelete | ReadOnly, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjScriptStringAttr), (intptr_t)0 THUNK_GENERATOR(0) },
+    { "description", DontDelete | ReadOnly, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjDescription), (intptr_t)0 THUNK_GENERATOR(0) },
+    { "id", DontDelete, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjId), (intptr_t)setJSTestObjId THUNK_GENERATOR(0) },
+    { "hash", DontDelete | ReadOnly, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjHash), (intptr_t)0 THUNK_GENERATOR(0) },
     { "constructor", DontEnum | ReadOnly, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjConstructor), (intptr_t)0 THUNK_GENERATOR(0) },
     { 0, 0, 0, 0 THUNK_GENERATOR(0) }
 };
 
 #undef THUNK_GENERATOR
-static JSC_CONST_HASHTABLE HashTable JSTestObjTable = { 34, 31, JSTestObjTableValues, 0 };
+static JSC_CONST_HASHTABLE HashTable JSTestObjTable = { 65, 63, JSTestObjTableValues, 0 };
 /* Hash table for constructor */
 #if ENABLE(JIT)
 #define THUNK_GENERATOR(generator) , generator
@@ -121,7 +124,7 @@ bool JSTestObjConstructor::getOwnPropertyDescriptor(ExecState* exec, const Ident
 #define THUNK_GENERATOR(generator)
 #endif
 
-static const HashTableValue JSTestObjPrototypeTableValues[29] =
+static const HashTableValue JSTestObjPrototypeTableValues[30] =
 {
     { "voidMethod", DontDelete | Function, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionVoidMethod), (intptr_t)0 THUNK_GENERATOR(0) },
     { "voidMethodWithArgs", DontDelete | Function, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionVoidMethodWithArgs), (intptr_t)3 THUNK_GENERATOR(0) },
@@ -147,6 +150,7 @@ static const HashTableValue JSTestObjPrototypeTableValues[29] =
     { "withScriptStateObj", DontDelete | Function, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionWithScriptStateObj), (intptr_t)0 THUNK_GENERATOR(0) },
     { "withScriptStateVoidException", DontDelete | Function, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionWithScriptStateVoidException), (intptr_t)0 THUNK_GENERATOR(0) },
     { "withScriptStateObjException", DontDelete | Function, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionWithScriptStateObjException), (intptr_t)0 THUNK_GENERATOR(0) },
+    { "withScriptExecutionContext", DontDelete | Function, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionWithScriptExecutionContext), (intptr_t)0 THUNK_GENERATOR(0) },
     { "methodWithOptionalArg", DontDelete | Function, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithOptionalArg), (intptr_t)1 THUNK_GENERATOR(0) },
     { "methodWithNonOptionalArgAndOptionalArg", DontDelete | Function, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithNonOptionalArgAndOptionalArg), (intptr_t)2 THUNK_GENERATOR(0) },
     { "methodWithNonOptionalArgAndTwoOptionalArgs", DontDelete | Function, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithNonOptionalArgAndTwoOptionalArgs), (intptr_t)3 THUNK_GENERATOR(0) },
@@ -316,6 +320,33 @@ JSValue jsTestObjScriptStringAttr(ExecState* exec, JSValue slotBase, const Ident
     return result;
 }
 
+JSValue jsTestObjDescription(ExecState* exec, JSValue slotBase, const Identifier&)
+{
+    JSTestObj* castedThis = static_cast<JSTestObj*>(asObject(slotBase));
+    UNUSED_PARAM(exec);
+    TestObj* imp = static_cast<TestObj*>(castedThis->impl());
+    JSValue result = jsNumber(exec, imp->description());
+    return result;
+}
+
+JSValue jsTestObjId(ExecState* exec, JSValue slotBase, const Identifier&)
+{
+    JSTestObj* castedThis = static_cast<JSTestObj*>(asObject(slotBase));
+    UNUSED_PARAM(exec);
+    TestObj* imp = static_cast<TestObj*>(castedThis->impl());
+    JSValue result = jsNumber(exec, imp->id());
+    return result;
+}
+
+JSValue jsTestObjHash(ExecState* exec, JSValue slotBase, const Identifier&)
+{
+    JSTestObj* castedThis = static_cast<JSTestObj*>(asObject(slotBase));
+    UNUSED_PARAM(exec);
+    TestObj* imp = static_cast<TestObj*>(castedThis->impl());
+    JSValue result = jsString(exec, imp->hash());
+    return result;
+}
+
 JSValue jsTestObjConstructor(ExecState* exec, JSValue slotBase, const Identifier&)
 {
     JSTestObj* domObject = static_cast<JSTestObj*>(asObject(slotBase));
@@ -391,28 +422,35 @@ void setJSTestObjCustomAttr(ExecState* exec, JSObject* thisObject, JSValue value
     static_cast<JSTestObj*>(thisObject)->setCustomAttr(exec, value);
 }
 
+void setJSTestObjId(ExecState* exec, JSObject* thisObject, JSValue value)
+{
+    JSTestObj* castedThis = static_cast<JSTestObj*>(thisObject);
+    TestObj* imp = static_cast<TestObj*>(castedThis->impl());
+    imp->setId(value.toInt32(exec));
+}
+
 JSValue JSTestObj::getConstructor(ExecState* exec, JSGlobalObject* globalObject)
 {
     return getDOMConstructor<JSTestObjConstructor>(exec, static_cast<JSDOMGlobalObject*>(globalObject));
 }
 
-JSValue JSC_HOST_CALL jsTestObjPrototypeFunctionVoidMethod(ExecState* exec)
+EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionVoidMethod(ExecState* exec)
 {
     JSValue thisValue = exec->hostThisValue();
     if (!thisValue.inherits(&JSTestObj::s_info))
-        return throwError(exec, TypeError);
+        return throwVMTypeError(exec);
     JSTestObj* castedThis = static_cast<JSTestObj*>(asObject(thisValue));
     TestObj* imp = static_cast<TestObj*>(castedThis->impl());
 
     imp->voidMethod();
-    return jsUndefined();
+    return JSValue::encode(jsUndefined());
 }
 
-JSValue JSC_HOST_CALL jsTestObjPrototypeFunctionVoidMethodWithArgs(ExecState* exec)
+EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionVoidMethodWithArgs(ExecState* exec)
 {
     JSValue thisValue = exec->hostThisValue();
     if (!thisValue.inherits(&JSTestObj::s_info))
-        return throwError(exec, TypeError);
+        return throwVMTypeError(exec);
     JSTestObj* castedThis = static_cast<JSTestObj*>(asObject(thisValue));
     TestObj* imp = static_cast<TestObj*>(castedThis->impl());
     int intArg = exec->argument(0).toInt32(exec);
@@ -420,27 +458,27 @@ JSValue JSC_HOST_CALL jsTestObjPrototypeFunctionVoidMethodWithArgs(ExecState* ex
     TestObj* objArg = toTestObj(exec->argument(2));
 
     imp->voidMethodWithArgs(intArg, strArg, objArg);
-    return jsUndefined();
+    return JSValue::encode(jsUndefined());
 }
 
-JSValue JSC_HOST_CALL jsTestObjPrototypeFunctionIntMethod(ExecState* exec)
+EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionIntMethod(ExecState* exec)
 {
     JSValue thisValue = exec->hostThisValue();
     if (!thisValue.inherits(&JSTestObj::s_info))
-        return throwError(exec, TypeError);
+        return throwVMTypeError(exec);
     JSTestObj* castedThis = static_cast<JSTestObj*>(asObject(thisValue));
     TestObj* imp = static_cast<TestObj*>(castedThis->impl());
 
 
     JSC::JSValue result = jsNumber(exec, imp->intMethod());
-    return result;
+    return JSValue::encode(result);
 }
 
-JSValue JSC_HOST_CALL jsTestObjPrototypeFunctionIntMethodWithArgs(ExecState* exec)
+EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionIntMethodWithArgs(ExecState* exec)
 {
     JSValue thisValue = exec->hostThisValue();
     if (!thisValue.inherits(&JSTestObj::s_info))
-        return throwError(exec, TypeError);
+        return throwVMTypeError(exec);
     JSTestObj* castedThis = static_cast<JSTestObj*>(asObject(thisValue));
     TestObj* imp = static_cast<TestObj*>(castedThis->impl());
     int intArg = exec->argument(0).toInt32(exec);
@@ -449,27 +487,27 @@ JSValue JSC_HOST_CALL jsTestObjPrototypeFunctionIntMethodWithArgs(ExecState* exe
 
 
     JSC::JSValue result = jsNumber(exec, imp->intMethodWithArgs(intArg, strArg, objArg));
-    return result;
+    return JSValue::encode(result);
 }
 
-JSValue JSC_HOST_CALL jsTestObjPrototypeFunctionObjMethod(ExecState* exec)
+EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionObjMethod(ExecState* exec)
 {
     JSValue thisValue = exec->hostThisValue();
     if (!thisValue.inherits(&JSTestObj::s_info))
-        return throwError(exec, TypeError);
+        return throwVMTypeError(exec);
     JSTestObj* castedThis = static_cast<JSTestObj*>(asObject(thisValue));
     TestObj* imp = static_cast<TestObj*>(castedThis->impl());
 
 
     JSC::JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(imp->objMethod()));
-    return result;
+    return JSValue::encode(result);
 }
 
-JSValue JSC_HOST_CALL jsTestObjPrototypeFunctionObjMethodWithArgs(ExecState* exec)
+EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionObjMethodWithArgs(ExecState* exec)
 {
     JSValue thisValue = exec->hostThisValue();
     if (!thisValue.inherits(&JSTestObj::s_info))
-        return throwError(exec, TypeError);
+        return throwVMTypeError(exec);
     JSTestObj* castedThis = static_cast<JSTestObj*>(asObject(thisValue));
     TestObj* imp = static_cast<TestObj*>(castedThis->impl());
     int intArg = exec->argument(0).toInt32(exec);
@@ -478,35 +516,35 @@ JSValue JSC_HOST_CALL jsTestObjPrototypeFunctionObjMethodWithArgs(ExecState* exe
 
 
     JSC::JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(imp->objMethodWithArgs(intArg, strArg, objArg)));
-    return result;
+    return JSValue::encode(result);
 }
 
-JSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodThatRequiresAllArgs(ExecState* exec)
+EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodThatRequiresAllArgs(ExecState* exec)
 {
     JSValue thisValue = exec->hostThisValue();
     if (!thisValue.inherits(&JSTestObj::s_info))
-        return throwError(exec, TypeError);
+        return throwVMTypeError(exec);
     JSTestObj* castedThis = static_cast<JSTestObj*>(asObject(thisValue));
     TestObj* imp = static_cast<TestObj*>(castedThis->impl());
     if (exec->argumentCount() < 2)
-        return jsUndefined();
+        return JSValue::encode(jsUndefined());
     const String& strArg = ustringToString(exec->argument(0).toString(exec));
     TestObj* objArg = toTestObj(exec->argument(1));
 
 
     JSC::JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(imp->methodThatRequiresAllArgs(strArg, objArg)));
-    return result;
+    return JSValue::encode(result);
 }
 
-JSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodThatRequiresAllArgsAndThrows(ExecState* exec)
+EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodThatRequiresAllArgsAndThrows(ExecState* exec)
 {
     JSValue thisValue = exec->hostThisValue();
     if (!thisValue.inherits(&JSTestObj::s_info))
-        return throwError(exec, TypeError);
+        return throwVMTypeError(exec);
     JSTestObj* castedThis = static_cast<JSTestObj*>(asObject(thisValue));
     TestObj* imp = static_cast<TestObj*>(castedThis->impl());
     if (exec->argumentCount() < 2)
-        return throwError(exec, SyntaxError, "Not enough arguments");
+        return throwVMError(exec, createSyntaxError(exec, "Not enough arguments"));
     ExceptionCode ec = 0;
     const String& strArg = ustringToString(exec->argument(0).toString(exec));
     TestObj* objArg = toTestObj(exec->argument(1));
@@ -514,59 +552,59 @@ JSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodThatRequiresAllArgsAndThro
 
     JSC::JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(imp->methodThatRequiresAllArgsAndThrows(strArg, objArg, ec)));
     setDOMException(exec, ec);
-    return result;
+    return JSValue::encode(result);
 }
 
-JSValue JSC_HOST_CALL jsTestObjPrototypeFunctionSerializedValue(ExecState* exec)
+EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionSerializedValue(ExecState* exec)
 {
     JSValue thisValue = exec->hostThisValue();
     if (!thisValue.inherits(&JSTestObj::s_info))
-        return throwError(exec, TypeError);
+        return throwVMTypeError(exec);
     JSTestObj* castedThis = static_cast<JSTestObj*>(asObject(thisValue));
     TestObj* imp = static_cast<TestObj*>(castedThis->impl());
     RefPtr<SerializedScriptValue> serializedArg = SerializedScriptValue::create(exec, exec->argument(0));
 
     imp->serializedValue(serializedArg);
-    return jsUndefined();
+    return JSValue::encode(jsUndefined());
 }
 
-JSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithException(ExecState* exec)
+EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithException(ExecState* exec)
 {
     JSValue thisValue = exec->hostThisValue();
     if (!thisValue.inherits(&JSTestObj::s_info))
-        return throwError(exec, TypeError);
+        return throwVMTypeError(exec);
     JSTestObj* castedThis = static_cast<JSTestObj*>(asObject(thisValue));
     TestObj* imp = static_cast<TestObj*>(castedThis->impl());
     ExceptionCode ec = 0;
 
     imp->methodWithException(ec);
     setDOMException(exec, ec);
-    return jsUndefined();
+    return JSValue::encode(jsUndefined());
 }
 
-JSValue JSC_HOST_CALL jsTestObjPrototypeFunctionCustomMethod(ExecState* exec)
+EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionCustomMethod(ExecState* exec)
 {
     JSValue thisValue = exec->hostThisValue();
     if (!thisValue.inherits(&JSTestObj::s_info))
-        return throwError(exec, TypeError);
+        return throwVMTypeError(exec);
     JSTestObj* castedThis = static_cast<JSTestObj*>(asObject(thisValue));
-    return castedThis->customMethod(exec);
+    return JSValue::encode(castedThis->customMethod(exec));
 }
 
-JSValue JSC_HOST_CALL jsTestObjPrototypeFunctionCustomMethodWithArgs(ExecState* exec)
+EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionCustomMethodWithArgs(ExecState* exec)
 {
     JSValue thisValue = exec->hostThisValue();
     if (!thisValue.inherits(&JSTestObj::s_info))
-        return throwError(exec, TypeError);
+        return throwVMTypeError(exec);
     JSTestObj* castedThis = static_cast<JSTestObj*>(asObject(thisValue));
-    return castedThis->customMethodWithArgs(exec);
+    return JSValue::encode(castedThis->customMethodWithArgs(exec));
 }
 
-JSValue JSC_HOST_CALL jsTestObjPrototypeFunctionCustomArgsAndException(ExecState* exec)
+EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionCustomArgsAndException(ExecState* exec)
 {
     JSValue thisValue = exec->hostThisValue();
     if (!thisValue.inherits(&JSTestObj::s_info))
-        return throwError(exec, TypeError);
+        return throwVMTypeError(exec);
     JSTestObj* castedThis = static_cast<JSTestObj*>(asObject(thisValue));
     TestObj* imp = static_cast<TestObj*>(castedThis->impl());
     ExceptionCode ec = 0;
@@ -575,178 +613,178 @@ JSValue JSC_HOST_CALL jsTestObjPrototypeFunctionCustomArgsAndException(ExecState
 
     imp->customArgsAndException(intArg, &callStack, ec);
     setDOMException(exec, ec);
-    return jsUndefined();
+    return JSValue::encode(jsUndefined());
 }
 
-JSValue JSC_HOST_CALL jsTestObjPrototypeFunctionAddEventListener(ExecState* exec)
+EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionAddEventListener(ExecState* exec)
 {
     JSValue thisValue = exec->hostThisValue();
     if (!thisValue.inherits(&JSTestObj::s_info))
-        return throwError(exec, TypeError);
+        return throwVMTypeError(exec);
     JSTestObj* castedThis = static_cast<JSTestObj*>(asObject(thisValue));
     TestObj* imp = static_cast<TestObj*>(castedThis->impl());
     JSValue listener = exec->argument(1);
     if (!listener.isObject())
-        return jsUndefined();
+        return JSValue::encode(jsUndefined());
     imp->addEventListener(ustringToAtomicString(exec->argument(0).toString(exec)), JSEventListener::create(asObject(listener), castedThis, false, currentWorld(exec)), exec->argument(2).toBoolean(exec));
-    return jsUndefined();
+    return JSValue::encode(jsUndefined());
 }
 
-JSValue JSC_HOST_CALL jsTestObjPrototypeFunctionRemoveEventListener(ExecState* exec)
+EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionRemoveEventListener(ExecState* exec)
 {
     JSValue thisValue = exec->hostThisValue();
     if (!thisValue.inherits(&JSTestObj::s_info))
-        return throwError(exec, TypeError);
+        return throwVMTypeError(exec);
     JSTestObj* castedThis = static_cast<JSTestObj*>(asObject(thisValue));
     TestObj* imp = static_cast<TestObj*>(castedThis->impl());
     JSValue listener = exec->argument(1);
     if (!listener.isObject())
-        return jsUndefined();
+        return JSValue::encode(jsUndefined());
     imp->removeEventListener(ustringToAtomicString(exec->argument(0).toString(exec)), JSEventListener::create(asObject(listener), castedThis, false, currentWorld(exec)).get(), exec->argument(2).toBoolean(exec));
-    return jsUndefined();
+    return JSValue::encode(jsUndefined());
 }
 
-JSValue JSC_HOST_CALL jsTestObjPrototypeFunctionWithDynamicFrame(ExecState* exec)
+EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionWithDynamicFrame(ExecState* exec)
 {
     JSValue thisValue = exec->hostThisValue();
     if (!thisValue.inherits(&JSTestObj::s_info))
-        return throwError(exec, TypeError);
+        return throwVMTypeError(exec);
     JSTestObj* castedThis = static_cast<JSTestObj*>(asObject(thisValue));
     TestObj* imp = static_cast<TestObj*>(castedThis->impl());
     Frame* dynamicFrame = toDynamicFrame(exec);
     if (!dynamicFrame)
-        return jsUndefined();
+        return JSValue::encode(jsUndefined());
 
     imp->withDynamicFrame(dynamicFrame);
-    return jsUndefined();
+    return JSValue::encode(jsUndefined());
 }
 
-JSValue JSC_HOST_CALL jsTestObjPrototypeFunctionWithDynamicFrameAndArg(ExecState* exec)
+EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionWithDynamicFrameAndArg(ExecState* exec)
 {
     JSValue thisValue = exec->hostThisValue();
     if (!thisValue.inherits(&JSTestObj::s_info))
-        return throwError(exec, TypeError);
+        return throwVMTypeError(exec);
     JSTestObj* castedThis = static_cast<JSTestObj*>(asObject(thisValue));
     TestObj* imp = static_cast<TestObj*>(castedThis->impl());
     Frame* dynamicFrame = toDynamicFrame(exec);
     if (!dynamicFrame)
-        return jsUndefined();
-    int intArg = exec->argument(1).toInt32(exec);
+        return JSValue::encode(jsUndefined());
+    int intArg = exec->argument(0).toInt32(exec);
 
     imp->withDynamicFrameAndArg(dynamicFrame, intArg);
-    return jsUndefined();
+    return JSValue::encode(jsUndefined());
 }
 
-JSValue JSC_HOST_CALL jsTestObjPrototypeFunctionWithDynamicFrameAndOptionalArg(ExecState* exec)
+EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionWithDynamicFrameAndOptionalArg(ExecState* exec)
 {
     JSValue thisValue = exec->hostThisValue();
     if (!thisValue.inherits(&JSTestObj::s_info))
-        return throwError(exec, TypeError);
+        return throwVMTypeError(exec);
     JSTestObj* castedThis = static_cast<JSTestObj*>(asObject(thisValue));
     TestObj* imp = static_cast<TestObj*>(castedThis->impl());
     Frame* dynamicFrame = toDynamicFrame(exec);
     if (!dynamicFrame)
-        return jsUndefined();
-    int intArg = exec->argument(1).toInt32(exec);
+        return JSValue::encode(jsUndefined());
+    int intArg = exec->argument(0).toInt32(exec);
 
     int argsCount = exec->argumentCount();
-    if (argsCount < 3) {
+    if (argsCount < 2) {
         imp->withDynamicFrameAndOptionalArg(dynamicFrame, intArg);
-        return jsUndefined();
+        return JSValue::encode(jsUndefined());
     }
 
-    int optionalArg = exec->argument(2).toInt32(exec);
+    int optionalArg = exec->argument(1).toInt32(exec);
 
     imp->withDynamicFrameAndOptionalArg(dynamicFrame, intArg, optionalArg);
-    return jsUndefined();
+    return JSValue::encode(jsUndefined());
 }
 
-JSValue JSC_HOST_CALL jsTestObjPrototypeFunctionWithDynamicFrameAndUserGesture(ExecState* exec)
+EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionWithDynamicFrameAndUserGesture(ExecState* exec)
 {
     JSValue thisValue = exec->hostThisValue();
     if (!thisValue.inherits(&JSTestObj::s_info))
-        return throwError(exec, TypeError);
+        return throwVMTypeError(exec);
     JSTestObj* castedThis = static_cast<JSTestObj*>(asObject(thisValue));
     TestObj* imp = static_cast<TestObj*>(castedThis->impl());
     Frame* dynamicFrame = toDynamicFrame(exec);
     if (!dynamicFrame)
-        return jsUndefined();
-    int intArg = exec->argument(1).toInt32(exec);
+        return JSValue::encode(jsUndefined());
+    int intArg = exec->argument(0).toInt32(exec);
 
     imp->withDynamicFrameAndUserGesture(dynamicFrame, intArg, processingUserGesture(exec));
-    return jsUndefined();
+    return JSValue::encode(jsUndefined());
 }
 
-JSValue JSC_HOST_CALL jsTestObjPrototypeFunctionWithDynamicFrameAndUserGestureASAD(ExecState* exec)
+EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionWithDynamicFrameAndUserGestureASAD(ExecState* exec)
 {
     JSValue thisValue = exec->hostThisValue();
     if (!thisValue.inherits(&JSTestObj::s_info))
-        return throwError(exec, TypeError);
+        return throwVMTypeError(exec);
     JSTestObj* castedThis = static_cast<JSTestObj*>(asObject(thisValue));
     TestObj* imp = static_cast<TestObj*>(castedThis->impl());
     Frame* dynamicFrame = toDynamicFrame(exec);
     if (!dynamicFrame)
-        return jsUndefined();
-    int intArg = exec->argument(1).toInt32(exec);
+        return JSValue::encode(jsUndefined());
+    int intArg = exec->argument(0).toInt32(exec);
 
     int argsCount = exec->argumentCount();
-    if (argsCount < 3) {
+    if (argsCount < 2) {
         imp->withDynamicFrameAndUserGestureASAD(dynamicFrame, intArg);
-        return jsUndefined();
+        return JSValue::encode(jsUndefined());
     }
 
-    int optionalArg = exec->argument(2).toInt32(exec);
+    int optionalArg = exec->argument(1).toInt32(exec);
 
     imp->withDynamicFrameAndUserGestureASAD(dynamicFrame, intArg, optionalArg, processingUserGesture(exec));
-    return jsUndefined();
+    return JSValue::encode(jsUndefined());
 }
 
-JSValue JSC_HOST_CALL jsTestObjPrototypeFunctionWithScriptStateVoid(ExecState* exec)
+EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionWithScriptStateVoid(ExecState* exec)
 {
     JSValue thisValue = exec->hostThisValue();
     if (!thisValue.inherits(&JSTestObj::s_info))
-        return throwError(exec, TypeError);
+        return throwVMTypeError(exec);
     JSTestObj* castedThis = static_cast<JSTestObj*>(asObject(thisValue));
     TestObj* imp = static_cast<TestObj*>(castedThis->impl());
 
     imp->withScriptStateVoid(exec);
-    return jsUndefined();
+    return JSValue::encode(jsUndefined());
 }
 
-JSValue JSC_HOST_CALL jsTestObjPrototypeFunctionWithScriptStateObj(ExecState* exec)
+EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionWithScriptStateObj(ExecState* exec)
 {
     JSValue thisValue = exec->hostThisValue();
     if (!thisValue.inherits(&JSTestObj::s_info))
-        return throwError(exec, TypeError);
+        return throwVMTypeError(exec);
     JSTestObj* castedThis = static_cast<JSTestObj*>(asObject(thisValue));
     TestObj* imp = static_cast<TestObj*>(castedThis->impl());
 
 
     JSC::JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(imp->withScriptStateObj(exec)));
     if (exec->hadException())
-        return jsUndefined();
-    return result;
+        return JSValue::encode(jsUndefined());
+    return JSValue::encode(result);
 }
 
-JSValue JSC_HOST_CALL jsTestObjPrototypeFunctionWithScriptStateVoidException(ExecState* exec)
+EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionWithScriptStateVoidException(ExecState* exec)
 {
     JSValue thisValue = exec->hostThisValue();
     if (!thisValue.inherits(&JSTestObj::s_info))
-        return throwError(exec, TypeError);
+        return throwVMTypeError(exec);
     JSTestObj* castedThis = static_cast<JSTestObj*>(asObject(thisValue));
     TestObj* imp = static_cast<TestObj*>(castedThis->impl());
     ExceptionCode ec = 0;
 
     imp->withScriptStateVoidException(exec, ec);
     setDOMException(exec, ec);
-    return jsUndefined();
+    return JSValue::encode(jsUndefined());
 }
 
-JSValue JSC_HOST_CALL jsTestObjPrototypeFunctionWithScriptStateObjException(ExecState* exec)
+EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionWithScriptStateObjException(ExecState* exec)
 {
     JSValue thisValue = exec->hostThisValue();
     if (!thisValue.inherits(&JSTestObj::s_info))
-        return throwError(exec, TypeError);
+        return throwVMTypeError(exec);
     JSTestObj* castedThis = static_cast<JSTestObj*>(asObject(thisValue));
     TestObj* imp = static_cast<TestObj*>(castedThis->impl());
     ExceptionCode ec = 0;
@@ -755,35 +793,50 @@ JSValue JSC_HOST_CALL jsTestObjPrototypeFunctionWithScriptStateObjException(Exec
     JSC::JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(imp->withScriptStateObjException(exec, ec)));
     setDOMException(exec, ec);
     if (exec->hadException())
-        return jsUndefined();
-    return result;
+        return JSValue::encode(jsUndefined());
+    return JSValue::encode(result);
+}
+
+EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionWithScriptExecutionContext(ExecState* exec)
+{
+    JSValue thisValue = exec->hostThisValue();
+    if (!thisValue.inherits(&JSTestObj::s_info))
+        return throwVMTypeError(exec);
+    JSTestObj* castedThis = static_cast<JSTestObj*>(asObject(thisValue));
+    TestObj* imp = static_cast<TestObj*>(castedThis->impl());
+    ScriptExecutionContext* scriptContext = static_cast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
+    if (!scriptContext)
+        return JSValue::encode(jsUndefined());
+
+    imp->withScriptExecutionContext(scriptContext);
+    return JSValue::encode(jsUndefined());
 }
 
-JSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithOptionalArg(ExecState* exec)
+EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithOptionalArg(ExecState* exec)
 {
     JSValue thisValue = exec->hostThisValue();
     if (!thisValue.inherits(&JSTestObj::s_info))
-        return throwError(exec, TypeError);
+        return throwVMTypeError(exec);
     JSTestObj* castedThis = static_cast<JSTestObj*>(asObject(thisValue));
     TestObj* imp = static_cast<TestObj*>(castedThis->impl());
 
     int argsCount = exec->argumentCount();
     if (argsCount < 1) {
         imp->methodWithOptionalArg();
-        return jsUndefined();
+        return JSValue::encode(jsUndefined());
     }
 
     int opt = exec->argument(0).toInt32(exec);
 
     imp->methodWithOptionalArg(opt);
-    return jsUndefined();
+    return JSValue::encode(jsUndefined());
 }
 
-JSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithNonOptionalArgAndOptionalArg(ExecState* exec)
+EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithNonOptionalArgAndOptionalArg(ExecState* exec)
 {
     JSValue thisValue = exec->hostThisValue();
     if (!thisValue.inherits(&JSTestObj::s_info))
-        return throwError(exec, TypeError);
+        return throwVMTypeError(exec);
     JSTestObj* castedThis = static_cast<JSTestObj*>(asObject(thisValue));
     TestObj* imp = static_cast<TestObj*>(castedThis->impl());
     int nonOpt = exec->argument(0).toInt32(exec);
@@ -791,20 +844,20 @@ JSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithNonOptionalArgAndOptio
     int argsCount = exec->argumentCount();
     if (argsCount < 2) {
         imp->methodWithNonOptionalArgAndOptionalArg(nonOpt);
-        return jsUndefined();
+        return JSValue::encode(jsUndefined());
     }
 
     int opt = exec->argument(1).toInt32(exec);
 
     imp->methodWithNonOptionalArgAndOptionalArg(nonOpt, opt);
-    return jsUndefined();
+    return JSValue::encode(jsUndefined());
 }
 
-JSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithNonOptionalArgAndTwoOptionalArgs(ExecState* exec)
+EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithNonOptionalArgAndTwoOptionalArgs(ExecState* exec)
 {
     JSValue thisValue = exec->hostThisValue();
     if (!thisValue.inherits(&JSTestObj::s_info))
-        return throwError(exec, TypeError);
+        return throwVMTypeError(exec);
     JSTestObj* castedThis = static_cast<JSTestObj*>(asObject(thisValue));
     TestObj* imp = static_cast<TestObj*>(castedThis->impl());
     int nonOpt = exec->argument(0).toInt32(exec);
@@ -812,35 +865,35 @@ JSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithNonOptionalArgAndTwoOp
     int argsCount = exec->argumentCount();
     if (argsCount < 2) {
         imp->methodWithNonOptionalArgAndTwoOptionalArgs(nonOpt);
-        return jsUndefined();
+        return JSValue::encode(jsUndefined());
     }
 
     int opt1 = exec->argument(1).toInt32(exec);
     int opt2 = exec->argument(2).toInt32(exec);
 
     imp->methodWithNonOptionalArgAndTwoOptionalArgs(nonOpt, opt1, opt2);
-    return jsUndefined();
+    return JSValue::encode(jsUndefined());
 }
 
-JSValue JSC_HOST_CALL jsTestObjPrototypeFunctionOverloadedMethod1(ExecState* exec)
+EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionOverloadedMethod1(ExecState* exec)
 {
     JSValue thisValue = exec->hostThisValue();
     if (!thisValue.inherits(&JSTestObj::s_info))
-        return throwError(exec, TypeError);
+        return throwVMTypeError(exec);
     JSTestObj* castedThis = static_cast<JSTestObj*>(asObject(thisValue));
     TestObj* imp = static_cast<TestObj*>(castedThis->impl());
     TestObj* objArg = toTestObj(exec->argument(0));
     const String& strArg = ustringToString(exec->argument(1).toString(exec));
 
     imp->overloadedMethod(objArg, strArg);
-    return jsUndefined();
+    return JSValue::encode(jsUndefined());
 }
 
-JSValue JSC_HOST_CALL jsTestObjPrototypeFunctionOverloadedMethod2(ExecState* exec)
+EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionOverloadedMethod2(ExecState* exec)
 {
     JSValue thisValue = exec->hostThisValue();
     if (!thisValue.inherits(&JSTestObj::s_info))
-        return throwError(exec, TypeError);
+        return throwVMTypeError(exec);
     JSTestObj* castedThis = static_cast<JSTestObj*>(asObject(thisValue));
     TestObj* imp = static_cast<TestObj*>(castedThis->impl());
     TestObj* objArg = toTestObj(exec->argument(0));
@@ -848,52 +901,52 @@ JSValue JSC_HOST_CALL jsTestObjPrototypeFunctionOverloadedMethod2(ExecState* exe
     int argsCount = exec->argumentCount();
     if (argsCount < 2) {
         imp->overloadedMethod(objArg);
-        return jsUndefined();
+        return JSValue::encode(jsUndefined());
     }
 
     int intArg = exec->argument(1).toInt32(exec);
 
     imp->overloadedMethod(objArg, intArg);
-    return jsUndefined();
+    return JSValue::encode(jsUndefined());
 }
 
-JSValue JSC_HOST_CALL jsTestObjPrototypeFunctionOverloadedMethod3(ExecState* exec)
+EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionOverloadedMethod3(ExecState* exec)
 {
     JSValue thisValue = exec->hostThisValue();
     if (!thisValue.inherits(&JSTestObj::s_info))
-        return throwError(exec, TypeError);
+        return throwVMTypeError(exec);
     JSTestObj* castedThis = static_cast<JSTestObj*>(asObject(thisValue));
     TestObj* imp = static_cast<TestObj*>(castedThis->impl());
     const String& strArg = ustringToString(exec->argument(0).toString(exec));
 
     imp->overloadedMethod(strArg);
-    return jsUndefined();
+    return JSValue::encode(jsUndefined());
 }
 
-JSValue JSC_HOST_CALL jsTestObjPrototypeFunctionOverloadedMethod4(ExecState* exec)
+EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionOverloadedMethod4(ExecState* exec)
 {
     JSValue thisValue = exec->hostThisValue();
     if (!thisValue.inherits(&JSTestObj::s_info))
-        return throwError(exec, TypeError);
+        return throwVMTypeError(exec);
     JSTestObj* castedThis = static_cast<JSTestObj*>(asObject(thisValue));
     TestObj* imp = static_cast<TestObj*>(castedThis->impl());
     int intArg = exec->argument(0).toInt32(exec);
 
     imp->overloadedMethod(intArg);
-    return jsUndefined();
+    return JSValue::encode(jsUndefined());
 }
 
-JSValue JSC_HOST_CALL jsTestObjPrototypeFunctionOverloadedMethod(ExecState* exec)
+EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionOverloadedMethod(ExecState* exec)
 {
-    if ((exec->argumentCount() == 2 && (exec->argument(0).isNull() || asObject(exec->argument(0))->inherits(JSTestObj::s_info) && (exec->argument(1).isNull() || exec->argument(1).isUndefined() || exec->argument(1).isString() || exec->argument(1).isObject())))
+    if ((exec->argumentCount() == 2 && (exec->argument(0).isNull() || asObject(exec->argument(0))->inherits(&JSTestObj::s_info)) && (exec->argument(1).isNull() || exec->argument(1).isUndefined() || exec->argument(1).isString() || exec->argument(1).isObject())))
         return jsTestObjPrototypeFunctionOverloadedMethod1(exec);
-    if ((exec->argumentCount() == 1 && (exec->argument(0).isNull() || asObject(exec->argument(0))->inherits(JSTestObj::s_info)) || (exec->argumentCount() == 2 && (exec->argument(0).isNull() || asObject(exec->argument(0))->inherits(JSTestObj::s_info)))
+    if ((exec->argumentCount() == 1 && (exec->argument(0).isNull() || asObject(exec->argument(0))->inherits(&JSTestObj::s_info))) || (exec->argumentCount() == 2 && (exec->argument(0).isNull() || asObject(exec->argument(0))->inherits(&JSTestObj::s_info))))
         return jsTestObjPrototypeFunctionOverloadedMethod2(exec);
     if ((exec->argumentCount() == 1 && (exec->argument(0).isNull() || exec->argument(0).isUndefined() || exec->argument(0).isString() || exec->argument(0).isObject())))
         return jsTestObjPrototypeFunctionOverloadedMethod3(exec);
     if (exec->argumentCount() == 1)
         return jsTestObjPrototypeFunctionOverloadedMethod4(exec);
-    return throwError(exec, TypeError);
+    return throwTypeError(exec);
 }
 
 JSC::JSValue toJS(JSC::ExecState* exec, JSDOMGlobalObject* globalObject, TestObj* object)
diff --git a/WebCore/bindings/scripts/test/JS/JSTestObj.h b/WebCore/bindings/scripts/test/JS/JSTestObj.h
index 38cf8c2..dd84005 100644
--- a/WebCore/bindings/scripts/test/JS/JSTestObj.h
+++ b/WebCore/bindings/scripts/test/JS/JSTestObj.h
@@ -86,34 +86,35 @@ protected:
 
 // Functions
 
-JSC::JSValue JSC_HOST_CALL jsTestObjPrototypeFunctionVoidMethod(JSC::ExecState*);
-JSC::JSValue JSC_HOST_CALL jsTestObjPrototypeFunctionVoidMethodWithArgs(JSC::ExecState*);
-JSC::JSValue JSC_HOST_CALL jsTestObjPrototypeFunctionIntMethod(JSC::ExecState*);
-JSC::JSValue JSC_HOST_CALL jsTestObjPrototypeFunctionIntMethodWithArgs(JSC::ExecState*);
-JSC::JSValue JSC_HOST_CALL jsTestObjPrototypeFunctionObjMethod(JSC::ExecState*);
-JSC::JSValue JSC_HOST_CALL jsTestObjPrototypeFunctionObjMethodWithArgs(JSC::ExecState*);
-JSC::JSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodThatRequiresAllArgs(JSC::ExecState*);
-JSC::JSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodThatRequiresAllArgsAndThrows(JSC::ExecState*);
-JSC::JSValue JSC_HOST_CALL jsTestObjPrototypeFunctionSerializedValue(JSC::ExecState*);
-JSC::JSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithException(JSC::ExecState*);
-JSC::JSValue JSC_HOST_CALL jsTestObjPrototypeFunctionCustomMethod(JSC::ExecState*);
-JSC::JSValue JSC_HOST_CALL jsTestObjPrototypeFunctionCustomMethodWithArgs(JSC::ExecState*);
-JSC::JSValue JSC_HOST_CALL jsTestObjPrototypeFunctionCustomArgsAndException(JSC::ExecState*);
-JSC::JSValue JSC_HOST_CALL jsTestObjPrototypeFunctionAddEventListener(JSC::ExecState*);
-JSC::JSValue JSC_HOST_CALL jsTestObjPrototypeFunctionRemoveEventListener(JSC::ExecState*);
-JSC::JSValue JSC_HOST_CALL jsTestObjPrototypeFunctionWithDynamicFrame(JSC::ExecState*);
-JSC::JSValue JSC_HOST_CALL jsTestObjPrototypeFunctionWithDynamicFrameAndArg(JSC::ExecState*);
-JSC::JSValue JSC_HOST_CALL jsTestObjPrototypeFunctionWithDynamicFrameAndOptionalArg(JSC::ExecState*);
-JSC::JSValue JSC_HOST_CALL jsTestObjPrototypeFunctionWithDynamicFrameAndUserGesture(JSC::ExecState*);
-JSC::JSValue JSC_HOST_CALL jsTestObjPrototypeFunctionWithDynamicFrameAndUserGestureASAD(JSC::ExecState*);
-JSC::JSValue JSC_HOST_CALL jsTestObjPrototypeFunctionWithScriptStateVoid(JSC::ExecState*);
-JSC::JSValue JSC_HOST_CALL jsTestObjPrototypeFunctionWithScriptStateObj(JSC::ExecState*);
-JSC::JSValue JSC_HOST_CALL jsTestObjPrototypeFunctionWithScriptStateVoidException(JSC::ExecState*);
-JSC::JSValue JSC_HOST_CALL jsTestObjPrototypeFunctionWithScriptStateObjException(JSC::ExecState*);
-JSC::JSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithOptionalArg(JSC::ExecState*);
-JSC::JSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithNonOptionalArgAndOptionalArg(JSC::ExecState*);
-JSC::JSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithNonOptionalArgAndTwoOptionalArgs(JSC::ExecState*);
-JSC::JSValue JSC_HOST_CALL jsTestObjPrototypeFunctionOverloadedMethod(JSC::ExecState*);
+JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionVoidMethod(JSC::ExecState*);
+JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionVoidMethodWithArgs(JSC::ExecState*);
+JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionIntMethod(JSC::ExecState*);
+JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionIntMethodWithArgs(JSC::ExecState*);
+JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionObjMethod(JSC::ExecState*);
+JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionObjMethodWithArgs(JSC::ExecState*);
+JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodThatRequiresAllArgs(JSC::ExecState*);
+JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodThatRequiresAllArgsAndThrows(JSC::ExecState*);
+JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionSerializedValue(JSC::ExecState*);
+JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithException(JSC::ExecState*);
+JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionCustomMethod(JSC::ExecState*);
+JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionCustomMethodWithArgs(JSC::ExecState*);
+JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionCustomArgsAndException(JSC::ExecState*);
+JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionAddEventListener(JSC::ExecState*);
+JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionRemoveEventListener(JSC::ExecState*);
+JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionWithDynamicFrame(JSC::ExecState*);
+JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionWithDynamicFrameAndArg(JSC::ExecState*);
+JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionWithDynamicFrameAndOptionalArg(JSC::ExecState*);
+JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionWithDynamicFrameAndUserGesture(JSC::ExecState*);
+JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionWithDynamicFrameAndUserGestureASAD(JSC::ExecState*);
+JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionWithScriptStateVoid(JSC::ExecState*);
+JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionWithScriptStateObj(JSC::ExecState*);
+JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionWithScriptStateVoidException(JSC::ExecState*);
+JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionWithScriptStateObjException(JSC::ExecState*);
+JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionWithScriptExecutionContext(JSC::ExecState*);
+JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithOptionalArg(JSC::ExecState*);
+JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithNonOptionalArgAndOptionalArg(JSC::ExecState*);
+JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithNonOptionalArgAndTwoOptionalArgs(JSC::ExecState*);
+JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionOverloadedMethod(JSC::ExecState*);
 // Attributes
 
 JSC::JSValue jsTestObjReadOnlyIntAttr(JSC::ExecState*, JSC::JSValue, const JSC::Identifier&);
@@ -138,6 +139,10 @@ void setJSTestObjAttrWithGetterException(JSC::ExecState*, JSC::JSObject*, JSC::J
 JSC::JSValue jsTestObjCustomAttr(JSC::ExecState*, JSC::JSValue, const JSC::Identifier&);
 void setJSTestObjCustomAttr(JSC::ExecState*, JSC::JSObject*, JSC::JSValue);
 JSC::JSValue jsTestObjScriptStringAttr(JSC::ExecState*, JSC::JSValue, const JSC::Identifier&);
+JSC::JSValue jsTestObjDescription(JSC::ExecState*, JSC::JSValue, const JSC::Identifier&);
+JSC::JSValue jsTestObjId(JSC::ExecState*, JSC::JSValue, const JSC::Identifier&);
+void setJSTestObjId(JSC::ExecState*, JSC::JSObject*, JSC::JSValue);
+JSC::JSValue jsTestObjHash(JSC::ExecState*, JSC::JSValue, const JSC::Identifier&);
 JSC::JSValue jsTestObjConstructor(JSC::ExecState*, JSC::JSValue, const JSC::Identifier&);
 
 } // namespace WebCore
diff --git a/WebCore/bindings/scripts/test/ObjC/DOMTestObj.h b/WebCore/bindings/scripts/test/ObjC/DOMTestObj.h
index 247f4a3..6b50246 100644
--- a/WebCore/bindings/scripts/test/ObjC/DOMTestObj.h
+++ b/WebCore/bindings/scripts/test/ObjC/DOMTestObj.h
@@ -56,6 +56,10 @@
 - (int)customAttr;
 - (void)setCustomAttr:(int)newCustomAttr;
 - (NSString *)scriptStringAttr;
+- (int)descriptionName;
+- (int)idName;
+- (void)setIdName:(int)newIdName;
+- (NSString *)hashName;
 - (void)voidMethod;
 - (void)voidMethodWithArgs:(int)intArg strArg:(NSString *)strArg objArg:(DOMTestObj *)objArg;
 - (int)intMethod;
@@ -80,6 +84,7 @@
 - (DOMTestObj *)withScriptStateObj;
 - (void)withScriptStateVoidException;
 - (DOMTestObj *)withScriptStateObjException;
+- (void)withScriptExecutionContext;
 - (void)methodWithOptionalArg:(int)opt;
 - (void)methodWithNonOptionalArgAndOptionalArg:(int)nonOpt opt:(int)opt;
 - (void)methodWithNonOptionalArgAndTwoOptionalArgs:(int)nonOpt opt1:(int)opt1 opt2:(int)opt2;
diff --git a/WebCore/bindings/scripts/test/ObjC/DOMTestObj.mm b/WebCore/bindings/scripts/test/ObjC/DOMTestObj.mm
index 0f3fb66..e57ed87 100644
--- a/WebCore/bindings/scripts/test/ObjC/DOMTestObj.mm
+++ b/WebCore/bindings/scripts/test/ObjC/DOMTestObj.mm
@@ -212,6 +212,30 @@
     return IMPL->scriptStringAttr();
 }
 
+- (int)descriptionName
+{
+    WebCore::JSMainThreadNullState state;
+    return IMPL->description();
+}
+
+- (int)idName
+{
+    WebCore::JSMainThreadNullState state;
+    return IMPL->id();
+}
+
+- (void)setIdName:(int)newIdName
+{
+    WebCore::JSMainThreadNullState state;
+    IMPL->setId(newIdName);
+}
+
+- (NSString *)hashName
+{
+    WebCore::JSMainThreadNullState state;
+    return IMPL->hash();
+}
+
 - (void)voidMethod
 {
     WebCore::JSMainThreadNullState state;
@@ -370,6 +394,12 @@
     return result;
 }
 
+- (void)withScriptExecutionContext
+{
+    WebCore::JSMainThreadNullState state;
+    IMPL->withScriptExecutionContext();
+}
+
 - (void)methodWithOptionalArg:(int)opt
 {
     WebCore::JSMainThreadNullState state;
diff --git a/WebCore/bindings/scripts/test/TestObj.idl b/WebCore/bindings/scripts/test/TestObj.idl
index bda2586..1cb004c 100644
--- a/WebCore/bindings/scripts/test/TestObj.idl
+++ b/WebCore/bindings/scripts/test/TestObj.idl
@@ -87,6 +87,7 @@ module test {
             raises(DOMException);
         [CallWith=ScriptState] TestObj withScriptStateObjException()
             raises(DOMException);
+        [CallWith=ScriptExecutionContext] void withScriptExecutionContext();
 
         // 'Optional' extended attribute
         void    methodWithOptionalArg(in [Optional] long opt);
@@ -103,5 +104,10 @@ module test {
         void    overloadedMethod(in DOMString strArg);
         void    overloadedMethod(in long intArg);
 #endif
+
+        // ObjectiveC reserved words.
+        readonly attribute long      description;
+        attribute long               id;
+        readonly attribute DOMString hash;
     };
 }
diff --git a/WebCore/bindings/scripts/test/V8/V8TestCallback.cpp b/WebCore/bindings/scripts/test/V8/V8TestCallback.cpp
index e8be71d..fef199a 100644
--- a/WebCore/bindings/scripts/test/V8/V8TestCallback.cpp
+++ b/WebCore/bindings/scripts/test/V8/V8TestCallback.cpp
@@ -29,6 +29,8 @@
 #include "V8CustomVoidCallback.h"
 #include "V8DOMString.h"
 
+#include <wtf/Assertions.h>
+
 namespace WebCore {
 
 V8TestCallback::V8TestCallback(v8::Local<v8::Object> callback)
@@ -54,8 +56,14 @@ bool V8TestCallback::callbackWithClass1Param(ScriptExecutionContext* context, Cl
 
     v8::Context::Scope scope(v8Context);
 
+    v8::Handle<v8::Value> class1ParamHandle = toV8(class1Param);
+    if (class1ParamHandle.IsEmpty()) {
+        CRASH();
+        return true;
+    }
+
     v8::Handle<v8::Value> argv[] = {
-        toV8(class1Param)
+        class1ParamHandle
     };
 
     bool callbackReturnValue = false;
@@ -72,9 +80,20 @@ bool V8TestCallback::callbackWithClass2Param(ScriptExecutionContext* context, Cl
 
     v8::Context::Scope scope(v8Context);
 
+    v8::Handle<v8::Value> class2ParamHandle = toV8(class2Param);
+    if (class2ParamHandle.IsEmpty()) {
+        CRASH();
+        return true;
+    }
+    v8::Handle<v8::Value> strArgHandle = toV8(strArg);
+    if (strArgHandle.IsEmpty()) {
+        CRASH();
+        return true;
+    }
+
     v8::Handle<v8::Value> argv[] = {
-        toV8(class2Param),
-        toV8(strArg)
+        class2ParamHandle,
+        strArgHandle
     };
 
     bool callbackReturnValue = false;
diff --git a/WebCore/bindings/scripts/test/V8/V8TestObj.cpp b/WebCore/bindings/scripts/test/V8/V8TestObj.cpp
index 449e086..69c57bb 100644
--- a/WebCore/bindings/scripts/test/V8/V8TestObj.cpp
+++ b/WebCore/bindings/scripts/test/V8/V8TestObj.cpp
@@ -218,6 +218,36 @@ static v8::Handle<v8::Value> scriptStringAttrAttrGetter(v8::Local<v8::String> na
     return v8StringOrNull(imp->scriptStringAttr());
 }
 
+static v8::Handle<v8::Value> descriptionAttrGetter(v8::Local<v8::String> name, const v8::AccessorInfo& info)
+{
+    INC_STATS("DOM.TestObj.description._get");
+    TestObj* imp = V8TestObj::toNative(info.Holder());
+    return v8::Integer::New(imp->description());
+}
+
+static v8::Handle<v8::Value> idAttrGetter(v8::Local<v8::String> name, const v8::AccessorInfo& info)
+{
+    INC_STATS("DOM.TestObj.id._get");
+    TestObj* imp = V8TestObj::toNative(info.Holder());
+    return v8::Integer::New(imp->id());
+}
+
+static void idAttrSetter(v8::Local<v8::String> name, v8::Local<v8::Value> value, const v8::AccessorInfo& info)
+{
+    INC_STATS("DOM.TestObj.id._set");
+    TestObj* imp = V8TestObj::toNative(info.Holder());
+    int v = toInt32(value);
+    imp->setId(v);
+    return;
+}
+
+static v8::Handle<v8::Value> hashAttrGetter(v8::Local<v8::String> name, const v8::AccessorInfo& info)
+{
+    INC_STATS("DOM.TestObj.hash._get");
+    TestObj* imp = V8TestObj::toNative(info.Holder());
+    return v8String(imp->hash());
+}
+
 static v8::Handle<v8::Value> voidMethodCallback(const v8::Arguments& args)
 {
     INC_STATS("DOM.TestObj.voidMethod");
@@ -507,6 +537,17 @@ static v8::Handle<v8::Value> withScriptStateObjExceptionCallback(const v8::Argum
     return v8::Handle<v8::Value>();
 }
 
+static v8::Handle<v8::Value> withScriptExecutionContextCallback(const v8::Arguments& args)
+{
+    INC_STATS("DOM.TestObj.withScriptExecutionContext");
+    TestObj* imp = V8TestObj::toNative(args.Holder());
+    ScriptExecutionContext* scriptContext = getScriptExecutionContext();
+    if (!scriptContext)
+        return v8::Undefined();
+    imp->withScriptExecutionContext(scriptContext);
+    return v8::Handle<v8::Value>();
+}
+
 static v8::Handle<v8::Value> methodWithOptionalArgCallback(const v8::Arguments& args)
 {
     INC_STATS("DOM.TestObj.methodWithOptionalArg");
@@ -635,6 +676,12 @@ static const BatchedAttribute TestObjAttrs[] = {
     {"customAttr", V8TestObj::customAttrAccessorGetter, V8TestObj::customAttrAccessorSetter, 0 /* no data */, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
     // Attribute 'scriptStringAttr' (Type: 'readonly attribute' ExtAttr: 'ConvertScriptString')
     {"scriptStringAttr", TestObjInternal::scriptStringAttrAttrGetter, 0, 0 /* no data */, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
+    // Attribute 'description' (Type: 'readonly attribute' ExtAttr: '')
+    {"description", TestObjInternal::descriptionAttrGetter, 0, 0 /* no data */, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
+    // Attribute 'id' (Type: 'attribute' ExtAttr: '')
+    {"id", TestObjInternal::idAttrGetter, TestObjInternal::idAttrSetter, 0 /* no data */, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
+    // Attribute 'hash' (Type: 'readonly attribute' ExtAttr: '')
+    {"hash", TestObjInternal::hashAttrGetter, 0, 0 /* no data */, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
 };
 static const BatchedCallback TestObjCallbacks[] = {
     {"voidMethod", TestObjInternal::voidMethodCallback},
@@ -655,6 +702,7 @@ static const BatchedCallback TestObjCallbacks[] = {
     {"withScriptStateObj", TestObjInternal::withScriptStateObjCallback},
     {"withScriptStateVoidException", TestObjInternal::withScriptStateVoidExceptionCallback},
     {"withScriptStateObjException", TestObjInternal::withScriptStateObjExceptionCallback},
+    {"withScriptExecutionContext", TestObjInternal::withScriptExecutionContextCallback},
     {"methodWithOptionalArg", TestObjInternal::methodWithOptionalArgCallback},
     {"methodWithNonOptionalArgAndOptionalArg", TestObjInternal::methodWithNonOptionalArgAndOptionalArgCallback},
     {"methodWithNonOptionalArgAndTwoOptionalArgs", TestObjInternal::methodWithNonOptionalArgAndTwoOptionalArgsCallback},
diff --git a/WebCore/bindings/v8/NPV8Object.cpp b/WebCore/bindings/v8/NPV8Object.cpp
index d8076f3..af0933f 100644
--- a/WebCore/bindings/v8/NPV8Object.cpp
+++ b/WebCore/bindings/v8/NPV8Object.cpp
@@ -49,7 +49,6 @@
 #endif
 
 #include <stdio.h>
-#include <v8.h>
 #include <wtf/StringExtras.h>
 
 using namespace WebCore;
diff --git a/WebCore/bindings/v8/ScriptArray.cpp b/WebCore/bindings/v8/ScriptArray.cpp
index 01b0898..a199a6c 100644
--- a/WebCore/bindings/v8/ScriptArray.cpp
+++ b/WebCore/bindings/v8/ScriptArray.cpp
@@ -39,8 +39,6 @@
 #include "V8Binding.h"
 #include "V8Proxy.h"
 
-#include <v8.h>
-
 namespace WebCore {
 
 ScriptArray::ScriptArray(ScriptState* scriptState, v8::Handle<v8::Array> v8Array)
diff --git a/WebCore/bindings/v8/ScriptCallStack.cpp b/WebCore/bindings/v8/ScriptCallStack.cpp
index 31b05ee..89809b2 100644
--- a/WebCore/bindings/v8/ScriptCallStack.cpp
+++ b/WebCore/bindings/v8/ScriptCallStack.cpp
@@ -37,7 +37,6 @@
 #include "V8Binding.h"
 
 #include <v8-debug.h>
-#include <v8.h>
 
 namespace WebCore {
 
diff --git a/WebCore/bindings/v8/ScriptController.cpp b/WebCore/bindings/v8/ScriptController.cpp
index f6cf3a4..d3ec33f 100644
--- a/WebCore/bindings/v8/ScriptController.cpp
+++ b/WebCore/bindings/v8/ScriptController.cpp
@@ -469,10 +469,12 @@ void ScriptController::updateDocument()
 
 void ScriptController::namedItemAdded(HTMLDocument* doc, const AtomicString& name)
 {
+    m_proxy->windowShell()->namedItemAdded(doc, name);
 }
 
 void ScriptController::namedItemRemoved(HTMLDocument* doc, const AtomicString& name)
 {
+    m_proxy->windowShell()->namedItemRemoved(doc, name);
 }
 
 } // namespace WebCore
diff --git a/WebCore/bindings/v8/ScriptDebugServer.cpp b/WebCore/bindings/v8/ScriptDebugServer.cpp
index fdbb26b..39e409e 100644
--- a/WebCore/bindings/v8/ScriptDebugServer.cpp
+++ b/WebCore/bindings/v8/ScriptDebugServer.cpp
@@ -256,6 +256,40 @@ void ScriptDebugServer::stepOutOfFunction()
 #endif
 }
 
+bool ScriptDebugServer::editScriptSource(const String& sourceID, const String& newContent, String& newSourceOrErrorMessage)
+{
+#if ENABLE(V8_SCRIPT_DEBUG_SERVER)
+    ensureDebuggerScriptCompiled();
+    v8::HandleScope scope;
+
+    OwnPtr<v8::Context::Scope> contextScope;
+    if (!m_pausedPage)
+        contextScope.set(new v8::Context::Scope(v8::Debug::GetDebugContext()));
+
+    v8::Handle<v8::Function> function = v8::Local<v8::Function>::Cast(m_debuggerScript.get()->Get(v8::String::New("editScriptSource")));
+    v8::Handle<v8::Value> argv[] = { v8String(sourceID), v8String(newContent) };
+
+    v8::TryCatch tryCatch;
+    tryCatch.SetVerbose(false);
+    v8::Handle<v8::Value> result = function->Call(m_debuggerScript.get(), 2, argv);
+    if (tryCatch.HasCaught()) {
+        v8::Local<v8::Message> message = tryCatch.Message();
+        if (!message.IsEmpty())
+            newSourceOrErrorMessage = toWebCoreStringWithNullOrUndefinedCheck(message->Get());
+        return false;
+    }
+    ASSERT(!result.IsEmpty());
+    newSourceOrErrorMessage = toWebCoreStringWithNullOrUndefinedCheck(result);
+
+    // Call stack may have changed after if the edited function was on the stack.
+    if (m_currentCallFrame)
+        m_currentCallFrame.clear();
+    return true;
+#else
+    return false;
+#endif
+}
+
 PassRefPtr<JavaScriptCallFrame> ScriptDebugServer::currentCallFrame()
 {
     if (!m_currentCallFrame) {
@@ -267,6 +301,11 @@ PassRefPtr<JavaScriptCallFrame> ScriptDebugServer::currentCallFrame()
     return m_currentCallFrame;
 }
 
+bool ScriptDebugServer::isDebuggerAlwaysEnabled()
+{
+    return true;
+}
+
 #if ENABLE(V8_SCRIPT_DEBUG_SERVER)
 void ScriptDebugServer::v8DebugEventCallback(const v8::Debug::EventDetails& eventDetails)
 {
@@ -320,7 +359,8 @@ void ScriptDebugServer::dispatchDidParseSource(ScriptDebugListener* listener, v8
         toWebCoreStringWithNullOrUndefinedCheck(object->Get(v8::String::New("id"))),
         toWebCoreStringWithNullOrUndefinedCheck(object->Get(v8::String::New("name"))),
         toWebCoreStringWithNullOrUndefinedCheck(object->Get(v8::String::New("source"))),
-        object->Get(v8::String::New("lineOffset"))->ToInteger()->Value());
+        object->Get(v8::String::New("lineOffset"))->ToInteger()->Value(),
+        static_cast<ScriptWorldType>(object->Get(v8::String::New("scriptWorldType"))->Int32Value()));
 }
 
 void ScriptDebugServer::ensureDebuggerScriptCompiled()
diff --git a/WebCore/bindings/v8/ScriptDebugServer.h b/WebCore/bindings/v8/ScriptDebugServer.h
index 7c8c5cc..9439c16 100644
--- a/WebCore/bindings/v8/ScriptDebugServer.h
+++ b/WebCore/bindings/v8/ScriptDebugServer.h
@@ -74,6 +74,8 @@ public:
     void stepOverStatement();
     void stepOutOfFunction();
 
+    bool editScriptSource(const String& sourceID, const String& newContent, String& newSourceOrErrorMessage);
+
     void recompileAllJSFunctionsSoon() { }
     void recompileAllJSFunctions(Timer<ScriptDebugServer>* = 0) { }
 
@@ -92,6 +94,8 @@ public:
 
     PassRefPtr<JavaScriptCallFrame> currentCallFrame();
 
+    bool isDebuggerAlwaysEnabled();
+
 private:
     ScriptDebugServer();
     ~ScriptDebugServer() { }
diff --git a/WebCore/bindings/v8/ScriptEventListener.cpp b/WebCore/bindings/v8/ScriptEventListener.cpp
index cad7a1c..57a2824 100644
--- a/WebCore/bindings/v8/ScriptEventListener.cpp
+++ b/WebCore/bindings/v8/ScriptEventListener.cpp
@@ -36,7 +36,7 @@
 #include "EventListener.h"
 #include "Frame.h"
 #include "ScriptScope.h"
-#include "Tokenizer.h"
+#include "DocumentParser.h"
 #include "V8AbstractEventListener.h"
 #include "V8Binding.h"
 #include "XSSAuditor.h"
@@ -64,10 +64,10 @@ PassRefPtr<V8LazyEventListener> createAttributeEventListener(Node* node, Attribu
             return 0;
         }
 
-        if (frame->document()->tokenizer()) {
+        if (frame->document()->parser()) {
             // FIXME: Change to use script->eventHandlerLineNumber() when implemented.
-            lineNumber = frame->document()->tokenizer()->lineNumber();
-            columnNumber = frame->document()->tokenizer()->columnNumber();
+            lineNumber = frame->document()->parser()->lineNumber();
+            columnNumber = frame->document()->parser()->columnNumber();
         }
         sourceURL = node->document()->url().string();
     }
@@ -97,10 +97,10 @@ PassRefPtr<V8LazyEventListener> createAttributeEventListener(Frame* frame, Attri
         return 0;
     }
 
-    if (frame->document()->tokenizer()) {
+    if (frame->document()->parser()) {
         // FIXME: Change to use script->eventHandlerLineNumber() when implemented.
-        lineNumber = frame->document()->tokenizer()->lineNumber();
-        columnNumber = frame->document()->tokenizer()->columnNumber();
+        lineNumber = frame->document()->parser()->lineNumber();
+        columnNumber = frame->document()->parser()->columnNumber();
     }
     sourceURL = frame->document()->url().string();
     return V8LazyEventListener::create(attr->localName().string(), frame->document()->isSVGDocument(), attr->value(), sourceURL, lineNumber, columnNumber, WorldContextHandle(UseMainWorld));
diff --git a/WebCore/bindings/v8/ScriptProfiler.cpp b/WebCore/bindings/v8/ScriptProfiler.cpp
index 1f09420..ab0b9fe 100644
--- a/WebCore/bindings/v8/ScriptProfiler.cpp
+++ b/WebCore/bindings/v8/ScriptProfiler.cpp
@@ -46,7 +46,9 @@ void ScriptProfiler::start(ScriptState* state, const String& title)
 PassRefPtr<ScriptProfile> ScriptProfiler::stop(ScriptState* state, const String& title)
 {
     v8::HandleScope hs;
-    const v8::CpuProfile* profile = v8::CpuProfiler::StopProfiling(v8String(title));
+    const v8::CpuProfile* profile = state ?
+        v8::CpuProfiler::StopProfiling(v8String(title), state->context()->GetSecurityToken()) :
+        v8::CpuProfiler::StopProfiling(v8String(title));
     return profile ? ScriptProfile::create(profile) : 0;
 }
 
diff --git a/WebCore/bindings/v8/SerializedScriptValue.cpp b/WebCore/bindings/v8/SerializedScriptValue.cpp
index 50ac86b..8e91920 100644
--- a/WebCore/bindings/v8/SerializedScriptValue.cpp
+++ b/WebCore/bindings/v8/SerializedScriptValue.cpp
@@ -38,13 +38,13 @@
 #include "FileList.h"
 #include "ImageData.h"
 #include "SharedBuffer.h"
+#include "V8Binding.h"
 #include "V8Blob.h"
 #include "V8File.h"
 #include "V8FileList.h"
 #include "V8ImageData.h"
 #include "V8Proxy.h"
 
-#include <v8.h>
 #include <wtf/Assertions.h>
 #include <wtf/RefCounted.h>
 #include <wtf/Vector.h>
@@ -1012,6 +1012,52 @@ private:
 
 } // namespace
 
+void SerializedScriptValue::deserializeAndSetProperty(v8::Handle<v8::Object> object, const char* propertyName,
+                                                      v8::PropertyAttribute attribute, SerializedScriptValue* value)
+{
+    if (!value)
+        return;
+    v8::Handle<v8::Value> deserialized = value->deserialize();
+    object->ForceSet(v8::String::NewSymbol(propertyName), deserialized, attribute);
+}
+
+PassRefPtr<SerializedScriptValue> SerializedScriptValue::create(v8::Handle<v8::Value> value, bool& didThrow)
+{
+    return adoptRef(new SerializedScriptValue(value, didThrow));
+}
+
+PassRefPtr<SerializedScriptValue> SerializedScriptValue::create(v8::Handle<v8::Value> value)
+{
+    bool didThrow;
+    return adoptRef(new SerializedScriptValue(value, didThrow));
+}
+
+PassRefPtr<SerializedScriptValue> SerializedScriptValue::createFromWire(String data)
+{
+    return adoptRef(new SerializedScriptValue(data, WireData));
+}
+
+PassRefPtr<SerializedScriptValue> SerializedScriptValue::create(String data)
+{
+    return adoptRef(new SerializedScriptValue(data, StringValue));
+}
+
+PassRefPtr<SerializedScriptValue> SerializedScriptValue::create()
+{
+    return adoptRef(new SerializedScriptValue());
+}
+
+PassRefPtr<SerializedScriptValue> SerializedScriptValue::release()
+{
+    RefPtr<SerializedScriptValue> result = adoptRef(new SerializedScriptValue(m_data, WireData));
+    m_data = String();
+    return result.release();
+}
+
+SerializedScriptValue::SerializedScriptValue()
+{
+}
+
 SerializedScriptValue::SerializedScriptValue(v8::Handle<v8::Value> value, bool& didThrow)
 {
     didThrow = false;
diff --git a/WebCore/bindings/v8/SerializedScriptValue.h b/WebCore/bindings/v8/SerializedScriptValue.h
index 8205a42..3710b5a 100644
--- a/WebCore/bindings/v8/SerializedScriptValue.h
+++ b/WebCore/bindings/v8/SerializedScriptValue.h
@@ -32,7 +32,6 @@
 #define SerializedScriptValue_h
 
 #include "ScriptValue.h"
-#include "V8Binding.h"
 #include <v8.h>
 #include <wtf/RefCounted.h>
 
@@ -40,63 +39,21 @@ namespace WebCore {
 
 class SerializedScriptValue : public RefCounted<SerializedScriptValue> {
 public:
-    // Deserializes the given value and sets it as a property on the
-    // object.
-    static void deserializeAndSetProperty(v8::Handle<v8::Object> object,
-                                          const char* propertyName,
-                                          v8::PropertyAttribute attribute,
-                                          SerializedScriptValue* value)
-    {
-        if (!value)
-            return;
-        v8::Handle<v8::Value> deserialized = value->deserialize();
-        object->ForceSet(v8::String::NewSymbol(propertyName), deserialized, attribute);
-    }
+    static void deserializeAndSetProperty(v8::Handle<v8::Object> object, const char* propertyName,
+                                          v8::PropertyAttribute, SerializedScriptValue*);
 
-    // Creates a serialized representation of the given V8 value.
-    static PassRefPtr<SerializedScriptValue> create(v8::Handle<v8::Value> value)
-    {
-        bool didThrow;
-        return adoptRef(new SerializedScriptValue(value, didThrow));
-    }
-
-    // Creates a serialized representation of the given V8 value.
-    //
     // If a serialization error occurs (e.g., cyclic input value) this
     // function returns an empty representation, schedules a V8 exception to
     // be thrown using v8::ThrowException(), and sets |didThrow|. In this case
     // the caller must not invoke any V8 operations until control returns to
     // V8. When serialization is successful, |didThrow| is false.
-    static PassRefPtr<SerializedScriptValue> create(v8::Handle<v8::Value> value, bool& didThrow)
-    {
-        return adoptRef(new SerializedScriptValue(value, didThrow));
-    }
-
-    // Creates a serialized value with the given data obtained from a
-    // prior call to toWireString().
-    static PassRefPtr<SerializedScriptValue> createFromWire(String data)
-    {
-        return adoptRef(new SerializedScriptValue(data, WireData));
-    }
-
-    // Creates a serialized representation of WebCore string.
-    static PassRefPtr<SerializedScriptValue> create(String data)
-    {
-        return adoptRef(new SerializedScriptValue(data, StringValue));
-    }
+    static PassRefPtr<SerializedScriptValue> create(v8::Handle<v8::Value> value, bool& didThrow);
+    static PassRefPtr<SerializedScriptValue> create(v8::Handle<v8::Value>);
+    static PassRefPtr<SerializedScriptValue> createFromWire(String data);
+    static PassRefPtr<SerializedScriptValue> create(String data);
+    static PassRefPtr<SerializedScriptValue> create();
 
-    // Creates an empty serialized value.
-    static PassRefPtr<SerializedScriptValue> create()
-    {
-        return adoptRef(new SerializedScriptValue());
-    }
-
-    PassRefPtr<SerializedScriptValue> release()
-    {
-        RefPtr<SerializedScriptValue> result = adoptRef(new SerializedScriptValue(m_data, WireData));
-        m_data = String();
-        return result.release();
-    }
+    PassRefPtr<SerializedScriptValue> release();
 
     String toWireString() const { return m_data; }
 
@@ -110,10 +67,8 @@ private:
         WireData
     };
 
-    SerializedScriptValue() { }
-
+    SerializedScriptValue();
     SerializedScriptValue(v8::Handle<v8::Value>, bool& didThrow);
-
     SerializedScriptValue(String data, StringDataMode mode);
 
     String m_data;
diff --git a/WebCore/bindings/v8/V8Binding.cpp b/WebCore/bindings/v8/V8Binding.cpp
index e0904d7..97805c0 100644
--- a/WebCore/bindings/v8/V8Binding.cpp
+++ b/WebCore/bindings/v8/V8Binding.cpp
@@ -44,8 +44,6 @@
 #include "V8Proxy.h"
 #include <wtf/text/CString.h>
 
-#include <v8.h>
-
 namespace WebCore {
 
 // WebCoreStringResource is a helper class for v8ExternalString. It is used
diff --git a/WebCore/bindings/v8/V8DOMWindowShell.cpp b/WebCore/bindings/v8/V8DOMWindowShell.cpp
index c7c77d3..99fea4c 100644
--- a/WebCore/bindings/v8/V8DOMWindowShell.cpp
+++ b/WebCore/bindings/v8/V8DOMWindowShell.cpp
@@ -50,6 +50,7 @@
 #include "V8DOMWindow.h"
 #include "V8Document.h"
 #include "V8GCForContextDispose.h"
+#include "V8HTMLDocument.h"
 #include "V8HiddenPropertyName.h"
 #include "V8History.h"
 #include "V8Location.h"
@@ -414,6 +415,12 @@ void V8DOMWindowShell::clearDocumentWrapper()
     }
 }
 
+static void checkDocumentWrapper(v8::Handle<v8::Object> wrapper, Document* document)
+{
+    ASSERT(V8Document::toNative(wrapper) == document);
+    ASSERT(!document->isHTMLDocument() || (V8Document::toNative(v8::Handle<v8::Object>::Cast(wrapper->GetPrototype())) == document));
+}
+
 void V8DOMWindowShell::updateDocumentWrapperCache()
 {
     v8::HandleScope handleScope;
@@ -432,6 +439,10 @@ void V8DOMWindowShell::updateDocumentWrapperCache()
     }
 
     v8::Handle<v8::Value> documentWrapper = toV8(m_frame->document());
+    ASSERT(documentWrapper == m_document || m_document.IsEmpty());
+    if (m_document.IsEmpty())
+        updateDocumentWrapper(v8::Handle<v8::Object>::Cast(documentWrapper));
+    checkDocumentWrapper(m_document, m_frame->document());
 
     // If instantiation of the document wrapper fails, clear the cache
     // and let the DOMWindow accessor handle access to the document.
@@ -509,6 +520,39 @@ void V8DOMWindowShell::updateDocument()
     updateSecurityOrigin();
 }
 
+v8::Handle<v8::Value> getter(v8::Local<v8::String> property, const v8::AccessorInfo& info)
+{
+    // FIXME(antonm): consider passing AtomicStringImpl directly.
+    AtomicString name = v8StringToAtomicWebCoreString(property);
+    HTMLDocument* htmlDocument = V8HTMLDocument::toNative(info.Holder());
+    ASSERT(htmlDocument);
+    return V8HTMLDocument::GetNamedProperty(htmlDocument, name);
+}
+
+void V8DOMWindowShell::namedItemAdded(HTMLDocument* doc, const AtomicString& name)
+{
+    initContextIfNeeded();
+
+    v8::HandleScope handleScope;
+    v8::Context::Scope contextScope(m_context);
+
+    ASSERT(!m_document.IsEmpty());
+    checkDocumentWrapper(m_document, doc);
+    m_document->SetAccessor(v8String(name), getter);
+}
+
+void V8DOMWindowShell::namedItemRemoved(HTMLDocument* doc, const AtomicString& name)
+{
+    initContextIfNeeded();
+
+    v8::HandleScope handleScope;
+    v8::Context::Scope contextScope(m_context);
+
+    ASSERT(!m_document.IsEmpty());
+    checkDocumentWrapper(m_document, doc);
+    m_document->Delete(v8String(name));
+}
+
 void V8DOMWindowShell::updateSecurityOrigin()
 {
     v8::HandleScope scope;
diff --git a/WebCore/bindings/v8/V8DOMWindowShell.h b/WebCore/bindings/v8/V8DOMWindowShell.h
index f4eaff2..3cf1b52 100644
--- a/WebCore/bindings/v8/V8DOMWindowShell.h
+++ b/WebCore/bindings/v8/V8DOMWindowShell.h
@@ -31,6 +31,7 @@
 #ifndef V8DOMWindowShell_h
 #define V8DOMWindowShell_h
 
+#include "AtomicString.h"
 #include "WrapperTypeInfo.h"
 #include <wtf/HashMap.h>
 #include <wtf/PassRefPtr.h>
@@ -41,6 +42,7 @@ namespace WebCore {
 
 class DOMWindow;
 class Frame;
+class HTMLDocument;
 class String;
 
 // V8WindowShell represents all the per-global object state for a Frame that
@@ -54,6 +56,9 @@ public:
     // Update document object of the frame.
     void updateDocument();
 
+    void namedItemAdded(HTMLDocument*, const AtomicString&);
+    void namedItemRemoved(HTMLDocument*, const AtomicString&);
+
     // Update the security origin of a document
     // (e.g., after setting docoument.domain).
     void updateSecurityOrigin();
diff --git a/WebCore/bindings/v8/V8DOMWrapper.cpp b/WebCore/bindings/v8/V8DOMWrapper.cpp
index f8426dc..596090d 100644
--- a/WebCore/bindings/v8/V8DOMWrapper.cpp
+++ b/WebCore/bindings/v8/V8DOMWrapper.cpp
@@ -82,7 +82,6 @@
 
 #include <algorithm>
 #include <utility>
-#include <v8.h>
 #include <v8-debug.h>
 #include <wtf/Assertions.h>
 #include <wtf/OwnArrayPtr.h>
@@ -286,6 +285,8 @@ v8::Local<v8::Object> V8DOMWrapper::instantiateV8Object(V8Proxy* proxy, WrapperT
     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;
 }
diff --git a/WebCore/bindings/v8/V8GCController.cpp b/WebCore/bindings/v8/V8GCController.cpp
index fa7c357..5611199 100644
--- a/WebCore/bindings/v8/V8GCController.cpp
+++ b/WebCore/bindings/v8/V8GCController.cpp
@@ -46,7 +46,6 @@
 
 #include <algorithm>
 #include <utility>
-#include <v8.h>
 #include <v8-debug.h>
 #include <wtf/HashMap.h>
 #include <wtf/StdLibExtras.h>
diff --git a/WebCore/bindings/v8/V8IsolatedContext.cpp b/WebCore/bindings/v8/V8IsolatedContext.cpp
index 3237ede..b5e4590 100644
--- a/WebCore/bindings/v8/V8IsolatedContext.cpp
+++ b/WebCore/bindings/v8/V8IsolatedContext.cpp
@@ -38,7 +38,6 @@
 #include "ScriptController.h"
 #include "V8DOMWindow.h"
 #include "V8HiddenPropertyName.h"
-#include <v8.h>
 
 namespace WebCore {
 
diff --git a/WebCore/bindings/v8/V8NPObject.cpp b/WebCore/bindings/v8/V8NPObject.cpp
index f9cc94a..7f2051e 100644
--- a/WebCore/bindings/v8/V8NPObject.cpp
+++ b/WebCore/bindings/v8/V8NPObject.cpp
@@ -243,6 +243,12 @@ v8::Handle<v8::Value> npObjectGetIndexedProperty(v8::Local<v8::Object> self, uin
     return npObjectGetProperty(self, identifier, v8::Number::New(index));
 }
 
+v8::Handle<v8::Integer> npObjectQueryProperty(v8::Local<v8::String> name, const v8::AccessorInfo& info)
+{
+    NPIdentifier identifier = getStringIdentifier(name);
+    return npObjectGetProperty(info.Holder(), identifier, name).IsEmpty() ? v8::Handle<v8::Integer>() : v8::Integer::New(v8::None);
+}
+
 static v8::Handle<v8::Value> npObjectSetProperty(v8::Local<v8::Object> self, NPIdentifier identifier, v8::Local<v8::Value> value)
 {
     NPObject* npObject = v8ObjectToNPObject(self);
@@ -373,7 +379,7 @@ v8::Local<v8::Object> createV8ObjectForNPObject(NPObject* object, NPObject* root
     if (npObjectDesc.IsEmpty()) {
         npObjectDesc = v8::Persistent<v8::FunctionTemplate>::New(v8::FunctionTemplate::New());
         npObjectDesc->InstanceTemplate()->SetInternalFieldCount(npObjectInternalFieldCount);
-        npObjectDesc->InstanceTemplate()->SetNamedPropertyHandler(npObjectNamedPropertyGetter, npObjectNamedPropertySetter, 0, 0, npObjectNamedPropertyEnumerator);
+        npObjectDesc->InstanceTemplate()->SetNamedPropertyHandler(npObjectNamedPropertyGetter, npObjectNamedPropertySetter, npObjectQueryProperty, 0, npObjectNamedPropertyEnumerator);
         npObjectDesc->InstanceTemplate()->SetIndexedPropertyHandler(npObjectIndexedPropertyGetter, npObjectIndexedPropertySetter, 0, 0, npObjectIndexedPropertyEnumerator);
         npObjectDesc->InstanceTemplate()->SetCallAsFunctionHandler(npObjectInvokeDefaultHandler);
     }
diff --git a/WebCore/bindings/v8/V8Proxy.cpp b/WebCore/bindings/v8/V8Proxy.cpp
index 7f52374..7a5df96 100644
--- a/WebCore/bindings/v8/V8Proxy.cpp
+++ b/WebCore/bindings/v8/V8Proxy.cpp
@@ -67,7 +67,6 @@
 #include <algorithm>
 #include <stdio.h>
 #include <utility>
-#include <v8.h>
 #include <wtf/Assertions.h>
 #include <wtf/OwnArrayPtr.h>
 #include <wtf/StdLibExtras.h>
diff --git a/WebCore/bindings/v8/custom/V8ArrayBufferViewCustom.cpp b/WebCore/bindings/v8/custom/V8ArrayBufferViewCustom.cpp
index 6ae3a3e..2c89b95 100644
--- a/WebCore/bindings/v8/custom/V8ArrayBufferViewCustom.cpp
+++ b/WebCore/bindings/v8/custom/V8ArrayBufferViewCustom.cpp
@@ -36,7 +36,7 @@
 #include "V8Binding.h"
 #include "V8Proxy.h"
 #include "V8Int8Array.h"
-#include "V8FloatArray.h"
+#include "V8Float32Array.h"
 #include "V8Int32Array.h"
 #include "V8Int16Array.h"
 #include "V8Uint8Array.h"
@@ -52,7 +52,7 @@ v8::Handle<v8::Value> toV8(ArrayBufferView* impl)
     if (impl->isByteArray())
         return toV8(static_cast<Int8Array*>(impl));
     if (impl->isFloatArray())
-        return toV8(static_cast<FloatArray*>(impl));
+        return toV8(static_cast<Float32Array*>(impl));
     if (impl->isIntArray())
         return toV8(static_cast<Int32Array*>(impl));
     if (impl->isShortArray())
diff --git a/WebCore/bindings/v8/custom/V8ConsoleCustom.cpp b/WebCore/bindings/v8/custom/V8ConsoleCustom.cpp
index 4cc6ac2..7d1cfc1 100644
--- a/WebCore/bindings/v8/custom/V8ConsoleCustom.cpp
+++ b/WebCore/bindings/v8/custom/V8ConsoleCustom.cpp
@@ -33,8 +33,10 @@
 #include "V8Console.h"
 
 #include "Console.h"
+#include "MemoryInfo.h"
 #include "ScriptProfile.h"
 #include "V8Binding.h"
+#include "V8MemoryInfo.h"
 #include "V8Proxy.h"
 #include "V8ScriptProfile.h"
 
@@ -42,11 +44,23 @@ namespace WebCore {
 
 typedef Vector<RefPtr<ScriptProfile> > ProfilesArray;
 
-v8::Handle<v8::Value> V8Console::profilesAccessorGetter(v8::Local<v8::String>, const v8::AccessorInfo&)
+v8::Handle<v8::Value> V8Console::profilesAccessorGetter(v8::Local<v8::String> name, const v8::AccessorInfo& info)
 {
     INC_STATS("DOM.Console.profilesAccessorGetter");
-    // FIXME: Provide a real implementation.
-    return v8::Array::New(0);
+    Console* imp = V8Console::toNative(info.Holder());
+    const ProfilesArray& profiles = imp->profiles();
+    v8::Handle<v8::Array> result = v8::Array::New(profiles.size());
+    int index = 0;
+    ProfilesArray::const_iterator end = profiles.end();
+    for (ProfilesArray::const_iterator iter = profiles.begin(); iter != end; ++iter)
+        result->Set(v8::Integer::New(index++), toV8(iter->get()));
+    return result;
+}
+
+v8::Handle<v8::Value> V8Console::memoryAccessorGetter(v8::Local<v8::String>, const v8::AccessorInfo&)
+{
+    INC_STATS("DOM.Console.memoryAccessorGetter");
+    return toV8(MemoryInfo::create());
 }
 
 } // namespace WebCore
diff --git a/WebCore/bindings/v8/custom/V8CustomPositionCallback.cpp b/WebCore/bindings/v8/custom/V8CustomPositionCallback.cpp
index 5e20e376..18f27cb 100644
--- a/WebCore/bindings/v8/custom/V8CustomPositionCallback.cpp
+++ b/WebCore/bindings/v8/custom/V8CustomPositionCallback.cpp
@@ -26,15 +26,16 @@
 #include "config.h"
 #include "V8CustomPositionCallback.h"
 
-#include "Frame.h"
+#include "ScriptExecutionContext.h"
 #include "V8CustomVoidCallback.h"  // For invokeCallback
 #include "V8Geoposition.h"
+#include "V8Proxy.h"
 
 namespace WebCore {
 
-V8CustomPositionCallback::V8CustomPositionCallback(v8::Local<v8::Object> callback, Frame* frame)
-    : m_callback(v8::Persistent<v8::Object>::New(callback))
-    , m_frame(frame)
+V8CustomPositionCallback::V8CustomPositionCallback(v8::Local<v8::Object> callback, ScriptExecutionContext* context)
+    : PositionCallback(context)
+    , m_callback(v8::Persistent<v8::Object>::New(callback))
 {
 }
 
@@ -47,7 +48,17 @@ void V8CustomPositionCallback::handleEvent(Geoposition* position)
 {
     v8::HandleScope handleScope;
 
-    v8::Handle<v8::Context> context = V8Proxy::context(m_frame.get());
+    // ActiveDOMObject will null our pointer to the ScriptExecutionContext when it goes away.
+    ScriptExecutionContext* scriptContext = scriptExecutionContext();
+    if (!scriptContext)
+        return;
+
+    // The lookup of the proxy will fail if the Frame has been detached.
+    V8Proxy* proxy = V8Proxy::retrieve(scriptContext);
+    if (!proxy)
+        return;
+
+    v8::Handle<v8::Context> context = proxy->context();
     if (context.IsEmpty())
         return;
 
@@ -57,11 +68,11 @@ void V8CustomPositionCallback::handleEvent(Geoposition* position)
         toV8(position)
     };
 
-    // Protect the frame until the callback returns.
-    RefPtr<Frame> protector(m_frame);
+    // Protect the script context until the callback returns.
+    RefPtr<ScriptExecutionContext> protector(scriptContext);
 
     bool callbackReturnValue = false;
-    invokeCallback(m_callback, 1, argv, callbackReturnValue, m_frame->document());
+    invokeCallback(m_callback, 1, argv, callbackReturnValue, scriptContext);
 }
 
 } // namespace WebCore
diff --git a/WebCore/bindings/v8/custom/V8CustomPositionCallback.h b/WebCore/bindings/v8/custom/V8CustomPositionCallback.h
index d2290ee..61db922 100644
--- a/WebCore/bindings/v8/custom/V8CustomPositionCallback.h
+++ b/WebCore/bindings/v8/custom/V8CustomPositionCallback.h
@@ -27,6 +27,7 @@
 #define V8CustomPositionCallback_h
 
 #include "PositionCallback.h"
+
 #include <v8.h>
 #include <wtf/PassRefPtr.h>
 #include <wtf/RefPtr.h>
@@ -35,23 +36,23 @@ namespace WebCore {
 
 class Frame;
 class Geoposition;
+class ScriptExecutionContext;
 
 class V8CustomPositionCallback : public PositionCallback {
 public:
-    static PassRefPtr<V8CustomPositionCallback> create(v8::Local<v8::Value> value, Frame* frame)
+    static PassRefPtr<V8CustomPositionCallback> create(v8::Local<v8::Value> value, ScriptExecutionContext* context)
     {
         ASSERT(value->IsObject());
-        return adoptRef(new V8CustomPositionCallback(value->ToObject(), frame));
+        return adoptRef(new V8CustomPositionCallback(value->ToObject(), context));
     }
     virtual ~V8CustomPositionCallback();
 
     virtual void handleEvent(Geoposition*);
 
 private:
-    V8CustomPositionCallback(v8::Local<v8::Object>, Frame*);
+    V8CustomPositionCallback(v8::Local<v8::Object>, ScriptExecutionContext*);
 
     v8::Persistent<v8::Object> m_callback;
-    RefPtr<Frame> m_frame;
 };
 
 } // namespace WebCore
diff --git a/WebCore/bindings/v8/custom/V8CustomPositionErrorCallback.cpp b/WebCore/bindings/v8/custom/V8CustomPositionErrorCallback.cpp
index bd42d94..36b5e04 100644
--- a/WebCore/bindings/v8/custom/V8CustomPositionErrorCallback.cpp
+++ b/WebCore/bindings/v8/custom/V8CustomPositionErrorCallback.cpp
@@ -26,15 +26,16 @@
 #include "config.h"
 #include "V8CustomPositionErrorCallback.h"
 
-#include "Frame.h"
+#include "ScriptExecutionContext.h"
 #include "V8CustomVoidCallback.h"  // For invokeCallback
 #include "V8PositionError.h"
+#include "V8Proxy.h"
 
 namespace WebCore {
 
-V8CustomPositionErrorCallback::V8CustomPositionErrorCallback(v8::Local<v8::Object> callback, Frame* frame)
-    : m_callback(v8::Persistent<v8::Object>::New(callback))
-    , m_frame(frame)
+V8CustomPositionErrorCallback::V8CustomPositionErrorCallback(v8::Local<v8::Object> callback, ScriptExecutionContext* context)
+    : PositionErrorCallback(context)
+    , m_callback(v8::Persistent<v8::Object>::New(callback))
 {
 }
 
@@ -47,7 +48,17 @@ void V8CustomPositionErrorCallback::handleEvent(PositionError* error)
 {
     v8::HandleScope handleScope;
 
-    v8::Handle<v8::Context> context = V8Proxy::context(m_frame.get());
+    // ActiveDOMObject will null our pointer to the ScriptExecutionContext when it goes away.
+    ScriptExecutionContext* scriptContext = scriptExecutionContext();
+    if (!scriptContext)
+        return;
+
+    // The lookup of the proxy will fail if the Frame has been detached.
+    V8Proxy* proxy = V8Proxy::retrieve(scriptContext);
+    if (!proxy)
+        return;
+
+    v8::Handle<v8::Context> context = proxy->context();
     if (context.IsEmpty())
         return;
 
@@ -57,11 +68,11 @@ void V8CustomPositionErrorCallback::handleEvent(PositionError* error)
         toV8(error)
     };
 
-    // Protect the frame until the callback returns.
-    RefPtr<Frame> protector(m_frame);
+    // Protect the script context until the callback returns.
+    RefPtr<ScriptExecutionContext> protector(scriptContext);
 
     bool callbackReturnValue = false;
-    invokeCallback(m_callback, 1, argv, callbackReturnValue, m_frame->document());
+    invokeCallback(m_callback, 1, argv, callbackReturnValue, scriptContext);
 }
 
 } // namespace WebCore
diff --git a/WebCore/bindings/v8/custom/V8CustomPositionErrorCallback.h b/WebCore/bindings/v8/custom/V8CustomPositionErrorCallback.h
index aaf56a7..5211b60 100644
--- a/WebCore/bindings/v8/custom/V8CustomPositionErrorCallback.h
+++ b/WebCore/bindings/v8/custom/V8CustomPositionErrorCallback.h
@@ -27,6 +27,7 @@
 #define V8CustomPositionErrorCallback_h
 
 #include "PositionErrorCallback.h"
+
 #include <v8.h>
 #include <wtf/PassRefPtr.h>
 #include <wtf/RefPtr.h>
@@ -35,23 +36,23 @@ namespace WebCore {
 
 class Frame;
 class PositionError;
+class ScriptExecutionContext;
 
 class V8CustomPositionErrorCallback : public PositionErrorCallback {
 public:
-    static PassRefPtr<V8CustomPositionErrorCallback> create(v8::Local<v8::Value> value, Frame* frame)
+    static PassRefPtr<V8CustomPositionErrorCallback> create(v8::Local<v8::Value> value, ScriptExecutionContext* context)
     {
         ASSERT(value->IsObject());
-        return adoptRef(new V8CustomPositionErrorCallback(value->ToObject(), frame));
+        return adoptRef(new V8CustomPositionErrorCallback(value->ToObject(), context));
     }
     virtual ~V8CustomPositionErrorCallback();
 
     virtual void handleEvent(PositionError*);
 
 private:
-    V8CustomPositionErrorCallback(v8::Local<v8::Object>, Frame*);
+    V8CustomPositionErrorCallback(v8::Local<v8::Object>, ScriptExecutionContext*);
 
     v8::Persistent<v8::Object> m_callback;
-    RefPtr<Frame> m_frame;
 };
 
 } // namespace WebCore
diff --git a/WebCore/bindings/v8/custom/V8CustomSQLStatementErrorCallback.cpp b/WebCore/bindings/v8/custom/V8CustomSQLStatementErrorCallback.cpp
index 3bdc79b..6603344 100644
--- a/WebCore/bindings/v8/custom/V8CustomSQLStatementErrorCallback.cpp
+++ b/WebCore/bindings/v8/custom/V8CustomSQLStatementErrorCallback.cpp
@@ -39,6 +39,7 @@
 #include "V8Proxy.h"
 #include "V8SQLError.h"
 #include "V8SQLTransaction.h"
+#include <wtf/Assertions.h>
 
 namespace WebCore {
 
@@ -52,9 +53,16 @@ bool V8SQLStatementErrorCallback::handleEvent(ScriptExecutionContext* context, S
 
     v8::Context::Scope scope(v8Context);
 
+    v8::Handle<v8::Value> transactionHandle = toV8(transaction);
+    v8::Handle<v8::Value> errorHandle = toV8(error);
+    if (transactionHandle.IsEmpty() || errorHandle.IsEmpty()) {
+        CRASH();
+        return true;
+    }
+
     v8::Handle<v8::Value> argv[] = {
-        toV8(transaction),
-        toV8(error)
+        transactionHandle,
+        errorHandle
     };
 
     // Protect the context until the callback returns.
diff --git a/WebCore/bindings/v8/custom/V8CustomVoidCallback.cpp b/WebCore/bindings/v8/custom/V8CustomVoidCallback.cpp
index bc7bb6c..25e7e0d 100644
--- a/WebCore/bindings/v8/custom/V8CustomVoidCallback.cpp
+++ b/WebCore/bindings/v8/custom/V8CustomVoidCallback.cpp
@@ -40,6 +40,7 @@ namespace WebCore {
 V8CustomVoidCallback::V8CustomVoidCallback(v8::Local<v8::Object> callback, ScriptExecutionContext *context)
     : m_callback(v8::Persistent<v8::Object>::New(callback))
     , m_scriptExecutionContext(context)
+    , m_worldContext(UseCurrentWorld)
 {
 }
 
@@ -52,7 +53,7 @@ void V8CustomVoidCallback::handleEvent()
 {
     v8::HandleScope handleScope;
 
-    v8::Handle<v8::Context> v8Context = toV8Context(m_scriptExecutionContext.get(), WorldContextHandle(UseCurrentWorld));
+    v8::Handle<v8::Context> v8Context = toV8Context(m_scriptExecutionContext.get(), m_worldContext);
     if (v8Context.IsEmpty())
         return;
 
diff --git a/WebCore/bindings/v8/custom/V8CustomVoidCallback.h b/WebCore/bindings/v8/custom/V8CustomVoidCallback.h
index 03a47bc..94bb782 100644
--- a/WebCore/bindings/v8/custom/V8CustomVoidCallback.h
+++ b/WebCore/bindings/v8/custom/V8CustomVoidCallback.h
@@ -32,6 +32,7 @@
 #define V8CustomVoidCallback_h
 
 #include "VoidCallback.h"
+#include "WorldContextHandle.h"
 #include <v8.h>
 #include <wtf/PassRefPtr.h>
 #include <wtf/RefPtr.h>
@@ -56,6 +57,7 @@ private:
 
     v8::Persistent<v8::Object> m_callback;
     RefPtr<ScriptExecutionContext> m_scriptExecutionContext;
+    WorldContextHandle m_worldContext;
 };
 
 // Returns false if callback failed (null, wrong type, or threw exception).
diff --git a/WebCore/bindings/v8/custom/V8DOMWindowCustom.cpp b/WebCore/bindings/v8/custom/V8DOMWindowCustom.cpp
index 4867cfe..25564ee 100644
--- a/WebCore/bindings/v8/custom/V8DOMWindowCustom.cpp
+++ b/WebCore/bindings/v8/custom/V8DOMWindowCustom.cpp
@@ -72,7 +72,7 @@
 #if ENABLE(3D_CANVAS)
 #include "V8ArrayBuffer.h"
 #include "V8Int8Array.h"
-#include "V8FloatArray.h"
+#include "V8Float32Array.h"
 #include "V8Int32Array.h"
 #include "V8Int16Array.h"
 #include "V8Uint8Array.h"
@@ -308,7 +308,7 @@ v8::Handle<v8::Value> V8DOMWindow::WebGLUnsignedIntArrayAccessorGetter(v8::Local
 v8::Handle<v8::Value> V8DOMWindow::WebGLFloatArrayAccessorGetter(v8::Local<v8::String> name, const v8::AccessorInfo& info)
 {
     DOMWindow* window = V8DOMWindow::toNative(info.Holder());
-    return V8DOMWrapper::getConstructor(&V8FloatArray::info, window);
+    return V8DOMWrapper::getConstructor(&V8Float32Array::info, window);
 }
 
 #endif
diff --git a/WebCore/bindings/v8/custom/V8FloatArrayCustom.cpp b/WebCore/bindings/v8/custom/V8Float32ArrayCustom.cpp
index ebc65db..93c5e91 100644
--- a/WebCore/bindings/v8/custom/V8FloatArrayCustom.cpp
+++ b/WebCore/bindings/v8/custom/V8Float32ArrayCustom.cpp
@@ -33,34 +33,34 @@
 #if ENABLE(3D_CANVAS)
 
 #include "ArrayBuffer.h"
-#include "FloatArray.h"
+#include "Float32Array.h"
 
 #include "V8Binding.h"
 #include "V8ArrayBuffer.h"
 #include "V8ArrayBufferViewCustom.h"
-#include "V8FloatArray.h"
+#include "V8Float32Array.h"
 #include "V8Proxy.h"
 
 namespace WebCore {
 
-v8::Handle<v8::Value> V8FloatArray::constructorCallback(const v8::Arguments& args)
+v8::Handle<v8::Value> V8Float32Array::constructorCallback(const v8::Arguments& args)
 {
-    INC_STATS("DOM.FloatArray.Contructor");
+    INC_STATS("DOM.Float32Array.Contructor");
 
-    return constructWebGLArray<FloatArray, float>(args, &info, v8::kExternalFloatArray);
+    return constructWebGLArray<Float32Array, float>(args, &info, v8::kExternalFloatArray);
 }
 
-v8::Handle<v8::Value> V8FloatArray::setCallback(const v8::Arguments& args)
+v8::Handle<v8::Value> V8Float32Array::setCallback(const v8::Arguments& args)
 {
-    INC_STATS("DOM.FloatArray.set()");
-    return setWebGLArrayHelper<FloatArray, V8FloatArray>(args);
+    INC_STATS("DOM.Float32Array.set()");
+    return setWebGLArrayHelper<Float32Array, V8Float32Array>(args);
 }
 
-v8::Handle<v8::Value> toV8(FloatArray* impl)
+v8::Handle<v8::Value> toV8(Float32Array* impl)
 {
     if (!impl)
         return v8::Null();
-    v8::Handle<v8::Object> wrapper = V8FloatArray::wrap(impl);
+    v8::Handle<v8::Object> wrapper = V8Float32Array::wrap(impl);
     if (!wrapper.IsEmpty())
         wrapper->SetIndexedPropertiesToExternalArrayData(impl->baseAddress(), v8::kExternalFloatArray, impl->length());
     return wrapper;
diff --git a/WebCore/bindings/v8/custom/V8GeolocationCustom.cpp b/WebCore/bindings/v8/custom/V8GeolocationCustom.cpp
index 7173be1..649c45f 100644
--- a/WebCore/bindings/v8/custom/V8GeolocationCustom.cpp
+++ b/WebCore/bindings/v8/custom/V8GeolocationCustom.cpp
@@ -26,8 +26,8 @@
 #include "config.h"
 #include "V8Geolocation.h"
 
+#include "Frame.h"
 #include "Geolocation.h"
-
 #include "V8Binding.h"
 #include "V8CustomPositionCallback.h"
 #include "V8CustomPositionErrorCallback.h"
@@ -56,8 +56,7 @@ static PassRefPtr<PositionCallback> createPositionCallback(v8::Local<v8::Value>
         return 0;
     }
 
-    Frame* frame = V8Proxy::retrieveFrameForCurrentContext();
-    return V8CustomPositionCallback::create(value, frame);
+    return V8CustomPositionCallback::create(value, getScriptExecutionContext());
 }
 
 static PassRefPtr<PositionErrorCallback> createPositionErrorCallback(v8::Local<v8::Value> value, bool& succeeded)
@@ -75,8 +74,7 @@ static PassRefPtr<PositionErrorCallback> createPositionErrorCallback(v8::Local<v
         return 0;
     }
 
-    Frame* frame = V8Proxy::retrieveFrameForCurrentContext();
-    return V8CustomPositionErrorCallback::create(value, frame);
+    return V8CustomPositionErrorCallback::create(value, getScriptExecutionContext());
 }
 
 static PassRefPtr<PositionOptions> createPositionOptions(v8::Local<v8::Value> value, bool& succeeded)
diff --git a/WebCore/bindings/v8/custom/V8HTMLCanvasElementCustom.cpp b/WebCore/bindings/v8/custom/V8HTMLCanvasElementCustom.cpp
index 66e326c..d2f8c96 100644
--- a/WebCore/bindings/v8/custom/V8HTMLCanvasElementCustom.cpp
+++ b/WebCore/bindings/v8/custom/V8HTMLCanvasElementCustom.cpp
@@ -105,7 +105,7 @@ v8::Handle<v8::Value> V8HTMLCanvasElement::toDataURLCallback(const v8::Arguments
     HTMLCanvasElement* canvas = V8HTMLCanvasElement::toNative(holder);
     String type = toWebCoreString(args[0]);
     ExceptionCode ec = 0;
-    String result = canvas->toDataURL(type, quality, ec);
+    String result = canvas->toDataURL(type, &quality, ec);
     V8Proxy::setDOMException(ec);
     return v8StringOrUndefined(result);
 }
diff --git a/WebCore/bindings/v8/custom/V8HTMLDocumentCustom.cpp b/WebCore/bindings/v8/custom/V8HTMLDocumentCustom.cpp
index 86f2eb5..e6f1b8f 100644
--- a/WebCore/bindings/v8/custom/V8HTMLDocumentCustom.cpp
+++ b/WebCore/bindings/v8/custom/V8HTMLDocumentCustom.cpp
@@ -49,48 +49,37 @@
 
 namespace WebCore {
 
-v8::Handle<v8::Boolean> V8HTMLDocument::namedPropertyDeleter(v8::Local<v8::String> name, const v8::AccessorInfo& info)
+v8::Local<v8::Object> V8HTMLDocument::WrapInShadowObject(v8::Local<v8::Object> wrapper, Node* impl)
 {
-    // Only handle document.all.  Insert the marker object into the
-    // shadow internal field to signal that document.all is no longer
-    // shadowed.
-    AtomicString key = v8StringToAtomicWebCoreString(name);
-    DEFINE_STATIC_LOCAL(const AtomicString, all, ("all"));
-    if (key != all)
-        return deletionNotHandledByInterceptor();
-
-    ASSERT(info.Holder()->InternalFieldCount() == V8HTMLDocument::internalFieldCount);
-    v8::Local<v8::Value> marker = info.Holder()->GetInternalField(V8HTMLDocument::markerIndex);
-    info.Holder()->SetInternalField(V8HTMLDocument::shadowIndex, marker);
-    return v8::True();
-}
-
-v8::Handle<v8::Value> V8HTMLDocument::namedPropertyGetter(v8::Local<v8::String> name, const v8::AccessorInfo& info)
-{
-    INC_STATS("DOM.HTMLDocument.NamedPropertyGetter");
-    AtomicString key = v8StringToAtomicWebCoreString(name);
-
-    // Special case for document.all.  If the value in the shadow
-    // internal field is not the marker object, then document.all has
-    // been temporarily shadowed and we return the value.
-    DEFINE_STATIC_LOCAL(const AtomicString, all, ("all"));
-    if (key == all) {
-        ASSERT(info.Holder()->InternalFieldCount() == V8HTMLDocument::internalFieldCount);
-        v8::Local<v8::Value> marker = info.Holder()->GetInternalField(V8HTMLDocument::markerIndex);
-        v8::Local<v8::Value> value = info.Holder()->GetInternalField(V8HTMLDocument::shadowIndex);
-        if (marker != value)
-            return value;
+    DEFINE_STATIC_LOCAL(v8::Persistent<v8::Function>, shadowConstructor, ());
+    if (shadowConstructor.IsEmpty()) {
+        v8::Local<v8::FunctionTemplate> shadowTemplate = v8::FunctionTemplate::New();
+        if (shadowTemplate.IsEmpty())
+            return v8::Local<v8::Object>();
+        shadowTemplate->SetClassName(v8::String::New("HTMLDocument"));
+        shadowTemplate->Inherit(V8HTMLDocument::GetTemplate());
+        shadowTemplate->InstanceTemplate()->SetInternalFieldCount(V8HTMLDocument::internalFieldCount);
+        shadowConstructor = v8::Persistent<v8::Function>::New(shadowTemplate->GetFunction());
+        if (shadowConstructor.IsEmpty())
+            return v8::Local<v8::Object>();
     }
 
-    HTMLDocument* htmlDocument = V8HTMLDocument::toNative(info.Holder());
+    ASSERT(!shadowConstructor.IsEmpty());
+    v8::Local<v8::Object> shadow = shadowConstructor->NewInstance();
+    if (shadow.IsEmpty())
+        return v8::Local<v8::Object>();
+    V8DOMWrapper::setDOMWrapper(shadow, &V8HTMLDocument::info, impl);
+    shadow->SetPrototype(wrapper);
+    return shadow;
+}
 
-    // Fast case for named elements that are not there.
-    if (!htmlDocument->hasNamedItem(key.impl()) && !htmlDocument->hasExtraNamedItem(key.impl()))
-        return v8::Handle<v8::Value>();
+v8::Handle<v8::Value> V8HTMLDocument::GetNamedProperty(HTMLDocument* htmlDocument, const AtomicString& key)
+{
+    ASSERT(htmlDocument->hasNamedItem(key.impl()) || htmlDocument->hasExtraNamedItem(key.impl()));
 
     RefPtr<HTMLCollection> items = htmlDocument->documentNamedItems(key);
     if (!items->length())
-        return notHandledByInterceptor();
+        return v8::Handle<v8::Value>();
 
     if (items->length() == 1) {
         Node* node = items->firstItem();
@@ -104,13 +93,6 @@ v8::Handle<v8::Value> V8HTMLDocument::namedPropertyGetter(v8::Local<v8::String>
     return toV8(items.release());
 }
 
-v8::Handle<v8::Value> V8HTMLDocument::indexedPropertyGetter(uint32_t index, const v8::AccessorInfo &info) 
-{
-    INC_STATS("DOM.HTMLDocument.IndexedPropertyGetter");
-    v8::Local<v8::Integer> indexV8 = v8::Integer::NewFromUnsigned(index);
-    return namedPropertyGetter(indexV8->ToString(), info);
-}
-
 // HTMLDocument ----------------------------------------------------------------
 
 // Concatenates "args" to a string. If args is empty, returns empty string.
@@ -193,10 +175,8 @@ v8::Handle<v8::Value> V8HTMLDocument::allAccessorGetter(v8::Local<v8::String> na
 
 void V8HTMLDocument::allAccessorSetter(v8::Local<v8::String> name, v8::Local<v8::Value> value, const v8::AccessorInfo& info)
 {
-    INC_STATS("DOM.HTMLDocument.all._set");
-    v8::Handle<v8::Object> holder = info.Holder();
-    ASSERT(info.Holder()->InternalFieldCount() == V8HTMLDocument::internalFieldCount);
-    info.Holder()->SetInternalField(V8HTMLDocument::shadowIndex, value);
+    // Just emulate a normal JS behaviour---install a property on this.
+    info.This()->ForceSet(name, value);
 }
 
 v8::Handle<v8::Value> toV8(HTMLDocument* impl, bool forceNewObject)
@@ -210,12 +190,6 @@ v8::Handle<v8::Value> toV8(HTMLDocument* impl, bool forceNewObject)
         if (V8Proxy* proxy = V8Proxy::retrieve(impl->frame()))
             proxy->windowShell()->updateDocumentWrapper(wrapper);
     }
-    // Create marker object and insert it in two internal fields.
-    // This is used to implement temporary shadowing of document.all.
-    ASSERT(wrapper->InternalFieldCount() == V8HTMLDocument::internalFieldCount);
-    v8::Local<v8::Object> marker = v8::Object::New();
-    wrapper->SetInternalField(V8HTMLDocument::markerIndex, marker);
-    wrapper->SetInternalField(V8HTMLDocument::shadowIndex, marker);
     return wrapper;
 }
 
diff --git a/WebCore/bindings/v8/custom/V8NamedNodesCollection.cpp b/WebCore/bindings/v8/custom/V8NamedNodesCollection.cpp
index 905b23d..d9da174 100644
--- a/WebCore/bindings/v8/custom/V8NamedNodesCollection.cpp
+++ b/WebCore/bindings/v8/custom/V8NamedNodesCollection.cpp
@@ -46,7 +46,7 @@ Node* V8NamedNodesCollection::itemWithName(const AtomicString& id) const
 {
     for (unsigned i = 0; i < m_nodes.size(); ++i) {
         Node* node = m_nodes[i].get();
-        if (node->hasAttributes() && node->attributes()->id() == id)
+        if (node->hasID() && static_cast<Element*>(node)->getIdAttribute() == id)
             return node;
     }
     return 0;
diff --git a/WebCore/bindings/v8/custom/V8NodeListCustom.cpp b/WebCore/bindings/v8/custom/V8NodeListCustom.cpp
index 20a5471..8cc3983 100644
--- a/WebCore/bindings/v8/custom/V8NodeListCustom.cpp
+++ b/WebCore/bindings/v8/custom/V8NodeListCustom.cpp
@@ -45,7 +45,7 @@ v8::Handle<v8::Value> V8NodeList::namedPropertyGetter(v8::Local<v8::String> name
 {
     INC_STATS("DOM.NodeList.NamedPropertyGetter");
     NodeList* list = V8NodeList::toNative(info.Holder());
-    String key = toWebCoreString(name);
+    AtomicString key = v8ValueToAtomicWebCoreString(name);
 
     // Length property cannot be overridden.
     DEFINE_STATIC_LOCAL(const AtomicString, length, ("length"));
diff --git a/WebCore/bindings/v8/custom/V8PopStateEventCustom.cpp b/WebCore/bindings/v8/custom/V8PopStateEventCustom.cpp
index 51a57c0..58f34bf 100644
--- a/WebCore/bindings/v8/custom/V8PopStateEventCustom.cpp
+++ b/WebCore/bindings/v8/custom/V8PopStateEventCustom.cpp
@@ -35,8 +35,6 @@
 #include "SerializedScriptValue.h"
 #include "V8Proxy.h"
 
-#include <v8.h>
-
 namespace WebCore {
 
 v8::Handle<v8::Value> V8PopStateEvent::stateAccessorGetter(v8::Local<v8::String> name, const v8::AccessorInfo& info)
diff --git a/WebCore/bindings/v8/custom/V8StorageCustom.cpp b/WebCore/bindings/v8/custom/V8StorageCustom.cpp
index 70d8a09..d0a0d92 100755
--- a/WebCore/bindings/v8/custom/V8StorageCustom.cpp
+++ b/WebCore/bindings/v8/custom/V8StorageCustom.cpp
@@ -79,6 +79,19 @@ v8::Handle<v8::Value> V8Storage::namedPropertyGetter(v8::Local<v8::String> name,
     return storageGetter(name, info);
 }
 
+v8::Handle<v8::Integer> V8Storage::namedPropertyQuery(v8::Local<v8::String> v8Name, const v8::AccessorInfo& info)
+{
+    INC_STATS("DOM.Storage.NamedPropertyQuery");
+
+    Storage* storage = V8Storage::toNative(info.Holder());
+    String name = toWebCoreString(v8Name);
+
+    if (storage->contains(name) && name != "length")
+        return v8::Integer::New(v8::None);
+
+    return v8::Handle<v8::Integer>();
+}
+
 static v8::Handle<v8::Value> storageSetter(v8::Local<v8::String> v8Name, v8::Local<v8::Value> v8Value, const v8::AccessorInfo& info)
 {
     Storage* storage = V8Storage::toNative(info.Holder());
diff --git a/WebCore/bindings/v8/custom/V8WebGLRenderingContextCustom.cpp b/WebCore/bindings/v8/custom/V8WebGLRenderingContextCustom.cpp
index 7a031b1..5da4b3e 100644
--- a/WebCore/bindings/v8/custom/V8WebGLRenderingContextCustom.cpp
+++ b/WebCore/bindings/v8/custom/V8WebGLRenderingContextCustom.cpp
@@ -44,7 +44,7 @@
 #include "V8ArrayBufferView.h"
 #include "V8WebGLBuffer.h"
 #include "V8Int8Array.h"
-#include "V8FloatArray.h"
+#include "V8Float32Array.h"
 #include "V8WebGLFramebuffer.h"
 #include "V8Int32Array.h"
 #include "V8WebGLProgram.h"
@@ -392,21 +392,21 @@ static v8::Handle<v8::Value> vertexAttribAndUniformHelperf(const v8::Arguments&
                                                            FunctionToCall functionToCall) {
     // Forms:
     // * glUniform1fv(WebGLUniformLocation location, Array data);
-    // * glUniform1fv(WebGLUniformLocation location, FloatArray data);
+    // * glUniform1fv(WebGLUniformLocation location, Float32Array data);
     // * glUniform2fv(WebGLUniformLocation location, Array data);
-    // * glUniform2fv(WebGLUniformLocation location, FloatArray data);
+    // * glUniform2fv(WebGLUniformLocation location, Float32Array data);
     // * glUniform3fv(WebGLUniformLocation location, Array data);
-    // * glUniform3fv(WebGLUniformLocation location, FloatArray data);
+    // * glUniform3fv(WebGLUniformLocation location, Float32Array data);
     // * glUniform4fv(WebGLUniformLocation location, Array data);
-    // * glUniform4fv(WebGLUniformLocation location, FloatArray data);
+    // * glUniform4fv(WebGLUniformLocation location, Float32Array data);
     // * glVertexAttrib1fv(GLint index, Array data);
-    // * glVertexAttrib1fv(GLint index, FloatArray data);
+    // * glVertexAttrib1fv(GLint index, Float32Array data);
     // * glVertexAttrib2fv(GLint index, Array data);
-    // * glVertexAttrib2fv(GLint index, FloatArray data);
+    // * glVertexAttrib2fv(GLint index, Float32Array data);
     // * glVertexAttrib3fv(GLint index, Array data);
-    // * glVertexAttrib3fv(GLint index, FloatArray data);
+    // * glVertexAttrib3fv(GLint index, Float32Array data);
     // * glVertexAttrib4fv(GLint index, Array data);
-    // * glVertexAttrib4fv(GLint index, FloatArray data);
+    // * glVertexAttrib4fv(GLint index, Float32Array data);
 
     if (args.Length() != 2) {
         V8Proxy::setDOMException(SYNTAX_ERR);
@@ -424,8 +424,8 @@ static v8::Handle<v8::Value> vertexAttribAndUniformHelperf(const v8::Arguments&
 
     WebGLRenderingContext* context = V8WebGLRenderingContext::toNative(args.Holder());
 
-    if (V8FloatArray::HasInstance(args[1])) {
-        FloatArray* array = V8FloatArray::toNative(args[1]->ToObject());
+    if (V8Float32Array::HasInstance(args[1])) {
+        Float32Array* array = V8Float32Array::toNative(args[1]->ToObject());
         ASSERT(array != NULL);
         ExceptionCode ec = 0;
         switch (functionToCall) {
@@ -592,13 +592,13 @@ static v8::Handle<v8::Value> uniformMatrixHelper(const v8::Arguments& args,
 {
     // Forms:
     // * glUniformMatrix2fv(GLint location, GLboolean transpose, Array data);
-    // * glUniformMatrix2fv(GLint location, GLboolean transpose, FloatArray data);
+    // * glUniformMatrix2fv(GLint location, GLboolean transpose, Float32Array data);
     // * glUniformMatrix3fv(GLint location, GLboolean transpose, Array data);
-    // * glUniformMatrix3fv(GLint location, GLboolean transpose, FloatArray data);
+    // * glUniformMatrix3fv(GLint location, GLboolean transpose, Float32Array data);
     // * glUniformMatrix4fv(GLint location, GLboolean transpose, Array data);
-    // * glUniformMatrix4fv(GLint location, GLboolean transpose, FloatArray data);
+    // * glUniformMatrix4fv(GLint location, GLboolean transpose, Float32Array data);
     //
-    // FIXME: need to change to accept FloatArray as well.
+    // FIXME: need to change to accept Float32Array as well.
     if (args.Length() != 3) {
         V8Proxy::setDOMException(SYNTAX_ERR);
         return notHandledByInterceptor();
@@ -610,8 +610,8 @@ static v8::Handle<v8::Value> uniformMatrixHelper(const v8::Arguments& args,
     WebGLUniformLocation* location = toWebGLUniformLocation(args[0], ok);
     
     bool transpose = args[1]->BooleanValue();
-    if (V8FloatArray::HasInstance(args[2])) {
-        FloatArray* array = V8FloatArray::toNative(args[2]->ToObject());
+    if (V8Float32Array::HasInstance(args[2])) {
+        Float32Array* array = V8Float32Array::toNative(args[2]->ToObject());
         ASSERT(array != NULL);
         ExceptionCode ec = 0;
         switch (matrixSize) {