/*
* Copyright (C) 1999-2001 Harri Porten (porten@kde.org)
* 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.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#ifndef JSDOMBinding_h
#define JSDOMBinding_h
#include "JSDOMGlobalObject.h"
#include "JSDOMWrapper.h"
#include "DOMWrapperWorld.h"
#include "Document.h"
#include <heap/Weak.h>
#include <runtime/Completion.h>
#include <runtime/Lookup.h>
#include <wtf/Forward.h>
#include <wtf/Noncopyable.h>
namespace JSC {
class JSGlobalData;
class DebuggerCallFrame;
}
namespace WebCore {
class Document;
class Frame;
class JSNode;
class KURL;
class Node;
class ScriptController;
class ScriptCachedFrameData;
typedef int ExceptionCode;
// FIXME: This class should collapse into JSDOMWrapper once all JSDOMWrappers are
// updated to store a globalObject pointer.
class JSDOMWrapperWithGlobalPointer : public JSDOMWrapper {
public:
JSDOMGlobalObject* globalObject() const
{
return static_cast<JSDOMGlobalObject*>(JSDOMWrapper::globalObject());
}
ScriptExecutionContext* scriptExecutionContext() const
{
// FIXME: Should never be 0, but can be due to bug 27640.
return globalObject()->scriptExecutionContext();
}
static JSC::Structure* createStructure(JSC::JSGlobalData& globalData, JSC::JSValue prototype)
{
return JSC::Structure::create(globalData, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), AnonymousSlotCount, &s_info);
}
protected:
JSDOMWrapperWithGlobalPointer(JSC::Structure* structure, JSDOMGlobalObject* globalObject)
: JSDOMWrapper(globalObject, structure)
{
// FIXME: This ASSERT is valid, but fires in fast/dom/gc-6.html when trying to create
// new JavaScript objects on detached windows due to DOMWindow::document()
// needing to reach through the frame to get to the Document*. See bug 27640.
// ASSERT(globalObject->scriptExecutionContext());
}
};
// Base class for all constructor objects in the JSC bindings.
class DOMConstructorObject : public JSDOMWrapperWithGlobalPointer {
public:
static JSC::Structure* createStructure(JSC::JSGlobalData& globalData, JSC::JSValue prototype)
{
return JSC::Structure::create(globalData, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), AnonymousSlotCount, &s_info);
}
protected:
static const unsigned StructureFlags = JSC::ImplementsHasInstance | JSC::OverridesMarkChildren | JSDOMWrapperWithGlobalPointer::StructureFlags;
DOMConstructorObject(JSC::Structure* structure, JSDOMGlobalObject* globalObject)
: JSDOMWrapperWithGlobalPointer(structure, globalObject)
{
}
};
// Constructors using this base class depend on being in a Document and
// can never be used from a WorkerContext.
class DOMConstructorWithDocument : public DOMConstructorObject {
public:
Document* document() const
{
return static_cast<Document*>(scriptExecutionContext());
}
protected:
DOMConstructorWithDocument(JSC::Structure* structure, JSDOMGlobalObject* globalObject)
: DOMConstructorObject(structure, globalObject)
{
ASSERT(globalObject->scriptExecutionContext()->isDocument());
}
};
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*, JSC::Structure*, const JSC::ClassInfo*);
inline JSDOMGlobalObject* deprecatedGlobalObjectForPrototype(JSC::ExecState* exec)
{
// FIXME: Callers to this function should be using the global object
// from which the object is being created, instead of assuming the lexical one.
// e.g. subframe.document.body should use the subframe's global object, not the lexical one.
return static_cast<JSDOMGlobalObject*>(exec->lexicalGlobalObject());
}
template<class WrapperClass> inline JSC::Structure* getDOMStructure(JSC::ExecState* exec, JSDOMGlobalObject* globalObject)
{
if (JSC::Structure* structure = getCachedDOMStructure(globalObject, &WrapperClass::s_info))
return structure;
return cacheDOMStructure(globalObject, WrapperClass::createStructure(exec->globalData(), WrapperClass::createPrototype(exec, globalObject)), &WrapperClass::s_info);
}
template<class WrapperClass> inline JSC::Structure* deprecatedGetDOMStructure(JSC::ExecState* exec)
{
// FIXME: This function is wrong. It uses the wrong global object for creating the prototype structure.
return getDOMStructure<WrapperClass>(exec, deprecatedGlobalObjectForPrototype(exec));
}
template<class WrapperClass> inline JSC::JSObject* getDOMPrototype(JSC::ExecState* exec, JSC::JSGlobalObject* globalObject)
{
return static_cast<JSC::JSObject*>(asObject(getDOMStructure<WrapperClass>(exec, static_cast<JSDOMGlobalObject*>(globalObject))->storedPrototype()));
}
// Overload these functions to provide a fast path for wrapper access.
inline JSDOMWrapper* getInlineCachedWrapper(DOMWrapperWorld*, void*) { return 0; }
inline bool setInlineCachedWrapper(DOMWrapperWorld*, void*, JSDOMWrapper*) { return false; }
inline bool clearInlineCachedWrapper(DOMWrapperWorld*, void*, JSDOMWrapper*) { return false; }
// Overload these functions to provide a custom WeakHandleOwner.
inline JSC::WeakHandleOwner* wrapperOwner(DOMWrapperWorld* world, void*) { return world->defaultWrapperOwner(); }
inline void* wrapperContext(DOMWrapperWorld*, void* domObject) { return domObject; }
template <typename DOMClass> inline JSDOMWrapper* getCachedWrapper(DOMWrapperWorld* world, DOMClass* domObject)
{
if (JSDOMWrapper* wrapper = getInlineCachedWrapper(world, domObject))
return wrapper;
return world->m_wrappers.get(domObject).get();
}
template <typename DOMClass> inline void cacheWrapper(DOMWrapperWorld* world, DOMClass* domObject, JSDOMWrapper* wrapper)
{
if (setInlineCachedWrapper(world, domObject, wrapper))
return;
ASSERT(!world->m_wrappers.contains(domObject));
world->m_wrappers.set(domObject, JSC::Weak<JSDOMWrapper>(*world->globalData(), wrapper, wrapperOwner(world, domObject), wrapperContext(world, domObject)));
}
template <typename DOMClass> inline void uncacheWrapper(DOMWrapperWorld* world, DOMClass* domObject, JSDOMWrapper* wrapper)
{
if (clearInlineCachedWrapper(world, domObject, wrapper))
return;
ASSERT(world->m_wrappers.find(domObject)->second.get() == wrapper);
world->m_wrappers.remove(domObject);
}
#define CREATE_DOM_OBJECT_WRAPPER(exec, globalObject, className, object) createWrapper<JS##className>(exec, globalObject, static_cast<className*>(object))
#define CREATE_DOM_NODE_WRAPPER(exec, globalObject, className, object) static_cast<JSNode*>(createWrapper<JS##className>(exec, globalObject, static_cast<className*>(object)))
template<class WrapperClass, class DOMClass> inline JSDOMWrapper* createWrapper(JSC::ExecState* exec, JSDOMGlobalObject* globalObject, DOMClass* node)
{
ASSERT(node);
ASSERT(!getCachedWrapper(currentWorld(exec), node));
WrapperClass* wrapper = new (exec) WrapperClass(getDOMStructure<WrapperClass>(exec, globalObject), globalObject, node);
// FIXME: The entire function can be removed, once we fix caching.
// This function is a one-off hack to make Nodes cache in the right global object.
cacheWrapper(currentWorld(exec), node, wrapper);
return wrapper;
}
template<class WrapperClass, class DOMClass> inline JSC::JSValue wrap(JSC::ExecState* exec, JSDOMGlobalObject* globalObject, DOMClass* domObject)
{
if (!domObject)
return JSC::jsNull();
if (JSDOMWrapper* wrapper = getCachedWrapper(currentWorld(exec), domObject))
return wrapper;
return createWrapper<WrapperClass>(exec, globalObject, domObject);
}
const JSC::HashTable* getHashTableForGlobalData(JSC::JSGlobalData&, const JSC::HashTable* staticTable);
void reportException(JSC::ExecState*, JSC::JSValue exception);
void reportCurrentException(JSC::ExecState*);
// Convert a DOM implementation exception code into a JavaScript exception in the execution state.
void setDOMException(JSC::ExecState*, ExceptionCode);
JSC::JSValue jsString(JSC::ExecState*, const String&); // empty if the string is null
JSC::JSValue jsStringSlowCase(JSC::ExecState*, JSStringCache&, StringImpl*);
JSC::JSValue jsString(JSC::ExecState*, const KURL&); // empty if the URL is null
inline JSC::JSValue jsString(JSC::ExecState* exec, const AtomicString& s)
{
return jsString(exec, s.string());
}
JSC::JSValue jsStringOrNull(JSC::ExecState*, const String&); // null if the string is null
JSC::JSValue jsStringOrNull(JSC::ExecState*, const KURL&); // null if the URL is null
JSC::JSValue jsStringOrUndefined(JSC::ExecState*, const String&); // undefined if the string is null
JSC::JSValue jsStringOrUndefined(JSC::ExecState*, const KURL&); // undefined if the URL is null
JSC::JSValue jsStringOrFalse(JSC::ExecState*, const String&); // boolean false if the string is null
JSC::JSValue jsStringOrFalse(JSC::ExecState*, const KURL&); // boolean false if the URL is null
// See JavaScriptCore for explanation: Should be used for any string that is already owned by another
// object, to let the engine know that collecting the JSString wrapper is unlikely to save memory.
JSC::JSValue jsOwnedStringOrNull(JSC::ExecState*, const String&);
String identifierToString(const JSC::Identifier&);
String ustringToString(const JSC::UString&);
JSC::UString stringToUString(const String&);
AtomicString identifierToAtomicString(const JSC::Identifier&);
AtomicString ustringToAtomicString(const JSC::UString&);
AtomicStringImpl* findAtomicString(const JSC::Identifier&);
String valueToStringWithNullCheck(JSC::ExecState*, JSC::JSValue); // null if the value is null
String valueToStringWithUndefinedOrNullCheck(JSC::ExecState*, JSC::JSValue); // null if the value is null or undefined
inline int32_t finiteInt32Value(JSC::JSValue value, JSC::ExecState* exec, bool& okay)
{
double number = value.toNumber(exec);
okay = isfinite(number);
return JSC::toInt32(number);
}
// Returns a Date instance for the specified value, or null if the value is NaN or infinity.
JSC::JSValue jsDateOrNull(JSC::ExecState*, double);
// NaN if the value can't be converted to a date.
double valueToDate(JSC::ExecState*, JSC::JSValue);
// FIXME: These are a stop-gap until all toJS calls can be converted to pass a globalObject
template <typename T>
inline JSC::JSValue toJS(JSC::ExecState* exec, T* ptr)
{
return toJS(exec, deprecatedGlobalObjectForPrototype(exec), ptr);
}
template <typename T>
inline JSC::JSValue toJS(JSC::ExecState* exec, PassRefPtr<T> ptr)
{
return toJS(exec, deprecatedGlobalObjectForPrototype(exec), ptr.get());
}
template <typename T>
inline JSC::JSValue toJSNewlyCreated(JSC::ExecState* exec, T* ptr)
{
return toJSNewlyCreated(exec, deprecatedGlobalObjectForPrototype(exec), ptr);
}
template <typename T>
inline JSC::JSValue toJS(JSC::ExecState* exec, JSDOMGlobalObject* globalObject, PassRefPtr<T> ptr)
{
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.
// Besides the cross-domain check, they need non-caching versions of staticFunctionGetter for
// because we do not want current property values involved at all.
// FIXME: These functions should be named frameAllowsAccessFrom, because the access is *to* the frame.
bool allowsAccessFromFrame(JSC::ExecState*, Frame*);
bool allowsAccessFromFrame(JSC::ExecState*, Frame*, String& message);
DOMWindow* activeDOMWindow(JSC::ExecState*);
DOMWindow* firstDOMWindow(JSC::ExecState*);
void printErrorMessageForFrame(Frame*, const String& message);
JSC::JSValue objectToStringFunctionGetter(JSC::ExecState*, JSC::JSValue, const JSC::Identifier& propertyName);
Frame* toDynamicFrame(JSC::ExecState*);
bool processingUserGesture();
inline JSC::JSValue jsString(JSC::ExecState* exec, const String& s)
{
StringImpl* stringImpl = s.impl();
if (!stringImpl || !stringImpl->length())
return jsEmptyString(exec);
if (stringImpl->length() == 1 && stringImpl->characters()[0] <= 0xFF)
return jsString(exec, stringToUString(s));
JSStringCache& stringCache = currentWorld(exec)->m_stringCache;
if (JSC::JSString* wrapper = stringCache.get(stringImpl))
return wrapper;
return jsStringSlowCase(exec, stringCache, stringImpl);
}
inline DOMObjectWrapperMap& domObjectWrapperMapFor(JSC::ExecState* exec)
{
return currentWorld(exec)->m_wrappers;
}
inline String ustringToString(const JSC::UString& u)
{
return u.impl();
}
inline JSC::UString stringToUString(const String& s)
{
return JSC::UString(s.impl());
}
inline String identifierToString(const JSC::Identifier& i)
{
return i.impl();
}
inline AtomicString ustringToAtomicString(const JSC::UString& u)
{
return AtomicString(u.impl());
}
inline AtomicString identifierToAtomicString(const JSC::Identifier& identifier)
{
return AtomicString(identifier.impl());
}
} // namespace WebCore
#endif // JSDOMBinding_h