#include "config.h"
#include "MessagePort.h"
#include "AtomicString.h"
#include "DOMWindow.h"
#include "Document.h"
#include "EventException.h"
#include "EventNames.h"
#include "MessageEvent.h"
#include "SecurityOrigin.h"
#include "Timer.h"
namespace WebCore {
MessagePort::MessagePort(ScriptExecutionContext& scriptExecutionContext)
: m_entangledChannel(0)
, m_started(false)
, m_scriptExecutionContext(&scriptExecutionContext)
{
m_scriptExecutionContext->createdMessagePort(this);
}
MessagePort::~MessagePort()
{
close();
if (m_scriptExecutionContext)
m_scriptExecutionContext->destroyedMessagePort(this);
}
void MessagePort::postMessage(const String& message, ExceptionCode& ec)
{
postMessage(message, 0, ec);
}
void MessagePort::postMessage(const String& message, MessagePort* dataPort, ExceptionCode& ec)
{
if (!m_entangledChannel)
return;
ASSERT(m_scriptExecutionContext);
OwnPtr<MessagePortChannel> channel;
if (dataPort) {
if (dataPort == this || m_entangledChannel->isConnectedTo(dataPort)) {
ec = INVALID_STATE_ERR;
return;
}
channel = dataPort->disentangle(ec);
if (ec)
return;
}
m_entangledChannel->postMessageToRemote(MessagePortChannel::EventData::create(message, channel.release()));
}
PassOwnPtr<MessagePortChannel> MessagePort::disentangle(ExceptionCode& ec)
{
if (!m_entangledChannel)
ec = INVALID_STATE_ERR;
else {
m_entangledChannel->disentangle();
ASSERT(m_scriptExecutionContext);
m_scriptExecutionContext->destroyedMessagePort(this);
m_scriptExecutionContext = 0;
}
return m_entangledChannel.release();
}
void MessagePort::messageAvailable()
{
ASSERT(m_scriptExecutionContext);
m_scriptExecutionContext->processMessagePortMessagesSoon();
}
void MessagePort::start()
{
if (!m_entangledChannel)
return;
ASSERT(m_scriptExecutionContext);
if (m_started)
return;
m_started = true;
m_scriptExecutionContext->processMessagePortMessagesSoon();
}
void MessagePort::close()
{
if (!m_entangledChannel)
return;
m_entangledChannel->close();
}
void MessagePort::entangle(PassOwnPtr<MessagePortChannel> remote)
{
ASSERT(!m_entangledChannel);
ASSERT(m_scriptExecutionContext);
if (remote->entangleIfOpen(this))
m_entangledChannel = remote;
}
void MessagePort::contextDestroyed()
{
ASSERT(m_scriptExecutionContext);
close();
m_scriptExecutionContext = 0;
}
ScriptExecutionContext* MessagePort::scriptExecutionContext() const
{
return m_scriptExecutionContext;
}
void MessagePort::dispatchMessages()
{
ASSERT(started());
OwnPtr<MessagePortChannel::EventData> eventData;
while (m_entangledChannel && m_entangledChannel->tryGetMessageFromRemote(eventData)) {
RefPtr<MessagePort> port;
OwnPtr<MessagePortChannel> channel = eventData->channel();
if (channel) {
port = MessagePort::create(*m_scriptExecutionContext);
port->entangle(channel.release());
}
RefPtr<Event> evt = MessageEvent::create(eventData->message(), "", "", 0, port.release());
if (m_onMessageListener) {
evt->setTarget(this);
evt->setCurrentTarget(this);
m_onMessageListener->handleEvent(evt.get(), false);
}
ExceptionCode ec = 0;
dispatchEvent(evt.release(), ec);
ASSERT(!ec);
}
}
void MessagePort::addEventListener(const AtomicString& eventType, PassRefPtr<EventListener> eventListener, bool)
{
EventListenersMap::iterator iter = m_eventListeners.find(eventType);
if (iter == m_eventListeners.end()) {
ListenerVector listeners;
listeners.append(eventListener);
m_eventListeners.add(eventType, listeners);
} else {
ListenerVector& listeners = iter->second;
for (ListenerVector::iterator listenerIter = listeners.begin(); listenerIter != listeners.end(); ++listenerIter) {
if (*listenerIter == eventListener)
return;
}
listeners.append(eventListener);
m_eventListeners.add(eventType, listeners);
}
}
void MessagePort::removeEventListener(const AtomicString& eventType, EventListener* eventListener, bool)
{
EventListenersMap::iterator iter = m_eventListeners.find(eventType);
if (iter == m_eventListeners.end())
return;
ListenerVector& listeners = iter->second;
for (ListenerVector::const_iterator listenerIter = listeners.begin(); listenerIter != listeners.end(); ++listenerIter) {
if (*listenerIter == eventListener) {
listeners.remove(listenerIter - listeners.begin());
return;
}
}
}
bool MessagePort::dispatchEvent(PassRefPtr<Event> event, ExceptionCode& ec)
{
if (!event || event->type().isEmpty()) {
ec = EventException::UNSPECIFIED_EVENT_TYPE_ERR;
return true;
}
ListenerVector listenersCopy = m_eventListeners.get(event->type());
for (ListenerVector::const_iterator listenerIter = listenersCopy.begin(); listenerIter != listenersCopy.end(); ++listenerIter) {
event->setTarget(this);
event->setCurrentTarget(this);
listenerIter->get()->handleEvent(event.get(), false);
}
return !event->defaultPrevented();
}
void MessagePort::setOnmessage(PassRefPtr<EventListener> eventListener)
{
m_onMessageListener = eventListener;
start();
}
bool MessagePort::hasPendingActivity()
{
return m_started && m_entangledChannel && m_entangledChannel->hasPendingActivity();
}
MessagePort* MessagePort::locallyEntangledPort()
{
return m_entangledChannel ? m_entangledChannel->locallyEntangledPort(m_scriptExecutionContext) : 0;
}
}