CIdleTaskThread.h

//========================================================================================
// 
// $File$
// 
// Owner: Shawn Sheridan
// 
// $Author$
// 
// $DateTime$
// 
// $Revision$
// 
// $Change$
// 
// Copyright 1997-2010 Adobe Systems Incorporated. All rights reserved.
// 
// NOTICE: Adobe permits you to use, modify, and distribute this file in accordance 
// with the terms of the Adobe license agreement accompanying it. If you have received
// this file from a source other than Adobe, then your use, modification, or 
// distribution of it requires the prior written permission of Adobe.
// 
//========================================================================================

#ifndef __IdleTaskThread__
#define __IdleTaskThread__

#include "IIdleTaskThread.h"
#include "HelperInterface.h"
#ifdef MACINTOSH
# include <CoreServices/CoreServices.h>
#endif

// forward declares
class IExecutionContext;


namespace idt_syncprimitives{
class CIdleTaskThreadSyncPrimitives;
}
class CIdleTaskThread : public IIdleTaskThread
{
public:
 CIdleTaskThread(IPMUnknown *boss);
 ~CIdleTaskThread();

 /*
 YieldToEventLoop() will OR in this flag to the returned appflags when it
 needs the Thread to return from its RunThread() method. This can be useful
 for those Threads that normally never return and simply yield within an
 endless loop. When the Thread is forcibly Uninstalled() the CIdleTaskThread
 will call RunTask() one more time and expects the Thread to return.
 */
 const static uint32 kCITT_Shutdown = 0x80000000;

 virtual uint32 RunTask( uint32 schedulerFlags, IdleTimer* timeCheck);

 virtual void InstallTask(uint32 millisecsBeforeFirstRun);

 virtual void UninstallTask();

 virtual const char* TaskName() = 0;

 uint32 YieldToEventLoop(uint32 millisecSleep = 0);

 virtual bool16 IsShuttingDown() const
 { return ((fFlags & kCITT_Shutdown) != 0); }

 void ExecuteTaskInMainThread(IIdleTaskThread::Task& task);

private:
 virtual void RunThread(uint32 flags) = 0;

 virtual uint32 StackSize();

private:
#if MACINTOSH
 typedef ThreadID ThreadHandle;
 ThreadEntryUPP entryPoint;
#elif WINDOWS
 typedef LPVOID ThreadHandle;
#elif WASM
 typedef int32 ThreadHandle;
#else
# error CIdleTaskThread unimplemented
#endif
 static const ThreadHandle kInvalidThreadHandle;
 ThreadHandle fThisThread;
 K2Vector<ThreadHandle> fParentThread; //can I use stack<ThreadHandle, K2Vector<ThreadHandle> > here?

 uint32 fSleep; //when this becomes kEndOfTime thread is done
 uint32 fFlags; //set every time RunTask is called, i.e. every time YieldToEventLoop returns
 IdleTimer* fTimeCheck;
 //fState is for sanity checking--could make kFinished == kConstructed call it say kUninstalled
 //hmm is kInstalled the same as kYielding? Not yet, see UninstallTask
 enum { kConstructed, kInstalled, kRunning, kYielding, kFinished, kDestroyed, kProcessingMainThreadTasks} fState;
 
 IIdleTaskThread::Task fMainThreadTask;
 
 void SwitchToChildThread();
 void SwitchToParentThread();

 static void private_FiberFunction( CIdleTaskThread* theTask);
#ifdef MACINTOSH
 static DEFINE_API(void *) FiberEntryPoint( void * cookie);
#elif WASM
 static void * FiberEntryPoint( void * cookie);
#else
 static VOID CALLBACK CIdleTaskThread::FiberEntryPoint( PVOID cookie);
#endif

 // For private use only.
 void FiberEntryPointNoReturn(void* cookie);
 
 idt_syncprimitives::CIdleTaskThreadSyncPrimitives* fSyncPrimitives;
 
};


#endif // __IdleTaskThread__