/*

 * 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"

#include "SerializedScriptValue.h"

#include "WebKit.h"

#include "WebKitClient.h"

#include "WebMessagePortChannel.h"

#include "WebString.h"

using namespace WebKit;

namespace WebCore {

PassOwnPtr<MessagePortChannel> MessagePortChannel::create(PassRefPtr<PlatformMessagePortChannel> channel)

{

    return new MessagePortChannel(channel);

}

void MessagePortChannel::createChannel(PassRefPtr<MessagePort> port1, PassRefPtr<MessagePort> port2)

{

    PlatformMessagePortChannel::createChannel(port1, port2);

}

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)

{

    // This is just an optimization, so return 0 always.

    return 0;

}

PassRefPtr<PlatformMessagePortChannel> PlatformMessagePortChannel::create()

{

    return adoptRef(new PlatformMessagePortChannel());

}

PassRefPtr<PlatformMessagePortChannel> PlatformMessagePortChannel::create(

    WebMessagePortChannel* channel)

{

    return adoptRef(new PlatformMessagePortChannel(channel));

}

PlatformMessagePortChannel::PlatformMessagePortChannel()

    : m_localPort(0)

{

    m_webChannel = webKitClient()->createMessagePortChannel();

    if (m_webChannel)

        m_webChannel->setClient(this);

}

PlatformMessagePortChannel::PlatformMessagePortChannel(WebMessagePortChannel* channel)

    : m_localPort(0)

    , m_webChannel(channel)

{

}

PlatformMessagePortChannel::~PlatformMessagePortChannel()

{

    if (m_webChannel)

        m_webChannel->destroy();

}

void PlatformMessagePortChannel::createChannel(PassRefPtr<MessagePort> port1, PassRefPtr<MessagePort> port2)

{

    // Create proxies for each endpoint.

    RefPtr<PlatformMessagePortChannel> channel1 = PlatformMessagePortChannel::create();

    RefPtr<PlatformMessagePortChannel> channel2 = PlatformMessagePortChannel::create();

    // 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));

}

void PlatformMessagePortChannel::messageAvailable()

{

    MutexLocker lock(m_mutex);

    if (m_localPort)

        m_localPort->messageAvailable();

}

bool PlatformMessagePortChannel::entangleIfOpen(MessagePort* port)

{

    MutexLocker lock(m_mutex);

    m_localPort = port;

    return true;

}

void PlatformMessagePortChannel::disentangle()

{

    MutexLocker lock(m_mutex);

    m_localPort = 0;

}

void PlatformMessagePortChannel::postMessageToRemote(PassOwnPtr<MessagePortChannel::EventData> message)

{

    if (!m_localPort || !m_webChannel)

        return;

    WebString messageString = message->message()->toWireString();

    OwnPtr<WebCore::MessagePortChannelArray> channels = message->channels();

    WebMessagePortChannelArray* webChannels = 0;

    if (channels.get() && channels->size()) {

        webChannels = new WebMessagePortChannelArray(channels->size());

        for (size_t i = 0; i < channels->size(); ++i) {

            WebCore::PlatformMessagePortChannel* platformChannel = (*channels)[i]->channel();

            (*webChannels)[i] = platformChannel->webChannelRelease();

            (*webChannels)[i]->setClient(0);

        }

    }

    m_webChannel->postMessage(messageString, webChannels);

}

bool PlatformMessagePortChannel::tryGetMessageFromRemote(OwnPtr<MessagePortChannel::EventData>& result)

{

    if (!m_webChannel)

        return false;

    WebString message;

    WebMessagePortChannelArray webChannels;

    bool rv = m_webChannel->tryGetMessage(&message, webChannels);

    if (rv) {

        OwnPtr<MessagePortChannelArray> channels;

        if (webChannels.size()) {

            channels = new MessagePortChannelArray(webChannels.size());

            for (size_t i = 0; i < webChannels.size(); ++i) {

                RefPtr<PlatformMessagePortChannel> platformChannel = create(webChannels[i]);

                webChannels[i]->setClient(platformChannel.get());

                (*channels)[i] = MessagePortChannel::create(platformChannel);

            }

        }

        RefPtr<SerializedScriptValue> serializedMessage = SerializedScriptValue::createFromWire(message);

        result = MessagePortChannel::EventData::create(serializedMessage.release(), channels.release());

    }

    return rv;

}

void PlatformMessagePortChannel::close()

{

    MutexLocker lock(m_mutex);

    // Disentangle ourselves from the other end.  We still maintain a reference to m_webChannel,

    // since previously-existing messages should still be delivered.

    m_localPort = 0;

    m_entangledChannel = 0;

}

bool PlatformMessagePortChannel::isConnectedTo(MessagePort* port)

{

    MutexLocker lock(m_mutex);

    return m_entangledChannel && m_entangledChannel->m_localPort == port;

}

bool PlatformMessagePortChannel::hasPendingActivity()

{

    MutexLocker lock(m_mutex);

    return m_localPort;

}

void PlatformMessagePortChannel::setEntangledChannel(PassRefPtr<PlatformMessagePortChannel> remote)

{

    if (m_webChannel)

        m_webChannel->entangle(remote->m_webChannel);

    MutexLocker lock(m_mutex);

    m_entangledChannel = remote;

}

WebMessagePortChannel* PlatformMessagePortChannel::webChannelRelease()

{

    WebMessagePortChannel* rv = m_webChannel;

    m_webChannel = 0;

    return rv;

}

} // namespace WebCore