#ifndef WorkerContext_h
#define WorkerContext_h
#if ENABLE(WORKERS)
#include "ContentSecurityPolicy.h"
#include "EventListener.h"
#include "EventNames.h"
#include "EventTarget.h"
#include "ScriptExecutionContext.h"
#include "WorkerEventQueue.h"
#include "WorkerScriptController.h"
#include <wtf/Assertions.h>
#include <wtf/HashMap.h>
#include <wtf/OwnPtr.h>
#include <wtf/PassRefPtr.h>
#include <wtf/RefCounted.h>
#include <wtf/RefPtr.h>
#include <wtf/text/AtomicStringHash.h>
namespace WebCore {
class Blob;
class DOMURL;
class ScheduledAction;
class WorkerInspectorController;
class WorkerLocation;
class WorkerNavigator;
class WorkerThread;
class WorkerContext : public RefCounted<WorkerContext>, public ScriptExecutionContext, public EventTarget {
public:
virtual ~WorkerContext();
virtual bool isWorkerContext() const { return true; }
virtual ScriptExecutionContext* scriptExecutionContext() const;
virtual bool isSharedWorkerContext() const { return false; }
virtual bool isDedicatedWorkerContext() const { return false; }
const KURL& url() const { return m_url; }
KURL completeURL(const String&) const;
virtual String userAgent(const KURL&) const;
virtual void disableEval();
WorkerScriptController* script() { return m_script.get(); }
void clearScript() { m_script.clear(); }
#if ENABLE(INSPECTOR)
void clearInspector();
#endif
WorkerThread* thread() const { return m_thread; }
bool hasPendingActivity() const;
virtual void postTask(PassOwnPtr<Task>);
WorkerContext* self() { return this; }
WorkerLocation* location() const;
void close();
DEFINE_ATTRIBUTE_EVENT_LISTENER(error);
virtual void importScripts(const Vector<String>& urls, ExceptionCode&);
WorkerNavigator* navigator() const;
int setTimeout(PassOwnPtr<ScheduledAction>, int timeout);
void clearTimeout(int timeoutId);
int setInterval(PassOwnPtr<ScheduledAction>, int timeout);
void clearInterval(int timeoutId);
virtual WorkerEventQueue* eventQueue() const;
virtual bool isContextThread() const;
virtual bool isJSExecutionForbidden() const;
#if ENABLE(INSPECTOR)
WorkerInspectorController* workerInspectorController() { return m_workerInspectorController.get(); }
#endif
WorkerNavigator* optionalNavigator() const { return m_navigator.get(); }
WorkerLocation* optionalLocation() const { return m_location.get(); }
using RefCounted<WorkerContext>::ref;
using RefCounted<WorkerContext>::deref;
bool isClosing() { return m_closing; }
class Observer {
WTF_MAKE_NONCOPYABLE(Observer);
public:
Observer(WorkerContext*);
virtual ~Observer();
virtual void notifyStop() = 0;
void stopObserving();
private:
WorkerContext* m_context;
};
friend class Observer;
void registerObserver(Observer*);
void unregisterObserver(Observer*);
void notifyObserversOfStop();
protected:
WorkerContext(const KURL&, const String&, WorkerThread*, const String& contentSecurityPolicy, ContentSecurityPolicy::HeaderType);
virtual void logExceptionToConsole(const String& errorMessage, const String& sourceURL, int lineNumber, PassRefPtr<ScriptCallStack>);
void addMessageToWorkerConsole(MessageSource, MessageType, MessageLevel, const String& message, const String& sourceURL, unsigned lineNumber, PassRefPtr<ScriptCallStack>);
private:
virtual void refScriptExecutionContext() { ref(); }
virtual void derefScriptExecutionContext() { deref(); }
virtual void refEventTarget() { ref(); }
virtual void derefEventTarget() { deref(); }
virtual EventTargetData* eventTargetData();
virtual EventTargetData* ensureEventTargetData();
virtual const KURL& virtualURL() const;
virtual KURL virtualCompleteURL(const String&) const;
virtual void addMessage(MessageSource, MessageType, MessageLevel, const String& message, const String& sourceURL, unsigned lineNumber, PassRefPtr<ScriptCallStack>);
virtual EventTarget* errorEventTarget();
KURL m_url;
String m_userAgent;
mutable RefPtr<WorkerLocation> m_location;
mutable RefPtr<WorkerNavigator> m_navigator;
OwnPtr<WorkerScriptController> m_script;
WorkerThread* m_thread;
#if ENABLE(BLOB)
mutable RefPtr<DOMURL> m_domURL;
#endif
#if ENABLE(INSPECTOR)
OwnPtr<WorkerInspectorController> m_workerInspectorController;
#endif
bool m_closing;
EventTargetData m_eventTargetData;
HashSet<Observer*> m_workerObservers;
OwnPtr<WorkerEventQueue> m_eventQueue;
};
}
#endif // ENABLE(WORKERS)
#endif // WorkerContext_h