#include "config.h"
#include "MessagePort.h"
#include "DOMWindow.h"
#include "Document.h"
#include "EventException.h"
#include "EventNames.h"
#include "ExceptionCode.h"
#include "MessageEvent.h"
#include "SecurityOrigin.h"
#include "Timer.h"
#include "WorkerContext.h"
#include <wtf/text/AtomicString.h>
namespace WebCore {
MessagePort::MessagePort(ScriptExecutionContext& scriptExecutionContext)
: m_started(false)
, m_closed(false)
, m_scriptExecutionContext(&scriptExecutionContext)
{
m_scriptExecutionContext->createdMessagePort(this);
}
MessagePort::~MessagePort()
{
close();
if (m_scriptExecutionContext)
m_scriptExecutionContext->destroyedMessagePort(this);
}
void MessagePort::postMessage(PassRefPtr<SerializedScriptValue> message, MessagePort* port, ExceptionCode& ec)
{
MessagePortArray ports;
if (port)
ports.append(port);
postMessage(message, &ports, ec);
}
void MessagePort::postMessage(PassRefPtr<SerializedScriptValue> message, ExceptionCode& ec)
{
postMessage(message, static_cast<MessagePortArray*>(0), ec);
}
void MessagePort::postMessage(PassRefPtr<SerializedScriptValue> message, const MessagePortArray* ports, ExceptionCode& ec)
{
if (!isEntangled())
return;
ASSERT(m_scriptExecutionContext);
OwnPtr<MessagePortChannelArray> channels;
if (ports) {
for (unsigned int i = 0; i < ports->size(); ++i) {
MessagePort* dataPort = (*ports)[i].get();
if (dataPort == this || m_entangledChannel->isConnectedTo(dataPort)) {
ec = INVALID_STATE_ERR;
return;
}
}
channels = MessagePort::disentanglePorts(ports, ec);
if (ec)
return;
}
m_entangledChannel->postMessageToRemote(MessagePortChannel::EventData::create(message, channels.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 (!isEntangled())
return;
ASSERT(m_scriptExecutionContext);
if (m_started)
return;
m_started = true;
m_scriptExecutionContext->processMessagePortMessagesSoon();
}
void MessagePort::close()
{
m_closed = true;
if (!isEntangled())
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);
ASSERT(m_closed);
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)) {
#if ENABLE(WORKERS)
if (m_scriptExecutionContext->isWorkerContext() && static_cast<WorkerContext*>(m_scriptExecutionContext)->isClosing())
return;
#endif
OwnPtr<MessagePortArray> ports = MessagePort::entanglePorts(*m_scriptExecutionContext, eventData->channels());
RefPtr<Event> evt = MessageEvent::create(ports.release(), eventData->message());
ExceptionCode ec = 0;
dispatchEvent(evt.release(), ec);
ASSERT(!ec);
}
}
bool MessagePort::hasPendingActivity()
{
if (m_started && m_entangledChannel && m_entangledChannel->hasPendingActivity())
return true;
if (isEntangled() && !locallyEntangledPort())
return true;
return false;
}
MessagePort* MessagePort::locallyEntangledPort()
{
return m_entangledChannel ? m_entangledChannel->locallyEntangledPort(m_scriptExecutionContext) : 0;
}
PassOwnPtr<MessagePortChannelArray> MessagePort::disentanglePorts(const MessagePortArray* ports, ExceptionCode& ec)
{
if (!ports || !ports->size())
return nullptr;
HashSet<MessagePort*> portSet;
for (unsigned int i = 0; i < ports->size(); ++i) {
MessagePort* port = (*ports)[i].get();
if (!port || port->isCloned() || portSet.contains(port)) {
ec = INVALID_STATE_ERR;
return nullptr;
}
portSet.add(port);
}
OwnPtr<MessagePortChannelArray> portArray = adoptPtr(new MessagePortChannelArray(ports->size()));
for (unsigned int i = 0 ; i < ports->size() ; ++i) {
OwnPtr<MessagePortChannel> channel = (*ports)[i]->disentangle(ec);
ASSERT(!ec); (*portArray)[i] = channel.release();
}
return portArray.release();
}
PassOwnPtr<MessagePortArray> MessagePort::entanglePorts(ScriptExecutionContext& context, PassOwnPtr<MessagePortChannelArray> channels)
{
if (!channels || !channels->size())
return nullptr;
OwnPtr<MessagePortArray> portArray = adoptPtr(new MessagePortArray(channels->size()));
for (unsigned int i = 0; i < channels->size(); ++i) {
RefPtr<MessagePort> port = MessagePort::create(context);
port->entangle((*channels)[i].release());
(*portArray)[i] = port.release();
}
return portArray.release();
}
EventTargetData* MessagePort::eventTargetData()
{
return &m_eventTargetData;
}
EventTargetData* MessagePort::ensureEventTargetData()
{
return &m_eventTargetData;
}
}