/*

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

     }

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