diff options
Diffstat (limited to 'src/3rdparty/webkit/WebCore/bindings/js')
164 files changed, 6745 insertions, 1673 deletions
diff --git a/src/3rdparty/webkit/WebCore/bindings/js/DOMObjectWithSVGContext.h b/src/3rdparty/webkit/WebCore/bindings/js/DOMObjectWithSVGContext.h index 570548dc2..3d435cb2f 100644 --- a/src/3rdparty/webkit/WebCore/bindings/js/DOMObjectWithSVGContext.h +++ b/src/3rdparty/webkit/WebCore/bindings/js/DOMObjectWithSVGContext.h @@ -40,7 +40,7 @@ namespace WebCore { SVGElement* context() const { return m_context.get(); } protected: - DOMObjectWithSVGContext(PassRefPtr<JSC::Structure> structure, JSDOMGlobalObject*, SVGElement* context) + DOMObjectWithSVGContext(NonNullPassRefPtr<JSC::Structure> structure, JSDOMGlobalObject*, SVGElement* context) : DOMObject(structure) , m_context(context) { diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSAbstractWorkerCustom.cpp b/src/3rdparty/webkit/WebCore/bindings/js/JSAbstractWorkerCustom.cpp index 314641344..6eca7bdbe 100644 --- a/src/3rdparty/webkit/WebCore/bindings/js/JSAbstractWorkerCustom.cpp +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSAbstractWorkerCustom.cpp @@ -1,5 +1,6 @@ /* * Copyright (C) 2009 Google Inc. All rights reserved. + * 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 @@ -43,42 +44,23 @@ using namespace JSC; namespace WebCore { -void JSAbstractWorker::mark() -{ - Base::mark(); - - markIfNotNull(m_impl->onerror()); - - typedef AbstractWorker::EventListenersMap EventListenersMap; - typedef AbstractWorker::ListenerVector ListenerVector; - EventListenersMap& eventListeners = m_impl->eventListeners(); - for (EventListenersMap::iterator mapIter = eventListeners.begin(); mapIter != eventListeners.end(); ++mapIter) { - for (ListenerVector::iterator vecIter = mapIter->second.begin(); vecIter != mapIter->second.end(); ++vecIter) - (*vecIter)->markJSFunction(); - } -} - JSValue JSAbstractWorker::addEventListener(ExecState* exec, const ArgList& args) { - JSDOMGlobalObject* globalObject = toJSDOMGlobalObject(impl()->scriptExecutionContext()); - if (!globalObject) + JSValue listener = args.at(1); + if (!listener.isObject()) return jsUndefined(); - RefPtr<JSEventListener> listener = globalObject->findOrCreateJSEventListener(args.at(1)); - if (!listener) - return jsUndefined(); - impl()->addEventListener(args.at(0).toString(exec), listener.release(), args.at(2).toBoolean(exec)); + + impl()->addEventListener(args.at(0).toString(exec), JSEventListener::create(asObject(listener), false, currentWorld(exec)), args.at(2).toBoolean(exec)); return jsUndefined(); } JSValue JSAbstractWorker::removeEventListener(ExecState* exec, const ArgList& args) { - JSDOMGlobalObject* globalObject = toJSDOMGlobalObject(impl()->scriptExecutionContext()); - if (!globalObject) + JSValue listener = args.at(1); + if (!listener.isObject()) return jsUndefined(); - JSEventListener* listener = globalObject->findJSEventListener(args.at(1)); - if (!listener) - return jsUndefined(); - impl()->removeEventListener(args.at(0).toString(exec), listener, args.at(2).toBoolean(exec)); + + impl()->removeEventListener(args.at(0).toString(exec), JSEventListener::create(asObject(listener), false, currentWorld(exec)).get(), args.at(2).toBoolean(exec)); return jsUndefined(); } diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSAttrCustom.cpp b/src/3rdparty/webkit/WebCore/bindings/js/JSAttrCustom.cpp index abd5ad5fc..14457c4db 100644 --- a/src/3rdparty/webkit/WebCore/bindings/js/JSAttrCustom.cpp +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSAttrCustom.cpp @@ -1,5 +1,5 @@ /* - * Copyright (C) 2007, 2008 Apple Inc. All rights reserved. + * Copyright (C) 2007, 2008, 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 @@ -48,7 +48,8 @@ void JSAttr::setValue(ExecState* exec, JSValue value) Element* ownerElement = imp->ownerElement(); if (ownerElement && (ownerElement->hasTagName(iframeTag) || ownerElement->hasTagName(frameTag))) { if (equalIgnoringCase(imp->name(), "src") && protocolIsJavaScript(deprecatedParseURL(attrValue))) { - if (!checkNodeSecurity(exec, static_cast<HTMLFrameElementBase*>(ownerElement)->contentDocument())) + Document* contentDocument = static_cast<HTMLFrameElementBase*>(ownerElement)->contentDocument(); + if (contentDocument && !checkNodeSecurity(exec, contentDocument)) return; } } @@ -58,4 +59,16 @@ void JSAttr::setValue(ExecState* exec, JSValue value) setDOMException(exec, ec); } +void JSAttr::markChildren(MarkStack& markStack) +{ + Base::markChildren(markStack); + + // Mark the element so that this will work to access the attribute even if the last + // other reference goes away. + if (Element* element = impl()->ownerElement()) { + if (JSNode* wrapper = getCachedDOMNodeWrapper(element->document(), element)) + markStack.append(wrapper); + } +} + } // namespace WebCore diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSAudioConstructor.cpp b/src/3rdparty/webkit/WebCore/bindings/js/JSAudioConstructor.cpp index 87a388073..174cc11f5 100644 --- a/src/3rdparty/webkit/WebCore/bindings/js/JSAudioConstructor.cpp +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSAudioConstructor.cpp @@ -34,6 +34,7 @@ #include "JSHTMLAudioElement.h" #include "ScriptExecutionContext.h" #include "Text.h" +#include <runtime/Error.h> using namespace JSC; diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSBindingsAllInOne.cpp b/src/3rdparty/webkit/WebCore/bindings/js/JSBindingsAllInOne.cpp new file mode 100644 index 000000000..f08303a0c --- /dev/null +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSBindingsAllInOne.cpp @@ -0,0 +1,150 @@ +/* + * 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 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 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. + */ + +// This all-in-one cpp file cuts down on template bloat to allow us to build our Windows release build. + +#include "GCController.cpp" +#include "JSAbstractWorkerCustom.cpp" +#include "JSAttrCustom.cpp" +#include "JSAudioConstructor.cpp" +#include "JSCDATASectionCustom.cpp" +#include "JSCSSRuleCustom.cpp" +#include "JSCSSRuleListCustom.cpp" +#include "JSCSSStyleDeclarationCustom.cpp" +#include "JSCSSValueCustom.cpp" +#include "JSCallbackData.cpp" +#include "JSCanvasRenderingContext2DCustom.cpp" +#include "JSCanvasRenderingContextCustom.cpp" +#include "JSClipboardCustom.cpp" +#include "JSConsoleCustom.cpp" +#include "JSCoordinatesCustom.cpp" +#include "JSCustomSQLStatementCallback.cpp" +#include "JSCustomSQLStatementErrorCallback.cpp" +#include "JSCustomSQLTransactionCallback.cpp" +#include "JSCustomSQLTransactionErrorCallback.cpp" +#include "JSCustomVoidCallback.cpp" +#include "JSCustomXPathNSResolver.cpp" +#include "JSDOMApplicationCacheCustom.cpp" +#include "JSDOMBinding.cpp" +#include "JSDOMGlobalObject.cpp" +#include "JSDOMWindowBase.cpp" +#include "JSDOMWindowCustom.cpp" +#include "JSDOMWindowShell.cpp" +#include "JSDataGridColumnListCustom.cpp" +#include "JSDataGridDataSource.cpp" +#include "JSDatabaseCustom.cpp" +#include "JSDedicatedWorkerContextCustom.cpp" +#include "JSDesktopNotificationsCustom.cpp" +#include "JSDocumentCustom.cpp" +#include "JSDocumentFragmentCustom.cpp" +#include "JSElementCustom.cpp" +#include "JSEventCustom.cpp" +#include "JSEventListener.cpp" +#include "JSEventSourceConstructor.cpp" +#include "JSEventSourceCustom.cpp" +#include "JSEventTarget.cpp" +#include "JSExceptionBase.cpp" +#include "JSHTMLAllCollectionCustom.cpp" +#include "JSHTMLAppletElementCustom.cpp" +#include "JSHTMLCanvasElementCustom.cpp" +#include "JSHTMLCollectionCustom.cpp" +#include "JSHTMLDataGridElementCustom.cpp" +#include "JSHTMLDocumentCustom.cpp" +#include "JSHTMLElementCustom.cpp" +#include "JSHTMLEmbedElementCustom.cpp" +#include "JSHTMLFormElementCustom.cpp" +#include "JSHTMLFrameElementCustom.cpp" +#include "JSHTMLFrameSetElementCustom.cpp" +#include "JSHTMLIFrameElementCustom.cpp" +#include "JSHTMLInputElementCustom.cpp" +#include "JSHTMLObjectElementCustom.cpp" +#include "JSHTMLOptionsCollectionCustom.cpp" +#include "JSHTMLSelectElementCustom.cpp" +#include "JSHistoryCustom.cpp" +#include "JSImageConstructor.cpp" +#include "JSImageDataCustom.cpp" +#include "JSInspectedObjectWrapper.cpp" +#include "JSInspectorBackendCustom.cpp" +#include "JSJavaScriptCallFrameCustom.cpp" +#include "JSLazyEventListener.cpp" +#include "JSLocationCustom.cpp" +#include "JSMessageChannelConstructor.cpp" +#include "JSMessageChannelCustom.cpp" +#include "JSMessageEventCustom.cpp" +#include "JSMessagePortCustom.cpp" +#include "JSMimeTypeArrayCustom.cpp" +#include "JSNamedNodeMapCustom.cpp" +#include "JSNavigatorCustom.cpp" +#include "JSNodeCustom.cpp" +#include "JSNodeFilterCondition.cpp" +#include "JSNodeFilterCustom.cpp" +#include "JSNodeIteratorCustom.cpp" +#include "JSNodeListCustom.cpp" +#include "JSOptionConstructor.cpp" +#include "JSPluginArrayCustom.cpp" +#include "JSPluginCustom.cpp" +#include "JSPluginElementFunctions.cpp" +#include "JSQuarantinedObjectWrapper.cpp" +#include "JSSQLResultSetRowListCustom.cpp" +#include "JSSQLTransactionCustom.cpp" +#include "JSSVGElementInstanceCustom.cpp" +#include "JSSVGLengthCustom.cpp" +#include "JSSVGMatrixCustom.cpp" +#include "JSSVGPathSegCustom.cpp" +#include "JSSVGPathSegListCustom.cpp" +#include "JSSVGPointListCustom.cpp" +#include "JSSharedWorkerConstructor.cpp" +#include "JSSharedWorkerCustom.cpp" +#include "JSStorageCustom.cpp" +#include "JSStyleSheetCustom.cpp" +#include "JSStyleSheetListCustom.cpp" +#include "JSTextCustom.cpp" +#include "JSTreeWalkerCustom.cpp" +#include "JSWebKitCSSMatrixConstructor.cpp" +#include "JSWebKitPointConstructor.cpp" +#include "JSWebSocketConstructor.cpp" +#include "JSWebSocketCustom.cpp" +#include "JSWorkerConstructor.cpp" +#include "JSWorkerContextBase.cpp" +#include "JSWorkerContextCustom.cpp" +#include "JSWorkerCustom.cpp" +#include "JSXMLHttpRequestConstructor.cpp" +#include "JSXMLHttpRequestCustom.cpp" +#include "JSXMLHttpRequestUploadCustom.cpp" +#include "JSXSLTProcessorConstructor.cpp" +#include "JSXSLTProcessorCustom.cpp" +#include "ScheduledAction.cpp" +#include "ScriptArray.cpp" +#include "ScriptCachedFrameData.cpp" +#include "ScriptCallFrame.cpp" +#include "ScriptCallStack.cpp" +#include "ScriptController.cpp" +#include "ScriptControllerWin.cpp" +#include "ScriptEventListener.cpp" +#include "ScriptFunctionCall.cpp" +#include "ScriptObjectQuarantine.cpp" +#include "ScriptState.cpp" +#include "SerializedScriptValue.cpp" +#include "WorkerScriptController.cpp" diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSCSSRuleListCustom.cpp b/src/3rdparty/webkit/WebCore/bindings/js/JSCSSRuleListCustom.cpp new file mode 100644 index 000000000..be3a9a2d6 --- /dev/null +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSCSSRuleListCustom.cpp @@ -0,0 +1,47 @@ +/* + * Copyright (C) 2009 Apple Inc. All right 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" +#include "JSCSSRuleList.h" + +#include "CSSRuleList.h" + +using namespace JSC; + +namespace WebCore { + +void JSCSSRuleList::markChildren(MarkStack& markStack) +{ + Base::markChildren(markStack); + + CSSRuleList* list = impl(); + JSGlobalData& globalData = *Heap::heap(this)->globalData(); + + unsigned length = list->length(); + for (unsigned i = 0; i < length; ++i) + markDOMObjectWrapper(markStack, globalData, list->item(i)); +} + +} diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSCSSStyleDeclarationCustom.cpp b/src/3rdparty/webkit/WebCore/bindings/js/JSCSSStyleDeclarationCustom.cpp index 280ec937f..4a137d36f 100644 --- a/src/3rdparty/webkit/WebCore/bindings/js/JSCSSStyleDeclarationCustom.cpp +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSCSSStyleDeclarationCustom.cpp @@ -1,5 +1,5 @@ /* - * Copyright (C) 2007, 2008 Apple Inc. All rights reserved. + * Copyright (C) 2007, 2008, 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 @@ -27,8 +27,8 @@ #include "JSCSSStyleDeclarationCustom.h" #include "AtomicString.h" +#include "CSSMutableStyleDeclaration.h" #include "CSSPrimitiveValue.h" -#include "CSSStyleDeclaration.h" #include "CSSValue.h" #include "PlatformString.h" #include <runtime/StringObjectThatMasqueradesAsUndefined.h> @@ -40,6 +40,21 @@ using namespace WTF; namespace WebCore { +void JSCSSStyleDeclaration::markChildren(MarkStack& markStack) +{ + Base::markChildren(markStack); + + CSSStyleDeclaration* declaration = impl(); + JSGlobalData& globalData = *Heap::heap(this)->globalData(); + + if (declaration->isMutableStyleDeclaration()) { + CSSMutableStyleDeclaration* mutableDeclaration = static_cast<CSSMutableStyleDeclaration*>(declaration); + CSSMutableStyleDeclaration::const_iterator end = mutableDeclaration->end(); + for (CSSMutableStyleDeclaration::const_iterator it = mutableDeclaration->begin(); it != end; ++it) + markDOMObjectWrapper(markStack, globalData, it->value()); + } +} + // Check for a CSS prefix. // Passed prefix is all lowercase. // First character of the prefix within the property name may be upper or lowercase. diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSCallbackData.cpp b/src/3rdparty/webkit/WebCore/bindings/js/JSCallbackData.cpp new file mode 100644 index 000000000..38292c7b6 --- /dev/null +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSCallbackData.cpp @@ -0,0 +1,82 @@ +/* + * Copyright (C) 2007, 2008, 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. + * 3. Neither the name of Apple Computer, Inc. ("Apple") nor the names of + * its contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "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 OR ITS 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" +#include "JSCallbackData.h" + +#include "Document.h" +#include "JSDOMBinding.h" + +using namespace JSC; + +namespace WebCore { + +void JSCallbackData::deleteData(void* context) +{ + delete static_cast<JSCallbackData*>(context); +} + +JSValue JSCallbackData::invokeCallback(MarkedArgumentBuffer& args, bool* raisedException) +{ + ASSERT(callback()); + ASSERT(globalObject()); + + ExecState* exec = globalObject()->globalExec(); + + JSValue function; + { + // Switch worlds, just in case handleEvent is a getter and causes JS execution! + EnterDOMWrapperWorld worldEntry(exec, m_isolatedWorld.get()); + function = callback()->get(exec, Identifier(exec, "handleEvent")); + } + CallData callData; + CallType callType = function.getCallData(callData); + if (callType == CallTypeNone) { + callType = callback()->getCallData(callData); + if (callType == CallTypeNone) + return JSValue(); + function = callback(); + } + + globalObject()->globalData()->timeoutChecker.start(); + JSValue result = callInWorld(exec, function, callType, callData, callback(), args, m_isolatedWorld.get()); + globalObject()->globalData()->timeoutChecker.stop(); + + Document::updateStyleForAllDocuments(); + + if (exec->hadException()) { + reportCurrentException(exec); + if (raisedException) + *raisedException = true; + return result; + } + + return result; +} + +} // namespace WebCore diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSCallbackData.h b/src/3rdparty/webkit/WebCore/bindings/js/JSCallbackData.h new file mode 100644 index 000000000..5c867019c --- /dev/null +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSCallbackData.h @@ -0,0 +1,73 @@ +/* + * Copyright (C) 2007, 2008, 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. + * 3. Neither the name of Apple Computer, Inc. ("Apple") nor the names of + * its contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "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 OR ITS 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. + */ + +#ifndef JSCallbackData_h +#define JSCallbackData_h + +#include "JSDOMBinding.h" +#include "JSDOMGlobalObject.h" +#include <runtime/JSObject.h> +#include <runtime/Protect.h> +#include <wtf/Threading.h> + +namespace WebCore { + +// We have to clean up this data on the main thread because unprotecting a +// JSObject on a non-main thread without synchronization would corrupt the heap +// (and synchronization would be slow). + +class JSCallbackData { +public: + static void deleteData(void*); + + JSCallbackData(JSC::JSObject* callback, JSDOMGlobalObject* globalObject) + : m_callback(callback) + , m_globalObject(globalObject) + , m_isolatedWorld(currentWorld(globalObject->globalExec())) + { + } + + ~JSCallbackData() + { + ASSERT(isMainThread()); + } + + JSC::JSObject* callback() { return m_callback.get(); } + JSDOMGlobalObject* globalObject() { return m_globalObject.get(); } + + JSC::JSValue invokeCallback(JSC::MarkedArgumentBuffer&, bool* raisedException = 0); + +private: + JSC::ProtectedPtr<JSC::JSObject> m_callback; + JSC::ProtectedPtr<JSDOMGlobalObject> m_globalObject; + RefPtr<DOMWrapperWorld> m_isolatedWorld; +}; + +} // namespace WebCore + +#endif // JSCallbackData_h diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSCanvasArrayBufferConstructor.cpp b/src/3rdparty/webkit/WebCore/bindings/js/JSCanvasArrayBufferConstructor.cpp new file mode 100644 index 000000000..93d53cae8 --- /dev/null +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSCanvasArrayBufferConstructor.cpp @@ -0,0 +1,70 @@ +/* + * 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 "JSCanvasArrayBufferConstructor.h" + +#include "Document.h" +#include "CanvasArrayBuffer.h" +#include "JSCanvasArrayBuffer.h" + +namespace WebCore { + +using namespace JSC; + +const ClassInfo JSCanvasArrayBufferConstructor::s_info = { "CanvasArrayBufferConstructor", 0, 0, 0 }; + +JSCanvasArrayBufferConstructor::JSCanvasArrayBufferConstructor(ExecState* exec, JSDOMGlobalObject* globalObject) + : DOMConstructorObject(JSCanvasArrayBufferConstructor::createStructure(globalObject->objectPrototype()), globalObject) +{ + putDirect(exec->propertyNames().prototype, JSCanvasArrayBufferPrototype::self(exec, globalObject), None); + putDirect(exec->propertyNames().length, jsNumber(exec, 2), ReadOnly|DontDelete|DontEnum); +} + +static JSObject* constructCanvasArrayBuffer(ExecState* exec, JSObject* constructor, const ArgList& args) +{ + JSCanvasArrayBufferConstructor* jsConstructor = static_cast<JSCanvasArrayBufferConstructor*>(constructor); + + unsigned int size = 0; + if (args.size() == 1) { + size = (unsigned int)args.at(0).toInt32(exec); + if (isnan(size)) + size = 0; + } + return asObject(toJS(exec, jsConstructor->globalObject(), CanvasArrayBuffer::create(size))); +} + +JSC::ConstructType JSCanvasArrayBufferConstructor::getConstructData(JSC::ConstructData& constructData) +{ + constructData.native.function = constructCanvasArrayBuffer; + return ConstructTypeHost; +} + +} // namespace WebCore + +#endif // ENABLE(3D_CANVAS) diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSCanvasArrayBufferConstructor.h b/src/3rdparty/webkit/WebCore/bindings/js/JSCanvasArrayBufferConstructor.h new file mode 100644 index 000000000..5f1254ed9 --- /dev/null +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSCanvasArrayBufferConstructor.h @@ -0,0 +1,97 @@ +/* + * 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. + */ + +#ifndef JSCanvasArrayBufferConstructor_h +#define JSCanvasArrayBufferConstructor_h + +#include "JSDOMBinding.h" +#include "JSDocument.h" +#include "JSCanvasArrayBuffer.h" +#include <runtime/Error.h> + +namespace WebCore { + + class CanvasArray; + + // Template function used by CanvasXXXArrayConstructors + template<class C, typename T> + PassRefPtr<CanvasArray> construct(JSC::ExecState* exec, const JSC::ArgList& args) + { + // There are 3 constructors: + // + // 1) (in int size) + // 2) (in CanvasArrayBuffer buffer, [Optional] in int offset, [Optional] in unsigned int length) + // 3) (in sequence<T>) - This ends up being a JS "array-like" object + // + RefPtr<C> arrayObject; + + // For the 0 args case, just create an object without a buffer + if (args.size() < 1) + return C::create(0, 0, 0); + + if (args.at(0).isObject()) { + RefPtr<CanvasArrayBuffer> buffer = toCanvasArrayBuffer(args.at(0)); + if (buffer) { + int offset = (args.size() > 1) ? args.at(1).toInt32(exec) : 0; + unsigned int length = (args.size() > 2) ? static_cast<unsigned int>(args.at(2).toInt32(exec)) : 0; + return C::create(buffer, offset, length); + } + + JSC::JSObject* array = asObject(args.at(0)); + int length = array->get(exec, JSC::Identifier(exec, "length")).toInt32(exec); + void* tempValues; + if (!tryFastMalloc(length * sizeof(T)).getValue(tempValues)) { + throwError(exec, JSC::GeneralError); + return 0; + } + + OwnFastMallocPtr<T> values(static_cast<T*>(tempValues)); + for (int i = 0; i < length; ++i) { + JSC::JSValue v = array->get(exec, i); + if (exec->hadException()) + return 0; + values.get()[i] = static_cast<T>(v.toNumber(exec)); + } + + return C::create(values.get(), length); + } + + unsigned size = static_cast<unsigned>(args.at(0).toInt32(exec)); + return C::create(size); + } + + class JSCanvasArrayBufferConstructor : public DOMConstructorObject { + public: + JSCanvasArrayBufferConstructor(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; } + }; + +} + +#endif // JSCanvasArrayBufferConstructor_h diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSCanvasArrayCustom.cpp b/src/3rdparty/webkit/WebCore/bindings/js/JSCanvasArrayCustom.cpp new file mode 100644 index 000000000..14548d7e3 --- /dev/null +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSCanvasArrayCustom.cpp @@ -0,0 +1,67 @@ +/* + * 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 "config.h" +#include "JSCanvasArray.h" +#include "JSCanvasByteArray.h" +#include "JSCanvasUnsignedByteArray.h" +#include "JSCanvasShortArray.h" +#include "JSCanvasUnsignedShortArray.h" +#include "JSCanvasIntArray.h" +#include "JSCanvasUnsignedIntArray.h" +#include "JSCanvasFloatArray.h" + +#include "CanvasArray.h" + +using namespace JSC; + +namespace WebCore { + +JSC::JSValue toJS(JSC::ExecState* exec, JSDOMGlobalObject* globalObject, CanvasArray* object) +{ + if (object->isFloatArray()) + return getDOMObjectWrapper<JSCanvasFloatArray>(exec, globalObject, static_cast<CanvasFloatArray*>(object)); + if (object->isUnsignedByteArray()) + return getDOMObjectWrapper<JSCanvasUnsignedByteArray>(exec, globalObject, static_cast<CanvasUnsignedByteArray*>(object)); + if (object->isByteArray()) + return getDOMObjectWrapper<JSCanvasByteArray>(exec, globalObject, static_cast<CanvasByteArray*>(object)); + if (object->isIntArray()) + return getDOMObjectWrapper<JSCanvasIntArray>(exec, globalObject, static_cast<CanvasIntArray*>(object)); + if (object->isUnsignedIntArray()) + return getDOMObjectWrapper<JSCanvasUnsignedIntArray>(exec, globalObject, static_cast<CanvasUnsignedIntArray*>(object)); + if (object->isShortArray()) + return getDOMObjectWrapper<JSCanvasShortArray>(exec, globalObject, static_cast<CanvasShortArray*>(object)); + if (object->isUnsignedShortArray()) + return getDOMObjectWrapper<JSCanvasUnsignedShortArray>(exec, globalObject, static_cast<CanvasUnsignedShortArray*>(object)); + return jsUndefined(); +} + +} // namespace WebCore + +#endif // ENABLE(3D_CANVAS) diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSCanvasByteArrayConstructor.cpp b/src/3rdparty/webkit/WebCore/bindings/js/JSCanvasByteArrayConstructor.cpp new file mode 100644 index 000000000..ec1d66d25 --- /dev/null +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSCanvasByteArrayConstructor.cpp @@ -0,0 +1,67 @@ +/* + * 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 "JSCanvasByteArrayConstructor.h" + +#include "Document.h" +#include "CanvasByteArray.h" +#include "JSCanvasArrayBuffer.h" +#include "JSCanvasArrayBufferConstructor.h" +#include "JSCanvasByteArray.h" +#include <runtime/Error.h> + +namespace WebCore { + +using namespace JSC; + +const ClassInfo JSCanvasByteArrayConstructor::s_info = { "CanvasByteArrayConstructor", &JSCanvasArray::s_info, 0, 0 }; + +JSCanvasByteArrayConstructor::JSCanvasByteArrayConstructor(ExecState* exec, JSDOMGlobalObject* globalObject) + : DOMConstructorObject(JSCanvasByteArrayConstructor::createStructure(globalObject->objectPrototype()), globalObject) +{ + putDirect(exec->propertyNames().prototype, JSCanvasByteArrayPrototype::self(exec, globalObject), None); + putDirect(exec->propertyNames().length, jsNumber(exec, 2), ReadOnly|DontDelete|DontEnum); +} + +static JSObject* constructCanvasByteArray(ExecState* exec, JSObject* constructor, const ArgList& args) +{ + JSCanvasByteArrayConstructor* jsConstructor = static_cast<JSCanvasByteArrayConstructor*>(constructor); + RefPtr<CanvasByteArray> array = static_cast<CanvasByteArray*>(construct<CanvasByteArray, signed char>(exec, args).get()); + return asObject(toJS(exec, jsConstructor->globalObject(), array.get())); +} + +JSC::ConstructType JSCanvasByteArrayConstructor::getConstructData(JSC::ConstructData& constructData) +{ + constructData.native.function = constructCanvasByteArray; + return ConstructTypeHost; +} + +} // namespace WebCore + +#endif // ENABLE(3D_CANVAS) diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSHTMLAllCollection.h b/src/3rdparty/webkit/WebCore/bindings/js/JSCanvasByteArrayConstructor.h index 7363e5ce2..4d5dc11b8 100644 --- a/src/3rdparty/webkit/WebCore/bindings/js/JSHTMLAllCollection.h +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSCanvasByteArrayConstructor.h @@ -1,5 +1,5 @@ /* - * Copyright (C) 2007, 2008 Apple Inc. All rights reserved. + * 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 @@ -20,37 +20,27 @@ * 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. + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -#ifndef JSHTMLAllCollection_h -#define JSHTMLAllCollection_h +#ifndef JSCanvasByteArrayConstructor_h +#define JSCanvasByteArrayConstructor_h -#include "HTMLCollection.h" -#include "JSHTMLCollection.h" +#include "JSDOMBinding.h" +#include "JSDocument.h" namespace WebCore { - class HTMLCollection; - - class JSHTMLAllCollection : public JSHTMLCollection { + class JSCanvasByteArrayConstructor : public DOMConstructorObject { public: - JSHTMLAllCollection(PassRefPtr<JSC::Structure> structure, JSDOMGlobalObject* globalObject, PassRefPtr<HTMLCollection> collection) - : JSHTMLCollection(structure, globalObject, collection) - { - } - - static PassRefPtr<JSC::Structure> createStructure(JSC::JSValue proto) - { - return JSC::Structure::create(proto, JSC::TypeInfo(JSC::ObjectType, JSC::MasqueradesAsUndefined)); - } - + JSCanvasByteArrayConstructor(JSC::ExecState*, JSDOMGlobalObject*); static const JSC::ClassInfo s_info; private: - virtual bool toBoolean(JSC::ExecState*) const { return false; } + virtual JSC::ConstructType getConstructData(JSC::ConstructData&); + virtual const JSC::ClassInfo* classInfo() const { return &s_info; } }; -} // namespace WebCore +} -#endif // JSHTMLAllCollection_h +#endif // JSCanvasByteArrayConstructor_h diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSCanvasByteArrayCustom.cpp b/src/3rdparty/webkit/WebCore/bindings/js/JSCanvasByteArrayCustom.cpp new file mode 100644 index 000000000..04697cebf --- /dev/null +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSCanvasByteArrayCustom.cpp @@ -0,0 +1,50 @@ +/* + * 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 "JSCanvasByteArray.h" + +#include "CanvasByteArray.h" + +using namespace JSC; + +namespace WebCore { + +void JSCanvasByteArray::indexSetter(JSC::ExecState* exec, unsigned index, JSC::JSValue value) +{ + impl()->set(index, static_cast<signed char>(value.toInt32(exec))); +} + +JSC::JSValue toJS(JSC::ExecState* exec, JSDOMGlobalObject* globalObject, CanvasByteArray* object) +{ + return getDOMObjectWrapper<JSCanvasByteArray>(exec, globalObject, object); +} + +} // namespace WebCore + +#endif // ENABLE(3D_CANVAS) diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSCanvasFloatArrayConstructor.cpp b/src/3rdparty/webkit/WebCore/bindings/js/JSCanvasFloatArrayConstructor.cpp new file mode 100644 index 000000000..15e39c27b --- /dev/null +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSCanvasFloatArrayConstructor.cpp @@ -0,0 +1,67 @@ +/* + * 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 "JSCanvasFloatArrayConstructor.h" + +#include "Document.h" +#include "CanvasFloatArray.h" +#include "JSCanvasArrayBuffer.h" +#include "JSCanvasArrayBufferConstructor.h" +#include "JSCanvasFloatArray.h" +#include <runtime/Error.h> + +namespace WebCore { + +using namespace JSC; + +const ClassInfo JSCanvasFloatArrayConstructor::s_info = { "CanvasFloatArrayConstructor", &JSCanvasArray::s_info, 0, 0 }; + +JSCanvasFloatArrayConstructor::JSCanvasFloatArrayConstructor(ExecState* exec, JSDOMGlobalObject* globalObject) + : DOMConstructorObject(JSCanvasFloatArrayConstructor::createStructure(globalObject->objectPrototype()), globalObject) +{ + putDirect(exec->propertyNames().prototype, JSCanvasFloatArrayPrototype::self(exec, globalObject), None); + putDirect(exec->propertyNames().length, jsNumber(exec, 2), ReadOnly|DontDelete|DontEnum); +} + +static JSObject* constructCanvasFloatArray(ExecState* exec, JSObject* constructor, const ArgList& args) +{ + JSCanvasFloatArrayConstructor* jsConstructor = static_cast<JSCanvasFloatArrayConstructor*>(constructor); + RefPtr<CanvasFloatArray> array = static_cast<CanvasFloatArray*>(construct<CanvasFloatArray, float>(exec, args).get()); + return asObject(toJS(exec, jsConstructor->globalObject(), array.get())); +} + +JSC::ConstructType JSCanvasFloatArrayConstructor::getConstructData(JSC::ConstructData& constructData) +{ + constructData.native.function = constructCanvasFloatArray; + return ConstructTypeHost; +} + +} // namespace WebCore + +#endif // ENABLE(3D_CANVAS) diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSNamedNodesCollection.h b/src/3rdparty/webkit/WebCore/bindings/js/JSCanvasFloatArrayConstructor.h index cd6c2cb9f..efea2506d 100644 --- a/src/3rdparty/webkit/WebCore/bindings/js/JSNamedNodesCollection.h +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSCanvasFloatArrayConstructor.h @@ -1,5 +1,5 @@ /* - * Copyright (C) 2007, 2008 Apple Inc. All rights reserved. + * 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 @@ -23,44 +23,24 @@ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -#ifndef JSNamedNodesCollection_h -#define JSNamedNodesCollection_h +#ifndef JSCanvasFloatArrayConstructor_h +#define JSCanvasFloatArrayConstructor_h #include "JSDOMBinding.h" -#include <wtf/Vector.h> +#include "JSDocument.h" namespace WebCore { - class Node; - - // Internal class, used for the collection return by e.g. document.forms.myinput - // when multiple nodes have the same name. - class JSNamedNodesCollection : public DOMObjectWithGlobalPointer { + class JSCanvasFloatArrayConstructor : public DOMConstructorObject { public: - JSNamedNodesCollection(JSC::ExecState*, JSDOMGlobalObject*, const Vector<RefPtr<Node> >&); - - virtual bool getOwnPropertySlot(JSC::ExecState*, const JSC::Identifier&, JSC::PropertySlot&); - - virtual const JSC::ClassInfo* classInfo() const { return &s_info; } + JSCanvasFloatArrayConstructor(JSC::ExecState*, JSDOMGlobalObject*); static const JSC::ClassInfo s_info; - static JSC::ObjectPrototype* createPrototype(JSC::ExecState*, JSC::JSGlobalObject* globalObject) - { - return globalObject->objectPrototype(); - } - - static PassRefPtr<JSC::Structure> createStructure(JSC::JSValue prototype) - { - return JSC::Structure::create(prototype, JSC::TypeInfo(JSC::ObjectType)); - } - private: - static JSC::JSValue lengthGetter(JSC::ExecState*, const JSC::Identifier&, const JSC::PropertySlot&); - static JSC::JSValue indexGetter(JSC::ExecState*, const JSC::Identifier&, const JSC::PropertySlot&); - - OwnPtr<Vector<RefPtr<Node> > > m_nodes; + virtual JSC::ConstructType getConstructData(JSC::ConstructData&); + virtual const JSC::ClassInfo* classInfo() const { return &s_info; } }; -} // namespace WebCore +} -#endif // JSNamedNodesCollection_h +#endif // JSCanvasFloatArrayConstructor_h diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSCanvasFloatArrayCustom.cpp b/src/3rdparty/webkit/WebCore/bindings/js/JSCanvasFloatArrayCustom.cpp new file mode 100644 index 000000000..20cd805c0 --- /dev/null +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSCanvasFloatArrayCustom.cpp @@ -0,0 +1,50 @@ +/* + * 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 "JSCanvasFloatArray.h" + +#include "CanvasFloatArray.h" + +using namespace JSC; + +namespace WebCore { + +void JSCanvasFloatArray::indexSetter(JSC::ExecState* exec, unsigned index, JSC::JSValue value) +{ + impl()->set(index, static_cast<float>(value.toInt32(exec))); +} + +JSC::JSValue toJS(JSC::ExecState* exec, JSDOMGlobalObject* globalObject, CanvasFloatArray* object) +{ + return getDOMObjectWrapper<JSCanvasFloatArray>(exec, globalObject, object); +} + +} // namespace WebCore + +#endif // ENABLE(3D_CANVAS) diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSCanvasIntArrayConstructor.cpp b/src/3rdparty/webkit/WebCore/bindings/js/JSCanvasIntArrayConstructor.cpp new file mode 100644 index 000000000..6d57912eb --- /dev/null +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSCanvasIntArrayConstructor.cpp @@ -0,0 +1,67 @@ +/* + * 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 "JSCanvasIntArrayConstructor.h" + +#include "Document.h" +#include "CanvasIntArray.h" +#include "JSCanvasArrayBuffer.h" +#include "JSCanvasArrayBufferConstructor.h" +#include "JSCanvasIntArray.h" +#include <runtime/Error.h> + +namespace WebCore { + +using namespace JSC; + +const ClassInfo JSCanvasIntArrayConstructor::s_info = { "CanvasIntArrayConstructor", &JSCanvasArray::s_info, 0, 0 }; + +JSCanvasIntArrayConstructor::JSCanvasIntArrayConstructor(ExecState* exec, JSDOMGlobalObject* globalObject) + : DOMConstructorObject(JSCanvasIntArrayConstructor::createStructure(globalObject->objectPrototype()), globalObject) +{ + putDirect(exec->propertyNames().prototype, JSCanvasIntArrayPrototype::self(exec, globalObject), None); + putDirect(exec->propertyNames().length, jsNumber(exec, 2), ReadOnly|DontDelete|DontEnum); +} + +static JSObject* constructCanvasIntArray(ExecState* exec, JSObject* constructor, const ArgList& args) +{ + JSCanvasIntArrayConstructor* jsConstructor = static_cast<JSCanvasIntArrayConstructor*>(constructor); + RefPtr<CanvasIntArray> array = static_cast<CanvasIntArray*>(construct<CanvasIntArray, int>(exec, args).get()); + return asObject(toJS(exec, jsConstructor->globalObject(), array.get())); +} + +JSC::ConstructType JSCanvasIntArrayConstructor::getConstructData(JSC::ConstructData& constructData) +{ + constructData.native.function = constructCanvasIntArray; + return ConstructTypeHost; +} + +} // namespace WebCore + +#endif // ENABLE(3D_CANVAS) diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSCanvasIntArrayConstructor.h b/src/3rdparty/webkit/WebCore/bindings/js/JSCanvasIntArrayConstructor.h new file mode 100644 index 000000000..5e196529c --- /dev/null +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSCanvasIntArrayConstructor.h @@ -0,0 +1,46 @@ +/* + * 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. + */ + +#ifndef JSCanvasIntArrayConstructor_h +#define JSCanvasIntArrayConstructor_h + +#include "JSDOMBinding.h" +#include "JSDocument.h" + +namespace WebCore { + + class JSCanvasIntArrayConstructor : public DOMConstructorObject { + public: + JSCanvasIntArrayConstructor(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; } + }; + +} + +#endif // JSCanvasIntArrayConstructor_h diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSCanvasIntArrayCustom.cpp b/src/3rdparty/webkit/WebCore/bindings/js/JSCanvasIntArrayCustom.cpp new file mode 100644 index 000000000..8442b8769 --- /dev/null +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSCanvasIntArrayCustom.cpp @@ -0,0 +1,50 @@ +/* + * 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 "JSCanvasIntArray.h" + +#include "CanvasIntArray.h" + +using namespace JSC; + +namespace WebCore { + +void JSCanvasIntArray::indexSetter(JSC::ExecState* exec, unsigned index, JSC::JSValue value) +{ + impl()->set(index, static_cast<signed int>(value.toInt32(exec))); +} + +JSC::JSValue toJS(JSC::ExecState* exec, JSDOMGlobalObject* globalObject, CanvasIntArray* object) +{ + return getDOMObjectWrapper<JSCanvasIntArray>(exec, globalObject, object); +} + +} // namespace WebCore + +#endif // ENABLE(3D_CANVAS) diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSHTMLAllCollection.cpp b/src/3rdparty/webkit/WebCore/bindings/js/JSCanvasNumberArrayCustom.cpp index ce2609ce1..be10ac058 100644 --- a/src/3rdparty/webkit/WebCore/bindings/js/JSHTMLAllCollection.cpp +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSCanvasNumberArrayCustom.cpp @@ -1,5 +1,5 @@ /* - * Copyright (C) 2008 Apple Inc. All rights reserved. + * 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 @@ -20,16 +20,27 @@ * 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. + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ #include "config.h" -#include "JSHTMLAllCollection.h" + +#if ENABLE(3D_CANVAS) + +#include "JSCanvasNumberArray.h" + +#include "CanvasNumberArray.h" using namespace JSC; namespace WebCore { -const ClassInfo JSHTMLAllCollection::s_info = { "HTMLAllCollection", 0, 0, 0 }; +JSValue JSCanvasNumberArray::getByIndex(JSC::ExecState* exec, unsigned int index) +{ + JSC::JSValue result = jsNumber(exec, impl()->item(index)); + return result; +} } // namespace WebCore + +#endif // ENABLE(3D_CANVAS) diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSCanvasRenderingContext2DCustom.cpp b/src/3rdparty/webkit/WebCore/bindings/js/JSCanvasRenderingContext2DCustom.cpp index 398a6799d..bb3500b9e 100644 --- a/src/3rdparty/webkit/WebCore/bindings/js/JSCanvasRenderingContext2DCustom.cpp +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSCanvasRenderingContext2DCustom.cpp @@ -67,27 +67,31 @@ static PassRefPtr<CanvasStyle> toHTMLCanvasStyle(ExecState*, JSValue value) JSValue JSCanvasRenderingContext2D::strokeStyle(ExecState* exec) const { - return toJS(exec, impl()->strokeStyle()); + CanvasRenderingContext2D* context = static_cast<CanvasRenderingContext2D*>(impl()); + return toJS(exec, context->strokeStyle()); } void JSCanvasRenderingContext2D::setStrokeStyle(ExecState* exec, JSValue value) { - impl()->setStrokeStyle(toHTMLCanvasStyle(exec, value)); + CanvasRenderingContext2D* context = static_cast<CanvasRenderingContext2D*>(impl()); + context->setStrokeStyle(toHTMLCanvasStyle(exec, value)); } JSValue JSCanvasRenderingContext2D::fillStyle(ExecState* exec) const { - return toJS(exec, impl()->fillStyle()); + CanvasRenderingContext2D* context = static_cast<CanvasRenderingContext2D*>(impl()); + return toJS(exec, context->fillStyle()); } void JSCanvasRenderingContext2D::setFillStyle(ExecState* exec, JSValue value) { - impl()->setFillStyle(toHTMLCanvasStyle(exec, value)); + CanvasRenderingContext2D* context = static_cast<CanvasRenderingContext2D*>(impl()); + context->setFillStyle(toHTMLCanvasStyle(exec, value)); } JSValue JSCanvasRenderingContext2D::setFillColor(ExecState* exec, const ArgList& args) { - CanvasRenderingContext2D* context = impl(); + CanvasRenderingContext2D* context = static_cast<CanvasRenderingContext2D*>(impl()); // string arg = named color // number arg = gray color @@ -124,7 +128,7 @@ JSValue JSCanvasRenderingContext2D::setFillColor(ExecState* exec, const ArgList& JSValue JSCanvasRenderingContext2D::setStrokeColor(ExecState* exec, const ArgList& args) { - CanvasRenderingContext2D* context = impl(); + CanvasRenderingContext2D* context = static_cast<CanvasRenderingContext2D*>(impl()); // string arg = named color // number arg = gray color @@ -162,7 +166,7 @@ JSValue JSCanvasRenderingContext2D::setStrokeColor(ExecState* exec, const ArgLis JSValue JSCanvasRenderingContext2D::strokeRect(ExecState* exec, const ArgList& args) { - CanvasRenderingContext2D* context = impl(); + CanvasRenderingContext2D* context = static_cast<CanvasRenderingContext2D*>(impl()); if (args.size() <= 4) context->strokeRect(args.at(0).toFloat(exec), args.at(1).toFloat(exec), @@ -176,7 +180,7 @@ JSValue JSCanvasRenderingContext2D::strokeRect(ExecState* exec, const ArgList& a JSValue JSCanvasRenderingContext2D::drawImage(ExecState* exec, const ArgList& args) { - CanvasRenderingContext2D* context = impl(); + CanvasRenderingContext2D* context = static_cast<CanvasRenderingContext2D*>(impl()); // DrawImage has three variants: // drawImage(img, dx, dy) @@ -264,7 +268,7 @@ JSValue JSCanvasRenderingContext2D::drawImage(ExecState* exec, const ArgList& ar JSValue JSCanvasRenderingContext2D::drawImageFromRect(ExecState* exec, const ArgList& args) { - CanvasRenderingContext2D* context = impl(); + CanvasRenderingContext2D* context = static_cast<CanvasRenderingContext2D*>(impl()); JSValue value = args.at(0); if (!value.isObject()) @@ -284,7 +288,7 @@ JSValue JSCanvasRenderingContext2D::drawImageFromRect(ExecState* exec, const Arg JSValue JSCanvasRenderingContext2D::setShadow(ExecState* exec, const ArgList& args) { - CanvasRenderingContext2D* context = impl(); + CanvasRenderingContext2D* context = static_cast<CanvasRenderingContext2D*>(impl()); switch (args.size()) { case 3: @@ -330,7 +334,7 @@ JSValue JSCanvasRenderingContext2D::setShadow(ExecState* exec, const ArgList& ar JSValue JSCanvasRenderingContext2D::createPattern(ExecState* exec, const ArgList& args) { - CanvasRenderingContext2D* context = impl(); + CanvasRenderingContext2D* context = static_cast<CanvasRenderingContext2D*>(impl()); JSValue value = args.at(0); if (!value.isObject()) @@ -362,7 +366,7 @@ JSValue JSCanvasRenderingContext2D::putImageData(ExecState* exec, const ArgList& // putImageData has two variants // putImageData(ImageData, x, y) // putImageData(ImageData, x, y, dirtyX, dirtyY, dirtyWidth, dirtyHeight) - CanvasRenderingContext2D* context = impl(); + CanvasRenderingContext2D* context = static_cast<CanvasRenderingContext2D*>(impl()); ExceptionCode ec = 0; if (args.size() >= 7) @@ -377,7 +381,7 @@ JSValue JSCanvasRenderingContext2D::putImageData(ExecState* exec, const ArgList& JSValue JSCanvasRenderingContext2D::fillText(ExecState* exec, const ArgList& args) { - CanvasRenderingContext2D* context = impl(); + CanvasRenderingContext2D* context = static_cast<CanvasRenderingContext2D*>(impl()); // string arg = text to draw // number arg = x @@ -395,7 +399,7 @@ JSValue JSCanvasRenderingContext2D::fillText(ExecState* exec, const ArgList& arg JSValue JSCanvasRenderingContext2D::strokeText(ExecState* exec, const ArgList& args) { - CanvasRenderingContext2D* context = impl(); + CanvasRenderingContext2D* context = static_cast<CanvasRenderingContext2D*>(impl()); // string arg = text to draw // number arg = x diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSCanvasRenderingContext3DCustom.cpp b/src/3rdparty/webkit/WebCore/bindings/js/JSCanvasRenderingContext3DCustom.cpp new file mode 100644 index 000000000..3938ba1c2 --- /dev/null +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSCanvasRenderingContext3DCustom.cpp @@ -0,0 +1,443 @@ +/* + * 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 "JSCanvasRenderingContext3D.h" + +#include "CanvasRenderingContext3D.h" +#include "ExceptionCode.h" +#include "HTMLCanvasElement.h" +#include "HTMLImageElement.h" +#include "JSCanvasFloatArray.h" +#include "JSCanvasIntArray.h" +#include "JSHTMLCanvasElement.h" +#include "JSHTMLImageElement.h" +#include "JSWebKitCSSMatrix.h" +#include <runtime/Error.h> +#include <wtf/FastMalloc.h> +#include <wtf/OwnFastMallocPtr.h> + +using namespace JSC; + +namespace WebCore { + +JSValue JSCanvasRenderingContext3D::bufferData(JSC::ExecState* exec, JSC::ArgList const& args) +{ + if (args.size() != 3) + return throwError(exec, SyntaxError); + + unsigned target = args.at(0).toInt32(exec); + unsigned usage = args.at(2).toInt32(exec); + + // If argument 1 is a number, we are initializing this buffer to that size + if (!args.at(1).isObject()) { + unsigned int count = args.at(1).toInt32(exec); + static_cast<CanvasRenderingContext3D*>(impl())->bufferData(target, count, usage); + return jsUndefined(); + } + + CanvasArray* array = toCanvasArray(args.at(1)); + + static_cast<CanvasRenderingContext3D*>(impl())->bufferData(target, array, usage); + return jsUndefined(); +} + +JSValue JSCanvasRenderingContext3D::bufferSubData(JSC::ExecState* exec, JSC::ArgList const& args) +{ + if (args.size() != 3) + return throwError(exec, SyntaxError); + + unsigned target = args.at(0).toInt32(exec); + unsigned offset = args.at(1).toInt32(exec); + + CanvasArray* array = toCanvasArray(args.at(2)); + + static_cast<CanvasRenderingContext3D*>(impl())->bufferSubData(target, offset, array); + return jsUndefined(); +} + +// void texImage2DHTML(in unsigned long target, in unsigned long level, in HTMLImageElement image); +JSValue JSCanvasRenderingContext3D::texImage2D(ExecState* exec, const ArgList& args) +{ + if (args.size() < 3) + return throwError(exec, SyntaxError); + + ExceptionCode ec = 0; + CanvasRenderingContext3D* context = static_cast<CanvasRenderingContext3D*>(impl()); + unsigned target = args.at(0).toInt32(exec); + if (exec->hadException()) + return jsUndefined(); + + unsigned level = args.at(1).toInt32(exec); + if (exec->hadException()) + return jsUndefined(); + + if (args.size() > 5) { + // This must be the bare array case. + if (args.size() != 9) + return throwError(exec, SyntaxError); + + unsigned internalformat = args.at(2).toInt32(exec); + if (exec->hadException()) + return jsUndefined(); + + unsigned width = args.at(3).toInt32(exec); + if (exec->hadException()) + return jsUndefined(); + + unsigned height = args.at(4).toInt32(exec); + if (exec->hadException()) + return jsUndefined(); + + unsigned border = args.at(5).toInt32(exec); + if (exec->hadException()) + return jsUndefined(); + + unsigned format = args.at(6).toInt32(exec); + if (exec->hadException()) + return jsUndefined(); + + unsigned type = args.at(7).toInt32(exec); + if (exec->hadException()) + return jsUndefined(); + + CanvasArray* array = toCanvasArray(args.at(8)); + if (exec->hadException()) + return jsUndefined(); + + if (!array) + return throwError(exec, TypeError); + + // FIXME: Need to check to make sure CanvasArray is a CanvasByteArray or CanvasShortArray, + // depending on the passed type parameter. + + context->texImage2D(target, level, internalformat, width, height, border, format, type, array, ec); + return jsUndefined(); + } + + // The image parameter can be a <img> or <canvas> element. + JSValue value = args.at(2); + if (!value.isObject()) + return throwError(exec, TypeError); + JSObject* o = asObject(value); + + bool flipY = (args.size() > 3) ? args.at(3).toBoolean(exec) : false; + bool premultiplyAlpha = (args.size() > 4) ? args.at(3).toBoolean(exec) : false; + + if (o->inherits(&JSHTMLImageElement::s_info)) { + HTMLImageElement* imgElt = static_cast<HTMLImageElement*>(static_cast<JSHTMLElement*>(o)->impl()); + context->texImage2D(target, level, imgElt, flipY, premultiplyAlpha, ec); + } else if (o->inherits(&JSHTMLCanvasElement::s_info)) { + HTMLCanvasElement* canvas = static_cast<HTMLCanvasElement*>(static_cast<JSHTMLElement*>(o)->impl()); + context->texImage2D(target, level, canvas, flipY, premultiplyAlpha, ec); + } else { + setDOMException(exec, TYPE_MISMATCH_ERR); + } + + return jsUndefined(); +} + +// void texSubImage2DHTML(in unsigned long target, in unsigned long level, in unsigned long xoff, in unsigned long yoff, in unsigned long width, in unsigned long height, in HTMLImageElement image); +JSValue JSCanvasRenderingContext3D::texSubImage2D(ExecState* exec, const ArgList& args) +{ + if (args.size() < 7 || args.size() > 9) + return throwError(exec, SyntaxError); + + CanvasRenderingContext3D* context = static_cast<CanvasRenderingContext3D*>(impl()); + unsigned target = args.at(0).toInt32(exec); + unsigned level = args.at(1).toInt32(exec); + unsigned xoff = args.at(2).toInt32(exec); + unsigned yoff = args.at(3).toInt32(exec); + unsigned width = args.at(4).toInt32(exec); + unsigned height = args.at(5).toInt32(exec); + + // The image parameter can be a <img> or <canvas> element. + JSValue value = args.at(6); + if (!value.isObject()) + return throwError(exec, TypeError); + JSObject* o = asObject(value); + + bool flipY = (args.size() > 3) ? args.at(3).toBoolean(exec) : false; + bool premultiplyAlpha = (args.size() > 4) ? args.at(3).toBoolean(exec) : false; + + ExceptionCode ec = 0; + if (o->inherits(&JSHTMLImageElement::s_info)) { + HTMLImageElement* imgElt = static_cast<HTMLImageElement*>(static_cast<JSHTMLElement*>(o)->impl()); + context->texSubImage2D(target, level, xoff, yoff, width, height, imgElt, flipY, premultiplyAlpha, ec); + } else if (o->inherits(&JSHTMLCanvasElement::s_info)) { + HTMLCanvasElement* canvas = static_cast<HTMLCanvasElement*>(static_cast<JSHTMLElement*>(o)->impl()); + context->texSubImage2D(target, level, xoff, yoff, width, height, canvas, flipY, premultiplyAlpha, ec); + } else { + setDOMException(exec, TYPE_MISMATCH_ERR); + } + + return jsUndefined(); +} + +template<typename T> +void toArray(JSC::ExecState* exec, JSC::JSValue value, T*& array, int& size) +{ + array = 0; + + if (!value.isObject()) + return; + + JSC::JSObject* object = asObject(value); + int length = object->get(exec, JSC::Identifier(exec, "length")).toInt32(exec); + void* tempValues; + if (!tryFastMalloc(length * sizeof(T)).getValue(tempValues)) + return; + + T* values = static_cast<T*>(tempValues); + for (int i = 0; i < length; ++i) { + JSC::JSValue v = object->get(exec, i); + if (exec->hadException()) + return; + values[i] = static_cast<T>(v.toNumber(exec)); + } + + array = values; + size = length; +} + +enum DataFunctionToCall { + f_uniform1v, f_uniform2v, f_uniform3v, f_uniform4v, + f_vertexAttrib1v, f_vertexAttrib2v, f_vertexAttrib3v, f_vertexAttrib4v +}; + +enum DataFunctionMatrixToCall { + f_uniformMatrix2fv, f_uniformMatrix3fv, f_uniformMatrix4fv +}; + +static JSC::JSValue dataFunctionf(DataFunctionToCall f, JSC::ExecState* exec, const JSC::ArgList& args, CanvasRenderingContext3D* context) +{ + if (args.size() != 2) + return throwError(exec, SyntaxError); + + long location = args.at(0).toInt32(exec); + if (exec->hadException()) + return jsUndefined(); + + RefPtr<CanvasFloatArray> canvasArray = toCanvasFloatArray(args.at(1)); + if (exec->hadException()) + return jsUndefined(); + + if (canvasArray) { + switch(f) { + case f_uniform1v: context->uniform1fv(location, canvasArray.get()); break; + case f_uniform2v: context->uniform2fv(location, canvasArray.get()); break; + case f_uniform3v: context->uniform3fv(location, canvasArray.get()); break; + case f_uniform4v: context->uniform4fv(location, canvasArray.get()); break; + case f_vertexAttrib1v: context->vertexAttrib1fv(location, canvasArray.get()); break; + case f_vertexAttrib2v: context->vertexAttrib2fv(location, canvasArray.get()); break; + case f_vertexAttrib3v: context->vertexAttrib3fv(location, canvasArray.get()); break; + case f_vertexAttrib4v: context->vertexAttrib4fv(location, canvasArray.get()); break; + } + return jsUndefined(); + } + + float* array; + int size; + toArray<float>(exec, args.at(1), array, size); + + if (!array) + return throwError(exec, TypeError); + + switch(f) { + case f_uniform1v: context->uniform1fv(location, array, size); break; + case f_uniform2v: context->uniform2fv(location, array, size); break; + case f_uniform3v: context->uniform3fv(location, array, size); break; + case f_uniform4v: context->uniform4fv(location, array, size); break; + case f_vertexAttrib1v: context->vertexAttrib1fv(location, array, size); break; + case f_vertexAttrib2v: context->vertexAttrib2fv(location, array, size); break; + case f_vertexAttrib3v: context->vertexAttrib3fv(location, array, size); break; + case f_vertexAttrib4v: context->vertexAttrib4fv(location, array, size); break; + } + return jsUndefined(); +} + +static JSC::JSValue dataFunctioni(DataFunctionToCall f, JSC::ExecState* exec, const JSC::ArgList& args, CanvasRenderingContext3D* context) +{ + if (args.size() != 2) + return throwError(exec, SyntaxError); + + long location = args.at(0).toInt32(exec); + if (exec->hadException()) + return jsUndefined(); + + RefPtr<CanvasIntArray> canvasArray = toCanvasIntArray(args.at(1)); + if (exec->hadException()) + return jsUndefined(); + + if (canvasArray) { + switch(f) { + case f_uniform1v: context->uniform1iv(location, canvasArray.get()); break; + case f_uniform2v: context->uniform2iv(location, canvasArray.get()); break; + case f_uniform3v: context->uniform3iv(location, canvasArray.get()); break; + case f_uniform4v: context->uniform4iv(location, canvasArray.get()); break; + default: break; + } + return jsUndefined(); + } + + int* array; + int size; + toArray<int>(exec, args.at(1), array, size); + + if (!array) + return throwError(exec, TypeError); + + switch(f) { + case f_uniform1v: context->uniform1iv(location, array, size); break; + case f_uniform2v: context->uniform2iv(location, array, size); break; + case f_uniform3v: context->uniform3iv(location, array, size); break; + case f_uniform4v: context->uniform4iv(location, array, size); break; + default: break; + } + return jsUndefined(); +} + +static JSC::JSValue dataFunctionMatrix(DataFunctionMatrixToCall f, JSC::ExecState* exec, const JSC::ArgList& args, CanvasRenderingContext3D* context) +{ + if (args.size() != 3) + return throwError(exec, SyntaxError); + + long location = args.at(0).toInt32(exec); + if (exec->hadException()) + return jsUndefined(); + + bool transpose = args.at(1).toBoolean(exec); + if (exec->hadException()) + return jsUndefined(); + + RefPtr<CanvasFloatArray> canvasArray = toCanvasFloatArray(args.at(2)); + if (exec->hadException()) + return jsUndefined(); + + if (canvasArray) { + switch(f) { + case f_uniformMatrix2fv: context->uniformMatrix2fv(location, transpose, canvasArray.get()); break; + case f_uniformMatrix3fv: context->uniformMatrix3fv(location, transpose, canvasArray.get()); break; + case f_uniformMatrix4fv: context->uniformMatrix4fv(location, transpose, canvasArray.get()); break; + } + return jsUndefined(); + } + + float* array; + int size; + toArray<float>(exec, args.at(2), array, size); + + if (!array) + return throwError(exec, TypeError); + + switch(f) { + case f_uniformMatrix2fv: context->uniformMatrix2fv(location, transpose, array, size); break; + case f_uniformMatrix3fv: context->uniformMatrix3fv(location, transpose, array, size); break; + case f_uniformMatrix4fv: context->uniformMatrix4fv(location, transpose, array, size); break; + } + return jsUndefined(); +} + +JSC::JSValue JSCanvasRenderingContext3D::uniform1fv(JSC::ExecState* exec, const JSC::ArgList& args) +{ + return dataFunctionf(f_uniform1v, exec, args, static_cast<CanvasRenderingContext3D*>(impl())); +} + +JSC::JSValue JSCanvasRenderingContext3D::uniform1iv(JSC::ExecState* exec, const JSC::ArgList& args) +{ + return dataFunctioni(f_uniform1v, exec, args, static_cast<CanvasRenderingContext3D*>(impl())); +} + +JSC::JSValue JSCanvasRenderingContext3D::uniform2fv(JSC::ExecState* exec, const JSC::ArgList& args) +{ + return dataFunctionf(f_uniform2v, exec, args, static_cast<CanvasRenderingContext3D*>(impl())); +} + +JSC::JSValue JSCanvasRenderingContext3D::uniform2iv(JSC::ExecState* exec, const JSC::ArgList& args) +{ + return dataFunctioni(f_uniform2v, exec, args, static_cast<CanvasRenderingContext3D*>(impl())); +} + +JSC::JSValue JSCanvasRenderingContext3D::uniform3fv(JSC::ExecState* exec, const JSC::ArgList& args) +{ + return dataFunctionf(f_uniform3v, exec, args, static_cast<CanvasRenderingContext3D*>(impl())); +} + +JSC::JSValue JSCanvasRenderingContext3D::uniform3iv(JSC::ExecState* exec, const JSC::ArgList& args) +{ + return dataFunctioni(f_uniform3v, exec, args, static_cast<CanvasRenderingContext3D*>(impl())); +} + +JSC::JSValue JSCanvasRenderingContext3D::uniform4fv(JSC::ExecState* exec, const JSC::ArgList& args) +{ + return dataFunctionf(f_uniform4v, exec, args, static_cast<CanvasRenderingContext3D*>(impl())); +} + +JSC::JSValue JSCanvasRenderingContext3D::uniform4iv(JSC::ExecState* exec, const JSC::ArgList& args) +{ + return dataFunctioni(f_uniform4v, exec, args, static_cast<CanvasRenderingContext3D*>(impl())); +} + +JSC::JSValue JSCanvasRenderingContext3D::uniformMatrix2fv(JSC::ExecState* exec, const JSC::ArgList& args) +{ + return dataFunctionMatrix(f_uniformMatrix2fv, exec, args, static_cast<CanvasRenderingContext3D*>(impl())); +} + +JSC::JSValue JSCanvasRenderingContext3D::uniformMatrix3fv(JSC::ExecState* exec, const JSC::ArgList& args) +{ + return dataFunctionMatrix(f_uniformMatrix3fv, exec, args, static_cast<CanvasRenderingContext3D*>(impl())); +} + +JSC::JSValue JSCanvasRenderingContext3D::uniformMatrix4fv(JSC::ExecState* exec, const JSC::ArgList& args) +{ + return dataFunctionMatrix(f_uniformMatrix4fv, exec, args, static_cast<CanvasRenderingContext3D*>(impl())); +} + +JSC::JSValue JSCanvasRenderingContext3D::vertexAttrib1fv(JSC::ExecState* exec, const JSC::ArgList& args) +{ + return dataFunctionf(f_vertexAttrib1v, exec, args, static_cast<CanvasRenderingContext3D*>(impl())); +} + +JSC::JSValue JSCanvasRenderingContext3D::vertexAttrib2fv(JSC::ExecState* exec, const JSC::ArgList& args) +{ + return dataFunctionf(f_vertexAttrib2v, exec, args, static_cast<CanvasRenderingContext3D*>(impl())); +} + +JSC::JSValue JSCanvasRenderingContext3D::vertexAttrib3fv(JSC::ExecState* exec, const JSC::ArgList& args) +{ + return dataFunctionf(f_vertexAttrib3v, exec, args, static_cast<CanvasRenderingContext3D*>(impl())); +} + +JSC::JSValue JSCanvasRenderingContext3D::vertexAttrib4fv(JSC::ExecState* exec, const JSC::ArgList& args) +{ + return dataFunctionf(f_vertexAttrib4v, exec, args, static_cast<CanvasRenderingContext3D*>(impl())); +} + +} // namespace WebCore + +#endif // ENABLE(3D_CANVAS) diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSCanvasRenderingContextCustom.cpp b/src/3rdparty/webkit/WebCore/bindings/js/JSCanvasRenderingContextCustom.cpp new file mode 100644 index 000000000..0cd2aa388 --- /dev/null +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSCanvasRenderingContextCustom.cpp @@ -0,0 +1,53 @@ +/* + * 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" +#include "JSCanvasRenderingContext.h" + +#include "CanvasRenderingContext2D.h" +#include "JSCanvasRenderingContext2D.h" +#if ENABLE(3D_CANVAS) +#include "CanvasRenderingContext3D.h" +#include "JSCanvasRenderingContext3D.h" +#endif + +using namespace JSC; + +namespace WebCore { + +JSC::JSValue toJS(JSC::ExecState* exec, JSDOMGlobalObject* globalObject, CanvasRenderingContext* object) +{ + if (!object) + return jsUndefined(); + +#if ENABLE(3D_CANVAS) + if (object->is3d()) + return getDOMObjectWrapper<JSCanvasRenderingContext3D>(exec, globalObject, static_cast<CanvasRenderingContext3D*>(object)); +#endif + ASSERT(object->is2d()); + return getDOMObjectWrapper<JSCanvasRenderingContext2D>(exec, globalObject, static_cast<CanvasRenderingContext2D*>(object)); +} + +} // namespace WebCore diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSCanvasShortArrayConstructor.cpp b/src/3rdparty/webkit/WebCore/bindings/js/JSCanvasShortArrayConstructor.cpp new file mode 100644 index 000000000..a885b7bca --- /dev/null +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSCanvasShortArrayConstructor.cpp @@ -0,0 +1,68 @@ +/* + * 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 "JSCanvasShortArrayConstructor.h" + +#include "Document.h" +#include "CanvasShortArray.h" +#include "JSCanvasArray.h" +#include "JSCanvasArrayBuffer.h" +#include "JSCanvasArrayBufferConstructor.h" +#include "JSCanvasShortArray.h" +#include <runtime/Error.h> + +namespace WebCore { + +using namespace JSC; + +const ClassInfo JSCanvasShortArrayConstructor::s_info = { "CanvasShortArrayConstructor", &JSCanvasArray::s_info, 0, 0 }; + +JSCanvasShortArrayConstructor::JSCanvasShortArrayConstructor(ExecState* exec, JSDOMGlobalObject* globalObject) + : DOMConstructorObject(JSCanvasShortArrayConstructor::createStructure(globalObject->objectPrototype()), globalObject) +{ + putDirect(exec->propertyNames().prototype, JSCanvasShortArrayPrototype::self(exec, globalObject), None); + putDirect(exec->propertyNames().length, jsNumber(exec, 2), ReadOnly|DontDelete|DontEnum); +} + +static JSObject* constructCanvasShortArray(ExecState* exec, JSObject* constructor, const ArgList& args) +{ + JSCanvasShortArrayConstructor* jsConstructor = static_cast<JSCanvasShortArrayConstructor*>(constructor); + RefPtr<CanvasShortArray> array = static_cast<CanvasShortArray*>(construct<CanvasShortArray, short>(exec, args).get()); + return asObject(toJS(exec, jsConstructor->globalObject(), array.get())); +} + +JSC::ConstructType JSCanvasShortArrayConstructor::getConstructData(JSC::ConstructData& constructData) +{ + constructData.native.function = constructCanvasShortArray; + return ConstructTypeHost; +} + +} // namespace WebCore + +#endif // ENABLE(3D_CANVAS) diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSCanvasShortArrayConstructor.h b/src/3rdparty/webkit/WebCore/bindings/js/JSCanvasShortArrayConstructor.h new file mode 100644 index 000000000..df218252d --- /dev/null +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSCanvasShortArrayConstructor.h @@ -0,0 +1,46 @@ +/* + * 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. + */ + +#ifndef JSCanvasShortArrayConstructor_h +#define JSCanvasShortArrayConstructor_h + +#include "JSDOMBinding.h" +#include "JSDocument.h" + +namespace WebCore { + + class JSCanvasShortArrayConstructor : public DOMConstructorObject { + public: + JSCanvasShortArrayConstructor(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; } + }; + +} + +#endif // JSCanvasShortArrayConstructor_h diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSCanvasShortArrayCustom.cpp b/src/3rdparty/webkit/WebCore/bindings/js/JSCanvasShortArrayCustom.cpp new file mode 100644 index 000000000..21af0a616 --- /dev/null +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSCanvasShortArrayCustom.cpp @@ -0,0 +1,50 @@ +/* + * 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 "JSCanvasShortArray.h" + +#include "CanvasShortArray.h" + +using namespace JSC; + +namespace WebCore { + +void JSCanvasShortArray::indexSetter(JSC::ExecState* exec, unsigned index, JSC::JSValue value) +{ + impl()->set(index, static_cast<signed short>(value.toInt32(exec))); +} + +JSC::JSValue toJS(JSC::ExecState* exec, JSDOMGlobalObject* globalObject, CanvasShortArray* object) +{ + return getDOMObjectWrapper<JSCanvasShortArray>(exec, globalObject, object); +} + +} // namespace WebCore + +#endif // ENABLE(3D_CANVAS) diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSCanvasUnsignedByteArrayConstructor.cpp b/src/3rdparty/webkit/WebCore/bindings/js/JSCanvasUnsignedByteArrayConstructor.cpp new file mode 100644 index 000000000..5d0800e66 --- /dev/null +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSCanvasUnsignedByteArrayConstructor.cpp @@ -0,0 +1,67 @@ +/* + * 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 "JSCanvasUnsignedByteArrayConstructor.h" + +#include "Document.h" +#include "CanvasUnsignedByteArray.h" +#include "JSCanvasArrayBuffer.h" +#include "JSCanvasArrayBufferConstructor.h" +#include "JSCanvasUnsignedByteArray.h" +#include <runtime/Error.h> + +namespace WebCore { + +using namespace JSC; + +const ClassInfo JSCanvasUnsignedByteArrayConstructor::s_info = { "CanvasUnsignedByteArrayConstructor", &JSCanvasArray::s_info, 0, 0 }; + +JSCanvasUnsignedByteArrayConstructor::JSCanvasUnsignedByteArrayConstructor(ExecState* exec, JSDOMGlobalObject* globalObject) + : DOMConstructorObject(JSCanvasUnsignedByteArrayConstructor::createStructure(globalObject->objectPrototype()), globalObject) +{ + putDirect(exec->propertyNames().prototype, JSCanvasUnsignedByteArrayPrototype::self(exec, globalObject), None); + putDirect(exec->propertyNames().length, jsNumber(exec, 2), ReadOnly|DontDelete|DontEnum); +} + +static JSObject* constructCanvasUnsignedByteArray(ExecState* exec, JSObject* constructor, const ArgList& args) +{ + JSCanvasUnsignedByteArrayConstructor* jsConstructor = static_cast<JSCanvasUnsignedByteArrayConstructor*>(constructor); + RefPtr<CanvasUnsignedByteArray> array = static_cast<CanvasUnsignedByteArray*>(construct<CanvasUnsignedByteArray, unsigned char>(exec, args).get()); + return asObject(toJS(exec, jsConstructor->globalObject(), array.get())); +} + +JSC::ConstructType JSCanvasUnsignedByteArrayConstructor::getConstructData(JSC::ConstructData& constructData) +{ + constructData.native.function = constructCanvasUnsignedByteArray; + return ConstructTypeHost; +} + +} // namespace WebCore + +#endif // ENABLE(3D_CANVAS) diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSCanvasUnsignedByteArrayConstructor.h b/src/3rdparty/webkit/WebCore/bindings/js/JSCanvasUnsignedByteArrayConstructor.h new file mode 100644 index 000000000..9cfb72142 --- /dev/null +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSCanvasUnsignedByteArrayConstructor.h @@ -0,0 +1,46 @@ +/* + * 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. + */ + +#ifndef JSCanvasUnsignedByteArrayConstructor_h +#define JSCanvasUnsignedByteArrayConstructor_h + +#include "JSDOMBinding.h" +#include "JSDocument.h" + +namespace WebCore { + + class JSCanvasUnsignedByteArrayConstructor : public DOMConstructorObject { + public: + JSCanvasUnsignedByteArrayConstructor(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; } + }; + +} + +#endif // JSCanvasUnsignedByteArrayConstructor_h diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSCanvasUnsignedByteArrayCustom.cpp b/src/3rdparty/webkit/WebCore/bindings/js/JSCanvasUnsignedByteArrayCustom.cpp new file mode 100644 index 000000000..f2b0c7453 --- /dev/null +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSCanvasUnsignedByteArrayCustom.cpp @@ -0,0 +1,50 @@ +/* + * 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 "JSCanvasUnsignedByteArray.h" + +#include "CanvasUnsignedByteArray.h" + +using namespace JSC; + +namespace WebCore { + +void JSCanvasUnsignedByteArray::indexSetter(JSC::ExecState* exec, unsigned index, JSC::JSValue value) +{ + impl()->set(index, static_cast<unsigned char>(value.toInt32(exec))); +} + +JSC::JSValue toJS(JSC::ExecState* exec, JSDOMGlobalObject* globalObject, CanvasUnsignedByteArray* object) +{ + return getDOMObjectWrapper<JSCanvasUnsignedByteArray>(exec, globalObject, object); +} + +} // namespace WebCore + +#endif // ENABLE(3D_CANVAS) diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSCanvasUnsignedIntArrayConstructor.cpp b/src/3rdparty/webkit/WebCore/bindings/js/JSCanvasUnsignedIntArrayConstructor.cpp new file mode 100644 index 000000000..5f145a731 --- /dev/null +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSCanvasUnsignedIntArrayConstructor.cpp @@ -0,0 +1,67 @@ +/* + * 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 "JSCanvasUnsignedIntArrayConstructor.h" + +#include "Document.h" +#include "CanvasUnsignedIntArray.h" +#include "JSCanvasArrayBuffer.h" +#include "JSCanvasArrayBufferConstructor.h" +#include "JSCanvasUnsignedIntArray.h" +#include <runtime/Error.h> + +namespace WebCore { + +using namespace JSC; + +const ClassInfo JSCanvasUnsignedIntArrayConstructor::s_info = { "CanvasUnsignedIntArrayConstructor", &JSCanvasArray::s_info, 0, 0 }; + +JSCanvasUnsignedIntArrayConstructor::JSCanvasUnsignedIntArrayConstructor(ExecState* exec, JSDOMGlobalObject* globalObject) + : DOMConstructorObject(JSCanvasUnsignedIntArrayConstructor::createStructure(globalObject->objectPrototype()), globalObject) +{ + putDirect(exec->propertyNames().prototype, JSCanvasUnsignedIntArrayPrototype::self(exec, globalObject), None); + putDirect(exec->propertyNames().length, jsNumber(exec, 2), ReadOnly|DontDelete|DontEnum); +} + +static JSObject* constructCanvasUnsignedIntArray(ExecState* exec, JSObject* constructor, const ArgList& args) +{ + JSCanvasUnsignedIntArrayConstructor* jsConstructor = static_cast<JSCanvasUnsignedIntArrayConstructor*>(constructor); + RefPtr<CanvasUnsignedIntArray> array = static_cast<CanvasUnsignedIntArray*>(construct<CanvasUnsignedIntArray, unsigned int>(exec, args).get()); + return asObject(toJS(exec, jsConstructor->globalObject(), array.get())); +} + +JSC::ConstructType JSCanvasUnsignedIntArrayConstructor::getConstructData(JSC::ConstructData& constructData) +{ + constructData.native.function = constructCanvasUnsignedIntArray; + return ConstructTypeHost; +} + +} // namespace WebCore + +#endif // ENABLE(3D_CANVAS) diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSCanvasUnsignedIntArrayConstructor.h b/src/3rdparty/webkit/WebCore/bindings/js/JSCanvasUnsignedIntArrayConstructor.h new file mode 100644 index 000000000..6016159e3 --- /dev/null +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSCanvasUnsignedIntArrayConstructor.h @@ -0,0 +1,46 @@ +/* + * 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. + */ + +#ifndef JSCanvasUnsignedIntArrayConstructor_h +#define JSCanvasUnsignedIntArrayConstructor_h + +#include "JSDOMBinding.h" +#include "JSDocument.h" + +namespace WebCore { + + class JSCanvasUnsignedIntArrayConstructor : public DOMConstructorObject { + public: + JSCanvasUnsignedIntArrayConstructor(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; } + }; + +} + +#endif // JSCanvasUnsignedIntArrayConstructor_h diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSCanvasUnsignedIntArrayCustom.cpp b/src/3rdparty/webkit/WebCore/bindings/js/JSCanvasUnsignedIntArrayCustom.cpp new file mode 100644 index 000000000..95a80a722 --- /dev/null +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSCanvasUnsignedIntArrayCustom.cpp @@ -0,0 +1,50 @@ +/* + * 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 "JSCanvasUnsignedIntArray.h" + +#include "CanvasUnsignedIntArray.h" + +using namespace JSC; + +namespace WebCore { + +void JSCanvasUnsignedIntArray::indexSetter(JSC::ExecState* exec, unsigned index, JSC::JSValue value) +{ + impl()->set(index, static_cast<unsigned int>(value.toInt32(exec))); +} + +JSC::JSValue toJS(JSC::ExecState* exec, JSDOMGlobalObject* globalObject, CanvasUnsignedIntArray* object) +{ + return getDOMObjectWrapper<JSCanvasUnsignedIntArray>(exec, globalObject, object); +} + +} // namespace WebCore + +#endif // ENABLE(3D_CANVAS) diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSCanvasUnsignedShortArrayConstructor.cpp b/src/3rdparty/webkit/WebCore/bindings/js/JSCanvasUnsignedShortArrayConstructor.cpp new file mode 100644 index 000000000..97356937b --- /dev/null +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSCanvasUnsignedShortArrayConstructor.cpp @@ -0,0 +1,67 @@ +/* + * 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 "JSCanvasUnsignedShortArrayConstructor.h" + +#include "Document.h" +#include "CanvasUnsignedShortArray.h" +#include "JSCanvasArrayBuffer.h" +#include "JSCanvasArrayBufferConstructor.h" +#include "JSCanvasUnsignedShortArray.h" +#include <runtime/Error.h> + +namespace WebCore { + +using namespace JSC; + +const ClassInfo JSCanvasUnsignedShortArrayConstructor::s_info = { "CanvasUnsignedShortArrayConstructor", &JSCanvasArray::s_info, 0, 0 }; + +JSCanvasUnsignedShortArrayConstructor::JSCanvasUnsignedShortArrayConstructor(ExecState* exec, JSDOMGlobalObject* globalObject) + : DOMConstructorObject(JSCanvasUnsignedShortArrayConstructor::createStructure(globalObject->objectPrototype()), globalObject) +{ + putDirect(exec->propertyNames().prototype, JSCanvasUnsignedShortArrayPrototype::self(exec, globalObject), None); + putDirect(exec->propertyNames().length, jsNumber(exec, 2), ReadOnly|DontDelete|DontEnum); +} + +static JSObject* constructCanvasUnsignedShortArray(ExecState* exec, JSObject* constructor, const ArgList& args) +{ + JSCanvasUnsignedShortArrayConstructor* jsConstructor = static_cast<JSCanvasUnsignedShortArrayConstructor*>(constructor); + RefPtr<CanvasUnsignedShortArray> array = static_cast<CanvasUnsignedShortArray*>(construct<CanvasUnsignedShortArray, unsigned short>(exec, args).get()); + return asObject(toJS(exec, jsConstructor->globalObject(), array.get())); +} + +JSC::ConstructType JSCanvasUnsignedShortArrayConstructor::getConstructData(JSC::ConstructData& constructData) +{ + constructData.native.function = constructCanvasUnsignedShortArray; + return ConstructTypeHost; +} + +} // namespace WebCore + +#endif // ENABLE(3D_CANVAS) diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSCanvasUnsignedShortArrayConstructor.h b/src/3rdparty/webkit/WebCore/bindings/js/JSCanvasUnsignedShortArrayConstructor.h new file mode 100644 index 000000000..23c197fde --- /dev/null +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSCanvasUnsignedShortArrayConstructor.h @@ -0,0 +1,46 @@ +/* + * 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. + */ + +#ifndef JSCanvasUnsignedShortArrayConstructor_h +#define JSCanvasUnsignedShortArrayConstructor_h + +#include "JSDOMBinding.h" +#include "JSDocument.h" + +namespace WebCore { + + class JSCanvasUnsignedShortArrayConstructor : public DOMConstructorObject { + public: + JSCanvasUnsignedShortArrayConstructor(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; } + }; + +} + +#endif // JSCanvasUnsignedShortArrayConstructor_h diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSCanvasUnsignedShortArrayCustom.cpp b/src/3rdparty/webkit/WebCore/bindings/js/JSCanvasUnsignedShortArrayCustom.cpp new file mode 100644 index 000000000..290cd4bbf --- /dev/null +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSCanvasUnsignedShortArrayCustom.cpp @@ -0,0 +1,50 @@ +/* + * 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 "JSCanvasUnsignedShortArray.h" + +#include "CanvasUnsignedShortArray.h" + +using namespace JSC; + +namespace WebCore { + +void JSCanvasUnsignedShortArray::indexSetter(JSC::ExecState* exec, unsigned index, JSC::JSValue value) +{ + impl()->set(index, static_cast<unsigned short>(value.toInt32(exec))); +} + +JSC::JSValue toJS(JSC::ExecState* exec, JSDOMGlobalObject* globalObject, CanvasUnsignedShortArray* object) +{ + return getDOMObjectWrapper<JSCanvasUnsignedShortArray>(exec, globalObject, object); +} + +} // namespace WebCore + +#endif // ENABLE(3D_CANVAS) diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSCustomPositionCallback.cpp b/src/3rdparty/webkit/WebCore/bindings/js/JSCustomPositionCallback.cpp index 6abed9901..e5f83aa10 100644 --- a/src/3rdparty/webkit/WebCore/bindings/js/JSCustomPositionCallback.cpp +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSCustomPositionCallback.cpp @@ -35,53 +35,20 @@ namespace WebCore { using namespace JSC; -JSCustomPositionCallback::JSCustomPositionCallback(JSObject* callback, Frame* frame) - : m_callback(callback) - , m_frame(frame) +JSCustomPositionCallback::JSCustomPositionCallback(JSObject* callback, JSDOMGlobalObject* globalObject) + : m_data(callback, globalObject) { } -void JSCustomPositionCallback::handleEvent(Geoposition* geoposition, bool& raisedException) +void JSCustomPositionCallback::handleEvent(Geoposition* geoposition) { - ASSERT(m_callback); - ASSERT(m_frame); - - if (!m_frame->script()->isEnabled()) - return; - - // FIXME: This is likely the wrong globalObject (for prototype chains at least) - JSGlobalObject* globalObject = m_frame->script()->globalObject(); - ExecState* exec = globalObject->globalExec(); - - JSC::JSLock lock(SilenceAssertionsOnly); - - JSValue function = m_callback->get(exec, Identifier(exec, "handleEvent")); - CallData callData; - CallType callType = function.getCallData(callData); - if (callType == CallTypeNone) { - callType = m_callback->getCallData(callData); - if (callType == CallTypeNone) { - // FIXME: Should an exception be thrown here? - return; - } - function = m_callback; - } - RefPtr<JSCustomPositionCallback> protect(this); + JSC::JSLock lock(SilenceAssertionsOnly); + ExecState* exec = m_data.globalObject()->globalExec(); MarkedArgumentBuffer args; args.append(toJS(exec, deprecatedGlobalObjectForPrototype(exec), geoposition)); - - globalObject->globalData()->timeoutChecker.start(); - call(exec, function, callType, callData, m_callback, args); - globalObject->globalData()->timeoutChecker.stop(); - - if (exec->hadException()) { - reportCurrentException(exec); - raisedException = true; - } - - Document::updateStyleForAllDocuments(); + m_data.invokeCallback(args); } } // namespace WebCore diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSCustomPositionCallback.h b/src/3rdparty/webkit/WebCore/bindings/js/JSCustomPositionCallback.h index 6c0d306e0..ad5528dc2 100644 --- a/src/3rdparty/webkit/WebCore/bindings/js/JSCustomPositionCallback.h +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSCustomPositionCallback.h @@ -26,31 +26,28 @@ #ifndef JSCustomPositionCallback_h #define JSCustomPositionCallback_h +#include "JSCallbackData.h" #include "PositionCallback.h" -#include <runtime/JSObject.h> -#include <runtime/Protect.h> #include <wtf/Forward.h> -namespace JSC { - class JSObject; -} - namespace WebCore { -class Frame; class Geoposition; +class JSDOMGlobalObject; class JSCustomPositionCallback : public PositionCallback { public: - static PassRefPtr<JSCustomPositionCallback> create(JSC::JSObject* callback, Frame* frame) { return adoptRef(new JSCustomPositionCallback(callback, frame)); } + static PassRefPtr<JSCustomPositionCallback> create(JSC::JSObject* callback, JSDOMGlobalObject* globalObject) + { + return adoptRef(new JSCustomPositionCallback(callback, globalObject)); + } - virtual void handleEvent(Geoposition*, bool& raisedException); - private: - JSCustomPositionCallback(JSC::JSObject* callback, Frame*); + JSCustomPositionCallback(JSC::JSObject* callback, JSDOMGlobalObject*); - JSC::ProtectedPtr<JSC::JSObject> m_callback; - RefPtr<Frame> m_frame; + virtual void handleEvent(Geoposition*); + + JSCallbackData m_data; }; } // namespace WebCore diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSCustomPositionErrorCallback.cpp b/src/3rdparty/webkit/WebCore/bindings/js/JSCustomPositionErrorCallback.cpp index cda5738f6..bd64deb48 100644 --- a/src/3rdparty/webkit/WebCore/bindings/js/JSCustomPositionErrorCallback.cpp +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSCustomPositionErrorCallback.cpp @@ -35,51 +35,21 @@ namespace WebCore { using namespace JSC; -JSCustomPositionErrorCallback::JSCustomPositionErrorCallback(JSObject* callback, Frame* frame) - : m_callback(callback) - , m_frame(frame) +JSCustomPositionErrorCallback::JSCustomPositionErrorCallback(JSObject* callback, JSDOMGlobalObject* globalObject) + : m_data(callback, globalObject) { } void JSCustomPositionErrorCallback::handleEvent(PositionError* positionError) { - ASSERT(m_callback); - ASSERT(m_frame); - - if (!m_frame->script()->isEnabled()) - return; + RefPtr<JSCustomPositionErrorCallback> protect(this); - // FIXME: This is likely the wrong globalObject (for prototype chains at least) - JSGlobalObject* globalObject = m_frame->script()->globalObject(); - ExecState* exec = globalObject->globalExec(); - JSC::JSLock lock(SilenceAssertionsOnly); - - JSValue function = m_callback->get(exec, Identifier(exec, "handleEvent")); - CallData callData; - CallType callType = function.getCallData(callData); - if (callType == CallTypeNone) { - callType = m_callback->getCallData(callData); - if (callType == CallTypeNone) { - // FIXME: Should an exception be thrown here? - return; - } - function = m_callback; - } - - RefPtr<JSCustomPositionErrorCallback> protect(this); - + ExecState* exec = m_data.globalObject()->globalExec(); MarkedArgumentBuffer args; args.append(toJS(exec, deprecatedGlobalObjectForPrototype(exec), positionError)); - globalObject->globalData()->timeoutChecker.start(); - call(exec, function, callType, callData, m_callback, args); - globalObject->globalData()->timeoutChecker.stop(); - - if (exec->hadException()) - reportCurrentException(exec); - - Document::updateStyleForAllDocuments(); + m_data.invokeCallback(args); } } // namespace WebCore diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSCustomPositionErrorCallback.h b/src/3rdparty/webkit/WebCore/bindings/js/JSCustomPositionErrorCallback.h index 9f143a21d..59328ca9e 100644 --- a/src/3rdparty/webkit/WebCore/bindings/js/JSCustomPositionErrorCallback.h +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSCustomPositionErrorCallback.h @@ -26,31 +26,26 @@ #ifndef JSCustomPositionErrorCallback_h #define JSCustomPositionErrorCallback_h +#include "JSCallbackData.h" #include "PositionErrorCallback.h" -#include <runtime/JSObject.h> -#include <runtime/Protect.h> #include <wtf/Forward.h> -namespace JSC { - class JSObject; -} - namespace WebCore { -class Frame; class PositionError; class JSCustomPositionErrorCallback : public PositionErrorCallback { public: - static PassRefPtr<JSCustomPositionErrorCallback> create(JSC::JSObject* callback, Frame* frame) { return adoptRef(new JSCustomPositionErrorCallback(callback, frame)); } + static PassRefPtr<JSCustomPositionErrorCallback> create(JSC::JSObject* callback, JSDOMGlobalObject* globalObject) + { + return adoptRef(new JSCustomPositionErrorCallback(callback, globalObject)); + } - virtual void handleEvent(PositionError*); - private: - JSCustomPositionErrorCallback(JSC::JSObject* callback, Frame*); - - JSC::ProtectedPtr<JSC::JSObject> m_callback; - RefPtr<Frame> m_frame; + JSCustomPositionErrorCallback(JSC::JSObject* callback, JSDOMGlobalObject* globalObject); + virtual void handleEvent(PositionError*); + + JSCallbackData m_data; }; } // namespace WebCore diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSCustomSQLStatementCallback.cpp b/src/3rdparty/webkit/WebCore/bindings/js/JSCustomSQLStatementCallback.cpp index d0943dede..1f6bd95e9 100644 --- a/src/3rdparty/webkit/WebCore/bindings/js/JSCustomSQLStatementCallback.cpp +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSCustomSQLStatementCallback.cpp @@ -28,6 +28,7 @@ #include "config.h" #include "JSCustomSQLStatementCallback.h" + #if ENABLE(DATABASE) #include "Frame.h" @@ -35,60 +36,38 @@ #include "JSSQLResultSet.h" #include "JSSQLTransaction.h" #include <runtime/JSLock.h> +#include <wtf/MainThread.h> namespace WebCore { using namespace JSC; -JSCustomSQLStatementCallback::JSCustomSQLStatementCallback(JSObject* callback, Frame* frame) - : m_callback(callback) - , m_frame(frame) +JSCustomSQLStatementCallback::JSCustomSQLStatementCallback(JSObject* callback, JSDOMGlobalObject* globalObject) + : m_data(new JSCallbackData(callback, globalObject)) { } -void JSCustomSQLStatementCallback::handleEvent(SQLTransaction* transaction, SQLResultSet* resultSet, bool& raisedException) +JSCustomSQLStatementCallback::~JSCustomSQLStatementCallback() { - ASSERT(m_callback); - ASSERT(m_frame); - - if (!m_frame->script()->isEnabled()) - return; - - // FIXME: This is likely the wrong globalObject (for prototype chains at least) - JSGlobalObject* globalObject = m_frame->script()->globalObject(); - ExecState* exec = globalObject->globalExec(); - - JSC::JSLock lock(SilenceAssertionsOnly); + callOnMainThread(JSCallbackData::deleteData, m_data); +#ifndef NDEBUG + m_data = 0; +#endif +} - JSValue function = m_callback->get(exec, Identifier(exec, "handleEvent")); - CallData callData; - CallType callType = function.getCallData(callData); - if (callType == CallTypeNone) { - callType = m_callback->getCallData(callData); - if (callType == CallTypeNone) { - // FIXME: Should an exception be thrown here? - return; - } - function = m_callback; - } +void JSCustomSQLStatementCallback::handleEvent(SQLTransaction* transaction, SQLResultSet* resultSet, bool& raisedException) +{ + ASSERT(m_data); RefPtr<JSCustomSQLStatementCallback> protect(this); + JSC::JSLock lock(SilenceAssertionsOnly); + ExecState* exec = m_data->globalObject()->globalExec(); MarkedArgumentBuffer args; args.append(toJS(exec, deprecatedGlobalObjectForPrototype(exec), transaction)); args.append(toJS(exec, deprecatedGlobalObjectForPrototype(exec), resultSet)); - - globalObject->globalData()->timeoutChecker.start(); - call(exec, function, callType, callData, m_callback, args); - globalObject->globalData()->timeoutChecker.stop(); - - if (exec->hadException()) { - reportCurrentException(exec); - - raisedException = true; - } - Document::updateStyleForAllDocuments(); + m_data->invokeCallback(args, &raisedException); } } diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSCustomSQLStatementCallback.h b/src/3rdparty/webkit/WebCore/bindings/js/JSCustomSQLStatementCallback.h index c380670ed..259aecf13 100644 --- a/src/3rdparty/webkit/WebCore/bindings/js/JSCustomSQLStatementCallback.h +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSCustomSQLStatementCallback.h @@ -31,32 +31,29 @@ #if ENABLE(DATABASE) +#include "JSCallbackData.h" #include "SQLStatementCallback.h" - -#include <runtime/JSObject.h> -#include <runtime/Protect.h> #include <wtf/Forward.h> -namespace JSC { - class JSObject; -} - namespace WebCore { -class Frame; class SQLResultSet; class JSCustomSQLStatementCallback : public SQLStatementCallback { public: - static PassRefPtr<JSCustomSQLStatementCallback> create(JSC::JSObject* callback, Frame* frame) { return adoptRef(new JSCustomSQLStatementCallback(callback, frame)); } + static PassRefPtr<JSCustomSQLStatementCallback> create(JSC::JSObject* callback, JSDOMGlobalObject* globalObject) + { + return adoptRef(new JSCustomSQLStatementCallback(callback, globalObject)); + } + + virtual ~JSCustomSQLStatementCallback(); virtual void handleEvent(SQLTransaction*, SQLResultSet*, bool& raisedException); private: - JSCustomSQLStatementCallback(JSC::JSObject* callback, Frame*); + JSCustomSQLStatementCallback(JSC::JSObject* callback, JSDOMGlobalObject*); - JSC::ProtectedPtr<JSC::JSObject> m_callback; - RefPtr<Frame> m_frame; + JSCallbackData* m_data; }; } diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSCustomSQLStatementErrorCallback.cpp b/src/3rdparty/webkit/WebCore/bindings/js/JSCustomSQLStatementErrorCallback.cpp index 6c831accc..61785092b 100644 --- a/src/3rdparty/webkit/WebCore/bindings/js/JSCustomSQLStatementErrorCallback.cpp +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSCustomSQLStatementErrorCallback.cpp @@ -32,75 +32,51 @@ #if ENABLE(DATABASE) #include "Frame.h" -#include "ScriptController.h" +#include "JSCallbackData.h" #include "JSSQLError.h" #include "JSSQLTransaction.h" +#include "ScriptController.h" #include <runtime/JSLock.h> +#include <wtf/MainThread.h> namespace WebCore { using namespace JSC; -JSCustomSQLStatementErrorCallback::JSCustomSQLStatementErrorCallback(JSObject* callback, Frame* frame) - : m_callback(callback) - , m_frame(frame) +JSCustomSQLStatementErrorCallback::JSCustomSQLStatementErrorCallback(JSObject* callback, JSDOMGlobalObject* globalObject) + : m_data(new JSCallbackData(callback, globalObject)) { } - -bool JSCustomSQLStatementErrorCallback::handleEvent(SQLTransaction* transaction, SQLError* error) -{ - ASSERT(m_callback); - ASSERT(m_frame); - - if (!m_frame->script()->isEnabled()) - return true; - // FIXME: This is likely the wrong globalObject (for prototype chains at least) - JSGlobalObject* globalObject = m_frame->script()->globalObject(); - ExecState* exec = globalObject->globalExec(); - - JSC::JSLock lock(SilenceAssertionsOnly); - - JSValue handleEventFunction = m_callback->get(exec, Identifier(exec, "handleEvent")); - CallData handleEventCallData; - CallType handleEventCallType = handleEventFunction.getCallData(handleEventCallData); - CallData callbackCallData; - CallType callbackCallType = CallTypeNone; +JSCustomSQLStatementErrorCallback::~JSCustomSQLStatementErrorCallback() +{ + callOnMainThread(JSCallbackData::deleteData, m_data); +#ifndef NDEBUG + m_data = 0; +#endif +} - if (handleEventCallType == CallTypeNone) { - callbackCallType = m_callback->getCallData(callbackCallData); - if (callbackCallType == CallTypeNone) { - // FIXME: Should an exception be thrown here? - return true; - } - } +bool JSCustomSQLStatementErrorCallback::handleEvent(SQLTransaction* transaction, SQLError* error) +{ + ASSERT(m_data); RefPtr<JSCustomSQLStatementErrorCallback> protect(this); + JSC::JSLock lock(SilenceAssertionsOnly); + ExecState* exec = m_data->globalObject()->globalExec(); MarkedArgumentBuffer args; args.append(toJS(exec, deprecatedGlobalObjectForPrototype(exec), transaction)); args.append(toJS(exec, deprecatedGlobalObjectForPrototype(exec), error)); - - JSValue result; - globalObject->globalData()->timeoutChecker.start(); - if (handleEventCallType != CallTypeNone) - result = call(exec, handleEventFunction, handleEventCallType, handleEventCallData, m_callback, args); - else - result = call(exec, m_callback, callbackCallType, callbackCallData, m_callback, args); - globalObject->globalData()->timeoutChecker.stop(); - - if (exec->hadException()) { - reportCurrentException(exec); - + + bool raisedException = false; + JSValue result = m_data->invokeCallback(args, &raisedException); + if (raisedException) { // The spec says: // "If the error callback returns false, then move on to the next statement..." // "Otherwise, the error callback did not return false, or there was no error callback" // Therefore an exception and returning true are the same thing - so, return true on an exception return true; } - - Document::updateStyleForAllDocuments(); - return result.toBoolean(exec); } diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSCustomSQLStatementErrorCallback.h b/src/3rdparty/webkit/WebCore/bindings/js/JSCustomSQLStatementErrorCallback.h index e56339316..ac4e45f9f 100644 --- a/src/3rdparty/webkit/WebCore/bindings/js/JSCustomSQLStatementErrorCallback.h +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSCustomSQLStatementErrorCallback.h @@ -31,32 +31,31 @@ #if ENABLE(DATABASE) +#include "JSDOMGlobalObject.h" #include "SQLStatementErrorCallback.h" - -#include <runtime/JSObject.h> #include <runtime/Protect.h> #include <wtf/Forward.h> -namespace JSC { - class JSObject; -} - namespace WebCore { - -class Frame; + +class JSCallbackData; class SQLError; class JSCustomSQLStatementErrorCallback : public SQLStatementErrorCallback { public: - static PassRefPtr<JSCustomSQLStatementErrorCallback> create(JSC::JSObject* callback, Frame* frame) { return adoptRef(new JSCustomSQLStatementErrorCallback(callback, frame)); } - + static PassRefPtr<JSCustomSQLStatementErrorCallback> create(JSC::JSObject* callback, JSDOMGlobalObject* globalObject) + { + return adoptRef(new JSCustomSQLStatementErrorCallback(callback, globalObject)); + } + + virtual ~JSCustomSQLStatementErrorCallback(); + virtual bool handleEvent(SQLTransaction*, SQLError*); private: - JSCustomSQLStatementErrorCallback(JSC::JSObject* callback, Frame*); + JSCustomSQLStatementErrorCallback(JSC::JSObject* callback, JSDOMGlobalObject*); - JSC::ProtectedPtr<JSC::JSObject> m_callback; - RefPtr<Frame> m_frame; + JSCallbackData* m_data; }; } diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSCustomSQLTransactionCallback.cpp b/src/3rdparty/webkit/WebCore/bindings/js/JSCustomSQLTransactionCallback.cpp index 3d42f814f..456022f9f 100644 --- a/src/3rdparty/webkit/WebCore/bindings/js/JSCustomSQLTransactionCallback.cpp +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSCustomSQLTransactionCallback.cpp @@ -32,9 +32,11 @@ #if ENABLE(DATABASE) #include "Frame.h" -#include "ScriptController.h" +#include "JSCallbackData.h" +#include "JSDOMGlobalObject.h" #include "JSSQLTransaction.h" #include "Page.h" +#include "ScriptController.h" #include <runtime/JSLock.h> #include <wtf/MainThread.h> #include <wtf/RefCountedLeakCounter.h> @@ -47,39 +49,17 @@ using namespace JSC; static WTF::RefCountedLeakCounter counter("JSCustomSQLTransactionCallback"); #endif -// We have to clean up the data on the main thread for two reasons: -// -// 1) Can't deref a Frame on a non-main thread. -// 2) Unprotecting the JSObject on a non-main thread would register that thread -// for JavaScript garbage collection, which could unnecessarily slow things down. - -class JSCustomSQLTransactionCallback::Data { -public: - Data(JSObject* callback, Frame* frame) : m_callback(callback), m_frame(frame) { } - JSObject* callback() { return m_callback; } - Frame* frame() { return m_frame.get(); } - -private: - ProtectedPtr<JSObject> m_callback; - RefPtr<Frame> m_frame; -}; - -JSCustomSQLTransactionCallback::JSCustomSQLTransactionCallback(JSObject* callback, Frame* frame) - : m_data(new Data(callback, frame)) +JSCustomSQLTransactionCallback::JSCustomSQLTransactionCallback(JSObject* callback, JSDOMGlobalObject* globalObject) + : m_data(new JSCallbackData(callback, globalObject)) { #ifndef NDEBUG counter.increment(); #endif } -void JSCustomSQLTransactionCallback::deleteData(void* context) -{ - delete static_cast<Data*>(context); -} - JSCustomSQLTransactionCallback::~JSCustomSQLTransactionCallback() { - callOnMainThread(deleteData, m_data); + callOnMainThread(JSCallbackData::deleteData, m_data); #ifndef NDEBUG m_data = 0; counter.decrement(); @@ -89,51 +69,14 @@ JSCustomSQLTransactionCallback::~JSCustomSQLTransactionCallback() void JSCustomSQLTransactionCallback::handleEvent(SQLTransaction* transaction, bool& raisedException) { ASSERT(m_data); - ASSERT(m_data->callback()); - ASSERT(m_data->frame()); - if (!m_data->frame()->script()->isEnabled()) - return; - - // FIXME: This is likely the wrong globalObject (for prototype chains at least) - JSGlobalObject* globalObject = m_data->frame()->script()->globalObject(); - ExecState* exec = globalObject->globalExec(); - - JSC::JSLock lock(SilenceAssertionsOnly); - - JSValue handleEventFunction = m_data->callback()->get(exec, Identifier(exec, "handleEvent")); - CallData handleEventCallData; - CallType handleEventCallType = handleEventFunction.getCallData(handleEventCallData); - CallData callbackCallData; - CallType callbackCallType = CallTypeNone; - - if (handleEventCallType == CallTypeNone) { - callbackCallType = m_data->callback()->getCallData(callbackCallData); - if (callbackCallType == CallTypeNone) { - // FIXME: Should an exception be thrown here? - return; - } - } - RefPtr<JSCustomSQLTransactionCallback> protect(this); + JSC::JSLock lock(SilenceAssertionsOnly); + ExecState* exec = m_data->globalObject()->globalExec(); MarkedArgumentBuffer args; args.append(toJS(exec, deprecatedGlobalObjectForPrototype(exec), transaction)); - - globalObject->globalData()->timeoutChecker.start(); - if (handleEventCallType != CallTypeNone) - call(exec, handleEventFunction, handleEventCallType, handleEventCallData, m_data->callback(), args); - else - call(exec, m_data->callback(), callbackCallType, callbackCallData, m_data->callback(), args); - globalObject->globalData()->timeoutChecker.stop(); - - if (exec->hadException()) { - reportCurrentException(exec); - - raisedException = true; - } - - Document::updateStyleForAllDocuments(); + m_data->invokeCallback(args, &raisedException); } } diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSCustomSQLTransactionCallback.h b/src/3rdparty/webkit/WebCore/bindings/js/JSCustomSQLTransactionCallback.h index 22c367c14..f142e59b8 100644 --- a/src/3rdparty/webkit/WebCore/bindings/js/JSCustomSQLTransactionCallback.h +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSCustomSQLTransactionCallback.h @@ -32,7 +32,6 @@ #if ENABLE(DATABASE) #include "SQLTransactionCallback.h" - #include <wtf/PassRefPtr.h> namespace JSC { @@ -42,22 +41,24 @@ namespace JSC { namespace WebCore { class Frame; +class JSCallbackData; +class JSDOMGlobalObject; class JSCustomSQLTransactionCallback : public SQLTransactionCallback { public: - static PassRefPtr<JSCustomSQLTransactionCallback> create(JSC::JSObject* callback, Frame* frame) { return adoptRef(new JSCustomSQLTransactionCallback(callback, frame)); } + static PassRefPtr<JSCustomSQLTransactionCallback> create(JSC::JSObject* callback, JSDOMGlobalObject* globalObject) + { + return adoptRef(new JSCustomSQLTransactionCallback(callback, globalObject)); + } virtual ~JSCustomSQLTransactionCallback(); virtual void handleEvent(SQLTransaction*, bool& raisedException); private: - JSCustomSQLTransactionCallback(JSC::JSObject* callback, Frame*); - - static void deleteData(void*); + JSCustomSQLTransactionCallback(JSC::JSObject* callback, JSDOMGlobalObject*); - class Data; - Data* m_data; + JSCallbackData* m_data; }; } diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSCustomSQLTransactionErrorCallback.cpp b/src/3rdparty/webkit/WebCore/bindings/js/JSCustomSQLTransactionErrorCallback.cpp index 2d41bb824..331e014c7 100644 --- a/src/3rdparty/webkit/WebCore/bindings/js/JSCustomSQLTransactionErrorCallback.cpp +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSCustomSQLTransactionErrorCallback.cpp @@ -32,59 +32,40 @@ #if ENABLE(DATABASE) #include "Frame.h" -#include "ScriptController.h" +#include "JSCallbackData.h" #include "JSSQLError.h" +#include "ScriptController.h" #include <runtime/JSLock.h> +#include <wtf/MainThread.h> namespace WebCore { using namespace JSC; -JSCustomSQLTransactionErrorCallback::JSCustomSQLTransactionErrorCallback(JSObject* callback, Frame* frame) - : m_callback(callback) - , m_frame(frame) +JSCustomSQLTransactionErrorCallback::JSCustomSQLTransactionErrorCallback(JSObject* callback, JSDOMGlobalObject* globalObject) + : m_data(new JSCallbackData(callback, globalObject)) { } - -void JSCustomSQLTransactionErrorCallback::handleEvent(SQLError* error) -{ - ASSERT(m_callback); - ASSERT(m_frame); - - if (!m_frame->script()->isEnabled()) - return; - // FIXME: This is likely the wrong globalObject (for prototype chains at least) - JSGlobalObject* globalObject = m_frame->script()->globalObject(); - ExecState* exec = globalObject->globalExec(); - - JSC::JSLock lock(SilenceAssertionsOnly); +JSCustomSQLTransactionErrorCallback::~JSCustomSQLTransactionErrorCallback() +{ + callOnMainThread(JSCallbackData::deleteData, m_data); +#ifndef NDEBUG + m_data = 0; +#endif +} - JSValue function = m_callback->get(exec, Identifier(exec, "handleEvent")); - CallData callData; - CallType callType = function.getCallData(callData); - if (callType == CallTypeNone) { - callType = m_callback->getCallData(callData); - if (callType == CallTypeNone) { - // FIXME: Should an exception be thrown here? - return; - } - function = m_callback; - } +void JSCustomSQLTransactionErrorCallback::handleEvent(SQLError* error) +{ + ASSERT(m_data); RefPtr<JSCustomSQLTransactionErrorCallback> protect(this); + JSC::JSLock lock(SilenceAssertionsOnly); + ExecState* exec = m_data->globalObject()->globalExec(); MarkedArgumentBuffer args; args.append(toJS(exec, deprecatedGlobalObjectForPrototype(exec), error)); - - globalObject->globalData()->timeoutChecker.start(); - call(exec, function, callType, callData, m_callback, args); - globalObject->globalData()->timeoutChecker.stop(); - - if (exec->hadException()) - reportCurrentException(exec); - - Document::updateStyleForAllDocuments(); + m_data->invokeCallback(args); } } diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSCustomSQLTransactionErrorCallback.h b/src/3rdparty/webkit/WebCore/bindings/js/JSCustomSQLTransactionErrorCallback.h index be3df29de..54bf33b8c 100644 --- a/src/3rdparty/webkit/WebCore/bindings/js/JSCustomSQLTransactionErrorCallback.h +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSCustomSQLTransactionErrorCallback.h @@ -32,31 +32,30 @@ #if ENABLE(DATABASE) #include "SQLTransactionErrorCallback.h" - -#include <runtime/JSObject.h> +#include "JSDOMGlobalObject.h" #include <runtime/Protect.h> #include <wtf/Forward.h> -namespace JSC { - class JSObject; -} - namespace WebCore { -class Frame; +class JSCallbackData; class SQLError; class JSCustomSQLTransactionErrorCallback : public SQLTransactionErrorCallback { public: - static PassRefPtr<JSCustomSQLTransactionErrorCallback> create(JSC::JSObject* callback, Frame* frame) { return adoptRef(new JSCustomSQLTransactionErrorCallback(callback, frame)); } + static PassRefPtr<JSCustomSQLTransactionErrorCallback> create(JSC::JSObject* callback, JSDOMGlobalObject* globalObject) + { + return adoptRef(new JSCustomSQLTransactionErrorCallback(callback, globalObject)); + } + + virtual ~JSCustomSQLTransactionErrorCallback(); virtual void handleEvent(SQLError*); private: - JSCustomSQLTransactionErrorCallback(JSC::JSObject* callback, Frame*); + JSCustomSQLTransactionErrorCallback(JSC::JSObject* callback, JSDOMGlobalObject* globalObject); - JSC::ProtectedPtr<JSC::JSObject> m_callback; - RefPtr<Frame> m_frame; + JSCallbackData* m_data; }; } diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSCustomVoidCallback.cpp b/src/3rdparty/webkit/WebCore/bindings/js/JSCustomVoidCallback.cpp index b4e525b98..0edd66fdd 100644 --- a/src/3rdparty/webkit/WebCore/bindings/js/JSCustomVoidCallback.cpp +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSCustomVoidCallback.cpp @@ -30,70 +30,38 @@ #include "JSCustomVoidCallback.h" #include "Frame.h" +#include "JSCallbackData.h" #include "JSDOMWindowCustom.h" #include "ScriptController.h" #include <runtime/JSLock.h> +#include <wtf/MainThread.h> namespace WebCore { using namespace JSC; -JSCustomVoidCallback::JSCustomVoidCallback(JSObject* callback, Frame* frame) - : m_callback(callback) - , m_frame(frame) +JSCustomVoidCallback::JSCustomVoidCallback(JSObject* callback, JSDOMGlobalObject* globalObject) + : m_data(new JSCallbackData(callback, globalObject)) { } + +JSCustomVoidCallback::~JSCustomVoidCallback() +{ + callOnMainThread(JSCallbackData::deleteData, m_data); +#ifndef NDEBUG + m_data = 0; +#endif +} void JSCustomVoidCallback::handleEvent() { - ASSERT(m_callback); - ASSERT(m_frame); - - if (!m_frame->script()->isEnabled()) - return; - - JSGlobalObject* globalObject = m_frame->script()->globalObject(); - ExecState* exec = globalObject->globalExec(); - - JSC::JSLock lock(SilenceAssertionsOnly); - - JSValue function = m_callback->get(exec, Identifier(exec, "handleEvent")); - CallData callData; - CallType callType = function.getCallData(callData); - if (callType == CallTypeNone) { - callType = m_callback->getCallData(callData); - if (callType == CallTypeNone) { - // FIXME: Should an exception be thrown here? - return; - } - function = m_callback; - } - + ASSERT(m_data); + RefPtr<JSCustomVoidCallback> protect(this); + JSC::JSLock lock(SilenceAssertionsOnly); MarkedArgumentBuffer args; - - globalObject->globalData()->timeoutChecker.start(); - call(exec, function, callType, callData, m_callback, args); - globalObject->globalData()->timeoutChecker.stop(); - - if (exec->hadException()) - reportCurrentException(exec); - - Document::updateStyleForAllDocuments(); -} - -PassRefPtr<VoidCallback> toVoidCallback(ExecState* exec, JSValue value) -{ - JSObject* object = value.getObject(); - if (!object) - return 0; - - Frame* frame = asJSDOMWindow(exec->dynamicGlobalObject())->impl()->frame(); - if (!frame) - return 0; - - return JSCustomVoidCallback::create(object, frame); + m_data->invokeCallback(args); } -} +} // namespace WebCore diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSCustomVoidCallback.h b/src/3rdparty/webkit/WebCore/bindings/js/JSCustomVoidCallback.h index 9cd7c34ea..4b8d7ea39 100644 --- a/src/3rdparty/webkit/WebCore/bindings/js/JSCustomVoidCallback.h +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSCustomVoidCallback.h @@ -29,33 +29,31 @@ #ifndef JSCustomVoidCallback_h #define JSCustomVoidCallback_h +#include "JSDOMGlobalObject.h" #include "VoidCallback.h" - -#include <runtime/JSObject.h> #include <runtime/Protect.h> #include <wtf/Forward.h> namespace WebCore { + +class JSCallbackData; + +class JSCustomVoidCallback : public VoidCallback { +public: + static PassRefPtr<JSCustomVoidCallback> create(JSC::JSObject* callback, JSDOMGlobalObject* globalObject) + { + return adoptRef(new JSCustomVoidCallback(callback, globalObject)); + } - class Frame; + virtual ~JSCustomVoidCallback(); - class JSCustomVoidCallback : public VoidCallback { - public: - static PassRefPtr<JSCustomVoidCallback> create(JSC::JSObject* callback, Frame* frame) - { - return adoptRef(new JSCustomVoidCallback(callback, frame)); - } - - virtual void handleEvent(); - - private: - JSCustomVoidCallback(JSC::JSObject* callback, Frame*); - - JSC::ProtectedPtr<JSC::JSObject> m_callback; - RefPtr<Frame> m_frame; - }; - - PassRefPtr<VoidCallback> toVoidCallback(JSC::ExecState*, JSC::JSValue); + virtual void handleEvent(); + +private: + JSCustomVoidCallback(JSC::JSObject* callback, JSDOMGlobalObject*); + + JSCallbackData* m_data; +}; } // namespace WebCore diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSCustomXPathNSResolver.cpp b/src/3rdparty/webkit/WebCore/bindings/js/JSCustomXPathNSResolver.cpp index 4476be583..c2884d7a3 100644 --- a/src/3rdparty/webkit/WebCore/bindings/js/JSCustomXPathNSResolver.cpp +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSCustomXPathNSResolver.cpp @@ -49,13 +49,13 @@ PassRefPtr<JSCustomXPathNSResolver> JSCustomXPathNSResolver::create(JSC::ExecSta setDOMException(exec, TYPE_MISMATCH_ERR); return 0; } - - return adoptRef(new JSCustomXPathNSResolver(resolverObject, asJSDOMWindow(exec->dynamicGlobalObject())->impl()->frame())); + + return adoptRef(new JSCustomXPathNSResolver(resolverObject, asJSDOMWindow(exec->dynamicGlobalObject()))); } -JSCustomXPathNSResolver::JSCustomXPathNSResolver(JSObject* customResolver, Frame* frame) +JSCustomXPathNSResolver::JSCustomXPathNSResolver(JSObject* customResolver, JSDOMWindow* globalObject) : m_customResolver(customResolver) - , m_frame(frame) + , m_globalObject(globalObject) { } @@ -67,15 +67,9 @@ String JSCustomXPathNSResolver::lookupNamespaceURI(const String& prefix) { ASSERT(m_customResolver); - if (!m_frame) - return String(); - if (!m_frame->script()->isEnabled()) - return String(); - JSLock lock(SilenceAssertionsOnly); - JSGlobalObject* globalObject = m_frame->script()->globalObject(); - ExecState* exec = globalObject->globalExec(); + ExecState* exec = m_globalObject->globalExec(); JSValue function = m_customResolver->get(exec, Identifier(exec, "lookupNamespaceURI")); CallData callData; @@ -84,7 +78,7 @@ String JSCustomXPathNSResolver::lookupNamespaceURI(const String& prefix) callType = m_customResolver->getCallData(callData); if (callType == CallTypeNone) { // FIXME: Pass actual line number and source URL. - m_frame->domWindow()->console()->addMessage(JSMessageSource, LogMessageType, ErrorMessageLevel, "XPathNSResolver does not have a lookupNamespaceURI method.", 0, String()); + m_globalObject->impl()->console()->addMessage(JSMessageSource, LogMessageType, ErrorMessageLevel, "XPathNSResolver does not have a lookupNamespaceURI method.", 0, String()); return String(); } function = m_customResolver; @@ -95,9 +89,9 @@ String JSCustomXPathNSResolver::lookupNamespaceURI(const String& prefix) MarkedArgumentBuffer args; args.append(jsString(exec, prefix)); - globalObject->globalData()->timeoutChecker.start(); - JSValue retval = call(exec, function, callType, callData, m_customResolver, args); - globalObject->globalData()->timeoutChecker.stop(); + m_globalObject->globalData()->timeoutChecker.start(); + JSValue retval = callInWorld(exec, function, callType, callData, m_customResolver, args, currentWorld(m_globalObject->globalExec())); + m_globalObject->globalData()->timeoutChecker.stop(); String result; if (exec->hadException()) diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSCustomXPathNSResolver.h b/src/3rdparty/webkit/WebCore/bindings/js/JSCustomXPathNSResolver.h index 44c44f964..7d664948d 100644 --- a/src/3rdparty/webkit/WebCore/bindings/js/JSCustomXPathNSResolver.h +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSCustomXPathNSResolver.h @@ -41,6 +41,7 @@ namespace JSC { namespace WebCore { class Frame; + class JSDOMWindow; class JSCustomXPathNSResolver : public XPathNSResolver { public: @@ -51,10 +52,11 @@ namespace WebCore { virtual String lookupNamespaceURI(const String& prefix); private: - JSCustomXPathNSResolver(JSC::JSObject*, Frame*); + JSCustomXPathNSResolver(JSC::JSObject*, JSDOMWindow*); - JSC::JSObject* m_customResolver; // JSCustomXPathNSResolvers are always temporary, thus no need to GC protect the object. - RefPtr<Frame> m_frame; + // JSCustomXPathNSResolvers are always temporary, thus no need to GC protect the objects. + JSC::JSObject* m_customResolver; + JSDOMWindow* m_globalObject; }; } // namespace WebCore diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSDOMApplicationCacheCustom.cpp b/src/3rdparty/webkit/WebCore/bindings/js/JSDOMApplicationCacheCustom.cpp index a7fae788e..91ee51ada 100644 --- a/src/3rdparty/webkit/WebCore/bindings/js/JSDOMApplicationCacheCustom.cpp +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSDOMApplicationCacheCustom.cpp @@ -42,28 +42,6 @@ using namespace JSC; namespace WebCore { -void JSDOMApplicationCache::mark() -{ - Base::mark(); - - markIfNotNull(m_impl->onchecking()); - markIfNotNull(m_impl->onerror()); - markIfNotNull(m_impl->onnoupdate()); - markIfNotNull(m_impl->ondownloading()); - markIfNotNull(m_impl->onprogress()); - markIfNotNull(m_impl->onupdateready()); - markIfNotNull(m_impl->oncached()); - markIfNotNull(m_impl->onobsolete()); - - typedef DOMApplicationCache::EventListenersMap EventListenersMap; - typedef DOMApplicationCache::ListenerVector ListenerVector; - EventListenersMap& eventListeners = m_impl->eventListeners(); - for (EventListenersMap::iterator mapIter = eventListeners.begin(); mapIter != eventListeners.end(); ++mapIter) { - for (ListenerVector::iterator vecIter = mapIter->second.begin(); vecIter != mapIter->second.end(); ++vecIter) - (*vecIter)->markJSFunction(); - } -} - #if ENABLE(APPLICATION_CACHE_DYNAMIC_ENTRIES) JSValue JSDOMApplicationCache::hasItem(ExecState* exec, const ArgList& args) @@ -109,25 +87,21 @@ JSValue JSDOMApplicationCache::remove(ExecState* exec, const ArgList& args) JSValue JSDOMApplicationCache::addEventListener(ExecState* exec, const ArgList& args) { - JSDOMGlobalObject* globalObject = toJSDOMGlobalObject(impl()->scriptExecutionContext()); - if (!globalObject) - return jsUndefined(); - RefPtr<JSEventListener> listener = globalObject->findOrCreateJSEventListener(args.at(1)); - if (!listener) + JSValue listener = args.at(1); + if (!listener.isObject()) return jsUndefined(); - impl()->addEventListener(args.at(0).toString(exec), listener.release(), args.at(2).toBoolean(exec)); + + impl()->addEventListener(args.at(0).toString(exec), JSEventListener::create(asObject(listener), false, currentWorld(exec)), args.at(2).toBoolean(exec)); return jsUndefined(); } JSValue JSDOMApplicationCache::removeEventListener(ExecState* exec, const ArgList& args) { - JSDOMGlobalObject* globalObject = toJSDOMGlobalObject(impl()->scriptExecutionContext()); - if (!globalObject) - return jsUndefined(); - JSEventListener* listener = globalObject->findJSEventListener(args.at(1)); - if (!listener) + JSValue listener = args.at(1); + if (!listener.isObject()) return jsUndefined(); - impl()->removeEventListener(args.at(0).toString(exec), listener, args.at(2).toBoolean(exec)); + + impl()->removeEventListener(args.at(0).toString(exec), JSEventListener::create(asObject(listener), false, currentWorld(exec)).get(), args.at(2).toBoolean(exec)); return jsUndefined(); } diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSDOMBinding.cpp b/src/3rdparty/webkit/WebCore/bindings/js/JSDOMBinding.cpp index 910da12b8..ef69c7b1e 100644 --- a/src/3rdparty/webkit/WebCore/bindings/js/JSDOMBinding.cpp +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSDOMBinding.cpp @@ -18,27 +18,27 @@ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ -// gcc 3.x can't handle including the HashMap pointer specialization in this file -#if defined __GNUC__ && !defined __GLIBCXX__ // less than gcc 3.4 -#define HASH_MAP_PTR_SPEC_WORKAROUND 1 -#endif - #include "config.h" #include "JSDOMBinding.h" +#include "debugger/DebuggerCallFrame.h" + #include "ActiveDOMObject.h" #include "DOMCoreException.h" #include "Document.h" #include "EventException.h" +#include "ExceptionBase.h" #include "ExceptionCode.h" #include "Frame.h" #include "HTMLAudioElement.h" +#include "HTMLCanvasElement.h" #include "HTMLImageElement.h" #include "HTMLScriptElement.h" #include "HTMLNames.h" #include "JSDOMCoreException.h" #include "JSDOMWindowCustom.h" #include "JSEventException.h" +#include "JSExceptionBase.h" #include "JSNode.h" #include "JSRangeException.h" #include "JSXMLHttpRequestException.h" @@ -46,7 +46,10 @@ #include "MessagePort.h" #include "RangeException.h" #include "ScriptController.h" +#include "Settings.h" #include "XMLHttpRequestException.h" +#include <runtime/Error.h> +#include <runtime/JSFunction.h> #include <runtime/PrototypeFunction.h> #include <wtf/StdLibExtras.h> @@ -72,6 +75,7 @@ namespace WebCore { using namespace HTMLNames; typedef Document::JSWrapperCache JSWrapperCache; +typedef Document::JSWrapperCacheMap JSWrapperCacheMap; // For debugging, keep a set of wrappers currently registered, and check that // all are unregistered before they are destroyed. This has helped us fix at @@ -80,6 +84,7 @@ typedef Document::JSWrapperCache JSWrapperCache; static void addWrapper(DOMObject* wrapper); static void removeWrapper(DOMObject* wrapper); static void removeWrappers(const JSWrapperCache& wrappers); +static void removeWrappers(const DOMObjectWrapperMap& wrappers); #ifdef NDEBUG @@ -95,6 +100,10 @@ static inline void removeWrappers(const JSWrapperCache&) { } +static inline void removeWrappers(const DOMObjectWrapperMap&) +{ +} + #else static HashSet<DOMObject*>& wrapperSet() @@ -124,7 +133,15 @@ static void removeWrapper(DOMObject* wrapper) static void removeWrappers(const JSWrapperCache& wrappers) { - for (JSWrapperCache::const_iterator it = wrappers.begin(); it != wrappers.end(); ++it) + JSWrapperCache::const_iterator wrappersEnd = wrappers.end(); + for (JSWrapperCache::const_iterator it = wrappers.begin(); it != wrappersEnd; ++it) + removeWrapper(it->second); +} + +static inline void removeWrappers(const DOMObjectWrapperMap& wrappers) +{ + DOMObjectWrapperMap::const_iterator wrappersEnd = wrappers.end(); + for (DOMObjectWrapperMap::const_iterator it = wrappers.begin(); it != wrappersEnd; ++it) removeWrapper(it->second); } @@ -135,67 +152,120 @@ DOMObject::~DOMObject() #endif -class DOMObjectWrapperMap { -public: - static DOMObjectWrapperMap& mapFor(JSGlobalData&); +DOMWrapperWorld::DOMWrapperWorld(JSC::JSGlobalData* globalData) + : m_globalData(globalData) +{ +} + +DOMWrapperWorld::~DOMWrapperWorld() +{ + JSGlobalData::ClientData* clientData = m_globalData->clientData; + ASSERT(clientData); + static_cast<WebCoreJSClientData*>(clientData)->forgetWorld(this); + + removeWrappers(m_wrappers); - DOMObject* get(void* objectHandle) + for (HashSet<Document*>::iterator iter = documentsWithWrappers.begin(); iter != documentsWithWrappers.end(); ++iter) + forgetWorldOfDOMNodesForDocument(*iter, this); + for (HashSet<ScriptController*>::iterator iter = scriptControllersWithShells.begin(); iter != scriptControllersWithShells.end(); ++iter) + (*iter)->forgetWorld(this); +} + +EnterDOMWrapperWorld::EnterDOMWrapperWorld(JSC::JSGlobalData& globalData, DOMWrapperWorld* isolatedWorld) +{ + JSGlobalData::ClientData* clientData = globalData.clientData; + ASSERT(clientData); + m_clientData = static_cast<WebCoreJSClientData*>(clientData); + m_clientData->m_worldStack.append(isolatedWorld); +} + +EnterDOMWrapperWorld::EnterDOMWrapperWorld(JSC::ExecState* exec, DOMWrapperWorld* isolatedWorld) +{ + JSGlobalData::ClientData* clientData = exec->globalData().clientData; + ASSERT(clientData); + m_clientData = static_cast<WebCoreJSClientData*>(clientData); + m_clientData->m_worldStack.append(isolatedWorld); +} + +EnterDOMWrapperWorld::~EnterDOMWrapperWorld() +{ + m_clientData->m_worldStack.removeLast(); +} + +class JSGlobalDataWorldIterator { +public: + JSGlobalDataWorldIterator(JSGlobalData* globalData) + : m_pos(static_cast<WebCoreJSClientData*>(globalData->clientData)->m_worldSet.begin()) + , m_end(static_cast<WebCoreJSClientData*>(globalData->clientData)->m_worldSet.end()) { - return m_map.get(objectHandle); } - void set(void* objectHandle, DOMObject* wrapper) + operator bool() { - addWrapper(wrapper); - m_map.set(objectHandle, wrapper); + return m_pos != m_end; } - void remove(void* objectHandle) + DOMWrapperWorld* operator*() { - removeWrapper(m_map.take(objectHandle)); + ASSERT(m_pos != m_end); + return *m_pos; } -private: - HashMap<void*, DOMObject*> m_map; -}; - -// Map from static HashTable instances to per-GlobalData ones. -class DOMObjectHashTableMap { -public: - static DOMObjectHashTableMap& mapFor(JSGlobalData&); - - ~DOMObjectHashTableMap() + DOMWrapperWorld* operator->() { - HashMap<const JSC::HashTable*, JSC::HashTable>::iterator mapEnd = m_map.end(); - for (HashMap<const JSC::HashTable*, JSC::HashTable>::iterator iter = m_map.begin(); iter != m_map.end(); ++iter) - iter->second.deleteTable(); + ASSERT(m_pos != m_end); + return *m_pos; } - const JSC::HashTable* get(const JSC::HashTable* staticTable) + JSGlobalDataWorldIterator& operator++() { - HashMap<const JSC::HashTable*, JSC::HashTable>::iterator iter = m_map.find(staticTable); - if (iter != m_map.end()) - return &iter->second; - return &m_map.set(staticTable, JSC::HashTable(*staticTable)).first->second; + ++m_pos; + return *this; } private: - HashMap<const JSC::HashTable*, JSC::HashTable> m_map; + HashSet<DOMWrapperWorld*>::iterator m_pos; + HashSet<DOMWrapperWorld*>::iterator m_end; }; -class WebCoreJSClientData : public JSGlobalData::ClientData { -public: - DOMObjectHashTableMap hashTableMap; - DOMObjectWrapperMap wrapperMap; -}; +static inline DOMWrapperWorld* currentWorld(JSC::JSGlobalData& globalData) +{ + JSGlobalData::ClientData* clientData = globalData.clientData; + ASSERT(clientData); + return static_cast<WebCoreJSClientData*>(clientData)->currentWorld(); +} + +DOMWrapperWorld* currentWorld(JSC::ExecState* exec) +{ + return currentWorld(exec->globalData()); +} + +DOMWrapperWorld* normalWorld(JSC::JSGlobalData& globalData) +{ + JSGlobalData::ClientData* clientData = globalData.clientData; + ASSERT(clientData); + return static_cast<WebCoreJSClientData*>(clientData)->normalWorld(); +} + +DOMWrapperWorld* mainThreadNormalWorld() +{ + ASSERT(isMainThread()); + return normalWorld(*JSDOMWindow::commonJSGlobalData()); +} + +DOMWrapperWorld* mainThreadCurrentWorld() +{ + ASSERT(isMainThread()); + + JSGlobalData::ClientData* clientData = JSDOMWindowBase::commonJSGlobalData()->clientData; + ASSERT(clientData); + return static_cast<WebCoreJSClientData*>(clientData)->currentWorld(); +} DOMObjectHashTableMap& DOMObjectHashTableMap::mapFor(JSGlobalData& globalData) { JSGlobalData::ClientData* clientData = globalData.clientData; - if (!clientData) { - clientData = new WebCoreJSClientData; - globalData.clientData = clientData; - } + ASSERT(clientData); return static_cast<WebCoreJSClientData*>(clientData)->hashTableMap; } @@ -204,64 +274,102 @@ const JSC::HashTable* getHashTableForGlobalData(JSGlobalData& globalData, const return DOMObjectHashTableMap::mapFor(globalData).get(staticTable); } -inline DOMObjectWrapperMap& DOMObjectWrapperMap::mapFor(JSGlobalData& globalData) +//inline DOMObjectWrapperMap& DOMObjectWrapperMap::mapFor(JSGlobalData& globalData) +inline DOMObjectWrapperMap& DOMObjectWrapperMapFor(JSGlobalData& globalData) { - JSGlobalData::ClientData* clientData = globalData.clientData; - if (!clientData) { - clientData = new WebCoreJSClientData; - globalData.clientData = clientData; - } - return static_cast<WebCoreJSClientData*>(clientData)->wrapperMap; + return currentWorld(globalData)->m_wrappers; } DOMObject* getCachedDOMObjectWrapper(JSGlobalData& globalData, void* objectHandle) { - return DOMObjectWrapperMap::mapFor(globalData).get(objectHandle); + return DOMObjectWrapperMapFor(globalData).get(objectHandle); } void cacheDOMObjectWrapper(JSGlobalData& globalData, void* objectHandle, DOMObject* wrapper) { - DOMObjectWrapperMap::mapFor(globalData).set(objectHandle, wrapper); + addWrapper(wrapper); + DOMObjectWrapperMapFor(globalData).set(objectHandle, wrapper); } -void forgetDOMObject(JSGlobalData& globalData, void* objectHandle) +JSNode* getCachedDOMNodeWrapper(Document* document, Node* node) { - DOMObjectWrapperMap::mapFor(globalData).remove(objectHandle); + if (document) + return document->getWrapperCache(mainThreadCurrentWorld())->get(node); + return static_cast<JSNode*>(DOMObjectWrapperMapFor(*JSDOMWindow::commonJSGlobalData()).get(node)); } -JSNode* getCachedDOMNodeWrapper(Document* document, Node* node) +void forgetDOMObject(DOMObject* wrapper, void* objectHandle) { - if (!document) - return static_cast<JSNode*>(DOMObjectWrapperMap::mapFor(*JSDOMWindow::commonJSGlobalData()).get(node)); - return document->wrapperCache().get(node); + JSC::JSGlobalData* globalData = Heap::heap(wrapper)->globalData(); + for (JSGlobalDataWorldIterator worldIter(globalData); worldIter; ++worldIter) { + DOMObjectWrapperMap& wrappers = worldIter->m_wrappers; + DOMObjectWrapperMap::iterator iter = wrappers.find(objectHandle); + if ((iter != wrappers.end()) && (iter->second == wrapper)) { + removeWrapper(wrapper); + wrappers.remove(iter); + return; + } + } + + // If the world went away, it should have removed this wrapper from the set. + ASSERT(!wrapperSet().contains(wrapper)); } -void forgetDOMNode(Document* document, Node* node) +void forgetDOMNode(DOMObject* wrapper, Node* node, Document* document) { if (!document) { - DOMObjectWrapperMap::mapFor(*JSDOMWindow::commonJSGlobalData()).remove(node); + forgetDOMObject(wrapper, node); return; } - removeWrapper(document->wrapperCache().take(node)); + + JSWrapperCacheMap& wrapperCacheMap = document->wrapperCacheMap(); + for (JSWrapperCacheMap::iterator wrappersIter = wrapperCacheMap.begin(); wrappersIter != wrapperCacheMap.end(); ++wrappersIter) { + JSWrapperCache* wrappers = wrappersIter->second; + JSWrapperCache::iterator iter = wrappers->find(node); + if ((iter != wrappers->end()) && (iter->second == wrapper)) { + wrappers->remove(iter); + removeWrapper(wrapper); + return; + } + } + + // If the world went away, it should have removed this wrapper from the set. + ASSERT(!wrapperSet().contains(wrapper)); } void cacheDOMNodeWrapper(Document* document, Node* node, JSNode* wrapper) { if (!document) { - DOMObjectWrapperMap::mapFor(*JSDOMWindow::commonJSGlobalData()).set(node, wrapper); + addWrapper(wrapper); + DOMObjectWrapperMapFor(*JSDOMWindow::commonJSGlobalData()).set(node, wrapper); return; } addWrapper(wrapper); - document->wrapperCache().set(node, wrapper); + document->getWrapperCache(mainThreadCurrentWorld())->set(node, wrapper); } void forgetAllDOMNodesForDocument(Document* document) { ASSERT(document); - removeWrappers(document->wrapperCache()); + JSWrapperCacheMap& wrapperCacheMap = document->wrapperCacheMap(); + JSWrapperCacheMap::const_iterator wrappersMapEnd = wrapperCacheMap.end(); + for (JSWrapperCacheMap::const_iterator wrappersMapIter = wrapperCacheMap.begin(); wrappersMapIter != wrappersMapEnd; ++wrappersMapIter) { + JSWrapperCache* wrappers = wrappersMapIter->second; + removeWrappers(*wrappers); + delete wrappers; + wrappersMapIter->first->forgetDocument(document); + } } -static inline bool isObservableThroughDOM(JSNode* jsNode) +void forgetWorldOfDOMNodesForDocument(Document* document, DOMWrapperWorld* world) +{ + JSWrapperCache* wrappers = document->wrapperCacheMap().take(world); + ASSERT(wrappers); // 'world' should only know about 'document' if 'document' knows about 'world'! + removeWrappers(*wrappers); + delete wrappers; +} + +static inline bool isObservableThroughDOM(JSNode* jsNode, DOMWrapperWorld* world) { // Certain conditions implicitly make a JS DOM node wrapper observable // through the DOM, even if no explicit reference to it remains. @@ -269,18 +377,48 @@ static inline bool isObservableThroughDOM(JSNode* jsNode) Node* node = jsNode->impl(); if (node->inDocument()) { - // 1. If a node is in the document, and its wrapper has custom properties, + // If a node is in the document, and its wrapper has custom properties, // the wrapper is observable because future access to the node through the // DOM must reflect those properties. if (jsNode->hasCustomProperties()) return true; - // 2. If a node is in the document, and has event listeners, its wrapper is + // If a node is in the document, and has event listeners, its wrapper is // observable because its wrapper is responsible for marking those event listeners. - if (node->eventListeners().size()) + if (node->hasEventListeners()) return true; // Technically, we may overzealously mark a wrapper for a node that has only non-JS event listeners. Oh well. + + // If a node owns another object with a wrapper with custom properties, + // the wrapper must be treated as observable, because future access to + // those objects through the DOM must reflect those properties. + // FIXME: It would be better if this logic could be in the node next to + // the custom markChildren functions rather than here. + if (node->isElementNode()) { + if (NamedNodeMap* attributes = static_cast<Element*>(node)->attributeMap()) { + if (DOMObject* wrapper = world->m_wrappers.get(attributes)) { + if (wrapper->hasCustomProperties()) + return true; + } + } + if (node->isStyledElement()) { + if (CSSMutableStyleDeclaration* style = static_cast<StyledElement*>(node)->inlineStyleDecl()) { + if (DOMObject* wrapper = world->m_wrappers.get(style)) { + if (wrapper->hasCustomProperties()) + return true; + } + } + } + if (static_cast<Element*>(node)->hasTagName(canvasTag)) { + if (CanvasRenderingContext* context = static_cast<HTMLCanvasElement*>(node)->renderingContext()) { + if (DOMObject* wrapper = world->m_wrappers.get(context)) { + if (wrapper->hasCustomProperties()) + return true; + } + } + } + } } else { - // 3. If a wrapper is the last reference to an image or script element + // If a wrapper is the last reference to an image or script element // that is loading but not in the document, the wrapper is observable // because it is the only thing keeping the image element alive, and if // the image element is destroyed, its load event will not fire. @@ -295,21 +433,31 @@ static inline bool isObservableThroughDOM(JSNode* jsNode) #endif } + // If a node is firing event listeners, its wrapper is observable because + // its wrapper is responsible for marking those event listeners. + if (node->isFiringEventListeners()) + return true; + return false; } -void markDOMNodesForDocument(Document* doc) +void markDOMNodesForDocument(MarkStack& markStack, Document* document) { - JSWrapperCache& nodeDict = doc->wrapperCache(); - JSWrapperCache::iterator nodeEnd = nodeDict.end(); - for (JSWrapperCache::iterator nodeIt = nodeDict.begin(); nodeIt != nodeEnd; ++nodeIt) { - JSNode* jsNode = nodeIt->second; - if (!jsNode->marked() && isObservableThroughDOM(jsNode)) - jsNode->mark(); + JSWrapperCacheMap& wrapperCacheMap = document->wrapperCacheMap(); + for (JSWrapperCacheMap::iterator wrappersIter = wrapperCacheMap.begin(); wrappersIter != wrapperCacheMap.end(); ++wrappersIter) { + DOMWrapperWorld* world = wrappersIter->first; + JSWrapperCache* nodeDict = wrappersIter->second; + + JSWrapperCache::iterator nodeEnd = nodeDict->end(); + for (JSWrapperCache::iterator nodeIt = nodeDict->begin(); nodeIt != nodeEnd; ++nodeIt) { + JSNode* jsNode = nodeIt->second; + if (isObservableThroughDOM(jsNode, world)) + markStack.append(jsNode); + } } } -void markActiveObjectsForContext(JSGlobalData& globalData, ScriptExecutionContext* scriptExecutionContext) +void markActiveObjectsForContext(MarkStack& markStack, JSGlobalData& globalData, ScriptExecutionContext* scriptExecutionContext) { // If an element has pending activity that may result in event listeners being called // (e.g. an XMLHttpRequest), we need to keep JS wrappers alive. @@ -318,12 +466,10 @@ void markActiveObjectsForContext(JSGlobalData& globalData, ScriptExecutionContex HashMap<ActiveDOMObject*, void*>::const_iterator activeObjectsEnd = activeObjects.end(); for (HashMap<ActiveDOMObject*, void*>::const_iterator iter = activeObjects.begin(); iter != activeObjectsEnd; ++iter) { if (iter->first->hasPendingActivity()) { - DOMObject* wrapper = getCachedDOMObjectWrapper(globalData, iter->second); // Generally, an active object with pending activity must have a wrapper to mark its listeners. // However, some ActiveDOMObjects don't have JS wrappers (timers created by setTimeout is one example). // FIXME: perhaps need to make sure even timers have a markable 'wrapper'. - if (wrapper && !wrapper->marked()) - wrapper->mark(); + markDOMObjectWrapper(markStack, globalData, iter->second); } } @@ -331,10 +477,31 @@ void markActiveObjectsForContext(JSGlobalData& globalData, ScriptExecutionContex HashSet<MessagePort*>::const_iterator portsEnd = messagePorts.end(); for (HashSet<MessagePort*>::const_iterator iter = messagePorts.begin(); iter != portsEnd; ++iter) { // If the message port is remotely entangled, then always mark it as in-use because we can't determine reachability across threads. - if (!(*iter)->locallyEntangledPort() || (*iter)->hasPendingActivity()) { - DOMObject* wrapper = getCachedDOMObjectWrapper(globalData, *iter); - if (wrapper && !wrapper->marked()) - wrapper->mark(); + if (!(*iter)->locallyEntangledPort() || (*iter)->hasPendingActivity()) + markDOMObjectWrapper(markStack, globalData, *iter); + } +} + +typedef std::pair<JSNode*, DOMWrapperWorld*> WrapperAndWorld; +typedef WTF::Vector<WrapperAndWorld, 8> WrapperSet; + +static inline void takeWrappers(Node* node, Document* document, WrapperSet& wrapperSet) +{ + if (document) { + JSWrapperCacheMap& wrapperCacheMap = document->wrapperCacheMap(); + for (JSWrapperCacheMap::iterator iter = wrapperCacheMap.begin(); iter != wrapperCacheMap.end(); ++iter) { + if (JSNode* wrapper = iter->second->take(node)) { + removeWrapper(wrapper); + wrapperSet.append(WrapperAndWorld(wrapper, iter->first)); + } + } + } else { + for (JSGlobalDataWorldIterator worldIter(JSDOMWindow::commonJSGlobalData()); worldIter; ++worldIter) { + DOMWrapperWorld* world = *worldIter; + if (JSNode* wrapper = static_cast<JSNode*>(world->m_wrappers.take(node))) { + removeWrapper(wrapper); + wrapperSet.append(WrapperAndWorld(wrapper, world)); + } } } } @@ -342,23 +509,32 @@ void markActiveObjectsForContext(JSGlobalData& globalData, ScriptExecutionContex void updateDOMNodeDocument(Node* node, Document* oldDocument, Document* newDocument) { ASSERT(oldDocument != newDocument); - JSNode* wrapper = getCachedDOMNodeWrapper(oldDocument, node); - if (!wrapper) - return; - removeWrapper(wrapper); - cacheDOMNodeWrapper(newDocument, node, wrapper); - forgetDOMNode(oldDocument, node); - addWrapper(wrapper); + + WrapperSet wrapperSet; + takeWrappers(node, oldDocument, wrapperSet); + + for (unsigned i = 0; i < wrapperSet.size(); ++i) { + JSNode* wrapper = wrapperSet[i].first; + if (newDocument) + newDocument->getWrapperCache(wrapperSet[i].second)->set(node, wrapper); + else + wrapperSet[i].second->m_wrappers.set(node, wrapper); + addWrapper(wrapper); + } } -void markDOMObjectWrapper(JSGlobalData& globalData, void* object) +void markDOMObjectWrapper(MarkStack& markStack, JSGlobalData& globalData, void* object) { + // FIXME: This could be changed to only mark wrappers that are "observable" + // as markDOMNodesForDocument does, allowing us to collect more wrappers, + // but doing this correctly would be challenging. if (!object) return; - DOMObject* wrapper = getCachedDOMObjectWrapper(globalData, object); - if (!wrapper || wrapper->marked()) - return; - wrapper->mark(); + + for (JSGlobalDataWorldIterator worldIter(&globalData); worldIter; ++worldIter) { + if (DOMObject* wrapper = worldIter->m_wrappers.get(object)) + markStack.append(wrapper); + } } JSValue jsStringOrNull(ExecState* exec, const String& s) @@ -432,6 +608,9 @@ void reportException(ExecState* exec, JSValue exception) UString exceptionSourceURL = exceptionObject->get(exec, Identifier(exec, "sourceURL")).toString(exec); exec->clearException(); + if (ExceptionBase* exceptionBase = toExceptionBase(exception)) + errorMessage = exceptionBase->message() + ": " + exceptionBase->description(); + ScriptExecutionContext* scriptExecutionContext = static_cast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext(); ASSERT(scriptExecutionContext); @@ -502,7 +681,7 @@ bool allowsAccessFromFrame(ExecState* exec, Frame* frame) { if (!frame) return false; - JSDOMWindow* window = toJSDOMWindow(frame); + JSDOMWindow* window = toJSDOMWindow(frame, currentWorld(exec)); return window && window->allowsAccessFrom(exec); } @@ -510,7 +689,7 @@ bool allowsAccessFromFrame(ExecState* exec, Frame* frame, String& message) { if (!frame) return false; - JSDOMWindow* window = toJSDOMWindow(frame); + JSDOMWindow* window = toJSDOMWindow(frame, currentWorld(exec)); return window && window->allowsAccessFrom(exec, message); } @@ -524,8 +703,16 @@ void printErrorMessageForFrame(Frame* frame, const String& message) { if (!frame) return; - if (JSDOMWindow* window = toJSDOMWindow(frame)) - window->printErrorMessage(message); + if (message.isEmpty()) + return; + + Settings* settings = frame->settings(); + if (!settings) + return; + if (settings->privateBrowsingEnabled()) + return; + + frame->domWindow()->console()->addMessage(JSMessageSource, LogMessageType, ErrorMessageLevel, message, 1, String()); // FIXME: provide a real line number and source URL. } Frame* toLexicalFrame(ExecState* exec) @@ -564,7 +751,7 @@ Structure* getCachedDOMStructure(JSDOMGlobalObject* globalObject, const ClassInf return structures.get(classInfo).get(); } -Structure* cacheDOMStructure(JSDOMGlobalObject* globalObject, PassRefPtr<Structure> structure, const ClassInfo* classInfo) +Structure* cacheDOMStructure(JSDOMGlobalObject* globalObject, NonNullPassRefPtr<Structure> structure, const ClassInfo* classInfo) { JSDOMStructureMap& structures = globalObject->structures(); ASSERT(!structures.contains(classInfo)); @@ -576,7 +763,7 @@ Structure* getCachedDOMStructure(ExecState* exec, const ClassInfo* classInfo) return getCachedDOMStructure(static_cast<JSDOMGlobalObject*>(exec->lexicalGlobalObject()), classInfo); } -Structure* cacheDOMStructure(ExecState* exec, PassRefPtr<Structure> structure, const ClassInfo* classInfo) +Structure* cacheDOMStructure(ExecState* exec, NonNullPassRefPtr<Structure> structure, const ClassInfo* classInfo) { return cacheDOMStructure(static_cast<JSDOMGlobalObject*>(exec->lexicalGlobalObject()), structure, classInfo); } @@ -594,4 +781,57 @@ void cacheDOMConstructor(ExecState* exec, const ClassInfo* classInfo, JSObject* constructors.set(classInfo, constructor); } +JSC::JSObject* toJSSequence(ExecState* exec, JSValue value, unsigned& length) +{ + JSObject* object = value.getObject(); + if (!object) { + throwError(exec, TypeError); + return 0; + } + JSValue lengthValue = object->get(exec, exec->propertyNames().length); + if (exec->hadException()) + return 0; + + if (lengthValue.isUndefinedOrNull()) { + throwError(exec, TypeError); + return 0; + } + + length = lengthValue.toUInt32(exec); + if (exec->hadException()) + return 0; + + return object; +} + +bool DOMObject::defineOwnProperty(ExecState* exec, const Identifier&, PropertyDescriptor&, bool) +{ + throwError(exec, TypeError, "defineProperty is not supported on DOM Objects"); + return false; +} + +JSValue DebuggerCallFrame_evaluateInWorld(const JSC::DebuggerCallFrame& debuggerCallFrame, const UString& script, JSValue& exception) +{ + EnterDOMWrapperWorld worldEntry(debuggerCallFrame.dynamicGlobalObject()->globalExec(), debuggerWorld()); + return debuggerCallFrame.evaluate(script, exception); +} + +JSValue callInWorld(ExecState* exec, JSValue function, CallType callType, const CallData& callData, JSValue thisValue, const ArgList& args, DOMWrapperWorld* isolatedWorld) +{ + EnterDOMWrapperWorld worldEntry(exec, isolatedWorld); + return JSC::call(exec, function, callType, callData, thisValue, args); +} + +JSObject* constructInWorld(ExecState* exec, JSValue object, ConstructType constructType, const ConstructData& constructData, const ArgList& args, DOMWrapperWorld* isolatedWorld) +{ + EnterDOMWrapperWorld worldEntry(exec, isolatedWorld); + return JSC::construct(exec, object, constructType, constructData, args); +} + +Completion evaluateInWorld(ExecState* exec, ScopeChain& scopeChain, const SourceCode& sourceCode, JSValue thisValue, DOMWrapperWorld* isolatedWorld) +{ + EnterDOMWrapperWorld worldEntry(exec, isolatedWorld); + return JSC::evaluate(exec, scopeChain, sourceCode, thisValue); +} + } // namespace WebCore diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSDOMBinding.h b/src/3rdparty/webkit/WebCore/bindings/js/JSDOMBinding.h index 3975940e1..ba41d8599 100644 --- a/src/3rdparty/webkit/WebCore/bindings/js/JSDOMBinding.h +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSDOMBinding.h @@ -1,6 +1,6 @@ /* * Copyright (C) 1999-2001 Harri Porten (porten@kde.org) - * Copyright (C) 2003, 2004, 2005, 2006, 2008 Apple Inc. All rights reserved. + * Copyright (C) 2003, 2004, 2005, 2006, 2008, 2009 Apple Inc. All rights reserved. * Copyright (C) 2007 Samuel Weinig <sam@webkit.org> * Copyright (C) 2009 Google, Inc. All rights reserved. * @@ -26,21 +26,22 @@ #include "Document.h" // For DOMConstructorWithDocument #include <runtime/Completion.h> #include <runtime/Lookup.h> -#include <runtime/JSFunction.h> #include <wtf/Noncopyable.h> namespace JSC { class JSGlobalData; + class DebuggerCallFrame; } namespace WebCore { class Document; class Frame; + class JSNode; class KURL; class Node; class String; - class JSNode; + class ScriptController; typedef int ExceptionCode; @@ -51,17 +52,19 @@ namespace WebCore { // Base class for all objects in this binding except Window. class DOMObject : public JSC::JSObject { protected: - explicit DOMObject(PassRefPtr<JSC::Structure> structure) + explicit DOMObject(NonNullPassRefPtr<JSC::Structure> structure) : JSObject(structure) { } + virtual bool defineOwnProperty(JSC::ExecState*, const JSC::Identifier&, JSC::PropertyDescriptor&, bool); + #ifndef NDEBUG virtual ~DOMObject(); #endif }; - // FIXME: This class should colapse into DOMObject once all DOMObjects are + // FIXME: This class should collapse into DOMObject once all DOMObjects are // updated to store a globalObject pointer. class DOMObjectWithGlobalPointer : public DOMObject { public: @@ -73,8 +76,15 @@ namespace WebCore { return m_globalObject->scriptExecutionContext(); } + static PassRefPtr<JSC::Structure> createStructure(JSC::JSValue prototype) + { + return JSC::Structure::create(prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags)); + } + protected: - DOMObjectWithGlobalPointer(PassRefPtr<JSC::Structure> structure, JSDOMGlobalObject* globalObject) + static const unsigned StructureFlags = JSC::OverridesMarkChildren | DOMObject::StructureFlags; + + DOMObjectWithGlobalPointer(NonNullPassRefPtr<JSC::Structure> structure, JSDOMGlobalObject* globalObject) : DOMObject(structure) , m_globalObject(globalObject) { @@ -83,13 +93,12 @@ namespace WebCore { // needing to reach through the frame to get to the Document*. See bug 27640. // ASSERT(globalObject->scriptExecutionContext()); } - virtual ~DOMObjectWithGlobalPointer() {} + virtual ~DOMObjectWithGlobalPointer() { } - void mark() + void markChildren(JSC::MarkStack& markStack) { - DOMObject::mark(); - if (!m_globalObject->marked()) - m_globalObject->mark(); + DOMObject::markChildren(markStack); + markStack.append(m_globalObject); } private: @@ -101,11 +110,12 @@ namespace WebCore { public: static PassRefPtr<JSC::Structure> createStructure(JSC::JSValue prototype) { - return JSC::Structure::create(prototype, JSC::TypeInfo(JSC::ObjectType, JSC::HasStandardGetOwnPropertySlot | JSC::ImplementsHasInstance)); + return JSC::Structure::create(prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags)); } protected: - DOMConstructorObject(PassRefPtr<JSC::Structure> structure, JSDOMGlobalObject* globalObject) + static const unsigned StructureFlags = JSC::ImplementsHasInstance | JSC::OverridesMarkChildren | DOMObjectWithGlobalPointer::StructureFlags; + DOMConstructorObject(NonNullPassRefPtr<JSC::Structure> structure, JSDOMGlobalObject* globalObject) : DOMObjectWithGlobalPointer(structure, globalObject) { } @@ -121,30 +131,127 @@ namespace WebCore { } protected: - DOMConstructorWithDocument(PassRefPtr<JSC::Structure> structure, JSDOMGlobalObject* globalObject) + DOMConstructorWithDocument(NonNullPassRefPtr<JSC::Structure> structure, JSDOMGlobalObject* globalObject) : DOMConstructorObject(structure, globalObject) { ASSERT(globalObject->scriptExecutionContext()->isDocument()); } }; + typedef HashMap<void*, DOMObject*> DOMObjectWrapperMap; + + class DOMWrapperWorld : public RefCounted<DOMWrapperWorld> { + public: + DOMWrapperWorld(JSC::JSGlobalData*); + ~DOMWrapperWorld(); + + void rememberDocument(Document* document) { documentsWithWrappers.add(document); } + void forgetDocument(Document* document) { documentsWithWrappers.remove(document); } + void rememberScriptController(ScriptController* scriptController) { scriptControllersWithShells.add(scriptController); } + void forgetScriptController(ScriptController* scriptController) { scriptControllersWithShells.remove(scriptController); } + + // FIXME: can we make this private? + DOMObjectWrapperMap m_wrappers; + + private: + JSC::JSGlobalData* m_globalData; + HashSet<Document*> documentsWithWrappers; + HashSet<ScriptController*> scriptControllersWithShells; + }; + + // Map from static HashTable instances to per-GlobalData ones. + class DOMObjectHashTableMap { + public: + static DOMObjectHashTableMap& mapFor(JSC::JSGlobalData&); + + ~DOMObjectHashTableMap() + { + HashMap<const JSC::HashTable*, JSC::HashTable>::iterator mapEnd = m_map.end(); + for (HashMap<const JSC::HashTable*, JSC::HashTable>::iterator iter = m_map.begin(); iter != m_map.end(); ++iter) + iter->second.deleteTable(); + } + + const JSC::HashTable* get(const JSC::HashTable* staticTable) + { + HashMap<const JSC::HashTable*, JSC::HashTable>::iterator iter = m_map.find(staticTable); + if (iter != m_map.end()) + return &iter->second; + return &m_map.set(staticTable, JSC::HashTable(*staticTable)).first->second; + } + + private: + HashMap<const JSC::HashTable*, JSC::HashTable> m_map; + }; + + class WebCoreJSClientData : public JSC::JSGlobalData::ClientData { + friend class EnterDOMWrapperWorld; + friend class JSGlobalDataWorldIterator; + + public: + WebCoreJSClientData(JSC::JSGlobalData* globalData) + : m_normalWorld(globalData) + { + m_worldStack.append(&m_normalWorld); + m_worldSet.add(&m_normalWorld); + } + // FIXME: add a destructor to assert m_worldSet only contains m_normalWorld? + + DOMWrapperWorld* currentWorld() { return m_worldStack.last(); } + DOMWrapperWorld* normalWorld() { return &m_normalWorld; } + + void rememberWorld(DOMWrapperWorld* world) + { + ASSERT(!m_worldSet.contains(world)); + m_worldSet.add(world); + } + void forgetWorld(DOMWrapperWorld* world) + { + ASSERT(m_worldSet.contains(world)); + m_worldSet.remove(world); + } + + DOMObjectHashTableMap hashTableMap; + private: + Vector<DOMWrapperWorld*> m_worldStack; + HashSet<DOMWrapperWorld*> m_worldSet; + DOMWrapperWorld m_normalWorld; + }; + + class EnterDOMWrapperWorld { + public: + EnterDOMWrapperWorld(JSC::JSGlobalData&, DOMWrapperWorld*); + EnterDOMWrapperWorld(JSC::ExecState*, DOMWrapperWorld*); + ~EnterDOMWrapperWorld(); + + private: + WebCoreJSClientData* m_clientData; + }; + DOMObject* getCachedDOMObjectWrapper(JSC::JSGlobalData&, void* objectHandle); void cacheDOMObjectWrapper(JSC::JSGlobalData&, void* objectHandle, DOMObject* wrapper); - void forgetDOMObject(JSC::JSGlobalData&, void* objectHandle); + void forgetDOMNode(DOMObject* wrapper, Node* node, Document* document); + void forgetDOMObject(DOMObject* wrapper, void* objectHandle); JSNode* getCachedDOMNodeWrapper(Document*, Node*); void cacheDOMNodeWrapper(Document*, Node*, JSNode* wrapper); - void forgetDOMNode(Document*, Node*); void forgetAllDOMNodesForDocument(Document*); + void forgetWorldOfDOMNodesForDocument(Document*, DOMWrapperWorld*); void updateDOMNodeDocument(Node*, Document* oldDocument, Document* newDocument); - void markDOMNodesForDocument(Document*); - void markActiveObjectsForContext(JSC::JSGlobalData&, ScriptExecutionContext*); - void markDOMObjectWrapper(JSC::JSGlobalData& globalData, void* object); + void markDOMNodesForDocument(JSC::MarkStack&, Document*); + void markActiveObjectsForContext(JSC::MarkStack&, JSC::JSGlobalData&, ScriptExecutionContext*); + void markDOMObjectWrapper(JSC::MarkStack&, JSC::JSGlobalData& globalData, void* object); JSC::Structure* getCachedDOMStructure(JSDOMGlobalObject*, const JSC::ClassInfo*); - JSC::Structure* cacheDOMStructure(JSDOMGlobalObject*, PassRefPtr<JSC::Structure>, const JSC::ClassInfo*); + JSC::Structure* cacheDOMStructure(JSDOMGlobalObject*, NonNullPassRefPtr<JSC::Structure>, const JSC::ClassInfo*); JSC::Structure* getCachedDOMStructure(JSC::ExecState*, const JSC::ClassInfo*); - JSC::Structure* cacheDOMStructure(JSC::ExecState*, PassRefPtr<JSC::Structure>, const JSC::ClassInfo*); + JSC::Structure* cacheDOMStructure(JSC::ExecState*, NonNullPassRefPtr<JSC::Structure>, const JSC::ClassInfo*); + + DOMWrapperWorld* currentWorld(JSC::ExecState*); + DOMWrapperWorld* normalWorld(JSC::JSGlobalData&); + DOMWrapperWorld* mainThreadCurrentWorld(); + DOMWrapperWorld* mainThreadNormalWorld(); + inline DOMWrapperWorld* debuggerWorld() { return mainThreadNormalWorld(); } + inline DOMWrapperWorld* pluginWorld() { return mainThreadNormalWorld(); } JSC::JSObject* getCachedDOMConstructor(JSC::ExecState*, const JSC::ClassInfo*); void cacheDOMConstructor(JSC::ExecState*, const JSC::ClassInfo*, JSC::JSObject* constructor); @@ -278,6 +385,9 @@ namespace WebCore { return toJS(exec, globalObject, ptr.get()); } + // Validates that the passed object is a sequence type per section 4.1.13 of the WebIDL spec. + JSC::JSObject* toJSSequence(JSC::ExecState*, JSC::JSValue, unsigned&); + bool checkNodeSecurity(JSC::ExecState*, Node*); // Helpers for Window, History, and Location classes to implement cross-domain policy. @@ -294,6 +404,11 @@ namespace WebCore { bool processingUserGesture(JSC::ExecState*); KURL completeURL(JSC::ExecState*, const String& relativeURL); + JSC::JSValue DebuggerCallFrame_evaluateInWorld(const JSC::DebuggerCallFrame& debuggerCallFrame, const JSC::UString& script, JSC::JSValue& exception); + JSC::JSValue callInWorld(JSC::ExecState*, JSC::JSValue function, JSC::CallType, const JSC::CallData&, JSC::JSValue thisValue, const JSC::ArgList&, DOMWrapperWorld*); + JSC::JSObject* constructInWorld(JSC::ExecState* exec, JSC::JSValue object, JSC::ConstructType constructType, const JSC::ConstructData& constructData, const JSC::ArgList& args, DOMWrapperWorld*); + JSC::Completion evaluateInWorld(JSC::ExecState*, JSC::ScopeChain&, const JSC::SourceCode&, JSC::JSValue thisValue, DOMWrapperWorld*); + } // namespace WebCore #endif // JSDOMBinding_h diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSDOMGlobalObject.cpp b/src/3rdparty/webkit/WebCore/bindings/js/JSDOMGlobalObject.cpp index a7f7b2167..011a4e4c9 100644 --- a/src/3rdparty/webkit/WebCore/bindings/js/JSDOMGlobalObject.cpp +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSDOMGlobalObject.cpp @@ -1,5 +1,5 @@ /* - * Copyright (C) 2008 Apple Inc. All Rights Reserved. + * Copyright (C) 2008, 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 @@ -40,86 +40,75 @@ using namespace JSC; namespace WebCore { -JSDOMGlobalObject::JSDOMGlobalObjectData::JSDOMGlobalObjectData() - : evt(0) -{ -} - -JSDOMGlobalObject::JSDOMGlobalObject(PassRefPtr<Structure> structure, JSDOMGlobalObject::JSDOMGlobalObjectData* data, JSObject* thisValue) +JSDOMGlobalObject::JSDOMGlobalObject(NonNullPassRefPtr<Structure> structure, JSDOMGlobalObject::JSDOMGlobalObjectData* data, JSObject* thisValue) : JSGlobalObject(structure, data, thisValue) { } -JSDOMGlobalObject::~JSDOMGlobalObject() +void JSDOMGlobalObject::markChildren(MarkStack& markStack) { - JSListenersMap::iterator it = d()->jsEventListeners.begin(); - JSListenersMap::iterator end = d()->jsEventListeners.end(); - for (; it != end; ++it) - it->second->clearGlobalObject(); -} - -void JSDOMGlobalObject::mark() -{ - Base::mark(); + Base::markChildren(markStack); JSDOMStructureMap::iterator end = structures().end(); for (JSDOMStructureMap::iterator it = structures().begin(); it != end; ++it) - it->second->mark(); + markStack.append(it->second->storedPrototype()); JSDOMConstructorMap::iterator end2 = constructors().end(); - for (JSDOMConstructorMap::iterator it2 = constructors().begin(); it2 != end2; ++it2) { - if (!it2->second->marked()) - it2->second->mark(); - } + for (JSDOMConstructorMap::iterator it2 = constructors().begin(); it2 != end2; ++it2) + markStack.append(it2->second); } -JSEventListener* JSDOMGlobalObject::findJSEventListener(JSValue val) +PassRefPtr<JSEventListener> JSDOMGlobalObject::createJSAttributeEventListener(JSValue val) { if (!val.isObject()) return 0; - return d()->jsEventListeners.get(asObject(val)); + return JSEventListener::create(asObject(val), true, currentWorld(globalExec())).get(); } -PassRefPtr<JSEventListener> JSDOMGlobalObject::findOrCreateJSEventListener(JSValue val) +void JSDOMGlobalObject::setCurrentEvent(Event* evt) { - if (JSEventListener* listener = findJSEventListener(val)) - return listener; - - if (!val.isObject()) - return 0; - - // The JSEventListener constructor adds it to our jsEventListeners map. - return JSEventListener::create(asObject(val), this, false).get(); + d()->evt = evt; } -PassRefPtr<JSEventListener> JSDOMGlobalObject::createJSAttributeEventListener(JSValue val) +Event* JSDOMGlobalObject::currentEvent() const { - if (!val.isObject()) - return 0; + return d()->evt; +} - return JSEventListener::create(asObject(val), this, true).get(); +void JSDOMGlobalObject::destroyJSDOMGlobalObjectData(void* jsDOMGlobalObjectData) +{ + delete static_cast<JSDOMGlobalObjectData*>(jsDOMGlobalObjectData); } -JSDOMGlobalObject::JSListenersMap& JSDOMGlobalObject::jsEventListeners() +JSDOMGlobalObject* toJSDOMGlobalObject(Document* document, JSC::ExecState* exec) { - return d()->jsEventListeners; + return toJSDOMWindow(document->frame(), currentWorld(exec)); } -void JSDOMGlobalObject::setCurrentEvent(Event* evt) +JSDOMGlobalObject* toJSDOMGlobalObject(ScriptExecutionContext* scriptExecutionContext, JSC::ExecState* exec) { - d()->evt = evt; + if (scriptExecutionContext->isDocument()) + return toJSDOMGlobalObject(static_cast<Document*>(scriptExecutionContext), exec); + +#if ENABLE(WORKERS) + if (scriptExecutionContext->isWorkerContext()) + return static_cast<WorkerContext*>(scriptExecutionContext)->script()->workerContextWrapper(); +#endif + + ASSERT_NOT_REACHED(); + return 0; } -Event* JSDOMGlobalObject::currentEvent() const +JSDOMGlobalObject* toJSDOMGlobalObject(Document* document, DOMWrapperWorld* world) { - return d()->evt; + return toJSDOMWindow(document->frame(), world); } -JSDOMGlobalObject* toJSDOMGlobalObject(ScriptExecutionContext* scriptExecutionContext) +JSDOMGlobalObject* toJSDOMGlobalObject(ScriptExecutionContext* scriptExecutionContext, DOMWrapperWorld* world) { if (scriptExecutionContext->isDocument()) - return toJSDOMWindow(static_cast<Document*>(scriptExecutionContext)->frame()); + return toJSDOMGlobalObject(static_cast<Document*>(scriptExecutionContext), world); #if ENABLE(WORKERS) if (scriptExecutionContext->isWorkerContext()) diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSDOMGlobalObject.h b/src/3rdparty/webkit/WebCore/bindings/js/JSDOMGlobalObject.h index bc6c1f2d2..6b75a6f6d 100644 --- a/src/3rdparty/webkit/WebCore/bindings/js/JSDOMGlobalObject.h +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSDOMGlobalObject.h @@ -31,7 +31,9 @@ namespace WebCore { + class Document; class Event; + class DOMWrapperWorld; class JSLazyEventListener; class JSEventListener; class ScriptExecutionContext; @@ -44,8 +46,7 @@ namespace WebCore { protected: struct JSDOMGlobalObjectData; - JSDOMGlobalObject(PassRefPtr<JSC::Structure>, JSDOMGlobalObjectData*, JSC::JSObject* thisValue); - virtual ~JSDOMGlobalObject(); + JSDOMGlobalObject(NonNullPassRefPtr<JSC::Structure>, JSDOMGlobalObjectData*, JSC::JSObject* thisValue); public: JSDOMStructureMap& structures() { return d()->structures; } @@ -53,41 +54,41 @@ namespace WebCore { virtual ScriptExecutionContext* scriptExecutionContext() const = 0; - // Finds a wrapper of a GC-unprotected JS EventListener, returns 0 if no existing one. - JSEventListener* findJSEventListener(JSC::JSValue); - - // Finds or creates a wrapper of a JS EventListener. JS EventListener object is *NOT* GC-protected. - PassRefPtr<JSEventListener> findOrCreateJSEventListener(JSC::JSValue); - - // Creates a GC-protected JS EventListener for an "onXXX" event attribute. - // These listeners cannot be removed through the removeEventListener API. + // Creates a JS EventListener for an "onXXX" event attribute. These + // listeners cannot be removed through the removeEventListener API. PassRefPtr<JSEventListener> createJSAttributeEventListener(JSC::JSValue); - typedef HashMap<JSC::JSObject*, JSEventListener*> JSListenersMap; - - JSListenersMap& jsEventListeners(); - // Make binding code generation easier. JSDOMGlobalObject* globalObject() { return this; } void setCurrentEvent(Event*); Event* currentEvent() const; - virtual void mark(); + virtual void markChildren(JSC::MarkStack&); protected: struct JSDOMGlobalObjectData : public JSC::JSGlobalObject::JSGlobalObjectData { - JSDOMGlobalObjectData(); + JSDOMGlobalObjectData() + : JSGlobalObjectData(destroyJSDOMGlobalObjectData) + , evt(0) + { + } + + JSDOMGlobalObjectData(Destructor destructor) + : JSGlobalObjectData(destructor) + , evt(0) + { + } JSDOMStructureMap structures; JSDOMConstructorMap constructors; - JSDOMGlobalObject::JSListenersMap jsEventListeners; - Event* evt; }; private: + static void destroyJSDOMGlobalObjectData(void*); + JSDOMGlobalObjectData* d() const { return static_cast<JSDOMGlobalObjectData*>(JSC::JSVariableObject::d); } }; @@ -102,7 +103,11 @@ namespace WebCore { return constructor; } - JSDOMGlobalObject* toJSDOMGlobalObject(ScriptExecutionContext*); + JSDOMGlobalObject* toJSDOMGlobalObject(Document*, JSC::ExecState*); + JSDOMGlobalObject* toJSDOMGlobalObject(ScriptExecutionContext*, JSC::ExecState*); + + JSDOMGlobalObject* toJSDOMGlobalObject(Document*, DOMWrapperWorld*); + JSDOMGlobalObject* toJSDOMGlobalObject(ScriptExecutionContext*, DOMWrapperWorld*); } // namespace WebCore diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSDOMWindowBase.cpp b/src/3rdparty/webkit/WebCore/bindings/js/JSDOMWindowBase.cpp index df6068a52..86ff149bb 100644 --- a/src/3rdparty/webkit/WebCore/bindings/js/JSDOMWindowBase.cpp +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSDOMWindowBase.cpp @@ -42,13 +42,7 @@ namespace WebCore { const ClassInfo JSDOMWindowBase::s_info = { "Window", 0, 0, 0 }; -JSDOMWindowBase::JSDOMWindowBaseData::JSDOMWindowBaseData(PassRefPtr<DOMWindow> window, JSDOMWindowShell* shell) - : impl(window) - , shell(shell) -{ -} - -JSDOMWindowBase::JSDOMWindowBase(PassRefPtr<Structure> structure, PassRefPtr<DOMWindow> window, JSDOMWindowShell* shell) +JSDOMWindowBase::JSDOMWindowBase(NonNullPassRefPtr<Structure> structure, PassRefPtr<DOMWindow> window, JSDOMWindowShell* shell) : JSDOMGlobalObject(structure, new JSDOMWindowBaseData(window, shell), shell) { GlobalPropertyInfo staticGlobals[] = { @@ -59,10 +53,11 @@ JSDOMWindowBase::JSDOMWindowBase(PassRefPtr<Structure> structure, PassRefPtr<DOM addStaticGlobals(staticGlobals, sizeof(staticGlobals) / sizeof(GlobalPropertyInfo)); } -void JSDOMWindowBase::updateDocument() +void JSDOMWindowBase::updateDocument(DOMWrapperWorld* world) { ASSERT(d()->impl->document()); ExecState* exec = globalExec(); + EnterDOMWrapperWorld worldEntry(exec, world); symbolTablePutWithAttributes(Identifier(exec, "document"), toJS(exec, this, d()->impl->document()), DontDelete | ReadOnly); } @@ -85,21 +80,7 @@ String JSDOMWindowBase::crossDomainAccessErrorMessage(const JSGlobalObject* othe void JSDOMWindowBase::printErrorMessage(const String& message) const { - if (message.isEmpty()) - return; - - Frame* frame = impl()->frame(); - if (!frame) - return; - - Settings* settings = frame->settings(); - if (!settings) - return; - - if (settings->privateBrowsingEnabled()) - return; - - impl()->console()->addMessage(JSMessageSource, LogMessageType, ErrorMessageLevel, message, 1, String()); // FIXME: provide a real line number and source URL. + printErrorMessageForFrame(impl()->frame(), message); } ExecState* JSDOMWindowBase::globalExec() @@ -113,7 +94,7 @@ ExecState* JSDOMWindowBase::globalExec() bool JSDOMWindowBase::supportsProfiling() const { -#if !ENABLE(JAVASCRIPT_DEBUGGER) +#if !ENABLE(JAVASCRIPT_DEBUGGER) || !ENABLE(INSPECTOR) return false; #else Frame* frame = impl()->frame(); @@ -163,15 +144,26 @@ JSDOMWindowShell* JSDOMWindowBase::shell() const JSGlobalData* JSDOMWindowBase::commonJSGlobalData() { - static JSGlobalData* globalData; + ASSERT(isMainThread()); + + static JSGlobalData* globalData = 0; if (!globalData) { globalData = JSGlobalData::createLeaked().releaseRef(); globalData->timeoutChecker.setTimeoutInterval(10000); // 10 seconds +#ifndef NDEBUG + globalData->mainThreadOnly = true; +#endif + globalData->clientData = new WebCoreJSClientData(globalData); } return globalData; } +void JSDOMWindowBase::destroyJSDOMWindowBaseData(void* jsDOMWindowBaseData) +{ + delete static_cast<JSDOMWindowBaseData*>(jsDOMWindowBaseData); +} + // JSDOMGlobalObject* is ignored, accesing a window in any context will // use that DOMWindow's prototype chain. JSValue toJS(ExecState* exec, JSDOMGlobalObject*, DOMWindow* domWindow) @@ -179,21 +171,21 @@ JSValue toJS(ExecState* exec, JSDOMGlobalObject*, DOMWindow* domWindow) return toJS(exec, domWindow); } -JSValue toJS(ExecState*, DOMWindow* domWindow) +JSValue toJS(ExecState* exec, DOMWindow* domWindow) { if (!domWindow) return jsNull(); Frame* frame = domWindow->frame(); if (!frame) return jsNull(); - return frame->script()->windowShell(); + return frame->script()->windowShell(currentWorld(exec)); } -JSDOMWindow* toJSDOMWindow(Frame* frame) +JSDOMWindow* toJSDOMWindow(Frame* frame, DOMWrapperWorld* world) { if (!frame) return 0; - return frame->script()->windowShell()->window(); + return frame->script()->windowShell(world)->window(); } JSDOMWindow* toJSDOMWindow(JSValue value) diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSDOMWindowBase.h b/src/3rdparty/webkit/WebCore/bindings/js/JSDOMWindowBase.h index 84cc81f46..31e24868f 100644 --- a/src/3rdparty/webkit/WebCore/bindings/js/JSDOMWindowBase.h +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSDOMWindowBase.h @@ -32,6 +32,7 @@ namespace WebCore { class DOMWindow; class Event; class Frame; + class DOMWrapperWorld; class JSDOMWindow; class JSDOMWindowShell; class JSLocation; @@ -43,10 +44,10 @@ namespace WebCore { class JSDOMWindowBase : public JSDOMGlobalObject { typedef JSDOMGlobalObject Base; protected: - JSDOMWindowBase(PassRefPtr<JSC::Structure>, PassRefPtr<DOMWindow>, JSDOMWindowShell*); + JSDOMWindowBase(NonNullPassRefPtr<JSC::Structure>, PassRefPtr<DOMWindow>, JSDOMWindowShell*); public: - void updateDocument(); + void updateDocument(DOMWrapperWorld*); DOMWindow* impl() const { return d()->impl.get(); } virtual ScriptExecutionContext* scriptExecutionContext() const; @@ -76,7 +77,12 @@ namespace WebCore { private: struct JSDOMWindowBaseData : public JSDOMGlobalObjectData { - JSDOMWindowBaseData(PassRefPtr<DOMWindow>, JSDOMWindowShell*); + JSDOMWindowBaseData(PassRefPtr<DOMWindow> window, JSDOMWindowShell* shell) + : JSDOMGlobalObjectData(destroyJSDOMWindowBaseData) + , impl(window) + , shell(shell) + { + } RefPtr<DOMWindow> impl; JSDOMWindowShell* shell; @@ -85,6 +91,8 @@ namespace WebCore { bool allowsAccessFromPrivate(const JSC::JSGlobalObject*) const; String crossDomainAccessErrorMessage(const JSC::JSGlobalObject*) const; + static void destroyJSDOMWindowBaseData(void*); + JSDOMWindowBaseData* d() const { return static_cast<JSDOMWindowBaseData*>(JSC::JSVariableObject::d); } }; @@ -95,7 +103,7 @@ namespace WebCore { JSC::JSValue toJS(JSC::ExecState*, DOMWindow*); // Returns JSDOMWindow or 0 - JSDOMWindow* toJSDOMWindow(Frame*); + JSDOMWindow* toJSDOMWindow(Frame*, DOMWrapperWorld*); JSDOMWindow* toJSDOMWindow(JSC::JSValue); } // namespace WebCore diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSDOMWindowCustom.cpp b/src/3rdparty/webkit/WebCore/bindings/js/JSDOMWindowCustom.cpp index 33ac7bbfd..2804b3ce6 100644 --- a/src/3rdparty/webkit/WebCore/bindings/js/JSDOMWindowCustom.cpp +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSDOMWindowCustom.cpp @@ -38,29 +38,53 @@ #include "JSDOMWindowShell.h" #include "JSEvent.h" #include "JSEventListener.h" +#include "JSEventSourceConstructor.h" #include "JSHTMLCollection.h" #include "JSHistory.h" #include "JSImageConstructor.h" #include "JSLocation.h" #include "JSMessageChannelConstructor.h" #include "JSMessagePort.h" +#include "JSMessagePortCustom.h" #include "JSOptionConstructor.h" + +#if ENABLE(SHARED_WORKERS) #include "JSSharedWorkerConstructor.h" +#endif + +#if ENABLE(3D_CANVAS) +#include "JSCanvasArrayBufferConstructor.h" +#include "JSCanvasByteArrayConstructor.h" +#include "JSCanvasUnsignedByteArrayConstructor.h" +#include "JSCanvasIntArrayConstructor.h" +#include "JSCanvasUnsignedIntArrayConstructor.h" +#include "JSCanvasShortArrayConstructor.h" +#include "JSCanvasUnsignedShortArrayConstructor.h" +#include "JSCanvasFloatArrayConstructor.h" +#endif #include "JSWebKitCSSMatrixConstructor.h" #include "JSWebKitPointConstructor.h" +#if ENABLE(WEB_SOCKETS) +#include "JSWebSocketConstructor.h" +#endif #include "JSWorkerConstructor.h" #include "JSXMLHttpRequestConstructor.h" #include "JSXSLTProcessorConstructor.h" #include "Location.h" #include "MediaPlayer.h" #include "MessagePort.h" +#include "NotificationCenter.h" #include "Page.h" #include "PlatformScreen.h" #include "RegisteredEventListener.h" #include "ScheduledAction.h" #include "ScriptController.h" +#include "SerializedScriptValue.h" #include "Settings.h" +#include "SharedWorkerRepository.h" #include "WindowFeatures.h" +#include <runtime/Error.h> +#include <runtime/JSFunction.h> #include <runtime/JSObject.h> #include <runtime/PrototypeFunction.h> @@ -68,32 +92,32 @@ using namespace JSC; namespace WebCore { -void JSDOMWindow::mark() +void JSDOMWindow::markChildren(MarkStack& markStack) { - Base::mark(); + Base::markChildren(markStack); - markEventListeners(impl()->eventListeners()); + impl()->markEventListeners(markStack); JSGlobalData& globalData = *Heap::heap(this)->globalData(); - markDOMObjectWrapper(globalData, impl()->optionalConsole()); - markDOMObjectWrapper(globalData, impl()->optionalHistory()); - markDOMObjectWrapper(globalData, impl()->optionalLocationbar()); - markDOMObjectWrapper(globalData, impl()->optionalMenubar()); - markDOMObjectWrapper(globalData, impl()->optionalNavigator()); - markDOMObjectWrapper(globalData, impl()->optionalPersonalbar()); - markDOMObjectWrapper(globalData, impl()->optionalScreen()); - markDOMObjectWrapper(globalData, impl()->optionalScrollbars()); - markDOMObjectWrapper(globalData, impl()->optionalSelection()); - markDOMObjectWrapper(globalData, impl()->optionalStatusbar()); - markDOMObjectWrapper(globalData, impl()->optionalToolbar()); - markDOMObjectWrapper(globalData, impl()->optionalLocation()); + markDOMObjectWrapper(markStack, globalData, impl()->optionalConsole()); + markDOMObjectWrapper(markStack, globalData, impl()->optionalHistory()); + markDOMObjectWrapper(markStack, globalData, impl()->optionalLocationbar()); + markDOMObjectWrapper(markStack, globalData, impl()->optionalMenubar()); + markDOMObjectWrapper(markStack, globalData, impl()->optionalNavigator()); + markDOMObjectWrapper(markStack, globalData, impl()->optionalPersonalbar()); + markDOMObjectWrapper(markStack, globalData, impl()->optionalScreen()); + markDOMObjectWrapper(markStack, globalData, impl()->optionalScrollbars()); + markDOMObjectWrapper(markStack, globalData, impl()->optionalSelection()); + markDOMObjectWrapper(markStack, globalData, impl()->optionalStatusbar()); + markDOMObjectWrapper(markStack, globalData, impl()->optionalToolbar()); + markDOMObjectWrapper(markStack, globalData, impl()->optionalLocation()); #if ENABLE(DOM_STORAGE) - markDOMObjectWrapper(globalData, impl()->optionalSessionStorage()); - markDOMObjectWrapper(globalData, impl()->optionalLocalStorage()); + markDOMObjectWrapper(markStack, globalData, impl()->optionalSessionStorage()); + markDOMObjectWrapper(markStack, globalData, impl()->optionalLocalStorage()); #endif #if ENABLE(OFFLINE_WEB_APPLICATIONS) - markDOMObjectWrapper(globalData, impl()->optionalApplicationCache()); + markDOMObjectWrapper(markStack, globalData, impl()->optionalApplicationCache()); #endif } @@ -271,6 +295,150 @@ bool JSDOMWindow::getOwnPropertySlot(ExecState* exec, const Identifier& property return Base::getOwnPropertySlot(exec, propertyName, slot); } +bool JSDOMWindow::getOwnPropertyDescriptor(ExecState* exec, const Identifier& propertyName, PropertyDescriptor& descriptor) +{ + // When accessing a Window cross-domain, functions are always the native built-in ones, and they + // are not affected by properties changed on the Window or anything in its prototype chain. + // This is consistent with the behavior of Firefox. + + const HashEntry* entry; + + // We don't want any properties other than "close" and "closed" on a closed window. + if (!impl()->frame()) { + // The following code is safe for cross-domain and same domain use. + // It ignores any custom properties that might be set on the DOMWindow (including a custom prototype). + entry = s_info.propHashTable(exec)->entry(exec, propertyName); + if (entry && !(entry->attributes() & Function) && entry->propertyGetter() == jsDOMWindowClosed) { + descriptor.setDescriptor(jsBoolean(true), ReadOnly | DontDelete | DontEnum); + return true; + } + entry = JSDOMWindowPrototype::s_info.propHashTable(exec)->entry(exec, propertyName); + if (entry && (entry->attributes() & Function) && entry->function() == jsDOMWindowPrototypeFunctionClose) { + PropertySlot slot; + slot.setCustom(this, nonCachingStaticFunctionGetter<jsDOMWindowPrototypeFunctionClose, 0>); + descriptor.setDescriptor(slot.getValue(exec, propertyName), ReadOnly | DontDelete | DontEnum); + return true; + } + descriptor.setUndefined(); + return true; + } + + String errorMessage; + bool allowsAccess = allowsAccessFrom(exec, errorMessage); + if (allowsAccess && JSGlobalObject::getOwnPropertyDescriptor(exec, propertyName, descriptor)) + return true; + + // We need this code here because otherwise JSDOMWindowBase will stop the search before we even get to the + // prototype due to the blanket same origin (allowsAccessFrom) check at the end of getOwnPropertySlot. + // Also, it's important to get the implementation straight out of the DOMWindow prototype regardless of + // what prototype is actually set on this object. + entry = JSDOMWindowPrototype::s_info.propHashTable(exec)->entry(exec, propertyName); + if (entry) { + if (entry->attributes() & Function) { + if (entry->function() == jsDOMWindowPrototypeFunctionBlur) { + if (!allowsAccess) { + PropertySlot slot; + slot.setCustom(this, nonCachingStaticFunctionGetter<jsDOMWindowPrototypeFunctionBlur, 0>); + descriptor.setDescriptor(slot.getValue(exec, propertyName), ReadOnly | DontDelete | DontEnum); + return true; + } + } else if (entry->function() == jsDOMWindowPrototypeFunctionClose) { + if (!allowsAccess) { + PropertySlot slot; + slot.setCustom(this, nonCachingStaticFunctionGetter<jsDOMWindowPrototypeFunctionClose, 0>); + descriptor.setDescriptor(slot.getValue(exec, propertyName), ReadOnly | DontDelete | DontEnum); + return true; + } + } else if (entry->function() == jsDOMWindowPrototypeFunctionFocus) { + if (!allowsAccess) { + PropertySlot slot; + slot.setCustom(this, nonCachingStaticFunctionGetter<jsDOMWindowPrototypeFunctionFocus, 0>); + descriptor.setDescriptor(slot.getValue(exec, propertyName), ReadOnly | DontDelete | DontEnum); + return true; + } + } else if (entry->function() == jsDOMWindowPrototypeFunctionPostMessage) { + if (!allowsAccess) { + PropertySlot slot; + slot.setCustom(this, nonCachingStaticFunctionGetter<jsDOMWindowPrototypeFunctionPostMessage, 2>); + descriptor.setDescriptor(slot.getValue(exec, propertyName), ReadOnly | DontDelete | DontEnum); + return true; + } + } else if (entry->function() == jsDOMWindowPrototypeFunctionShowModalDialog) { + if (!DOMWindow::canShowModalDialog(impl()->frame())) { + descriptor.setUndefined(); + return true; + } + } + } + } else { + // Allow access to toString() cross-domain, but always Object.prototype.toString. + if (propertyName == exec->propertyNames().toString) { + if (!allowsAccess) { + PropertySlot slot; + slot.setCustom(this, objectToStringFunctionGetter); + descriptor.setDescriptor(slot.getValue(exec, propertyName), ReadOnly | DontDelete | DontEnum); + return true; + } + } + } + + entry = JSDOMWindow::s_info.propHashTable(exec)->entry(exec, propertyName); + if (entry) { + PropertySlot slot; + slot.setCustom(this, entry->propertyGetter()); + descriptor.setDescriptor(slot.getValue(exec, propertyName), entry->attributes()); + return true; + } + + // Check for child frames by name before built-in properties to + // match Mozilla. This does not match IE, but some sites end up + // naming frames things that conflict with window properties that + // are in Moz but not IE. Since we have some of these, we have to do + // it the Moz way. + if (impl()->frame()->tree()->child(propertyName)) { + PropertySlot slot; + slot.setCustom(this, childFrameGetter); + descriptor.setDescriptor(slot.getValue(exec, propertyName), ReadOnly | DontDelete | DontEnum); + return true; + } + + // Do prototype lookup early so that functions and attributes in the prototype can have + // precedence over the index and name getters. + JSValue proto = prototype(); + if (proto.isObject()) { + if (asObject(proto)->getPropertyDescriptor(exec, propertyName, descriptor)) { + if (!allowsAccess) { + printErrorMessage(errorMessage); + descriptor.setUndefined(); + } + return true; + } + } + + bool ok; + unsigned i = propertyName.toArrayIndex(&ok); + if (ok && i < impl()->frame()->tree()->childCount()) { + PropertySlot slot; + slot.setCustomIndex(this, i, indexGetter); + descriptor.setDescriptor(slot.getValue(exec, propertyName), ReadOnly | DontDelete | DontEnum); + return true; + } + + // Allow shortcuts like 'Image1' instead of document.images.Image1 + Document* document = impl()->frame()->document(); + if (document->isHTMLDocument()) { + AtomicStringImpl* atomicPropertyName = AtomicString::find(propertyName); + if (atomicPropertyName && (static_cast<HTMLDocument*>(document)->hasNamedItem(atomicPropertyName) || document->hasElementWithId(atomicPropertyName))) { + PropertySlot slot; + slot.setCustom(this, namedItemGetter); + descriptor.setDescriptor(slot.getValue(exec, propertyName), ReadOnly | DontDelete | DontEnum); + return true; + } + } + + return Base::getOwnPropertyDescriptor(exec, propertyName, descriptor); +} + void JSDOMWindow::put(ExecState* exec, const Identifier& propertyName, JSValue value, PutPropertySlot& slot) { if (!impl()->frame()) @@ -306,6 +474,14 @@ void JSDOMWindow::getPropertyNames(ExecState* exec, PropertyNameArray& propertyN Base::getPropertyNames(exec, propertyNames); } +void JSDOMWindow::getOwnPropertyNames(ExecState* exec, PropertyNameArray& propertyNames) +{ + // Only allow the window to enumerated by frames in the same origin. + if (!allowsAccessFrom(exec)) + return; + Base::getOwnPropertyNames(exec, propertyNames); +} + bool JSDOMWindow::getPropertyAttributes(ExecState* exec, const Identifier& propertyName, unsigned& attributes) const { // Only allow getting property attributes properties by frames in the same origin. @@ -314,7 +490,7 @@ bool JSDOMWindow::getPropertyAttributes(ExecState* exec, const Identifier& prope return Base::getPropertyAttributes(exec, propertyName, attributes); } -void JSDOMWindow::defineGetter(ExecState* exec, const Identifier& propertyName, JSObject* getterFunction) +void JSDOMWindow::defineGetter(ExecState* exec, const Identifier& propertyName, JSObject* getterFunction, unsigned attributes) { // Only allow defining getters by frames in the same origin. if (!allowsAccessFrom(exec)) @@ -324,15 +500,23 @@ void JSDOMWindow::defineGetter(ExecState* exec, const Identifier& propertyName, if (propertyName == "location") return; - Base::defineGetter(exec, propertyName, getterFunction); + Base::defineGetter(exec, propertyName, getterFunction, attributes); } -void JSDOMWindow::defineSetter(ExecState* exec, const Identifier& propertyName, JSObject* setterFunction) +void JSDOMWindow::defineSetter(ExecState* exec, const Identifier& propertyName, JSObject* setterFunction, unsigned attributes) { // Only allow defining setters by frames in the same origin. if (!allowsAccessFrom(exec)) return; - Base::defineSetter(exec, propertyName, setterFunction); + Base::defineSetter(exec, propertyName, setterFunction, attributes); +} + +bool JSDOMWindow::defineOwnProperty(JSC::ExecState* exec, const JSC::Identifier& propertyName, JSC::PropertyDescriptor& descriptor, bool shouldThrow) +{ + // Only allow defining properties in this way by frames in the same origin, as it allows setters to be introduced. + if (!allowsAccessFrom(exec)) + return false; + return Base::defineOwnProperty(exec, propertyName, descriptor, shouldThrow); } JSValue JSDOMWindow::lookupGetter(ExecState* exec, const Identifier& propertyName) @@ -398,16 +582,16 @@ void JSDOMWindow::setLocation(ExecState* exec, JSValue value) Frame* frame = impl()->frame(); ASSERT(frame); - if (!shouldAllowNavigation(exec, frame)) - return; - KURL url = completeURL(exec, value.toString(exec)); if (url.isNull()) return; + if (!shouldAllowNavigation(exec, frame)) + return; + if (!protocolIsJavaScript(url) || allowsAccessFrom(exec)) { // We want a new history item if this JS was called via a user gesture - frame->loader()->scheduleLocationChange(url, lexicalFrame->loader()->outgoingReferrer(), !lexicalFrame->script()->anyPageIsProcessingUserGesture(), false, processingUserGesture(exec)); + frame->redirectScheduler()->scheduleLocationChange(url, lexicalFrame->loader()->outgoingReferrer(), !lexicalFrame->script()->anyPageIsProcessingUserGesture(), false, processingUserGesture(exec)); } } @@ -424,6 +608,13 @@ JSValue JSDOMWindow::event(ExecState* exec) const return toJS(exec, event); } +#if ENABLE(EVENTSOURCE) +JSValue JSDOMWindow::eventSource(ExecState* exec) const +{ + return getDOMConstructor<JSEventSourceConstructor>(exec, this); +} +#endif + JSValue JSDOMWindow::image(ExecState* exec) const { return getDOMConstructor<JSImageConstructor>(exec, this); @@ -453,6 +644,48 @@ JSValue JSDOMWindow::webKitCSSMatrix(ExecState* exec) const return getDOMConstructor<JSWebKitCSSMatrixConstructor>(exec, this); } +#if ENABLE(3D_CANVAS) +JSValue JSDOMWindow::canvasArrayBuffer(ExecState* exec) const +{ + return getDOMConstructor<JSCanvasArrayBufferConstructor>(exec, this); +} + +JSValue JSDOMWindow::canvasByteArray(ExecState* exec) const +{ + return getDOMConstructor<JSCanvasByteArrayConstructor>(exec, this); +} + +JSValue JSDOMWindow::canvasUnsignedByteArray(ExecState* exec) const +{ + return getDOMConstructor<JSCanvasUnsignedByteArrayConstructor>(exec, this); +} + +JSValue JSDOMWindow::canvasIntArray(ExecState* exec) const +{ + return getDOMConstructor<JSCanvasIntArrayConstructor>(exec, this); +} + +JSValue JSDOMWindow::canvasUnsignedIntArray(ExecState* exec) const +{ + return getDOMConstructor<JSCanvasUnsignedIntArrayConstructor>(exec, this); +} + +JSValue JSDOMWindow::canvasShortArray(ExecState* exec) const +{ + return getDOMConstructor<JSCanvasShortArrayConstructor>(exec, this); +} + +JSValue JSDOMWindow::canvasUnsignedShortArray(ExecState* exec) const +{ + return getDOMConstructor<JSCanvasUnsignedShortArrayConstructor>(exec, this); +} + +JSValue JSDOMWindow::canvasFloatArray(ExecState* exec) const +{ + return getDOMConstructor<JSCanvasFloatArrayConstructor>(exec, this); +} +#endif + JSValue JSDOMWindow::xmlHttpRequest(ExecState* exec) const { return getDOMConstructor<JSXMLHttpRequestConstructor>(exec, this); @@ -482,7 +715,22 @@ JSValue JSDOMWindow::worker(ExecState* exec) const #if ENABLE(SHARED_WORKERS) JSValue JSDOMWindow::sharedWorker(ExecState* exec) const { - return getDOMConstructor<JSSharedWorkerConstructor>(exec, this); + if (SharedWorkerRepository::isAvailable()) + return getDOMConstructor<JSSharedWorkerConstructor>(exec, this); + return jsUndefined(); +} +#endif + +#if ENABLE(WEB_SOCKETS) +JSValue JSDOMWindow::webSocket(ExecState* exec) const +{ + Frame* frame = impl()->frame(); + if (!frame) + return jsUndefined(); + Settings* settings = frame->settings(); + if (!settings) + return jsUndefined(); + return getDOMConstructor<JSWebSocketConstructor>(exec, this); } #endif @@ -521,21 +769,22 @@ static Frame* createWindow(ExecState* exec, Frame* lexicalFrame, Frame* dynamicF return 0; newFrame->loader()->setOpener(openerFrame); - newFrame->loader()->setOpenedByDOM(); + newFrame->page()->setOpenedByDOM(); - JSDOMWindow* newWindow = toJSDOMWindow(newFrame); + // FIXME: If a window is created from an isolated world, what are the consequences of this? 'dialogArguments' only appears back in the normal world? + JSDOMWindow* newWindow = toJSDOMWindow(newFrame, normalWorld(exec->globalData())); if (dialogArgs) newWindow->putDirect(Identifier(exec, "dialogArguments"), dialogArgs); if (!protocolIsJavaScript(url) || newWindow->allowsAccessFrom(exec)) { - KURL completedURL = url.isEmpty() ? KURL("") : completeURL(exec, url); + KURL completedURL = url.isEmpty() ? KURL(ParsedURLString, "") : completeURL(exec, url); bool userGesture = processingUserGesture(exec); if (created) newFrame->loader()->changeLocation(completedURL, referrer, false, false, userGesture); else if (!url.isEmpty()) - newFrame->loader()->scheduleLocationChange(completedURL.string(), referrer, !lexicalFrame->script()->anyPageIsProcessingUserGesture(), false, userGesture); + newFrame->redirectScheduler()->scheduleLocationChange(completedURL.string(), referrer, !lexicalFrame->script()->anyPageIsProcessingUserGesture(), false, userGesture); } return newFrame; @@ -543,6 +792,10 @@ static Frame* createWindow(ExecState* exec, Frame* lexicalFrame, Frame* dynamicF JSValue JSDOMWindow::open(ExecState* exec, const ArgList& args) { + String urlString = valueToStringWithUndefinedOrNullCheck(exec, args.at(0)); + AtomicString frameName = args.at(1).isUndefinedOrNull() ? "_blank" : AtomicString(args.at(1).toString(exec)); + WindowFeatures windowFeatures(valueToStringWithUndefinedOrNullCheck(exec, args.at(2))); + Frame* frame = impl()->frame(); if (!frame) return jsUndefined(); @@ -555,9 +808,6 @@ JSValue JSDOMWindow::open(ExecState* exec, const ArgList& args) Page* page = frame->page(); - String urlString = valueToStringWithUndefinedOrNullCheck(exec, args.at(0)); - AtomicString frameName = args.at(1).isUndefinedOrNull() ? "_blank" : AtomicString(args.at(1).toString(exec)); - // Because FrameTree::find() returns true for empty strings, we must check for empty framenames. // Otherwise, illegitimate window.open() calls with no name will pass right through the popup blocker. if (!DOMWindow::allowPopUp(dynamicFrame) && (frameName.isEmpty() || !frame->tree()->find(frameName))) @@ -575,14 +825,14 @@ JSValue JSDOMWindow::open(ExecState* exec, const ArgList& args) topOrParent = true; } if (topOrParent) { - if (!shouldAllowNavigation(exec, frame)) - return jsUndefined(); - String completedURL; if (!urlString.isEmpty()) completedURL = completeURL(exec, urlString).string(); - const JSDOMWindow* targetedWindow = toJSDOMWindow(frame); + if (!shouldAllowNavigation(exec, frame)) + return jsUndefined(); + + const JSDOMWindow* targetedWindow = toJSDOMWindow(frame, currentWorld(exec)); if (!completedURL.isEmpty() && (!protocolIsJavaScript(completedURL) || (targetedWindow && targetedWindow->allowsAccessFrom(exec)))) { bool userGesture = processingUserGesture(exec); @@ -591,13 +841,12 @@ JSValue JSDOMWindow::open(ExecState* exec, const ArgList& args) // here. String referrer = dynamicFrame->loader()->outgoingReferrer(); - frame->loader()->scheduleLocationChange(completedURL, referrer, !lexicalFrame->script()->anyPageIsProcessingUserGesture(), false, userGesture); + frame->redirectScheduler()->scheduleLocationChange(completedURL, referrer, !lexicalFrame->script()->anyPageIsProcessingUserGesture(), false, userGesture); } return toJS(exec, frame->domWindow()); } // In the case of a named frame or a new window, we'll use the createWindow() helper - WindowFeatures windowFeatures(valueToStringWithUndefinedOrNullCheck(exec, args.at(2))); FloatRect windowRect(windowFeatures.xSet ? windowFeatures.x : 0, windowFeatures.ySet ? windowFeatures.y : 0, windowFeatures.widthSet ? windowFeatures.width : 0, windowFeatures.heightSet ? windowFeatures.height : 0); DOMWindow::adjustWindowRect(screenAvailableRect(page ? page->mainFrame()->view() : 0), windowRect, windowRect); @@ -617,6 +866,10 @@ JSValue JSDOMWindow::open(ExecState* exec, const ArgList& args) JSValue JSDOMWindow::showModalDialog(ExecState* exec, const ArgList& args) { + String url = valueToStringWithUndefinedOrNullCheck(exec, args.at(0)); + JSValue dialogArgs = args.at(1); + String featureArgs = valueToStringWithUndefinedOrNullCheck(exec, args.at(2)); + Frame* frame = impl()->frame(); if (!frame) return jsUndefined(); @@ -630,10 +883,6 @@ JSValue JSDOMWindow::showModalDialog(ExecState* exec, const ArgList& args) if (!DOMWindow::canShowModalDialogNow(frame) || !DOMWindow::allowPopUp(dynamicFrame)) return jsUndefined(); - String url = valueToStringWithUndefinedOrNullCheck(exec, args.at(0)); - JSValue dialogArgs = args.at(1); - String featureArgs = valueToStringWithUndefinedOrNullCheck(exec, args.at(2)); - HashMap<String, String> features; DOMWindow::parseModalDialogFeatures(featureArgs, features); @@ -684,10 +933,18 @@ JSValue JSDOMWindow::showModalDialog(ExecState* exec, const ArgList& args) if (!dialogFrame) return jsUndefined(); - JSDOMWindow* dialogWindow = toJSDOMWindow(dialogFrame); + JSDOMWindow* dialogWindow = toJSDOMWindow(dialogFrame, currentWorld(exec)); dialogFrame->page()->chrome()->runModal(); - return dialogWindow->getDirect(Identifier(exec, "returnValue")); + Identifier returnValue(exec, "returnValue"); + if (dialogWindow->allowsAccessFromNoErrorMessage(exec)) { + PropertySlot slot; + // This is safe, we have already performed the origin security check and we are + // not interested in any of the DOM properties of the window. + if (dialogWindow->JSGlobalObject::getOwnPropertySlot(exec, returnValue, slot)) + return slot.getValue(exec, returnValue); + } + return jsUndefined(); } JSValue JSDOMWindow::postMessage(ExecState* exec, const ArgList& args) @@ -695,19 +952,23 @@ JSValue JSDOMWindow::postMessage(ExecState* exec, const ArgList& args) DOMWindow* window = impl(); DOMWindow* source = asJSDOMWindow(exec->lexicalGlobalObject())->impl(); - String message = args.at(0).toString(exec); + PassRefPtr<SerializedScriptValue> message = SerializedScriptValue::create(exec, args.at(0)); if (exec->hadException()) return jsUndefined(); - MessagePort* messagePort = (args.size() == 2) ? 0 : toMessagePort(args.at(1)); + MessagePortArray messagePorts; + if (args.size() > 2) + fillMessagePortArray(exec, args.at(1), messagePorts); + if (exec->hadException()) + return jsUndefined(); String targetOrigin = valueToStringWithUndefinedOrNullCheck(exec, args.at((args.size() == 2) ? 1 : 2)); if (exec->hadException()) return jsUndefined(); ExceptionCode ec = 0; - window->postMessage(message, messagePort, targetOrigin, source, ec); + window->postMessage(message, &messagePorts, targetOrigin, source, ec); setDOMException(exec, ec); return jsUndefined(); @@ -715,7 +976,7 @@ JSValue JSDOMWindow::postMessage(ExecState* exec, const ArgList& args) JSValue JSDOMWindow::setTimeout(ExecState* exec, const ArgList& args) { - ScheduledAction* action = ScheduledAction::create(exec, args); + ScheduledAction* action = ScheduledAction::create(exec, args, currentWorld(exec)); if (exec->hadException()) return jsUndefined(); int delay = args.at(1).toInt32(exec); @@ -724,7 +985,7 @@ JSValue JSDOMWindow::setTimeout(ExecState* exec, const ArgList& args) JSValue JSDOMWindow::setInterval(ExecState* exec, const ArgList& args) { - ScheduledAction* action = ScheduledAction::create(exec, args); + ScheduledAction* action = ScheduledAction::create(exec, args, currentWorld(exec)); if (exec->hadException()) return jsUndefined(); int delay = args.at(1).toInt32(exec); @@ -788,9 +1049,11 @@ JSValue JSDOMWindow::addEventListener(ExecState* exec, const ArgList& args) if (!frame) return jsUndefined(); - if (RefPtr<JSEventListener> listener = findOrCreateJSEventListener(args.at(1))) - impl()->addEventListener(AtomicString(args.at(0).toString(exec)), listener.release(), args.at(2).toBoolean(exec)); + JSValue listener = args.at(1); + if (!listener.isObject()) + return jsUndefined(); + impl()->addEventListener(args.at(0).toString(exec), JSEventListener::create(asObject(listener), false, currentWorld(exec)), args.at(2).toBoolean(exec)); return jsUndefined(); } @@ -800,9 +1063,11 @@ JSValue JSDOMWindow::removeEventListener(ExecState* exec, const ArgList& args) if (!frame) return jsUndefined(); - if (JSEventListener* listener = findJSEventListener(args.at(1))) - impl()->removeEventListener(AtomicString(args.at(0).toString(exec)), listener, args.at(2).toBoolean(exec)); + JSValue listener = args.at(1); + if (!listener.isObject()) + return jsUndefined(); + impl()->removeEventListener(args.at(0).toString(exec), JSEventListener::create(asObject(listener), false, currentWorld(exec)).get(), args.at(2).toBoolean(exec)); return jsUndefined(); } diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSDOMWindowShell.cpp b/src/3rdparty/webkit/WebCore/bindings/js/JSDOMWindowShell.cpp index 1bf478b3e..9072f91bc 100644 --- a/src/3rdparty/webkit/WebCore/bindings/js/JSDOMWindowShell.cpp +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSDOMWindowShell.cpp @@ -1,5 +1,5 @@ /* - * Copyright (C) 2008 Apple Inc. All rights reserved. + * Copyright (C) 2008, 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 @@ -71,11 +71,11 @@ void JSDOMWindowShell::setWindow(PassRefPtr<DOMWindow> domWindow) // JSObject methods // ---- -void JSDOMWindowShell::mark() +void JSDOMWindowShell::markChildren(MarkStack& markStack) { - Base::mark(); - if (m_window && !m_window->marked()) - m_window->mark(); + Base::markChildren(markStack); + if (m_window) + markStack.append(m_window); } UString JSDOMWindowShell::className() const @@ -88,6 +88,11 @@ bool JSDOMWindowShell::getOwnPropertySlot(ExecState* exec, const Identifier& pro return m_window->getOwnPropertySlot(exec, propertyName, slot); } +bool JSDOMWindowShell::getOwnPropertyDescriptor(ExecState* exec, const Identifier& propertyName, PropertyDescriptor& descriptor) +{ + return m_window->getOwnPropertyDescriptor(exec, propertyName, descriptor); +} + void JSDOMWindowShell::put(ExecState* exec, const Identifier& propertyName, JSValue value, PutPropertySlot& slot) { m_window->put(exec, propertyName, value, slot); @@ -98,6 +103,11 @@ void JSDOMWindowShell::putWithAttributes(ExecState* exec, const Identifier& prop m_window->putWithAttributes(exec, propertyName, value, attributes); } +bool JSDOMWindowShell::defineOwnProperty(JSC::ExecState* exec, const JSC::Identifier& propertyName, JSC::PropertyDescriptor& descriptor, bool shouldThrow) +{ + return m_window->defineOwnProperty(exec, propertyName, descriptor, shouldThrow); +} + bool JSDOMWindowShell::deleteProperty(ExecState* exec, const Identifier& propertyName) { return m_window->deleteProperty(exec, propertyName); @@ -108,19 +118,24 @@ void JSDOMWindowShell::getPropertyNames(ExecState* exec, PropertyNameArray& prop m_window->getPropertyNames(exec, propertyNames); } +void JSDOMWindowShell::getOwnPropertyNames(ExecState* exec, PropertyNameArray& propertyNames) +{ + m_window->getOwnPropertyNames(exec, propertyNames); +} + bool JSDOMWindowShell::getPropertyAttributes(JSC::ExecState* exec, const Identifier& propertyName, unsigned& attributes) const { return m_window->getPropertyAttributes(exec, propertyName, attributes); } -void JSDOMWindowShell::defineGetter(ExecState* exec, const Identifier& propertyName, JSObject* getterFunction) +void JSDOMWindowShell::defineGetter(ExecState* exec, const Identifier& propertyName, JSObject* getterFunction, unsigned attributes) { - m_window->defineGetter(exec, propertyName, getterFunction); + m_window->defineGetter(exec, propertyName, getterFunction, attributes); } -void JSDOMWindowShell::defineSetter(ExecState* exec, const Identifier& propertyName, JSObject* setterFunction) +void JSDOMWindowShell::defineSetter(ExecState* exec, const Identifier& propertyName, JSObject* setterFunction, unsigned attributes) { - m_window->defineSetter(exec, propertyName, setterFunction); + m_window->defineSetter(exec, propertyName, setterFunction, attributes); } JSValue JSDOMWindowShell::lookupGetter(ExecState* exec, const Identifier& propertyName) @@ -156,18 +171,18 @@ void* JSDOMWindowShell::operator new(size_t size) // Conversion methods // ---- -JSValue toJS(ExecState*, Frame* frame) +JSValue toJS(ExecState* exec, Frame* frame) { if (!frame) return jsNull(); - return frame->script()->windowShell(); + return frame->script()->windowShell(currentWorld(exec)); } -JSDOMWindowShell* toJSDOMWindowShell(Frame* frame) +JSDOMWindowShell* toJSDOMWindowShell(Frame* frame, DOMWrapperWorld* isolatedWorld) { if (!frame) return 0; - return frame->script()->windowShell(); + return frame->script()->windowShell(isolatedWorld); } } // namespace WebCore diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSDOMWindowShell.h b/src/3rdparty/webkit/WebCore/bindings/js/JSDOMWindowShell.h index 6f2189253..36cb8d6ad 100644 --- a/src/3rdparty/webkit/WebCore/bindings/js/JSDOMWindowShell.h +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSDOMWindowShell.h @@ -60,20 +60,25 @@ namespace WebCore { static PassRefPtr<JSC::Structure> createStructure(JSC::JSValue prototype) { - return JSC::Structure::create(prototype, JSC::TypeInfo(JSC::ObjectType)); + return JSC::Structure::create(prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags)); } private: - virtual void mark(); + static const unsigned StructureFlags = JSC::OverridesGetOwnPropertySlot | JSC::OverridesMarkChildren | JSC::OverridesGetPropertyNames | DOMObject::StructureFlags; + + virtual void markChildren(JSC::MarkStack&); virtual JSC::UString className() const; virtual bool getOwnPropertySlot(JSC::ExecState*, const JSC::Identifier& propertyName, JSC::PropertySlot&); + virtual bool getOwnPropertyDescriptor(JSC::ExecState*, const JSC::Identifier& propertyName, JSC::PropertyDescriptor&); virtual void put(JSC::ExecState*, const JSC::Identifier& propertyName, JSC::JSValue, JSC::PutPropertySlot&); virtual void putWithAttributes(JSC::ExecState*, const JSC::Identifier& propertyName, JSC::JSValue, unsigned attributes); virtual bool deleteProperty(JSC::ExecState*, const JSC::Identifier& propertyName); virtual void getPropertyNames(JSC::ExecState*, JSC::PropertyNameArray&); + virtual void getOwnPropertyNames(JSC::ExecState*, JSC::PropertyNameArray&); virtual bool getPropertyAttributes(JSC::ExecState*, const JSC::Identifier& propertyName, unsigned& attributes) const; - virtual void defineGetter(JSC::ExecState*, const JSC::Identifier& propertyName, JSC::JSObject* getterFunction); - virtual void defineSetter(JSC::ExecState*, const JSC::Identifier& propertyName, JSC::JSObject* setterFunction); + virtual void defineGetter(JSC::ExecState*, const JSC::Identifier& propertyName, JSC::JSObject* getterFunction, unsigned attributes); + virtual void defineSetter(JSC::ExecState*, const JSC::Identifier& propertyName, JSC::JSObject* setterFunction, unsigned attributes); + virtual bool defineOwnProperty(JSC::ExecState*, const JSC::Identifier& propertyName, JSC::PropertyDescriptor&, bool shouldThrow); virtual JSC::JSValue lookupGetter(JSC::ExecState*, const JSC::Identifier& propertyName); virtual JSC::JSValue lookupSetter(JSC::ExecState*, const JSC::Identifier& propertyName); virtual JSC::JSObject* unwrappedObject(); @@ -83,7 +88,7 @@ namespace WebCore { }; JSC::JSValue toJS(JSC::ExecState*, Frame*); - JSDOMWindowShell* toJSDOMWindowShell(Frame*); + JSDOMWindowShell* toJSDOMWindowShell(Frame*, DOMWrapperWorld*); } // namespace WebCore diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSDatabaseCustom.cpp b/src/3rdparty/webkit/WebCore/bindings/js/JSDatabaseCustom.cpp index af3b06634..0932ccaa6 100644 --- a/src/3rdparty/webkit/WebCore/bindings/js/JSDatabaseCustom.cpp +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSDatabaseCustom.cpp @@ -52,17 +52,13 @@ JSValue JSDatabase::changeVersion(ExecState* exec, const ArgList& args) String oldVersion = args.at(0).toString(exec); String newVersion = args.at(1).toString(exec); - Frame* frame = asJSDOMWindow(exec->dynamicGlobalObject())->impl()->frame(); - if (!frame) - return jsUndefined(); - JSObject* object; if (!(object = args.at(2).getObject())) { setDOMException(exec, TYPE_MISMATCH_ERR); return jsUndefined(); } - RefPtr<SQLTransactionCallback> callback(JSCustomSQLTransactionCallback::create(object, frame)); + RefPtr<SQLTransactionCallback> callback(JSCustomSQLTransactionCallback::create(object, static_cast<JSDOMGlobalObject*>(exec->dynamicGlobalObject()))); RefPtr<SQLTransactionErrorCallback> errorCallback; if (!args.at(3).isNull()) { @@ -71,24 +67,25 @@ JSValue JSDatabase::changeVersion(ExecState* exec, const ArgList& args) return jsUndefined(); } - errorCallback = JSCustomSQLTransactionErrorCallback::create(object, frame); + errorCallback = JSCustomSQLTransactionErrorCallback::create(object, static_cast<JSDOMGlobalObject*>(exec->dynamicGlobalObject())); } RefPtr<VoidCallback> successCallback; if (!args.at(4).isNull()) { - successCallback = toVoidCallback(exec, args.at(4)); - if (!successCallback) { + if (!(object = args.at(4).getObject())) { setDOMException(exec, TYPE_MISMATCH_ERR); return jsUndefined(); } + + successCallback = JSCustomVoidCallback::create(object, static_cast<JSDOMGlobalObject*>(exec->dynamicGlobalObject())); } - + m_impl->changeVersion(oldVersion, newVersion, callback.release(), errorCallback.release(), successCallback.release()); return jsUndefined(); } -JSValue JSDatabase::transaction(ExecState* exec, const ArgList& args) +static JSValue createTransaction(ExecState* exec, const ArgList& args, Database* database, JSDOMGlobalObject* globalObject, bool readOnly) { JSObject* object; @@ -96,12 +93,8 @@ JSValue JSDatabase::transaction(ExecState* exec, const ArgList& args) setDOMException(exec, TYPE_MISMATCH_ERR); return jsUndefined(); } - - Frame* frame = asJSDOMWindow(exec->dynamicGlobalObject())->impl()->frame(); - if (!frame) - return jsUndefined(); - - RefPtr<SQLTransactionCallback> callback(JSCustomSQLTransactionCallback::create(object, frame)); + + RefPtr<SQLTransactionCallback> callback(JSCustomSQLTransactionCallback::create(object, globalObject)); RefPtr<SQLTransactionErrorCallback> errorCallback; if (args.size() > 1 && !args.at(1).isNull()) { @@ -110,22 +103,33 @@ JSValue JSDatabase::transaction(ExecState* exec, const ArgList& args) return jsUndefined(); } - errorCallback = JSCustomSQLTransactionErrorCallback::create(object, frame); + errorCallback = JSCustomSQLTransactionErrorCallback::create(object, globalObject); } RefPtr<VoidCallback> successCallback; if (args.size() > 2 && !args.at(2).isNull()) { - successCallback = toVoidCallback(exec, args.at(2)); - if (!successCallback) { + if (!(object = args.at(2).getObject())) { setDOMException(exec, TYPE_MISMATCH_ERR); return jsUndefined(); } + + successCallback = JSCustomVoidCallback::create(object, globalObject); } - m_impl->transaction(callback.release(), errorCallback.release(), successCallback.release()); - + database->transaction(callback.release(), errorCallback.release(), successCallback.release(), readOnly); return jsUndefined(); } + +JSValue JSDatabase::transaction(ExecState* exec, const ArgList& args) +{ + return createTransaction(exec, args, m_impl.get(), static_cast<JSDOMGlobalObject*>(exec->dynamicGlobalObject()), false); +} +JSValue JSDatabase::readTransaction(ExecState* exec, const ArgList& args) +{ + return createTransaction(exec, args, m_impl.get(), static_cast<JSDOMGlobalObject*>(exec->dynamicGlobalObject()), true); +} + } + #endif // ENABLE(DATABASE) diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSDedicatedWorkerContextCustom.cpp b/src/3rdparty/webkit/WebCore/bindings/js/JSDedicatedWorkerContextCustom.cpp index c45a6a34a..fbee5ef42 100644 --- a/src/3rdparty/webkit/WebCore/bindings/js/JSDedicatedWorkerContextCustom.cpp +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSDedicatedWorkerContextCustom.cpp @@ -1,5 +1,6 @@ /* * Copyright (C) 2009 Google Inc. All rights reserved. + * 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 @@ -34,15 +35,16 @@ #include "JSDedicatedWorkerContext.h" +#include "JSDOMBinding.h" +#include "JSMessagePortCustom.h" + using namespace JSC; namespace WebCore { -void JSDedicatedWorkerContext::mark() +JSC::JSValue JSDedicatedWorkerContext::postMessage(JSC::ExecState* exec, const JSC::ArgList& args) { - Base::mark(); - - markIfNotNull(impl()->onmessage()); + return handlePostMessage(exec, args, impl()); } } // namespace WebCore diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSDesktopNotificationsCustom.cpp b/src/3rdparty/webkit/WebCore/bindings/js/JSDesktopNotificationsCustom.cpp new file mode 100644 index 000000000..7485c1f86 --- /dev/null +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSDesktopNotificationsCustom.cpp @@ -0,0 +1,87 @@ +/* + * Copyright (C) 2009 Google 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: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * 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. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "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 THE COPYRIGHT + * OWNER 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(NOTIFICATIONS) + +#include "Document.h" +#include "JSCustomVoidCallback.h" +#include "JSEventListener.h" +#include "JSNotification.h" +#include "JSNotificationCenter.h" +#include "Notification.h" +#include "NotificationCenter.h" +#include <runtime/Error.h> + +using namespace JSC; + +namespace WebCore { + +JSValue JSNotificationCenter::requestPermission(ExecState* exec, const ArgList& args) +{ + // Permission request is only valid from page context. + ScriptExecutionContext* context = impl()->context(); + if (context->isWorkerContext()) + return throwError(exec, SyntaxError); + + if (!args.at(0).isObject()) + return throwError(exec, TypeError); + + PassRefPtr<JSCustomVoidCallback> callback = JSCustomVoidCallback::create(args.at(0).getObject(), static_cast<Document*>(context)->frame()); + + impl()->requestPermission(callback); + return jsUndefined(); +} + +JSValue JSNotification::addEventListener(ExecState* exec, const ArgList& args) +{ + JSValue listener = args.at(1); + if (!listener.isObject()) + return jsUndefined(); + + impl()->addEventListener(args.at(0).toString(exec), JSEventListener::create(asObject(listener)), false, currentWorld(exec)), args.at(2).toBoolean(exec)); + return jsUndefined(); +} + +JSValue JSNotification::removeEventListener(ExecState* exec, const ArgList& args) +{ + JSValue listener = args.at(1); + if (!listener.isObject()) + return jsUndefined(); + + impl()->removeEventListener(args.at(0).toString(exec), JSEventListener::create(asObject(listener), false, currentWorld(exec)).get(), args.at(2).toBoolean(exec)); + return jsUndefined(); +} + + +} // namespace + +#endif // ENABLE(NOTIFICATIONS) diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSDocumentCustom.cpp b/src/3rdparty/webkit/WebCore/bindings/js/JSDocumentCustom.cpp index 493aaeaa8..d7f872542 100644 --- a/src/3rdparty/webkit/WebCore/bindings/js/JSDocumentCustom.cpp +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSDocumentCustom.cpp @@ -1,5 +1,5 @@ /* - * Copyright (C) 2007, 2008 Apple Inc. All rights reserved. + * Copyright (C) 2007, 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 @@ -24,6 +24,10 @@ #include "Frame.h" #include "FrameLoader.h" #include "HTMLDocument.h" +#include "JSCanvasRenderingContext2D.h" +#if ENABLE(3D_CANVAS) +#include "JSCanvasRenderingContext3D.h" +#endif #include "JSDOMWindowCustom.h" #include "JSHTMLDocument.h" #include "JSLocation.h" @@ -35,15 +39,23 @@ #include "SVGDocument.h" #endif +#include <wtf/GetPtr.h> + using namespace JSC; namespace WebCore { -void JSDocument::mark() +void JSDocument::markChildren(MarkStack& markStack) { - JSNode::mark(); - markDOMNodesForDocument(impl()); - markActiveObjectsForContext(*Heap::heap(this)->globalData(), impl()); + JSNode::markChildren(markStack); + + Document* document = impl(); + JSGlobalData& globalData = *Heap::heap(this)->globalData(); + + markDOMNodesForDocument(markStack, document); + markActiveObjectsForContext(markStack, globalData, document); + markDOMObjectWrapper(markStack, globalData, document->implementation()); + markDOMObjectWrapper(markStack, globalData, document->styleSheets()); } JSValue JSDocument::location(ExecState* exec) const @@ -76,7 +88,7 @@ void JSDocument::setLocation(ExecState* exec, JSValue value) str = activeFrame->document()->completeURL(str).string(); bool userGesture = activeFrame->script()->processingUserGesture(); - frame->loader()->scheduleLocationChange(str, activeFrame->loader()->outgoingReferrer(), !activeFrame->script()->anyPageIsProcessingUserGesture(), false, userGesture); + frame->redirectScheduler()->scheduleLocationChange(str, activeFrame->loader()->outgoingReferrer(), !activeFrame->script()->anyPageIsProcessingUserGesture(), false, userGesture); } JSValue toJS(ExecState* exec, JSDOMGlobalObject* globalObject, Document* document) diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSElementCustom.cpp b/src/3rdparty/webkit/WebCore/bindings/js/JSElementCustom.cpp index 47793d0a8..fb64ff26c 100644 --- a/src/3rdparty/webkit/WebCore/bindings/js/JSElementCustom.cpp +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSElementCustom.cpp @@ -1,5 +1,5 @@ /* - * Copyright (C) 2007, 2008 Apple Inc. All rights reserved. + * Copyright (C) 2007, 2008, 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 @@ -51,15 +51,27 @@ namespace WebCore { using namespace HTMLNames; +void JSElement::markChildren(MarkStack& markStack) +{ + Base::markChildren(markStack); + + Element* element = impl(); + JSGlobalData& globalData = *Heap::heap(this)->globalData(); + + markDOMObjectWrapper(markStack, globalData, element->attributeMap()); + if (element->isStyledElement()) + markDOMObjectWrapper(markStack, globalData, static_cast<StyledElement*>(element)->inlineStyleDecl()); +} + static inline bool allowSettingSrcToJavascriptURL(ExecState* exec, Element* element, const String& name, const String& value) { if ((element->hasTagName(iframeTag) || element->hasTagName(frameTag)) && equalIgnoringCase(name, "src") && protocolIsJavaScript(deprecatedParseURL(value))) { - HTMLFrameElementBase* frame = static_cast<HTMLFrameElementBase*>(element); - if (!checkNodeSecurity(exec, frame->contentDocument())) + Document* contentDocument = static_cast<HTMLFrameElementBase*>(element)->contentDocument(); + if (contentDocument && !checkNodeSecurity(exec, contentDocument)) return false; } return true; -} +} JSValue JSElement::setAttribute(ExecState* exec, const ArgList& args) { diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSEventCustom.cpp b/src/3rdparty/webkit/WebCore/bindings/js/JSEventCustom.cpp index 257c25928..edf9151a7 100644 --- a/src/3rdparty/webkit/WebCore/bindings/js/JSEventCustom.cpp +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSEventCustom.cpp @@ -31,6 +31,7 @@ #include "Clipboard.h" #include "Event.h" +#include "JSBeforeLoadEvent.h" #include "JSClipboard.h" #include "JSErrorEvent.h" #include "JSKeyboardEvent.h" @@ -38,6 +39,7 @@ #include "JSMouseEvent.h" #include "JSMutationEvent.h" #include "JSOverflowEvent.h" +#include "JSPageTransitionEvent.h" #include "JSProgressEvent.h" #include "JSTextEvent.h" #include "JSUIEvent.h" @@ -45,12 +47,14 @@ #include "JSWebKitTransitionEvent.h" #include "JSWheelEvent.h" #include "JSXMLHttpRequestProgressEvent.h" +#include "BeforeLoadEvent.h" #include "ErrorEvent.h" #include "KeyboardEvent.h" #include "MessageEvent.h" #include "MouseEvent.h" #include "MutationEvent.h" #include "OverflowEvent.h" +#include "PageTransitionEvent.h" #include "ProgressEvent.h" #include "TextEvent.h" #include "UIEvent.h" @@ -111,12 +115,15 @@ JSValue toJS(ExecState* exec, JSDOMGlobalObject* globalObject, Event* event) wrapper = CREATE_DOM_OBJECT_WRAPPER(exec, globalObject, OverflowEvent, event); else if (event->isMessageEvent()) wrapper = CREATE_DOM_OBJECT_WRAPPER(exec, globalObject, MessageEvent, event); + else if (event->isPageTransitionEvent()) + wrapper = CREATE_DOM_OBJECT_WRAPPER(exec, globalObject, PageTransitionEvent, event); else if (event->isProgressEvent()) { if (event->isXMLHttpRequestProgressEvent()) wrapper = CREATE_DOM_OBJECT_WRAPPER(exec, globalObject, XMLHttpRequestProgressEvent, event); else wrapper = CREATE_DOM_OBJECT_WRAPPER(exec, globalObject, ProgressEvent, event); - } + } else if (event->isBeforeLoadEvent()) + wrapper = CREATE_DOM_OBJECT_WRAPPER(exec, globalObject, BeforeLoadEvent, event); #if ENABLE(DOM_STORAGE) else if (event->isStorageEvent()) wrapper = CREATE_DOM_OBJECT_WRAPPER(exec, globalObject, StorageEvent, event); diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSEventListener.cpp b/src/3rdparty/webkit/WebCore/bindings/js/JSEventListener.cpp index a659d3e36..1a999a859 100644 --- a/src/3rdparty/webkit/WebCore/bindings/js/JSEventListener.cpp +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSEventListener.cpp @@ -31,54 +31,45 @@ using namespace JSC; namespace WebCore { -JSEventListener::JSEventListener(JSObject* function, JSDOMGlobalObject* globalObject, bool isAttribute) - : m_jsFunction(function) - , m_globalObject(globalObject) +JSEventListener::JSEventListener(JSObject* function, bool isAttribute, DOMWrapperWorld* isolatedWorld) + : EventListener(JSEventListenerType) + , m_jsFunction(function) , m_isAttribute(isAttribute) + , m_isolatedWorld(isolatedWorld) { - if (!m_isAttribute && m_jsFunction) - globalObject->jsEventListeners().set(m_jsFunction, this); } JSEventListener::~JSEventListener() { - if (!m_isAttribute && m_jsFunction && m_globalObject) - m_globalObject->jsEventListeners().remove(m_jsFunction); } -JSObject* JSEventListener::jsFunction() const +JSObject* JSEventListener::jsFunction(ScriptExecutionContext*) const { return m_jsFunction; } -void JSEventListener::markJSFunction() +void JSEventListener::markJSFunction(MarkStack& markStack) { - if (m_jsFunction && !m_jsFunction->marked()) - m_jsFunction->mark(); - if (m_globalObject && !m_globalObject->marked()) - m_globalObject->mark(); + if (m_jsFunction) + markStack.append(m_jsFunction); } -void JSEventListener::handleEvent(Event* event, bool isWindowEvent) +void JSEventListener::handleEvent(ScriptExecutionContext* scriptExecutionContext, Event* event) { + ASSERT(scriptExecutionContext); + if (!scriptExecutionContext) + return; + JSLock lock(SilenceAssertionsOnly); - JSObject* jsFunction = this->jsFunction(); + JSObject* jsFunction = this->jsFunction(scriptExecutionContext); if (!jsFunction) return; - JSDOMGlobalObject* globalObject = m_globalObject; - // Null check as clearGlobalObject() can clear this and we still get called back by - // xmlhttprequest objects. See http://bugs.webkit.org/show_bug.cgi?id=13275 - // FIXME: Is this check still necessary? Requests are supposed to be stopped before clearGlobalObject() is called. - ASSERT(globalObject); + JSDOMGlobalObject* globalObject = toJSDOMGlobalObject(scriptExecutionContext, m_isolatedWorld.get()); if (!globalObject) return; - ScriptExecutionContext* scriptExecutionContext = globalObject->scriptExecutionContext(); - if (!scriptExecutionContext) - return; - if (scriptExecutionContext->isDocument()) { JSDOMWindow* window = static_cast<JSDOMWindow*>(globalObject); Frame* frame = window->impl()->frame(); @@ -96,7 +87,12 @@ void JSEventListener::handleEvent(Event* event, bool isWindowEvent) ExecState* exec = globalObject->globalExec(); - JSValue handleEventFunction = jsFunction->get(exec, Identifier(exec, "handleEvent")); + JSValue handleEventFunction; + { + // Switch worlds, just in case handleEvent is a getter and causes JS execution! + EnterDOMWrapperWorld worldEntry(exec, m_isolatedWorld.get()); + handleEventFunction = jsFunction->get(exec, Identifier(exec, "handleEvent")); + } CallData callData; CallType callType = handleEventFunction.getCallData(callData); if (callType == CallTypeNone) { @@ -113,26 +109,14 @@ void JSEventListener::handleEvent(Event* event, bool isWindowEvent) Event* savedEvent = globalObject->currentEvent(); globalObject->setCurrentEvent(event); - // If this event handler is the first JavaScript to execute, then the - // dynamic global object should be set to the global object of the - // window in which the event occurred. JSGlobalData* globalData = globalObject->globalData(); DynamicGlobalObjectScope globalObjectScope(exec, globalData->dynamicGlobalObject ? globalData->dynamicGlobalObject : globalObject); - JSValue retval; - if (handleEventFunction) { - globalObject->globalData()->timeoutChecker.start(); - retval = call(exec, handleEventFunction, callType, callData, jsFunction, args); - } else { - JSValue thisValue; - if (isWindowEvent) - thisValue = globalObject->toThisObject(exec); - else - thisValue = toJS(exec, globalObject, event->currentTarget()); - globalObject->globalData()->timeoutChecker.start(); - retval = call(exec, jsFunction, callType, callData, thisValue, args); - } - globalObject->globalData()->timeoutChecker.stop(); + globalData->timeoutChecker.start(); + JSValue retval = handleEventFunction + ? callInWorld(exec, handleEventFunction, callType, callData, jsFunction, args, m_isolatedWorld.get()) + : callInWorld(exec, jsFunction, callType, callData, toJS(exec, globalObject, event->currentTarget()), args, m_isolatedWorld.get()); + globalData->timeoutChecker.stop(); globalObject->setCurrentEvent(savedEvent); @@ -154,18 +138,15 @@ void JSEventListener::handleEvent(Event* event, bool isWindowEvent) } } -bool JSEventListener::reportError(const String& message, const String& url, int lineNumber) +bool JSEventListener::reportError(ScriptExecutionContext* context, const String& message, const String& url, int lineNumber) { JSLock lock(SilenceAssertionsOnly); - JSObject* jsFunction = this->jsFunction(); + JSObject* jsFunction = this->jsFunction(context); if (!jsFunction) return false; - JSDOMGlobalObject* globalObject = m_globalObject; - if (!globalObject) - return false; - + JSDOMGlobalObject* globalObject = toJSDOMGlobalObject(context, m_isolatedWorld.get()); ExecState* exec = globalObject->globalExec(); CallData callData; @@ -179,17 +160,14 @@ bool JSEventListener::reportError(const String& message, const String& url, int args.append(jsString(exec, url)); args.append(jsNumber(exec, lineNumber)); - // If this event handler is the first JavaScript to execute, then the - // dynamic global object should be set to the global object of the - // window in which the event occurred. JSGlobalData* globalData = globalObject->globalData(); DynamicGlobalObjectScope globalObjectScope(exec, globalData->dynamicGlobalObject ? globalData->dynamicGlobalObject : globalObject); JSValue thisValue = globalObject->toThisObject(exec); - globalObject->globalData()->timeoutChecker.start(); - JSValue returnValue = call(exec, jsFunction, callType, callData, thisValue, args); - globalObject->globalData()->timeoutChecker.stop(); + globalData->timeoutChecker.start(); + JSValue returnValue = callInWorld(exec, jsFunction, callType, callData, thisValue, args, m_isolatedWorld.get()); + globalData->timeoutChecker.stop(); // If an error occurs while handling the script error, it should be bubbled up. if (exec->hadException()) { @@ -206,4 +184,11 @@ bool JSEventListener::virtualisAttribute() const return m_isAttribute; } +bool JSEventListener::operator==(const EventListener& listener) +{ + if (const JSEventListener* jsEventListener = JSEventListener::cast(&listener)) + return m_jsFunction == jsEventListener->m_jsFunction && m_isAttribute == jsEventListener->m_isAttribute; + return false; +} + } // namespace WebCore diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSEventListener.h b/src/3rdparty/webkit/WebCore/bindings/js/JSEventListener.h index 24977502e..bf3af4811 100644 --- a/src/3rdparty/webkit/WebCore/bindings/js/JSEventListener.h +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSEventListener.h @@ -30,31 +30,40 @@ namespace WebCore { class JSEventListener : public EventListener { public: - static PassRefPtr<JSEventListener> create(JSC::JSObject* listener, JSDOMGlobalObject* globalObject, bool isAttribute) + static PassRefPtr<JSEventListener> create(JSC::JSObject* listener, bool isAttribute, DOMWrapperWorld* isolatedWorld) { - return adoptRef(new JSEventListener(listener, globalObject, isAttribute)); + return adoptRef(new JSEventListener(listener, isAttribute, isolatedWorld)); } + + static const JSEventListener* cast(const EventListener* listener) + { + return listener->type() == JSEventListenerType + ? static_cast<const JSEventListener*>(listener) + : 0; + } + virtual ~JSEventListener(); - void clearGlobalObject() { m_globalObject = 0; } + + virtual bool operator==(const EventListener& other); // Returns true if this event listener was created for an event handler attribute, like "onload" or "onclick". bool isAttribute() const { return m_isAttribute; } - virtual JSC::JSObject* jsFunction() const; + virtual JSC::JSObject* jsFunction(ScriptExecutionContext*) const; private: - virtual void markJSFunction(); - virtual void handleEvent(Event*, bool isWindowEvent); - virtual bool reportError(const String& message, const String& url, int lineNumber); + virtual void markJSFunction(JSC::MarkStack&); + virtual void handleEvent(ScriptExecutionContext*, Event*); + virtual bool reportError(ScriptExecutionContext*, const String& message, const String& url, int lineNumber); virtual bool virtualisAttribute() const; void clearJSFunctionInline(); protected: - JSEventListener(JSC::JSObject* function, JSDOMGlobalObject*, bool isAttribute); + JSEventListener(JSC::JSObject* function, bool isAttribute, DOMWrapperWorld* isolatedWorld); mutable JSC::JSObject* m_jsFunction; - JSDOMGlobalObject* m_globalObject; bool m_isAttribute; + RefPtr<DOMWrapperWorld> m_isolatedWorld; }; } // namespace WebCore diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSEventSourceConstructor.cpp b/src/3rdparty/webkit/WebCore/bindings/js/JSEventSourceConstructor.cpp new file mode 100644 index 000000000..c6e482539 --- /dev/null +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSEventSourceConstructor.cpp @@ -0,0 +1,91 @@ +/* + * Copyright (C) 2009 Ericsson AB + * 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. + * 3. Neither the name of Ericsson nor the names of its contributors + * may be used to endorse or promote products derived from this + * software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "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 THE COPYRIGHT + * OWNER 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(EVENTSOURCE) + +#include "JSEventSourceConstructor.h" + +#include "EventSource.h" +#include "ExceptionCode.h" +#include "JSEventSource.h" +#include "ScriptExecutionContext.h" +#include <runtime/Error.h> + +using namespace JSC; + +namespace WebCore { + +ASSERT_CLASS_FITS_IN_CELL(JSEventSourceConstructor); + +const ClassInfo JSEventSourceConstructor::s_info = { "EventSourceContructor", 0, 0, 0 }; + +JSEventSourceConstructor::JSEventSourceConstructor(ExecState* exec, JSDOMGlobalObject* globalObject) + : DOMConstructorObject(JSEventSourceConstructor::createStructure(globalObject->objectPrototype()), globalObject) +{ + putDirect(exec->propertyNames().prototype, JSEventSourcePrototype::self(exec, globalObject), None); + putDirect(exec->propertyNames().length, jsNumber(exec, 1), ReadOnly|DontDelete|DontEnum); +} + +static JSObject* constructEventSource(ExecState* exec, JSObject* constructor, const ArgList& args) +{ + if (args.size() < 1) + return throwError(exec, SyntaxError, "Not enough arguments"); + + UString url = args.at(0).toString(exec); + if (exec->hadException()) + return 0; + + JSEventSourceConstructor* jsConstructor = static_cast<JSEventSourceConstructor*>(constructor); + ScriptExecutionContext* context = jsConstructor->scriptExecutionContext(); + if (!context) + return throwError(exec, ReferenceError, "EventSource constructor associated document is unavailable"); + + ExceptionCode ec = 0; + RefPtr<EventSource> eventSource = EventSource::create(url, context, ec); + if (ec) { + setDOMException(exec, ec); + return 0; + } + + return asObject(toJS(exec, jsConstructor->globalObject(), eventSource.release())); +} + +ConstructType JSEventSourceConstructor::getConstructData(ConstructData& constructData) +{ + constructData.native.function = constructEventSource; + return ConstructTypeHost; +} + +} // namespace WebCore + +#endif // ENABLE(EVENTSOURCE) diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSEventSourceConstructor.h b/src/3rdparty/webkit/WebCore/bindings/js/JSEventSourceConstructor.h new file mode 100644 index 000000000..b2f3cb525 --- /dev/null +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSEventSourceConstructor.h @@ -0,0 +1,55 @@ +/* + * Copyright (C) 2009 Ericsson AB + * 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. + * 3. Neither the name of Ericsson nor the names of its contributors + * may be used to endorse or promote products derived from this + * software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "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 THE COPYRIGHT + * OWNER 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. + */ + +#ifndef JSEventSourceConstructor_h +#define JSEventSourceConstructor_h + +#if ENABLE(EVENTSOURCE) + +#include "JSDOMBinding.h" + +namespace WebCore { + + class JSEventSourceConstructor : public DOMConstructorObject { + public: + JSEventSourceConstructor(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 // ENABLE(EVENTSOURCE) + +#endif // JSEventSourceConstructor_h diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSEventSourceCustom.cpp b/src/3rdparty/webkit/WebCore/bindings/js/JSEventSourceCustom.cpp new file mode 100644 index 000000000..8f0dfb10a --- /dev/null +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSEventSourceCustom.cpp @@ -0,0 +1,68 @@ +/* + * Copyright (C) 2009 Ericsson AB + * 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. + * 3. Neither the name of Ericsson nor the names of its contributors + * may be used to endorse or promote products derived from this + * software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "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 THE COPYRIGHT + * OWNER 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(EVENTSOURCE) + +#include "JSEventSource.h" + +#include "EventSource.h" +#include "JSDOMGlobalObject.h" +#include "JSEventListener.h" + +using namespace JSC; + +namespace WebCore { + +JSValue JSEventSource::addEventListener(ExecState* exec, const ArgList& args) +{ + JSValue listener = args.at(1); + if (!listener.isObject()) + return jsUndefined(); + + impl()->addEventListener(args.at(0).toString(exec), JSEventListener::create(asObject(listener), false, currentWorld(exec)).get(), args.at(2).toBoolean(exec)); + return jsUndefined(); +} + +JSValue JSEventSource::removeEventListener(ExecState* exec, const ArgList& args) +{ + JSValue listener = args.at(1); + if (!listener.isObject()) + return jsUndefined(); + + impl()->removeEventListener(args.at(0).toString(exec), JSEventListener::create(asObject(listener), false, currentWorld(exec)).get(), args.at(2).toBoolean(exec)); + return jsUndefined(); +} + +} // namespace WebCore + +#endif // ENABLE(EVENTSOURCE) diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSEventTarget.cpp b/src/3rdparty/webkit/WebCore/bindings/js/JSEventTarget.cpp index b75cccf6a..6ea11352d 100644 --- a/src/3rdparty/webkit/WebCore/bindings/js/JSEventTarget.cpp +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSEventTarget.cpp @@ -33,12 +33,29 @@ #include "JSEventListener.h" #include "JSMessagePort.h" #include "JSNode.h" +#if ENABLE(SHARED_WORKERS) + +#include "JSSharedWorker.h" +#include "JSSharedWorkerContext.h" +#endif + #include "JSXMLHttpRequest.h" #include "JSXMLHttpRequestUpload.h" #include "MessagePort.h" + +#if ENABLE(SHARED_WORKERS) +#include "SharedWorker.h" +#include "SharedWorkerContext.h" +#endif + #include "XMLHttpRequest.h" #include "XMLHttpRequestUpload.h" +#if ENABLE(EVENTSOURCE) +#include "EventSource.h" +#include "JSEventSource.h" +#endif + #if ENABLE(OFFLINE_WEB_APPLICATIONS) #include "DOMApplicationCache.h" #include "JSDOMApplicationCache.h" @@ -56,9 +73,14 @@ #include "Worker.h" #endif -#if ENABLE(SHARED_WORKERS) -#include "JSSharedWorker.h" -#include "SharedWorker.h" +#if ENABLE(NOTIFICATIONS) +#include "JSNotification.h" +#include "Notification.h" +#endif + +#if ENABLE(WEB_SOCKETS) +#include "JSWebSocket.h" +#include "WebSocket.h" #endif using namespace JSC; @@ -70,6 +92,11 @@ JSValue toJS(ExecState* exec, JSDOMGlobalObject* globalObject, EventTarget* targ if (!target) return jsNull(); +#if ENABLE(EVENTSOURCE) + if (EventSource* eventSource = target->toEventSource()) + return toJS(exec, globalObject, eventSource); +#endif + #if ENABLE(SVG) // SVGElementInstance supports both toSVGElementInstance and toNode since so much mouse handling code depends on toNode returning a valid node. if (SVGElementInstance* instance = target->toSVGElementInstance()) @@ -101,12 +128,25 @@ JSValue toJS(ExecState* exec, JSDOMGlobalObject* globalObject, EventTarget* targ return toJS(exec, globalObject, worker); if (DedicatedWorkerContext* workerContext = target->toDedicatedWorkerContext()) - return toJSDOMGlobalObject(workerContext); + return toJSDOMGlobalObject(workerContext, exec); #endif #if ENABLE(SHARED_WORKERS) if (SharedWorker* sharedWorker = target->toSharedWorker()) return toJS(exec, globalObject, sharedWorker); + + if (SharedWorkerContext* workerContext = target->toSharedWorkerContext()) + return toJSDOMGlobalObject(workerContext, exec); +#endif + +#if ENABLE(NOTIFICATIONS) + if (Notification* notification = target->toNotification()) + return toJS(exec, notification); +#endif + +#if ENABLE(WEB_SOCKETS) + if (WebSocket* webSocket = target->toWebSocket()) + return toJS(exec, webSocket); #endif ASSERT_NOT_REACHED(); @@ -116,7 +156,7 @@ JSValue toJS(ExecState* exec, JSDOMGlobalObject* globalObject, EventTarget* targ EventTarget* toEventTarget(JSC::JSValue value) { #define CONVERT_TO_EVENT_TARGET(type) \ - if (value.isObject(&JS##type::s_info)) \ + if (value.inherits(&JS##type::s_info)) \ return static_cast<JS##type*>(asObject(value))->impl(); CONVERT_TO_EVENT_TARGET(Node) @@ -124,9 +164,13 @@ EventTarget* toEventTarget(JSC::JSValue value) CONVERT_TO_EVENT_TARGET(XMLHttpRequestUpload) CONVERT_TO_EVENT_TARGET(MessagePort) - if (value.isObject(&JSDOMWindowShell::s_info)) + if (value.inherits(&JSDOMWindowShell::s_info)) return static_cast<JSDOMWindowShell*>(asObject(value))->impl(); +#if ENABLE(EVENTSOURCE) + CONVERT_TO_EVENT_TARGET(EventSource) +#endif + #if ENABLE(OFFLINE_WEB_APPLICATIONS) CONVERT_TO_EVENT_TARGET(DOMApplicationCache) #endif @@ -142,6 +186,15 @@ EventTarget* toEventTarget(JSC::JSValue value) #if ENABLE(SHARED_WORKERS) CONVERT_TO_EVENT_TARGET(SharedWorker) + CONVERT_TO_EVENT_TARGET(SharedWorkerContext) +#endif + +#if ENABLE(NOTIFICATIONS) + CONVERT_TO_EVENT_TARGET(Notification) +#endif + +#if ENABLE(WEB_SOCKETS) + CONVERT_TO_EVENT_TARGET(WebSocket) #endif return 0; diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSExceptionBase.cpp b/src/3rdparty/webkit/WebCore/bindings/js/JSExceptionBase.cpp new file mode 100644 index 000000000..a588ab1b1 --- /dev/null +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSExceptionBase.cpp @@ -0,0 +1,64 @@ +/* + * 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 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 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" +#include "JSExceptionBase.h" + +#include "JSDOMCoreException.h" +#include "JSEventException.h" +#include "JSRangeException.h" +#include "JSXMLHttpRequestException.h" +#if ENABLE(SVG) +#include "JSSVGException.h" +#endif +#if ENABLE(XPATH) +#include "JSXPathException.h" +#endif + +namespace WebCore { + +ExceptionBase* toExceptionBase(JSC::JSValue value) +{ + if (DOMCoreException* domException = toDOMCoreException(value)) + return reinterpret_cast<ExceptionBase*>(domException); + if (RangeException* rangeException = toRangeException(value)) + return reinterpret_cast<ExceptionBase*>(rangeException); + if (EventException* eventException = toEventException(value)) + return reinterpret_cast<ExceptionBase*>(eventException); + if (XMLHttpRequestException* xmlHttpException = toXMLHttpRequestException(value)) + return reinterpret_cast<ExceptionBase*>(xmlHttpException); +#if ENABLE(SVG) + if (SVGException* svgException = toSVGException(value)) + return reinterpret_cast<ExceptionBase*>(svgException); +#endif +#if ENABLE(XPATH) + if (XPathException* pathException = toXPathException(value)) + return reinterpret_cast<ExceptionBase*>(pathException); +#endif + + return 0; +} + +} // namespace WebCore diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSExceptionBase.h b/src/3rdparty/webkit/WebCore/bindings/js/JSExceptionBase.h new file mode 100644 index 000000000..a9366ed70 --- /dev/null +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSExceptionBase.h @@ -0,0 +1,43 @@ +/* + * 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 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 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. + */ + +#ifndef JSExceptionBase_h +#define JSExceptionBase_h + +namespace JSC { + +class JSValue; + +} // namespace JSC + +namespace WebCore { + +class ExceptionBase; + +ExceptionBase* toExceptionBase(JSC::JSValue); + +} // namespace WebCore + +#endif // JSExceptionBase_h diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSGeolocationCustom.cpp b/src/3rdparty/webkit/WebCore/bindings/js/JSGeolocationCustom.cpp index 493166c05..530b89bc6 100644 --- a/src/3rdparty/webkit/WebCore/bindings/js/JSGeolocationCustom.cpp +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSGeolocationCustom.cpp @@ -20,7 +20,7 @@ * 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. + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ #include "config.h" @@ -34,114 +34,144 @@ #include "JSCustomPositionErrorCallback.h" #include "JSDOMWindow.h" #include "PositionOptions.h" +#include <runtime/InternalFunction.h> using namespace JSC; +using namespace std; namespace WebCore { -static PassRefPtr<PositionOptions> createPositionOptions(ExecState* exec, JSValue value) +static PassRefPtr<PositionCallback> createPositionCallback(ExecState* exec, JSDOMGlobalObject* globalObject, JSValue value) { - if (!value.isObject()) + // The spec specifies 'FunctionOnly' for this object. + if (!value.inherits(&InternalFunction::info)) { + setDOMException(exec, TYPE_MISMATCH_ERR); return 0; + } JSObject* object = asObject(value); + return JSCustomPositionCallback::create(object, globalObject); +} - JSValue enableHighAccuracyValue = object->get(exec, Identifier(exec, "enableHighAccuracy")); - if (exec->hadException()) +static PassRefPtr<PositionErrorCallback> createPositionErrorCallback(ExecState* exec, JSDOMGlobalObject* globalObject, JSValue value) +{ + // Argument is optional (hence undefined is allowed), and null is allowed. + if (value.isUndefinedOrNull()) return 0; - bool enableHighAccuracy = enableHighAccuracyValue.toBoolean(exec); - if (exec->hadException()) + + // The spec specifies 'FunctionOnly' for this object. + if (!value.inherits(&InternalFunction::info)) { + setDOMException(exec, TYPE_MISMATCH_ERR); return 0; + } - JSValue timeoutValue = object->get(exec, Identifier(exec, "timeout")); + JSObject* object = asObject(value); + return JSCustomPositionErrorCallback::create(object, globalObject); +} + +static PassRefPtr<PositionOptions> createPositionOptions(ExecState* exec, JSValue value) +{ + // Create default options. + RefPtr<PositionOptions> options = PositionOptions::create(); + + // Argument is optional (hence undefined is allowed), and null is allowed. + if (value.isUndefinedOrNull()) { + // Use default options. + return options.release(); + } + + // Given the above test, this will always yield an object. + JSObject* object = value.toObject(exec); + + // For all three properties, we apply the following ... + // - If the getter or the property's valueOf method throws an exception, we + // quit so as not to risk overwriting the exception. + // - If the value is absent or undefined, we don't override the default. + JSValue enableHighAccuracyValue = object->get(exec, Identifier(exec, "enableHighAccuracy")); if (exec->hadException()) return 0; - unsigned timeout = timeoutValue.toUInt32(exec); + if (!enableHighAccuracyValue.isUndefined()) { + options->setEnableHighAccuracy(enableHighAccuracyValue.toBoolean(exec)); + if (exec->hadException()) + return 0; + } + + JSValue timeoutValue = object->get(exec, Identifier(exec, "timeout")); if (exec->hadException()) return 0; + if (!timeoutValue.isUndefined()) { + double timeoutNumber = timeoutValue.toNumber(exec); + if (exec->hadException()) + return 0; + // If the value is positive infinity, there's nothing to do. + if (!(isinf(timeoutNumber) && (timeoutNumber > 0))) { + // Wrap to int32 and force non-negative to match behavior of window.setTimeout. + options->setTimeout(max(0, timeoutValue.toInt32(exec))); + if (exec->hadException()) + return 0; + } + } JSValue maximumAgeValue = object->get(exec, Identifier(exec, "maximumAge")); if (exec->hadException()) return 0; - unsigned maximumAge = maximumAgeValue.toUInt32(exec); - if (exec->hadException()) - return 0; + if (!maximumAgeValue.isUndefined()) { + double maximumAgeNumber = maximumAgeValue.toNumber(exec); + if (exec->hadException()) + return 0; + if (isinf(maximumAgeNumber) && (maximumAgeNumber > 0)) { + // If the value is positive infinity, clear maximumAge. + options->clearMaximumAge(); + } else { + // Wrap to int32 and force non-negative to match behavior of window.setTimeout. + options->setMaximumAge(max(0, maximumAgeValue.toInt32(exec))); + if (exec->hadException()) + return 0; + } + } - return PositionOptions::create(enableHighAccuracy, timeout, maximumAge); + return options.release(); } JSValue JSGeolocation::getCurrentPosition(ExecState* exec, const ArgList& args) { // Arguments: PositionCallback, (optional)PositionErrorCallback, (optional)PositionOptions - RefPtr<PositionCallback> positionCallback; - JSObject* object = args.at(0).getObject(); + + RefPtr<PositionCallback> positionCallback = createPositionCallback(exec, static_cast<JSDOMGlobalObject*>(exec->lexicalGlobalObject()), args.at(0)); if (exec->hadException()) return jsUndefined(); - if (!object) { - setDOMException(exec, TYPE_MISMATCH_ERR); - return jsUndefined(); - } + ASSERT(positionCallback); - if (Frame* frame = toJSDOMWindow(exec->lexicalGlobalObject())->impl()->frame()) - positionCallback = JSCustomPositionCallback::create(object, frame); - - RefPtr<PositionErrorCallback> positionErrorCallback; - if (!args.at(1).isUndefinedOrNull()) { - JSObject* object = args.at(1).getObject(); - if (!object) { - setDOMException(exec, TYPE_MISMATCH_ERR); - return jsUndefined(); - } + RefPtr<PositionErrorCallback> positionErrorCallback = createPositionErrorCallback(exec, static_cast<JSDOMGlobalObject*>(exec->lexicalGlobalObject()), args.at(1)); + if (exec->hadException()) + return jsUndefined(); - if (Frame* frame = toJSDOMWindow(exec->lexicalGlobalObject())->impl()->frame()) - positionErrorCallback = JSCustomPositionErrorCallback::create(object, frame); - } - - RefPtr<PositionOptions> positionOptions; - if (!args.at(2).isUndefinedOrNull()) { - positionOptions = createPositionOptions(exec, args.at(2)); - if (exec->hadException()) - return jsUndefined(); - } + RefPtr<PositionOptions> positionOptions = createPositionOptions(exec, args.at(2)); + if (exec->hadException()) + return jsUndefined(); + ASSERT(positionOptions); m_impl->getCurrentPosition(positionCallback.release(), positionErrorCallback.release(), positionOptions.release()); - return jsUndefined(); } JSValue JSGeolocation::watchPosition(ExecState* exec, const ArgList& args) { // Arguments: PositionCallback, (optional)PositionErrorCallback, (optional)PositionOptions - RefPtr<PositionCallback> positionCallback; - JSObject* object = args.at(0).getObject(); + + RefPtr<PositionCallback> positionCallback = createPositionCallback(exec, static_cast<JSDOMGlobalObject*>(exec->lexicalGlobalObject()), args.at(0)); if (exec->hadException()) return jsUndefined(); - if (!object) { - setDOMException(exec, TYPE_MISMATCH_ERR); + ASSERT(positionCallback); + + RefPtr<PositionErrorCallback> positionErrorCallback = createPositionErrorCallback(exec, static_cast<JSDOMGlobalObject*>(exec->lexicalGlobalObject()), args.at(1)); + if (exec->hadException()) return jsUndefined(); - } - - if (Frame* frame = toJSDOMWindow(exec->lexicalGlobalObject())->impl()->frame()) - positionCallback = JSCustomPositionCallback::create(object, frame); - - RefPtr<PositionErrorCallback> positionErrorCallback; - if (!args.at(1).isUndefinedOrNull()) { - JSObject* object = args.at(1).getObject(); - if (!object) { - setDOMException(exec, TYPE_MISMATCH_ERR); - return jsUndefined(); - } - - if (Frame* frame = toJSDOMWindow(exec->lexicalGlobalObject())->impl()->frame()) - positionErrorCallback = JSCustomPositionErrorCallback::create(object, frame); - } - - RefPtr<PositionOptions> positionOptions; - if (!args.at(2).isUndefinedOrNull()) { - positionOptions = createPositionOptions(exec, args.at(2)); - if (exec->hadException()) - return jsUndefined(); - } + + RefPtr<PositionOptions> positionOptions = createPositionOptions(exec, args.at(2)); + if (exec->hadException()) + return jsUndefined(); + ASSERT(positionOptions); int watchID = m_impl->watchPosition(positionCallback.release(), positionErrorCallback.release(), positionOptions.release()); return jsNumber(exec, watchID); diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSHTMLAllCollectionCustom.cpp b/src/3rdparty/webkit/WebCore/bindings/js/JSHTMLAllCollectionCustom.cpp new file mode 100644 index 000000000..fd1dd11ee --- /dev/null +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSHTMLAllCollectionCustom.cpp @@ -0,0 +1,135 @@ +/* + * 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 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 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" +#include "JSHTMLAllCollection.h" + +#include "AtomicString.h" +#include "HTMLAllCollection.h" +#include "JSDOMBinding.h" +#include "JSHTMLAllCollection.h" +#include "JSNode.h" +#include "JSNodeList.h" +#include "Node.h" +#include "StaticNodeList.h" +#include <wtf/Vector.h> + +using namespace JSC; + +namespace WebCore { + +static JSValue getNamedItems(ExecState* exec, JSHTMLAllCollection* collection, const Identifier& propertyName) +{ + Vector<RefPtr<Node> > namedItems; + collection->impl()->namedItems(propertyName, namedItems); + + if (namedItems.isEmpty()) + return jsUndefined(); + if (namedItems.size() == 1) + return toJS(exec, collection->globalObject(), namedItems[0].get()); + + // FIXME: HTML5 specifies that this should be a DynamicNodeList. + // FIXME: HTML5 specifies that non-HTMLOptionsCollection collections should return + // the first matching item instead of a NodeList. + return toJS(exec, collection->globalObject(), StaticNodeList::adopt(namedItems).get()); +} + +// 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, JSObject* function, JSValue, const ArgList& args) +{ + if (args.size() < 1) + return jsUndefined(); + + // Do not use thisObj here. It can be the JSHTMLDocument, in the document.forms(i) case. + JSHTMLAllCollection* jsCollection = static_cast<JSHTMLAllCollection*>(function); + HTMLAllCollection* collection = static_cast<HTMLAllCollection*>(jsCollection->impl()); + + // Also, do we need the TypeError test here ? + + if (args.size() == 1) { + // Support for document.all(<index>) etc. + bool ok; + UString string = args.at(0).toString(exec); + unsigned index = string.toUInt32(&ok, false); + if (ok) + return toJS(exec, jsCollection->globalObject(), collection->item(index)); + + // Support for document.images('<name>') etc. + return getNamedItems(exec, jsCollection, Identifier(exec, string)); + } + + // The second arg, if set, is the index of the item we want + bool ok; + UString string = args.at(0).toString(exec); + unsigned index = args.at(1).toString(exec).toUInt32(&ok, false); + if (ok) { + String pstr = string; + Node* node = collection->namedItem(pstr); + while (node) { + if (!index) + return toJS(exec, jsCollection->globalObject(), node); + node = collection->nextNamedItem(pstr); + --index; + } + } + + return jsUndefined(); +} + +CallType JSHTMLAllCollection::getCallData(CallData& callData) +{ + callData.native.function = callHTMLAllCollection; + return CallTypeHost; +} + +bool JSHTMLAllCollection::canGetItemsForName(ExecState*, HTMLAllCollection* collection, const Identifier& propertyName) +{ + Vector<RefPtr<Node> > namedItems; + collection->namedItems(propertyName, namedItems); + return !namedItems.isEmpty(); +} + +JSValue JSHTMLAllCollection::nameGetter(ExecState* exec, const Identifier& propertyName, const PropertySlot& slot) +{ + JSHTMLAllCollection* thisObj = static_cast<JSHTMLAllCollection*>(asObject(slot.slotBase())); + return getNamedItems(exec, thisObj, propertyName); +} + +JSValue JSHTMLAllCollection::item(ExecState* exec, const ArgList& args) +{ + bool ok; + uint32_t index = args.at(0).toString(exec).toUInt32(&ok, false); + if (ok) + return toJS(exec, globalObject(), impl()->item(index)); + return getNamedItems(exec, this, Identifier(exec, args.at(0).toString(exec))); +} + +JSValue JSHTMLAllCollection::namedItem(ExecState* exec, const ArgList& args) +{ + return getNamedItems(exec, this, Identifier(exec, args.at(0).toString(exec))); +} + +} // namespace WebCore diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSHTMLAppletElementCustom.cpp b/src/3rdparty/webkit/WebCore/bindings/js/JSHTMLAppletElementCustom.cpp index 37561afbf..30892e0c6 100644 --- a/src/3rdparty/webkit/WebCore/bindings/js/JSHTMLAppletElementCustom.cpp +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSHTMLAppletElementCustom.cpp @@ -38,6 +38,11 @@ bool JSHTMLAppletElement::getOwnPropertySlotDelegate(ExecState* exec, const Iden return runtimeObjectCustomGetOwnPropertySlot(exec, propertyName, slot, this); } +bool JSHTMLAppletElement::getOwnPropertyDescriptorDelegate(ExecState* exec, const Identifier& propertyName, PropertyDescriptor& descriptor) +{ + return runtimeObjectCustomGetOwnPropertyDescriptor(exec, propertyName, descriptor, this); +} + bool JSHTMLAppletElement::putDelegate(ExecState* exec, const Identifier& propertyName, JSValue value, PutPropertySlot& slot) { return runtimeObjectCustomPut(exec, propertyName, value, impl(), slot); diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSHTMLCanvasElementCustom.cpp b/src/3rdparty/webkit/WebCore/bindings/js/JSHTMLCanvasElementCustom.cpp new file mode 100644 index 000000000..8ecd28741 --- /dev/null +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSHTMLCanvasElementCustom.cpp @@ -0,0 +1,50 @@ +/* + * Copyright (C) 2007 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" +#include "JSHTMLCanvasElement.h" + +#include "HTMLCanvasElement.h" +#include "JSCanvasRenderingContext2D.h" +#if ENABLE(3D_CANVAS) +#include "JSCanvasRenderingContext3D.h" +#endif +#include <wtf/GetPtr.h> + +using namespace JSC; + +namespace WebCore { + +void JSHTMLCanvasElement::markChildren(MarkStack& markStack) +{ + Base::markChildren(markStack); + + HTMLCanvasElement* canvas = static_cast<HTMLCanvasElement*>(impl()); + JSGlobalData& globalData = *Heap::heap(this)->globalData(); + + markDOMObjectWrapper(markStack, globalData, canvas->renderingContext()); +} + +} // namespace WebCore diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSHTMLCollectionCustom.cpp b/src/3rdparty/webkit/WebCore/bindings/js/JSHTMLCollectionCustom.cpp index dd9af749b..dd4ceaa69 100644 --- a/src/3rdparty/webkit/WebCore/bindings/js/JSHTMLCollectionCustom.cpp +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSHTMLCollectionCustom.cpp @@ -23,12 +23,14 @@ #include "AtomicString.h" #include "HTMLCollection.h" #include "HTMLOptionsCollection.h" +#include "HTMLAllCollection.h" +#include "JSDOMBinding.h" #include "JSHTMLAllCollection.h" #include "JSHTMLOptionsCollection.h" -#include "JSNamedNodesCollection.h" #include "JSNode.h" +#include "JSNodeList.h" #include "Node.h" -#include "JSDOMBinding.h" +#include "StaticNodeList.h" #include <wtf/Vector.h> using namespace JSC; @@ -42,11 +44,13 @@ static JSValue getNamedItems(ExecState* exec, JSHTMLCollection* collection, cons if (namedItems.isEmpty()) return jsUndefined(); - if (namedItems.size() == 1) return toJS(exec, collection->globalObject(), namedItems[0].get()); - return new (exec) JSNamedNodesCollection(exec, collection->globalObject(), namedItems); + // FIXME: HTML5 specifies that this should be a DynamicNodeList. + // FIXME: HTML5 specifies that non-HTMLOptionsCollection collections should return + // the first matching item instead of a NodeList. + return toJS(exec, collection->globalObject(), StaticNodeList::adopt(namedItems).get()); } // HTMLCollections are strange objects, they support both get and call, @@ -140,7 +144,6 @@ JSValue toJS(ExecState* exec, JSDOMGlobalObject* globalObject, HTMLCollection* c wrapper = CREATE_DOM_OBJECT_WRAPPER(exec, globalObject, HTMLOptionsCollection, collection); break; case DocAll: - typedef HTMLCollection HTMLAllCollection; wrapper = CREATE_DOM_OBJECT_WRAPPER(exec, globalObject, HTMLAllCollection, collection); break; default: diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSHTMLDocumentCustom.cpp b/src/3rdparty/webkit/WebCore/bindings/js/JSHTMLDocumentCustom.cpp index c113ec77d..a65ca7cfb 100644 --- a/src/3rdparty/webkit/WebCore/bindings/js/JSHTMLDocumentCustom.cpp +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSHTMLDocumentCustom.cpp @@ -28,6 +28,7 @@ #include "CharacterNames.h" #include "Frame.h" +#include "HTMLAllCollection.h" #include "HTMLBodyElement.h" #include "HTMLCollection.h" #include "HTMLDocument.h" @@ -105,14 +106,14 @@ JSValue JSHTMLDocument::open(ExecState* exec, const ArgList& args) if (args.size() > 2) { Frame* frame = static_cast<HTMLDocument*>(impl())->frame(); if (frame) { - JSDOMWindowShell* wrapper = toJSDOMWindowShell(frame); + JSDOMWindowShell* wrapper = toJSDOMWindowShell(frame, currentWorld(exec)); if (wrapper) { JSValue function = wrapper->get(exec, Identifier(exec, "open")); CallData callData; CallType callType = function.getCallData(callData); if (callType == CallTypeNone) return throwError(exec, TypeError); - return call(exec, function, callType, callData, wrapper, args); + return callInWorld(exec, function, callType, callData, wrapper, args, currentWorld(exec)); } } return jsUndefined(); diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSHTMLEmbedElementCustom.cpp b/src/3rdparty/webkit/WebCore/bindings/js/JSHTMLEmbedElementCustom.cpp index 2570bc60d..bce3ffb6a 100644 --- a/src/3rdparty/webkit/WebCore/bindings/js/JSHTMLEmbedElementCustom.cpp +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSHTMLEmbedElementCustom.cpp @@ -38,6 +38,11 @@ bool JSHTMLEmbedElement::getOwnPropertySlotDelegate(ExecState* exec, const Ident return runtimeObjectCustomGetOwnPropertySlot(exec, propertyName, slot, this); } +bool JSHTMLEmbedElement::getOwnPropertyDescriptorDelegate(ExecState* exec, const Identifier& propertyName, PropertyDescriptor& descriptor) +{ + return runtimeObjectCustomGetOwnPropertyDescriptor(exec, propertyName, descriptor, this); +} + bool JSHTMLEmbedElement::putDelegate(ExecState* exec, const Identifier& propertyName, JSValue value, PutPropertySlot& slot) { return runtimeObjectCustomPut(exec, propertyName, value, impl(), slot); diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSHTMLFormElementCustom.cpp b/src/3rdparty/webkit/WebCore/bindings/js/JSHTMLFormElementCustom.cpp index ffa2d5779..de9ec4ac9 100644 --- a/src/3rdparty/webkit/WebCore/bindings/js/JSHTMLFormElementCustom.cpp +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSHTMLFormElementCustom.cpp @@ -30,7 +30,8 @@ #include "HTMLCollection.h" #include "HTMLFormElement.h" #include "JSDOMWindowCustom.h" -#include "JSNamedNodesCollection.h" +#include "JSNodeList.h" +#include "StaticNodeList.h" using namespace JSC; @@ -47,15 +48,17 @@ JSValue JSHTMLFormElement::nameGetter(ExecState* exec, const Identifier& propert { JSHTMLElement* jsForm = static_cast<JSHTMLFormElement*>(asObject(slot.slotBase())); HTMLFormElement* form = static_cast<HTMLFormElement*>(jsForm->impl()); - + Vector<RefPtr<Node> > namedItems; form->getNamedElements(propertyName, namedItems); + if (namedItems.isEmpty()) + return jsUndefined(); if (namedItems.size() == 1) return toJS(exec, namedItems[0].get()); - if (namedItems.size() > 1) - return new (exec) JSNamedNodesCollection(exec, jsForm->globalObject(), namedItems); - return jsUndefined(); + + // FIXME: HTML5 specifies that this should be a RadioNodeList. + return toJS(exec, jsForm->globalObject(), StaticNodeList::adopt(namedItems).get()); } JSValue JSHTMLFormElement::submit(ExecState* exec, const ArgList&) diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSHTMLFrameElementCustom.cpp b/src/3rdparty/webkit/WebCore/bindings/js/JSHTMLFrameElementCustom.cpp index c8aea9fea..6e0151396 100644 --- a/src/3rdparty/webkit/WebCore/bindings/js/JSHTMLFrameElementCustom.cpp +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSHTMLFrameElementCustom.cpp @@ -32,16 +32,20 @@ #include "CSSHelper.h" #include "Document.h" #include "HTMLFrameElement.h" +#include "HTMLNames.h" #include "JSDOMBinding.h" using namespace JSC; namespace WebCore { +using namespace HTMLNames; + static inline bool allowSettingJavascriptURL(ExecState* exec, HTMLFrameElement* imp, const String& value) { if (protocolIsJavaScript(deprecatedParseURL(value))) { - if (!checkNodeSecurity(exec, imp->contentDocument())) + Document* contentDocument = imp->contentDocument(); + if (contentDocument && !checkNodeSecurity(exec, contentDocument)) return false; } return true; @@ -55,8 +59,7 @@ void JSHTMLFrameElement::setSrc(ExecState* exec, JSValue value) if (!allowSettingJavascriptURL(exec, imp, srcValue)) return; - imp->setSrc(srcValue); - return; + imp->setAttribute(srcAttr, srcValue); } void JSHTMLFrameElement::setLocation(ExecState* exec, JSValue value) @@ -68,7 +71,6 @@ void JSHTMLFrameElement::setLocation(ExecState* exec, JSValue value) return; imp->setLocation(locationValue); - return; } } // namespace WebCore diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSHTMLFrameSetElementCustom.cpp b/src/3rdparty/webkit/WebCore/bindings/js/JSHTMLFrameSetElementCustom.cpp index 05972e6fb..68769d6ac 100644 --- a/src/3rdparty/webkit/WebCore/bindings/js/JSHTMLFrameSetElementCustom.cpp +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSHTMLFrameSetElementCustom.cpp @@ -47,14 +47,14 @@ bool JSHTMLFrameSetElement::canGetItemsForName(ExecState*, HTMLFrameSetElement* return frame && frame->hasTagName(frameTag); } -JSValue JSHTMLFrameSetElement::nameGetter(ExecState*, const Identifier& propertyName, const PropertySlot& slot) +JSValue JSHTMLFrameSetElement::nameGetter(ExecState* exec, const Identifier& propertyName, const PropertySlot& slot) { JSHTMLElement* thisObj = static_cast<JSHTMLElement*>(asObject(slot.slotBase())); HTMLElement* element = static_cast<HTMLElement*>(thisObj->impl()); Node* frame = element->children()->namedItem(propertyName); if (Document* doc = static_cast<HTMLFrameElement*>(frame)->contentDocument()) { - if (JSDOMWindowShell* window = toJSDOMWindowShell(doc->frame())) + if (JSDOMWindowShell* window = toJSDOMWindowShell(doc->frame(), currentWorld(exec))) return window; } diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSHTMLIFrameElementCustom.cpp b/src/3rdparty/webkit/WebCore/bindings/js/JSHTMLIFrameElementCustom.cpp index 8e32381bc..60ea45e59 100644 --- a/src/3rdparty/webkit/WebCore/bindings/js/JSHTMLIFrameElementCustom.cpp +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSHTMLIFrameElementCustom.cpp @@ -32,12 +32,15 @@ #include "CSSHelper.h" #include "Document.h" #include "HTMLIFrameElement.h" +#include "HTMLNames.h" #include "JSDOMBinding.h" using namespace JSC; namespace WebCore { +using namespace HTMLNames; + void JSHTMLIFrameElement::setSrc(ExecState* exec, JSValue value) { HTMLIFrameElement* imp = static_cast<HTMLIFrameElement*>(impl()); @@ -45,11 +48,12 @@ void JSHTMLIFrameElement::setSrc(ExecState* exec, JSValue value) String srcValue = valueToStringWithNullCheck(exec, value); if (protocolIsJavaScript(deprecatedParseURL(srcValue))) { - if (!checkNodeSecurity(exec, imp->contentDocument())) + Document* contentDocument = imp->contentDocument(); + if (contentDocument && !checkNodeSecurity(exec, contentDocument)) return; } - imp->setSrc(srcValue); + imp->setAttribute(srcAttr, srcValue); } } // namespace WebCore diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSHTMLInputElementCustom.cpp b/src/3rdparty/webkit/WebCore/bindings/js/JSHTMLInputElementCustom.cpp index 6b4762216..e5166eec1 100644 --- a/src/3rdparty/webkit/WebCore/bindings/js/JSHTMLInputElementCustom.cpp +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSHTMLInputElementCustom.cpp @@ -29,6 +29,7 @@ #include "Document.h" #include "HTMLInputElement.h" #include "Settings.h" +#include <runtime/Error.h> using namespace JSC; diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSHTMLObjectElementCustom.cpp b/src/3rdparty/webkit/WebCore/bindings/js/JSHTMLObjectElementCustom.cpp index a99e46c7c..1bfb51f0a 100644 --- a/src/3rdparty/webkit/WebCore/bindings/js/JSHTMLObjectElementCustom.cpp +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSHTMLObjectElementCustom.cpp @@ -38,6 +38,11 @@ bool JSHTMLObjectElement::getOwnPropertySlotDelegate(ExecState* exec, const Iden return runtimeObjectCustomGetOwnPropertySlot(exec, propertyName, slot, this); } +bool JSHTMLObjectElement::getOwnPropertyDescriptorDelegate(ExecState* exec, const Identifier& propertyName, PropertyDescriptor& descriptor) +{ + return runtimeObjectCustomGetOwnPropertyDescriptor(exec, propertyName, descriptor, this); +} + bool JSHTMLObjectElement::putDelegate(ExecState* exec, const Identifier& propertyName, JSValue value, PutPropertySlot& slot) { return runtimeObjectCustomPut(exec, propertyName, value, impl(), slot); diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSHistoryCustom.cpp b/src/3rdparty/webkit/WebCore/bindings/js/JSHistoryCustom.cpp index a3b15e171..b24b1ffed 100644 --- a/src/3rdparty/webkit/WebCore/bindings/js/JSHistoryCustom.cpp +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSHistoryCustom.cpp @@ -31,6 +31,7 @@ #include "Frame.h" #include "History.h" +#include <runtime/JSFunction.h> #include <runtime/PrototypeFunction.h> using namespace JSC; @@ -92,6 +93,52 @@ bool JSHistory::getOwnPropertySlotDelegate(ExecState* exec, const Identifier& pr return true; } +bool JSHistory::getOwnPropertyDescriptorDelegate(ExecState* exec, const Identifier& propertyName, PropertyDescriptor& descriptor) +{ + // When accessing History cross-domain, functions are always the native built-in ones. + // See JSDOMWindow::getOwnPropertySlotDelegate for additional details. + + // Our custom code is only needed to implement the Window cross-domain scheme, so if access is + // allowed, return false so the normal lookup will take place. + String message; + if (allowsAccessFromFrame(exec, impl()->frame(), message)) + return false; + + // Check for the few functions that we allow, even when called cross-domain. + const HashEntry* entry = JSHistoryPrototype::s_info.propHashTable(exec)->entry(exec, propertyName); + if (entry) { + PropertySlot slot; + // Allow access to back(), forward() and go() from any frame. + if (entry->attributes() & Function) { + if (entry->function() == jsHistoryPrototypeFunctionBack) { + slot.setCustom(this, nonCachingStaticBackFunctionGetter); + descriptor.setDescriptor(slot.getValue(exec, propertyName), entry->attributes()); + return true; + } else if (entry->function() == jsHistoryPrototypeFunctionForward) { + slot.setCustom(this, nonCachingStaticForwardFunctionGetter); + descriptor.setDescriptor(slot.getValue(exec, propertyName), entry->attributes()); + return true; + } else if (entry->function() == jsHistoryPrototypeFunctionGo) { + slot.setCustom(this, nonCachingStaticGoFunctionGetter); + descriptor.setDescriptor(slot.getValue(exec, propertyName), entry->attributes()); + return true; + } + } + } else { + // Allow access to toString() cross-domain, but always Object.toString. + if (propertyName == exec->propertyNames().toString) { + PropertySlot slot; + slot.setCustom(this, objectToStringFunctionGetter); + descriptor.setDescriptor(slot.getValue(exec, propertyName), entry->attributes()); + return true; + } + } + + printErrorMessageForFrame(impl()->frame(), message); + descriptor.setUndefined(); + return true; +} + bool JSHistory::putDelegate(ExecState* exec, const Identifier&, JSValue, PutPropertySlot&) { // Only allow putting by frames in the same origin. @@ -108,12 +155,12 @@ bool JSHistory::deleteProperty(ExecState* exec, const Identifier& propertyName) return Base::deleteProperty(exec, propertyName); } -void JSHistory::getPropertyNames(ExecState* exec, PropertyNameArray& propertyNames) +void JSHistory::getOwnPropertyNames(ExecState* exec, PropertyNameArray& propertyNames) { // Only allow the history object to enumerated by frames in the same origin. if (!allowsAccessFromFrame(exec, impl()->frame())) return; - Base::getPropertyNames(exec, propertyNames); + Base::getOwnPropertyNames(exec, propertyNames); } } // namespace WebCore diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSImageConstructor.cpp b/src/3rdparty/webkit/WebCore/bindings/js/JSImageConstructor.cpp index faaaf41ed..0f4a99196 100644 --- a/src/3rdparty/webkit/WebCore/bindings/js/JSImageConstructor.cpp +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSImageConstructor.cpp @@ -25,6 +25,7 @@ #include "JSHTMLImageElement.h" #include "JSNode.h" #include "ScriptExecutionContext.h" +#include <runtime/Error.h> using namespace JSC; diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSInspectedObjectWrapper.cpp b/src/3rdparty/webkit/WebCore/bindings/js/JSInspectedObjectWrapper.cpp index fff7aee27..ed79427b6 100644 --- a/src/3rdparty/webkit/WebCore/bindings/js/JSInspectedObjectWrapper.cpp +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSInspectedObjectWrapper.cpp @@ -26,6 +26,8 @@ #include "config.h" #include "JSInspectedObjectWrapper.h" +#if ENABLE(INSPECTOR) + #include "JSInspectorCallbackWrapper.h" #include <runtime/JSGlobalObject.h> #include <wtf/StdLibExtras.h> @@ -69,7 +71,7 @@ JSValue JSInspectedObjectWrapper::wrap(ExecState* unwrappedExec, JSValue unwrapp return new (unwrappedExec) JSInspectedObjectWrapper(unwrappedExec, unwrappedObject, JSQuarantinedObjectWrapper::createStructure(asObject(wrap(unwrappedExec, prototype)))); } -JSInspectedObjectWrapper::JSInspectedObjectWrapper(ExecState* unwrappedExec, JSObject* unwrappedObject, PassRefPtr<Structure> structure) +JSInspectedObjectWrapper::JSInspectedObjectWrapper(ExecState* unwrappedExec, JSObject* unwrappedObject, NonNullPassRefPtr<Structure> structure) : JSQuarantinedObjectWrapper(unwrappedExec, unwrappedObject, structure) { WrapperMap* wrapperMap = wrappers().get(unwrappedGlobalObject()); @@ -125,3 +127,5 @@ JSValue JSInspectedObjectWrapper::prepareIncomingValue(ExecState*, JSValue value } } // namespace WebCore + +#endif // ENABLE(INSPECTOR) diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSInspectedObjectWrapper.h b/src/3rdparty/webkit/WebCore/bindings/js/JSInspectedObjectWrapper.h index 201feb675..ad97035e5 100644 --- a/src/3rdparty/webkit/WebCore/bindings/js/JSInspectedObjectWrapper.h +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSInspectedObjectWrapper.h @@ -38,7 +38,7 @@ namespace WebCore { static const JSC::ClassInfo s_info; private: - JSInspectedObjectWrapper(JSC::ExecState* unwrappedExec, JSC::JSObject* unwrappedObject, PassRefPtr<JSC::Structure>); + JSInspectedObjectWrapper(JSC::ExecState* unwrappedExec, JSC::JSObject* unwrappedObject, NonNullPassRefPtr<JSC::Structure>); virtual bool allowsGetProperty() const { return true; } virtual bool allowsSetProperty() const { return true; } diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSInspectorBackendCustom.cpp b/src/3rdparty/webkit/WebCore/bindings/js/JSInspectorBackendCustom.cpp index b2eb2d17c..439f53282 100644 --- a/src/3rdparty/webkit/WebCore/bindings/js/JSInspectorBackendCustom.cpp +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSInspectorBackendCustom.cpp @@ -33,6 +33,8 @@ #include "config.h" #include "JSInspectorBackend.h" +#if ENABLE(INSPECTOR) + #include "Console.h" #if ENABLE(DATABASE) #include "Database.h" @@ -51,6 +53,10 @@ #include "JSRange.h" #include "Node.h" #include "Page.h" +#if ENABLE(DOM_STORAGE) +#include "Storage.h" +#include "JSStorage.h" +#endif #include "TextIterator.h" #include "VisiblePosition.h" #include <runtime/JSArray.h> @@ -60,31 +66,19 @@ #if ENABLE(JAVASCRIPT_DEBUGGER) #include "JavaScriptCallFrame.h" #include "JavaScriptDebugServer.h" -#include "JavaScriptProfile.h" #include "JSJavaScriptCallFrame.h" -#include <profiler/Profile.h> -#include <profiler/Profiler.h> #endif using namespace JSC; namespace WebCore { -JSValue JSInspectorBackend::highlightDOMNode(JSC::ExecState*, const JSC::ArgList& args) +JSValue JSInspectorBackend::highlightDOMNode(JSC::ExecState* exec, const JSC::ArgList& args) { if (args.size() < 1) return jsUndefined(); - JSQuarantinedObjectWrapper* wrapper = JSQuarantinedObjectWrapper::asWrapper(args.at(0)); - if (!wrapper) - return jsUndefined(); - - Node* node = toNode(wrapper->unwrappedObject()); - if (!node) - return jsUndefined(); - - impl()->highlight(node); - + impl()->highlight(args.at(0).toInt32(exec)); return jsUndefined(); } @@ -125,27 +119,21 @@ JSValue JSInspectorBackend::search(ExecState* exec, const ArgList& args) } #if ENABLE(DATABASE) -JSValue JSInspectorBackend::databaseTableNames(ExecState* exec, const ArgList& args) +JSValue JSInspectorBackend::databaseForId(ExecState* exec, const ArgList& args) { if (args.size() < 1) return jsUndefined(); - JSQuarantinedObjectWrapper* wrapper = JSQuarantinedObjectWrapper::asWrapper(args.at(0)); - if (!wrapper) + InspectorController* ic = impl()->inspectorController(); + if (!ic) return jsUndefined(); - Database* database = toDatabase(wrapper->unwrappedObject()); + Database* database = impl()->databaseForId(args.at(0).toInt32(exec)); if (!database) return jsUndefined(); - - MarkedArgumentBuffer result; - - Vector<String> tableNames = database->tableNames(); - unsigned length = tableNames.size(); - for (unsigned i = 0; i < length; ++i) - result.append(jsString(exec, tableNames[i])); - - return constructArray(exec, result); + // Could use currentWorld(exec) ... but which exec! The following mixed use of exec & inspectedWindow->globalExec() scares me! + JSDOMWindow* inspectedWindow = toJSDOMWindow(ic->inspectedPage()->mainFrame(), debuggerWorld()); + return JSInspectedObjectWrapper::wrap(inspectedWindow->globalExec(), toJS(exec, database)); } #endif @@ -154,7 +142,7 @@ JSValue JSInspectorBackend::inspectedWindow(ExecState*, const ArgList&) InspectorController* ic = impl()->inspectorController(); if (!ic) return jsUndefined(); - JSDOMWindow* inspectedWindow = toJSDOMWindow(ic->inspectedPage()->mainFrame()); + JSDOMWindow* inspectedWindow = toJSDOMWindow(ic->inspectedPage()->mainFrame(), debuggerWorld()); return JSInspectedObjectWrapper::wrap(inspectedWindow->globalExec(), inspectedWindow); } @@ -257,27 +245,102 @@ JSValue JSInspectorBackend::currentCallFrame(ExecState* exec, const ArgList&) return jsUndefined(); // FIXME: I am not sure if this is actually needed. Can we just use exec? - ExecState* globalExec = callFrame->scopeChain()->globalObject()->globalExec(); + ExecState* globalExec = callFrame->scopeChain()->globalObject->globalExec(); JSLock lock(SilenceAssertionsOnly); return JSInspectedObjectWrapper::wrap(globalExec, toJS(exec, callFrame)); } -JSValue JSInspectorBackend::profiles(JSC::ExecState* exec, const JSC::ArgList&) +#endif + +JSValue JSInspectorBackend::nodeForId(ExecState* exec, const ArgList& args) { - JSLock lock(SilenceAssertionsOnly); - MarkedArgumentBuffer result; + if (args.size() < 1) + return jsUndefined(); + + Node* node = impl()->nodeForId(args.at(0).toInt32(exec)); + if (!node) + return jsUndefined(); + InspectorController* ic = impl()->inspectorController(); if (!ic) return jsUndefined(); - const Vector<RefPtr<Profile> >& profiles = ic->profiles(); - for (size_t i = 0; i < profiles.size(); ++i) - result.append(toJS(exec, profiles[i].get())); + JSLock lock(SilenceAssertionsOnly); + JSDOMWindow* inspectedWindow = toJSDOMWindow(ic->inspectedPage()->mainFrame(), debuggerWorld()); + return JSInspectedObjectWrapper::wrap(inspectedWindow->globalExec(), toJS(exec, deprecatedGlobalObjectForPrototype(inspectedWindow->globalExec()), node)); +} - return constructArray(exec, result); +JSValue JSInspectorBackend::wrapObject(ExecState* exec, const ArgList& args) +{ + if (args.size() < 2) + return jsUndefined(); + + return impl()->wrapObject(ScriptValue(args.at(0)), args.at(1).toString(exec)).jsValue(); +} + +JSValue JSInspectorBackend::unwrapObject(ExecState* exec, const ArgList& args) +{ + if (args.size() < 1) + return jsUndefined(); + + return impl()->unwrapObject(args.at(0).toString(exec)).jsValue(); +} + +JSValue JSInspectorBackend::pushNodePathToFrontend(ExecState* exec, const ArgList& args) +{ + if (args.size() < 2) + return jsUndefined(); + + JSQuarantinedObjectWrapper* wrapper = JSQuarantinedObjectWrapper::asWrapper(args.at(0)); + if (!wrapper) + return jsUndefined(); + + Node* node = toNode(wrapper->unwrappedObject()); + if (!node) + return jsUndefined(); + + bool selectInUI = args.at(1).toBoolean(exec); + return jsNumber(exec, impl()->pushNodePathToFrontend(node, selectInUI)); } +#if ENABLE(DATABASE) +JSValue JSInspectorBackend::selectDatabase(ExecState*, const ArgList& args) +{ + if (args.size() < 1) + return jsUndefined(); + + JSQuarantinedObjectWrapper* wrapper = JSQuarantinedObjectWrapper::asWrapper(args.at(0)); + if (!wrapper) + return jsUndefined(); + + Database* database = toDatabase(wrapper->unwrappedObject()); + if (database) + impl()->selectDatabase(database); + return jsUndefined(); +} +#endif + +#if ENABLE(DOM_STORAGE) +JSValue JSInspectorBackend::selectDOMStorage(ExecState*, const ArgList& args) +{ + if (args.size() < 1) + return jsUndefined(); + InspectorController* ic = impl()->inspectorController(); + if (!ic) + return jsUndefined(); + + JSQuarantinedObjectWrapper* wrapper = JSQuarantinedObjectWrapper::asWrapper(args.at(0)); + if (!wrapper) + return jsUndefined(); + + Storage* storage = toStorage(wrapper->unwrappedObject()); + if (storage) + impl()->selectDOMStorage(storage); + return jsUndefined(); +} #endif } // namespace WebCore + +#endif // ENABLE(INSPECTOR) diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSInspectorCallbackWrapper.cpp b/src/3rdparty/webkit/WebCore/bindings/js/JSInspectorCallbackWrapper.cpp index 0e14109c0..9c4330d05 100644 --- a/src/3rdparty/webkit/WebCore/bindings/js/JSInspectorCallbackWrapper.cpp +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSInspectorCallbackWrapper.cpp @@ -26,6 +26,8 @@ #include "config.h" #include "JSInspectorCallbackWrapper.h" +#if ENABLE(INSPECTOR) + #include "JSInspectedObjectWrapper.h" #include <wtf/StdLibExtras.h> @@ -73,10 +75,10 @@ JSValue JSInspectorCallbackWrapper::wrap(ExecState* unwrappedExec, JSValue unwra static Structure* structure = leakInspectorCallbackWrapperStructure(); return new (unwrappedExec) JSInspectorCallbackWrapper(unwrappedExec, unwrappedObject, structure); } - return new (unwrappedExec) JSInspectorCallbackWrapper(unwrappedExec, unwrappedObject, asObject(wrap(unwrappedExec, prototype))->inheritorID()); + return new (unwrappedExec) JSInspectorCallbackWrapper(unwrappedExec, unwrappedObject, createStructure(wrap(unwrappedExec, prototype))); } -JSInspectorCallbackWrapper::JSInspectorCallbackWrapper(ExecState* unwrappedExec, JSObject* unwrappedObject, PassRefPtr<Structure> structure) +JSInspectorCallbackWrapper::JSInspectorCallbackWrapper(ExecState* unwrappedExec, JSObject* unwrappedObject, NonNullPassRefPtr<Structure> structure) : JSQuarantinedObjectWrapper(unwrappedExec, unwrappedObject, structure) { ASSERT(!wrappers().contains(unwrappedObject)); @@ -105,3 +107,5 @@ JSValue JSInspectorCallbackWrapper::prepareIncomingValue(ExecState* unwrappedExe } } // namespace WebCore + +#endif // ENABLE(INSPECTOR) diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSInspectorCallbackWrapper.h b/src/3rdparty/webkit/WebCore/bindings/js/JSInspectorCallbackWrapper.h index cfc2fb6ef..be280632f 100644 --- a/src/3rdparty/webkit/WebCore/bindings/js/JSInspectorCallbackWrapper.h +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSInspectorCallbackWrapper.h @@ -40,7 +40,7 @@ namespace WebCore { static const JSC::ClassInfo s_info; protected: - JSInspectorCallbackWrapper(JSC::ExecState* unwrappedExec, JSC::JSObject* unwrappedObject, PassRefPtr<JSC::Structure>); + JSInspectorCallbackWrapper(JSC::ExecState* unwrappedExec, JSC::JSObject* unwrappedObject, NonNullPassRefPtr<JSC::Structure>); virtual bool allowsCallAsFunction() const { return true; } diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSLazyEventListener.cpp b/src/3rdparty/webkit/WebCore/bindings/js/JSLazyEventListener.cpp index 7caff2b23..6d75f4fbb 100644 --- a/src/3rdparty/webkit/WebCore/bindings/js/JSLazyEventListener.cpp +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSLazyEventListener.cpp @@ -23,6 +23,7 @@ #include "Frame.h" #include "JSNode.h" #include <runtime/FunctionConstructor.h> +#include <runtime/JSFunction.h> #include <runtime/JSLock.h> #include <wtf/RefCountedLeakCounter.h> @@ -34,12 +35,13 @@ namespace WebCore { static WTF::RefCountedLeakCounter eventListenerCounter("JSLazyEventListener"); #endif -JSLazyEventListener::JSLazyEventListener(const String& functionName, const String& eventParameterName, const String& code, JSDOMGlobalObject* globalObject, Node* node, int lineNumber) - : JSEventListener(0, globalObject, true) +JSLazyEventListener::JSLazyEventListener(const String& functionName, const String& eventParameterName, const String& code, Node* node, const String& sourceURL, int lineNumber, DOMWrapperWorld* isolatedWorld) + : JSEventListener(0, true, isolatedWorld) , m_functionName(functionName) , m_eventParameterName(eventParameterName) , m_code(code) , m_parsed(false) + , m_sourceURL(sourceURL) , m_lineNumber(lineNumber) , m_originalNode(node) { @@ -66,23 +68,43 @@ JSLazyEventListener::~JSLazyEventListener() #endif } -JSObject* JSLazyEventListener::jsFunction() const +JSObject* JSLazyEventListener::jsFunction(ScriptExecutionContext* executionContext) const { - parseCode(); + parseCode(executionContext); return m_jsFunction; } -void JSLazyEventListener::parseCode() const +void JSLazyEventListener::parseCode(ScriptExecutionContext* executionContext) const { + ASSERT(executionContext); + ASSERT(executionContext->isDocument()); + if (!executionContext) + return; + if (m_parsed) return; - ScriptExecutionContext* executionContext = m_globalObject->scriptExecutionContext(); - ASSERT(executionContext); - if (!executionContext) + Frame* frame = static_cast<Document*>(executionContext)->frame(); + if (!frame) return; + + ScriptController* scriptController = frame->script(); + if (!scriptController->isEnabled()) + return; + + JSDOMGlobalObject* globalObject = toJSDOMGlobalObject(executionContext, m_isolatedWorld.get()); + if (!globalObject) + return; + + // Ensure that 'node' has a JavaScript wrapper to mark the event listener we're creating. + if (m_originalNode) { + JSLock lock(SilenceAssertionsOnly); + // FIXME: Should pass the global object associated with the node + toJS(globalObject->globalExec(), globalObject, m_originalNode); + } + if (executionContext->isDocument()) { - JSDOMWindow* window = static_cast<JSDOMWindow*>(m_globalObject); + JSDOMWindow* window = static_cast<JSDOMWindow*>(globalObject); Frame* frame = window->impl()->frame(); if (!frame) return; @@ -94,16 +116,13 @@ void JSLazyEventListener::parseCode() const m_parsed = true; - ExecState* exec = m_globalObject->globalExec(); + ExecState* exec = globalObject->globalExec(); MarkedArgumentBuffer args; - UString sourceURL(executionContext->url().string()); args.append(jsNontrivialString(exec, m_eventParameterName)); args.append(jsString(exec, m_code)); - // FIXME: Passing the document's URL to construct is not always correct, since this event listener might - // have been added with setAttribute from a script, and we should pass String() in that case. - m_jsFunction = constructFunction(exec, args, Identifier(exec, m_functionName), sourceURL, m_lineNumber); // FIXME: is globalExec ok? + m_jsFunction = constructFunction(exec, args, Identifier(exec, m_functionName), m_sourceURL, m_lineNumber); // FIXME: is globalExec ok? JSFunction* listenerAsFunction = static_cast<JSFunction*>(m_jsFunction); @@ -117,7 +136,7 @@ void JSLazyEventListener::parseCode() const // (and the document, and the form - see JSHTMLElement::eventHandlerScope) ScopeChain scope = listenerAsFunction->scope(); - JSValue thisObj = toJS(exec, m_globalObject, m_originalNode); + JSValue thisObj = toJS(exec, globalObject, m_originalNode); if (thisObj.isObject()) { static_cast<JSNode*>(asObject(thisObj))->pushEventHandlerScope(exec, scope); listenerAsFunction->setScope(scope); @@ -128,6 +147,7 @@ void JSLazyEventListener::parseCode() const m_functionName = String(); m_code = String(); m_eventParameterName = String(); + m_sourceURL = String(); } } // namespace WebCore diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSLazyEventListener.h b/src/3rdparty/webkit/WebCore/bindings/js/JSLazyEventListener.h index a5304cf51..ba26ef697 100644 --- a/src/3rdparty/webkit/WebCore/bindings/js/JSLazyEventListener.h +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSLazyEventListener.h @@ -29,24 +29,25 @@ namespace WebCore { class JSLazyEventListener : public JSEventListener { public: - static PassRefPtr<JSLazyEventListener> create(const String& functionName, const String& eventParameterName, const String& code, JSDOMGlobalObject* globalObject, Node* node, int lineNumber) + static PassRefPtr<JSLazyEventListener> create(const String& functionName, const String& eventParameterName, const String& code, Node* node, const String& sourceURL, int lineNumber, DOMWrapperWorld* isolatedWorld) { - return adoptRef(new JSLazyEventListener(functionName, eventParameterName, code, globalObject, node, lineNumber)); + return adoptRef(new JSLazyEventListener(functionName, eventParameterName, code, node, sourceURL, lineNumber, isolatedWorld)); } virtual ~JSLazyEventListener(); private: - JSLazyEventListener(const String& functionName, const String& eventParameterName, const String& code, JSDOMGlobalObject*, Node*, int lineNumber); + JSLazyEventListener(const String& functionName, const String& eventParameterName, const String& code, Node*, const String& sourceURL, int lineNumber, DOMWrapperWorld* isolatedWorld); - virtual JSC::JSObject* jsFunction() const; + virtual JSC::JSObject* jsFunction(ScriptExecutionContext*) const; virtual bool wasCreatedFromMarkup() const { return true; } - void parseCode() const; + void parseCode(ScriptExecutionContext*) const; mutable String m_functionName; mutable String m_eventParameterName; mutable String m_code; mutable bool m_parsed; + mutable String m_sourceURL; int m_lineNumber; Node* m_originalNode; }; diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSLocationCustom.cpp b/src/3rdparty/webkit/WebCore/bindings/js/JSLocationCustom.cpp index e4f1653b3..c76a2b18c 100644 --- a/src/3rdparty/webkit/WebCore/bindings/js/JSLocationCustom.cpp +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSLocationCustom.cpp @@ -31,6 +31,7 @@ #include "KURL.h" #include "Location.h" #include "ScriptController.h" +#include <runtime/JSFunction.h> #include <runtime/PrototypeFunction.h> using namespace JSC; @@ -93,6 +94,51 @@ bool JSLocation::getOwnPropertySlotDelegate(ExecState* exec, const Identifier& p return true; } +bool JSLocation::getOwnPropertyDescriptorDelegate(ExecState* exec, const Identifier& propertyName, PropertyDescriptor& descriptor) +{ + Frame* frame = impl()->frame(); + if (!frame) { + descriptor.setUndefined(); + return true; + } + + // When accessing Location cross-domain, functions are always the native built-in ones. + // See JSDOMWindow::getOwnPropertySlotDelegate for additional details. + + // Our custom code is only needed to implement the Window cross-domain scheme, so if access is + // allowed, return false so the normal lookup will take place. + String message; + if (allowsAccessFromFrame(exec, frame, message)) + return false; + + // Check for the few functions that we allow, even when called cross-domain. + const HashEntry* entry = JSLocationPrototype::s_info.propHashTable(exec)->entry(exec, propertyName); + PropertySlot slot; + if (entry && (entry->attributes() & Function)) { + if (entry->function() == jsLocationPrototypeFunctionReplace) { + slot.setCustom(this, nonCachingStaticReplaceFunctionGetter); + descriptor.setDescriptor(slot.getValue(exec, propertyName), entry->attributes()); + return true; + } else if (entry->function() == jsLocationPrototypeFunctionReload) { + slot.setCustom(this, nonCachingStaticReloadFunctionGetter); + descriptor.setDescriptor(slot.getValue(exec, propertyName), entry->attributes()); + return true; + } else if (entry->function() == jsLocationPrototypeFunctionAssign) { + slot.setCustom(this, nonCachingStaticAssignFunctionGetter); + descriptor.setDescriptor(slot.getValue(exec, propertyName), entry->attributes()); + return true; + } + } + + // FIXME: Other implementers of the Window cross-domain scheme (Window, History) allow toString, + // but for now we have decided not to, partly because it seems silly to return "[Object Location]" in + // such cases when normally the string form of Location would be the URL. + + printErrorMessageForFrame(frame, message); + descriptor.setUndefined(); + return true; +} + bool JSLocation::putDelegate(ExecState* exec, const Identifier& propertyName, JSValue value, PutPropertySlot& slot) { Frame* frame = impl()->frame(); @@ -128,19 +174,19 @@ bool JSLocation::deleteProperty(ExecState* exec, const Identifier& propertyName) return Base::deleteProperty(exec, propertyName); } -void JSLocation::getPropertyNames(ExecState* exec, PropertyNameArray& propertyNames) +void JSLocation::getOwnPropertyNames(ExecState* exec, PropertyNameArray& propertyNames) { // Only allow the location object to enumerated by frames in the same origin. if (!allowsAccessFromFrame(exec, impl()->frame())) return; - Base::getPropertyNames(exec, propertyNames); + Base::getOwnPropertyNames(exec, propertyNames); } -void JSLocation::defineGetter(ExecState* exec, const Identifier& propertyName, JSObject* getterFunction) +void JSLocation::defineGetter(ExecState* exec, const Identifier& propertyName, JSObject* getterFunction, unsigned attributes) { if (propertyName == exec->propertyNames().toString || propertyName == exec->propertyNames().valueOf) return; - Base::defineGetter(exec, propertyName, getterFunction); + Base::defineGetter(exec, propertyName, getterFunction, attributes); } static void navigateIfAllowed(ExecState* exec, Frame* frame, const KURL& url, bool lockHistory, bool lockBackForwardList) @@ -150,7 +196,7 @@ static void navigateIfAllowed(ExecState* exec, Frame* frame, const KURL& url, bo return; if (!protocolIsJavaScript(url) || allowsAccessFromFrame(exec, frame)) - frame->loader()->scheduleLocationChange(url.string(), lexicalFrame->loader()->outgoingReferrer(), lockHistory, lockBackForwardList, processingUserGesture(exec)); + frame->redirectScheduler()->scheduleLocationChange(url.string(), lexicalFrame->loader()->outgoingReferrer(), lockHistory, lockBackForwardList, processingUserGesture(exec)); } void JSLocation::setHref(ExecState* exec, JSValue value) @@ -158,13 +204,13 @@ void JSLocation::setHref(ExecState* exec, JSValue value) Frame* frame = impl()->frame(); ASSERT(frame); - if (!shouldAllowNavigation(exec, frame)) - return; - KURL url = completeURL(exec, value.toString(exec)); if (url.isNull()) return; + if (!shouldAllowNavigation(exec, frame)) + return; + navigateIfAllowed(exec, frame, url, !frame->script()->anyPageIsProcessingUserGesture(), false); } @@ -245,13 +291,13 @@ void JSLocation::setHash(ExecState* exec, JSValue value) ASSERT(frame); KURL url = frame->loader()->url(); - String oldRef = url.ref(); + String oldFragmentIdentifier = url.fragmentIdentifier(); String str = value.toString(exec); if (str.startsWith("#")) str = str.substring(1); - if (oldRef == str || (oldRef.isNull() && str.isEmpty())) + if (equalIgnoringNullity(oldFragmentIdentifier, str)) return; - url.setRef(str); + url.setFragmentIdentifier(str); navigateIfAllowed(exec, frame, url, !frame->script()->anyPageIsProcessingUserGesture(), false); } @@ -262,13 +308,13 @@ JSValue JSLocation::replace(ExecState* exec, const ArgList& args) if (!frame) return jsUndefined(); - if (!shouldAllowNavigation(exec, frame)) - return jsUndefined(); - KURL url = completeURL(exec, args.at(0).toString(exec)); if (url.isNull()) return jsUndefined(); + if (!shouldAllowNavigation(exec, frame)) + return jsUndefined(); + navigateIfAllowed(exec, frame, url, true, true); return jsUndefined(); } @@ -280,7 +326,7 @@ JSValue JSLocation::reload(ExecState* exec, const ArgList&) return jsUndefined(); if (!protocolIsJavaScript(frame->loader()->url())) - frame->loader()->scheduleRefresh(processingUserGesture(exec)); + frame->redirectScheduler()->scheduleRefresh(processingUserGesture(exec)); return jsUndefined(); } @@ -290,13 +336,13 @@ JSValue JSLocation::assign(ExecState* exec, const ArgList& args) if (!frame) return jsUndefined(); - if (!shouldAllowNavigation(exec, frame)) - return jsUndefined(); - KURL url = completeURL(exec, args.at(0).toString(exec)); if (url.isNull()) return jsUndefined(); + if (!shouldAllowNavigation(exec, frame)) + return jsUndefined(); + // We want a new history item if this JS was called via a user gesture navigateIfAllowed(exec, frame, url, !frame->script()->anyPageIsProcessingUserGesture(), false); return jsUndefined(); @@ -316,11 +362,11 @@ bool JSLocationPrototype::putDelegate(ExecState* exec, const Identifier& propert return (propertyName == exec->propertyNames().toString || propertyName == exec->propertyNames().valueOf); } -void JSLocationPrototype::defineGetter(ExecState* exec, const Identifier& propertyName, JSObject* getterFunction) +void JSLocationPrototype::defineGetter(ExecState* exec, const Identifier& propertyName, JSObject* getterFunction, unsigned attributes) { if (propertyName == exec->propertyNames().toString || propertyName == exec->propertyNames().valueOf) return; - Base::defineGetter(exec, propertyName, getterFunction); + Base::defineGetter(exec, propertyName, getterFunction, attributes); } } // namespace WebCore diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSMessageChannelConstructor.cpp b/src/3rdparty/webkit/WebCore/bindings/js/JSMessageChannelConstructor.cpp index 25a5cb2e8..9721ba3ea 100644 --- a/src/3rdparty/webkit/WebCore/bindings/js/JSMessageChannelConstructor.cpp +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSMessageChannelConstructor.cpp @@ -30,6 +30,7 @@ #include "JSDocument.h" #include "JSMessageChannel.h" #include "MessageChannel.h" +#include <runtime/Error.h> using namespace JSC; diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSMessageChannelCustom.cpp b/src/3rdparty/webkit/WebCore/bindings/js/JSMessageChannelCustom.cpp index d3b58789a..d28d49474 100644 --- a/src/3rdparty/webkit/WebCore/bindings/js/JSMessageChannelCustom.cpp +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSMessageChannelCustom.cpp @@ -1,5 +1,5 @@ /* - * Copyright (C) 2008 Apple Inc. All Rights Reserved. + * Copyright (C) 2008, 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 @@ -32,21 +32,15 @@ using namespace JSC; namespace WebCore { -void JSMessageChannel::mark() +void JSMessageChannel::markChildren(MarkStack& markStack) { - Base::mark(); + Base::markChildren(markStack); - if (MessagePort* port = m_impl->port1()) { - DOMObject* wrapper = getCachedDOMObjectWrapper(*Heap::heap(this)->globalData(), port); - if (wrapper && !wrapper->marked()) - wrapper->mark(); - } + if (MessagePort* port = m_impl->port1()) + markDOMObjectWrapper(markStack, *Heap::heap(this)->globalData(), port); - if (MessagePort* port = m_impl->port2()) { - DOMObject* wrapper = getCachedDOMObjectWrapper(*Heap::heap(this)->globalData(), port); - if (wrapper && !wrapper->marked()) - wrapper->mark(); - } + if (MessagePort* port = m_impl->port2()) + markDOMObjectWrapper(markStack, *Heap::heap(this)->globalData(), port); } } // namespace WebCore diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSMessageEventCustom.cpp b/src/3rdparty/webkit/WebCore/bindings/js/JSMessageEventCustom.cpp new file mode 100644 index 000000000..2e7b2d062 --- /dev/null +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSMessageEventCustom.cpp @@ -0,0 +1,79 @@ +/* + * Copyright (C) 2009 Google 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: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * 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. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "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 THE COPYRIGHT + * OWNER 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" +#include "JSMessageEvent.h" + +#include "JSDOMBinding.h" +#include "JSDOMWindow.h" +#include "JSEventTarget.h" +#include "JSMessagePortCustom.h" +#include "MessageEvent.h" +#include <runtime/JSArray.h> + +using namespace JSC; + +namespace WebCore { + +JSValue JSMessageEvent::ports(ExecState* exec) const +{ + MessagePortArray* ports = static_cast<MessageEvent*>(impl())->ports(); + if (!ports || ports->isEmpty()) + return jsNull(); + + MarkedArgumentBuffer list; + for (size_t i = 0; i < ports->size(); i++) + list.append(toJS(exec, globalObject(), (*ports)[i].get())); + return constructArray(exec, list); +} + +JSC::JSValue JSMessageEvent::initMessageEvent(JSC::ExecState* exec, const JSC::ArgList& args) +{ + const UString& typeArg = args.at(0).toString(exec); + bool canBubbleArg = args.at(1).toBoolean(exec); + bool cancelableArg = args.at(2).toBoolean(exec); + PassRefPtr<SerializedScriptValue> dataArg = SerializedScriptValue::create(exec, args.at(3)); + const UString& originArg = args.at(4).toString(exec); + const UString& lastEventIdArg = args.at(5).toString(exec); + DOMWindow* sourceArg = toDOMWindow(args.at(6)); + OwnPtr<MessagePortArray> messagePorts; + if (!args.at(7).isUndefinedOrNull()) { + messagePorts = new MessagePortArray(); + fillMessagePortArray(exec, args.at(7), *messagePorts); + if (exec->hadException()) + return jsUndefined(); + } + + MessageEvent* event = static_cast<MessageEvent*>(this->impl()); + event->initMessageEvent(typeArg, canBubbleArg, cancelableArg, dataArg, originArg, lastEventIdArg, sourceArg, messagePorts.release()); + return jsUndefined(); +} + +} // namespace WebCore diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSMessagePortCustom.cpp b/src/3rdparty/webkit/WebCore/bindings/js/JSMessagePortCustom.cpp index 71472d5b7..2c09620cd 100644 --- a/src/3rdparty/webkit/WebCore/bindings/js/JSMessagePortCustom.cpp +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSMessagePortCustom.cpp @@ -28,60 +28,89 @@ #include "AtomicString.h" #include "Event.h" +#include "ExceptionCode.h" #include "Frame.h" #include "JSDOMGlobalObject.h" #include "JSEvent.h" #include "JSEventListener.h" +#include "JSMessagePortCustom.h" #include "MessagePort.h" +#include <runtime/Error.h> using namespace JSC; namespace WebCore { -void JSMessagePort::mark() +void JSMessagePort::markChildren(MarkStack& markStack) { - Base::mark(); - - markIfNotNull(m_impl->onmessage()); + Base::markChildren(markStack); // If we have a locally entangled port, we can directly mark it as reachable. Ports that are remotely entangled are marked in-use by markActiveObjectsForContext(). - if (MessagePort* entangledPort = m_impl->locallyEntangledPort()) { - DOMObject* wrapper = getCachedDOMObjectWrapper(*Heap::heap(this)->globalData(), entangledPort); - if (wrapper && !wrapper->marked()) - wrapper->mark(); - } + if (MessagePort* entangledPort = m_impl->locallyEntangledPort()) + markDOMObjectWrapper(markStack, *Heap::heap(this)->globalData(), entangledPort); - typedef MessagePort::EventListenersMap EventListenersMap; - typedef MessagePort::ListenerVector ListenerVector; - EventListenersMap& eventListeners = m_impl->eventListeners(); - for (EventListenersMap::iterator mapIter = eventListeners.begin(); mapIter != eventListeners.end(); ++mapIter) { - for (ListenerVector::iterator vecIter = mapIter->second.begin(); vecIter != mapIter->second.end(); ++vecIter) - (*vecIter)->markJSFunction(); - } + m_impl->markEventListeners(markStack); } JSValue JSMessagePort::addEventListener(ExecState* exec, const ArgList& args) { - JSDOMGlobalObject* globalObject = toJSDOMGlobalObject(impl()->scriptExecutionContext()); - if (!globalObject) + JSValue listener = args.at(1); + if (!listener.isObject()) return jsUndefined(); - RefPtr<JSEventListener> listener = globalObject->findOrCreateJSEventListener(args.at(1)); - if (!listener) - return jsUndefined(); - impl()->addEventListener(args.at(0).toString(exec), listener.release(), args.at(2).toBoolean(exec)); + + impl()->addEventListener(args.at(0).toString(exec), JSEventListener::create(asObject(listener), false, currentWorld(exec)).get(), args.at(2).toBoolean(exec)); return jsUndefined(); } JSValue JSMessagePort::removeEventListener(ExecState* exec, const ArgList& args) { - JSDOMGlobalObject* globalObject = toJSDOMGlobalObject(impl()->scriptExecutionContext()); - if (!globalObject) + JSValue listener = args.at(1); + if (!listener.isObject()) return jsUndefined(); - JSEventListener* listener = globalObject->findJSEventListener(args.at(1)); - if (!listener) - return jsUndefined(); - impl()->removeEventListener(args.at(0).toString(exec), listener, args.at(2).toBoolean(exec)); + + impl()->removeEventListener(args.at(0).toString(exec), JSEventListener::create(asObject(listener), false, currentWorld(exec)).get(), args.at(2).toBoolean(exec)); return jsUndefined(); } +JSC::JSValue JSMessagePort::postMessage(JSC::ExecState* exec, const JSC::ArgList& args) +{ + return handlePostMessage(exec, args, impl()); +} + +void fillMessagePortArray(JSC::ExecState* exec, JSC::JSValue value, MessagePortArray& portArray) +{ + // Convert from the passed-in JS array-like object to a MessagePortArray. + // Also validates the elements per sections 4.1.13 and 4.1.15 of the WebIDL spec and section 8.3.3 of the HTML5 spec. + if (value.isUndefinedOrNull()) { + portArray.resize(0); + return; + } + + // Validation of sequence types, per WebIDL spec 4.1.13. + unsigned length; + JSObject* object = toJSSequence(exec, value, length); + if (exec->hadException()) + return; + + portArray.resize(length); + for (unsigned i = 0 ; i < length; ++i) { + JSValue value = object->get(exec, i); + if (exec->hadException()) + return; + // Validation of non-null objects, per HTML5 spec 8.3.3. + if (value.isUndefinedOrNull()) { + setDOMException(exec, INVALID_STATE_ERR); + return; + } + + // Validation of Objects implementing an interface, per WebIDL spec 4.1.15. + RefPtr<MessagePort> port = toMessagePort(value); + if (!port) { + throwError(exec, TypeError); + return; + } + portArray[i] = port.release(); + } +} + } // namespace WebCore diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSMessagePortCustom.h b/src/3rdparty/webkit/WebCore/bindings/js/JSMessagePortCustom.h new file mode 100644 index 000000000..17b1eae80 --- /dev/null +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSMessagePortCustom.h @@ -0,0 +1,65 @@ +/* + * Copyright (C) 2009 Google 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: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * 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. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "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 THE COPYRIGHT + * OWNER 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. + */ + +#ifndef JSMessagePortCustom_h +#define JSMessagePortCustom_h + +#include "MessagePort.h" +#include <runtime/JSValue.h> + +namespace WebCore { + + typedef int ExceptionCode; + + class String; + + // Helper function which pulls the values out of a JS sequence and into a MessagePortArray. + // Also validates the elements per sections 4.1.13 and 4.1.15 of the WebIDL spec and section 8.3.3 of the HTML5 spec. + // May generate an exception via the passed ExecState. + void fillMessagePortArray(JSC::ExecState*, JSC::JSValue, MessagePortArray&); + + // Helper function to convert from JS postMessage arguments to WebCore postMessage arguments. + template <typename T> + inline JSC::JSValue handlePostMessage(JSC::ExecState* exec, const JSC::ArgList& args, T* impl) + { + PassRefPtr<SerializedScriptValue> message = SerializedScriptValue::create(exec, args.at(0)); + MessagePortArray portArray; + fillMessagePortArray(exec, args.at(1), portArray); + if (exec->hadException()) + return JSC::jsUndefined(); + + ExceptionCode ec = 0; + impl->postMessage(message, &portArray, ec); + setDOMException(exec, ec); + return JSC::jsUndefined(); + } + +} +#endif // JSMessagePortCustom_h diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSNamedNodeMapCustom.cpp b/src/3rdparty/webkit/WebCore/bindings/js/JSNamedNodeMapCustom.cpp index 7bd95b4d9..1974ab0cc 100644 --- a/src/3rdparty/webkit/WebCore/bindings/js/JSNamedNodeMapCustom.cpp +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSNamedNodeMapCustom.cpp @@ -1,5 +1,5 @@ /* - * Copyright (C) 2007, 2008 Apple Inc. All rights reserved. + * Copyright (C) 2007, 2008, 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 @@ -27,10 +27,9 @@ #include "JSNamedNodeMap.h" #include "JSNode.h" + +#include "Element.h" #include "NamedNodeMap.h" -#include "Node.h" -#include "PlatformString.h" -#include "JSDOMBinding.h" using namespace JSC; @@ -47,4 +46,16 @@ JSValue JSNamedNodeMap::nameGetter(ExecState* exec, const Identifier& propertyNa return toJS(exec, thisObj->impl()->getNamedItem(propertyName)); } +void JSNamedNodeMap::markChildren(MarkStack& markStack) +{ + Base::markChildren(markStack); + + // Mark the element so that this will work to access the attribute even if the last + // other reference goes away. + if (Element* element = impl()->element()) { + if (JSNode* wrapper = getCachedDOMNodeWrapper(element->document(), element)) + markStack.append(wrapper); + } +} + } // namespace WebCore diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSNamedNodesCollection.cpp b/src/3rdparty/webkit/WebCore/bindings/js/JSNamedNodesCollection.cpp deleted file mode 100644 index f36a7d6a1..000000000 --- a/src/3rdparty/webkit/WebCore/bindings/js/JSNamedNodesCollection.cpp +++ /dev/null @@ -1,92 +0,0 @@ -/* - * Copyright (C) 2007, 2008 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" -#include "JSNamedNodesCollection.h" - -#include "AtomicString.h" -#include "Element.h" -#include "JSNode.h" -#include "NamedNodeMap.h" - -namespace WebCore { - -using namespace JSC; - -ASSERT_CLASS_FITS_IN_CELL(JSNamedNodesCollection); - -const ClassInfo JSNamedNodesCollection::s_info = { "Collection", 0, 0, 0 }; - -// Such a collection is usually very short-lived, it only exists -// for constructs like document.forms.<name>[1], -// so it shouldn't be a problem that it's storing all the nodes (with the same name). (David) -JSNamedNodesCollection::JSNamedNodesCollection(ExecState* exec, JSDOMGlobalObject* globalObject, const Vector<RefPtr<Node> >& nodes) - : DOMObjectWithGlobalPointer(getDOMStructure<JSNamedNodesCollection>(exec, globalObject), globalObject) - , m_nodes(new Vector<RefPtr<Node> >(nodes)) -{ -} - -JSValue JSNamedNodesCollection::lengthGetter(ExecState* exec, const Identifier&, const PropertySlot& slot) -{ - JSNamedNodesCollection* thisObj = static_cast<JSNamedNodesCollection*>(asObject(slot.slotBase())); - return jsNumber(exec, thisObj->m_nodes->size()); -} - -JSValue JSNamedNodesCollection::indexGetter(ExecState* exec, const Identifier&, const PropertySlot& slot) -{ - JSNamedNodesCollection *thisObj = static_cast<JSNamedNodesCollection*>(asObject(slot.slotBase())); - return toJS(exec, (*thisObj->m_nodes)[slot.index()].get()); -} - -bool JSNamedNodesCollection::getOwnPropertySlot(ExecState* exec, const Identifier& propertyName, PropertySlot& slot) -{ - if (propertyName == exec->propertyNames().length) { - slot.setCustom(this, lengthGetter); - return true; - } - - bool ok; - unsigned index = propertyName.toUInt32(&ok); - if (ok && index < m_nodes->size()) { - slot.setCustomIndex(this, index, indexGetter); - return true; - } - - // For IE compatibility, we need to be able to look up elements in a - // document.formName.name result by id as well as be index. - - AtomicString atomicPropertyName = propertyName; - for (unsigned i = 0; i < m_nodes->size(); i++) { - Node* node = (*m_nodes)[i].get(); - if (node->hasAttributes() && node->attributes()->id() == atomicPropertyName) { - slot.setCustomIndex(this, i, indexGetter); - return true; - } - } - - return DOMObjectWithGlobalPointer::getOwnPropertySlot(exec, propertyName, slot); -} - -} // namespace WebCore diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSNavigatorCustom.cpp b/src/3rdparty/webkit/WebCore/bindings/js/JSNavigatorCustom.cpp index ea6ccebd2..c02393132 100644 --- a/src/3rdparty/webkit/WebCore/bindings/js/JSNavigatorCustom.cpp +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSNavigatorCustom.cpp @@ -29,13 +29,13 @@ namespace WebCore { using namespace JSC; -void JSNavigator::mark() +void JSNavigator::markChildren(MarkStack& markStack) { - Base::mark(); + Base::markChildren(markStack); JSGlobalData& globalData = *Heap::heap(this)->globalData(); - markDOMObjectWrapper(globalData, impl()->optionalGeolocation()); + markDOMObjectWrapper(markStack, globalData, impl()->optionalGeolocation()); } } diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSNodeCustom.cpp b/src/3rdparty/webkit/WebCore/bindings/js/JSNodeCustom.cpp index 2f080b8f9..2a4aa80bf 100644 --- a/src/3rdparty/webkit/WebCore/bindings/js/JSNodeCustom.cpp +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSNodeCustom.cpp @@ -1,5 +1,5 @@ /* - * Copyright (C) 2007 Apple Inc. All rights reserved. + * Copyright (C) 2007, 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 @@ -110,25 +110,21 @@ JSValue JSNode::appendChild(ExecState* exec, const ArgList& args) JSValue JSNode::addEventListener(ExecState* exec, const ArgList& args) { - JSDOMGlobalObject* globalObject = toJSDOMGlobalObject(impl()->scriptExecutionContext()); - if (!globalObject) + JSValue listener = args.at(1); + if (!listener.isObject()) return jsUndefined(); - if (RefPtr<JSEventListener> listener = globalObject->findOrCreateJSEventListener(args.at(1))) - impl()->addEventListener(args.at(0).toString(exec), listener.release(), args.at(2).toBoolean(exec)); - + impl()->addEventListener(args.at(0).toString(exec), JSEventListener::create(asObject(listener), false, currentWorld(exec)), args.at(2).toBoolean(exec)); return jsUndefined(); } JSValue JSNode::removeEventListener(ExecState* exec, const ArgList& args) { - JSDOMGlobalObject* globalObject = toJSDOMGlobalObject(impl()->scriptExecutionContext()); - if (!globalObject) + JSValue listener = args.at(1); + if (!listener.isObject()) return jsUndefined(); - if (JSEventListener* listener = globalObject->findJSEventListener(args.at(1))) - impl()->removeEventListener(args.at(0).toString(exec), listener, args.at(2).toBoolean(exec)); - + impl()->removeEventListener(args.at(0).toString(exec), JSEventListener::create(asObject(listener), false, currentWorld(exec)).get(), args.at(2).toBoolean(exec)); return jsUndefined(); } @@ -136,22 +132,19 @@ void JSNode::pushEventHandlerScope(ExecState*, ScopeChain&) const { } -void JSNode::mark() +void JSNode::markChildren(MarkStack& markStack) { - ASSERT(!marked()); + Base::markChildren(markStack); Node* node = m_impl.get(); + node->markEventListeners(markStack); // Nodes in the document are kept alive by JSDocument::mark, so, if we're in // the document, we need to mark the document, but we don't need to explicitly // mark any other nodes. if (node->inDocument()) { - Base::mark(); - markEventListeners(node->eventListeners()); if (Document* doc = node->ownerDocument()) - if (DOMObject* docWrapper = getCachedDOMObjectWrapper(*Heap::heap(this)->globalData(), doc)) - if (!docWrapper->marked()) - docWrapper->mark(); + markDOMObjectWrapper(markStack, *Heap::heap(this)->globalData(), doc); return; } @@ -163,33 +156,17 @@ void JSNode::mark() // Nodes in a subtree are marked by the tree's root, so, if the root is already // marking the tree, we don't need to explicitly mark any other nodes. - if (root->inSubtreeMark()) { - Base::mark(); - markEventListeners(node->eventListeners()); + if (root->inSubtreeMark()) return; - } // Mark the whole tree subtree. root->setInSubtreeMark(true); for (Node* nodeToMark = root; nodeToMark; nodeToMark = nodeToMark->traverseNextNode()) { JSNode* wrapper = getCachedDOMNodeWrapper(m_impl->document(), nodeToMark); - if (wrapper) { - if (!wrapper->marked()) - wrapper->mark(); - } else if (nodeToMark == node) { - // This is the case where the map from the document to wrappers has - // been cleared out, but a wrapper is being marked. For now, we'll - // let the rest of the tree of wrappers get collected, because we have - // no good way of finding them. Later we should test behavior of other - // browsers and see if we need to preserve other wrappers in this case. - if (!marked()) - mark(); - } + if (wrapper) + markStack.append(wrapper); } root->setInSubtreeMark(false); - - // Double check that we actually ended up marked. This assert caught problems in the past. - ASSERT(marked()); } static ALWAYS_INLINE JSValue createWrapper(ExecState* exec, JSDOMGlobalObject* globalObject, Node* node) diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSNodeFilterCondition.cpp b/src/3rdparty/webkit/WebCore/bindings/js/JSNodeFilterCondition.cpp index 2595af587..54dc02003 100644 --- a/src/3rdparty/webkit/WebCore/bindings/js/JSNodeFilterCondition.cpp +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSNodeFilterCondition.cpp @@ -1,6 +1,6 @@ /* * Copyright (C) 2001 Peter Kelly (pmk@post.com) - * Copyright (C) 2007, 2008 Apple Inc. All rights reserved. + * Copyright (C) 2007, 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 Lesser General Public @@ -36,10 +36,9 @@ JSNodeFilterCondition::JSNodeFilterCondition(JSValue filter) { } -void JSNodeFilterCondition::mark() +void JSNodeFilterCondition::markAggregate(MarkStack& markStack) { - if (!m_filter.marked()) - m_filter.mark(); + markStack.append(m_filter); } short JSNodeFilterCondition::acceptNode(JSC::ExecState* exec, Node* filterNode) const @@ -67,7 +66,7 @@ short JSNodeFilterCondition::acceptNode(JSC::ExecState* exec, Node* filterNode) if (exec->hadException()) return NodeFilter::FILTER_REJECT; - JSValue result = call(exec, m_filter, callType, callData, m_filter, args); + JSValue result = callInWorld(exec, m_filter, callType, callData, m_filter, args, currentWorld(exec)); if (exec->hadException()) return NodeFilter::FILTER_REJECT; diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSNodeFilterCondition.h b/src/3rdparty/webkit/WebCore/bindings/js/JSNodeFilterCondition.h index 3d591c6df..b96534a0c 100644 --- a/src/3rdparty/webkit/WebCore/bindings/js/JSNodeFilterCondition.h +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSNodeFilterCondition.h @@ -1,6 +1,6 @@ /* * Copyright (C) 2001 Peter Kelly (pmk@post.com) - * Copyright (C) 2007, 2008 Apple Inc. All rights reserved. + * Copyright (C) 2007, 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 Lesser General Public @@ -39,7 +39,7 @@ namespace WebCore { JSNodeFilterCondition(JSC::JSValue filter); virtual short acceptNode(ScriptState*, Node*) const; - virtual void mark(); + virtual void markAggregate(JSC::MarkStack&); mutable JSC::JSValue m_filter; }; diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSNodeFilterCustom.cpp b/src/3rdparty/webkit/WebCore/bindings/js/JSNodeFilterCustom.cpp index a48a59d65..2a99a9361 100644 --- a/src/3rdparty/webkit/WebCore/bindings/js/JSNodeFilterCustom.cpp +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSNodeFilterCustom.cpp @@ -1,5 +1,5 @@ /* - * Copyright (C) 2007, 2008 Apple Inc. All rights reserved. + * Copyright (C) 2007, 2008, 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 @@ -35,10 +35,10 @@ using namespace JSC; namespace WebCore { -void JSNodeFilter::mark() +void JSNodeFilter::markChildren(MarkStack& markStack) { - impl()->mark(); - Base::mark(); + Base::markChildren(markStack); + impl()->markAggregate(markStack); } JSValue JSNodeFilter::acceptNode(ExecState* exec, const ArgList& args) @@ -48,7 +48,7 @@ JSValue JSNodeFilter::acceptNode(ExecState* exec, const ArgList& args) PassRefPtr<NodeFilter> toNodeFilter(JSValue value) { - if (value.isObject(&JSNodeFilter::s_info)) + if (value.inherits(&JSNodeFilter::s_info)) return static_cast<JSNodeFilter*>(asObject(value))->impl(); return NodeFilter::create(JSNodeFilterCondition::create(value)); diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSNodeIteratorCustom.cpp b/src/3rdparty/webkit/WebCore/bindings/js/JSNodeIteratorCustom.cpp index a2b96586b..6a09abf91 100644 --- a/src/3rdparty/webkit/WebCore/bindings/js/JSNodeIteratorCustom.cpp +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSNodeIteratorCustom.cpp @@ -1,5 +1,5 @@ /* - * Copyright (C) 2006, 2008 Apple Inc. All rights reserved. + * Copyright (C) 2006, 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 @@ -29,12 +29,12 @@ using namespace JSC; namespace WebCore { -void JSNodeIterator::mark() +void JSNodeIterator::markChildren(MarkStack& markStack) { + Base::markChildren(markStack); + if (NodeFilter* filter = m_impl->filter()) - filter->mark(); - - Base::mark(); + filter->markAggregate(markStack); } JSValue JSNodeIterator::nextNode(ExecState* exec, const ArgList&) diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSOptionConstructor.cpp b/src/3rdparty/webkit/WebCore/bindings/js/JSOptionConstructor.cpp index 2b8bd5d97..7da066635 100644 --- a/src/3rdparty/webkit/WebCore/bindings/js/JSOptionConstructor.cpp +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSOptionConstructor.cpp @@ -25,6 +25,7 @@ #include "JSHTMLOptionElement.h" #include "ScriptExecutionContext.h" #include "Text.h" +#include <runtime/Error.h> using namespace JSC; diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSPluginElementFunctions.cpp b/src/3rdparty/webkit/WebCore/bindings/js/JSPluginElementFunctions.cpp index 56b0eca2d..ada2a77a8 100644 --- a/src/3rdparty/webkit/WebCore/bindings/js/JSPluginElementFunctions.cpp +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSPluginElementFunctions.cpp @@ -86,6 +86,22 @@ bool runtimeObjectCustomGetOwnPropertySlot(ExecState* exec, const Identifier& pr return true; } +bool runtimeObjectCustomGetOwnPropertyDescriptor(ExecState* exec, const Identifier& propertyName, PropertyDescriptor& descriptor, JSHTMLElement* element) +{ + RuntimeObjectImp* runtimeObject = getRuntimeObject(exec, element->impl()); + if (!runtimeObject) + return false; + if (!runtimeObject->hasProperty(exec, propertyName)) + return false; + PropertySlot slot; + slot.setCustom(element, runtimeObjectPropertyGetter); + // While we don't know what the plugin allows, we do know that we prevent + // enumeration or deletion of properties, so we mark plugin properties + // as DontEnum | DontDelete + descriptor.setDescriptor(slot.getValue(exec, propertyName), DontEnum | DontDelete); + return true; +} + bool runtimeObjectCustomPut(ExecState* exec, const Identifier& propertyName, JSValue value, HTMLElement* element, PutPropertySlot& slot) { RuntimeObjectImp* runtimeObject = getRuntimeObject(exec, element); diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSPluginElementFunctions.h b/src/3rdparty/webkit/WebCore/bindings/js/JSPluginElementFunctions.h index 8c9dfa7f5..a5a323a27 100644 --- a/src/3rdparty/webkit/WebCore/bindings/js/JSPluginElementFunctions.h +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSPluginElementFunctions.h @@ -33,6 +33,7 @@ namespace WebCore { JSC::JSValue runtimeObjectGetter(JSC::ExecState*, const JSC::Identifier&, const JSC::PropertySlot&); JSC::JSValue runtimeObjectPropertyGetter(JSC::ExecState*, const JSC::Identifier&, const JSC::PropertySlot&); bool runtimeObjectCustomGetOwnPropertySlot(JSC::ExecState*, const JSC::Identifier&, JSC::PropertySlot&, JSHTMLElement*); + bool runtimeObjectCustomGetOwnPropertyDescriptor(JSC::ExecState*, const JSC::Identifier&, JSC::PropertyDescriptor&, JSHTMLElement*); bool runtimeObjectCustomPut(JSC::ExecState*, const JSC::Identifier&, JSC::JSValue, HTMLElement*, JSC::PutPropertySlot&); JSC::CallType runtimeObjectGetCallData(HTMLElement*, JSC::CallData&); diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSQuarantinedObjectWrapper.cpp b/src/3rdparty/webkit/WebCore/bindings/js/JSQuarantinedObjectWrapper.cpp index ad1e55619..2ab2c003c 100644 --- a/src/3rdparty/webkit/WebCore/bindings/js/JSQuarantinedObjectWrapper.cpp +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSQuarantinedObjectWrapper.cpp @@ -1,5 +1,5 @@ /* - * Copyright (C) 2008 Apple Inc. All Rights Reserved. + * Copyright (C) 2008, 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 @@ -26,6 +26,8 @@ #include "config.h" #include "JSQuarantinedObjectWrapper.h" +#include "JSDOMBinding.h" + #include <runtime/JSGlobalObject.h> using namespace JSC; @@ -56,7 +58,7 @@ JSValue JSQuarantinedObjectWrapper::cachedValueGetter(ExecState*, const Identifi return v; } -JSQuarantinedObjectWrapper::JSQuarantinedObjectWrapper(ExecState* unwrappedExec, JSObject* unwrappedObject, PassRefPtr<Structure> structure) +JSQuarantinedObjectWrapper::JSQuarantinedObjectWrapper(ExecState* unwrappedExec, JSObject* unwrappedObject, NonNullPassRefPtr<Structure> structure) : JSObject(structure) , m_unwrappedGlobalObject(unwrappedExec->lexicalGlobalObject()) , m_unwrappedObject(unwrappedObject) @@ -92,14 +94,12 @@ void JSQuarantinedObjectWrapper::transferExceptionToExecState(ExecState* exec) c exec->setException(wrapOutgoingValue(unwrappedExecState(), exception)); } -void JSQuarantinedObjectWrapper::mark() +void JSQuarantinedObjectWrapper::markChildren(MarkStack& markStack) { - JSObject::mark(); + JSObject::markChildren(markStack); - if (!m_unwrappedObject->marked()) - m_unwrappedObject->mark(); - if (!m_unwrappedGlobalObject->marked()) - m_unwrappedGlobalObject->mark(); + markStack.append(m_unwrappedObject); + markStack.append(m_unwrappedGlobalObject); } bool JSQuarantinedObjectWrapper::getOwnPropertySlot(ExecState* exec, const Identifier& identifier, PropertySlot& slot) @@ -140,6 +140,26 @@ bool JSQuarantinedObjectWrapper::getOwnPropertySlot(ExecState* exec, unsigned id return result; } +bool JSQuarantinedObjectWrapper::getOwnPropertyDescriptor(ExecState* exec, const Identifier& identifier, PropertyDescriptor& descriptor) +{ + if (!allowsGetProperty()) { + descriptor.setUndefined(); + return true; + } + + PropertyDescriptor unwrappedDescriptor; + bool result = m_unwrappedObject->getOwnPropertyDescriptor(unwrappedExecState(), identifier, unwrappedDescriptor); + + if (unwrappedDescriptor.isAccessorDescriptor()) { + descriptor.setAccessorDescriptor(wrapOutgoingValue(unwrappedExecState(), unwrappedDescriptor.getter()), + wrapOutgoingValue(unwrappedExecState(), unwrappedDescriptor.setter()), + unwrappedDescriptor.attributes()); + } else + descriptor.setDescriptor(wrapOutgoingValue(unwrappedExecState(), unwrappedDescriptor.value()), unwrappedDescriptor.attributes()); + transferExceptionToExecState(exec); + return result; +} + void JSQuarantinedObjectWrapper::put(ExecState* exec, const Identifier& identifier, JSValue value, PutPropertySlot& slot) { if (!allowsSetProperty()) @@ -160,6 +180,33 @@ void JSQuarantinedObjectWrapper::put(ExecState* exec, unsigned identifier, JSVal transferExceptionToExecState(exec); } +bool JSQuarantinedObjectWrapper::defineOwnProperty(ExecState* exec, const Identifier& propertyName, PropertyDescriptor& descriptor, bool shouldThrow) +{ + if (!allowsSetProperty()) + return false; + + PropertyDescriptor wrappedDescriptor; + if (descriptor.isDataDescriptor()) { + wrappedDescriptor.setValue(prepareIncomingValue(exec, descriptor.value())); + if (wrappedDescriptor.writablePresent()) + wrappedDescriptor.setWritable(descriptor.writable()); + } else if (descriptor.isAccessorDescriptor()) { + if (descriptor.getter()) + wrappedDescriptor.setGetter(prepareIncomingValue(exec, descriptor.getter())); + if (descriptor.setter()) + wrappedDescriptor.setSetter(prepareIncomingValue(exec, descriptor.setter())); + } + if (wrappedDescriptor.enumerablePresent()) + wrappedDescriptor.setEnumerable(descriptor.enumerable()); + if (wrappedDescriptor.configurablePresent()) + wrappedDescriptor.setConfigurable(descriptor.configurable()); + + bool result = m_unwrappedObject->defineOwnProperty(unwrappedExecState(), propertyName, wrappedDescriptor, shouldThrow); + + transferExceptionToExecState(exec); + return result; +} + bool JSQuarantinedObjectWrapper::deleteProperty(ExecState* exec, const Identifier& identifier) { if (!allowsDeleteProperty()) @@ -198,7 +245,8 @@ JSObject* JSQuarantinedObjectWrapper::construct(ExecState* exec, JSObject* const ConstructType unwrappedConstructType = wrapper->m_unwrappedObject->getConstructData(unwrappedConstructData); ASSERT(unwrappedConstructType != ConstructTypeNone); - JSValue unwrappedResult = JSC::construct(wrapper->unwrappedExecState(), wrapper->m_unwrappedObject, unwrappedConstructType, unwrappedConstructData, preparedArgs); + // FIXME: Quarantined objects are all in the debuggerWorld(), for now. Instead, we should remove the quarantined objects, & replace them with an isolated world? + JSValue unwrappedResult = constructInWorld(wrapper->unwrappedExecState(), wrapper->m_unwrappedObject, unwrappedConstructType, unwrappedConstructData, preparedArgs, debuggerWorld()); JSValue resultValue = wrapper->wrapOutgoingValue(wrapper->unwrappedExecState(), unwrappedResult); ASSERT(resultValue.isObject()); @@ -248,7 +296,8 @@ JSValue JSQuarantinedObjectWrapper::call(ExecState* exec, JSObject* function, JS CallType unwrappedCallType = wrapper->m_unwrappedObject->getCallData(unwrappedCallData); ASSERT(unwrappedCallType != CallTypeNone); - JSValue unwrappedResult = JSC::call(wrapper->unwrappedExecState(), wrapper->m_unwrappedObject, unwrappedCallType, unwrappedCallData, preparedThisValue, preparedArgs); + // FIXME: Quarantined objects are all in the debuggerWorld(), for now. Instead, we should remove the quarantined objects, & replace them with an isolated world? + JSValue unwrappedResult = callInWorld(wrapper->unwrappedExecState(), wrapper->m_unwrappedObject, unwrappedCallType, unwrappedCallData, preparedThisValue, preparedArgs, debuggerWorld()); JSValue result = wrapper->wrapOutgoingValue(wrapper->unwrappedExecState(), unwrappedResult); @@ -272,8 +321,16 @@ void JSQuarantinedObjectWrapper::getPropertyNames(ExecState*, PropertyNameArray& { if (!allowsGetPropertyNames()) return; - + m_unwrappedObject->getPropertyNames(unwrappedExecState(), array); } +void JSQuarantinedObjectWrapper::getOwnPropertyNames(ExecState*, PropertyNameArray& array) +{ + if (!allowsGetPropertyNames()) + return; + + m_unwrappedObject->getOwnPropertyNames(unwrappedExecState(), array); +} + } // namespace WebCore diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSQuarantinedObjectWrapper.h b/src/3rdparty/webkit/WebCore/bindings/js/JSQuarantinedObjectWrapper.h index bf8fddbe8..9f624951c 100644 --- a/src/3rdparty/webkit/WebCore/bindings/js/JSQuarantinedObjectWrapper.h +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSQuarantinedObjectWrapper.h @@ -1,5 +1,5 @@ /* - * Copyright (C) 2008 Apple Inc. All rights reserved. + * Copyright (C) 2008, 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 @@ -47,20 +47,24 @@ namespace WebCore { static PassRefPtr<JSC::Structure> createStructure(JSC::JSValue proto) { - return JSC::Structure::create(proto, JSC::TypeInfo(JSC::ObjectType, JSC::ImplementsHasInstance | JSC::OverridesHasInstance)); + return JSC::Structure::create(proto, JSC::TypeInfo(JSC::ObjectType, StructureFlags)); } protected: - JSQuarantinedObjectWrapper(JSC::ExecState* unwrappedExec, JSC::JSObject* unwrappedObject, PassRefPtr<JSC::Structure>); + static const unsigned StructureFlags = JSC::OverridesGetOwnPropertySlot | JSC::ImplementsHasInstance | JSC::OverridesHasInstance | JSC::OverridesMarkChildren | JSC::OverridesGetPropertyNames | JSC::JSObject::StructureFlags; - virtual void mark(); + JSQuarantinedObjectWrapper(JSC::ExecState* unwrappedExec, JSC::JSObject* unwrappedObject, NonNullPassRefPtr<JSC::Structure>); + + virtual void markChildren(JSC::MarkStack&); private: virtual bool getOwnPropertySlot(JSC::ExecState*, const JSC::Identifier&, JSC::PropertySlot&); virtual bool getOwnPropertySlot(JSC::ExecState*, unsigned, JSC::PropertySlot&); + virtual bool getOwnPropertyDescriptor(JSC::ExecState*, const JSC::Identifier&, JSC::PropertyDescriptor&); virtual void put(JSC::ExecState*, const JSC::Identifier&, JSC::JSValue, JSC::PutPropertySlot&); virtual void put(JSC::ExecState*, unsigned, JSC::JSValue); + virtual bool defineOwnProperty(JSC::ExecState*, const JSC::Identifier& propertyName, JSC::PropertyDescriptor&, bool shouldThrow); virtual bool deleteProperty(JSC::ExecState*, const JSC::Identifier&); virtual bool deleteProperty(JSC::ExecState*, unsigned); @@ -69,8 +73,9 @@ namespace WebCore { virtual JSC::ConstructType getConstructData(JSC::ConstructData&); virtual bool hasInstance(JSC::ExecState*, JSC::JSValue, JSC::JSValue proto); - + virtual void getPropertyNames(JSC::ExecState*, JSC::PropertyNameArray&); + virtual void getOwnPropertyNames(JSC::ExecState*, JSC::PropertyNameArray&); virtual JSC::UString className() const { return m_unwrappedObject->className(); } diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSSQLTransactionCustom.cpp b/src/3rdparty/webkit/WebCore/bindings/js/JSSQLTransactionCustom.cpp index 30d59aada..e02240193 100644 --- a/src/3rdparty/webkit/WebCore/bindings/js/JSSQLTransactionCustom.cpp +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSSQLTransactionCustom.cpp @@ -44,6 +44,11 @@ namespace WebCore { JSValue JSSQLTransaction::executeSql(ExecState* exec, const ArgList& args) { + if (args.isEmpty()) { + setDOMException(exec, SYNTAX_ERR); + return jsUndefined(); + } + String sqlStatement = args.at(0).toString(exec); if (exec->hadException()) return jsUndefined(); @@ -90,8 +95,7 @@ JSValue JSSQLTransaction::executeSql(ExecState* exec, const ArgList& args) return jsUndefined(); } - if (Frame* frame = asJSDOMWindow(exec->dynamicGlobalObject())->impl()->frame()) - callback = JSCustomSQLStatementCallback::create(object, frame); + callback = JSCustomSQLStatementCallback::create(object, static_cast<JSDOMGlobalObject*>(exec->dynamicGlobalObject())); } RefPtr<SQLStatementErrorCallback> errorCallback; @@ -102,8 +106,7 @@ JSValue JSSQLTransaction::executeSql(ExecState* exec, const ArgList& args) return jsUndefined(); } - if (Frame* frame = asJSDOMWindow(exec->dynamicGlobalObject())->impl()->frame()) - errorCallback = JSCustomSQLStatementErrorCallback::create(object, frame); + errorCallback = JSCustomSQLStatementErrorCallback::create(object, static_cast<JSDOMGlobalObject*>(exec->dynamicGlobalObject())); } ExceptionCode ec = 0; diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSSVGElementInstanceCustom.cpp b/src/3rdparty/webkit/WebCore/bindings/js/JSSVGElementInstanceCustom.cpp index 055368e3a..ba1cf2270 100644 --- a/src/3rdparty/webkit/WebCore/bindings/js/JSSVGElementInstanceCustom.cpp +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSSVGElementInstanceCustom.cpp @@ -1,5 +1,6 @@ /* * Copyright (C) 2008 Nikolas Zimmermann <zimmermann@kde.org> + * 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 @@ -37,37 +38,33 @@ using namespace JSC; namespace WebCore { -void JSSVGElementInstance::mark() +void JSSVGElementInstance::markChildren(MarkStack& markStack) { - Base::mark(); + Base::markChildren(markStack); // Mark the wrapper for our corresponding element, so it can mark its event handlers. JSNode* correspondingWrapper = getCachedDOMNodeWrapper(impl()->correspondingElement()->document(), impl()->correspondingElement()); - if (correspondingWrapper && !correspondingWrapper->marked()) - correspondingWrapper->mark(); + if (correspondingWrapper) + markStack.append(correspondingWrapper); } JSValue JSSVGElementInstance::addEventListener(ExecState* exec, const ArgList& args) { - JSDOMGlobalObject* globalObject = toJSDOMGlobalObject(impl()->scriptExecutionContext()); - if (!globalObject) + JSValue listener = args.at(1); + if (!listener.isObject()) return jsUndefined(); - if (RefPtr<JSEventListener> listener = globalObject->findOrCreateJSEventListener(args.at(1))) - impl()->addEventListener(args.at(0).toString(exec), listener.release(), args.at(2).toBoolean(exec)); - + impl()->addEventListener(args.at(0).toString(exec), JSEventListener::create(asObject(listener), false, currentWorld(exec)), args.at(2).toBoolean(exec)); return jsUndefined(); } JSValue JSSVGElementInstance::removeEventListener(ExecState* exec, const ArgList& args) { - JSDOMGlobalObject* globalObject = toJSDOMGlobalObject(impl()->scriptExecutionContext()); - if (!globalObject) + JSValue listener = args.at(1); + if (!listener.isObject()) return jsUndefined(); - if (JSEventListener* listener = globalObject->findJSEventListener(args.at(1))) - impl()->removeEventListener(args.at(0).toString(exec), listener, args.at(2).toBoolean(exec)); - + impl()->removeEventListener(args.at(0).toString(exec), JSEventListener::create(asObject(listener), false, currentWorld(exec)).get(), args.at(2).toBoolean(exec)); return jsUndefined(); } diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSSharedWorkerConstructor.cpp b/src/3rdparty/webkit/WebCore/bindings/js/JSSharedWorkerConstructor.cpp index a3122258d..c05b3d2fe 100644 --- a/src/3rdparty/webkit/WebCore/bindings/js/JSSharedWorkerConstructor.cpp +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSSharedWorkerConstructor.cpp @@ -37,6 +37,7 @@ #include "JSDOMWindowCustom.h" #include "JSSharedWorker.h" #include "SharedWorker.h" +#include <runtime/Error.h> using namespace JSC; @@ -45,30 +46,35 @@ namespace WebCore { const ClassInfo JSSharedWorkerConstructor::s_info = { "SharedWorkerConstructor", 0, 0, 0 }; JSSharedWorkerConstructor::JSSharedWorkerConstructor(ExecState* exec, JSDOMGlobalObject* globalObject) - : DOMConstructorObject(JSSharedWorkerConstructor::createStructure(globalObject->objectPrototype())) + : DOMConstructorObject(JSSharedWorkerConstructor::createStructure(globalObject->objectPrototype()), globalObject) { putDirect(exec->propertyNames().prototype, JSSharedWorkerPrototype::self(exec, globalObject), None); // Host functions have a length property describing the number of expected arguments. putDirect(exec->propertyNames().length, jsNumber(exec, 2), ReadOnly|DontDelete|DontEnum); } -static JSObject* constructSharedWorker(ExecState* exec, JSObject*, const ArgList& args) +static JSObject* constructSharedWorker(ExecState* exec, JSObject* constructor, const ArgList& args) { - if (args.size() < 2) + JSSharedWorkerConstructor* jsConstructor = static_cast<JSSharedWorkerConstructor*>(constructor); + + if (args.size() < 1) return throwError(exec, SyntaxError, "Not enough arguments"); UString scriptURL = args.at(0).toString(exec); - UString name = args.at(1).toString(exec); + UString name; + if (args.size() > 1) + name = args.at(1).toString(exec); + if (exec->hadException()) return 0; - ScriptExecutionContext* context = static_cast<JSDOMGlobalObject*>(exec->dynamicGlobalObject())->scriptExecutionContext(); + // 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(); ExceptionCode ec = 0; - RefPtr<SharedWorker> worker = SharedWorker::create(scriptURL, name, context, ec); + RefPtr<SharedWorker> worker = SharedWorker::create(scriptURL, name, window->document(), ec); setDOMException(exec, ec); - // FIXME: toJS() creates an object whose prototype is derived from lexicalGlobalScope, which is incorrect (Bug 27088) - return asObject(toJS(exec, worker.release())); + return asObject(toJS(exec, jsConstructor->globalObject(), worker.release())); } ConstructType JSSharedWorkerConstructor::getConstructData(ConstructData& constructData) diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSSharedWorkerCustom.cpp b/src/3rdparty/webkit/WebCore/bindings/js/JSSharedWorkerCustom.cpp index 8553298ea..4617087ea 100644 --- a/src/3rdparty/webkit/WebCore/bindings/js/JSSharedWorkerCustom.cpp +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSSharedWorkerCustom.cpp @@ -41,15 +41,12 @@ using namespace JSC; namespace WebCore { -void JSSharedWorker::mark() +void JSSharedWorker::markChildren(MarkStack& markStack) { - Base::mark(); + Base::markChildren(markStack); - if (MessagePort* port = impl()->port()) { - DOMObject* wrapper = getCachedDOMObjectWrapper(*Heap::heap(this)->globalData(), port); - if (wrapper && !wrapper->marked()) - wrapper->mark(); - } + if (MessagePort* port = impl()->port()) + markDOMObjectWrapper(markStack, *Heap::heap(this)->globalData(), port); } } // namespace WebCore diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSStorageCustom.cpp b/src/3rdparty/webkit/WebCore/bindings/js/JSStorageCustom.cpp index 2d2d0f845..e416d358c 100644 --- a/src/3rdparty/webkit/WebCore/bindings/js/JSStorageCustom.cpp +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSStorageCustom.cpp @@ -64,14 +64,13 @@ bool JSStorage::deleteProperty(ExecState* exec, const Identifier& propertyName) return true; } -void JSStorage::getPropertyNames(ExecState* exec, PropertyNameArray& propertyNames) +void JSStorage::getOwnPropertyNames(ExecState* exec, PropertyNameArray& propertyNames) { - ExceptionCode ec; unsigned length = m_impl->length(); for (unsigned i = 0; i < length; ++i) - propertyNames.add(Identifier(exec, m_impl->key(i, ec))); + propertyNames.add(Identifier(exec, m_impl->key(i))); - Base::getPropertyNames(exec, propertyNames); + Base::getOwnPropertyNames(exec, propertyNames); } bool JSStorage::putDelegate(ExecState* exec, const Identifier& propertyName, JSValue value, PutPropertySlot&) diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSStyleSheetCustom.cpp b/src/3rdparty/webkit/WebCore/bindings/js/JSStyleSheetCustom.cpp index 00dacee1b..d711b6fe3 100644 --- a/src/3rdparty/webkit/WebCore/bindings/js/JSStyleSheetCustom.cpp +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSStyleSheetCustom.cpp @@ -1,5 +1,5 @@ /* - * Copyright (C) 2007, 2008 Apple Inc. All rights reserved. + * Copyright (C) 2007, 2008, 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 @@ -52,20 +52,25 @@ JSValue toJS(ExecState* exec, JSDOMGlobalObject* globalObject, StyleSheet* style return wrapper; } -void JSStyleSheet::mark() +void JSStyleSheet::markChildren(MarkStack& markStack) { - Base::mark(); + Base::markChildren(markStack); + + StyleSheet* sheet = impl(); + JSGlobalData& globalData = *Heap::heap(this)->globalData(); + + unsigned length = sheet->length(); + for (unsigned i = 0; i < length; ++i) + markDOMObjectWrapper(markStack, globalData, sheet->item(i)); // This prevents us from having a style sheet with a dangling ownerNode pointer. // A better solution would be to handle this on the DOM side -- if the style sheet // is kept around, then we want the node to stay around too. One possibility would // be to make ref/deref on the style sheet ref/deref the node instead, but there's // a lot of disentangling of the CSS DOM objects that would need to happen first. - if (Node* ownerNode = impl()->ownerNode()) { - if (JSNode* ownerNodeWrapper = getCachedDOMNodeWrapper(ownerNode->document(), ownerNode)) { - if (!ownerNodeWrapper->marked()) - ownerNodeWrapper->mark(); - } + if (Node* ownerNode = sheet->ownerNode()) { + if (JSNode* ownerNodeWrapper = getCachedDOMNodeWrapper(ownerNode->document(), ownerNode)) + markStack.append(ownerNodeWrapper); } } diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSStyleSheetListCustom.cpp b/src/3rdparty/webkit/WebCore/bindings/js/JSStyleSheetListCustom.cpp index 1da641820..7bf93890d 100644 --- a/src/3rdparty/webkit/WebCore/bindings/js/JSStyleSheetListCustom.cpp +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSStyleSheetListCustom.cpp @@ -1,5 +1,5 @@ /* - * Copyright (C) 2007 Apple Inc. All rights reserved. + * Copyright (C) 2007, 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 @@ -35,6 +35,18 @@ using namespace JSC; namespace WebCore { +void JSStyleSheetList::markChildren(MarkStack& markStack) +{ + Base::markChildren(markStack); + + StyleSheetList* list = impl(); + JSGlobalData& globalData = *Heap::heap(this)->globalData(); + + unsigned length = list->length(); + for (unsigned i = 0; i < length; ++i) + markDOMObjectWrapper(markStack, globalData, list->item(i)); +} + bool JSStyleSheetList::canGetItemsForName(ExecState*, StyleSheetList* styleSheetList, const Identifier& propertyName) { return styleSheetList->getNamedItem(propertyName); diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSTreeWalkerCustom.cpp b/src/3rdparty/webkit/WebCore/bindings/js/JSTreeWalkerCustom.cpp index 58eea7252..f879cf437 100644 --- a/src/3rdparty/webkit/WebCore/bindings/js/JSTreeWalkerCustom.cpp +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSTreeWalkerCustom.cpp @@ -1,5 +1,5 @@ /* - * Copyright (C) 2006, 2008 Apple Inc. All rights reserved. + * Copyright (C) 2006, 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 @@ -29,12 +29,12 @@ using namespace JSC; namespace WebCore { -void JSTreeWalker::mark() +void JSTreeWalker::markChildren(MarkStack& markStack) { + Base::markChildren(markStack); + if (NodeFilter* filter = m_impl->filter()) - filter->mark(); - - Base::mark(); + filter->markAggregate(markStack); } JSValue JSTreeWalker::parentNode(ExecState* exec, const ArgList&) diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSWebSocketConstructor.cpp b/src/3rdparty/webkit/WebCore/bindings/js/JSWebSocketConstructor.cpp new file mode 100644 index 000000000..5b347651f --- /dev/null +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSWebSocketConstructor.cpp @@ -0,0 +1,93 @@ +/* + * Copyright (C) 2009 Google 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: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * 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. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "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 THE COPYRIGHT + * OWNER 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(WEB_SOCKETS) + +#include "JSWebSocketConstructor.h" + +#include "JSWebSocket.h" +#include "ScriptExecutionContext.h" +#include "WebSocket.h" +#include <runtime/Error.h> + +using namespace JSC; + +namespace WebCore { + +ASSERT_CLASS_FITS_IN_CELL(JSWebSocketConstructor); + +const ClassInfo JSWebSocketConstructor::s_info = { "WebSocketConstructor", 0, 0, 0 }; + +JSWebSocketConstructor::JSWebSocketConstructor(ExecState* exec, JSDOMGlobalObject* globalObject) + : DOMConstructorObject(JSWebSocketConstructor::createStructure(globalObject->objectPrototype()), globalObject) +{ + putDirect(exec->propertyNames().prototype, JSWebSocketPrototype::self(exec, globalObject), None); + putDirect(exec->propertyNames().length, jsNumber(exec, 1), ReadOnly | DontDelete | DontEnum); +} + +static JSObject* constructWebSocket(ExecState* exec, JSObject* constructor, const ArgList& args) +{ + JSWebSocketConstructor* jsConstructor = static_cast<JSWebSocketConstructor*>(constructor); + ScriptExecutionContext* context = jsConstructor->scriptExecutionContext(); + if (!context) + return throwError(exec, ReferenceError, "WebSocket constructor associated document is unavailable"); + + if (args.size() == 0) + return throwError(exec, SyntaxError, "Not enough arguments"); + + const String& urlString = args.at(0).toString(exec); + if (exec->hadException()) + return throwError(exec, SyntaxError, "wrong URL"); + const KURL& url = context->completeURL(urlString); + RefPtr<WebSocket> webSocket = WebSocket::create(context); + ExceptionCode ec = 0; + if (args.size() < 2) + webSocket->connect(url, ec); + else { + const String& protocol = args.at(1).toString(exec); + if (exec->hadException()) + return 0; + webSocket->connect(url, protocol, ec); + } + setDOMException(exec, ec); + return CREATE_DOM_OBJECT_WRAPPER(exec, jsConstructor->globalObject(), WebSocket, webSocket.get()); +} + +ConstructType JSWebSocketConstructor::getConstructData(ConstructData& constructData) +{ + constructData.native.function = constructWebSocket; + return ConstructTypeHost; +} + +} // namespace WebCore + +#endif diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSWebSocketConstructor.h b/src/3rdparty/webkit/WebCore/bindings/js/JSWebSocketConstructor.h new file mode 100644 index 000000000..069647a7a --- /dev/null +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSWebSocketConstructor.h @@ -0,0 +1,50 @@ +/* + * Copyright (C) 2009 Google 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: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * 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. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "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 THE COPYRIGHT + * OWNER 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. + */ + +#ifndef JSWebSocketConstructor_h +#define JSWebSocketConstructor_h + +#include "JSDOMBinding.h" + +namespace WebCore { + +class JSWebSocketConstructor : public DOMConstructorObject { + public: + JSWebSocketConstructor(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 // JSWebSocketConstructor_h diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSWebSocketCustom.cpp b/src/3rdparty/webkit/WebCore/bindings/js/JSWebSocketCustom.cpp new file mode 100644 index 000000000..33c3fcd58 --- /dev/null +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSWebSocketCustom.cpp @@ -0,0 +1,85 @@ +/* + * Copyright (C) 2009 Google Inc. All rights reserved. + * 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: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * 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. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "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 THE COPYRIGHT + * OWNER 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(WEB_SOCKETS) + +#include "JSWebSocket.h" + +#include "KURL.h" +#include "JSEventListener.h" +#include "WebSocket.h" +#include "NotImplemented.h" +#include <runtime/Error.h> + +using namespace JSC; + +namespace WebCore { + +// Custom functions +JSValue JSWebSocket::send(ExecState* exec, const ArgList& args) +{ + if (args.size() < 1) + return throwError(exec, SyntaxError, "Not enough arguments"); + + const String& msg = args.at(0).toString(exec); + if (exec->hadException()) + return throwError(exec, SyntaxError, "bad message data."); + ExceptionCode ec = 0; + JSValue ret = jsBoolean(impl()->send(msg, ec)); + setDOMException(exec, ec); + return ret; +} + +JSValue JSWebSocket::addEventListener(ExecState* exec, const ArgList& args) +{ + JSValue listener = args.at(1); + if (!listener.isObject()) + return jsUndefined(); + + impl()->addEventListener(args.at(0).toString(exec), JSEventListener::create(asObject(listener), false, currentWorld(exec)), args.at(2).toBoolean(exec)); + return jsUndefined(); +} + +JSValue JSWebSocket::removeEventListener(ExecState* exec, const ArgList& args) +{ + JSValue listener = args.at(1); + if (!listener.isObject()) + return jsUndefined(); + + impl()->removeEventListener(args.at(0).toString(exec), JSEventListener::create(asObject(listener), false, currentWorld(exec)).get(), args.at(2).toBoolean(exec)); + return jsUndefined(); +} + +} // namespace WebCore + +#endif diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSWorkerConstructor.cpp b/src/3rdparty/webkit/WebCore/bindings/js/JSWorkerConstructor.cpp index e1686f787..69c05e76b 100644 --- a/src/3rdparty/webkit/WebCore/bindings/js/JSWorkerConstructor.cpp +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSWorkerConstructor.cpp @@ -34,6 +34,7 @@ #include "JSDOMWindowCustom.h" #include "JSWorker.h" #include "Worker.h" +#include <runtime/Error.h> using namespace JSC; @@ -62,7 +63,12 @@ static JSObject* constructWorker(ExecState* exec, JSObject* constructor, const A // See section 4.8.2 step 14 of WebWorkers for why this is the lexicalGlobalObject. DOMWindow* window = asJSDOMWindow(exec->lexicalGlobalObject())->impl(); - RefPtr<Worker> worker = Worker::create(scriptURL, window->document()); + ExceptionCode ec = 0; + RefPtr<Worker> worker = Worker::create(scriptURL, window->document(), ec); + if (ec) { + setDOMException(exec, ec); + return 0; + } return asObject(toJS(exec, jsConstructor->globalObject(), worker.release())); } diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSWorkerContextBase.cpp b/src/3rdparty/webkit/WebCore/bindings/js/JSWorkerContextBase.cpp index 622da7056..741a2692f 100644 --- a/src/3rdparty/webkit/WebCore/bindings/js/JSWorkerContextBase.cpp +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSWorkerContextBase.cpp @@ -32,6 +32,7 @@ #include "JSWorkerContextBase.h" #include "JSDedicatedWorkerContext.h" +#include "JSSharedWorkerContext.h" #include "JSWorkerContext.h" #include "WorkerContext.h" @@ -43,7 +44,7 @@ ASSERT_CLASS_FITS_IN_CELL(JSWorkerContextBase); const ClassInfo JSWorkerContextBase::s_info = { "WorkerContext", 0, 0, 0 }; -JSWorkerContextBase::JSWorkerContextBase(PassRefPtr<JSC::Structure> structure, PassRefPtr<WorkerContext> impl) +JSWorkerContextBase::JSWorkerContextBase(NonNullPassRefPtr<JSC::Structure> structure, PassRefPtr<WorkerContext> impl) : JSDOMGlobalObject(structure, new JSDOMGlobalObjectData, this) , m_impl(impl) { @@ -83,10 +84,26 @@ JSDedicatedWorkerContext* toJSDedicatedWorkerContext(JSValue value) return 0; } +#if ENABLE(SHARED_WORKERS) +JSSharedWorkerContext* toJSSharedWorkerContext(JSValue value) +{ + if (!value.isObject()) + return 0; + const ClassInfo* classInfo = asObject(value)->classInfo(); + if (classInfo == &JSSharedWorkerContext::s_info) + return static_cast<JSSharedWorkerContext*>(asObject(value)); + return 0; +} +#endif + JSWorkerContext* toJSWorkerContext(JSValue value) { - // When we support shared workers, we'll add code to test for SharedWorkerContext too. - return toJSDedicatedWorkerContext(value); + JSWorkerContext* context = toJSDedicatedWorkerContext(value); +#if ENABLE(SHARED_WORKERS) + if (!context) + context = toJSSharedWorkerContext(value); +#endif + return context; } } // namespace WebCore diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSWorkerContextBase.h b/src/3rdparty/webkit/WebCore/bindings/js/JSWorkerContextBase.h index f7ad17f77..45238f1f8 100644 --- a/src/3rdparty/webkit/WebCore/bindings/js/JSWorkerContextBase.h +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSWorkerContextBase.h @@ -34,13 +34,14 @@ namespace WebCore { class JSDedicatedWorkerContext; + class JSSharedWorkerContext; class JSWorkerContext; class WorkerContext; class JSWorkerContextBase : public JSDOMGlobalObject { typedef JSDOMGlobalObject Base; public: - JSWorkerContextBase(PassRefPtr<JSC::Structure>, PassRefPtr<WorkerContext>); + JSWorkerContextBase(NonNullPassRefPtr<JSC::Structure>, PassRefPtr<WorkerContext>); virtual ~JSWorkerContextBase(); virtual const JSC::ClassInfo* classInfo() const { return &s_info; } @@ -61,6 +62,10 @@ namespace WebCore { JSDedicatedWorkerContext* toJSDedicatedWorkerContext(JSC::JSValue); JSWorkerContext* toJSWorkerContext(JSC::JSValue); +#if ENABLE(SHARED_WORKERS) + JSSharedWorkerContext* toJSSharedWorkerContext(JSC::JSValue); +#endif + } // namespace WebCore #endif // ENABLE(WORKERS) diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSWorkerContextCustom.cpp b/src/3rdparty/webkit/WebCore/bindings/js/JSWorkerContextCustom.cpp index 6a7602d3d..490d9b138 100644 --- a/src/3rdparty/webkit/WebCore/bindings/js/JSWorkerContextCustom.cpp +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSWorkerContextCustom.cpp @@ -43,30 +43,26 @@ #include "WorkerNavigator.h" #include <interpreter/Interpreter.h> +#if ENABLE(EVENTSOURCE) +#include "JSEventSourceConstructor.h" +#endif + using namespace JSC; namespace WebCore { -void JSWorkerContext::mark() +void JSWorkerContext::markChildren(MarkStack& markStack) { - Base::mark(); + Base::markChildren(markStack); JSGlobalData& globalData = *this->globalData(); - markActiveObjectsForContext(globalData, scriptExecutionContext()); + markActiveObjectsForContext(markStack, globalData, scriptExecutionContext()); - markDOMObjectWrapper(globalData, impl()->optionalLocation()); - markDOMObjectWrapper(globalData, impl()->optionalNavigator()); + markDOMObjectWrapper(markStack, globalData, impl()->optionalLocation()); + markDOMObjectWrapper(markStack, globalData, impl()->optionalNavigator()); - markIfNotNull(impl()->onerror()); - - typedef WorkerContext::EventListenersMap EventListenersMap; - typedef WorkerContext::ListenerVector ListenerVector; - EventListenersMap& eventListeners = impl()->eventListeners(); - for (EventListenersMap::iterator mapIter = eventListeners.begin(); mapIter != eventListeners.end(); ++mapIter) { - for (ListenerVector::iterator vecIter = mapIter->second.begin(); vecIter != mapIter->second.end(); ++vecIter) - (*vecIter)->markJSFunction(); - } + impl()->markEventListeners(markStack); } bool JSWorkerContext::getOwnPropertySlotDelegate(ExecState* exec, const Identifier& propertyName, PropertySlot& slot) @@ -77,6 +73,21 @@ bool JSWorkerContext::getOwnPropertySlotDelegate(ExecState* exec, const Identifi return false; } +bool JSWorkerContext::getOwnPropertyDescriptorDelegate(ExecState* exec, const Identifier& propertyName, PropertyDescriptor& descriptor) +{ + // Look for overrides before looking at any of our own properties. + if (JSGlobalObject::getOwnPropertyDescriptor(exec, propertyName, descriptor)) + return true; + return false; +} + +#if ENABLE(EVENTSOURCE) +JSValue JSWorkerContext::eventSource(ExecState* exec) const +{ + return getDOMConstructor<JSEventSourceConstructor>(exec, this); +} +#endif + JSValue JSWorkerContext::xmlHttpRequest(ExecState* exec) const { return getDOMConstructor<JSXMLHttpRequestConstructor>(exec, this); @@ -107,25 +118,27 @@ JSValue JSWorkerContext::importScripts(ExecState* exec, const ArgList& args) JSValue JSWorkerContext::addEventListener(ExecState* exec, const ArgList& args) { - RefPtr<JSEventListener> listener = findOrCreateJSEventListener(args.at(1)); - if (!listener) + JSValue listener = args.at(1); + if (!listener.isObject()) return jsUndefined(); - impl()->addEventListener(args.at(0).toString(exec), listener.release(), args.at(2).toBoolean(exec)); + + impl()->addEventListener(args.at(0).toString(exec), JSEventListener::create(asObject(listener), false, currentWorld(exec)), args.at(2).toBoolean(exec)); return jsUndefined(); } JSValue JSWorkerContext::removeEventListener(ExecState* exec, const ArgList& args) { - JSEventListener* listener = findJSEventListener(args.at(1)); - if (!listener) + JSValue listener = args.at(1); + if (!listener.isObject()) return jsUndefined(); - impl()->removeEventListener(args.at(0).toString(exec), listener, args.at(2).toBoolean(exec)); + + impl()->removeEventListener(args.at(0).toString(exec), JSEventListener::create(asObject(listener), false, currentWorld(exec)).get(), args.at(2).toBoolean(exec)); return jsUndefined(); } JSValue JSWorkerContext::setTimeout(ExecState* exec, const ArgList& args) { - ScheduledAction* action = ScheduledAction::create(exec, args); + ScheduledAction* action = ScheduledAction::create(exec, args, currentWorld(exec)); if (exec->hadException()) return jsUndefined(); int delay = args.at(1).toInt32(exec); @@ -134,7 +147,7 @@ JSValue JSWorkerContext::setTimeout(ExecState* exec, const ArgList& args) JSValue JSWorkerContext::setInterval(ExecState* exec, const ArgList& args) { - ScheduledAction* action = ScheduledAction::create(exec, args); + ScheduledAction* action = ScheduledAction::create(exec, args, currentWorld(exec)); if (exec->hadException()) return jsUndefined(); int delay = args.at(1).toInt32(exec); diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSWorkerCustom.cpp b/src/3rdparty/webkit/WebCore/bindings/js/JSWorkerCustom.cpp index 6010f8398..09b881af9 100644 --- a/src/3rdparty/webkit/WebCore/bindings/js/JSWorkerCustom.cpp +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSWorkerCustom.cpp @@ -30,17 +30,16 @@ #include "JSWorker.h" #include "JSDOMGlobalObject.h" +#include "JSMessagePortCustom.h" #include "Worker.h" using namespace JSC; namespace WebCore { - -void JSWorker::mark() -{ - Base::mark(); - markIfNotNull(static_cast<Worker*>(impl())->onmessage()); +JSC::JSValue JSWorker::postMessage(JSC::ExecState* exec, const JSC::ArgList& args) +{ + return handlePostMessage(exec, args, impl()); } } // namespace WebCore diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSXMLHttpRequestConstructor.cpp b/src/3rdparty/webkit/WebCore/bindings/js/JSXMLHttpRequestConstructor.cpp index a644c9e8e..91fff9ab1 100644 --- a/src/3rdparty/webkit/WebCore/bindings/js/JSXMLHttpRequestConstructor.cpp +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSXMLHttpRequestConstructor.cpp @@ -23,6 +23,7 @@ #include "JSXMLHttpRequest.h" #include "ScriptExecutionContext.h" #include "XMLHttpRequest.h" +#include <runtime/Error.h> using namespace JSC; diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSXMLHttpRequestCustom.cpp b/src/3rdparty/webkit/WebCore/bindings/js/JSXMLHttpRequestCustom.cpp index 06a58175d..7ee272018 100644 --- a/src/3rdparty/webkit/WebCore/bindings/js/JSXMLHttpRequestCustom.cpp +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSXMLHttpRequestCustom.cpp @@ -49,30 +49,14 @@ using namespace JSC; namespace WebCore { -void JSXMLHttpRequest::mark() +void JSXMLHttpRequest::markChildren(MarkStack& markStack) { - Base::mark(); + Base::markChildren(markStack); - if (XMLHttpRequestUpload* upload = m_impl->optionalUpload()) { - DOMObject* wrapper = getCachedDOMObjectWrapper(*Heap::heap(this)->globalData(), upload); - if (wrapper && !wrapper->marked()) - wrapper->mark(); - } + if (XMLHttpRequestUpload* upload = m_impl->optionalUpload()) + markDOMObjectWrapper(markStack, *Heap::heap(this)->globalData(), upload); - markIfNotNull(m_impl->onreadystatechange()); - markIfNotNull(m_impl->onabort()); - markIfNotNull(m_impl->onerror()); - markIfNotNull(m_impl->onload()); - markIfNotNull(m_impl->onloadstart()); - markIfNotNull(m_impl->onprogress()); - - typedef XMLHttpRequest::EventListenersMap EventListenersMap; - typedef XMLHttpRequest::ListenerVector ListenerVector; - EventListenersMap& eventListeners = m_impl->eventListeners(); - for (EventListenersMap::iterator mapIter = eventListeners.begin(); mapIter != eventListeners.end(); ++mapIter) { - for (ListenerVector::iterator vecIter = mapIter->second.begin(); vecIter != mapIter->second.end(); ++vecIter) - (*vecIter)->markJSFunction(); - } + m_impl->markEventListeners(markStack); } // Custom functions @@ -123,9 +107,9 @@ JSValue JSXMLHttpRequest::send(ExecState* exec, const ArgList& args) JSValue val = args.at(0); if (val.isUndefinedOrNull()) impl()->send(ec); - else if (val.isObject(&JSDocument::s_info)) + else if (val.inherits(&JSDocument::s_info)) impl()->send(toDocument(val), ec); - else if (val.isObject(&JSFile::s_info)) + else if (val.inherits(&JSFile::s_info)) impl()->send(toFile(val), ec); else impl()->send(val.toString(exec), ec); @@ -165,25 +149,21 @@ JSValue JSXMLHttpRequest::overrideMimeType(ExecState* exec, const ArgList& args) JSValue JSXMLHttpRequest::addEventListener(ExecState* exec, const ArgList& args) { - JSDOMGlobalObject* globalObject = toJSDOMGlobalObject(impl()->scriptExecutionContext()); - if (!globalObject) - return jsUndefined(); - RefPtr<JSEventListener> listener = globalObject->findOrCreateJSEventListener(args.at(1)); - if (!listener) + JSValue listener = args.at(1); + if (!listener.isObject()) return jsUndefined(); - impl()->addEventListener(args.at(0).toString(exec), listener.release(), args.at(2).toBoolean(exec)); + + impl()->addEventListener(args.at(0).toString(exec), JSEventListener::create(asObject(listener), false, currentWorld(exec)), args.at(2).toBoolean(exec)); return jsUndefined(); } JSValue JSXMLHttpRequest::removeEventListener(ExecState* exec, const ArgList& args) { - JSDOMGlobalObject* globalObject = toJSDOMGlobalObject(impl()->scriptExecutionContext()); - if (!globalObject) - return jsUndefined(); - JSEventListener* listener = globalObject->findJSEventListener(args.at(1)); - if (!listener) + JSValue listener = args.at(1); + if (!listener.isObject()) return jsUndefined(); - impl()->removeEventListener(args.at(0).toString(exec), listener, args.at(2).toBoolean(exec)); + + impl()->removeEventListener(args.at(0).toString(exec), JSEventListener::create(asObject(listener), false, currentWorld(exec)).get(), args.at(2).toBoolean(exec)); return jsUndefined(); } diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSXMLHttpRequestUploadCustom.cpp b/src/3rdparty/webkit/WebCore/bindings/js/JSXMLHttpRequestUploadCustom.cpp index 597010cef..fa7cfec41 100644 --- a/src/3rdparty/webkit/WebCore/bindings/js/JSXMLHttpRequestUploadCustom.cpp +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSXMLHttpRequestUploadCustom.cpp @@ -41,52 +41,33 @@ using namespace JSC; namespace WebCore { -void JSXMLHttpRequestUpload::mark() +void JSXMLHttpRequestUpload::markChildren(MarkStack& markStack) { - Base::mark(); + Base::markChildren(markStack); - if (XMLHttpRequest* xmlHttpRequest = m_impl->associatedXMLHttpRequest()) { - DOMObject* wrapper = getCachedDOMObjectWrapper(*Heap::heap(this)->globalData(), xmlHttpRequest); - if (wrapper && !wrapper->marked()) - wrapper->mark(); - } + if (XMLHttpRequest* xmlHttpRequest = m_impl->associatedXMLHttpRequest()) + markDOMObjectWrapper(markStack, *Heap::heap(this)->globalData(), xmlHttpRequest); - markIfNotNull(m_impl->onabort()); - markIfNotNull(m_impl->onerror()); - markIfNotNull(m_impl->onload()); - markIfNotNull(m_impl->onloadstart()); - markIfNotNull(m_impl->onprogress()); - - typedef XMLHttpRequestUpload::EventListenersMap EventListenersMap; - typedef XMLHttpRequestUpload::ListenerVector ListenerVector; - EventListenersMap& eventListeners = m_impl->eventListeners(); - for (EventListenersMap::iterator mapIter = eventListeners.begin(); mapIter != eventListeners.end(); ++mapIter) { - for (ListenerVector::iterator vecIter = mapIter->second.begin(); vecIter != mapIter->second.end(); ++vecIter) - (*vecIter)->markJSFunction(); - } + m_impl->markEventListeners(markStack); } JSValue JSXMLHttpRequestUpload::addEventListener(ExecState* exec, const ArgList& args) { - JSDOMGlobalObject* globalObject = toJSDOMGlobalObject(impl()->scriptExecutionContext()); - if (!globalObject) + JSValue listener = args.at(1); + if (!listener.isObject()) return jsUndefined(); - RefPtr<JSEventListener> listener = globalObject->findOrCreateJSEventListener(args.at(1)); - if (!listener) - return jsUndefined(); - impl()->addEventListener(args.at(0).toString(exec), listener.release(), args.at(2).toBoolean(exec)); + + impl()->addEventListener(args.at(0).toString(exec), JSEventListener::create(asObject(listener), false, currentWorld(exec)), args.at(2).toBoolean(exec)); return jsUndefined(); } JSValue JSXMLHttpRequestUpload::removeEventListener(ExecState* exec, const ArgList& args) { - JSDOMGlobalObject* globalObject = toJSDOMGlobalObject(impl()->scriptExecutionContext()); - if (!globalObject) + JSValue listener = args.at(1); + if (!listener.isObject()) return jsUndefined(); - JSEventListener* listener = globalObject->findJSEventListener(args.at(1)); - if (!listener) - return jsUndefined(); - impl()->removeEventListener(args.at(0).toString(exec), listener, args.at(2).toBoolean(exec)); + + impl()->removeEventListener(args.at(0).toString(exec), JSEventListener::create(asObject(listener), false, currentWorld(exec)).get(), args.at(2).toBoolean(exec)); return jsUndefined(); } diff --git a/src/3rdparty/webkit/WebCore/bindings/js/JSXSLTProcessorCustom.cpp b/src/3rdparty/webkit/WebCore/bindings/js/JSXSLTProcessorCustom.cpp index 01e53a6d2..441bbc9a2 100644 --- a/src/3rdparty/webkit/WebCore/bindings/js/JSXSLTProcessorCustom.cpp +++ b/src/3rdparty/webkit/WebCore/bindings/js/JSXSLTProcessorCustom.cpp @@ -49,7 +49,7 @@ namespace WebCore { JSValue JSXSLTProcessor::importStylesheet(ExecState*, const ArgList& args) { JSValue nodeVal = args.at(0); - if (nodeVal.isObject(&JSNode::s_info)) { + if (nodeVal.inherits(&JSNode::s_info)) { JSNode* node = static_cast<JSNode*>(asObject(nodeVal)); impl()->importStylesheet(node->impl()); return jsUndefined(); @@ -62,7 +62,7 @@ JSValue JSXSLTProcessor::transformToFragment(ExecState* exec, const ArgList& arg { JSValue nodeVal = args.at(0); JSValue docVal = args.at(1); - if (nodeVal.isObject(&JSNode::s_info) && docVal.isObject(&JSDocument::s_info)) { + if (nodeVal.inherits(&JSNode::s_info) && docVal.inherits(&JSDocument::s_info)) { WebCore::Node* node = static_cast<JSNode*>(asObject(nodeVal))->impl(); Document* doc = static_cast<Document*>(static_cast<JSDocument*>(asObject(docVal))->impl()); return toJS(exec, impl()->transformToFragment(node, doc).get()); @@ -74,7 +74,7 @@ JSValue JSXSLTProcessor::transformToFragment(ExecState* exec, const ArgList& arg JSValue JSXSLTProcessor::transformToDocument(ExecState* exec, const ArgList& args) { JSValue nodeVal = args.at(0); - if (nodeVal.isObject(&JSNode::s_info)) { + if (nodeVal.inherits(&JSNode::s_info)) { JSNode* node = static_cast<JSNode*>(asObject(nodeVal)); RefPtr<Document> resultDocument = impl()->transformToDocument(node->impl()); if (resultDocument) diff --git a/src/3rdparty/webkit/WebCore/bindings/js/ScheduledAction.cpp b/src/3rdparty/webkit/WebCore/bindings/js/ScheduledAction.cpp index 9e64bceb9..9a21b6b99 100644 --- a/src/3rdparty/webkit/WebCore/bindings/js/ScheduledAction.cpp +++ b/src/3rdparty/webkit/WebCore/bindings/js/ScheduledAction.cpp @@ -47,7 +47,7 @@ using namespace JSC; namespace WebCore { -ScheduledAction* ScheduledAction::create(ExecState* exec, const ArgList& args) +ScheduledAction* ScheduledAction::create(ExecState* exec, const ArgList& args, DOMWrapperWorld* isolatedWorld) { JSValue v = args.at(0); CallData callData; @@ -55,15 +55,16 @@ ScheduledAction* ScheduledAction::create(ExecState* exec, const ArgList& args) UString string = v.toString(exec); if (exec->hadException()) return 0; - return new ScheduledAction(string); + return new ScheduledAction(string, isolatedWorld); } ArgList argsTail; args.getSlice(2, argsTail); - return new ScheduledAction(v, argsTail); + return new ScheduledAction(v, argsTail, isolatedWorld); } -ScheduledAction::ScheduledAction(JSValue function, const ArgList& args) +ScheduledAction::ScheduledAction(JSValue function, const ArgList& args, DOMWrapperWorld* isolatedWorld) : m_function(function) + , m_isolatedWorld(isolatedWorld) { ArgList::const_iterator end = args.end(); for (ArgList::const_iterator it = args.begin(); it != end; ++it) @@ -102,7 +103,7 @@ void ScheduledAction::executeFunctionInContext(JSGlobalObject* globalObject, JSV args.append(m_args[i]); globalObject->globalData()->timeoutChecker.start(); - call(exec, m_function, callType, callData, thisValue, args); + callInWorld(exec, m_function, callType, callData, thisValue, args, m_isolatedWorld.get()); globalObject->globalData()->timeoutChecker.stop(); if (exec->hadException()) @@ -111,7 +112,7 @@ void ScheduledAction::executeFunctionInContext(JSGlobalObject* globalObject, JSV void ScheduledAction::execute(Document* document) { - JSDOMWindow* window = toJSDOMWindow(document->frame()); + JSDOMWindow* window = toJSDOMWindow(document->frame(), m_isolatedWorld.get()); if (!window) return; @@ -125,7 +126,7 @@ void ScheduledAction::execute(Document* document) executeFunctionInContext(window, window->shell()); Document::updateStyleForAllDocuments(); } else - frame->loader()->executeScript(m_code); + frame->script()->executeScriptInIsolatedWorld(m_isolatedWorld.get(), m_code); frame->script()->setProcessingTimerCallback(false); } diff --git a/src/3rdparty/webkit/WebCore/bindings/js/ScheduledAction.h b/src/3rdparty/webkit/WebCore/bindings/js/ScheduledAction.h index e7d0b750b..4ea727d5f 100644 --- a/src/3rdparty/webkit/WebCore/bindings/js/ScheduledAction.h +++ b/src/3rdparty/webkit/WebCore/bindings/js/ScheduledAction.h @@ -21,6 +21,8 @@ #define ScheduledAction_h #include "PlatformString.h" +#include <JSDOMBinding.h> +#include <runtime/JSCell.h> #include <runtime/Protect.h> #include <wtf/Vector.h> @@ -40,14 +42,15 @@ namespace WebCore { */ class ScheduledAction { public: - static ScheduledAction* create(JSC::ExecState*, const JSC::ArgList&); + static ScheduledAction* create(JSC::ExecState*, const JSC::ArgList&, DOMWrapperWorld* isolatedWorld); void execute(ScriptExecutionContext*); private: - ScheduledAction(JSC::JSValue function, const JSC::ArgList&); - ScheduledAction(const String& code) + ScheduledAction(JSC::JSValue function, const JSC::ArgList&, DOMWrapperWorld* isolatedWorld); + ScheduledAction(const String& code, DOMWrapperWorld* isolatedWorld) : m_code(code) + , m_isolatedWorld(isolatedWorld) { } @@ -60,6 +63,7 @@ namespace WebCore { JSC::ProtectedJSValue m_function; Vector<JSC::ProtectedJSValue> m_args; String m_code; + RefPtr<DOMWrapperWorld> m_isolatedWorld; }; } // namespace WebCore diff --git a/src/3rdparty/webkit/WebCore/bindings/js/ScriptArray.cpp b/src/3rdparty/webkit/WebCore/bindings/js/ScriptArray.cpp index 016c7a702..2c4075a91 100644 --- a/src/3rdparty/webkit/WebCore/bindings/js/ScriptArray.cpp +++ b/src/3rdparty/webkit/WebCore/bindings/js/ScriptArray.cpp @@ -37,8 +37,8 @@ using namespace JSC; namespace WebCore { -ScriptArray::ScriptArray(JSArray* object) - : ScriptObject(object) +ScriptArray::ScriptArray(ScriptState* scriptState, JSArray* object) + : ScriptObject(scriptState, object) { } @@ -51,57 +51,58 @@ static bool handleException(ScriptState* scriptState) return false; } -bool ScriptArray::set(ScriptState* scriptState, unsigned index, const ScriptObject& value) +bool ScriptArray::set(unsigned index, const ScriptObject& value) { JSLock lock(SilenceAssertionsOnly); - jsArray()->put(scriptState, index, value.jsObject()); - return handleException(scriptState); + jsArray()->put(m_scriptState, index, value.jsObject()); + return handleException(m_scriptState); } -bool ScriptArray::set(ScriptState* scriptState, unsigned index, const String& value) +bool ScriptArray::set(unsigned index, const String& value) { JSLock lock(SilenceAssertionsOnly); - jsArray()->put(scriptState, index, jsString(scriptState, value)); - return handleException(scriptState); + jsArray()->put(m_scriptState, index, jsString(m_scriptState, value)); + return handleException(m_scriptState); } -bool ScriptArray::set(ScriptState* scriptState, unsigned index, double value) +bool ScriptArray::set(unsigned index, double value) { JSLock lock(SilenceAssertionsOnly); - jsArray()->put(scriptState, index, jsNumber(scriptState, value)); - return handleException(scriptState); + jsArray()->put(m_scriptState, index, jsNumber(m_scriptState, value)); + return handleException(m_scriptState); } -bool ScriptArray::set(ScriptState* scriptState, unsigned index, long long value) +bool ScriptArray::set(unsigned index, long long value) { JSLock lock(SilenceAssertionsOnly); - jsArray()->put(scriptState, index, jsNumber(scriptState, value)); - return handleException(scriptState); + jsArray()->put(m_scriptState, index, jsNumber(m_scriptState, value)); + return handleException(m_scriptState); } -bool ScriptArray::set(ScriptState* scriptState, unsigned index, int value) +bool ScriptArray::set(unsigned index, int value) { JSLock lock(SilenceAssertionsOnly); - jsArray()->put(scriptState, index, jsNumber(scriptState, value)); - return handleException(scriptState); + jsArray()->put(m_scriptState, index, jsNumber(m_scriptState, value)); + return handleException(m_scriptState); } -bool ScriptArray::set(ScriptState* scriptState, unsigned index, bool value) +bool ScriptArray::set(unsigned index, bool value) { JSLock lock(SilenceAssertionsOnly); - jsArray()->put(scriptState, index, jsBoolean(value)); - return handleException(scriptState); + jsArray()->put(m_scriptState, index, jsBoolean(value)); + return handleException(m_scriptState); } -unsigned ScriptArray::length(ScriptState*) +unsigned ScriptArray::length() { + JSLock lock(SilenceAssertionsOnly); return jsArray()->length(); } ScriptArray ScriptArray::createNew(ScriptState* scriptState) { JSLock lock(SilenceAssertionsOnly); - return ScriptArray(constructEmptyArray(scriptState)); + return ScriptArray(scriptState, constructEmptyArray(scriptState)); } } // namespace WebCore diff --git a/src/3rdparty/webkit/WebCore/bindings/js/ScriptArray.h b/src/3rdparty/webkit/WebCore/bindings/js/ScriptArray.h index 2ba307f2e..92403681e 100644 --- a/src/3rdparty/webkit/WebCore/bindings/js/ScriptArray.h +++ b/src/3rdparty/webkit/WebCore/bindings/js/ScriptArray.h @@ -40,17 +40,17 @@ namespace WebCore { class ScriptArray : public ScriptObject { public: - ScriptArray(JSC::JSArray*); + ScriptArray(ScriptState*, JSC::JSArray*); ScriptArray() {} JSC::JSArray* jsArray() const { return asArray(jsValue()); } - bool set(ScriptState*, unsigned index, const ScriptObject&); - bool set(ScriptState*, unsigned index, const String&); - bool set(ScriptState*, unsigned index, double); - bool set(ScriptState*, unsigned index, long long); - bool set(ScriptState*, unsigned index, int); - bool set(ScriptState*, unsigned index, bool); - unsigned length(ScriptState*); + bool set(unsigned index, const ScriptObject&); + bool set(unsigned index, const String&); + bool set(unsigned index, double); + bool set(unsigned index, long long); + bool set(unsigned index, int); + bool set(unsigned index, bool); + unsigned length(); static ScriptArray createNew(ScriptState*); }; diff --git a/src/3rdparty/webkit/WebCore/bindings/js/ScriptCachedFrameData.cpp b/src/3rdparty/webkit/WebCore/bindings/js/ScriptCachedFrameData.cpp index 885261124..e01324e17 100644 --- a/src/3rdparty/webkit/WebCore/bindings/js/ScriptCachedFrameData.cpp +++ b/src/3rdparty/webkit/WebCore/bindings/js/ScriptCachedFrameData.cpp @@ -48,8 +48,9 @@ ScriptCachedFrameData::ScriptCachedFrameData(Frame* frame) JSLock lock(SilenceAssertionsOnly); ScriptController* scriptController = frame->script(); - if (scriptController->haveWindowShell()) { - m_window = scriptController->windowShell()->window(); + // FIXME: explicitly save and restore isolated worlds' global objects when using the back/forward cache. <rdar://problem/7328111> + if (JSDOMWindowShell* windowShell = scriptController->existingWindowShell(mainThreadNormalWorld())) { + m_window = windowShell->window(); scriptController->attachDebugger(0); } } @@ -70,11 +71,11 @@ void ScriptCachedFrameData::restore(Frame* frame) JSLock lock(SilenceAssertionsOnly); ScriptController* scriptController = frame->script(); - if (scriptController->haveWindowShell()) { - JSDOMWindowShell* windowShell = scriptController->windowShell(); - if (m_window) { + // FIXME: explicitly save and restore isolated worlds' global objects when using the back/forward cache. <rdar://problem/7328111> + if (JSDOMWindowShell* windowShell = scriptController->existingWindowShell(mainThreadNormalWorld())) { + if (m_window) windowShell->setWindow(m_window.get()); - } else { + else { windowShell->setWindow(frame->domWindow()); scriptController->attachDebugger(page->debugger()); windowShell->window()->setProfileGroup(page->group().identifier()); @@ -86,7 +87,7 @@ void ScriptCachedFrameData::clear() { JSLock lock(SilenceAssertionsOnly); - if (!m_window) { + if (m_window) { m_window = 0; gcController().garbageCollectSoon(); } diff --git a/src/3rdparty/webkit/WebCore/bindings/js/ScriptCallFrame.cpp b/src/3rdparty/webkit/WebCore/bindings/js/ScriptCallFrame.cpp index 58168d069..09752d1b2 100644 --- a/src/3rdparty/webkit/WebCore/bindings/js/ScriptCallFrame.cpp +++ b/src/3rdparty/webkit/WebCore/bindings/js/ScriptCallFrame.cpp @@ -40,7 +40,7 @@ namespace WebCore { ScriptCallFrame::ScriptCallFrame(const UString& functionName, const UString& urlString, int lineNumber, const ArgList& args, unsigned skipArgumentCount) : m_functionName(functionName) - , m_sourceURL(urlString) + , m_sourceURL(ParsedURLString, urlString) , m_lineNumber(lineNumber) { size_t argumentCount = args.size(); diff --git a/src/3rdparty/webkit/WebCore/bindings/js/ScriptController.cpp b/src/3rdparty/webkit/WebCore/bindings/js/ScriptController.cpp index a1c43764d..4a1d413bc 100644 --- a/src/3rdparty/webkit/WebCore/bindings/js/ScriptController.cpp +++ b/src/3rdparty/webkit/WebCore/bindings/js/ScriptController.cpp @@ -21,6 +21,7 @@ #include "config.h" #include "ScriptController.h" +#include "CString.h" #include "Event.h" #include "EventNames.h" #include "Frame.h" @@ -33,20 +34,28 @@ #include "ScriptSourceCode.h" #include "ScriptValue.h" #include "Settings.h" +#include "StorageNamespace.h" #include "XSSAuditor.h" #include "npruntime_impl.h" #include "runtime_root.h" #include <debugger/Debugger.h> +#include <runtime/InitializeThreading.h> #include <runtime/JSLock.h> using namespace JSC; namespace WebCore { +void ScriptController::initializeThreading() +{ + JSC::initializeThreading(); +} + ScriptController::ScriptController(Frame* frame) : m_frame(frame) , m_handlerLineNumber(0) , m_sourceURL(0) + , m_inExecuteScript(false) , m_processingTimerCallback(false) , m_paused(false) , m_allowPopupsFromPlugin(false) @@ -69,8 +78,11 @@ ScriptController::ScriptController(Frame* frame) ScriptController::~ScriptController() { - if (m_windowShell) { - m_windowShell = 0; + if (!m_windowShells.isEmpty()) { + for (ShellMap::iterator iter = m_windowShells.begin(); iter != m_windowShells.end(); ++iter) + iter->first->forgetScriptController(this); + + m_windowShells.clear(); // It's likely that releasing the global object has created a lot of garbage. gcController().garbageCollectSoon(); @@ -79,17 +91,12 @@ ScriptController::~ScriptController() disconnectPlatformScriptObjects(); } -ScriptValue ScriptController::evaluate(const ScriptSourceCode& sourceCode) +ScriptValue ScriptController::evaluateInWorld(const ScriptSourceCode& sourceCode, DOMWrapperWorld* world) { const SourceCode& jsSourceCode = sourceCode.jsSourceCode(); String sourceURL = jsSourceCode.provider()->url(); - - if (sourceURL.isNull() && !m_XSSAuditor->canEvaluateJavaScriptURL(sourceCode.source())) { - // This JavaScript URL is not safe to be evaluated. - return JSValue(); - } - - if (!sourceURL.isNull() && !m_XSSAuditor->canEvaluate(sourceCode.source())) { + + if (!m_XSSAuditor->canEvaluate(sourceCode.source())) { // This script is not safe to be evaluated. return JSValue(); } @@ -97,12 +104,12 @@ ScriptValue ScriptController::evaluate(const ScriptSourceCode& sourceCode) // evaluate code. Returns the JS return value or 0 // if there was none, an error occured or the type couldn't be converted. - initScriptIfNeeded(); // inlineCode is true for <a href="javascript:doSomething()"> // and false for <script>doSomething()</script>. Check if it has the // expected value in all cases. // See smart window.open policy for where this is used. - ExecState* exec = m_windowShell->window()->globalExec(); + JSDOMWindowShell* shell = windowShell(world); + ExecState* exec = shell->window()->globalExec(); const String* savedSourceURL = m_sourceURL; m_sourceURL = &sourceURL; @@ -110,9 +117,9 @@ ScriptValue ScriptController::evaluate(const ScriptSourceCode& sourceCode) RefPtr<Frame> protect = m_frame; - m_windowShell->window()->globalData()->timeoutChecker.start(); - Completion comp = JSC::evaluate(exec, exec->dynamicGlobalObject()->globalScopeChain(), jsSourceCode, m_windowShell); - m_windowShell->window()->globalData()->timeoutChecker.stop(); + exec->globalData().timeoutChecker.start(); + Completion comp = WebCore::evaluateInWorld(exec, exec->dynamicGlobalObject()->globalScopeChain(), jsSourceCode, shell, world); + exec->globalData().timeoutChecker.stop(); // Evaluating the JavaScript could cause the frame to be deallocated // so we start the keep alive timer here. @@ -130,44 +137,114 @@ ScriptValue ScriptController::evaluate(const ScriptSourceCode& sourceCode) return JSValue(); } +ScriptValue ScriptController::evaluate(const ScriptSourceCode& sourceCode) +{ + return evaluateInWorld(sourceCode, mainThreadNormalWorld()); +} + +// An DOMWrapperWorld other than the thread's normal world. +class IsolatedWorld : public DOMWrapperWorld { +public: + IsolatedWorld(JSGlobalData* globalData) + : DOMWrapperWorld(globalData) + { + JSGlobalData::ClientData* clientData = globalData->clientData; + ASSERT(clientData); + static_cast<WebCoreJSClientData*>(clientData)->rememberWorld(this); + } + + static PassRefPtr<IsolatedWorld> create(JSGlobalData* globalData) { return adoptRef(new IsolatedWorld(globalData)); } +}; + +static PassRefPtr<IsolatedWorld> findWorld(unsigned worldID) +{ + if (!worldID) + return IsolatedWorld::create(JSDOMWindow::commonJSGlobalData()); + + typedef HashMap<unsigned, RefPtr<IsolatedWorld> > WorldMap; + DEFINE_STATIC_LOCAL(WorldMap, isolatedWorlds, ()); + + WorldMap::iterator iter = isolatedWorlds.find(worldID); + if (iter != isolatedWorlds.end()) + return iter->second; + + RefPtr<IsolatedWorld> newWorld = IsolatedWorld::create(JSDOMWindow::commonJSGlobalData()); + isolatedWorlds.add(worldID, newWorld); + return newWorld; +} + +JSDOMWindow* ScriptController::globalObject(unsigned worldID) +{ + RefPtr<DOMWrapperWorld> world = findWorld(worldID); + return windowShell(world.get())->window(); +} + +ScriptValue ScriptController::evaluateInIsolatedWorld(unsigned worldID, const ScriptSourceCode& sourceCode) +{ + RefPtr<DOMWrapperWorld> world = findWorld(worldID); + return evaluateInWorld(sourceCode, world.get()); +} + +void ScriptController::evaluateInIsolatedWorld(unsigned worldID, const Vector<ScriptSourceCode>& sourceCode) +{ + RefPtr<DOMWrapperWorld> world = findWorld(worldID); + + unsigned size = sourceCode.size(); + for (unsigned i = 0; i < size; ++i) + evaluateInWorld(sourceCode[i], world.get()); +} + void ScriptController::clearWindowShell() { - if (!m_windowShell) + if (m_windowShells.isEmpty()) return; JSLock lock(SilenceAssertionsOnly); // Clear the debugger from the current window before setting the new window. + DOMWrapperWorld* debugWorld = debuggerWorld(); attachDebugger(0); - m_windowShell->window()->willRemoveFromWindowShell(); - m_windowShell->setWindow(m_frame->domWindow()); + for (ShellMap::iterator iter = m_windowShells.begin(); iter != m_windowShells.end(); ++iter) { + DOMWrapperWorld* world = iter->first; + JSDOMWindowShell* windowShell = iter->second; + windowShell->window()->willRemoveFromWindowShell(); + windowShell->setWindow(m_frame->domWindow()); - if (Page* page = m_frame->page()) { - attachDebugger(page->debugger()); - m_windowShell->window()->setProfileGroup(page->group().identifier()); + if (Page* page = m_frame->page()) { + if (world == debugWorld) + attachDebugger(page->debugger()); + windowShell->window()->setProfileGroup(page->group().identifier()); + } } // There is likely to be a lot of garbage now. gcController().garbageCollectSoon(); } -void ScriptController::initScript() +JSDOMWindowShell* ScriptController::initScript(DOMWrapperWorld* world) { - if (m_windowShell) - return; + ASSERT(!m_windowShells.contains(world)); JSLock lock(SilenceAssertionsOnly); - m_windowShell = new JSDOMWindowShell(m_frame->domWindow()); - m_windowShell->window()->updateDocument(); + JSDOMWindowShell* windowShell = new JSDOMWindowShell(m_frame->domWindow()); + m_windowShells.add(world, windowShell); + world->rememberScriptController(this); + windowShell->window()->updateDocument(world); if (Page* page = m_frame->page()) { - attachDebugger(page->debugger()); - m_windowShell->window()->setProfileGroup(page->group().identifier()); + if (world == debuggerWorld()) + attachDebugger(page->debugger()); + windowShell->window()->setProfileGroup(page->group().identifier()); } - m_frame->loader()->dispatchWindowObjectAvailable(); + { + EnterDOMWrapperWorld worldEntry(*JSDOMWindow::commonJSGlobalData(), world); + m_frame->loader()->dispatchWindowObjectAvailable(); + } + + return windowShell; } bool ScriptController::processingUserGesture() const @@ -177,10 +254,14 @@ bool ScriptController::processingUserGesture() const bool ScriptController::processingUserGestureEvent() const { - if (!m_windowShell) + JSDOMWindowShell* shell = existingWindowShell(mainThreadNormalWorld()); + if (!shell) return false; - if (Event* event = m_windowShell->window()->currentEvent()) { + if (Event* event = shell->window()->currentEvent()) { + if (event->createdByDOM()) + return false; + const AtomicString& type = event->type(); if ( // mouse events type == eventNames().clickEvent || type == eventNames().mousedownEvent || @@ -235,13 +316,16 @@ bool ScriptController::isEnabled() void ScriptController::attachDebugger(JSC::Debugger* debugger) { - if (!m_windowShell) + // FIXME: Should be able to debug isolated worlds. + JSDOMWindowShell* shell = existingWindowShell(debuggerWorld()); + if (!shell) return; + JSDOMWindow* globalObject = shell->window(); if (debugger) - debugger->attach(m_windowShell->window()); - else if (JSC::Debugger* currentDebugger = m_windowShell->window()->debugger()) - currentDebugger->detach(m_windowShell->window()); + debugger->attach(globalObject); + else if (JSC::Debugger* currentDebugger = globalObject->debugger()) + currentDebugger->detach(globalObject); } void ScriptController::updateDocument() @@ -250,8 +334,8 @@ void ScriptController::updateDocument() return; JSLock lock(SilenceAssertionsOnly); - if (m_windowShell) - m_windowShell->window()->updateDocument(); + for (ShellMap::iterator iter = m_windowShells.begin(); iter != m_windowShells.end(); ++iter) + iter->second->window()->updateDocument(iter->first); } void ScriptController::updateSecurityOrigin() @@ -266,7 +350,7 @@ Bindings::RootObject* ScriptController::bindingRootObject() if (!m_bindingRootObject) { JSLock lock(SilenceAssertionsOnly); - m_bindingRootObject = Bindings::RootObject::create(0, globalObject()); + m_bindingRootObject = Bindings::RootObject::create(0, globalObject(pluginWorld())); } return m_bindingRootObject.get(); } @@ -277,7 +361,7 @@ PassRefPtr<Bindings::RootObject> ScriptController::createRootObject(void* native if (it != m_rootObjects.end()) return it->second; - RefPtr<Bindings::RootObject> rootObject = Bindings::RootObject::create(nativeHandle, globalObject()); + RefPtr<Bindings::RootObject> rootObject = Bindings::RootObject::create(nativeHandle, globalObject(pluginWorld())); m_rootObjects.set(nativeHandle, rootObject); return rootObject.release(); @@ -292,7 +376,7 @@ NPObject* ScriptController::windowScriptNPObject() // JavaScript is enabled, so there is a JavaScript window object. // Return an NPObject bound to the window object. JSC::JSLock lock(SilenceAssertionsOnly); - JSObject* win = windowShell()->window(); + JSObject* win = windowShell(pluginWorld())->window(); ASSERT(win); Bindings::RootObject* root = bindingRootObject(); m_windowScriptNPObject = _NPN_CreateScriptObject(0, win, root); @@ -326,8 +410,9 @@ JSObject* ScriptController::jsObjectForPluginElement(HTMLPlugInElement* plugin) // Create a JSObject bound to this element JSLock lock(SilenceAssertionsOnly); - ExecState* exec = globalObject()->globalExec(); - JSValue jsElementValue = toJS(exec, globalObject(), plugin); + JSDOMWindow* globalObj = globalObject(pluginWorld()); + // FIXME: is normal okay? - used for NP plugins? + JSValue jsElementValue = toJS(globalObj->globalExec(), globalObj, plugin); if (!jsElementValue || !jsElementValue.isObject()) return 0; @@ -383,4 +468,44 @@ void ScriptController::clearScriptObjects() #endif } +ScriptValue ScriptController::executeScriptInIsolatedWorld(unsigned worldID, const String& script, bool forceUserGesture) +{ + ScriptSourceCode sourceCode(script, forceUserGesture ? KURL() : m_frame->loader()->url()); + + if (!isEnabled() || isPaused()) + return ScriptValue(); + + bool wasInExecuteScript = m_inExecuteScript; + m_inExecuteScript = true; + + ScriptValue result = evaluateInIsolatedWorld(worldID, sourceCode); + + if (!wasInExecuteScript) { + m_inExecuteScript = false; + Document::updateStyleForAllDocuments(); + } + + return result; +} + +ScriptValue ScriptController::executeScriptInIsolatedWorld(DOMWrapperWorld* world, const String& script, bool forceUserGesture) +{ + ScriptSourceCode sourceCode(script, forceUserGesture ? KURL() : m_frame->loader()->url()); + + if (!isEnabled() || isPaused()) + return ScriptValue(); + + bool wasInExecuteScript = m_inExecuteScript; + m_inExecuteScript = true; + + ScriptValue result = evaluateInWorld(sourceCode, world); + + if (!wasInExecuteScript) { + m_inExecuteScript = false; + Document::updateStyleForAllDocuments(); + } + + return result; +} + } // namespace WebCore diff --git a/src/3rdparty/webkit/WebCore/bindings/js/ScriptController.h b/src/3rdparty/webkit/WebCore/bindings/js/ScriptController.h index 452849597..f2a497d19 100644 --- a/src/3rdparty/webkit/WebCore/bindings/js/ScriptController.h +++ b/src/3rdparty/webkit/WebCore/bindings/js/ScriptController.h @@ -63,24 +63,49 @@ class XSSAuditor; typedef HashMap<void*, RefPtr<JSC::Bindings::RootObject> > RootObjectMap; class ScriptController { + typedef WTF::HashMap<DOMWrapperWorld*, JSC::ProtectedPtr<JSDOMWindowShell> > ShellMap; + public: ScriptController(Frame*); ~ScriptController(); - bool haveWindowShell() const { return m_windowShell; } - JSDOMWindowShell* windowShell() + JSDOMWindowShell* windowShell(DOMWrapperWorld* world) + { + ShellMap::iterator iter = m_windowShells.find(world); + return (iter != m_windowShells.end()) ? iter->second.get() : initScript(world); + } + JSDOMWindowShell* existingWindowShell(DOMWrapperWorld* world) const { - initScriptIfNeeded(); - return m_windowShell; + ShellMap::const_iterator iter = m_windowShells.find(world); + return (iter != m_windowShells.end()) ? iter->second.get() : 0; } + JSDOMWindow* globalObject(DOMWrapperWorld* world) + { + return windowShell(world)->window(); + } + JSDOMWindow* globalObject(unsigned worldID); - JSDOMWindow* globalObject() + void forgetWorld(DOMWrapperWorld* world) { - initScriptIfNeeded(); - return m_windowShell->window(); + m_windowShells.remove(world); } + ScriptValue executeScript(const ScriptSourceCode&); + ScriptValue executeScript(const String& script, bool forceUserGesture = false); + ScriptValue executeScriptInIsolatedWorld(unsigned worldID, const String& script, bool forceUserGesture = false); + ScriptValue executeScriptInIsolatedWorld(DOMWrapperWorld* world, const String& script, bool forceUserGesture = false); + + // Returns true if argument is a JavaScript URL. + bool executeIfJavaScriptURL(const KURL&, bool userGesture = false, bool replaceDocument = true); + + // This function must be called from the main thread. It is safe to call it repeatedly. + // Darwin is an exception to this rule: it is OK to call this function from any thread, even reentrantly. + static void initializeThreading(); + ScriptValue evaluate(const ScriptSourceCode&); + ScriptValue evaluateInWorld(const ScriptSourceCode&, DOMWrapperWorld*); + ScriptValue evaluateInIsolatedWorld(unsigned /*worldID*/, const ScriptSourceCode&); + void evaluateInIsolatedWorld(unsigned /*worldID*/, const Vector<ScriptSourceCode>&); void setEventHandlerLineNumber(int lineno) { m_handlerLineNumber = lineno; } int eventHandlerLineNumber() { return m_handlerLineNumber; } @@ -137,23 +162,20 @@ public: XSSAuditor* xssAuditor() { return m_XSSAuditor.get(); } private: - void initScriptIfNeeded() - { - if (!m_windowShell) - initScript(); - } - void initScript(); + JSDOMWindowShell* initScript(DOMWrapperWorld* world); void disconnectPlatformScriptObjects(); bool processingUserGestureEvent() const; bool isJavaScriptAnchorNavigation() const; - JSC::ProtectedPtr<JSDOMWindowShell> m_windowShell; + ShellMap m_windowShells; Frame* m_frame; int m_handlerLineNumber; const String* m_sourceURL; + bool m_inExecuteScript; + bool m_processingTimerCallback; bool m_paused; bool m_allowPopupsFromPlugin; diff --git a/src/3rdparty/webkit/WebCore/bindings/js/ScriptControllerHaiku.cpp b/src/3rdparty/webkit/WebCore/bindings/js/ScriptControllerHaiku.cpp index b573b97e6..3fe471d6f 100644 --- a/src/3rdparty/webkit/WebCore/bindings/js/ScriptControllerHaiku.cpp +++ b/src/3rdparty/webkit/WebCore/bindings/js/ScriptControllerHaiku.cpp @@ -28,8 +28,8 @@ #include "ScriptController.h" #include "PluginView.h" -#include "runtime_root.h" #include "runtime.h" +#include "runtime_root.h" namespace WebCore { diff --git a/src/3rdparty/webkit/WebCore/bindings/js/ScriptControllerMac.mm b/src/3rdparty/webkit/WebCore/bindings/js/ScriptControllerMac.mm index e6a654f06..21ec0f287 100644 --- a/src/3rdparty/webkit/WebCore/bindings/js/ScriptControllerMac.mm +++ b/src/3rdparty/webkit/WebCore/bindings/js/ScriptControllerMac.mm @@ -114,7 +114,7 @@ WebScriptObject* ScriptController::windowScriptObject() if (!m_windowScriptObject) { JSC::JSLock lock(JSC::SilenceAssertionsOnly); JSC::Bindings::RootObject* root = bindingRootObject(); - m_windowScriptObject = [WebScriptObject scriptObjectForJSObject:toRef(windowShell()) originRootObject:root rootObject:root]; + m_windowScriptObject = [WebScriptObject scriptObjectForJSObject:toRef(windowShell(pluginWorld())) originRootObject:root rootObject:root]; } ASSERT([m_windowScriptObject.get() isKindOfClass:[DOMAbstractView class]]); diff --git a/src/3rdparty/webkit/WebCore/bindings/js/ScriptEventListener.cpp b/src/3rdparty/webkit/WebCore/bindings/js/ScriptEventListener.cpp index 878c5353f..8399c7acb 100644 --- a/src/3rdparty/webkit/WebCore/bindings/js/ScriptEventListener.cpp +++ b/src/3rdparty/webkit/WebCore/bindings/js/ScriptEventListener.cpp @@ -33,12 +33,11 @@ #include "Attribute.h" #include "Document.h" +#include "EventListener.h" #include "JSNode.h" #include "Frame.h" #include "XSSAuditor.h" -#include <runtime/JSLock.h> - using namespace JSC; namespace WebCore { @@ -54,29 +53,25 @@ PassRefPtr<JSLazyEventListener> createAttributeEventListener(Node* node, Attribu { ASSERT(node); - Frame* frame = node->document()->frame(); - if (!frame) - return 0; - - ScriptController* scriptController = frame->script(); - if (!scriptController->isEnabled()) - return 0; - - if (!scriptController->xssAuditor()->canCreateInlineEventListener(attr->localName().string(), attr->value())) { - // This script is not safe to execute. - return 0; - } + int lineNumber = 1; + String sourceURL; - JSDOMWindow* globalObject = scriptController->globalObject(); - - // Ensure that 'node' has a JavaScript wrapper to mark the event listener we're creating. - { - JSLock lock(SilenceAssertionsOnly); - // FIXME: Should pass the global object associated with the node - toJS(globalObject->globalExec(), globalObject, node); + // FIXME: We should be able to provide accurate source information for frameless documents, too (e.g. for importing nodes from XMLHttpRequest.responseXML). + if (Frame* frame = node->document()->frame()) { + ScriptController* scriptController = frame->script(); + if (!scriptController->isEnabled()) + return 0; + + if (!scriptController->xssAuditor()->canCreateInlineEventListener(attr->localName().string(), attr->value())) { + // This script is not safe to execute. + return 0; + } + + lineNumber = scriptController->eventHandlerLineNumber(); + sourceURL = node->document()->url().string(); } - return JSLazyEventListener::create(attr->localName().string(), eventParameterName(node->isSVGElement()), attr->value(), globalObject, node, scriptController->eventHandlerLineNumber()); + return JSLazyEventListener::create(attr->localName().string(), eventParameterName(node->isSVGElement()), attr->value(), node, sourceURL, lineNumber, mainThreadNormalWorld()); } PassRefPtr<JSLazyEventListener> createAttributeEventListener(Frame* frame, Attribute* attr) @@ -84,19 +79,29 @@ PassRefPtr<JSLazyEventListener> createAttributeEventListener(Frame* frame, Attri if (!frame) return 0; + int lineNumber = 1; + String sourceURL; + ScriptController* scriptController = frame->script(); if (!scriptController->isEnabled()) return 0; - + if (!scriptController->xssAuditor()->canCreateInlineEventListener(attr->localName().string(), attr->value())) { // This script is not safe to execute. return 0; } - // 'globalObject' is the JavaScript wrapper that will mark the event listener we're creating. - JSDOMWindow* globalObject = scriptController->globalObject(); + lineNumber = scriptController->eventHandlerLineNumber(); + sourceURL = frame->document()->url().string(); + return JSLazyEventListener::create(attr->localName().string(), eventParameterName(frame->document()->isSVGDocument()), attr->value(), 0, sourceURL, lineNumber, mainThreadNormalWorld()); +} - return JSLazyEventListener::create(attr->localName().string(), eventParameterName(frame->document()->isSVGDocument()), attr->value(), globalObject, 0, scriptController->eventHandlerLineNumber()); +String getEventListenerHandlerBody(ScriptExecutionContext* context, ScriptState* scriptState, EventListener* eventListener) +{ + JSC::JSObject* functionObject = eventListener->jsFunction(context); + if (!functionObject) + return ""; + return functionObject->toString(scriptState); } } // namespace WebCore diff --git a/src/3rdparty/webkit/WebCore/bindings/js/ScriptEventListener.h b/src/3rdparty/webkit/WebCore/bindings/js/ScriptEventListener.h index 8299d2956..33965412b 100644 --- a/src/3rdparty/webkit/WebCore/bindings/js/ScriptEventListener.h +++ b/src/3rdparty/webkit/WebCore/bindings/js/ScriptEventListener.h @@ -32,17 +32,20 @@ #define ScriptEventListener_h #include "JSLazyEventListener.h" +#include "ScriptState.h" #include <wtf/PassRefPtr.h> namespace WebCore { class Attribute; + class EventListener; class Frame; class Node; PassRefPtr<JSLazyEventListener> createAttributeEventListener(Node*, Attribute*); PassRefPtr<JSLazyEventListener> createAttributeEventListener(Frame*, Attribute*); + String getEventListenerHandlerBody(ScriptExecutionContext*, ScriptState*, EventListener*); } // namespace WebCore diff --git a/src/3rdparty/webkit/WebCore/bindings/js/ScriptFunctionCall.cpp b/src/3rdparty/webkit/WebCore/bindings/js/ScriptFunctionCall.cpp index ca6b03a9d..91b2a5761 100644 --- a/src/3rdparty/webkit/WebCore/bindings/js/ScriptFunctionCall.cpp +++ b/src/3rdparty/webkit/WebCore/bindings/js/ScriptFunctionCall.cpp @@ -123,7 +123,8 @@ ScriptValue ScriptFunctionCall::call(bool& hadException, bool reportExceptions) if (callType == CallTypeNone) return ScriptValue(); - JSValue result = JSC::call(m_exec, function, callType, callData, thisObject, m_arguments); + // FIXME: Should this function take a worldID? - only used by inspector? + JSValue result = callInWorld(m_exec, function, callType, callData, thisObject, m_arguments, debuggerWorld()); if (m_exec->hadException()) { if (reportExceptions) reportException(m_exec, m_exec->exception()); @@ -161,7 +162,8 @@ ScriptObject ScriptFunctionCall::construct(bool& hadException, bool reportExcept if (constructType == ConstructTypeNone) return ScriptObject(); - JSValue result = JSC::construct(m_exec, constructor, constructType, constructData, m_arguments); + // FIXME: Currently this method constructs objects in debuggerWorld(). We could use the current world, or pass a worldID to this function? + JSValue result = constructInWorld(m_exec, constructor, constructType, constructData, m_arguments, debuggerWorld()); if (m_exec->hadException()) { if (reportExceptions) reportException(m_exec, m_exec->exception()); @@ -170,7 +172,7 @@ ScriptObject ScriptFunctionCall::construct(bool& hadException, bool reportExcept return ScriptObject(); } - return ScriptObject(asObject(result)); + return ScriptObject(m_exec, asObject(result)); } } // namespace WebCore diff --git a/src/3rdparty/webkit/WebCore/bindings/js/ScriptObject.cpp b/src/3rdparty/webkit/WebCore/bindings/js/ScriptObject.cpp index e66464532..1172e8e81 100644 --- a/src/3rdparty/webkit/WebCore/bindings/js/ScriptObject.cpp +++ b/src/3rdparty/webkit/WebCore/bindings/js/ScriptObject.cpp @@ -40,8 +40,9 @@ using namespace JSC; namespace WebCore { -ScriptObject::ScriptObject(JSObject* object) +ScriptObject::ScriptObject(ScriptState* scriptState, JSObject* object) : ScriptValue(object) + , m_scriptState(scriptState) { } @@ -54,66 +55,74 @@ static bool handleException(ScriptState* scriptState) return false; } -bool ScriptObject::set(ScriptState* scriptState, const String& name, const String& value) +bool ScriptObject::set(const String& name, const String& value) { JSLock lock(SilenceAssertionsOnly); PutPropertySlot slot; - jsObject()->put(scriptState, Identifier(scriptState, name), jsString(scriptState, value), slot); - return handleException(scriptState); + jsObject()->put(m_scriptState, Identifier(m_scriptState, name), jsString(m_scriptState, value), slot); + return handleException(m_scriptState); } -bool ScriptObject::set(ScriptState* scriptState, const char* name, const ScriptObject& value) +bool ScriptObject::set(const char* name, const ScriptObject& value) { JSLock lock(SilenceAssertionsOnly); PutPropertySlot slot; - jsObject()->put(scriptState, Identifier(scriptState, name), value.jsObject(), slot); - return handleException(scriptState); + jsObject()->put(m_scriptState, Identifier(m_scriptState, name), value.jsObject(), slot); + return handleException(m_scriptState); } -bool ScriptObject::set(ScriptState* scriptState, const char* name, const String& value) +bool ScriptObject::set(const char* name, const String& value) { JSLock lock(SilenceAssertionsOnly); PutPropertySlot slot; - jsObject()->put(scriptState, Identifier(scriptState, name), jsString(scriptState, value), slot); - return handleException(scriptState); + jsObject()->put(m_scriptState, Identifier(m_scriptState, name), jsString(m_scriptState, value), slot); + return handleException(m_scriptState); } -bool ScriptObject::set(ScriptState* scriptState, const char* name, double value) +bool ScriptObject::set(const char* name, double value) { JSLock lock(SilenceAssertionsOnly); PutPropertySlot slot; - jsObject()->put(scriptState, Identifier(scriptState, name), jsNumber(scriptState, value), slot); - return handleException(scriptState); + jsObject()->put(m_scriptState, Identifier(m_scriptState, name), jsNumber(m_scriptState, value), slot); + return handleException(m_scriptState); } -bool ScriptObject::set(ScriptState* scriptState, const char* name, long long value) +bool ScriptObject::set(const char* name, long long value) { JSLock lock(SilenceAssertionsOnly); PutPropertySlot slot; - jsObject()->put(scriptState, Identifier(scriptState, name), jsNumber(scriptState, value), slot); - return handleException(scriptState); + jsObject()->put(m_scriptState, Identifier(m_scriptState, name), jsNumber(m_scriptState, value), slot); + return handleException(m_scriptState); } -bool ScriptObject::set(ScriptState* scriptState, const char* name, int value) +bool ScriptObject::set(const char* name, int value) { JSLock lock(SilenceAssertionsOnly); PutPropertySlot slot; - jsObject()->put(scriptState, Identifier(scriptState, name), jsNumber(scriptState, value), slot); - return handleException(scriptState); + jsObject()->put(m_scriptState, Identifier(m_scriptState, name), jsNumber(m_scriptState, value), slot); + return handleException(m_scriptState); } -bool ScriptObject::set(ScriptState* scriptState, const char* name, bool value) +bool ScriptObject::set(const char* name, unsigned value) { JSLock lock(SilenceAssertionsOnly); PutPropertySlot slot; - jsObject()->put(scriptState, Identifier(scriptState, name), jsBoolean(value), slot); - return handleException(scriptState); + jsObject()->put(m_scriptState, Identifier(m_scriptState, name), jsNumber(m_scriptState, value), slot); + return handleException(m_scriptState); +} + +bool ScriptObject::set(const char* name, bool value) +{ + JSLock lock(SilenceAssertionsOnly); + PutPropertySlot slot; + jsObject()->put(m_scriptState, Identifier(m_scriptState, name), jsBoolean(value), slot); + return handleException(m_scriptState); } ScriptObject ScriptObject::createNew(ScriptState* scriptState) { JSLock lock(SilenceAssertionsOnly); - return ScriptObject(constructEmptyObject(scriptState)); + return ScriptObject(scriptState, constructEmptyObject(scriptState)); } bool ScriptGlobalObject::set(ScriptState* scriptState, const char* name, const ScriptObject& value) @@ -123,6 +132,7 @@ bool ScriptGlobalObject::set(ScriptState* scriptState, const char* name, const S return handleException(scriptState); } +#if ENABLE(INSPECTOR) bool ScriptGlobalObject::set(ScriptState* scriptState, const char* name, InspectorBackend* value) { JSLock lock(SilenceAssertionsOnly); @@ -130,6 +140,7 @@ bool ScriptGlobalObject::set(ScriptState* scriptState, const char* name, Inspect globalObject->putDirect(Identifier(scriptState, name), toJS(scriptState, globalObject, value)); return handleException(scriptState); } +#endif // ENABLE(INSPECTOR) bool ScriptGlobalObject::get(ScriptState* scriptState, const char* name, ScriptObject& value) { @@ -141,7 +152,7 @@ bool ScriptGlobalObject::get(ScriptState* scriptState, const char* name, ScriptO if (!jsValue.isObject()) return false; - value = ScriptObject(asObject(jsValue)); + value = ScriptObject(scriptState, asObject(jsValue)); return true; } diff --git a/src/3rdparty/webkit/WebCore/bindings/js/ScriptObject.h b/src/3rdparty/webkit/WebCore/bindings/js/ScriptObject.h index 97022da09..31381f39d 100644 --- a/src/3rdparty/webkit/WebCore/bindings/js/ScriptObject.h +++ b/src/3rdparty/webkit/WebCore/bindings/js/ScriptObject.h @@ -42,25 +42,31 @@ namespace WebCore { class ScriptObject : public ScriptValue { public: - ScriptObject(JSC::JSObject*); + ScriptObject(ScriptState*, JSC::JSObject*); ScriptObject() {} JSC::JSObject* jsObject() const { return asObject(jsValue()); } - bool set(ScriptState*, const String& name, const String&); - bool set(ScriptState*, const char* name, const ScriptObject&); - bool set(ScriptState*, const char* name, const String&); - bool set(ScriptState*, const char* name, double); - bool set(ScriptState*, const char* name, long long); - bool set(ScriptState*, const char* name, int); - bool set(ScriptState*, const char* name, bool); + bool set(const String& name, const String&); + bool set(const char* name, const ScriptObject&); + bool set(const char* name, const String&); + bool set(const char* name, double); + bool set(const char* name, long long); + bool set(const char* name, int); + bool set(const char* name, unsigned); + bool set(const char* name, bool); static ScriptObject createNew(ScriptState*); + + protected: + ScriptState* m_scriptState; }; class ScriptGlobalObject { public: static bool set(ScriptState*, const char* name, const ScriptObject&); +#if ENABLE(INSPECTOR) static bool set(ScriptState*, const char* name, InspectorBackend*); +#endif static bool get(ScriptState*, const char* name, ScriptObject&); static bool remove(ScriptState*, const char* name); private: diff --git a/src/3rdparty/webkit/WebCore/bindings/js/ScriptObjectQuarantine.cpp b/src/3rdparty/webkit/WebCore/bindings/js/ScriptObjectQuarantine.cpp index 171883aa7..313530fec 100644 --- a/src/3rdparty/webkit/WebCore/bindings/js/ScriptObjectQuarantine.cpp +++ b/src/3rdparty/webkit/WebCore/bindings/js/ScriptObjectQuarantine.cpp @@ -31,6 +31,8 @@ #include "config.h" #include "ScriptObjectQuarantine.h" +#if ENABLE(INSPECTOR) + #include "Document.h" #include "Frame.h" #include "JSDOMBinding.h" @@ -38,6 +40,7 @@ #include "JSNode.h" #include "ScriptObject.h" #include "ScriptValue.h" +#include "Storage.h" #include <runtime/JSLock.h> @@ -69,27 +72,28 @@ bool getQuarantinedScriptObject(Database* database, ScriptObject& quarantinedObj if (!frame) return false; - JSDOMGlobalObject* globalObject = toJSDOMWindow(frame); + JSDOMGlobalObject* globalObject = toJSDOMWindow(frame, debuggerWorld()); ExecState* exec = globalObject->globalExec(); JSLock lock(SilenceAssertionsOnly); - quarantinedObject = ScriptObject(asObject(JSInspectedObjectWrapper::wrap(exec, toJS(exec, globalObject, database)))); + quarantinedObject = ScriptObject(exec, asObject(JSInspectedObjectWrapper::wrap(exec, toJS(exec, globalObject, database)))); return true; } #endif #if ENABLE(DOM_STORAGE) -bool getQuarantinedScriptObject(Frame* frame, Storage* storage, ScriptObject& quarantinedObject) +bool getQuarantinedScriptObject(Storage* storage, ScriptObject& quarantinedObject) { - ASSERT(frame); ASSERT(storage); + Frame* frame = storage->frame(); + ASSERT(frame); - JSDOMGlobalObject* globalObject = toJSDOMWindow(frame); + JSDOMGlobalObject* globalObject = toJSDOMWindow(frame, debuggerWorld()); ExecState* exec = globalObject->globalExec(); JSLock lock(SilenceAssertionsOnly); - quarantinedObject = ScriptObject(asObject(JSInspectedObjectWrapper::wrap(exec, toJS(exec, globalObject, storage)))); + quarantinedObject = ScriptObject(exec, asObject(JSInspectedObjectWrapper::wrap(exec, toJS(exec, globalObject, storage)))); return true; } @@ -103,7 +107,7 @@ bool getQuarantinedScriptObject(Node* node, ScriptObject& quarantinedObject) JSLock lock(SilenceAssertionsOnly); // FIXME: Should use some sort of globalObjectFromNode() - quarantinedObject = ScriptObject(asObject(JSInspectedObjectWrapper::wrap(exec, toJS(exec, deprecatedGlobalObjectForPrototype(exec), node)))); + quarantinedObject = ScriptObject(exec, asObject(JSInspectedObjectWrapper::wrap(exec, toJS(exec, deprecatedGlobalObjectForPrototype(exec), node)))); return true; } @@ -112,14 +116,16 @@ bool getQuarantinedScriptObject(DOMWindow* domWindow, ScriptObject& quarantinedO { ASSERT(domWindow); - JSDOMWindow* window = toJSDOMWindow(domWindow->frame()); + JSDOMWindow* window = toJSDOMWindow(domWindow->frame(), debuggerWorld()); ExecState* exec = window->globalExec(); JSLock lock(SilenceAssertionsOnly); - quarantinedObject = ScriptObject(asObject(JSInspectedObjectWrapper::wrap(exec, window))); + quarantinedObject = ScriptObject(exec, asObject(JSInspectedObjectWrapper::wrap(exec, window))); return true; } } // namespace WebCore + +#endif // ENABLE(INSPECTOR) diff --git a/src/3rdparty/webkit/WebCore/bindings/js/ScriptObjectQuarantine.h b/src/3rdparty/webkit/WebCore/bindings/js/ScriptObjectQuarantine.h index d70acd75a..df52379f4 100644 --- a/src/3rdparty/webkit/WebCore/bindings/js/ScriptObjectQuarantine.h +++ b/src/3rdparty/webkit/WebCore/bindings/js/ScriptObjectQuarantine.h @@ -37,7 +37,6 @@ namespace WebCore { class Database; class DOMWindow; - class Frame; class Node; class ScriptObject; class ScriptValue; @@ -49,7 +48,7 @@ namespace WebCore { bool getQuarantinedScriptObject(Database* database, ScriptObject& quarantinedObject); #endif #if ENABLE(DOM_STORAGE) - bool getQuarantinedScriptObject(Frame* frame, Storage* storage, ScriptObject& quarantinedObject); + bool getQuarantinedScriptObject(Storage* storage, ScriptObject& quarantinedObject); #endif bool getQuarantinedScriptObject(Node* node, ScriptObject& quarantinedObject); bool getQuarantinedScriptObject(DOMWindow* domWindow, ScriptObject& quarantinedObject); diff --git a/src/3rdparty/webkit/WebCore/bindings/js/ScriptSourceCode.h b/src/3rdparty/webkit/WebCore/bindings/js/ScriptSourceCode.h index 1b05dedb6..32d6298cd 100644 --- a/src/3rdparty/webkit/WebCore/bindings/js/ScriptSourceCode.h +++ b/src/3rdparty/webkit/WebCore/bindings/js/ScriptSourceCode.h @@ -44,6 +44,7 @@ public: ScriptSourceCode(const String& source, const KURL& url = KURL(), int startLine = 1) : m_provider(StringSourceProvider::create(source, url.isNull() ? String() : url.string())) , m_code(m_provider, startLine) + , m_url(url) { } @@ -59,10 +60,17 @@ public: const String& source() const { return m_provider->source(); } + int startLine() const { return m_code.firstLine(); } + + const KURL& url() const { return m_url; } + private: RefPtr<ScriptSourceProvider> m_provider; JSC::SourceCode m_code; + + KURL m_url; + }; } // namespace WebCore diff --git a/src/3rdparty/webkit/WebCore/bindings/js/ScriptState.cpp b/src/3rdparty/webkit/WebCore/bindings/js/ScriptState.cpp index 8bfa33d15..60ba2a05d 100644 --- a/src/3rdparty/webkit/WebCore/bindings/js/ScriptState.cpp +++ b/src/3rdparty/webkit/WebCore/bindings/js/ScriptState.cpp @@ -32,6 +32,7 @@ #include "ScriptState.h" #include "Frame.h" +#include "JSDOMWindowBase.h" #include "Node.h" #include "Page.h" @@ -49,12 +50,12 @@ ScriptState* scriptStateFromNode(Node* node) return 0; if (!frame->script()->isEnabled()) return 0; - return frame->script()->globalObject()->globalExec(); + return frame->script()->globalObject(mainThreadCurrentWorld())->globalExec(); } ScriptState* scriptStateFromPage(Page* page) { - return page->mainFrame()->script()->globalObject()->globalExec(); + return page->mainFrame()->script()->globalObject(mainThreadCurrentWorld())->globalExec(); } } diff --git a/src/3rdparty/webkit/WebCore/bindings/js/ScriptState.h b/src/3rdparty/webkit/WebCore/bindings/js/ScriptState.h index fa5c4a857..279234e4a 100644 --- a/src/3rdparty/webkit/WebCore/bindings/js/ScriptState.h +++ b/src/3rdparty/webkit/WebCore/bindings/js/ScriptState.h @@ -35,6 +35,7 @@ #include "JSDOMBinding.h" namespace WebCore { + class DOMWrapperWorld; class Node; class Page; diff --git a/src/3rdparty/webkit/WebCore/bindings/js/ScriptValue.cpp b/src/3rdparty/webkit/WebCore/bindings/js/ScriptValue.cpp index d427ceee2..6eac102d7 100644 --- a/src/3rdparty/webkit/WebCore/bindings/js/ScriptValue.cpp +++ b/src/3rdparty/webkit/WebCore/bindings/js/ScriptValue.cpp @@ -74,4 +74,11 @@ bool ScriptValue::isUndefined() const return m_value.get().isUndefined(); } +bool ScriptValue::isObject() const +{ + if (!m_value) + return false; + return m_value.get().isObject(); +} + } // namespace WebCore diff --git a/src/3rdparty/webkit/WebCore/bindings/js/ScriptValue.h b/src/3rdparty/webkit/WebCore/bindings/js/ScriptValue.h index 209ce0680..19bb69313 100644 --- a/src/3rdparty/webkit/WebCore/bindings/js/ScriptValue.h +++ b/src/3rdparty/webkit/WebCore/bindings/js/ScriptValue.h @@ -50,6 +50,7 @@ public: bool isEqual(ScriptState*, const ScriptValue&) const; bool isNull() const; bool isUndefined() const; + bool isObject() const; bool hasNoValue() const { return m_value == JSC::JSValue(); } private: diff --git a/src/3rdparty/webkit/WebCore/bindings/js/SerializedScriptValue.cpp b/src/3rdparty/webkit/WebCore/bindings/js/SerializedScriptValue.cpp new file mode 100644 index 000000000..48cd92d7c --- /dev/null +++ b/src/3rdparty/webkit/WebCore/bindings/js/SerializedScriptValue.cpp @@ -0,0 +1,839 @@ +/* + * 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" +#include "SerializedScriptValue.h" + +#include <runtime/DateInstance.h> +#include <runtime/ExceptionHelpers.h> +#include <runtime/PropertyNameArray.h> +#include <wtf/HashTraits.h> +#include <wtf/Vector.h> + +using namespace JSC; + +namespace WebCore { + +class SerializedObject : public SharedSerializedData +{ +public: + typedef Vector<RefPtr<StringImpl> > PropertyNameList; + typedef Vector<SerializedScriptValueData> ValueList; + + void set(const Identifier& propertyName, const SerializedScriptValueData& value) + { + ASSERT(m_names.size() == m_values.size()); + m_names.append(String(propertyName.ustring()).crossThreadString().impl()); + m_values.append(value); + } + + PropertyNameList& names() { return m_names; } + + ValueList& values() { return m_values; } + + static PassRefPtr<SerializedObject> create() + { + return adoptRef(new SerializedObject); + } + + void clear() + { + m_names.clear(); + m_values.clear(); + } + +private: + SerializedObject() { } + PropertyNameList m_names; + ValueList m_values; +}; + +class SerializedArray : public SharedSerializedData +{ + typedef HashMap<unsigned, SerializedScriptValueData, DefaultHash<unsigned>::Hash, WTF::UnsignedWithZeroKeyHashTraits<unsigned> > SparseMap; +public: + void setIndex(unsigned index, const SerializedScriptValueData& value) + { + ASSERT(index < m_length); + if (index == m_compactStorage.size()) + m_compactStorage.append(value); + else + m_sparseStorage.set(index, value); + } + + bool canDoFastRead(unsigned index) const + { + ASSERT(index < m_length); + return index < m_compactStorage.size(); + } + + const SerializedScriptValueData& getIndex(unsigned index) + { + ASSERT(index < m_compactStorage.size()); + return m_compactStorage[index]; + } + + SerializedScriptValueData getSparseIndex(unsigned index, bool& hasIndex) + { + ASSERT(index >= m_compactStorage.size()); + ASSERT(index < m_length); + SparseMap::iterator iter = m_sparseStorage.find(index); + if (iter == m_sparseStorage.end()) { + hasIndex = false; + return SerializedScriptValueData(); + } + hasIndex = true; + return iter->second; + } + + unsigned length() const + { + return m_length; + } + + static PassRefPtr<SerializedArray> create(unsigned length) + { + return adoptRef(new SerializedArray(length)); + } + + void clear() + { + m_compactStorage.clear(); + m_sparseStorage.clear(); + m_length = 0; + } +private: + SerializedArray(unsigned length) + : m_length(length) + { + } + + Vector<SerializedScriptValueData> m_compactStorage; + SparseMap m_sparseStorage; + unsigned m_length; +}; + +SerializedScriptValueData::SerializedScriptValueData(RefPtr<SerializedObject> data) + : m_type(ObjectType) + , m_sharedData(data) +{ +} + +SerializedScriptValueData::SerializedScriptValueData(RefPtr<SerializedArray> data) + : m_type(ArrayType) + , m_sharedData(data) +{ +} + +SerializedArray* SharedSerializedData::asArray() +{ + return static_cast<SerializedArray*>(this); +} + +SerializedObject* SharedSerializedData::asObject() +{ + return static_cast<SerializedObject*>(this); +} + +static const unsigned maximumFilterRecursion = 40000; +enum WalkerState { StateUnknown, ArrayStartState, ArrayStartVisitMember, ArrayEndVisitMember, + ObjectStartState, ObjectStartVisitMember, ObjectEndVisitMember }; +template <typename TreeWalker> typename TreeWalker::OutputType walk(TreeWalker& context, typename TreeWalker::InputType in) +{ + typedef typename TreeWalker::InputObject InputObject; + typedef typename TreeWalker::InputArray InputArray; + typedef typename TreeWalker::OutputObject OutputObject; + typedef typename TreeWalker::OutputArray OutputArray; + typedef typename TreeWalker::InputType InputType; + typedef typename TreeWalker::OutputType OutputType; + typedef typename TreeWalker::PropertyList PropertyList; + + Vector<uint32_t, 16> indexStack; + Vector<uint32_t, 16> lengthStack; + Vector<PropertyList, 16> propertyStack; + Vector<InputObject, 16> inputObjectStack; + Vector<InputArray, 16> inputArrayStack; + Vector<OutputObject, 16> outputObjectStack; + Vector<OutputArray, 16> outputArrayStack; + Vector<WalkerState, 16> stateStack; + WalkerState state = StateUnknown; + InputType inValue = in; + OutputType outValue = context.null(); + + unsigned tickCount = context.ticksUntilNextCheck(); + while (1) { + switch (state) { + arrayStartState: + case ArrayStartState: { + ASSERT(context.isArray(inValue)); + if (inputObjectStack.size() + inputArrayStack.size() > maximumFilterRecursion) { + context.throwStackOverflow(); + return context.null(); + } + + InputArray inArray = context.asInputArray(inValue); + unsigned length = context.length(inArray); + OutputArray outArray = context.createOutputArray(length); + if (!context.startArray(inArray, outArray)) + return context.null(); + inputArrayStack.append(inArray); + outputArrayStack.append(outArray); + indexStack.append(0); + lengthStack.append(length); + // fallthrough + } + arrayStartVisitMember: + case ArrayStartVisitMember: { + if (!--tickCount) { + if (context.didTimeOut()) { + context.throwInterruptedException(); + return context.null(); + } + tickCount = context.ticksUntilNextCheck(); + } + + InputArray array = inputArrayStack.last(); + uint32_t index = indexStack.last(); + if (index == lengthStack.last()) { + InputArray inArray = inputArrayStack.last(); + OutputArray outArray = outputArrayStack.last(); + context.endArray(inArray, outArray); + outValue = outArray; + inputArrayStack.removeLast(); + outputArrayStack.removeLast(); + indexStack.removeLast(); + lengthStack.removeLast(); + break; + } + if (context.canDoFastRead(array, index)) + inValue = context.getIndex(array, index); + else { + bool hasIndex = false; + inValue = context.getSparseIndex(array, index, hasIndex); + if (!hasIndex) { + indexStack.last()++; + goto arrayStartVisitMember; + } + } + + if (OutputType transformed = context.convertIfTerminal(inValue)) + outValue = transformed; + else { + stateStack.append(ArrayEndVisitMember); + goto stateUnknown; + } + // fallthrough + } + case ArrayEndVisitMember: { + OutputArray outArray = outputArrayStack.last(); + context.putProperty(outArray, indexStack.last(), outValue); + indexStack.last()++; + goto arrayStartVisitMember; + } + objectStartState: + case ObjectStartState: { + ASSERT(context.isObject(inValue)); + if (inputObjectStack.size() + inputArrayStack.size() > maximumFilterRecursion) { + context.throwStackOverflow(); + return context.null(); + } + InputObject inObject = context.asInputObject(inValue); + OutputObject outObject = context.createOutputObject(); + if (!context.startObject(inObject, outObject)) + return context.null(); + inputObjectStack.append(inObject); + outputObjectStack.append(outObject); + indexStack.append(0); + context.getPropertyNames(inObject, propertyStack); + // fallthrough + } + objectStartVisitMember: + case ObjectStartVisitMember: { + if (!--tickCount) { + if (context.didTimeOut()) { + context.throwInterruptedException(); + return context.null(); + } + tickCount = context.ticksUntilNextCheck(); + } + + InputObject object = inputObjectStack.last(); + uint32_t index = indexStack.last(); + PropertyList& properties = propertyStack.last(); + if (index == properties.size()) { + InputObject inObject = inputObjectStack.last(); + OutputObject outObject = outputObjectStack.last(); + context.endObject(inObject, outObject); + outValue = outObject; + inputObjectStack.removeLast(); + outputObjectStack.removeLast(); + indexStack.removeLast(); + propertyStack.removeLast(); + break; + } + inValue = context.getProperty(object, properties[index], index); + + if (context.shouldTerminate()) + return context.null(); + + if (OutputType transformed = context.convertIfTerminal(inValue)) + outValue = transformed; + else { + stateStack.append(ObjectEndVisitMember); + goto stateUnknown; + } + // fallthrough + } + case ObjectEndVisitMember: { + context.putProperty(outputObjectStack.last(), propertyStack.last()[indexStack.last()], outValue); + if (context.shouldTerminate()) + return context.null(); + + indexStack.last()++; + goto objectStartVisitMember; + } + stateUnknown: + case StateUnknown: + if (OutputType transformed = context.convertIfTerminal(inValue)) { + outValue = transformed; + break; + } + if (context.isArray(inValue)) + goto arrayStartState; + goto objectStartState; + } + if (stateStack.isEmpty()) + break; + + state = stateStack.last(); + stateStack.removeLast(); + + if (!--tickCount) { + if (context.didTimeOut()) { + context.throwInterruptedException(); + return context.null(); + } + tickCount = context.ticksUntilNextCheck(); + } + } + return outValue; +} + +struct BaseWalker { + BaseWalker(ExecState* exec) + : m_exec(exec) + , m_timeoutChecker(exec->globalData().timeoutChecker) + { + m_timeoutChecker.reset(); + } + ExecState* m_exec; + TimeoutChecker m_timeoutChecker; + MarkedArgumentBuffer m_gcBuffer; + + bool shouldTerminate() + { + return m_exec->hadException(); + } + + unsigned ticksUntilNextCheck() + { + return m_timeoutChecker.ticksUntilNextCheck(); + } + + bool didTimeOut() + { + return m_timeoutChecker.didTimeOut(m_exec); + } + + void throwStackOverflow() + { + m_exec->setException(createStackOverflowError(m_exec)); + } + + void throwInterruptedException() + { + m_exec->setException(createInterruptedExecutionException(&m_exec->globalData())); + } +}; + +struct SerializingTreeWalker : public BaseWalker { + typedef JSValue InputType; + typedef JSArray* InputArray; + typedef JSObject* InputObject; + typedef SerializedScriptValueData OutputType; + typedef RefPtr<SerializedArray> OutputArray; + typedef RefPtr<SerializedObject> OutputObject; + typedef PropertyNameArray PropertyList; + + SerializingTreeWalker(ExecState* exec) + : BaseWalker(exec) + { + } + + OutputType null() { return SerializedScriptValueData(); } + + bool isArray(JSValue value) + { + if (!value.isObject()) + return false; + JSObject* object = asObject(value); + return isJSArray(&m_exec->globalData(), object) || object->inherits(&JSArray::info); + } + + bool isObject(JSValue value) + { + return value.isObject(); + } + + JSArray* asInputArray(JSValue value) + { + return asArray(value); + } + + JSObject* asInputObject(JSValue value) + { + return asObject(value); + } + + PassRefPtr<SerializedArray> createOutputArray(unsigned length) + { + return SerializedArray::create(length); + } + + PassRefPtr<SerializedObject> createOutputObject() + { + return SerializedObject::create(); + } + + uint32_t length(JSValue array) + { + ASSERT(array.isObject()); + JSObject* object = asObject(array); + return object->get(m_exec, m_exec->propertyNames().length).toUInt32(m_exec); + } + + bool canDoFastRead(JSArray* array, unsigned index) + { + return isJSArray(&m_exec->globalData(), array) && array->canGetIndex(index); + } + + JSValue getIndex(JSArray* array, unsigned index) + { + return array->getIndex(index); + } + + JSValue getSparseIndex(JSObject* object, unsigned propertyName, bool& hasIndex) + { + PropertySlot slot(object); + if (object->getOwnPropertySlot(m_exec, propertyName, slot)) { + hasIndex = true; + return slot.getValue(m_exec, propertyName); + } + hasIndex = false; + return jsNull(); + } + + JSValue getProperty(JSObject* object, const Identifier& propertyName, unsigned) + { + PropertySlot slot(object); + if (object->getOwnPropertySlot(m_exec, propertyName, slot)) + return slot.getValue(m_exec, propertyName); + return jsNull(); + } + + SerializedScriptValueData convertIfTerminal(JSValue value) + { + if (!value.isCell()) + return SerializedScriptValueData(value); + + if (value.isString()) + return SerializedScriptValueData(asString(value)->value()); + + if (value.isNumber()) + return SerializedScriptValueData(SerializedScriptValueData::NumberType, value.uncheckedGetNumber()); + + if (value.isObject() && asObject(value)->inherits(&DateInstance::info)) + return SerializedScriptValueData(SerializedScriptValueData::DateType, asDateInstance(value)->internalNumber()); + + if (isArray(value)) + return SerializedScriptValueData(); + + CallData unusedData; + if (value.isObject() && value.getCallData(unusedData) == CallTypeNone) + return SerializedScriptValueData(); + + // Any other types are expected to serialize as null. + return SerializedScriptValueData(jsNull()); + } + + void getPropertyNames(JSObject* object, Vector<PropertyNameArray, 16>& propertyStack) + { + propertyStack.append(PropertyNameArray(m_exec)); + object->getOwnPropertyNames(m_exec, propertyStack.last()); + } + + void putProperty(RefPtr<SerializedArray> array, unsigned propertyName, const SerializedScriptValueData& value) + { + array->setIndex(propertyName, value); + } + + void putProperty(RefPtr<SerializedObject> object, const Identifier& propertyName, const SerializedScriptValueData& value) + { + object->set(propertyName, value); + } + + bool startArray(JSArray* inArray, RefPtr<SerializedArray>) + { + // Cycle detection + if (!m_cycleDetector.add(inArray).second) { + m_exec->setException(createTypeError(m_exec, "Cannot post cyclic structures.")); + return false; + } + m_gcBuffer.append(inArray); + return true; + } + + void endArray(JSArray* inArray, RefPtr<SerializedArray>) + { + m_cycleDetector.remove(inArray); + m_gcBuffer.removeLast(); + } + + bool startObject(JSObject* inObject, RefPtr<SerializedObject>) + { + // Cycle detection + if (!m_cycleDetector.add(inObject).second) { + m_exec->setException(createTypeError(m_exec, "Cannot post cyclic structures.")); + return false; + } + m_gcBuffer.append(inObject); + return true; + } + + void endObject(JSObject* inObject, RefPtr<SerializedObject>) + { + m_cycleDetector.remove(inObject); + m_gcBuffer.removeLast(); + } + +private: + HashSet<JSObject*> m_cycleDetector; +}; + +SerializedScriptValueData SerializedScriptValueData::serialize(ExecState* exec, JSValue inValue) +{ + SerializingTreeWalker context(exec); + return walk<SerializingTreeWalker>(context, inValue); +} + + +struct DeserializingTreeWalker : public BaseWalker { + typedef SerializedScriptValueData InputType; + typedef RefPtr<SerializedArray> InputArray; + typedef RefPtr<SerializedObject> InputObject; + typedef JSValue OutputType; + typedef JSArray* OutputArray; + typedef JSObject* OutputObject; + typedef SerializedObject::PropertyNameList PropertyList; + + DeserializingTreeWalker(ExecState* exec, bool mustCopy) + : BaseWalker(exec) + , m_mustCopy(mustCopy) + { + } + + OutputType null() { return jsNull(); } + + bool isArray(const SerializedScriptValueData& value) + { + return value.type() == SerializedScriptValueData::ArrayType; + } + + bool isObject(const SerializedScriptValueData& value) + { + return value.type() == SerializedScriptValueData::ObjectType; + } + + SerializedArray* asInputArray(const SerializedScriptValueData& value) + { + return value.asArray(); + } + + SerializedObject* asInputObject(const SerializedScriptValueData& value) + { + return value.asObject(); + } + + JSArray* createOutputArray(unsigned length) + { + JSArray* array = constructEmptyArray(m_exec); + array->setLength(length); + return array; + } + + JSObject* createOutputObject() + { + return constructEmptyObject(m_exec); + } + + uint32_t length(RefPtr<SerializedArray> array) + { + return array->length(); + } + + bool canDoFastRead(RefPtr<SerializedArray> array, unsigned index) + { + return array->canDoFastRead(index); + } + + SerializedScriptValueData getIndex(RefPtr<SerializedArray> array, unsigned index) + { + return array->getIndex(index); + } + + SerializedScriptValueData getSparseIndex(RefPtr<SerializedArray> array, unsigned propertyName, bool& hasIndex) + { + return array->getSparseIndex(propertyName, hasIndex); + } + + SerializedScriptValueData getProperty(RefPtr<SerializedObject> object, const RefPtr<StringImpl>& propertyName, unsigned propertyIndex) + { + ASSERT(object->names()[propertyIndex] == propertyName); + UNUSED_PARAM(propertyName); + return object->values()[propertyIndex]; + } + + JSValue convertIfTerminal(SerializedScriptValueData& value) + { + switch (value.type()) { + case SerializedScriptValueData::ArrayType: + case SerializedScriptValueData::ObjectType: + return JSValue(); + case SerializedScriptValueData::StringType: + return jsString(m_exec, value.asString().crossThreadString()); + case SerializedScriptValueData::ImmediateType: + return value.asImmediate(); + case SerializedScriptValueData::NumberType: + return jsNumber(m_exec, value.asDouble()); + case SerializedScriptValueData::DateType: + return new (m_exec) DateInstance(m_exec, value.asDouble()); + default: + ASSERT_NOT_REACHED(); + return JSValue(); + } + } + + void getPropertyNames(RefPtr<SerializedObject> object, Vector<SerializedObject::PropertyNameList, 16>& properties) + { + properties.append(object->names()); + } + + void putProperty(JSArray* array, unsigned propertyName, JSValue value) + { + array->put(m_exec, propertyName, value); + } + + void putProperty(JSObject* object, const RefPtr<StringImpl> propertyName, JSValue value) + { + object->putDirect(Identifier(m_exec, String(propertyName)), value); + } + + bool startArray(RefPtr<SerializedArray>, JSArray* outArray) + { + m_gcBuffer.append(outArray); + return true; + } + void endArray(RefPtr<SerializedArray>, JSArray*) + { + m_gcBuffer.removeLast(); + } + bool startObject(RefPtr<SerializedObject>, JSObject* outObject) + { + m_gcBuffer.append(outObject); + return true; + } + void endObject(RefPtr<SerializedObject>, JSObject*) + { + m_gcBuffer.removeLast(); + } + +private: + bool m_mustCopy; +}; + +JSValue SerializedScriptValueData::deserialize(ExecState* exec, bool mustCopy) const +{ + DeserializingTreeWalker context(exec, mustCopy); + return walk<DeserializingTreeWalker>(context, *this); +} + +struct TeardownTreeWalker { + typedef SerializedScriptValueData InputType; + typedef RefPtr<SerializedArray> InputArray; + typedef RefPtr<SerializedObject> InputObject; + typedef bool OutputType; + typedef bool OutputArray; + typedef bool OutputObject; + typedef SerializedObject::PropertyNameList PropertyList; + + bool shouldTerminate() + { + return false; + } + + unsigned ticksUntilNextCheck() + { + return 0xFFFFFFFF; + } + + bool didTimeOut() + { + return false; + } + + void throwStackOverflow() + { + } + + void throwInterruptedException() + { + } + + bool null() { return false; } + + bool isArray(const SerializedScriptValueData& value) + { + return value.type() == SerializedScriptValueData::ArrayType; + } + + bool isObject(const SerializedScriptValueData& value) + { + return value.type() == SerializedScriptValueData::ObjectType; + } + + SerializedArray* asInputArray(const SerializedScriptValueData& value) + { + return value.asArray(); + } + + SerializedObject* asInputObject(const SerializedScriptValueData& value) + { + return value.asObject(); + } + + bool createOutputArray(unsigned) + { + return false; + } + + bool createOutputObject() + { + return false; + } + + uint32_t length(RefPtr<SerializedArray> array) + { + return array->length(); + } + + bool canDoFastRead(RefPtr<SerializedArray> array, unsigned index) + { + return array->canDoFastRead(index); + } + + SerializedScriptValueData getIndex(RefPtr<SerializedArray> array, unsigned index) + { + return array->getIndex(index); + } + + SerializedScriptValueData getSparseIndex(RefPtr<SerializedArray> array, unsigned propertyName, bool& hasIndex) + { + return array->getSparseIndex(propertyName, hasIndex); + } + + SerializedScriptValueData getProperty(RefPtr<SerializedObject> object, const RefPtr<StringImpl>& propertyName, unsigned propertyIndex) + { + ASSERT(object->names()[propertyIndex] == propertyName); + UNUSED_PARAM(propertyName); + return object->values()[propertyIndex]; + } + + bool convertIfTerminal(SerializedScriptValueData& value) + { + switch (value.type()) { + case SerializedScriptValueData::ArrayType: + case SerializedScriptValueData::ObjectType: + return false; + case SerializedScriptValueData::StringType: + case SerializedScriptValueData::ImmediateType: + case SerializedScriptValueData::NumberType: + return true; + default: + ASSERT_NOT_REACHED(); + return JSValue(); + } + } + + void getPropertyNames(RefPtr<SerializedObject> object, Vector<SerializedObject::PropertyNameList, 16>& properties) + { + properties.append(object->names()); + } + + void putProperty(bool, unsigned, bool) + { + } + + void putProperty(bool, const RefPtr<StringImpl>&, bool) + { + } + + bool startArray(RefPtr<SerializedArray>, bool) + { + return true; + } + void endArray(RefPtr<SerializedArray> array, bool) + { + array->clear(); + } + bool startObject(RefPtr<SerializedObject>, bool) + { + return true; + } + void endObject(RefPtr<SerializedObject> object, bool) + { + object->clear(); + } +}; + +void SerializedScriptValueData::tearDownSerializedData() +{ + if (m_sharedData && m_sharedData->refCount() > 1) + return; + TeardownTreeWalker context; + walk<TeardownTreeWalker>(context, *this); +} + +} diff --git a/src/3rdparty/webkit/WebCore/bindings/js/SerializedScriptValue.h b/src/3rdparty/webkit/WebCore/bindings/js/SerializedScriptValue.h new file mode 100644 index 000000000..f8a126ff7 --- /dev/null +++ b/src/3rdparty/webkit/WebCore/bindings/js/SerializedScriptValue.h @@ -0,0 +1,199 @@ +/* + * 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. + * + */ + +#ifndef SerializedScriptValue_h +#define SerializedScriptValue_h + +#include "ScriptValue.h" + +namespace WebCore { + class SerializedObject; + class SerializedArray; + + class SharedSerializedData : public RefCounted<SharedSerializedData> { + public: + virtual ~SharedSerializedData() { } + SerializedArray* asArray(); + SerializedObject* asObject(); + }; + + class SerializedScriptValue; + + class SerializedScriptValueData { + public: + enum SerializedType { + EmptyType, + DateType, + NumberType, + ImmediateType, + ObjectType, + ArrayType, + StringType + }; + + SerializedType type() const { return m_type; } + static SerializedScriptValueData serialize(JSC::ExecState*, JSC::JSValue); + JSC::JSValue deserialize(JSC::ExecState*, bool mustCopy) const; + + ~SerializedScriptValueData() + { + if (m_sharedData) + tearDownSerializedData(); + } + + SerializedScriptValueData() + : m_type(EmptyType) + { + } + + explicit SerializedScriptValueData(const String& string) + : m_type(StringType) + , m_string(string.crossThreadString()) // FIXME: Should be able to just share the Rep + { + } + + explicit SerializedScriptValueData(JSC::JSValue value) + : m_type(ImmediateType) + { + ASSERT(!value.isCell()); + m_data.m_immediate = JSC::JSValue::encode(value); + } + + SerializedScriptValueData(SerializedType type, double value) + : m_type(type) + { + m_data.m_double = value; + } + + SerializedScriptValueData(RefPtr<SerializedObject>); + SerializedScriptValueData(RefPtr<SerializedArray>); + + JSC::JSValue asImmediate() const + { + ASSERT(m_type == ImmediateType); + return JSC::JSValue::decode(m_data.m_immediate); + } + + double asDouble() const + { + ASSERT(m_type == NumberType || m_type == DateType); + return m_data.m_double; + } + + String asString() const + { + ASSERT(m_type == StringType); + return m_string; + } + + SerializedObject* asObject() const + { + ASSERT(m_type == ObjectType); + ASSERT(m_sharedData); + return m_sharedData->asObject(); + } + + SerializedArray* asArray() const + { + ASSERT(m_type == ArrayType); + ASSERT(m_sharedData); + return m_sharedData->asArray(); + } + + operator bool() const { return m_type != EmptyType; } + + SerializedScriptValueData release() + { + SerializedScriptValueData result = *this; + *this = SerializedScriptValueData(); + return result; + } + + private: + void tearDownSerializedData(); + SerializedType m_type; + RefPtr<SharedSerializedData> m_sharedData; + String m_string; + union { + double m_double; + JSC::EncodedJSValue m_immediate; + } m_data; + }; + + class SerializedScriptValue : public RefCounted<SerializedScriptValue> { + public: + static PassRefPtr<SerializedScriptValue> create(JSC::ExecState* exec, JSC::JSValue value) + { + return adoptRef(new SerializedScriptValue(SerializedScriptValueData::serialize(exec, value))); + } + + static PassRefPtr<SerializedScriptValue> create(String string) + { + return adoptRef(new SerializedScriptValue(SerializedScriptValueData(string))); + } + + static PassRefPtr<SerializedScriptValue> create() + { + return adoptRef(new SerializedScriptValue(SerializedScriptValueData())); + } + + PassRefPtr<SerializedScriptValue> release() + { + PassRefPtr<SerializedScriptValue> result = adoptRef(new SerializedScriptValue(m_value)); + m_value = SerializedScriptValueData(); + result->m_mustCopy = true; + return result; + } + + String toString() + { + if (m_value.type() != SerializedScriptValueData::StringType) + return ""; + return m_value.asString(); + } + + JSC::JSValue deserialize(JSC::ExecState* exec) + { + if (!m_value) + return JSC::jsNull(); + return m_value.deserialize(exec, m_mustCopy); + } + + ~SerializedScriptValue() {} + + private: + SerializedScriptValue(SerializedScriptValueData value) + : m_value(value) + , m_mustCopy(false) + { + } + + SerializedScriptValueData m_value; + bool m_mustCopy; + }; +} + +#endif // SerializedScriptValue_h diff --git a/src/3rdparty/webkit/WebCore/bindings/js/WorkerScriptController.cpp b/src/3rdparty/webkit/WebCore/bindings/js/WorkerScriptController.cpp index fc3de3c96..b66b0e815 100644 --- a/src/3rdparty/webkit/WebCore/bindings/js/WorkerScriptController.cpp +++ b/src/3rdparty/webkit/WebCore/bindings/js/WorkerScriptController.cpp @@ -32,8 +32,10 @@ #include "JSDOMBinding.h" #include "JSDedicatedWorkerContext.h" +#include "JSSharedWorkerContext.h" #include "ScriptSourceCode.h" #include "ScriptValue.h" +#include "WorkerContext.h" #include "WorkerObjectProxy.h" #include "WorkerThread.h" #include <interpreter/Interpreter.h> @@ -50,6 +52,7 @@ WorkerScriptController::WorkerScriptController(WorkerContext* workerContext) , m_workerContext(workerContext) , m_executionForbidden(false) { + m_globalData->clientData = new WebCoreJSClientData(m_globalData.get()); } WorkerScriptController::~WorkerScriptController() @@ -73,12 +76,22 @@ void WorkerScriptController::initScript() RefPtr<Structure> workerContextPrototypeStructure = JSWorkerContextPrototype::createStructure(jsNull()); ProtectedPtr<JSWorkerContextPrototype> workerContextPrototype = new (m_globalData.get()) JSWorkerContextPrototype(workerContextPrototypeStructure.release()); - // FIXME: When we add SharedWorkerContext, generate the correct wrapper here. - RefPtr<Structure> dedicatedContextPrototypeStructure = JSDedicatedWorkerContextPrototype::createStructure(workerContextPrototype); - ProtectedPtr<JSDedicatedWorkerContextPrototype> dedicatedContextPrototype = new (m_globalData.get()) JSDedicatedWorkerContextPrototype(dedicatedContextPrototypeStructure.release()); - RefPtr<Structure> structure = JSDedicatedWorkerContext::createStructure(dedicatedContextPrototype); - - m_workerContextWrapper = new (m_globalData.get()) JSDedicatedWorkerContext(structure.release(), static_cast<DedicatedWorkerContext*>(m_workerContext)); + if (m_workerContext->isDedicatedWorkerContext()) { + RefPtr<Structure> dedicatedContextPrototypeStructure = JSDedicatedWorkerContextPrototype::createStructure(workerContextPrototype); + ProtectedPtr<JSDedicatedWorkerContextPrototype> dedicatedContextPrototype = new (m_globalData.get()) JSDedicatedWorkerContextPrototype(dedicatedContextPrototypeStructure.release()); + RefPtr<Structure> structure = JSDedicatedWorkerContext::createStructure(dedicatedContextPrototype); + + m_workerContextWrapper = new (m_globalData.get()) JSDedicatedWorkerContext(structure.release(), m_workerContext->toDedicatedWorkerContext()); +#if ENABLE(SHARED_WORKERS) + } else { + ASSERT(m_workerContext->isSharedWorkerContext()); + RefPtr<Structure> sharedContextPrototypeStructure = JSSharedWorkerContextPrototype::createStructure(workerContextPrototype); + ProtectedPtr<JSSharedWorkerContextPrototype> sharedContextPrototype = new (m_globalData.get()) JSSharedWorkerContextPrototype(sharedContextPrototypeStructure.release()); + RefPtr<Structure> structure = JSSharedWorkerContext::createStructure(sharedContextPrototype); + + m_workerContextWrapper = new (m_globalData.get()) JSSharedWorkerContext(structure.release(), m_workerContext->toSharedWorkerContext()); +#endif + } } ScriptValue WorkerScriptController::evaluate(const ScriptSourceCode& sourceCode) @@ -110,11 +123,9 @@ ScriptValue WorkerScriptController::evaluate(const ScriptSourceCode& sourceCode, ExecState* exec = m_workerContextWrapper->globalExec(); m_workerContextWrapper->globalData()->timeoutChecker.start(); - Completion comp = JSC::evaluate(exec, exec->dynamicGlobalObject()->globalScopeChain(), sourceCode.jsSourceCode(), m_workerContextWrapper); + Completion comp = evaluateInWorld(exec, exec->dynamicGlobalObject()->globalScopeChain(), sourceCode.jsSourceCode(), m_workerContextWrapper, currentWorld(exec)); m_workerContextWrapper->globalData()->timeoutChecker.stop(); - m_workerContext->thread()->workerObjectProxy().reportPendingActivity(m_workerContext->hasPendingActivity()); - if (comp.complType() == Normal || comp.complType() == ReturnValue) return comp.value(); diff --git a/src/3rdparty/webkit/WebCore/bindings/js/WorkerScriptController.h b/src/3rdparty/webkit/WebCore/bindings/js/WorkerScriptController.h index bb33f6082..c820cd936 100644 --- a/src/3rdparty/webkit/WebCore/bindings/js/WorkerScriptController.h +++ b/src/3rdparty/webkit/WebCore/bindings/js/WorkerScriptController.h @@ -62,6 +62,9 @@ namespace WebCore { void setException(ScriptValue); void forbidExecution(); + + JSC::JSGlobalData* globalData() { return m_globalData.get(); } + private: void initScriptIfNeeded() { |