#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 "ActiveDOMObject.h"
#include "DOMCoreException.h"
#include "Document.h"
#include "EventException.h"
#include "ExceptionCode.h"
#include "Frame.h"
#include "HTMLAudioElement.h"
#include "HTMLImageElement.h"
#include "HTMLScriptElement.h"
#include "HTMLNames.h"
#include "JSDOMCoreException.h"
#include "JSDOMWindowCustom.h"
#include "JSEventException.h"
#include "JSNode.h"
#include "JSRangeException.h"
#include "JSXMLHttpRequestException.h"
#include "KURL.h"
#include "MessagePort.h"
#include "RangeException.h"
#include "ScriptController.h"
#include "XMLHttpRequestException.h"
#include <runtime/PrototypeFunction.h>
#include <wtf/StdLibExtras.h>
#if ENABLE(SVG)
#include "JSSVGException.h"
#include "SVGException.h"
#endif
#if ENABLE(XPATH)
#include "JSXPathException.h"
#include "XPathException.h"
#endif
#if ENABLE(WORKERS)
#include <wtf/ThreadSpecific.h>
using namespace WTF;
#endif
using namespace JSC;
namespace WebCore {
using namespace HTMLNames;
typedef Document::JSWrapperCache JSWrapperCache;
static void addWrapper(DOMObject* wrapper);
static void removeWrapper(DOMObject* wrapper);
static void removeWrappers(const JSWrapperCache& wrappers);
#ifdef NDEBUG
static inline void addWrapper(DOMObject*)
{
}
static inline void removeWrapper(DOMObject*)
{
}
static inline void removeWrappers(const JSWrapperCache&)
{
}
#else
static HashSet<DOMObject*>& wrapperSet()
{
#if ENABLE(WORKERS)
DEFINE_STATIC_LOCAL(ThreadSpecific<HashSet<DOMObject*> >, staticWrapperSet, ());
return *staticWrapperSet;
#else
DEFINE_STATIC_LOCAL(HashSet<DOMObject*>, staticWrapperSet, ());
return staticWrapperSet;
#endif
}
static void addWrapper(DOMObject* wrapper)
{
ASSERT(!wrapperSet().contains(wrapper));
wrapperSet().add(wrapper);
}
static void removeWrapper(DOMObject* wrapper)
{
if (!wrapper)
return;
ASSERT(wrapperSet().contains(wrapper));
wrapperSet().remove(wrapper);
}
static void removeWrappers(const JSWrapperCache& wrappers)
{
for (JSWrapperCache::const_iterator it = wrappers.begin(); it != wrappers.end(); ++it)
removeWrapper(it->second);
}
DOMObject::~DOMObject()
{
ASSERT(!wrapperSet().contains(this));
}
#endif
class DOMObjectWrapperMap {
public:
static DOMObjectWrapperMap& mapFor(JSGlobalData&);
DOMObject* get(void* objectHandle)
{
return m_map.get(objectHandle);
}
void set(void* objectHandle, DOMObject* wrapper)
{
addWrapper(wrapper);
m_map.set(objectHandle, wrapper);
}
void remove(void* objectHandle)
{
removeWrapper(m_map.take(objectHandle));
}
private:
HashMap<void*, DOMObject*> m_map;
};
class DOMObjectHashTableMap {
public:
static DOMObjectHashTableMap& mapFor(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 JSGlobalData::ClientData {
public:
DOMObjectHashTableMap hashTableMap;
DOMObjectWrapperMap wrapperMap;
};
DOMObjectHashTableMap& DOMObjectHashTableMap::mapFor(JSGlobalData& globalData)
{
JSGlobalData::ClientData* clientData = globalData.clientData;
if (!clientData) {
clientData = new WebCoreJSClientData;
globalData.clientData = clientData;
}
return static_cast<WebCoreJSClientData*>(clientData)->hashTableMap;
}
const JSC::HashTable* getHashTableForGlobalData(JSGlobalData& globalData, const JSC::HashTable* staticTable)
{
return DOMObjectHashTableMap::mapFor(globalData).get(staticTable);
}
inline DOMObjectWrapperMap& DOMObjectWrapperMap::mapFor(JSGlobalData& globalData)
{
JSGlobalData::ClientData* clientData = globalData.clientData;
if (!clientData) {
clientData = new WebCoreJSClientData;
globalData.clientData = clientData;
}
return static_cast<WebCoreJSClientData*>(clientData)->wrapperMap;
}
DOMObject* getCachedDOMObjectWrapper(JSGlobalData& globalData, void* objectHandle)
{
return DOMObjectWrapperMap::mapFor(globalData).get(objectHandle);
}
void cacheDOMObjectWrapper(JSGlobalData& globalData, void* objectHandle, DOMObject* wrapper)
{
DOMObjectWrapperMap::mapFor(globalData).set(objectHandle, wrapper);
}
void forgetDOMObject(JSGlobalData& globalData, void* objectHandle)
{
DOMObjectWrapperMap::mapFor(globalData).remove(objectHandle);
}
JSNode* getCachedDOMNodeWrapper(Document* document, Node* node)
{
if (!document)
return static_cast<JSNode*>(DOMObjectWrapperMap::mapFor(*JSDOMWindow::commonJSGlobalData()).get(node));
return document->wrapperCache().get(node);
}
void forgetDOMNode(Document* document, Node* node)
{
if (!document) {
DOMObjectWrapperMap::mapFor(*JSDOMWindow::commonJSGlobalData()).remove(node);
return;
}
removeWrapper(document->wrapperCache().take(node));
}
void cacheDOMNodeWrapper(Document* document, Node* node, JSNode* wrapper)
{
if (!document) {
DOMObjectWrapperMap::mapFor(*JSDOMWindow::commonJSGlobalData()).set(node, wrapper);
return;
}
addWrapper(wrapper);
document->wrapperCache().set(node, wrapper);
}
void forgetAllDOMNodesForDocument(Document* document)
{
ASSERT(document);
removeWrappers(document->wrapperCache());
}
static inline bool isObservableThroughDOM(JSNode* jsNode)
{
Node* node = jsNode->impl();
if (node->inDocument()) {
if (jsNode->hasCustomProperties())
return true;
if (node->eventListeners().size())
return true; } else {
if (node->hasTagName(imgTag) && !static_cast<HTMLImageElement*>(node)->haveFiredLoadEvent())
return true;
if (node->hasTagName(scriptTag) && !static_cast<HTMLScriptElement*>(node)->haveFiredLoadEvent())
return true;
#if ENABLE(VIDEO)
if (node->hasTagName(audioTag) && !static_cast<HTMLAudioElement*>(node)->paused())
return true;
#endif
}
return false;
}
void markDOMNodesForDocument(Document* doc)
{
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();
}
}
void markActiveObjectsForContext(JSGlobalData& globalData, ScriptExecutionContext* scriptExecutionContext)
{
const HashMap<ActiveDOMObject*, void*>& activeObjects = scriptExecutionContext->activeDOMObjects();
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);
if (wrapper && !wrapper->marked())
wrapper->mark();
}
}
const HashSet<MessagePort*>& messagePorts = scriptExecutionContext->messagePorts();
HashSet<MessagePort*>::const_iterator portsEnd = messagePorts.end();
for (HashSet<MessagePort*>::const_iterator iter = messagePorts.begin(); iter != portsEnd; ++iter) {
if (!(*iter)->locallyEntangledPort() || (*iter)->hasPendingActivity()) {
DOMObject* wrapper = getCachedDOMObjectWrapper(globalData, *iter);
if (wrapper && !wrapper->marked())
wrapper->mark();
}
}
}
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);
}
void markDOMObjectWrapper(JSGlobalData& globalData, void* object)
{
if (!object)
return;
DOMObject* wrapper = getCachedDOMObjectWrapper(globalData, object);
if (!wrapper || wrapper->marked())
return;
wrapper->mark();
}
JSValue jsStringOrNull(ExecState* exec, const String& s)
{
if (s.isNull())
return jsNull();
return jsString(exec, s);
}
JSValue jsOwnedStringOrNull(ExecState* exec, const UString& s)
{
if (s.isNull())
return jsNull();
return jsOwnedString(exec, s);
}
JSValue jsStringOrUndefined(ExecState* exec, const String& s)
{
if (s.isNull())
return jsUndefined();
return jsString(exec, s);
}
JSValue jsStringOrFalse(ExecState* exec, const String& s)
{
if (s.isNull())
return jsBoolean(false);
return jsString(exec, s);
}
JSValue jsStringOrNull(ExecState* exec, const KURL& url)
{
if (url.isNull())
return jsNull();
return jsString(exec, url.string());
}
JSValue jsStringOrUndefined(ExecState* exec, const KURL& url)
{
if (url.isNull())
return jsUndefined();
return jsString(exec, url.string());
}
JSValue jsStringOrFalse(ExecState* exec, const KURL& url)
{
if (url.isNull())
return jsBoolean(false);
return jsString(exec, url.string());
}
UString valueToStringWithNullCheck(ExecState* exec, JSValue value)
{
if (value.isNull())
return UString();
return value.toString(exec);
}
UString valueToStringWithUndefinedOrNullCheck(ExecState* exec, JSValue value)
{
if (value.isUndefinedOrNull())
return UString();
return value.toString(exec);
}
void reportException(ExecState* exec, JSValue exception)
{
UString errorMessage = exception.toString(exec);
JSObject* exceptionObject = exception.toObject(exec);
int lineNumber = exceptionObject->get(exec, Identifier(exec, "line")).toInt32(exec);
UString exceptionSourceURL = exceptionObject->get(exec, Identifier(exec, "sourceURL")).toString(exec);
exec->clearException();
ScriptExecutionContext* scriptExecutionContext = static_cast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
ASSERT(scriptExecutionContext);
if (!scriptExecutionContext)
return;
scriptExecutionContext->reportException(errorMessage, lineNumber, exceptionSourceURL);
}
void reportCurrentException(ExecState* exec)
{
JSValue exception = exec->exception();
exec->clearException();
reportException(exec, exception);
}
void setDOMException(ExecState* exec, ExceptionCode ec)
{
if (!ec || exec->hadException())
return;
ExceptionCodeDescription description;
getExceptionCodeDescription(ec, description);
JSValue errorObject;
switch (description.type) {
case DOMExceptionType:
errorObject = toJS(exec, DOMCoreException::create(description));
break;
case RangeExceptionType:
errorObject = toJS(exec, RangeException::create(description));
break;
case EventExceptionType:
errorObject = toJS(exec, EventException::create(description));
break;
case XMLHttpRequestExceptionType:
errorObject = toJS(exec, XMLHttpRequestException::create(description));
break;
#if ENABLE(SVG)
case SVGExceptionType:
errorObject = toJS(exec, SVGException::create(description).get(), 0);
break;
#endif
#if ENABLE(XPATH)
case XPathExceptionType:
errorObject = toJS(exec, XPathException::create(description));
break;
#endif
}
ASSERT(errorObject);
exec->setException(errorObject);
}
bool checkNodeSecurity(ExecState* exec, Node* node)
{
return node && allowsAccessFromFrame(exec, node->document()->frame());
}
bool allowsAccessFromFrame(ExecState* exec, Frame* frame)
{
if (!frame)
return false;
JSDOMWindow* window = toJSDOMWindow(frame);
return window && window->allowsAccessFrom(exec);
}
bool allowsAccessFromFrame(ExecState* exec, Frame* frame, String& message)
{
if (!frame)
return false;
JSDOMWindow* window = toJSDOMWindow(frame);
return window && window->allowsAccessFrom(exec, message);
}
bool shouldAllowNavigation(ExecState* exec, Frame* frame)
{
Frame* lexicalFrame = toLexicalFrame(exec);
return lexicalFrame && lexicalFrame->loader()->shouldAllowNavigation(frame);
}
void printErrorMessageForFrame(Frame* frame, const String& message)
{
if (!frame)
return;
if (JSDOMWindow* window = toJSDOMWindow(frame))
window->printErrorMessage(message);
}
Frame* toLexicalFrame(ExecState* exec)
{
return asJSDOMWindow(exec->lexicalGlobalObject())->impl()->frame();
}
Frame* toDynamicFrame(ExecState* exec)
{
return asJSDOMWindow(exec->dynamicGlobalObject())->impl()->frame();
}
bool processingUserGesture(ExecState* exec)
{
Frame* frame = toDynamicFrame(exec);
return frame && frame->script()->processingUserGesture();
}
KURL completeURL(ExecState* exec, const String& relativeURL)
{
Frame* frame = toDynamicFrame(exec);
if (!frame)
return KURL();
return frame->loader()->completeURL(relativeURL);
}
JSValue objectToStringFunctionGetter(ExecState* exec, const Identifier& propertyName, const PropertySlot&)
{
return new (exec) NativeFunctionWrapper(exec, exec->lexicalGlobalObject()->prototypeFunctionStructure(), 0, propertyName, objectProtoFuncToString);
}
Structure* getCachedDOMStructure(JSDOMGlobalObject* globalObject, const ClassInfo* classInfo)
{
JSDOMStructureMap& structures = globalObject->structures();
return structures.get(classInfo).get();
}
Structure* cacheDOMStructure(JSDOMGlobalObject* globalObject, PassRefPtr<Structure> structure, const ClassInfo* classInfo)
{
JSDOMStructureMap& structures = globalObject->structures();
ASSERT(!structures.contains(classInfo));
return structures.set(classInfo, structure).first->second.get();
}
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)
{
return cacheDOMStructure(static_cast<JSDOMGlobalObject*>(exec->lexicalGlobalObject()), structure, classInfo);
}
JSObject* getCachedDOMConstructor(ExecState* exec, const ClassInfo* classInfo)
{
JSDOMConstructorMap& constructors = static_cast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->constructors();
return constructors.get(classInfo);
}
void cacheDOMConstructor(ExecState* exec, const ClassInfo* classInfo, JSObject* constructor)
{
JSDOMConstructorMap& constructors = static_cast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->constructors();
ASSERT(!constructors.contains(classInfo));
constructors.set(classInfo, constructor);
}
}