| /* |
| * Copyright (C) 2009 Google Inc. All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions are |
| * met: |
| * |
| * * Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * * Redistributions in binary form must reproduce the above |
| * copyright notice, this list of conditions and the following disclaimer |
| * in the documentation and/or other materials provided with the |
| * distribution. |
| * * Neither the name of Google Inc. nor the names of its |
| * contributors may be used to endorse or promote products derived from |
| * this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
| * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
| * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
| * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
| * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| |
| #include "config.h" |
| #include "PlatformMessagePortChannel.h" |
| |
| #include "MessagePort.h" |
| #include "ScriptExecutionContext.h" |
| |
| namespace WebCore { |
| |
| // MessagePortChannel implementations - just delegate to the PlatformMessagePortChannel. |
| void MessagePortChannel::createChannel(PassRefPtr<MessagePort> port1, PassRefPtr<MessagePort> port2) |
| { |
| PlatformMessagePortChannel::createChannel(port1, port2); |
| } |
| |
| PassOwnPtr<MessagePortChannel> MessagePortChannel::create(PassRefPtr<PlatformMessagePortChannel> channel) |
| { |
| return new MessagePortChannel(channel); |
| } |
| |
| MessagePortChannel::MessagePortChannel(PassRefPtr<PlatformMessagePortChannel> channel) |
| : m_channel(channel) |
| { |
| } |
| |
| MessagePortChannel::~MessagePortChannel() |
| { |
| // Make sure we close our platform channel when the base is freed, to keep the channel objects from leaking. |
| m_channel->close(); |
| } |
| |
| bool MessagePortChannel::entangleIfOpen(MessagePort* port) |
| { |
| return m_channel->entangleIfOpen(port); |
| } |
| |
| void MessagePortChannel::disentangle() |
| { |
| m_channel->disentangle(); |
| } |
| |
| void MessagePortChannel::postMessageToRemote(PassOwnPtr<MessagePortChannel::EventData> message) |
| { |
| m_channel->postMessageToRemote(message); |
| } |
| |
| bool MessagePortChannel::tryGetMessageFromRemote(OwnPtr<MessagePortChannel::EventData>& result) |
| { |
| return m_channel->tryGetMessageFromRemote(result); |
| } |
| |
| void MessagePortChannel::close() |
| { |
| m_channel->close(); |
| } |
| |
| bool MessagePortChannel::isConnectedTo(MessagePort* port) |
| { |
| return m_channel->isConnectedTo(port); |
| } |
| |
| bool MessagePortChannel::hasPendingActivity() |
| { |
| return m_channel->hasPendingActivity(); |
| } |
| |
| MessagePort* MessagePortChannel::locallyEntangledPort(const ScriptExecutionContext* context) |
| { |
| return m_channel->locallyEntangledPort(context); |
| } |
| |
| PassRefPtr<PlatformMessagePortChannel> PlatformMessagePortChannel::create(PassRefPtr<MessagePortQueue> incoming, PassRefPtr<MessagePortQueue> outgoing) |
| { |
| return adoptRef(new PlatformMessagePortChannel(incoming, outgoing)); |
| } |
| |
| PlatformMessagePortChannel::PlatformMessagePortChannel(PassRefPtr<MessagePortQueue> incoming, PassRefPtr<MessagePortQueue> outgoing) |
| : m_entangledChannel(0) |
| , m_incomingQueue(incoming) |
| , m_outgoingQueue(outgoing) |
| , m_remotePort(0) |
| { |
| } |
| |
| PlatformMessagePortChannel::~PlatformMessagePortChannel() |
| { |
| } |
| |
| void PlatformMessagePortChannel::createChannel(PassRefPtr<MessagePort> port1, PassRefPtr<MessagePort> port2) |
| { |
| // Create incoming/outgoing queues. |
| RefPtr<PlatformMessagePortChannel::MessagePortQueue> queue1 = PlatformMessagePortChannel::MessagePortQueue::create(); |
| RefPtr<PlatformMessagePortChannel::MessagePortQueue> queue2 = PlatformMessagePortChannel::MessagePortQueue::create(); |
| |
| // Create proxies for each endpoint. |
| RefPtr<PlatformMessagePortChannel> channel1 = PlatformMessagePortChannel::create(queue1, queue2); |
| RefPtr<PlatformMessagePortChannel> channel2 = PlatformMessagePortChannel::create(queue2, queue1); |
| |
| // Entangle the two endpoints. |
| channel1->setEntangledChannel(channel2); |
| channel2->setEntangledChannel(channel1); |
| |
| // Now entangle the proxies with the appropriate local ports. |
| port1->entangle(MessagePortChannel::create(channel2)); |
| port2->entangle(MessagePortChannel::create(channel1)); |
| } |
| |
| bool PlatformMessagePortChannel::entangleIfOpen(MessagePort* port) |
| { |
| // We can't call member functions on our remote pair while holding our mutex or we'll deadlock, but we need to guard against the remote port getting closed/freed, so create a standalone reference. |
| RefPtr<PlatformMessagePortChannel> remote = entangledChannel(); |
| if (!remote) |
| return false; |
| remote->setRemotePort(port); |
| return true; |
| } |
| |
| void PlatformMessagePortChannel::disentangle() |
| { |
| RefPtr<PlatformMessagePortChannel> remote = entangledChannel(); |
| if (remote) |
| remote->setRemotePort(0); |
| } |
| |
| void PlatformMessagePortChannel::setRemotePort(MessagePort* port) |
| { |
| MutexLocker lock(m_mutex); |
| // Should never set port if it is already set. |
| ASSERT(!port || !m_remotePort); |
| m_remotePort = port; |
| } |
| |
| MessagePort* PlatformMessagePortChannel::remotePort() |
| { |
| MutexLocker lock(m_mutex); |
| return m_remotePort; |
| } |
| |
| PassRefPtr<PlatformMessagePortChannel> PlatformMessagePortChannel::entangledChannel() |
| { |
| MutexLocker lock(m_mutex); |
| return m_entangledChannel; |
| } |
| |
| void PlatformMessagePortChannel::setEntangledChannel(PassRefPtr<PlatformMessagePortChannel> remote) |
| { |
| MutexLocker lock(m_mutex); |
| // Should only be set as part of initial creation/entanglement. |
| if (remote) |
| ASSERT(!m_entangledChannel.get()); |
| m_entangledChannel = remote; |
| } |
| |
| void PlatformMessagePortChannel::postMessageToRemote(PassOwnPtr<MessagePortChannel::EventData> message) |
| { |
| MutexLocker lock(m_mutex); |
| if (!m_outgoingQueue) |
| return; |
| bool wasEmpty = m_outgoingQueue->appendAndCheckEmpty(message); |
| if (wasEmpty && m_remotePort) |
| m_remotePort->messageAvailable(); |
| } |
| |
| bool PlatformMessagePortChannel::tryGetMessageFromRemote(OwnPtr<MessagePortChannel::EventData>& result) |
| { |
| MutexLocker lock(m_mutex); |
| result = m_incomingQueue->tryGetMessage(); |
| return result; |
| } |
| |
| bool PlatformMessagePortChannel::isConnectedTo(MessagePort* port) |
| { |
| MutexLocker lock(m_mutex); |
| return m_remotePort == port; |
| } |
| |
| // Closes the port so no further messages can be sent from either end. |
| void PlatformMessagePortChannel::close() |
| { |
| RefPtr<PlatformMessagePortChannel> remote = entangledChannel(); |
| if (!remote) |
| return; |
| closeInternal(); |
| remote->closeInternal(); |
| } |
| |
| void PlatformMessagePortChannel::closeInternal() |
| { |
| MutexLocker lock(m_mutex); |
| // Disentangle ourselves from the other end. We still maintain a reference to our incoming queue, since previously-existing messages should still be delivered. |
| m_remotePort = 0; |
| m_entangledChannel = 0; |
| m_outgoingQueue = 0; |
| } |
| |
| bool PlatformMessagePortChannel::hasPendingActivity() |
| { |
| MutexLocker lock(m_mutex); |
| return !m_incomingQueue->isEmpty(); |
| } |
| |
| MessagePort* PlatformMessagePortChannel::locallyEntangledPort(const ScriptExecutionContext* context) |
| { |
| MutexLocker lock(m_mutex); |
| // See if both contexts are run by the same thread (are the same context, or are both documents). |
| if (m_remotePort) { |
| // The remote port's ScriptExecutionContext is guaranteed not to change here - MessagePort::contextDestroyed() will close the port before the context goes away, and close() will block because we are holding the mutex. |
| ScriptExecutionContext* remoteContext = m_remotePort->scriptExecutionContext(); |
| if (remoteContext == context || (remoteContext && remoteContext->isDocument() && context->isDocument())) |
| return m_remotePort; |
| } |
| return 0; |
| } |
| |
| } // namespace WebCore |