--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/memspy/memspy_plat/memspy_api/include/memspy/engine/ThreadAndProcess/MemSpyEngineObjectThreadInfoObjects.h Tue Feb 02 01:57:15 2010 +0200
@@ -0,0 +1,913 @@
+/*
+* Copyright (c) 2009 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:
+*
+*/
+
+#ifndef MEMSPYTHREADINFOOBJECTS_H
+#define MEMSPYTHREADINFOOBJECTS_H
+
+// System includes
+#include <e32base.h>
+#include <badesca.h>
+
+// User includes
+#include <memspy/engine/memspyengineobject.h>
+#include <memspy/driver/memspydriverobjectsshared.h>
+#include <memspy/engine/memspyengineprocessmemorytracker.h>
+
+// Classes referenced
+class CMemSpyEngine;
+class CMemSpyThread;
+class CMemSpyThreadInfoContainer;
+class CMemSpyEngineChunkList;
+class CMemSpyEngineCodeSegList;
+class CMemSpyEngineActiveObjectArray;
+
+// Enumerations
+enum TMemSpyThreadInfoItemType
+ {
+ EMemSpyThreadInfoItemTypeFirst = 0,
+ //
+ EMemSpyThreadInfoItemTypeGeneralInfo = EMemSpyThreadInfoItemTypeFirst,
+ EMemSpyThreadInfoItemTypeHeap,
+ EMemSpyThreadInfoItemTypeStack,
+ EMemSpyThreadInfoItemTypeChunk,
+ EMemSpyThreadInfoItemTypeCodeSeg,
+ EMemSpyThreadInfoItemTypeOpenFiles,
+ EMemSpyThreadInfoItemTypeActiveObject,
+ EMemSpyThreadInfoItemTypeOwnedThreadHandles,
+ EMemSpyThreadInfoItemTypeOwnedProcessHandles,
+ EMemSpyThreadInfoItemTypeServer,
+ EMemSpyThreadInfoItemTypeSession,
+ EMemSpyThreadInfoItemTypeSemaphore,
+ EMemSpyThreadInfoItemTypeOtherThreads,
+ EMemSpyThreadInfoItemTypeOtherProcesses,
+ EMemSpyThreadInfoItemTypeMutex,
+ EMemSpyThreadInfoItemTypeTimer,
+ EMemSpyThreadInfoItemTypeLogicalChannel,
+ EMemSpyThreadInfoItemTypeChangeNotifier,
+ EMemSpyThreadInfoItemTypeUndertaker,
+ EMemSpyThreadInfoItemTypeMessageQueue,
+ EMemSpyThreadInfoItemTypeConditionalVariable,
+ EMemSpyThreadInfoItemTypeLDD,
+ EMemSpyThreadInfoItemTypePDD,
+ EMemSpyThreadInfoItemTypeMemoryTracking,
+ EMemSpyThreadInfoItemTypeMemoryTrackingCurrent,
+ EMemSpyThreadInfoItemTypeMemoryTrackingHWM,
+ EMemSpyThreadInfoItemTypeMemoryTrackingPeak,
+ //
+ EMemSpyThreadInfoItemTypeLast
+ };
+
+// Constants
+const TInt KMemSpyDefaultMaxHandleCount = 128;
+
+
+
+NONSHARABLE_CLASS( CMemSpyThreadInfoItemBase ) : public CMemSpyEngineObject, public MDesCArray
+ {
+protected:
+ CMemSpyThreadInfoItemBase( CMemSpyThreadInfoContainer& aContainer, TMemSpyThreadInfoItemType aType, TBool aAsyncConstruction );
+ ~CMemSpyThreadInfoItemBase();
+ virtual void ConstructL() = 0;
+
+private: // Construction support
+ static TInt CallConstructL( TAny* aSelf );
+
+public: // API
+ virtual TPtrC Name() const = 0;
+ IMPORT_C TMemSpyThreadInfoItemType Type() const;
+ IMPORT_C virtual void RebuildL();
+ inline CMemSpyThreadInfoContainer& Container() { return iContainer; }
+ IMPORT_C TBool IsReady() const;
+ IMPORT_C CMemSpyEngine& Engine() const;
+ IMPORT_C void PrintL();
+
+public: // From MDesCArray
+ IMPORT_C TInt MdcaCount() const;
+ IMPORT_C TPtrC MdcaPoint(TInt aIndex) const;
+
+protected:
+ class CItem : public CBase
+ {
+ public:
+ static CItem* NewLC( const CItem& aCopyMe );
+ static CItem* NewLC( const TDesC& aCaption );
+ static CItem* NewLC( const TDesC& aCaption, const TDesC& aValue );
+ static CItem* NewHexLC( const TDesC& aCaption, TUint aValue );
+ static CItem* NewDecimalLC( const TDesC& aCaption, TInt aValue );
+ static CItem* NewLongLC( const TDesC& aCaption, const TInt64& aValue );
+ static CItem* NewYesNoLC( const TDesC& aCaption, TBool aYes );
+ static CItem* NewOnOffLC( const TDesC& aCaption, TBool aOn );
+ static CItem* NewPercentageLC( const TDesC& aCaption, TInt aOneHundredPercentValue, TInt aValue );
+ ~CItem();
+
+ private:
+ CItem();
+ void ConstructL( const TDesC& aCaption, const TDesC& aValue );
+
+ public: // API
+ inline const TDesC& Caption() const { return *iCaption; }
+ inline const TDesC& Value() const { return *iValue; }
+ inline const TDesC& Combined() const { return *iCombined; }
+
+ public:
+ void SetValueL( const TDesC& aValue );
+ void SetHexL( TUint aValue );
+ void SetDecimalL( TInt aValue );
+ void SetLongL( const TInt64& aValue );
+ void SetYesNoL( TBool aYes );
+ void SetOnOffL( TBool aOn );
+ void SetPercentageL( TInt aOneHundredPercentValue, TInt aValue );
+
+ private: // Internal
+ void UpdateCombinedL();
+
+ private:
+ HBufC* iCaption;
+ HBufC* iValue;
+ HBufC* iCombined;
+ };
+
+protected: // Internal API
+ void AddItemL( const TDesC& aCaption, const TDesC& aValue );
+ void AddItemHexL( const TDesC& aCaption, TUint aValue );
+ void AddItemDecimalL( const TDesC& aCaption, TInt aValue );
+ void AddItemLongL( const TDesC& aCaption, const TInt64& aValue );
+ void AddItemYesNoL( const TDesC& aCaption, TBool aYes );
+ void AddItemOnOffL( const TDesC& aCaption, TBool aOn );
+ void AddItemPercentageL( const TDesC& aCaption, TInt aOneHundredPercentValue, TInt aValue );
+ void StripProcessAndThreadNames( TDes& aText );
+ void StripProcessName( TDes& aText );
+ void StripThreadName( TDes& aText );
+ CItem& Item( TInt aIndex );
+ const CItem& Item( TInt aIndex ) const;
+ virtual void Reset();
+
+private:
+ mutable CMemSpyThreadInfoContainer& iContainer;
+ TBool iReady;
+ TBool iIsEmpty;
+ RPointerArray<CItem> iItems;
+ CAsyncCallBack iCallBack;
+ const TMemSpyThreadInfoItemType iType;
+ };
+
+
+
+
+
+
+
+
+NONSHARABLE_CLASS( CMemSpyThreadInfoGeneral ) : public CMemSpyThreadInfoItemBase
+ {
+public:
+ static CMemSpyThreadInfoGeneral* NewLC( CMemSpyThreadInfoContainer& aContainer, TBool aAsyncConstruction );
+
+private: // From CMemSpyThreadInfoItemBase
+ CMemSpyThreadInfoGeneral( CMemSpyThreadInfoContainer& aContainer, TBool aAsyncConstruction );
+ void ConstructL();
+
+public: // From CMemSpyThreadInfoItemBase
+ IMPORT_C TPtrC Name() const;
+
+private: // Internal methods
+ void MakeRegisterListingL( RThread& aThread );
+ };
+
+
+
+
+
+
+
+NONSHARABLE_CLASS( CMemSpyThreadInfoHeap ) : public CMemSpyThreadInfoItemBase
+ {
+public:
+ static CMemSpyThreadInfoHeap* NewLC( CMemSpyThreadInfoContainer& aContainer, TBool aAsyncConstruction );
+
+private: // From CMemSpyThreadInfoItemBase
+ CMemSpyThreadInfoHeap( CMemSpyThreadInfoContainer& aContainer, TBool aAsyncConstruction );
+ void ConstructL();
+
+public: // From CMemSpyThreadInfoItemBase
+ IMPORT_C TPtrC Name() const;
+ };
+
+
+
+
+
+
+
+NONSHARABLE_CLASS( CMemSpyThreadInfoOpenFiles ) : public CMemSpyThreadInfoItemBase
+ {
+public:
+ static CMemSpyThreadInfoOpenFiles* NewLC( CMemSpyThreadInfoContainer& aContainer, TBool aAsyncConstruction );
+
+private: // From CMemSpyThreadInfoItemBase
+ CMemSpyThreadInfoOpenFiles( CMemSpyThreadInfoContainer& aContainer, TBool aAsyncConstruction );
+ void ConstructL();
+
+public: // From CMemSpyThreadInfoItemBase
+ IMPORT_C TPtrC Name() const;
+ };
+
+
+
+
+
+
+NONSHARABLE_CLASS( CMemSpyThreadInfoActiveObjects ) : public CMemSpyThreadInfoItemBase
+ {
+public:
+ static CMemSpyThreadInfoActiveObjects* NewLC( CMemSpyThreadInfoContainer& aContainer, TBool aAsyncConstruction );
+ ~CMemSpyThreadInfoActiveObjects();
+
+private: // From CMemSpyThreadInfoItemBase
+ CMemSpyThreadInfoActiveObjects( CMemSpyThreadInfoContainer& aContainer, TBool aAsyncConstruction );
+ void ConstructL();
+
+public: // From CMemSpyThreadInfoItemBase
+ IMPORT_C TPtrC Name() const;
+
+public: // From MDesCArray
+ IMPORT_C TInt MdcaCount() const;
+ IMPORT_C TPtrC MdcaPoint(TInt aIndex) const;
+
+public: // API
+ inline CMemSpyEngineActiveObjectArray& Array() { return *iItems; }
+
+private: // Member data
+ CMemSpyEngineActiveObjectArray* iItems;
+ };
+
+
+
+
+
+
+
+NONSHARABLE_CLASS( CMemSpyThreadInfoStack ) : public CMemSpyThreadInfoItemBase
+ {
+public:
+ static CMemSpyThreadInfoStack* NewLC( CMemSpyThreadInfoContainer& aContainer, TBool aAsyncConstruction );
+
+private: // From CMemSpyThreadInfoItemBase
+ CMemSpyThreadInfoStack( CMemSpyThreadInfoContainer& aContainer, TBool aAsyncConstruction );
+ void ConstructL();
+
+public: // From CMemSpyThreadInfoItemBase
+ IMPORT_C TPtrC Name() const;
+ };
+
+
+
+
+
+
+
+
+
+
+NONSHARABLE_CLASS( CMemSpyThreadInfoChunk ) : public CMemSpyThreadInfoItemBase
+ {
+public:
+ static CMemSpyThreadInfoChunk* NewLC( CMemSpyThreadInfoContainer& aContainer, TBool aAsyncConstruction );
+ ~CMemSpyThreadInfoChunk();
+
+private: // From CMemSpyThreadInfoItemBase
+ CMemSpyThreadInfoChunk( CMemSpyThreadInfoContainer& aContainer, TBool aAsyncConstruction );
+ void ConstructL();
+
+public: // From CMemSpyThreadInfoItemBase
+ IMPORT_C TPtrC Name() const;
+
+public: // From MDesCArray
+ IMPORT_C TInt MdcaCount() const;
+ IMPORT_C TPtrC MdcaPoint(TInt aIndex) const;
+
+public: // API
+ inline CMemSpyEngineChunkList& List() { return *iList; }
+ inline void NullifyList() { iList = NULL; }
+
+private:
+ CMemSpyEngineChunkList* iList;
+ };
+
+
+
+
+
+NONSHARABLE_CLASS( CMemSpyThreadInfoCodeSeg ) : public CMemSpyThreadInfoItemBase
+ {
+public:
+ static CMemSpyThreadInfoCodeSeg* NewLC( CMemSpyThreadInfoContainer& aContainer, TBool aAsyncConstruction );
+ ~CMemSpyThreadInfoCodeSeg();
+
+private: // From CMemSpyThreadInfoItemBase
+ CMemSpyThreadInfoCodeSeg( CMemSpyThreadInfoContainer& aContainer, TBool aAsyncConstruction );
+ void ConstructL();
+
+public: // From CMemSpyThreadInfoItemBase
+ IMPORT_C TPtrC Name() const;
+
+public: // From MDesCArray
+ IMPORT_C TInt MdcaCount() const;
+ IMPORT_C TPtrC MdcaPoint(TInt aIndex) const;
+
+public: // API
+ inline CMemSpyEngineCodeSegList& List() { return *iList; }
+ inline void NullifyList() { iList = NULL; }
+
+private: // Data members
+ CMemSpyEngineCodeSegList* iList;
+ };
+
+
+
+
+
+
+
+
+
+
+NONSHARABLE_CLASS( CMemSpyThreadInfoHandleObjectBase ) : public CMemSpyThreadInfoItemBase
+ {
+public:
+ ~CMemSpyThreadInfoHandleObjectBase();
+
+protected: // From CMemSpyThreadInfoItemBase
+ CMemSpyThreadInfoHandleObjectBase( CMemSpyThreadInfoContainer& aContainer, TMemSpyThreadInfoItemType aItemType, TMemSpyDriverContainerType aContainerType, TBool aAsyncConstruction );
+ void ConstructL();
+
+public: // New API
+ inline TMemSpyDriverContainerType ContainerType() const { return iContainerType; }
+ inline TInt DetailsCount() const { return iInfoItems.Count(); }
+ inline TMemSpyDriverHandleInfoGeneric& DetailsAt( TInt aIndex ) { return iInfoItems[ aIndex ]; }
+ inline const TMemSpyDriverHandleInfoGeneric& DetailsAt( TInt aIndex ) const { return iInfoItems[ aIndex ]; }
+ IMPORT_C TInt DetailsIndexByEntry( const TMemSpyDriverHandleInfoGeneric& aEntry ) const;
+ IMPORT_C TInt DetailsIndexByHandle( TAny* aHandle ) const;
+
+protected: // Internal class
+ class THandleWrapper
+ {
+ public:
+ inline THandleWrapper( TAny* aHandle, TMemSpyDriverContainerType aType ) : iHandle( aHandle ), iType( aType ), iRefCount( 1 ) { }
+
+ public: // API
+ static TBool Match( const THandleWrapper& aLeft, const THandleWrapper& aRight );
+
+ public: // Data members
+ TAny* iHandle;
+ TMemSpyDriverContainerType iType;
+ TInt iRefCount;
+ };
+
+protected: // Internal API
+ virtual void GetHandlesL( RArray<THandleWrapper>& aArray ) = 0;
+
+protected: // New internal framework API
+ virtual void HandleContainerItemL( TMemSpyDriverHandleInfoGeneric& aItem, TInt aRefCount, TDes& aFullName ) = 0;
+ virtual void HandleAllItemsLocatedL() { }
+
+private: // Data members
+ const TMemSpyDriverContainerType iContainerType;
+ RArray< TMemSpyDriverHandleInfoGeneric > iInfoItems;
+ };
+
+
+
+
+
+
+
+
+
+NONSHARABLE_CLASS( CMemSpyThreadInfoHandleByContainer ) : public CMemSpyThreadInfoHandleObjectBase
+ {
+protected: // From CMemSpyThreadInfoItemBase
+ CMemSpyThreadInfoHandleByContainer( CMemSpyThreadInfoContainer& aContainer, TMemSpyThreadInfoItemType aItemType, TMemSpyDriverContainerType aContainerType, TBool aAsyncConstruction );
+
+protected: // From CMemSpyThreadInfoHandleObjectBase
+ void GetHandlesL( RArray<THandleWrapper>& aArray );
+ };
+
+
+
+
+
+NONSHARABLE_CLASS( CMemSpyThreadInfoReferencedBy ) : public CMemSpyThreadInfoHandleObjectBase
+ {
+protected: // From CMemSpyThreadInfoItemBase
+ CMemSpyThreadInfoReferencedBy( CMemSpyThreadInfoContainer& aContainer, TMemSpyThreadInfoItemType aItemType, TMemSpyDriverContainerType aContainerType, TBool aAsyncConstruction );
+
+protected: // From CMemSpyThreadInfoHandleObjectBase
+ void GetHandlesL( RArray<THandleWrapper>& aArray );
+ };
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+NONSHARABLE_CLASS( CMemSpyThreadInfoServer ) : public CMemSpyThreadInfoHandleByContainer
+ {
+public:
+ static CMemSpyThreadInfoServer* NewLC( CMemSpyThreadInfoContainer& aContainer, TBool aAsyncConstruction );
+
+private:
+ CMemSpyThreadInfoServer( CMemSpyThreadInfoContainer& aContainer, TBool aAsyncConstruction );
+
+public: // From CMemSpyThreadInfoItemBase
+ IMPORT_C TPtrC Name() const;
+ IMPORT_C static TPtrC SessionType( TIpcSessionType aType );
+
+private: // From CMemSpyThreadInfoHandleByContainer
+ void HandleContainerItemL( TMemSpyDriverHandleInfoGeneric& aItem, TInt aRefCount, TDes& aFullName );
+ };
+
+
+
+
+
+NONSHARABLE_CLASS( CMemSpyThreadInfoSession ) : public CMemSpyThreadInfoHandleByContainer
+ {
+public:
+ static CMemSpyThreadInfoSession* NewLC( CMemSpyThreadInfoContainer& aContainer, TBool aAsyncConstruction );
+ ~CMemSpyThreadInfoSession();
+
+private:
+ CMemSpyThreadInfoSession( CMemSpyThreadInfoContainer& aContainer, TBool aAsyncConstruction );
+
+public: // From CMemSpyThreadInfoItemBase
+ IMPORT_C TPtrC Name() const;
+
+public: // API
+ IMPORT_C TInt ConnectionCount( const TDesC& aName ) const;
+
+private: // From CMemSpyThreadInfoHandleByContainer
+ void HandleContainerItemL( TMemSpyDriverHandleInfoGeneric& aItem, TInt aRefCount, TDes& aFullName );
+ void HandleAllItemsLocatedL();
+
+protected: // From CMemSpyThreadInfoItemBase
+ void Reset();
+
+private: // Internal object
+ class CSessionInfoEntry : public CBase
+ {
+ public:
+ inline CSessionInfoEntry( HBufC* aName ) : iCount(1), iName( aName ) { }
+ inline ~CSessionInfoEntry() { delete iName; }
+
+ public:
+ TInt iCount;
+ HBufC* iName;
+ };
+
+private: // Internal methods
+ static TBool CompareEntries( const CSessionInfoEntry& aLeft, const CSessionInfoEntry& aRight );
+
+private:
+ RPointerArray<CSessionInfoEntry> iServerNames;
+ };
+
+
+
+
+
+NONSHARABLE_CLASS( CMemSpyThreadInfoSemaphore ) : public CMemSpyThreadInfoHandleByContainer
+ {
+public:
+ static CMemSpyThreadInfoSemaphore* NewLC( CMemSpyThreadInfoContainer& aContainer, TBool aAsyncConstruction );
+
+private:
+ CMemSpyThreadInfoSemaphore( CMemSpyThreadInfoContainer& aContainer, TBool aAsyncConstruction );
+
+public: // From CMemSpyThreadInfoItemBase
+ IMPORT_C TPtrC Name() const;
+
+private: // From CMemSpyThreadInfoHandleByContainer
+ void HandleContainerItemL( TMemSpyDriverHandleInfoGeneric& aItem, TInt aRefCount, TDes& aFullName );
+ };
+
+
+
+
+
+NONSHARABLE_CLASS( CMemSpyThreadInfoMutex ) : public CMemSpyThreadInfoHandleByContainer
+ {
+public:
+ static CMemSpyThreadInfoMutex* NewLC( CMemSpyThreadInfoContainer& aContainer, TBool aAsyncConstruction );
+
+private:
+ CMemSpyThreadInfoMutex( CMemSpyThreadInfoContainer& aContainer, TBool aAsyncConstruction );
+
+public: // From CMemSpyThreadInfoItemBase
+ IMPORT_C TPtrC Name() const;
+
+private: // From CMemSpyThreadInfoHandleByContainer
+ void HandleContainerItemL( TMemSpyDriverHandleInfoGeneric& aItem, TInt aRefCount, TDes& aFullName );
+ };
+
+
+
+
+
+NONSHARABLE_CLASS( CMemSpyThreadInfoTimer ) : public CMemSpyThreadInfoHandleByContainer
+ {
+public:
+ static CMemSpyThreadInfoTimer* NewLC( CMemSpyThreadInfoContainer& aContainer, TBool aAsyncConstruction );
+
+private:
+ CMemSpyThreadInfoTimer( CMemSpyThreadInfoContainer& aContainer, TBool aAsyncConstruction );
+
+public: // From CMemSpyThreadInfoItemBase
+ IMPORT_C TPtrC Name() const;
+
+private: // From CMemSpyThreadInfoHandleByContainer
+ void HandleContainerItemL( TMemSpyDriverHandleInfoGeneric& aItem, TInt aRefCount, TDes& aFullName );
+
+private: // Internal methods
+ static void GetTimerState( TMemSpyDriverTimerState aState, TDes& aBuf );
+ static void GetTimerType( TMemSpyDriverTimerType aType, TDes& aBuf );
+ };
+
+
+
+
+
+NONSHARABLE_CLASS( CMemSpyThreadInfoLDD ) : public CMemSpyThreadInfoHandleByContainer
+ {
+public:
+ static CMemSpyThreadInfoLDD* NewLC( CMemSpyThreadInfoContainer& aContainer, TBool aAsyncConstruction );
+
+private:
+ CMemSpyThreadInfoLDD( CMemSpyThreadInfoContainer& aContainer, TBool aAsyncConstruction );
+
+public: // From CMemSpyThreadInfoItemBase
+ IMPORT_C TPtrC Name() const;
+
+private: // From CMemSpyThreadInfoHandleByContainer
+ void HandleContainerItemL( TMemSpyDriverHandleInfoGeneric& aItem, TInt aRefCount, TDes& aFullName );
+ };
+
+
+
+
+
+NONSHARABLE_CLASS( CMemSpyThreadInfoPDD ) : public CMemSpyThreadInfoHandleByContainer
+ {
+public:
+ static CMemSpyThreadInfoPDD* NewLC( CMemSpyThreadInfoContainer& aContainer, TBool aAsyncConstruction );
+
+private:
+ CMemSpyThreadInfoPDD( CMemSpyThreadInfoContainer& aContainer, TBool aAsyncConstruction );
+
+public: // From CMemSpyThreadInfoItemBase
+ IMPORT_C TPtrC Name() const;
+
+private: // From CMemSpyThreadInfoHandleByContainer
+ void HandleContainerItemL( TMemSpyDriverHandleInfoGeneric& aItem, TInt aRefCount, TDes& aFullName );
+ };
+
+
+
+
+
+NONSHARABLE_CLASS( CMemSpyThreadInfoLogicalChannel ) : public CMemSpyThreadInfoHandleByContainer
+ {
+public:
+ static CMemSpyThreadInfoLogicalChannel* NewLC( CMemSpyThreadInfoContainer& aContainer, TBool aAsyncConstruction );
+
+private:
+ CMemSpyThreadInfoLogicalChannel( CMemSpyThreadInfoContainer& aContainer, TBool aAsyncConstruction );
+
+public: // From CMemSpyThreadInfoItemBase
+ IMPORT_C TPtrC Name() const;
+
+private: // From CMemSpyThreadInfoHandleByContainer
+ void HandleContainerItemL( TMemSpyDriverHandleInfoGeneric& aItem, TInt aRefCount, TDes& aFullName );
+ };
+
+
+
+
+
+NONSHARABLE_CLASS( CMemSpyThreadInfoChangeNotifier ) : public CMemSpyThreadInfoHandleByContainer
+ {
+public:
+ static CMemSpyThreadInfoChangeNotifier* NewLC( CMemSpyThreadInfoContainer& aContainer, TBool aAsyncConstruction );
+
+private:
+ CMemSpyThreadInfoChangeNotifier( CMemSpyThreadInfoContainer& aContainer, TBool aAsyncConstruction );
+
+public: // From CMemSpyThreadInfoItemBase
+ IMPORT_C TPtrC Name() const;
+
+private: // From CMemSpyThreadInfoHandleByContainer
+ void HandleContainerItemL( TMemSpyDriverHandleInfoGeneric& aItem, TInt aRefCount, TDes& aFullName );
+ };
+
+
+
+
+
+NONSHARABLE_CLASS( CMemSpyThreadInfoUndertaker ) : public CMemSpyThreadInfoHandleByContainer
+ {
+public:
+ static CMemSpyThreadInfoUndertaker* NewLC( CMemSpyThreadInfoContainer& aContainer, TBool aAsyncConstruction );
+
+private:
+ CMemSpyThreadInfoUndertaker( CMemSpyThreadInfoContainer& aContainer, TBool aAsyncConstruction );
+
+public: // From CMemSpyThreadInfoItemBase
+ IMPORT_C TPtrC Name() const;
+
+private: // From CMemSpyThreadInfoHandleByContainer
+ void HandleContainerItemL( TMemSpyDriverHandleInfoGeneric& aItem, TInt aRefCount, TDes& aFullName );
+ };
+
+
+
+
+
+NONSHARABLE_CLASS( CMemSpyThreadInfoOwnedThreadHandles ) : public CMemSpyThreadInfoHandleByContainer
+ {
+public:
+ static CMemSpyThreadInfoOwnedThreadHandles* NewLC( CMemSpyThreadInfoContainer& aContainer, TBool aAsyncConstruction );
+
+private:
+ CMemSpyThreadInfoOwnedThreadHandles( CMemSpyThreadInfoContainer& aContainer, TBool aAsyncConstruction );
+
+public: // From CMemSpyThreadInfoItemBase
+ IMPORT_C TPtrC Name() const;
+
+private: // From CMemSpyThreadInfoHandleByContainer
+ void HandleContainerItemL( TMemSpyDriverHandleInfoGeneric& aItem, TInt aRefCount, TDes& aFullName );
+ };
+
+
+
+
+
+NONSHARABLE_CLASS( CMemSpyThreadInfoOwnedProcessHandles ) : public CMemSpyThreadInfoHandleByContainer
+ {
+public:
+ static CMemSpyThreadInfoOwnedProcessHandles* NewLC( CMemSpyThreadInfoContainer& aContainer, TBool aAsyncConstruction );
+
+private:
+ CMemSpyThreadInfoOwnedProcessHandles( CMemSpyThreadInfoContainer& aContainer, TBool aAsyncConstruction );
+
+public: // From CMemSpyThreadInfoItemBase
+ IMPORT_C TPtrC Name() const;
+
+private: // From CMemSpyThreadInfoHandleByContainer
+ void HandleContainerItemL( TMemSpyDriverHandleInfoGeneric& aItem, TInt aRefCount, TDes& aFullName );
+ };
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+NONSHARABLE_CLASS( CMemSpyThreadInfoOtherThreads ) : public CMemSpyThreadInfoReferencedBy
+ {
+public:
+ static CMemSpyThreadInfoOtherThreads* NewLC( CMemSpyThreadInfoContainer& aContainer, TBool aAsyncConstruction );
+
+private:
+ CMemSpyThreadInfoOtherThreads( CMemSpyThreadInfoContainer& aContainer, TBool aAsyncConstruction );
+
+public: // From CMemSpyThreadInfoItemBase
+ IMPORT_C TPtrC Name() const;
+
+private: // From CMemSpyThreadInfoHandleByContainer
+ void HandleContainerItemL( TMemSpyDriverHandleInfoGeneric& aItem, TInt aRefCount, TDes& aFullName );
+ };
+
+
+
+NONSHARABLE_CLASS( CMemSpyThreadInfoOtherProcesses ) : public CMemSpyThreadInfoReferencedBy
+ {
+public:
+ static CMemSpyThreadInfoOtherProcesses* NewLC( CMemSpyThreadInfoContainer& aContainer, TBool aAsyncConstruction );
+
+private:
+ CMemSpyThreadInfoOtherProcesses( CMemSpyThreadInfoContainer& aContainer, TBool aAsyncConstruction );
+
+public: // From CMemSpyThreadInfoItemBase
+ IMPORT_C TPtrC Name() const;
+
+private: // From CMemSpyThreadInfoHandleByContainer
+ void HandleContainerItemL( TMemSpyDriverHandleInfoGeneric& aItem, TInt aRefCount, TDes& aFullName );
+ };
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+NONSHARABLE_CLASS( CMemSpyThreadInfoMemoryTrackingStatisticsCurrent ) : public CMemSpyThreadInfoItemBase, public MMemSpyEngineProcessMemoryTrackerObserver
+ {
+public:
+ static CMemSpyThreadInfoMemoryTrackingStatisticsCurrent* NewLC( CMemSpyThreadInfoContainer& aContainer, TBool aAsyncConstruction );
+ ~CMemSpyThreadInfoMemoryTrackingStatisticsCurrent();
+
+private: // From CMemSpyThreadInfoItemBase
+ CMemSpyThreadInfoMemoryTrackingStatisticsCurrent( CMemSpyThreadInfoContainer& aContainer, TBool aAsyncConstruction );
+ void ConstructL();
+
+public: // From CMemSpyThreadInfoItemBase
+ TPtrC Name() const;
+
+public: // API
+ void SetTotalIncludesSharedMemoryL( TBool aIncludesSharedMemory );
+ inline CMemSpyEngineProcessMemoryTracker& Tracker() { return *iTracker; }
+
+private: // From MMemSpyEngineProcessMemoryTrackerObserver
+ void HandleMemoryTrackingStartedL();
+ void HandleMemoryTrackingStoppedL();
+ void HandleMemoryChangedL( const TProcessId& aPid, const TMemSpyDriverProcessInspectionInfo& aCurrentInfo, const TMemSpyDriverProcessInspectionInfo& aHWMInfoIncShared, const TMemSpyDriverProcessInspectionInfo& aHWMInfoExcShared );
+
+private: // Member data
+ TBool iTotalIncludesSharedMemory;
+ CMemSpyEngineProcessMemoryTracker* iTracker;
+ };
+
+
+
+
+
+NONSHARABLE_CLASS( CMemSpyThreadInfoMemoryTrackingStatisticsPeak ) : public CMemSpyThreadInfoItemBase, public MMemSpyEngineProcessMemoryTrackerObserver
+ {
+public:
+ static CMemSpyThreadInfoMemoryTrackingStatisticsPeak* NewLC( CMemSpyThreadInfoContainer& aContainer, TBool aAsyncConstruction );
+ ~CMemSpyThreadInfoMemoryTrackingStatisticsPeak();
+
+private: // From CMemSpyThreadInfoItemBase
+ CMemSpyThreadInfoMemoryTrackingStatisticsPeak( CMemSpyThreadInfoContainer& aContainer, TBool aAsyncConstruction );
+ void ConstructL();
+
+public: // From CMemSpyThreadInfoItemBase
+ TPtrC Name() const;
+
+public: // API
+ void SetTotalIncludesSharedMemoryL( TBool aIncludesSharedMemory );
+ inline CMemSpyEngineProcessMemoryTracker& Tracker() { return *iTracker; }
+
+private: // From MMemSpyEngineProcessMemoryTrackerObserver
+ void HandleMemoryTrackingStartedL();
+ void HandleMemoryTrackingStoppedL();
+ void HandleMemoryChangedL( const TProcessId& aPid, const TMemSpyDriverProcessInspectionInfo& aCurrentInfo, const TMemSpyDriverProcessInspectionInfo& aHWMInfoIncShared, const TMemSpyDriverProcessInspectionInfo& aHWMInfoExcShared );
+
+private: // Member data
+ TBool iTotalIncludesSharedMemory;
+ CMemSpyEngineProcessMemoryTracker* iTracker;
+ };
+
+
+
+
+NONSHARABLE_CLASS( CMemSpyThreadInfoMemoryTrackingStatisticsHWM ) : public CMemSpyThreadInfoItemBase, public MMemSpyEngineProcessMemoryTrackerObserver
+ {
+public:
+ static CMemSpyThreadInfoMemoryTrackingStatisticsHWM* NewLC( CMemSpyThreadInfoContainer& aContainer, TBool aAsyncConstruction );
+ ~CMemSpyThreadInfoMemoryTrackingStatisticsHWM();
+
+private: // From CMemSpyThreadInfoItemBase
+ CMemSpyThreadInfoMemoryTrackingStatisticsHWM( CMemSpyThreadInfoContainer& aContainer, TBool aAsyncConstruction );
+ void ConstructL();
+
+public: // From CMemSpyThreadInfoItemBase
+ TPtrC Name() const;
+
+public: // API
+ void SetTotalIncludesSharedMemoryL( TBool aIncludesSharedMemory );
+ inline CMemSpyEngineProcessMemoryTracker& Tracker() { return *iTracker; }
+
+private: // From MMemSpyEngineProcessMemoryTrackerObserver
+ void HandleMemoryTrackingStartedL();
+ void HandleMemoryTrackingStoppedL();
+ void HandleMemoryChangedL( const TProcessId& aPid, const TMemSpyDriverProcessInspectionInfo& aCurrentInfo, const TMemSpyDriverProcessInspectionInfo& aHWMInfoIncShared, const TMemSpyDriverProcessInspectionInfo& aHWMInfoExcShared );
+
+private: // Member data
+ TBool iTotalIncludesSharedMemory;
+ CMemSpyEngineProcessMemoryTracker* iTracker;
+ };
+
+
+
+
+
+NONSHARABLE_CLASS( CMemSpyThreadInfoMemoryTracking ) : public CMemSpyThreadInfoItemBase, public MMemSpyEngineProcessMemoryTrackerObserver
+ {
+public:
+ static CMemSpyThreadInfoMemoryTracking* NewLC( CMemSpyThreadInfoContainer& aContainer, TBool aAsyncConstruction );
+ ~CMemSpyThreadInfoMemoryTracking();
+
+private: // From CMemSpyThreadInfoItemBase
+ CMemSpyThreadInfoMemoryTracking( CMemSpyThreadInfoContainer& aContainer, TBool aAsyncConstruction );
+ void ConstructL();
+
+public: // From CMemSpyThreadInfoItemBase
+ IMPORT_C TPtrC Name() const;
+
+public: // API
+ IMPORT_C TBool TrackingActive() const;
+ IMPORT_C TBool TotalIncludesSharedMemory() const;
+ IMPORT_C void TrackingSetTotalIncludesSharedMemoryL( TBool aIncludesSharedMemory );
+ IMPORT_C void TrackingStartL();
+ IMPORT_C void TrackingStopL();
+ IMPORT_C void TrackingResetHWML();
+ IMPORT_C void TrackingObserverAddL( MMemSpyEngineProcessMemoryTrackerObserver& aObserver );
+ IMPORT_C void TrackingObserverRemove( MMemSpyEngineProcessMemoryTrackerObserver& aObserver );
+ IMPORT_C MDesCArray& InfoCurrent();
+ IMPORT_C MDesCArray& InfoHWM();
+ IMPORT_C MDesCArray& InfoPeak();
+ inline TBool TrackerExists() const { return iTracker != NULL; }
+
+private: // From MMemSpyEngineProcessMemoryTrackerObserver
+ void HandleMemoryTrackingStartedL();
+ void HandleMemoryTrackingStoppedL();
+ void HandleMemoryChangedL( const TProcessId& aPid, const TMemSpyDriverProcessInspectionInfo& aCurrentInfo, const TMemSpyDriverProcessInspectionInfo& aHWMInfoIncShared, const TMemSpyDriverProcessInspectionInfo& aHWMInfoExcShared );
+
+private: // Internal methods
+ inline CMemSpyEngineProcessMemoryTracker& Tracker() { return *iTracker; }
+ void UpdateCaptionsL();
+ void UpdateCaptionsL( const TMemSpyDriverProcessInspectionInfo& aInfoCurrent, const TMemSpyDriverProcessInspectionInfo& aHWMInfoIncShared, const TMemSpyDriverProcessInspectionInfo& aHWMInfoExcShared );
+
+private: // Member data
+ TBool iTotalIncludesSharedMemory;
+ CMemSpyEngineProcessMemoryTracker* iTracker;
+ CMemSpyThreadInfoMemoryTrackingStatisticsCurrent* iInfoCurrent;
+ CMemSpyThreadInfoMemoryTrackingStatisticsHWM* iInfoHWM;
+ CMemSpyThreadInfoMemoryTrackingStatisticsPeak* iInfoPeak;
+ };
+
+
+
+
+#endif