ScriptExecutionContext.h [plain text]
#ifndef ScriptExecutionContext_h
#define ScriptExecutionContext_h
#include "ActiveDOMObject.h"
#include "ConsoleTypes.h"
#include "KURL.h"
#include "SecurityContext.h"
#include "Supplementable.h"
#include <wtf/HashSet.h>
namespace JSC {
class ExecState;
class VM;
}
namespace WebCore {
class CachedScript;
class DatabaseContext;
class DOMTimer;
class EventListener;
class EventQueue;
class EventTarget;
class MessagePort;
class ScriptCallStack;
typedef JSC::ExecState ScriptState;
#if ENABLE(BLOB)
class PublicURLManager;
#endif
class ScriptExecutionContext : public SecurityContext, public Supplementable<ScriptExecutionContext> {
public:
ScriptExecutionContext();
virtual ~ScriptExecutionContext();
virtual bool isDocument() const { return false; }
virtual bool isWorkerContext() const { return false; }
virtual bool isContextThread() const { return true; }
virtual bool isJSExecutionForbidden() const = 0;
const KURL& url() const { return virtualURL(); }
KURL completeURL(const String& url) const { return virtualCompleteURL(url); }
virtual String userAgent(const KURL&) const = 0;
virtual void disableEval(const String& errorMessage) = 0;
bool sanitizeScriptError(String& errorMessage, int& lineNumber, String& sourceURL, CachedScript* = 0);
void reportException(const String& errorMessage, int lineNumber, int columnNumber, const String& sourceURL, PassRefPtr<ScriptCallStack>, CachedScript* = 0);
void addConsoleMessage(MessageSource, MessageLevel, const String& message, const String& sourceURL, unsigned lineNumber, unsigned columnNumber, ScriptState* = 0, unsigned long requestIdentifier = 0);
virtual void addConsoleMessage(MessageSource, MessageLevel, const String& message, unsigned long requestIdentifier = 0) = 0;
virtual SecurityOrigin* topOrigin() const = 0;
#if ENABLE(BLOB)
PublicURLManager& publicURLManager();
#endif
bool canSuspendActiveDOMObjects();
virtual void suspendActiveDOMObjects(ActiveDOMObject::ReasonForSuspension);
virtual void resumeActiveDOMObjects(ActiveDOMObject::ReasonForSuspension);
virtual void stopActiveDOMObjects();
bool activeDOMObjectsAreSuspended() const { return m_activeDOMObjectsAreSuspended; }
bool activeDOMObjectsAreStopped() const { return m_activeDOMObjectsAreStopped; }
void didCreateActiveDOMObject(ActiveDOMObject*);
void willDestroyActiveDOMObject(ActiveDOMObject*);
void suspendActiveDOMObjectIfNeeded(ActiveDOMObject*);
typedef HashSet<ActiveDOMObject*> ActiveDOMObjectsSet;
const ActiveDOMObjectsSet& activeDOMObjects() const { return m_activeDOMObjects; }
void didCreateDestructionObserver(ContextDestructionObserver*);
void willDestroyDestructionObserver(ContextDestructionObserver*);
void processMessagePortMessagesSoon();
void dispatchMessagePortEvents();
void createdMessagePort(MessagePort*);
void destroyedMessagePort(MessagePort*);
const HashSet<MessagePort*>& messagePorts() const { return m_messagePorts; }
void ref() { refScriptExecutionContext(); }
void deref() { derefScriptExecutionContext(); }
class Task {
WTF_MAKE_NONCOPYABLE(Task);
WTF_MAKE_FAST_ALLOCATED;
public:
Task() { }
virtual ~Task();
virtual void performTask(ScriptExecutionContext*) = 0;
virtual bool isCleanupTask() const { return false; }
};
virtual void postTask(PassOwnPtr<Task>) = 0;
int circularSequentialID();
bool addTimeout(int timeoutId, DOMTimer* timer) { return m_timeouts.add(timeoutId, timer).isNewEntry; }
void removeTimeout(int timeoutId) { m_timeouts.remove(timeoutId); }
DOMTimer* findTimeout(int timeoutId) { return m_timeouts.get(timeoutId); }
JSC::VM* vm();
void adjustMinimumTimerInterval(double oldMinimumTimerInterval);
virtual double minimumTimerInterval() const;
void didChangeTimerAlignmentInterval();
virtual double timerAlignmentInterval() const;
virtual EventQueue* eventQueue() const = 0;
#if ENABLE(SQL_DATABASE)
void setDatabaseContext(DatabaseContext*);
#endif
protected:
class AddConsoleMessageTask : public Task {
public:
static PassOwnPtr<AddConsoleMessageTask> create(MessageSource source, MessageLevel level, const String& message)
{
return adoptPtr(new AddConsoleMessageTask(source, level, message));
}
virtual void performTask(ScriptExecutionContext*);
private:
AddConsoleMessageTask(MessageSource source, MessageLevel level, const String& message)
: m_source(source)
, m_level(level)
, m_message(message.isolatedCopy())
{
}
MessageSource m_source;
MessageLevel m_level;
String m_message;
};
ActiveDOMObject::ReasonForSuspension reasonForSuspendingActiveDOMObjects() const { return m_reasonForSuspendingActiveDOMObjects; }
private:
virtual const KURL& virtualURL() const = 0;
virtual KURL virtualCompleteURL(const String&) const = 0;
virtual void addMessage(MessageSource, MessageLevel, const String& message, const String& sourceURL, unsigned lineNumber, unsigned columnNumber, PassRefPtr<ScriptCallStack>, ScriptState* = 0, unsigned long requestIdentifier = 0) = 0;
virtual EventTarget* errorEventTarget() = 0;
virtual void logExceptionToConsole(const String& errorMessage, const String& sourceURL, int lineNumber, int columnNumber, PassRefPtr<ScriptCallStack>) = 0;
bool dispatchErrorEvent(const String& errorMessage, int lineNumber, const String& sourceURL, CachedScript*);
void closeMessagePorts();
virtual void refScriptExecutionContext() = 0;
virtual void derefScriptExecutionContext() = 0;
HashSet<MessagePort*> m_messagePorts;
HashSet<ContextDestructionObserver*> m_destructionObservers;
ActiveDOMObjectsSet m_activeDOMObjects;
bool m_iteratingActiveDOMObjects;
bool m_inDestructor;
int m_circularSequentialID;
typedef HashMap<int, DOMTimer*> TimeoutMap;
TimeoutMap m_timeouts;
bool m_inDispatchErrorEvent;
class PendingException;
OwnPtr<Vector<OwnPtr<PendingException> > > m_pendingExceptions;
bool m_activeDOMObjectsAreSuspended;
ActiveDOMObject::ReasonForSuspension m_reasonForSuspendingActiveDOMObjects;
bool m_activeDOMObjectsAreStopped;
#if ENABLE(BLOB)
OwnPtr<PublicURLManager> m_publicURLManager;
#endif
#if ENABLE(SQL_DATABASE)
RefPtr<DatabaseContext> m_databaseContext;
#endif
};
}
#endif // ScriptExecutionContext_h