#ifndef MessagePort_h
#define MessagePort_h
#include "AtomicStringHash.h"
#include "EventListener.h"
#include "EventTarget.h"
#include <wtf/HashMap.h>
#include <wtf/MessageQueue.h>
#include <wtf/PassRefPtr.h>
#include <wtf/RefPtr.h>
#include <wtf/Vector.h>
namespace WebCore {
class AtomicStringImpl;
class Event;
class Frame;
class ScriptExecutionContext;
class String;
class WorkerContext;
class MessagePort : public RefCounted<MessagePort>, public EventTarget {
public:
static PassRefPtr<MessagePort> create(ScriptExecutionContext* scriptExecutionContext) { return adoptRef(new MessagePort(scriptExecutionContext)); }
~MessagePort();
PassRefPtr<MessagePort> clone(ExceptionCode&);
bool active() const { return m_entangledPort; }
void postMessage(const String& message, ExceptionCode&);
void postMessage(const String& message, MessagePort*, ExceptionCode&);
PassRefPtr<MessagePort> startConversation(ScriptExecutionContext*, const String& message);
void start();
void close();
bool queueIsOpen() const { return m_queueIsOpen; }
MessagePort* entangledPort() { return m_entangledPort; }
static void entangle(MessagePort*, MessagePort*);
void unentangle();
void contextDestroyed();
void attachToContext(ScriptExecutionContext*);
virtual ScriptExecutionContext* scriptExecutionContext() const;
virtual MessagePort* toMessagePort() { return this; }
void queueCloseEvent();
void dispatchMessages();
virtual void addEventListener(const AtomicString& eventType, PassRefPtr<EventListener>, bool useCapture);
virtual void removeEventListener(const AtomicString& eventType, EventListener*, bool useCapture);
virtual bool dispatchEvent(PassRefPtr<Event>, ExceptionCode&);
typedef Vector<RefPtr<EventListener> > ListenerVector;
typedef HashMap<AtomicString, ListenerVector> EventListenersMap;
EventListenersMap& eventListeners() { return m_eventListeners; }
using RefCounted<MessagePort>::ref;
using RefCounted<MessagePort>::deref;
bool hasPendingActivity();
void setOnmessage(PassRefPtr<EventListener> eventListener) { m_onMessageListener = eventListener; }
EventListener* onmessage() const { return m_onMessageListener.get(); }
void setOnclose(PassRefPtr<EventListener> eventListener) { m_onCloseListener = eventListener; }
EventListener* onclose() const { return m_onCloseListener.get(); }
private:
friend class MessagePortCloseEventTask;
MessagePort(ScriptExecutionContext*);
virtual void refEventTarget() { ref(); }
virtual void derefEventTarget() { deref(); }
void dispatchCloseEvent();
MessagePort* m_entangledPort;
struct EventData : public RefCounted<EventData> {
static PassRefPtr<EventData> create(const String& message, PassRefPtr<MessagePort>);
~EventData();
String message;
RefPtr<MessagePort> messagePort;
private:
EventData(const String& message, PassRefPtr<MessagePort>);
};
MessageQueue<RefPtr<EventData> > m_messageQueue; bool m_queueIsOpen;
ScriptExecutionContext* m_scriptExecutionContext;
RefPtr<EventListener> m_onMessageListener;
RefPtr<EventListener> m_onCloseListener;
EventListenersMap m_eventListeners;
bool m_pendingCloseEvent; };
}
#endif // MessagePort_h