1 /*

     2 * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies). 

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:

    15 *

    16 */

    17 

    18 #include <memspy/engine/memspyengineobjectthreadinfocontainer.h>

    19 

    20 // System includes

    21 #include <e32svr.h>

    22 

    23 // User includes

    24 #include <memspy/engine/memspyengine.h>

    25 #include <memspy/engine/memspyengineoutputsink.h>

    26 #include <memspy/engine/memspyengineobjectprocess.h>

    27 #include <memspy/engine/memspyengineobjectthread.h>

    28 #include <memspy/engine/memspyengineobjectthreadinfoobjects.h>

    29 

    30 

    31 

    32 CMemSpyThreadInfoContainer::CMemSpyThreadInfoContainer( CMemSpyThread& aThread )

    33 :   CMemSpyEngineObject( aThread ), iThread( &aThread )

    34     {

    35     }

    36 

    37 

    38 CMemSpyThreadInfoContainer::~CMemSpyThreadInfoContainer()

    39     {

    40     CloseAllInfoItems();

    41     //

    42     iItems.Close();

    43     iObservers.Close();

    44     }

    45 

    46 

    47 void CMemSpyThreadInfoContainer::ConstructItemByTypeL( TBool aAsync, TMemSpyThreadInfoItemType aType )

    48     {

    49     CMemSpyThreadInfoItemBase* item = NULL;

    50     //

    51     switch( aType )

    52         {

    53     case EMemSpyThreadInfoItemTypeGeneralInfo:

    54         item = CMemSpyThreadInfoGeneral::NewLC( *this, aAsync );

    55         break;

    56     case EMemSpyThreadInfoItemTypeHeap:

    57         item = CMemSpyThreadInfoHeap::NewLC( *this, aAsync );

    58         break;

    59     case EMemSpyThreadInfoItemTypeStack:

    60         item = CMemSpyThreadInfoStack::NewLC( *this, aAsync );

    61         break;

    62     case EMemSpyThreadInfoItemTypeChunk:

    63         item = CMemSpyThreadInfoChunk::NewLC( *this, aAsync );

    64         break;

    65     case EMemSpyThreadInfoItemTypeCodeSeg:

    66         item = CMemSpyThreadInfoCodeSeg::NewLC( *this, aAsync );

    67         break;

    68     case EMemSpyThreadInfoItemTypeOpenFiles:

    69         item = CMemSpyThreadInfoOpenFiles::NewLC( *this, aAsync );

    70         break;

    71     case EMemSpyThreadInfoItemTypeActiveObject:

    72         item = CMemSpyThreadInfoActiveObjects::NewLC( *this, aAsync );

    73         break;

    74     case EMemSpyThreadInfoItemTypeServer:

    75         item = CMemSpyThreadInfoServer::NewLC( *this, aAsync );

    76         break;

    77     case EMemSpyThreadInfoItemTypeSession:

    78         item = CMemSpyThreadInfoSession::NewLC( *this, aAsync );

    79         break;

    80     case EMemSpyThreadInfoItemTypeSemaphore:

    81         item = CMemSpyThreadInfoSemaphore::NewLC( *this, aAsync );

    82         break;

    83     case EMemSpyThreadInfoItemTypeMutex:

    84         item = CMemSpyThreadInfoMutex::NewLC( *this, aAsync );

    85         break;

    86     case EMemSpyThreadInfoItemTypeTimer:

    87         item = CMemSpyThreadInfoTimer::NewLC( *this, aAsync );

    88         break;

    89     case EMemSpyThreadInfoItemTypeLDD:

    90         item = CMemSpyThreadInfoLDD::NewLC( *this, aAsync );

    91         break;

    92     case EMemSpyThreadInfoItemTypePDD:

    93         item = CMemSpyThreadInfoPDD::NewLC( *this, aAsync );

    94         break;

    95     case EMemSpyThreadInfoItemTypeLogicalChannel:

    96         item = CMemSpyThreadInfoLogicalChannel::NewLC( *this, aAsync );

    97         break;

    98     case EMemSpyThreadInfoItemTypeChangeNotifier:

    99         item = CMemSpyThreadInfoChangeNotifier::NewLC( *this, aAsync );

   100         break;

   101     case EMemSpyThreadInfoItemTypeUndertaker:

   102         item = CMemSpyThreadInfoUndertaker::NewLC( *this, aAsync );

   103         break;

   104     case EMemSpyThreadInfoItemTypeOwnedThreadHandles:

   105         item = CMemSpyThreadInfoOwnedThreadHandles::NewLC( *this, aAsync );

   106         break;

   107     case EMemSpyThreadInfoItemTypeOwnedProcessHandles:

   108         item = CMemSpyThreadInfoOwnedProcessHandles::NewLC( *this, aAsync );

   109         break;

   110     case EMemSpyThreadInfoItemTypeOtherThreads:

   111         item = CMemSpyThreadInfoOtherThreads::NewLC( *this, aAsync );

   112         break;

   113     case EMemSpyThreadInfoItemTypeOtherProcesses:

   114         item = CMemSpyThreadInfoOtherProcesses::NewLC( *this, aAsync );

   115         break;

   116     case EMemSpyThreadInfoItemTypeMemoryTracking:

   117         item = CMemSpyThreadInfoMemoryTracking::NewLC( *this, aAsync );

   118         break;

   119     default:

   120     case EMemSpyThreadInfoItemTypeMessageQueue:

   121     case EMemSpyThreadInfoItemTypeConditionalVariable:

   122         break;

   123         }

   124     //

   125     if  ( item )

   126         {

   127         iItems.AppendL( item );

   128         CleanupStack::Pop( item );

   129         }

   130     }

   131 

   132 

   133 void CMemSpyThreadInfoContainer::ConstructL( TBool aAsync )

   134     {

   135     for( TInt type = EMemSpyThreadInfoItemTypeFirst; type<EMemSpyThreadInfoItemTypeLast; type++ )

   136         {

   137         const TMemSpyThreadInfoItemType realType = static_cast< TMemSpyThreadInfoItemType >( type );

   138         ConstructItemByTypeL( aAsync, realType );

   139         }

   140     }

   141 

   142 

   143 CMemSpyThreadInfoContainer* CMemSpyThreadInfoContainer::NewL( CMemSpyThread& aThread, TBool aAsync )

   144     {

   145     CMemSpyThreadInfoContainer* self = CMemSpyThreadInfoContainer::NewLC( aThread, aAsync );

   146     CleanupStack::Pop( self );

   147     return self;

   148     }

   149 

   150 

   151 CMemSpyThreadInfoContainer* CMemSpyThreadInfoContainer::NewLC( CMemSpyThread& aThread, TBool aAsync )

   152     {

   153     CMemSpyThreadInfoContainer* self = new(ELeave) CMemSpyThreadInfoContainer( aThread );

   154     CleanupStack::PushL( self );

   155     self->ConstructL( aAsync );

   156     return self;

   157     }

   158 

   159 

   160 CMemSpyThreadInfoContainer* CMemSpyThreadInfoContainer::NewLC( CMemSpyThread& aThread, TMemSpyThreadInfoItemType aSpecificType )

   161     {

   162     CMemSpyThreadInfoContainer* self = new(ELeave) CMemSpyThreadInfoContainer( aThread );

   163     CleanupStack::PushL( self );

   164     self->ConstructItemByTypeL( EFalse, aSpecificType );

   165     return self;

   166     }

   167 

   168 

   169 void CMemSpyThreadInfoContainer::AddItemL( TMemSpyThreadInfoItemType aType )

   170     {

   171     const TInt index = InfoItemIndexByType( aType );

   172     if  ( index == KErrNotFound )

   173         {

   174         ConstructItemByTypeL( EFalse, aType );

   175         }

   176     }

   177 

   178 

   179 EXPORT_C void CMemSpyThreadInfoContainer::Open()

   180     {

   181     if  ( !OpenOrCloseInProgress() )

   182         {

   183         SetOpenOrCloseInProgress( ETrue );

   184         CMemSpyEngineObject::Open();

   185         SetOpenOrCloseInProgress( EFalse );

   186         }

   187     }

   188 

   189 

   190 EXPORT_C void CMemSpyThreadInfoContainer::Close()

   191     {

   192     if  ( !OpenOrCloseInProgress() )

   193         {

   194         SetOpenOrCloseInProgress( ETrue );

   195         CMemSpyEngineObject::Close();

   196         SetOpenOrCloseInProgress( EFalse );

   197         }

   198     }

   199 

   200 

   201 EXPORT_C void CMemSpyThreadInfoContainer::PrintL()

   202     {

   203     _LIT( KMemSpyFolder, "ThreadInfo" );

   204     _LIT( KMemSpyContext, "ThreadInfo - %S" );

   205     //

   206     CMemSpyEngine& engine = Engine();

   207     CMemSpyEngineOutputSink& sink = engine.Sink();

   208     //

   209     TFullName fullName( iThread->FullName() );

   210     HBufC* context = HBufC::NewLC( KMaxFileName * 2 );

   211     TPtr pContext( context->Des() );

   212     pContext.Format( KMemSpyContext, &fullName );

   213     sink.DataStreamBeginL( pContext, KMemSpyFolder );

   214     CleanupStack::PopAndDestroy( context );

   215     //

   216     sink.OutputSectionHeadingL( fullName, TChar('=') );

   217     sink.OutputBlankLineL();

   218     //

   219     const TInt count = iItems.Count();

   220     for( TInt i=0; i<count; i++ )

   221         {

   222         CMemSpyThreadInfoItemBase* item = iItems[ i ];

   223         item->PrintL();

   224         }

   225     //

   226     sink.OutputBlankLineL();

   227     sink.DataStreamEndL();

   228     }

   229 

   230 

   231 EXPORT_C TInt CMemSpyThreadInfoContainer::MdcaCount() const

   232     {

   233     return iItems.Count();

   234     }

   235 

   236 

   237 EXPORT_C TPtrC CMemSpyThreadInfoContainer::MdcaPoint( TInt aIndex ) const

   238     {

   239     return iItems[ aIndex ]->Name();

   240     }

   241 

   242 

   243 EXPORT_C CMemSpyEngine& CMemSpyThreadInfoContainer::Engine() const

   244     {

   245     return iThread->Engine();

   246     }

   247 

   248 

   249 EXPORT_C CMemSpyThreadInfoItemBase& CMemSpyThreadInfoContainer::Item( TInt aIndex )

   250     {

   251     return *iItems[ aIndex ];

   252     }

   253 

   254 

   255 EXPORT_C CMemSpyThreadInfoItemBase& CMemSpyThreadInfoContainer::Item( TMemSpyThreadInfoItemType aType )

   256     {

   257     const TInt index = InfoItemIndexByType( aType );

   258     CMemSpyThreadInfoItemBase* ret = iItems[ index ];

   259     __ASSERT_ALWAYS( ret != NULL, User::Invariant() );

   260     return *ret;

   261     }

   262 

   263 

   264 EXPORT_C TInt CMemSpyThreadInfoContainer::InfoItemIndexByType( TMemSpyThreadInfoItemType aType )

   265     {

   266     TInt index = KErrNotFound;

   267     //

   268     const TInt count = iItems.Count();

   269     for(TInt i=0; i<count; i++)

   270         {

   271         CMemSpyThreadInfoItemBase* item = iItems[ i ];

   272         if  ( item->Type() == aType )

   273             {

   274             index = i;

   275             break;

   276             }

   277         }

   278     //

   279     return index;

   280     }

   281 

   282 

   283 EXPORT_C void CMemSpyThreadInfoContainer::ObserverAddL( MMemSpyThreadInfoContainerObserver& aObserver )

   284     {

   285     const TInt count = iObservers.Count();

   286     for(TInt i=count-1; i>=0; i--)

   287         {

   288         MMemSpyThreadInfoContainerObserver* observer = iObservers[ i ];

   289         if  ( observer == &aObserver )

   290             {

   291             return;

   292             }

   293         }

   294 

   295     iObservers.AppendL( &aObserver );

   296     }

   297 

   298 

   299 EXPORT_C void CMemSpyThreadInfoContainer::ObserverRemove( MMemSpyThreadInfoContainerObserver& aObserver )

   300     {

   301     const TInt count = iObservers.Count();

   302     for(TInt i=count-1; i>=0; i--)

   303         {

   304         MMemSpyThreadInfoContainerObserver* observer = iObservers[ i ];

   305         if  ( observer == &aObserver )

   306             {

   307             iObservers.Remove( i );

   308             break;

   309             }

   310         }

   311     }

   312 

   313 

   314 void CMemSpyThreadInfoContainer::NotifyObserverL( MMemSpyThreadInfoContainerObserver::TEvent aEvent, TMemSpyThreadInfoItemType aType )

   315     {

   316     if  ( aEvent == MMemSpyThreadInfoContainerObserver::EInfoItemDestroyed )

   317         {

   318         // Make sure we remove dead item

   319         const TInt index = InfoItemIndexByType( aType );

   320         if  ( index >= 0 )

   321             {

   322             iItems.Remove( index );

   323             }

   324         }

   325         

   326     const TInt count = iObservers.Count();

   327     for(TInt i=count-1; i>=0; i--)

   328         {

   329         MMemSpyThreadInfoContainerObserver* observer = iObservers[ i ];

   330         observer->HandleMemSpyEngineInfoContainerEventL( aEvent, aType );

   331         }

   332     }

   333 

   334 

   335 void CMemSpyThreadInfoContainer::OpenAllInfoItems()

   336     {

   337     const TInt count = iItems.Count();

   338     for(TInt i=count-1; i>=0; i--)

   339         {

   340         CMemSpyThreadInfoItemBase* item = iItems[ i ];

   341         item->Open();

   342         }

   343     }

   344 

   345 

   346 void CMemSpyThreadInfoContainer::CloseAllInfoItems()

   347     {

   348     const TInt count = iItems.Count();

   349     for(TInt i=count-1; i>=0; i--)

   350         {

   351         CMemSpyThreadInfoItemBase* item = iItems[ i ];

   352         item->Close();

   353         }

   354     }

   355