diff -r 000000000000 -r 7f656887cf89 libraries/btrace_parser/inc/btrace_parser.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/libraries/btrace_parser/inc/btrace_parser.h Wed Jun 23 15:52:26 2010 +0100 @@ -0,0 +1,927 @@ +// btrace_parser.h +// +// Copyright (c) 2008 - 2010 Accenture. All rights reserved. +// This component and the accompanying materials are made available +// under the terms of the "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: +// Accenture - Initial contribution +// +// Backwards Compatibility: +// The interfaces defined in this file should be considered INTERNAL to the +// fshell project as they may be subject to change. Expect to have to absorb +// downstream compatibility breaks if you use these interfaces from outside +// of the fshell project. + +#ifndef __BTRACE_PARSER_H__ +#define __BTRACE_PARSER_H__ + +#include +#include +#include +#include FSHELL_D32BTRACE_HEADER +#include +#include +#include + +#ifdef FSHELL_ATRACE_SUPPORT +#include +#endif + +class TBtraceHeader; +struct TKeyEvent; +struct TPointerEvent; +class CMultipartFragment; +class CFlusher; + +enum TBtraceParserPanic + { + EBtpPanicUndefinedCallBack = 0, + EBtpPanicIncompatiblePubSubArgs = 1, + EBtpPanicThreadIdNotFound = 2, + EBtpPanicProcessNameNotFound = 3, + EBtpPanicBtraceThreadIdOverflow = 4, + EBtpPanicThreadNotFoundForId = 5, + EBtpPanicFailedToInsertCpuUsageObject = 6, + EBtpPanicBtraceProcessIdOverflow = 7, + EBtpPanicUnused1 = 8, + EBtpPanicUnused2 = 9, + EBtpPanicNegativeTickInterval = 10, + EBtpPanicUnused3 = 11, + EBtpPanicInvalidReaderMode = 12, + EBtpPanicUnexpectedReaderRun = 13, + EBtpPanicUnknownCpuContext = 14, + EBtpPanicFlusherObserverAlreadySet = 15, + EBtpPanicReaderNotReplaying = 16, + EBtpPanicNoReplayData = 17, + EBtpPanicFailedToFindProcess = 18, + EBtpPanicNegativeRefCount = 19, + EBtpPanicNestedSynchronizeCalls = 20, + EBtpPanicFrameObserverAlreadyExists = 21, + EBtpPanicTriedToDisableReplayWhenBtraceNotRunning = 22, + EBtpPanicAddObserverCalledWhileIterating = 23, + EBtpPanicRemoveObserverCalledWhileIterating = 24, + EBtpPanicTooManyDomainEventDataItems = 25, + EBtpPanicBtraceWindowGroupIdOverflow = 26, + EBtpPanicWindowGroupIdNotFound = 27, + EBtpPanicWservWindowGroupIdNotFound = 28 + }; + +void Panic(TBtraceParserPanic aReason); +struct SBtraceParserTls; + +enum TBtraceNotificationPersistence + { + ENotificationOneShot, + ENotificationPersistent, + }; + +class TBtraceUtils + { +public: + IMPORT_C static TUint32 MicroSecondsToNanoTicks(TTimeIntervalMicroSeconds32 aInterval); + IMPORT_C static TUint64 MicroSecondsToFastTicks(TTimeIntervalMicroSeconds32 aInterval); + IMPORT_C static TTimeIntervalMicroSeconds NanoTicksToMicroSeconds(TUint32 aNanoTicks); + IMPORT_C static TTimeIntervalMicroSeconds FastTicksToMicroSeconds(const TUint64& aFastTicks); + + IMPORT_C static void DebugOverrideTimerSettings(TInt aNanoPeriod, TInt aFastCounterFreq, TBool aFastCountUp); + +public: + static TInt NanoTickPeriod(); + static TInt FastCounterFrequency(); + static TBool FastCounterCountsUp(); +private: + static SBtraceParserTls* CreateTls(); + static TInt CalculateNanoTickPeriod(); + static TInt CalculateFastCounterFrequency(); + static TInt CalculateFastCounterCountsUp(); + }; + +class TBtraceTickCount + { +public: + IMPORT_C TBtraceTickCount(); + IMPORT_C void SetToNow(); + IMPORT_C TUint32 IntervalInNanoTicks(const TBtraceTickCount& aTickCount) const; + IMPORT_C TUint64 IntervalInFastTicks(const TBtraceTickCount& aTickCount) const; + IMPORT_C TTimeIntervalMicroSeconds IntervalInMicroSeconds(const TBtraceTickCount& aTickCount) const; + IMPORT_C TBool operator==(const TBtraceTickCount& aTickCount) const; + IMPORT_C TBool operator!=(const TBtraceTickCount& aTickCount) const; + IMPORT_C TBool operator>=(const TBtraceTickCount& aTickCount) const; + IMPORT_C TBool operator<=(const TBtraceTickCount& aTickCount) const; + IMPORT_C TBool operator>(const TBtraceTickCount& aTickCount) const; + IMPORT_C TBool operator<(const TBtraceTickCount& aTickCount) const; +public: + TUint32 iNano; + TUint32 iFast; + }; + + +class TBtraceFrame + { +public: + TBtraceFrame(const TBtraceHeader& aHeader); +public: + TUint8 iSize; + TUint8 iFlags; + TUint8 iCategory; + TUint8 iSubCategory; + TBtraceTickCount iTickCount; + TUint32 iThreadContext; + TUint32 iProgramCounter; + TPtrC8 iData; + }; + + +class MBtraceLog + { +public: + IMPORT_C virtual TBool LogEnabled() = 0; + IMPORT_C virtual void Log(const TDesC& aLog) = 0; + }; + +class CBtraceReader; + + +class MBtraceObserver + { +public: + virtual void HandleBtraceFrameL(const TBtraceFrame& aFrame) = 0; + virtual void BtraceBufferHasBeenReset() {} // Empty default impl + }; + +class MBtraceFrameObserver + { +public: + virtual void HandleFrameDispatchStart() = 0; + virtual void HandleFrameDispatchComplete() = 0; + }; + +NONSHARABLE_CLASS(CBtraceReader) : public CActive + { +public: + enum TMode + { + EAllowBtraceToOverflow, + EFlushOnBtraceThreshold, + ELeaveOnBtraceThreshold + }; + enum TObserverType + { + ENormal, + EIncludeSynchronizationFrames + }; +public: + IMPORT_C static CBtraceReader* NewL(TMode aMode, TInt aBufferSize, TInt aThreshold, MBtraceLog* aLog = NULL); + IMPORT_C static CBtraceReader* NewL(const TDesC& aReplayFileName, MBtraceLog* aLog = NULL); + IMPORT_C ~CBtraceReader(); + IMPORT_C void Reset(); + IMPORT_C void SynchronizeL(); + IMPORT_C void Start(const TBtraceTickCount& aInitialTickCount); + IMPORT_C void Start(const TBtraceTickCount& aInitialTickCount, TTimeIntervalMicroSeconds32 aAutoFlushPeriod); + IMPORT_C void DisableBtrace(); + IMPORT_C void EnableCategoryL(TUint aCategory); + IMPORT_C void DisableCategoryL(TUint aCategory); + IMPORT_C void AddObserverL(MBtraceObserver& aObserver); + IMPORT_C void AddObserverL(MBtraceObserver& aObserver, TObserverType aType); + IMPORT_C void AddObserverL(TUint aCategory, MBtraceObserver& aObserver); + IMPORT_C void AddObserverL(TUint aCategory, MBtraceObserver& aObserver, TObserverType aType); + IMPORT_C void RemoveObserver(MBtraceObserver& aObserver); + IMPORT_C void RemoveObserver(TUint aCategory, MBtraceObserver& aObserver); + IMPORT_C void AddFrameObseverL(MBtraceFrameObserver& aObserver); + IMPORT_C void RemoveFrameObserver(MBtraceFrameObserver& aObserver); + IMPORT_C void GetReplayStartTickCountL(TBtraceTickCount& aTickCount); + IMPORT_C void SetBufferSizeL(TInt aBufferSize); + IMPORT_C void SetReplayFileNameL(const TDesC& aReplayFileName); // Pass empty desc to disable (not allowed to disable if constructed with the overload that took a replay filename) + IMPORT_C const TBtraceTickCount& CurrentTickCount() const; + IMPORT_C void RecordBtraceDataToFileL(const TDesC& aRecordFileName); // Pass empty desc to disable + IMPORT_C void LogBtraceStatus(); + IMPORT_C void SetMultipartReassemblyL(TInt aMaxTrackedFragments); // zero to disable + IMPORT_C void FlushL(); +public: + void Log(const TDesC& aDes) const; + void Log(TRefByValue aFmt, ...) const; +private: // From CActive. + virtual void RunL(); + virtual void DoCancel(); +private: + CBtraceReader(TMode aMode, TInt aThreshold, MBtraceLog* aLog); + void ConstructL(TInt aBufferSize); + void ConstructL(const TDesC& aReplayFileName); + void QueueRead(); + void DoReadL(TBool& aFinished); + TInt GetData(TUint8*& aData); + void DispatchFrameL(const TBtraceFrame& aFrame); + void NotifyObserversOfBufferReset(); + void ResetAndReprimeL(); + void NewMultipartFrameL(const TBtraceFrame& aFrame, TUint32 aExtra); + void AdditionalMultipartFragmentL(const TBtraceFrame& aFrame, TUint32 aExtra, TBool aLast); +private: + class TObserver + { + public: + TObserver(MBtraceObserver& aObserver, TObserverType aType, TUint aCategory); + static TObserver ArrayKey(TUint aCategory); + + private: + TObserver(TUint aCategory); // Only for use by ArrayKey + public: + MBtraceObserver* iObserver; + TObserverType iType; + TUint iCategory; + }; +private: + static TBool ObserversEqual(const TObserver& aA, const TObserver& aB); + static void DecIteratingObservers(TAny* aSelf); +private: + const TMode iMode; + MBtraceLog* iLog; + CFlusher* iFlusher; + RBTrace iBtrace; +#ifdef FSHELL_ATRACE_SUPPORT + RATraceConfig iAtraceConfig; +#endif + TInt iThreshold; + RArray iObservers; // Sorted by TObserver::iCategory + TInt iNumBytesRead; + TInt iNumFramesRead; + TBtraceTickCount iCurrentTickCount; + TBtraceTickCount iInitialTickCount; + TPtrC8 iBtraceBuffer; + HBufC8* iReplayData; + RFs iFs; + RFile iReplayFile; + TBool iSynchronizing; + MBtraceFrameObserver* iFrameObserver; + RFile iRecordFile; + TInt iIteratingObservers; + TInt iNextSyncFrameId; + TInt iSyncFrameIdToWaitFor; + TInt iMaxTrackedMultipartFragments; + RPointerArray iMultipartFragments; + }; + +class CRefCountedObject : public CBase + { +public: + IMPORT_C void IncRef(); + IMPORT_C void DecRef(); + IMPORT_C TInt RefCount() const; +protected: + CRefCountedObject(); +private: + TInt iRefCount; + }; + +class TBtraceIdBase + { +public: + IMPORT_C void Set(TUint aValue); + IMPORT_C TUint Value() const; + IMPORT_C TBool operator==(const TBtraceIdBase& aId) const; +protected: + TBtraceIdBase(); + TBtraceIdBase(TUint aId); + TBtraceIdBase(const TBtraceIdBase& aId); +private: + TUint iId; + }; + +class TBtraceThreadId : public TBtraceIdBase + { +public: + IMPORT_C TBtraceThreadId(); + IMPORT_C explicit TBtraceThreadId(TUint aId); + IMPORT_C TBtraceThreadId(const TBtraceThreadId& aId); + }; + +class TBtraceProcessId : public TBtraceIdBase + { +public: + IMPORT_C TBtraceProcessId(); + IMPORT_C explicit TBtraceProcessId(TUint aId); + IMPORT_C TBtraceProcessId(const TBtraceProcessId& aId); + }; + +class TBtraceWindowGroupId : public TBtraceIdBase + { +public: + IMPORT_C TBtraceWindowGroupId(); + IMPORT_C explicit TBtraceWindowGroupId(TUint aId); + IMPORT_C TBtraceWindowGroupId(const TBtraceWindowGroupId& aId); + }; + + +class MBtraceContextObserver + { +public: + IMPORT_C virtual void HandleThreadSeenL(const TBtraceTickCount& aTickCount, const TBtraceThreadId& aId, TUint aUserId); + IMPORT_C virtual void HandleThreadGoneL(const TBtraceTickCount& aTickCount, const TBtraceThreadId& aId, TUint aUserId); + IMPORT_C virtual void HandleThreadExitL(const TBtraceTickCount& aTickCount, const TBtraceThreadId& aId, TExitType aExitType, TInt aReason, const TDesC& aCategory, TUint aUserId); + IMPORT_C virtual void HandleWindowGroupSeenL(const TBtraceTickCount& aTickCount, const TBtraceWindowGroupId& aId, TUint aUserId); + }; + +NONSHARABLE_CLASS(CBtraceContext) : public CRefCountedObject, public MBtraceObserver + { +public: + enum TMode + { + ENormal + }; + enum TExitTypes + { + EKill = 0x00000001, + ETerminate = 0x00000002, + EPanic = 0x00000004 + }; +public: + IMPORT_C static CBtraceContext* NewL(CBtraceReader& aReader, TMode aMode = ENormal); + IMPORT_C ~CBtraceContext(); + IMPORT_C const TDesC& ThreadName(const TBtraceThreadId& aId) const; + IMPORT_C void GetFullThreadName(const TBtraceThreadId& aId, TDes& aFullName) const; + IMPORT_C TThreadId ThreadId(const TBtraceThreadId& aId) const; + IMPORT_C const TDesC& ProcessName(const TBtraceProcessId& aId) const; + IMPORT_C TInt WindowGroupId(const TBtraceWindowGroupId& aId) const; + IMPORT_C const TDesC& WindowGroupName(const TBtraceWindowGroupId& aId) const; + IMPORT_C const TBtraceThreadId* FindThread(TUint32 aNThreadAddress) const; + IMPORT_C const TBtraceThreadId* FindThread(const TThreadId& aId) const; + IMPORT_C const TBtraceWindowGroupId* FindWindowGroup(TInt aWServWgId) const; + IMPORT_C void FindThreadsL(const TDesC& aPattern, RArray& aThreads) const; + IMPORT_C void FindWindowGroupsL(const TDesC& aPattern, RArray& aWindowGroups) const; + IMPORT_C void FindWindowGroupsByThreadName(const TDesC& aPattern, RArray& aWindowGroups) const; + IMPORT_C void NotifyThreadSeenL(const TDesC& aPattern, MBtraceContextObserver& aObserver, TUint aId); + IMPORT_C void NotifyThreadSeenL(const TDesC& aPattern, MBtraceContextObserver& aObserver, TUint aId, TBtraceNotificationPersistence aPersistence); + IMPORT_C void CancelNotifyThreadSeen(MBtraceContextObserver& aObserver); + IMPORT_C void NotifyThreadGoneL(const TDesC& aPattern, MBtraceContextObserver& aObserver, TUint aId); + IMPORT_C void NotifyThreadGoneL(const TDesC& aPattern, MBtraceContextObserver& aObserver, TUint aId, TBtraceNotificationPersistence aPersistence); + IMPORT_C void CancelNotifyThreadGone(MBtraceContextObserver& aObserver); + IMPORT_C void NotifyThreadExitL(const TDesC& aPattern, TUint aExitTypes, TInt* aReason, const TDesC* aCategory, MBtraceContextObserver& aObserver, TUint aId, TBtraceNotificationPersistence aPersistence); // Note, the pointer parameters are optional. + IMPORT_C void CancelNotifyThreadExit(MBtraceContextObserver& aObserver); + IMPORT_C void NotifyWindowGroupSeenL(const TDesC& aPattern, MBtraceContextObserver& aObserver, TUint aId, TBtraceNotificationPersistence aPersistence); + IMPORT_C void NotifyWindowGroupSeenByThreadNameL(const TDesC& aPattern, MBtraceContextObserver& aObserver, TUint aId, TBtraceNotificationPersistence aPersistence); + IMPORT_C void CancelNotifyWindowGroupSeen(MBtraceContextObserver& aObserver); +private: + CBtraceContext(CBtraceReader& aReader, TMode aMode); + void ConstructL(); + TUint GetNextThreadId(); + TUint GetNextProcessId(); + TUint GetNextWindowGroupId(); +private: // From MBtraceObserver. + virtual void HandleBtraceFrameL(const TBtraceFrame& aFrame); + virtual void BtraceBufferHasBeenReset(); +private: + class TThread + { + public: + TThread(TUint32 aNThreadAddress, TUint32 aOwningProcess, const TDesC8& aName); + public: + TUint32 iNThreadAddress; + TBtraceThreadId iId; + TUint32 iOwningProcess; + TUint32 iKernelId; + TName iName; + }; + class TProcess + { + public: + TProcess(TUint32 aDProcessAddress); + TProcess(TUint32 aDProcessAddress, const TDesC8& aName); + public: + TUint32 iDProcessAddress; + TBtraceProcessId iId; + TName iName; + TInt iReferenceCount; + }; + class TWindowGroup + { + public: + TWindowGroup(TInt aWindowGroupId); + TWindowGroup(const TDesC& aName); + TWindowGroup(TInt aWindowGroupId, TThreadId aThreadId, const TDesC& aName); + public: + TBtraceWindowGroupId iId; + TInt iWindowGroupId; + TThreadId iThreadId; + TFullName iName; + }; + class TThreadSeenNotif + { + public: + TThreadSeenNotif(TUint aId, const TDesC& aPattern, MBtraceContextObserver& aObserver, TBtraceNotificationPersistence aPersistence); + public: + TUint iId; + TName iPattern; + MBtraceContextObserver& iObserver; + TBtraceNotificationPersistence iPersistence; + }; + class TThreadGoneNotif + { + public: + TThreadGoneNotif(TUint aId, const TDesC& aPattern, MBtraceContextObserver& aObserver, TBtraceNotificationPersistence aPersistence); + public: + TUint iId; + TName iPattern; + MBtraceContextObserver& iObserver; + TBtraceNotificationPersistence iPersistence; + }; + class TThreadExitNotif + { + public: + TThreadExitNotif(TUint aId, const TDesC& aPattern, TUint aExitTypes, TInt* aReason, const TDesC* aCategory, MBtraceContextObserver& aObserver, TBtraceNotificationPersistence aPersistence); + TBool Matches(const TDesC& aThreadName, TExitType aExitType, TInt aReason, const TDesC& aCategory) const; + private: + TBool MatchesType(TExitType aExitType) const; + public: + TUint iId; + TName iPattern; + TUint iExitTypes; + TInt* iReason; + const TDesC* iCategory; + MBtraceContextObserver& iObserver; + TBtraceNotificationPersistence iPersistence; + }; + class TWindowGroupSeenNotif + { + public: + enum TPatternType + { + EWindowGroupName, + EThreadName + }; + public: + TWindowGroupSeenNotif(TUint aId, const TDesC& aPattern, TPatternType aPatternType, MBtraceContextObserver& aObserver, TBtraceNotificationPersistence aPersistence); + public: + TUint iId; + TName iPattern; + TPatternType iPatternType; + MBtraceContextObserver& iObserver; + TBtraceNotificationPersistence iPersistence; + }; +private: + void SeenL(const TThread& aThread, const TBtraceTickCount& aTickCount); + void GoneL(const TThread& aThread, const TBtraceTickCount& aTickCount); + void ExitedL(const TThread& aThread, TExitType aExitType, TInt aReason, const TDesC& aCategory, const TBtraceTickCount& aTickCount); + void AppendL(const TThread& aThread, const TBtraceTickCount& aTickCount); + void AppendL(const TProcess& aProcess, const TBtraceTickCount& aTickCount); + void RemoveThread(TInt aPosition); + void SeenAllThreadsL(const TProcess& aProcess, const TBtraceTickCount& aTickCount); + void SeenL(const TWindowGroup& aWindowGroup, const TBtraceTickCount& aTickCount); + static TBool ThreadMatchesId(const TThread& aLeft, const TThread& aRight); + static TBool ThreadMatchesKernelId(const TThread& aLeft, const TThread& aRight); + static TBool ThreadMatchesNThreadAddress(const TThread& aLeft, const TThread& aRight); + static TBool ProcessMatchesId(const TProcess& aLeft, const TProcess& aRight); + static TBool ProcessMatchesDProcessAddress(const TProcess& aLeft, const TProcess& aRight); + static TBool WindowGroupMatchesId(const TWindowGroup& aLeft, const TWindowGroup& aRight); + static TBool WindowGroupMatchesThreadId(const TWindowGroup& aLeft, const TWindowGroup& aRight); + static TBool WindowGroupMatchesWServId(const TWindowGroup& aLeft, const TWindowGroup& aRight); +private: + TMode iMode; + CBtraceReader& iReader; + TUint iNextBtraceThreadId; + TUint iNextBtraceProcessId; + TUint iNextBtraceWindowGroupId; + RArray iThreads; + RArray iProcesses; + RArray iWindowGroups; + RArray iThreadSeenNotifs; + RArray iThreadGoneNotifs; + RArray iThreadExitNotifs; + RArray iWindowGroupSeenNotifs; + }; + + +class MBtraceCpuUsageObserver + { +public: + enum TContextSwitchType + { + EToThisThread, + EFromThisThread + }; + enum TIdleType + { + ENeverScheduled, + EScheduledAtLeastOnce + }; + class TCpuUsage + { + public: + TCpuUsage(const TBtraceThreadId& aId); + TCpuUsage(const TBtraceThreadId& aId, const TBtraceTickCount& aTickCount); + public: + TBtraceThreadId iId; + TUint64 iNumFastTicks; + private: + friend class CBtraceCpuUsage; + TBtraceTickCount iSwitchedInAt; + }; +public: + virtual void HandleCpuUsageL(const TBtraceTickCount& aTickCount, const TArray& aCpuUsage) = 0; + virtual void HandleContextSwitchL(const TBtraceTickCount& aTickCount, const TBtraceThreadId& aId, TContextSwitchType aType) = 0; + virtual void HandleThreadIdleL(const TBtraceTickCount& aTickCount, const TBtraceThreadId& aId, TIdleType aIdleType) = 0; + }; + +NONSHARABLE_CLASS(CBtraceCpuUsage) : public CRefCountedObject, public MBtraceObserver + { +public: + IMPORT_C static CBtraceCpuUsage* NewL(CBtraceReader& aReader, CBtraceContext& aContext); + IMPORT_C ~CBtraceCpuUsage(); + IMPORT_C void NotifyCpuUsageL(TUint32 aNanoTickCount, TTimeIntervalMicroSeconds32 aPeriod, MBtraceCpuUsageObserver& aObserver); + IMPORT_C void NotifyCpuUsageL(TUint32 aNanoTickCount, TTimeIntervalMicroSeconds32 aPeriod, MBtraceCpuUsageObserver& aObserver, TBtraceNotificationPersistence aPersistence); + IMPORT_C void NotifyContextSwitchL(const TBtraceThreadId& aId, MBtraceCpuUsageObserver& aObserver); + IMPORT_C void NotifyThreadIdleL(const TBtraceThreadId& aId, const TBtraceTickCount& aFromTickCount, TTimeIntervalMicroSeconds32 aPeriod, MBtraceCpuUsageObserver& aObserver); + IMPORT_C void NotifyThreadIdleL(const TBtraceThreadId& aId, const TBtraceTickCount& aFromTickCount, TTimeIntervalMicroSeconds32 aPeriod, MBtraceCpuUsageObserver& aObserver, TBtraceNotificationPersistence aPersistence); + IMPORT_C void CancelNotifyThreadIdle(MBtraceCpuUsageObserver& aObserver); +private: + CBtraceCpuUsage(CBtraceReader& aReader, CBtraceContext& aContext); + void ConstructL(); +private: // From MBtraceObserver. + virtual void HandleBtraceFrameL(const TBtraceFrame& aFrame); +private: + class RCpuUsageNotif + { + public: + RCpuUsageNotif(TUint32 aStartTickCount, TUint32 aNumNanoTicks, MBtraceCpuUsageObserver& aObserver, TBtraceNotificationPersistence aPersistence); + void Close(); + public: + TUint32 iStartTickCount; + TUint32 iNumNanoTicks; + MBtraceCpuUsageObserver* iObserver; + RArray iUsage; + TBtraceNotificationPersistence iPersistence; + }; + class TContextSwitchNotif + { + public: + TContextSwitchNotif(const TBtraceThreadId& aId); + TContextSwitchNotif(const TBtraceThreadId& aId, MBtraceCpuUsageObserver& aObserver); + public: + TBtraceThreadId iId; + MBtraceCpuUsageObserver* iObserver; + }; + class TThreadIdleNotif + { + public: + TThreadIdleNotif(const TBtraceThreadId& aId); + TThreadIdleNotif(const TBtraceThreadId& aId, const TBtraceTickCount& aFromTickCount, TUint aNumNanoTicks, MBtraceCpuUsageObserver& aObserver, TBtraceNotificationPersistence aPersistence); + public: + TBtraceThreadId iId; + TUint32 iNumNanoTicks; + MBtraceCpuUsageObserver* iObserver; + TBtraceTickCount iLastSwitchedOut; + TBool iEverScheduled; + TBtraceNotificationPersistence iPersistence; + }; +private: + void HandleContextSwitchL(const TBtraceTickCount& aTickCount, const TBtraceThreadId& aNewBtraceThreadId); + void TestCpuUsagePeriodL(const TBtraceTickCount& aTickCount); + void TestThreadIdlenessL(const TBtraceTickCount& aTickCount); +private: + CBtraceReader& iReader; + CBtraceContext& iContext; + RArray iCpuUsageNotifs; + RArray iContextSwitchNotifs; + RArray iThreadIdleNotifs; + TBtraceThreadId iLastBtractThreadId; + TInt iNumIgnoredFrames; + TInt iNumProcessedFrames; + TInt iNumRelevantFrames; + }; + + +class MBtraceKeyPressObserver + { +public: + virtual void HandleKeyPressL(const TBtraceTickCount& aTickCount, const TKeyEvent& aKey) = 0; + virtual void HandlePointerPressL(const TBtraceTickCount& aTickCount, const TPointerEvent& aPointer) = 0; + virtual void HandleUnclassifiedDataL(const TBtraceTickCount& aTickCount, const TInt aCommandClass, const TInt aOpcode, const TAny* aData) = 0; + virtual void HandleRawKeyL(const TBtraceTickCount& aTickCount, TBool aKeyUp, TInt aScanCode) = 0; + }; + +NONSHARABLE_CLASS(CBtraceKeyPress) : public CRefCountedObject, public MBtraceObserver + { +public: + IMPORT_C static CBtraceKeyPress* NewL(CBtraceReader& aReader); + IMPORT_C ~CBtraceKeyPress(); + IMPORT_C void NotifyKeyEventL(MBtraceKeyPressObserver& aObserver); + IMPORT_C void NotifyKeyEventL(MBtraceKeyPressObserver& aObserver, TBtraceNotificationPersistence aPersistence); + IMPORT_C void CancelNotifyKeyEvent(MBtraceKeyPressObserver& aObserver); + IMPORT_C void NotifyPointerEventL(MBtraceKeyPressObserver& aObserver); + IMPORT_C void NotifyPointerEventL(MBtraceKeyPressObserver& aObserver, TBtraceNotificationPersistence aPersistence); + IMPORT_C void CancelNotifyPointerEvent(MBtraceKeyPressObserver& aObserver); + IMPORT_C void NotifyUnclassifiedDataL(MBtraceKeyPressObserver& aObserver); + IMPORT_C void NotifyUnclassifiedDataL(MBtraceKeyPressObserver& aObserver, TBtraceNotificationPersistence aPersistence); + IMPORT_C void CancelNotifyUnclassifiedData(MBtraceKeyPressObserver& aObserver); + IMPORT_C void NotifyRawKeyEventL(MBtraceKeyPressObserver& aObserver); + IMPORT_C void NotifyRawKeyEventL(MBtraceKeyPressObserver& aObserver, TBtraceNotificationPersistence aPersistence); + IMPORT_C void CancelNotifyRawKeyEvent(MBtraceKeyPressObserver& aObserver); +private: + CBtraceKeyPress(CBtraceReader& aReader); + void ConstructL(); + void SeenKeyL(const TBtraceTickCount& aTickCount, const TKeyEvent& aKey); + void SeenPointerL(const TBtraceTickCount& aTickCount, const TPointerEvent& aKey); + void SeenUnclassifiedL(const TBtraceTickCount& aTickCount, const TInt aCommandClass, const TInt aOpcode, const TAny* aData); + void SeenRawKeyL(const TBtraceTickCount& aTickCount, TBool aKeyUp, TInt aScanCode); +private: // From MBtraceObserver. + virtual void HandleBtraceFrameL(const TBtraceFrame& aFrame); +private: + class TKeyPressNotif + { + public: + TKeyPressNotif(MBtraceKeyPressObserver& aObserver, TBtraceNotificationPersistence aPersistence); + public: + MBtraceKeyPressObserver* iObserver; + TBtraceNotificationPersistence iPersistence; + }; + CBtraceReader& iReader; + RArray iKeyNotifs; + RArray iPointerNotifs; + RArray iGenericNotifs; + RArray iRawKeyNotifs; + }; + + +class MBtraceTextOnScreenObserver + { +public: + virtual void HandleTextSeenL(const TBtraceTickCount& aTickCount, const TDesC& aText, TInt aWindowGroupId) = 0; + }; + +NONSHARABLE_CLASS(CBtraceTextOnScreen) : public CRefCountedObject, public MBtraceObserver + { +public: + enum TMatchMode + { + EWildNonSpanning, + ESpanningNonWild + }; +public: + IMPORT_C static CBtraceTextOnScreen* NewL(CBtraceReader& aReader); + IMPORT_C ~CBtraceTextOnScreen(); + IMPORT_C void NotifyTextOnScreenL(const TDesC& aText, MBtraceTextOnScreenObserver& aObserver); + IMPORT_C void NotifyTextOnScreenL(const TDesC& aText, MBtraceTextOnScreenObserver& aObserver, TBtraceNotificationPersistence aPersistence); + IMPORT_C void NotifyTextOnScreenL(const TDesC& aText, TMatchMode aMatchMode, MBtraceTextOnScreenObserver& aObserver, TBtraceNotificationPersistence aPersistence); + IMPORT_C void NotifyTextOnScreenL(const TDesC& aText, TInt aWindowGroupId, TMatchMode aMatchMode, MBtraceTextOnScreenObserver& aObserver); + IMPORT_C void NotifyTextOnScreenL(const TDesC& aText, TInt aWindowGroupId, TMatchMode aMatchMode, MBtraceTextOnScreenObserver& aObserver, TBtraceNotificationPersistence aPersistence); + IMPORT_C void CancelNotifyTextOnScreen(MBtraceTextOnScreenObserver& aObserver); +private: + CBtraceTextOnScreen(CBtraceReader& aReader); + void ConstructL(); + void SeenL(const TBtraceTickCount& aTickCount, const TDesC& aData, TInt aWindowGroupId); +private: // From MBtraceObserver. + virtual void HandleBtraceFrameL(const TBtraceFrame& aFrame); +private: + class TTextOnScreenNotif + { + public: + TTextOnScreenNotif(const TDesC& aText, MBtraceTextOnScreenObserver& aObserver, TBtraceNotificationPersistence aPersistence); + TTextOnScreenNotif(const TDesC& aText, TMatchMode aMatchMode, MBtraceTextOnScreenObserver& aObserver, TBtraceNotificationPersistence aPersistence); + TTextOnScreenNotif(const TDesC& aText, TInt aWindowGroupId, TMatchMode aMatchMode, MBtraceTextOnScreenObserver& aObserver, TBtraceNotificationPersistence aPersistence); + public: + TPtrC iTxtPtr; + TInt iWindowGroupId; + TInt iMatchedChars; + TMatchMode iMatchMode; + MBtraceTextOnScreenObserver* iObserver; + TBtraceNotificationPersistence iPersistence; + }; + CBtraceReader& iReader; + RArray iScreenNotifs; + }; + + +// +// An observer to identify the occurrence of generic events (see btrace_parser_defs.h) +// +class MBtraceGenericObserver + { +public: + virtual void HandleGenericEvent0L(const TBtraceTickCount& aTickCount, TUint8 aSubCategory) = 0; + virtual void HandleGenericEvent1L(const TBtraceTickCount& aTickCount, TUint8 aSubCategory, TUint32 aData1) = 0; + virtual void HandleGenericEvent2L(const TBtraceTickCount& aTickCount, TUint8 aSubCategory, TUint32 aData1, TUint32 aData2) = 0; + virtual void HandleGenericEvent3L(const TBtraceTickCount& aTickCount, TUint8 aSubCategory, TUint32 aData1, TUint32 aData2, TUint32 aData3) = 0; + }; + +NONSHARABLE_CLASS(CBtraceGeneric) : public CRefCountedObject, public MBtraceObserver + { +public: + IMPORT_C static CBtraceGeneric* NewL(CBtraceReader& aReader); + IMPORT_C ~CBtraceGeneric(); + IMPORT_C void NotifyGenericEventL(MBtraceGenericObserver& aObserver); +private: + CBtraceGeneric(CBtraceReader& aReader); + void ConstructL(); + // MBtraceObserver pure virtuals + virtual void HandleBtraceFrameL(const TBtraceFrame& aFrame); + void SeenGeneric0L(const TBtraceTickCount& aTickCount, TUint8 aSubCategory); + void SeenGeneric1L(const TBtraceTickCount& aTickCount, TUint8 aSubCategory, TUint32 aData1); + void SeenGeneric2L(const TBtraceTickCount& aTickCount, TUint8 aSubCategory, TUint32 aData1, TUint32 aData2); + void SeenGeneric3L(const TBtraceTickCount& aTickCount, TUint8 aSubCategory, TUint32 aData1, TUint32 aData2, TUint32 aData3); +private: + CBtraceReader& iReader; + //TODO TBtraceNotificationPersistence iPersistence + RPointerArray iObservers; // pointers not owned + }; + + +class MBtraceDomainEventObserver + { +public: + virtual void HandleDomainEventL(const TBtraceTickCount& aTickCount, MBtraceDomainEventObserver& aObserver) = 0; + }; + +NONSHARABLE_CLASS(CBtraceDomainEvent) : public CRefCountedObject, public MBtraceObserver + { +public: + IMPORT_C static CBtraceDomainEvent* NewL(CBtraceReader& aReader); + IMPORT_C ~CBtraceDomainEvent(); + IMPORT_C void NotifyDomainEventL(TUint aSubCategory, MBtraceDomainEventObserver& aObserver, TBtraceNotificationPersistence aPersistence); + IMPORT_C void NotifyDomainEventL(TUint aSubCategory, TUint aData1, MBtraceDomainEventObserver& aObserver, TBtraceNotificationPersistence aPersistence); + IMPORT_C void NotifyDomainEventL(TUint aSubCategory, TUint aData1, TUint aData2, MBtraceDomainEventObserver& aObserver, TBtraceNotificationPersistence aPersistence); + IMPORT_C void NotifyDomainEventL(TUint aSubCategory, TUint aData1, TUint aData2, TUint aData3, MBtraceDomainEventObserver& aObserver, TBtraceNotificationPersistence aPersistence); + IMPORT_C void CancelNotifyDomainEvent(MBtraceDomainEventObserver& aObserver); +private: + CBtraceDomainEvent(CBtraceReader& aReader); + void ConstructL(); +private: // From MBtraceObserver. + virtual void HandleBtraceFrameL(const TBtraceFrame& aFrame); +private: + class TDomainEventNotif + { + public: + TDomainEventNotif(TUint aSubCategory); + TDomainEventNotif(TUint aSubCategory, MBtraceDomainEventObserver& aObserver, TBtraceNotificationPersistence aPersistence); + void AddDataItem(TUint aData); + TBool operator==(const TDomainEventNotif& aNotif) const; + public: + enum { KMaxNumDataItems = 3 }; + public: + TUint iSubCategory; + MBtraceDomainEventObserver* iObserver; + TBtraceNotificationPersistence iPersistence; + TInt iDataCount; + TFixedArray iData; + }; +private: + CBtraceReader& iReader; + RArray iNotifs; + }; + + +class MBtraceAppResponseObserver + { +public: + virtual void HandleAppResponseSeenL(const TBtraceTickCount& aTickCount) = 0; + }; + +NONSHARABLE_CLASS(CBtraceAppResponse) : public CRefCountedObject, public MBtraceObserver + { +public: + IMPORT_C static CBtraceAppResponse* NewL(CBtraceReader& aReader); + IMPORT_C ~CBtraceAppResponse(); + IMPORT_C void NotifyAppResponseL(MBtraceAppResponseObserver& aObserver, const TProcessId& aProcessId); + IMPORT_C void NotifyAppResponseL(MBtraceAppResponseObserver& aObserver, const TProcessId& aProcessId, TBtraceNotificationPersistence aPersistence); + IMPORT_C void CancelNotifyAppResponse(MBtraceAppResponseObserver& aObserver); +private: + CBtraceAppResponse(CBtraceReader& aReader); + void ConstructL(); + void SeenAppResponseL(const TBtraceTickCount& aTickCount, const TProcessId& aProcessId); +private: // From MBtraceObserver. + virtual void HandleBtraceFrameL(const TBtraceFrame& aFrame); +private: + class TAppResponseNotif + { + public: + TAppResponseNotif(MBtraceAppResponseObserver& aObserver, const TProcessId& aProcessId, TBtraceNotificationPersistence aPersistence); + public: + MBtraceAppResponseObserver& iObserver; + TProcessId iProcessId; + TBtraceNotificationPersistence iPersistence; + }; +private: + CBtraceReader& iReader; + RArray iNotifs; + }; + + +class MBtraceScreenUpdateObserver + { +public: + virtual void HandleScreenUpdateL(const TBtraceTickCount& aTickCount, TInt aScreenNumber, const TRect& aRect) = 0; + }; + +NONSHARABLE_CLASS(CBtraceScreenUpdate) : public CRefCountedObject, public MBtraceObserver + { +public: + IMPORT_C static CBtraceScreenUpdate* NewL(CBtraceReader& aReader); + IMPORT_C ~CBtraceScreenUpdate(); + IMPORT_C void NotifyScreenUpdateL(MBtraceScreenUpdateObserver& aObserver); + IMPORT_C void NotifyScreenUpdateL(MBtraceScreenUpdateObserver& aObserver, TBtraceNotificationPersistence aPersistence); + IMPORT_C void NotifyScreenUpdateL(TInt aScreenNumber, const TRect& aRect, MBtraceScreenUpdateObserver& aObserver); + IMPORT_C void NotifyScreenUpdateL(TInt aScreenNumber, const TRect& aRect, MBtraceScreenUpdateObserver& aObserver, TBtraceNotificationPersistence aPersistence); + IMPORT_C void CancelNotifyScreenUpdate(MBtraceScreenUpdateObserver& aObserver); +private: + CBtraceScreenUpdate(CBtraceReader& aReader); + void ConstructL(); + void HandleScreenUpdateL(const TBtraceTickCount& aTickCount, TInt aScreenNumber, const TRect& aRect); +private: // From MBtraceObserver. + virtual void HandleBtraceFrameL(const TBtraceFrame& aFrame); +private: + class TScreenUpdateNotif + { + public: + TScreenUpdateNotif(MBtraceScreenUpdateObserver& aObserver, TBtraceNotificationPersistence aPersistence); + TScreenUpdateNotif(TInt aScreenNumber, const TRect& aRect, MBtraceScreenUpdateObserver& aObserver, TBtraceNotificationPersistence aPersistence); + public: + TBool iNotifyAll; + TInt iScreenNumber; + TRect iRect; + MBtraceScreenUpdateObserver* iObserver; + TBtraceNotificationPersistence iPersistence; + }; +private: + CBtraceReader& iReader; + RArray iNotifs; + }; + +class MBtracePubSubObserver + { +public: + virtual void HandlePropertyChangedL(const TBtraceTickCount& aTickCount, TUint aCategory, TUint aKey, TInt aNewValue) = 0; + virtual void HandlePropertyChangedL(const TBtraceTickCount& aTickCount, TUint aCategory, TUint aKey, const TDesC8& aNewValue) = 0; + }; + +NONSHARABLE_CLASS(CBtracePubSub) : public CRefCountedObject, public MBtraceObserver + { +public: + IMPORT_C static CBtracePubSub* NewL(CBtraceReader& aReader); + IMPORT_C ~CBtracePubSub(); + IMPORT_C void NotifyPropertyChangedL(MBtracePubSubObserver& aObserver); + IMPORT_C void NotifyPropertyChangedL(TUint* aCategory, TUint* aKey, MBtracePubSubObserver& aObserver, TBtraceNotificationPersistence aPersistence); // Note, the pointer parameters are optional. + IMPORT_C void NotifyIntegerPropertyChangedL(TUint* aCategory, TUint* aKey, TInt* aValue, MBtracePubSubObserver& aObserver, TBtraceNotificationPersistence aPersistence); // Note, the pointer parameters are optional. + IMPORT_C void NotifyDataPropertyChangedL(TUint* aCategory, TUint* aKey, const TDesC8* aValue, MBtracePubSubObserver& aObserver, TBtraceNotificationPersistence aPersistence); // Note, the pointer parameters are optional. + IMPORT_C void CancelNotifyPropertyChanged(MBtracePubSubObserver& aObserver); +private: + CBtracePubSub(CBtraceReader& aReader); + void ConstructL(); +private: // From MBtraceObserver. + virtual void HandleBtraceFrameL(const TBtraceFrame& aFrame); +private: + class TPubSubNotif + { + public: + TPubSubNotif(TUint* aCategory, TUint* aKey, TInt* aIntegerValue, const TDesC8* aDataValue, MBtracePubSubObserver& aObserver, TBtraceNotificationPersistence aPersistence); + TBool Matches(TUint aCategory, TUint aKey, TInt aIntegerValue) const; + TBool Matches(TUint aCategory, TUint aKey, const TDesC8& aDataValue) const; + public: + TUint* iCategory; + TUint* iKey; + TInt* iIntegerValue; + const TDesC8* iDataValue; + MBtracePubSubObserver& iObserver; + TBtraceNotificationPersistence iPersistence; + }; +private: + CBtraceReader& iReader; + RArray iNotifs; + }; + +class MBtraceFocusChangeObserver + { +public: + virtual void HandleFocusChangedL(const TBtraceTickCount& aTickCount, const TBtraceWindowGroupId& aWindowGroupId) = 0; + }; + +NONSHARABLE_CLASS(CBtraceFocusChange) : public CRefCountedObject, public MBtraceObserver + { +public: + IMPORT_C static CBtraceFocusChange* NewL(CBtraceReader& aReader, CBtraceContext& aContext); + IMPORT_C ~CBtraceFocusChange(); + IMPORT_C void NotifyFocusChangedL(const TDesC& aWindowGroupNamePattern, MBtraceFocusChangeObserver& aObserver); + IMPORT_C void NotifyFocusChangedL(const TDesC& aWindowGroupNamePattern, MBtraceFocusChangeObserver& aObserver, TBtraceNotificationPersistence aPersistence); + IMPORT_C void CancelNotifyFocusChanged(MBtraceFocusChangeObserver& aObserver); +private: + CBtraceFocusChange(CBtraceReader& aReader, CBtraceContext& aContext); + void ConstructL(); +private: // From MBtraceObserver. + virtual void HandleBtraceFrameL(const TBtraceFrame& aFrame); +private: + class TFocusChangeNotif + { + public: + TFocusChangeNotif(const TDesC& aWindowGroupNamePattern, MBtraceFocusChangeObserver& aObserver, TBtraceNotificationPersistence aPersistence); + public: + TPtrC iWindowGroupNamePattern; + MBtraceFocusChangeObserver& iObserver; + TBtraceNotificationPersistence iPersistence; + }; +private: + CBtraceReader& iReader; + CBtraceContext& iContext; + RArray iNotifs; + }; + + +#endif // __BTRACE_PARSER_H__