#if OS(SYMBIAN)

#include <platform/rpipe.h>

#endif

#if OS(SYMBIAN)

    typedef RPipe* Identifier;

#else

#endif

#if OS(SYMBIAN)

	RPipe m_readPipe;

    RPipe m_writePipe;

    QSymbianPipeNotifier* m_pipeReadNotifier; 

    struct ParsedMessage { 

        uint8_t* start ; // base address of message

        uint32_t size ;  // size in bytes

        uint32_t messageID;        

    };

#else

#endif

#if PLATFORM(QT) && !OS(SYMBIAN)

#endif

#include "config.h"

#if PLATFORM(QT) && OS(SYMBIAN)

#include "Connection.h"

#include "ArgumentEncoder.h"

#include "WorkItem.h"

#include <QVector>

#include <qt/QSymbianPipeNotifier.h>

#include <wtf/Assertions.h>

namespace CoreIPC {

static const uint32_t trailer = 0xDEADCAFE;

void Connection::platformInitialize(Identifier identifier)

{

    if (m_isServer) {

        m_readPipe = static_cast<RPipe*>(identifier)[0];

        m_writePipe = static_cast<RPipe*>(identifier)[1];

    } else {

        TInt error;

        // Open pipes via RProcess' "environment data slots" number 3 & 4

        // This is the Symbian OS way of passing handles from parent to child

        error = m_readPipe.Open(3); 

        error|= m_writePipe.Open(4);

        if (error) { 

            m_isConnected = false;

            return;

        }

    }

    m_readBuffer.resize(CoreIPC::Connection::MaxPipeCapacity);

    m_isConnected = true; 

}

void Connection::platformInvalidate()

{

    m_readBuffer.shrink(0);

    delete m_pipeReadNotifier;

    m_readPipe.Close();

    m_writePipe.Close();

    // TODO: delete the memory for the RPipe[2] array

    m_isConnected = false;

}

// Check if the data matches the trailer pattern

static inline bool isMessageTrailer(uint8_t *data) 

{  

    return ( trailer == *(reinterpret_cast<uint32_t*>(data)) );  

}

// Handler for "bytes available to read" event on pipe

void Connection::readyReadHandler()

{

    RProcess proc;

    m_pipeReadNotifier->setEnabled(false);

    // Make a temporary Symbian descriptor to point to existing buffer, with 0 current size, and a max size

    TPtr8 readPtr(m_readBuffer.data(), 0, m_readBuffer.size());

    // Read all the bytes we can. Note that multiple messages can be read in one read operation due to the stream-oriented channel

    TInt bytesRead = m_readPipe.Read(readPtr, readPtr.MaxSize());

    if (bytesRead > 0) {

        __ASSERT_ALWAYS(bytesRead == readPtr.Size(), User::Invariant());

        // Start parsing from the end of the buffer, where we expect to see a trailer and the size of this message

        uint8_t* messageStart = m_readBuffer.data() + bytesRead;

        // Place to keep track of parsed messages

        QVector<ParsedMessage> messsagePointers;

        while (true) {

            messageStart -= sizeof(uint32_t); // move back pointer to read trailer             

            if (!isMessageTrailer(messageStart)) // bail if no trailer 

                break; 

            messageStart -= sizeof(uint32_t); // move back pointer to read messageSize

            uint32_t messageSize = *reinterpret_cast<uint32_t*>(messageStart); 

            messageStart -= sizeof(uint32_t); // move back to read messageID

            uint32_t messageID = *reinterpret_cast<uint32_t*>(messageStart); 

            messageStart -= (messageSize - sizeof(uint32_t)); 

            // Keep a note of message boundary

            const ParsedMessage aMessage = {messageStart, messageSize - sizeof(uint32_t), messageID};

            messsagePointers.append(aMessage); 

            __ASSERT_ALWAYS(messageStart >=  m_readBuffer.data(), User::Invariant());

            if (messageStart == m_readBuffer.data()) 

                break;

        } // while loop

        // Now dispatch parsed messages in the order they were written by the sender

        for (int i = messsagePointers.size()-1; i >=0 ; i--) { 

            const ParsedMessage aMessage = messsagePointers.at(i);

            processIncomingMessage(MessageID::fromInt(aMessage.messageID), adoptPtr(new ArgumentDecoder(aMessage.start, aMessage.size)));

        }

    } 

    m_pipeReadNotifier->setEnabled(true);

}

bool Connection::open()

{

    // platformInitialize() should have taken care of the connection by now

    if (!m_isConnected) 

        return false; 

    // Start listening for read 

    m_pipeReadNotifier = m_connectionQueue.registerPipeEventHandler(m_readPipe, QSymbianPipeNotifier::PipeReadDataAvailable, WorkItem::create(this, &Connection::readyReadHandler));

    // Schedule a read.

    m_connectionQueue.scheduleWork(WorkItem::create(this, &Connection::readyReadHandler));

    return true;

}

bool Connection::platformCanSendOutgoingMessages() const

{

    // Seems adequate for now  

    return true;

}

bool Connection::sendOutgoingMessage(MessageID messageID, PassOwnPtr<ArgumentEncoder> arguments)

{    

    // Encode messageID. 

    arguments->encodeUInt32(messageID.toInt());

    // Encode size of message excluding this 4-byte field and the 4-byte trailer which follows.

    arguments->encodeUInt32(arguments->bufferSize());

    // a trailer marker (magic number) which makes it easier to spot mesage boundary at the receiver

    arguments->encodeUInt32(trailer);

    // Write to pipe using a temporary Symbian descriptor

    TPtr8 writeBuffer(arguments->buffer(), arguments->bufferSize(), arguments->bufferSize() );

    TInt bytesWritten = m_writePipe.Write(writeBuffer, writeBuffer.Size() );     

    return (bytesWritten ==  writeBuffer.Size());

}

} // namespace CoreIPC

#endif

#include "config.h"

#if PLATFORM (QT) && OS(SYMBIAN)

#include "QObject"

#include "QDebug"

#include "QCoreApplication"

#include "QEvent"

#include "QSymbianPipeNotifier.h"

#include "SymbianPipeActiveObject.h"

#include <platform/rpipe.h>

// Wrapper QObject around a Symbian Active Object (AO). We must use use an active object

// while registering asynchronous notification requests (e.g data available to read/space available to write) 

// on native Symbian IPC APIs such as RPipe

QSymbianPipeNotifier::QSymbianPipeNotifier(RPipe& pipe, EventType type, int bytes, QObject *parent) 

    :m_pipe(pipe), m_type(type), m_bytes(bytes), QObject(parent)

{

    d_ptr = new SymbianPipeActiveObject(pipe, type, bytes, this);

}

QSymbianPipeNotifier::~QSymbianPipeNotifier() 

{

    delete d_ptr;

}

void QSymbianPipeNotifier::setEnabled(bool enabled) 

{ 

    if (!d_ptr) { 

        // deferred initialization via postEvent(). Useful when a moveToThread() requires the Active Object to 

        // be deleted and re-created on the new thread. 

        QEvent *postThreadChangeEvent = new QEvent(PostThreadChangeEventType);

        QCoreApplication::postEvent(this, postThreadChangeEvent);

        return; 

    }

    d_ptr->setEnabled(enabled);       

}

// Symbian active objects (AOs) are bound to an "active scheduler" which is thread-local.

// Therefore, to allow moveToThread() to work correctly with the parent QObject we need to 

// delete the AO and re-create it once the execution moves to the new thread

bool QSymbianPipeNotifier::event(QEvent* ev)

{        

    if (ev->type() == QEvent::ThreadChange) { // pre-migration event

        if (d_ptr) { 

            if (d_ptr->IsAdded()) {

                bool oldState = d_ptr->IsActive();

                d_ptr->Deque(); // cancel outstanding request + remove from active scheduler

            }     

            delete d_ptr; 

            d_ptr = 0; 

        }

        // Fire a deferred re-initialization request

        QEvent *postThreadChangeEvent = new QEvent(PostThreadChangeEventType);

        QCoreApplication::postEvent(this, postThreadChangeEvent);

        return true;

    } 

    if (ev->type() == PostThreadChangeEventType) { // custom, post-migration event

        if (!d_ptr) { 

            d_ptr = new SymbianPipeActiveObject(m_pipe, m_type, m_bytes, this);

            // FIXME: We presumptively enable watch, even though client may have called

            // setEnabled(false) before the call to moveToThread()

            d_ptr->setEnabled(true);

        }

        return true; 

    }

    return false; 

}

#endif

#ifndef QSYMBIANPIPENOTIFIER_H_

#define QSYMBIANPIPENOTIFIER_H_

#include <QObject>

#include <QEvent>

#include <platform/rpipe.h>

class SymbianPipeActiveObject;

// This class wraps a friendly QObject interface around a Symbian

// active object (AO). The AO helps us watch for data available (for read) 

// or write space available events on Symbian RPipe objects.  

class QSymbianPipeNotifier : public QObject

{

    Q_OBJECT

public: 

    enum EventType {

        // data can be read

        PipeReadDataAvailable,

        // write pipe can take more data

        PipeWriteSpaceAvailable

    };

    QSymbianPipeNotifier(RPipe&, EventType, int, QObject *parent = 0);

    virtual ~QSymbianPipeNotifier();

    bool event(QEvent*);

public slots:

    void setEnabled(bool);

signals:

    // emitted when PipeReadDataAvailable occurs

    void readyToRead(int);

    // emitted when PipeWriteSpaceAvailable occurs

    void readyToWrite(int);

    void errorOccured(int);

protected:

    SymbianPipeActiveObject* d_ptr;

private: 

    // We need to delete and re-create SymbianPipeActiveObject to 

    // enable QObject->moveToThread() on this object, so break PIMPL

    // rules, and keep some c'tor args around 

    RPipe m_pipe; 

    EventType m_type;

    int m_bytes;   

    // Custom event to help with QObject->moveToThread() 

    static const QEvent::Type PostThreadChangeEventType = (QEvent::Type)(QEvent::User + 100);

    friend class SymbianPipeActiveObject;

    Q_DISABLE_COPY(QSymbianPipeNotifier)

};

#endif // QSYMBIANPIPENOTIFIER_H_

#include "config.h"

#if PLATFORM(QT) && OS(SYMBIAN)

#include "SymbianPipeActiveObject.h"

#include "QSymbianPipeNotifier.h"

#include <platform/rpipe.h>

// The Symbian Active Object that registers notification requests with the kernel, similar to POSIX's select() system call

// Note that unlike anything on Unix, Symbian Active Objects are schedulable objects that are bound to the current thread's Active Scheduler. 

// Therefore they are a lightweight version of threads from a resource utilization POV. 

SymbianPipeActiveObject::SymbianPipeActiveObject(RPipe pipe, QSymbianPipeNotifier::EventType type, int spaceInBytes, QSymbianPipeNotifier *qq)

    : CActive(CActive::EPriorityStandard), m_pipe(pipe), m_type(type), m_bytes(spaceInBytes), q_ptr(qq) 

{ 

    CActiveScheduler::Add(this);

}

SymbianPipeActiveObject::~SymbianPipeActiveObject() 

{ 

    Cancel();

}

void SymbianPipeActiveObject::setEnabled(bool enabled) 

{

    // start listening

    if (enabled && !IsActive()) {  

        if (m_type == QSymbianPipeNotifier::PipeReadDataAvailable) { 

            m_pipe.NotifyDataAvailable(iStatus);

            SetActive(); // base class method to declare the above request as "pending" completion

        }

        if (m_type == QSymbianPipeNotifier::PipeWriteSpaceAvailable) {

            int freeSpaceNeeded = m_bytes < 0 ? 1 : m_bytes; 

            m_pipe.NotifySpaceAvailable(freeSpaceNeeded, iStatus);

            SetActive(); // base class method to declare the above request as "pending" completion

        }

        return;

    }

    // stop listening

    if (!enabled) {

        Cancel(); // Automatically leads to a DoCancel() 

        return;

    }

}

// This method gets run by the Symbian OS Active Scheduler when the

// request initiated by NotifyDataAvailable above is marked as completed

// We send a Qt signal via our parent QObject, and then implicitly go

// into a disabled state, i.e notifications are off  

void SymbianPipeActiveObject::RunL() 

{

    Q_Q(QSymbianPipeNotifier);

    if (iStatus != KErrNone) {

        emit q->errorOccured(iStatus.Int());

        return; 

    }

    if (m_type == QSymbianPipeNotifier::PipeReadDataAvailable) {

        const int bytesAvailable =  m_pipe.Size(); // peek bytes available to read

        if (bytesAvailable > 0) {  

            emit q->readyToRead(bytesAvailable);

            return; 

        }

    }

    if (m_type == QSymbianPipeNotifier::PipeWriteSpaceAvailable) { 

        emit q->readyToWrite(0);

        return;

    }

}

void SymbianPipeActiveObject::DoCancel() 

{ 

    if (m_type == QSymbianPipeNotifier::PipeReadDataAvailable) { 

        m_pipe.CancelDataAvailable();

        return;

    }

    if (m_type == QSymbianPipeNotifier::PipeWriteSpaceAvailable) { 

        m_pipe.CancelSpaceAvailable();

        return;

    }

}

#endif

#ifndef SymbianPipeActiveObject_h

#define SymbianPipeActiveObject_h

#include <e32base.h>

#include "QSymbianPipeNotifier.h"

#include "qglobal.h"

#include <platform/rpipe.h>

class SymbianPipeActiveObject : public CActive {

public:

    SymbianPipeActiveObject(RPipe, QSymbianPipeNotifier::EventType, int, QSymbianPipeNotifier *);

    ~SymbianPipeActiveObject();

private:

    void setEnabled(bool);

    void RunL();

    void DoCancel(); 

    RPipe m_pipe;

    QSymbianPipeNotifier::EventType m_type;

    int m_bytes; // only used for write pipe; -1 means unused

    QSymbianPipeNotifier * q_ptr;

    Q_DECLARE_PUBLIC(QSymbianPipeNotifier)

};

#endif // SymbianPipeActiveObject_h

#if OS(SYMBIAN)

typedef RProcess* PlatformProcessIdentifier;

#else

#endif

#if OS(SYMBIAN)

        mutable uint32_t m_name;

#else

#endif

#if OS(SYMBIAN)

    int m_handle;

#else

#endif

#if OS(SYMBIAN)

#include "qt/QSymbianPipeNotifier.h"

#endif

#if OS(SYMBIAN)

    QSymbianPipeNotifier* registerPipeEventHandler(RPipe pipe, QSymbianPipeNotifier::EventType type, PassOwnPtr<WorkItem> workItem);

#else

#endif

#if PLATFORM(QT) && !OS(SYMBIAN)

#endif

#include "config.h"

#if PLATFORM(QT) && OS(SYMBIAN)

#include "SharedMemory.h"

#include "ArgumentDecoder.h"

#include "ArgumentEncoder.h"

#include <sys/param.h>

#include <e32math.h>

namespace WebKit {

_LIT(KFormatToString,"%d");

SharedMemory::Handle::Handle()

    : m_name(0) , m_size(0)

{

}

SharedMemory::Handle::~Handle()

{   

}

bool SharedMemory::Handle::isNull() const

{

    return m_name == 0;

}

void SharedMemory::Handle::encode(CoreIPC::ArgumentEncoder* encoder) const

{

    ASSERT(!isNull());    

    encoder->encodeUInt32(m_size);

    // name of the global chunk (masquarading as int32_t for ease of serialization) 

    encoder->encodeUInt32(m_name); 

}

bool SharedMemory::Handle::decode(CoreIPC::ArgumentDecoder* decoder, Handle& handle)

{

    size_t size;

    if (!decoder->decodeUInt32(size))

        return false; 

    uint32_t name;

     if (!decoder->decodeUInt32(name))

         return false;

     handle.m_size = size;

     handle.m_name = name; 

     return true;

}

// Create a new shared memory segment

PassRefPtr<SharedMemory> SharedMemory::create(size_t size)

{

    // On Symbian, global chunks (shared memory segments) have system-unique names, so we pick a random 

    // number from the kernel's random pool and use it as a string.  

    // Using an integer simplifies serialization of the name in Handle::encode()

    uint32_t random = Math::Random(); 

    TBuf<KMaxKernelName> globalChunkName;

    globalChunkName.Format(KFormatToString, random);

    RChunk chunk; 

    TInt error; 

    if ( (error = chunk.CreateGlobal(globalChunkName, size, size)) != KErrNone ) {

        qCritical() << " Failed to create Symbian shared memory " << error; 

        return 0; 

    }

    RefPtr<SharedMemory> sharedMemory(adoptRef(new SharedMemory));

    sharedMemory->m_handle = chunk.Handle();

    sharedMemory->m_size = chunk.Size();

    sharedMemory->m_data = static_cast<void*>(chunk.Base());

    return sharedMemory.release();

}

// Take a shared memory handle given usually by another process, and open it locally for read or write

PassRefPtr<SharedMemory> SharedMemory::create(const Handle& handle, Protection protection)

{

    if (handle.isNull())

        return 0;

    // Convert number to string, and open the global chunk

    TBuf<KMaxKernelName> globalChunkName;

    globalChunkName.Format(KFormatToString, handle.m_name);

    RChunk chunk;

    TInt error = chunk.OpenGlobal(globalChunkName, false); // NOTE: Symbian OS doesn't support read-only global chunks

    if (error) 

        return 0;

    RefPtr<SharedMemory> sharedMemory(adoptRef(new SharedMemory));

    sharedMemory->m_handle = chunk.Handle();

    sharedMemory->m_size = chunk.Size();

    sharedMemory->m_data = static_cast<void*>(chunk.Base());

    return sharedMemory.release();

}

SharedMemory::~SharedMemory()

{

    RChunk chunk;

    if (!chunk.SetReturnedHandle(m_handle)) {

        THandleInfo info;

        chunk.HandleInfo(&info);

        // FIXME: We need to figure out when to Decommit() memory from the chunk

        // FIXME: We need to also understand how Close() decrements the kernel-side ref count of the 

        // shared memory segment and leads to premature decommits() of the shared memory area

    }

}

// Initialized the passed Handle 

bool SharedMemory::createHandle(Handle& handle, Protection protection)

{

    ASSERT_ARG(handle, handle.isNull());

    RChunk chunk; 

    if (chunk.SetReturnedHandle(m_handle))

        return false;

    // convert the name (string form) to uint32_t

    TName globalChunkName = chunk.Name();

    TLex lexer(globalChunkName);

    TUint32 nameAsInt = 0; 

    if (lexer.Val(nameAsInt, EDecimal)) 

        return false; 

    handle.m_name = nameAsInt; 

    handle.m_size = m_size;

    return true;

}

unsigned SharedMemory::systemPageSize()

{

    return PAGE_SIZE;

}

} // namespace WebKit

#endif

#if OS(SYMBIAN)

QSymbianPipeNotifier* WorkQueue::registerPipeEventHandler(RPipe pipe, QSymbianPipeNotifier::EventType type, PassOwnPtr<WorkItem> workItem) 

{

    QSymbianPipeNotifier* notifier = new QSymbianPipeNotifier(pipe, type, -1);

    notifier->setEnabled(false);

    notifier->moveToThread(m_workThread);

    WorkQueue::WorkItemQt* itemQt = new WorkQueue::WorkItemQt(this, notifier, SIGNAL(readyToRead(int)), workItem.leakPtr());

    itemQt->moveToThread(m_workThread);    

    notifier->setEnabled(true);

    return notifier;

}

#else

#endif

    // FIXME: Need to implement a process watcher using Symbian RProcess

#if !OS(SYMBIAN)

#endif

#if PLATFORM(QT) && !OS(SYMBIAN)

#endif

#include "config.h"

#if PLATFORM(QT) && OS(SYMBIAN)

#include "ProcessLauncher.h"

#include "Connection.h"

#include "RunLoop.h"

#include "WebProcess.h"

#include "platform/rpipe.h"

#include <QDebug>

#include <qglobal.h>

_LIT(KWorkerProcessName,"QtWebProcess.exe");

using namespace WebCore;

namespace WebKit {

void ProcessLauncher::launchProcess()

{

    // Make a pair of half-duplex pipes

    RPipe* localPipes = new RPipe[2]; 

    RPipe* remotePipes = new RPipe[2]; 

    RPipe::Init();

    TInt error;

    // Create a pipe. First arg is the read-end RPipe and the second is the write-end. 

    error = RPipe::Create(CoreIPC::Connection::MaxPipeCapacity, remotePipes[0], localPipes[1] );

    error = RPipe::Create(CoreIPC::Connection::MaxPipeCapacity, localPipes[0], remotePipes[1]);

    // Prepare to launch worker process

    RProcess* workerProcess = new RProcess() ;

    error = workerProcess->Create(KWorkerProcessName(), KNullDesC);

    // Pass ownership of pipes via RProcess' "environment data slots". 

    // This is the Symbian way of passing ownership of handles from parent to child

    error = workerProcess->SetParameter(3, remotePipes[0]); // reader

    error = workerProcess->SetParameter(4, remotePipes[1]); // writer

    // Block until the remote process is up

    workerProcess->Resume();

    TRequestStatus launchStatus; 

    workerProcess->Rendezvous(launchStatus); 

    User::WaitForRequest(launchStatus);

    if (launchStatus.Int() != KErrNone) 

        qCritical() << " Worker process failed to launch " << launchStatus.Int();

    // Close the pipe ends we just passed to the remote

    remotePipes[0].Close(); 

    remotePipes[1].Close();

    delete remotePipes;

    CoreIPC::Connection::Identifier identifier = localPipes;  

    // Declare launch process as done. Note that this class owns 'workerProcess', but Connection owns 'identifier' 

    RunLoop::main()->scheduleWork(WorkItem::create(this, &WebKit::ProcessLauncher::didFinishLaunchingProcess, workerProcess, identifier));

}

void ProcessLauncher::terminateProcess()

{

	if (!m_processIdentifier)

	    return;

    // Important: Killing another process (even if we spawned it) requires PowerManagement capability,

    // which is a high bar to jump over for any user application. It's also dangerous.  

    // TODO: Check if we should signal the web process through the pipe to terminate itself?

    // ..although that won't work if the process is unresponsive!

	RProcess me;

	if (me.HasCapability(ECapabilityPowerMgmt)) 

	    m_processIdentifier->Terminate(KErrNone);

}

void ProcessLauncher::platformInvalidate()

{

    if (!m_processIdentifier)

           return;

    m_processIdentifier->Close();

    delete m_processIdentifier;

    m_processIdentifier = 0;

}

} // namespace WebKit

#endif

static CoreIPC::Connection::Identifier invalidConnectionIdentifier()

{ 

    CoreIPC::Connection::Identifier identifier; 

#if OS(SYMBIAN)

    identifier = 0; // NULL pointer

#else

    identifier = -1; // invalid socket descriptor

#endif

    return identifier;

}

symbian: LIBS += -lrpipe

    Platform/CoreIPC/qt/QSymbianPipeNotifier.h \

    Platform/CoreIPC/qt/ConnectionSymbian.cpp \

    Platform/CoreIPC/qt/QSymbianPipeNotifier.cpp \

    Platform/CoreIPC/qt/SymbianPipeActiveObject.cpp \

    Platform/qt/SharedMemorySymbian.cpp \

    UIProcess/Launcher/qt/ProcessLauncherSymbian.cpp \

#if defined(Q_OS_SYMBIAN)

    RProcess process; 

    process.SetPriority(EPriorityBackground);

#endif

    CoreIPC::Connection::Identifier identifier; 

#if OS(SYMBIAN)

    // NULL, as we obtain the handles directly from the "environment data slots" on the RProcess

    identifier = 0; 

#else

#if defined(Q_OS_SYMBIAN)

    bar->setIconSize(QSize(16, 16));

#endif

#if defined(Q_OS_SYMBIAN)

    addToolBarBreak();

    addToolBar("Location")->addWidget(m_addressBar);

#else

#endif