/*
* Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description: 
*
*/


/**
 @file
 @test
 @internalComponent - Internal Symbian test code
*/


#include <e32math.h>
#include "egltest_threadmonitor.h"


//CThreadMonitor creates a new monitor thread and instanciates a CThreadMonitorBackend object.
//The thread monitor backend is constructed on the monitor thread's heap and only 
//runs in that context. It creates a CThread instance for each thread that it needs
//to monitor. The CThread instance reports back to the monitor backend when the
//thread that it wraps has exitted. The backend is then responsible for deciding 
//how to respond: If the exit type is a panic, it forwards that panic to all the 
//other threads, then exits itself. Note: The controller thread MUST be at position
//zero in the passed in array.
class CThreadMonitorBackend : public CActive
    {
private:
    class CThread : public CActive
        {
    public:
        static CThread* NewL(const TThreadId& aThread, CThreadMonitorBackend& aMonitor);
        ~CThread();
        void Panic(TInt aExitReason, const TExitCategoryName& aExitCategory);
        
    private:
        CThread(CThreadMonitorBackend& aMonitor);
        void ConstructL(const TThreadId& aThread);
        void RunL();
        void DoCancel();
    
    private:
        CThreadMonitorBackend& iMonitor;
        RThread iThread;
        };

public:
    static CThreadMonitorBackend* NewL(const RArray<TThreadId>& aThreadsToMonitor, TRequestStatus*& aNotifyCancel);
    ~CThreadMonitorBackend();
    void StartMonitoring();
    void ThreadExitted(CThread* aThread, TExitType aExitType, TInt aExitReason, const TExitCategoryName& aExitCategory);
    
private:
    CThreadMonitorBackend(TRequestStatus*& aNotifyCancel);
    void ConstructL(const RArray<TThreadId>& aThreadsToMonitor);
    TBool ThreadIsController(CThread* aThread) const;
    void RunL();
    void DoCancel();
    
private:
    RPointerArray<CThread> iThreads;
    };


//CThreadMonitor---------------------------------------------------------------

CThreadMonitor* CThreadMonitor::NewL(const RArray<TThreadId>& aThreadsToMonitor)
    {
    CThreadMonitor* self = new (ELeave) CThreadMonitor(aThreadsToMonitor);
    CleanupStack::PushL(self);
    self->ConstructL();
    CleanupStack::Pop(self);
    return self;
    }


CThreadMonitor::~CThreadMonitor()
    {
    //Tell the backend to stop monitoring.
    iMonitor.RequestComplete(iNotifyCancel, KErrNone);
    iMonitor.Close();
    }


CThreadMonitor::CThreadMonitor(const RArray<TThreadId>& aThreadsToMonitor) :
    iThreadsToMonitor(aThreadsToMonitor)
    {
    }


void CThreadMonitor::ConstructL()
    {
    const TInt KStackSize = 12000;
    const TInt KHeapMinSize = 16000;
    const TInt KHeapMaxSize = 1000000;
    
    TUint32 random = Math::Random();
    TName threadName;
    _LIT(KThreadNameFormat, "%S-%u");
    _LIT(KMonitorName, "EpThreadMonitor");
    threadName.Format(KThreadNameFormat, &KMonitorName, random);
    
    User::LeaveIfError(iMonitor.Create(threadName, MonitorThreadEntry, KStackSize, KHeapMinSize, KHeapMaxSize, this, EOwnerThread));
    TRequestStatus rendezvous;
    iMonitor.Rendezvous(rendezvous);
    iMonitor.Resume();
    User::WaitForRequest(rendezvous);
    User::LeaveIfError(rendezvous.Int());
    ASSERT(iNotifyCancel);
    }


TInt CThreadMonitor::MonitorThreadEntry(TAny* aSelf)
    {
    CThreadMonitor* self = static_cast<CThreadMonitor*>(aSelf);
    CTrapCleanup* cleanup = CTrapCleanup::New();
    
    TRAPD(err, MonitorThreadEntryL(self->iThreadsToMonitor, self->iNotifyCancel));
    __ASSERT_ALWAYS(err == KErrNone, User::Invariant());

    delete cleanup;
    return KErrNone;
    }


void CThreadMonitor::MonitorThreadEntryL(const RArray<TThreadId>& aThreadsToMonitor, TRequestStatus*& aNotifyCancel)
    {
    //Create active scheduler.
    CActiveScheduler* scheduler = new (ELeave) CActiveScheduler();
    CleanupStack::PushL(scheduler);
    CActiveScheduler::Install(scheduler);

    //Create the monitor and start monitoring.
    CThreadMonitorBackend* monitor = CThreadMonitorBackend::NewL(aThreadsToMonitor, aNotifyCancel);
    RThread().Rendezvous(KErrNone);
    monitor->StartMonitoring();
    delete monitor;

    //Clean up.
    CleanupStack::PopAndDestroy(scheduler);
    }

//-----------------------------------------------------------------------------


//CThreadMonitorBackend--------------------------------------------------------

CThreadMonitorBackend* CThreadMonitorBackend::NewL(const RArray<TThreadId>& aThreadsToMonitor, TRequestStatus*& aNotifyCancel)
    {
    CThreadMonitorBackend* self = new (ELeave) CThreadMonitorBackend(aNotifyCancel);
    CleanupStack::PushL(self);
    self->ConstructL(aThreadsToMonitor);
    CleanupStack::Pop(self);
    return self;
    }


CThreadMonitorBackend::CThreadMonitorBackend(TRequestStatus*& aNotifyCancel) :
    CActive(CActive::EPriorityStandard)
    {
    CActiveScheduler::Add(this);
    iStatus = KRequestPending;
    SetActive();
    
    //Pass the cancel TRequestStatus back to the controller thread.
    aNotifyCancel = &iStatus;
    }


void CThreadMonitorBackend::ConstructL(const RArray<TThreadId>& aThreadsToMonitor)
    {
    //Reserve the space up front so we can gaurantee that the append will not fail.
    //This way we don't need to use the cleanup stack to hold the new CThread while
    //we attempt to append.
    iThreads.ReserveL(aThreadsToMonitor.Count());
    for(TInt i=0; i < aThreadsToMonitor.Count(); i++)
        {
        iThreads.Append(CThread::NewL(aThreadsToMonitor[i], *this));
        }
    }


CThreadMonitorBackend::~CThreadMonitorBackend()
    {
    Cancel();
    iThreads.ResetAndDestroy();
    }


void CThreadMonitorBackend::StartMonitoring()
    {
    CActiveScheduler::Start();
    }


void CThreadMonitorBackend::ThreadExitted(CThread* aThread, TExitType aExitType, TInt aExitReason, const TExitCategoryName& aExitCategory)
    {
    //If a worker thread exits normally, do nothing.
    //If a worker thread panics, forward the panic to all other threads and stop active scheduler.
    //If the controller thread exits normally, stop active scheduler.
    //If the controller thread panics, forward the panic to all other threads and stop active scheduler.
    
    //Stop monitoring according to above.
    if(ThreadIsController(aThread) || aExitType == EExitPanic)
        {
        CActiveScheduler::Stop();
        }

    //Forward panic according to above. Second condition is for when controller times out.
    if(aExitType == EExitPanic || (ThreadIsController(aThread) && aExitType == EExitKill && aExitReason == KErrTimedOut))
        {
        for(TInt i=0; i < iThreads.Count(); i++)
            {
            iThreads[i]->Panic(aExitReason, aExitCategory);
            }
        }
    }


TBool CThreadMonitorBackend::ThreadIsController(CThread* aThread) const
    {
    //The controller thread must be at index zero in the passed in array.
    //Due to way we construct, we gaurantee that it is also at index zero in iThread.
    return (iThreads.Count() > 0) && (iThreads[0] == aThread);
    }


void CThreadMonitorBackend::RunL()
    {
    //The client has destructed the CThreadMonitor object, 
    //so stop the active scheduler so we exit the thread.
    CActiveScheduler::Stop();
    }


void CThreadMonitorBackend::DoCancel()
    {
    //Not ideal, but we should only get here if the thread that created 
    //the original ConitorThread panics, so it should be safe.
    TRequestStatus* status =&iStatus;
    User::RequestComplete(status, KErrCancel);
    }

//-----------------------------------------------------------------------------


//CThreadMonitorBackend::CThread-----------------------------------------------

CThreadMonitorBackend::CThread* CThreadMonitorBackend::CThread::NewL(const TThreadId& aThread, CThreadMonitorBackend& aMonitor)
    {
    CThread* self = new (ELeave) CThread(aMonitor);
    CleanupStack::PushL(self);
    self->ConstructL(aThread);
    CleanupStack::Pop(self);
    return self;
    }


CThreadMonitorBackend::CThread::CThread(CThreadMonitorBackend& aMonitor) :
    CActive(CActive::EPriorityStandard),
    iMonitor(aMonitor)
    {
    CActiveScheduler::Add(this);
    }


void CThreadMonitorBackend::CThread::ConstructL(const TThreadId& aThread)
    {
    User::LeaveIfError(iThread.Open(aThread, EOwnerThread));
    iThread.Logon(iStatus);
    SetActive();
    }


CThreadMonitorBackend::CThread::~CThread()
    {
    Cancel();
    iThread.Close();
    }


void CThreadMonitorBackend::CThread::Panic(TInt aExitReason, const TExitCategoryName& aExitCategory)
    {
    iThread.Panic(aExitCategory, aExitReason);
    }


void CThreadMonitorBackend::CThread::RunL()
    {
    //Inform the monitor backend that the thread exitted.
    TExitCategoryName category = iThread.ExitCategory();
    TInt reason = iThread.ExitReason();
    TExitType type = iThread.ExitType();
    iMonitor.ThreadExitted(this, type, reason, category);
    }


void CThreadMonitorBackend::CThread::DoCancel()
    {
    iThread.LogonCancel(iStatus);
    }

//-----------------------------------------------------------------------------