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 "MemSpyEngineHelperSysMemTrackerEntryFileServerCache.h"

    19 

    20 // System includes

    21 #include <e32base.h>

    22 #include <badesca.h>

    23 

    24 // Driver includes

    25 #include <memspy/driver/memspydriverclient.h>

    26 

    27 // User includes

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

    29 #include <memspy/engine/memspyengineutils.h>

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

    31 #include <memspy/engine/memspyengineoutputlist.h>

    32 #include <memspy/engine/memspyenginehelperheap.h>

    33 #include <memspy/engine/memspyenginehelperchunk.h>

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

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

    36 #include <memspy/engine/memspyengineobjectcontainer.h>

    37 #include <memspy/engine/memspyenginehelpercodesegment.h>

    38 #include "MemSpyEngineHelperSysMemTrackerImp.h"

    39 #include <memspy/engine/memspyenginehelpersysmemtrackercycle.h>

    40 #include <memspy/engine/memspyenginehelpersysmemtrackerconfig.h>

    41 

    42 

    43 

    44 

    45 CMemSpyEngineHelperSysMemTrackerEntryFileServerCache::CMemSpyEngineHelperSysMemTrackerEntryFileServerCache( CMemSpyEngineHelperSysMemTrackerImp& aTracker, const TMemSpyDriverChunkInfo& aInfo )

    46 :   CMemSpyEngineHelperSysMemTrackerEntry( aTracker, EMemSpyEngineSysMemTrackerTypeFileServerCache ), iLast( aInfo ), iCurrent( aInfo )

    47     {

    48     }

    49 

    50 

    51 CMemSpyEngineHelperSysMemTrackerEntryFileServerCache::~CMemSpyEngineHelperSysMemTrackerEntryFileServerCache()

    52     {

    53     }

    54 

    55 

    56 void CMemSpyEngineHelperSysMemTrackerEntryFileServerCache::ConstructL()

    57     {

    58     SetHandle( iCurrent.iHandle );

    59     }

    60 

    61 

    62 CMemSpyEngineHelperSysMemTrackerEntryFileServerCache* CMemSpyEngineHelperSysMemTrackerEntryFileServerCache::NewLC( CMemSpyEngineHelperSysMemTrackerImp& aTracker, const TMemSpyDriverChunkInfo& aInfo )

    63     {

    64     CMemSpyEngineHelperSysMemTrackerEntryFileServerCache* self = new(ELeave) CMemSpyEngineHelperSysMemTrackerEntryFileServerCache( aTracker, aInfo );

    65     CleanupStack::PushL( self );

    66     self->ConstructL();

    67     return self;

    68     }

    69 

    70 

    71 void CMemSpyEngineHelperSysMemTrackerEntryFileServerCache::UpdateFromL( const CMemSpyEngineHelperSysMemTrackerEntry& aEntry )

    72     {

    73     const CMemSpyEngineHelperSysMemTrackerEntryFileServerCache& entry = static_cast< const CMemSpyEngineHelperSysMemTrackerEntryFileServerCache& >( aEntry );

    74     

    75     // Update state

    76     iLast = iCurrent;

    77     iCurrent = entry.iCurrent;

    78     }

    79 

    80 

    81 TBool CMemSpyEngineHelperSysMemTrackerEntryFileServerCache::HasChangedL( const TMemSpyEngineHelperSysMemTrackerConfig& /*aConfig*/ ) const

    82     {

    83     const TBool hasChanged = ( iCurrent.iSize != iLast.iSize );

    84     return hasChanged;

    85     }

    86 

    87 

    88 void CMemSpyEngineHelperSysMemTrackerEntryFileServerCache::CreateChangeDescriptorL( CMemSpyEngineHelperSysMemTrackerCycle& aCycle )

    89     {

    90     CMemSpyEngineHelperSysMemTrackerCycleChangeFileServerCache* changeDescriptor = CMemSpyEngineHelperSysMemTrackerCycleChangeFileServerCache::NewLC( Attributes(), iCurrent );

    91     aCycle.AddAndPopL( changeDescriptor );

    92     }

    93 

    94 

    95 void CMemSpyEngineHelperSysMemTrackerEntryFileServerCache::UpdateCycleStatistics( CMemSpyEngineHelperSysMemTrackerCycle& aCycle )

    96     {

    97     aCycle.AddToMemoryUsed( iCurrent.iSize );

    98     }

    99 

   100 

   101 

   102 

   103 

   104 

   105 

   106 

   107 

   108 

   109 

   110 

   111 

   112 

   113 

   114 

   115 

   116 

   117 

   118 

   119 

   120 

   121 

   122 

   123 

   124 

   125 

   126 

   127 

   128 

   129 

   130 

   131 

   132 

   133 

   134 

   135 

   136 

   137 

   138 

   139 

   140 

   141 

   142 

   143 CMemSpyEngineHelperSysMemTrackerCycleChangeFileServerCache::CMemSpyEngineHelperSysMemTrackerCycleChangeFileServerCache( TUint8 aAttribs, const TMemSpyDriverChunkInfo& aCurrent )

   144 :   CMemSpyEngineHelperSysMemTrackerCycleChange( aAttribs ), iCurrent( aCurrent )

   145     {

   146     }

   147 

   148 

   149 CMemSpyEngineHelperSysMemTrackerCycleChangeFileServerCache::~CMemSpyEngineHelperSysMemTrackerCycleChangeFileServerCache()

   150     {

   151     }

   152 

   153 

   154 void CMemSpyEngineHelperSysMemTrackerCycleChangeFileServerCache::ConstructL()

   155     {

   156     BaseConstructL();

   157     }

   158 

   159 

   160 CMemSpyEngineHelperSysMemTrackerCycleChangeFileServerCache* CMemSpyEngineHelperSysMemTrackerCycleChangeFileServerCache::NewLC( TUint8 aAttribs, const TMemSpyDriverChunkInfo& aCurrent )

   161     {

   162     CMemSpyEngineHelperSysMemTrackerCycleChangeFileServerCache* self = new(ELeave) CMemSpyEngineHelperSysMemTrackerCycleChangeFileServerCache( aAttribs, aCurrent );

   163     CleanupStack::PushL( self );

   164     self->ConstructL();

   165     return self;

   166     }

   167 

   168 

   169 TMemSpyEngineSysMemTrackerType CMemSpyEngineHelperSysMemTrackerCycleChangeFileServerCache::Type() const

   170     {

   171     return EMemSpyEngineSysMemTrackerTypeFileServerCache;

   172     }

   173    

   174 

   175 void CMemSpyEngineHelperSysMemTrackerCycleChangeFileServerCache::OutputHeaderL( CMemSpyEngineOutputSink& aSink, CMemSpyEngineHelperSysMemTrackerCycle& /*aCycle*/ )

   176     {

   177     _LIT( KHeaderChunk, "Type, Name, Handle, Base Addr, Size, Max Size, Attribs");

   178     aSink.OutputLineL( KHeaderChunk );

   179     }

   180  

   181 

   182 void CMemSpyEngineHelperSysMemTrackerCycleChangeFileServerCache::OutputContentL( CMemSpyEngineOutputSink& aSink, CMemSpyEngineHelperSysMemTrackerCycle& /*aCycle*/ )

   183     {

   184     _LIT( KFormat, "%S,%S,0x%08x,0x%08x,%d,%d,%S" );

   185     //

   186     TMemSpySWMTTypeName type;;

   187     FormatType( type );

   188     //

   189     TBuf<20> attribs;

   190     FormatAttributes( attribs );

   191     //

   192     HBufC* buf = HBufC::NewLC( 1024 );

   193     TPtr pBuf(buf->Des());

   194 

   195     // Now output line

   196     pBuf.Format( KFormat, 

   197                  &type,

   198                  &iCurrent.iName, 

   199                  iCurrent.iHandle,

   200                  iCurrent.iBaseAddress,

   201                  iCurrent.iSize,

   202                  iCurrent.iMaxSize,

   203                  &attribs

   204                  );

   205 

   206     aSink.OutputLineL( pBuf );

   207     CleanupStack::PopAndDestroy( buf );

   208     }

   209 

   210 

   211 void CMemSpyEngineHelperSysMemTrackerCycleChangeFileServerCache::OutputDataL( CMemSpyEngineOutputSink& aSink, CMemSpyEngineHelperSysMemTrackerCycle& /*aCycle*/ )

   212     {

   213     CMemSpyEngine& engine = aSink.Engine();

   214     }

   215