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 "MemSpyViewMemoryTrackingAutoStartConfig.h" |
|
19 |
|
20 // System includes |
|
21 #include <AknQueryDialog.h> |
|
22 #include <charconv.h> |
|
23 |
|
24 // Engine includes |
|
25 #include <memspy/engine/memspyengine.h> |
|
26 #include <memspy/engine/memspyengineobjectprocess.h> |
|
27 #include <memspy/engine/memspyengineobjectthread.h> |
|
28 #include <memspy/engine/memspyengineobjectcontainer.h> |
|
29 #include <memspy/engine/memspyengineobjectthreadinfoobjects.h> |
|
30 #include <memspy/engine/memspyengineobjectthreadinfocontainer.h> |
|
31 #include <memspy/engine/memspyengineprocessmemorytracker.h> |
|
32 #include <memspy/engine/memspyenginehelperprocess.h> |
|
33 |
|
34 // User includes |
|
35 #include "MemSpyUiUtils.h" |
|
36 #include "MemSpyViewMainMenu.h" |
|
37 #include "MemSpyContainerObserver.h" |
|
38 |
|
39 // Literal constants |
|
40 _LIT8( KMemSpyProcessMemoryTrackerXmlFileMimeType, "text/xml" ); |
|
41 _LIT8( KMemSpyXmlSpec_MasterSection, "memspy_process_memory_tracking" ); |
|
42 _LIT8( KMemSpyXmlSpec_EntryProcess, "process" ); |
|
43 _LIT8( KMemSpyXmlSpec_EntryProcess_SID, "sid" ); |
|
44 _LIT8( KMemSpyXmlSpec_HexPrefix, "0x" ); |
|
45 |
|
46 |
|
47 |
|
48 CMemSpyViewMemoryTrackingAutoStartConfig::CMemSpyViewMemoryTrackingAutoStartConfig( CMemSpyEngine& aEngine, MMemSpyViewObserver& aObserver ) |
|
49 : CMemSpyViewBase( aEngine, aObserver ) |
|
50 { |
|
51 } |
|
52 |
|
53 |
|
54 CMemSpyViewMemoryTrackingAutoStartConfig::~CMemSpyViewMemoryTrackingAutoStartConfig() |
|
55 { |
|
56 iProcessUids.Close(); |
|
57 // |
|
58 delete iParser; |
|
59 delete iConverter; |
|
60 // |
|
61 delete iXMLFileNameInstallTime; |
|
62 delete iXMLFileNameUserSupplied; |
|
63 } |
|
64 |
|
65 |
|
66 void CMemSpyViewMemoryTrackingAutoStartConfig::ConstructL( const TRect& aRect, CCoeControl& aContainer, TAny* aSelectionRune ) |
|
67 { |
|
68 CMemSpyViewBase::ConstructL( aRect, aContainer, aSelectionRune ); |
|
69 |
|
70 // We only convert from UTF-8 to UTF-16 |
|
71 iParser = CParser::NewL( KMemSpyProcessMemoryTrackerXmlFileMimeType, *this ); |
|
72 iConverter = CCnvCharacterSetConverter::NewL(); |
|
73 if ( iConverter->PrepareToConvertToOrFromL( KCharacterSetIdentifierUtf8, iEngine.FsSession() ) == CCnvCharacterSetConverter::ENotAvailable ) |
|
74 { |
|
75 User::Leave(KErrNotFound); |
|
76 } |
|
77 |
|
78 // Search for standard files |
|
79 FindXmlInstallTimeL(); |
|
80 FindXmlUserSuppliedL(); |
|
81 |
|
82 // Copy items to our own temporary list... |
|
83 const RArray<TUid>& list = iEngine.HelperProcess().MemoryTrackingAutoStartProcessList(); |
|
84 for( TInt i=0; i<list.Count(); i++ ) |
|
85 { |
|
86 User::LeaveIfError( iProcessUids.Append( list[ i ] ) ); |
|
87 } |
|
88 |
|
89 // Reset the title |
|
90 _LIT( KCustomTitle, "Process-Specific Memory Tracking" ); |
|
91 SetTitleL( KCustomTitle ); |
|
92 } |
|
93 |
|
94 |
|
95 TMemSpyViewType CMemSpyViewMemoryTrackingAutoStartConfig::ViewType() const |
|
96 { |
|
97 return EMemSpyViewTypeThreadInfoItemMemoryTrackingAutoStartConfig; |
|
98 } |
|
99 |
|
100 |
|
101 CMemSpyViewBase* CMemSpyViewMemoryTrackingAutoStartConfig::PrepareParentViewL() |
|
102 { |
|
103 CMemSpyViewMainMenu* parent = new(ELeave) CMemSpyViewMainMenu( iEngine, iObserver ); |
|
104 CleanupStack::PushL( parent ); |
|
105 parent->ConstructL( Rect(), *Parent(), (TAny*) ViewType() ); |
|
106 CleanupStack::Pop( parent ); |
|
107 |
|
108 return parent; |
|
109 } |
|
110 |
|
111 |
|
112 TBool CMemSpyViewMemoryTrackingAutoStartConfig::HandleCommandL( TInt aCommand ) |
|
113 { |
|
114 TBool handled = ETrue; |
|
115 // |
|
116 switch ( aCommand ) |
|
117 { |
|
118 case EMemSpyCmdMemoryTrackingAutoStartItemAdd: |
|
119 OnCmdItemAddL(); |
|
120 break; |
|
121 case EMemSpyCmdMemoryTrackingAutoStartItemEdit: |
|
122 OnCmdItemEditL(); |
|
123 break; |
|
124 case EMemSpyCmdMemoryTrackingAutoStartItemDelete: |
|
125 OnCmdItemDeleteL(); |
|
126 break; |
|
127 case EMemSpyCmdMemoryTrackingAutoStartItemDeleteAll: |
|
128 OnCmdItemDeleteAllL(); |
|
129 break; |
|
130 case EMemSpyCmdMemoryTrackingAutoStartItemImport: |
|
131 OnCmdItemImportL(); |
|
132 break; |
|
133 default: |
|
134 handled = CMemSpyViewBase::HandleCommandL( aCommand ); |
|
135 break; |
|
136 } |
|
137 // |
|
138 return handled; |
|
139 } |
|
140 |
|
141 |
|
142 void CMemSpyViewMemoryTrackingAutoStartConfig::HandleListBoxItemActionedL( TInt /*aIndex*/ ) |
|
143 { |
|
144 OnCmdItemEditL(); |
|
145 } |
|
146 |
|
147 |
|
148 void CMemSpyViewMemoryTrackingAutoStartConfig::SetListBoxModelL() |
|
149 { |
|
150 CDesCArrayFlat* model = new(ELeave) CDesCArrayFlat(5); |
|
151 CleanupStack::PushL( model ); |
|
152 |
|
153 TBuf<128> buf; |
|
154 _LIT( KProcUidFormatSpec, "\t0x%08x" ); |
|
155 |
|
156 const TInt count = iProcessUids.Count(); |
|
157 for( TInt i=0; i<count; i++ ) |
|
158 { |
|
159 const TUid procUid = iProcessUids[ i ]; |
|
160 // |
|
161 buf.Format( KProcUidFormatSpec, procUid.iUid ); |
|
162 model->AppendL( buf ); |
|
163 } |
|
164 |
|
165 // Set up list box |
|
166 CAknSettingStyleListBox* listbox = static_cast< CAknSettingStyleListBox* >( iListBox ); |
|
167 listbox->Model()->SetItemTextArray( model ); |
|
168 listbox->Model()->SetOwnershipType( ELbmOwnsItemArray ); |
|
169 CleanupStack::Pop( model ); |
|
170 } |
|
171 |
|
172 |
|
173 void CMemSpyViewMemoryTrackingAutoStartConfig::RefreshL() |
|
174 { |
|
175 SetListBoxModelL(); |
|
176 CMemSpyViewBase::RefreshL(); |
|
177 iListBox->HandleItemAdditionL(); |
|
178 iListBox->DrawDeferred(); |
|
179 } |
|
180 |
|
181 |
|
182 void CMemSpyViewMemoryTrackingAutoStartConfig::DynInitMenuPaneL( TInt aResourceId, CEikMenuPane* aMenuPane ) |
|
183 { |
|
184 if ( aResourceId == MenuCascadeResourceId() ) |
|
185 { |
|
186 const TInt count = iProcessUids.Count(); |
|
187 const TInt index = iListBox->CurrentItemIndex(); |
|
188 |
|
189 // We cannot edit an item if none exists |
|
190 aMenuPane->SetItemDimmed( EMemSpyCmdMemoryTrackingAutoStartItemEdit, ( count == 0 || index < 0 || index > count - 1 ) ); |
|
191 aMenuPane->SetItemDimmed( EMemSpyCmdMemoryTrackingAutoStartItemDelete, ( count == 0 || index < 0 || index > count - 1 ) ); |
|
192 aMenuPane->SetItemDimmed( EMemSpyCmdMemoryTrackingAutoStartItemDeleteAll, ( count <= 1 || index > count - 1 ) ); |
|
193 |
|
194 // We can only import items if an XML file is available |
|
195 const TBool xmlAvailable = ( iXMLFileNameInstallTime->Length() || iXMLFileNameUserSupplied->Length() ); |
|
196 aMenuPane->SetItemDimmed( EMemSpyCmdMemoryTrackingAutoStartItemImport, !xmlAvailable ); |
|
197 } |
|
198 } |
|
199 |
|
200 |
|
201 TUint CMemSpyViewMemoryTrackingAutoStartConfig::MenuCascadeResourceId() const |
|
202 { |
|
203 return R_MEMSPY_MENUPANE_MEMORY_TRACKING_AUTOSTART; |
|
204 } |
|
205 |
|
206 |
|
207 TInt CMemSpyViewMemoryTrackingAutoStartConfig::MenuCascadeCommandId() const |
|
208 { |
|
209 return EMemSpyCmdMemoryTrackingAutoStart; |
|
210 } |
|
211 |
|
212 |
|
213 void CMemSpyViewMemoryTrackingAutoStartConfig::OnCmdItemAddL() |
|
214 { |
|
215 const TUid uid = ShowDialogL( KNullUid ); |
|
216 if ( uid != KNullUid ) |
|
217 { |
|
218 User::LeaveIfError( iProcessUids.Append( uid ) ); |
|
219 SaveChangesL(); |
|
220 RefreshL(); |
|
221 iListBox->HandleItemAdditionL(); |
|
222 iListBox->DrawDeferred(); |
|
223 } |
|
224 } |
|
225 |
|
226 |
|
227 void CMemSpyViewMemoryTrackingAutoStartConfig::OnCmdItemEditL() |
|
228 { |
|
229 const TInt index = iListBox->CurrentItemIndex(); |
|
230 if ( index >= 0 && index < iProcessUids.Count() ) |
|
231 { |
|
232 TUid processUid = iProcessUids[ index ]; |
|
233 processUid = ShowDialogL( processUid ); |
|
234 // |
|
235 if ( processUid != KNullUid ) |
|
236 { |
|
237 iProcessUids[ index ] = processUid; |
|
238 SaveChangesL(); |
|
239 RefreshL(); |
|
240 iListBox->HandleItemAdditionL(); |
|
241 iListBox->DrawDeferred(); |
|
242 } |
|
243 } |
|
244 } |
|
245 |
|
246 |
|
247 void CMemSpyViewMemoryTrackingAutoStartConfig::OnCmdItemDeleteL() |
|
248 { |
|
249 const TInt index = iListBox->CurrentItemIndex(); |
|
250 if ( index >= 0 && index < iProcessUids.Count() ) |
|
251 { |
|
252 iProcessUids.Remove( index ); |
|
253 SaveChangesL(); |
|
254 RefreshL(); |
|
255 iListBox->HandleItemRemovalL(); |
|
256 iListBox->DrawDeferred(); |
|
257 |
|
258 const TInt newIndex = index - 1; |
|
259 const TInt count = iProcessUids.Count(); |
|
260 if ( newIndex >=0 && newIndex < count ) |
|
261 { |
|
262 iListBox->SetCurrentItemIndex( index ); |
|
263 } |
|
264 } |
|
265 } |
|
266 |
|
267 |
|
268 void CMemSpyViewMemoryTrackingAutoStartConfig::OnCmdItemDeleteAllL() |
|
269 { |
|
270 iProcessUids.Reset(); |
|
271 SaveChangesL(); |
|
272 RefreshL(); |
|
273 iListBox->HandleItemRemovalL(); |
|
274 iListBox->DrawDeferred(); |
|
275 } |
|
276 |
|
277 |
|
278 void CMemSpyViewMemoryTrackingAutoStartConfig::OnCmdItemImportL() |
|
279 { |
|
280 if ( iXMLFileNameInstallTime->Length() ) |
|
281 { |
|
282 CAknQueryDialog* importDialog = CAknQueryDialog::NewL(); |
|
283 if ( importDialog->ExecuteLD( R_MEMSPY_MEMORY_TRACKING_IMPORT_FROM_INSTALLED_XML_DIALOG ) ) |
|
284 { |
|
285 TRAP_IGNORE( ParseL( *iXMLFileNameInstallTime ) ); |
|
286 } |
|
287 } |
|
288 if ( iXMLFileNameUserSupplied->Length() ) |
|
289 { |
|
290 CAknQueryDialog* importDialog = CAknQueryDialog::NewL(); |
|
291 if ( importDialog->ExecuteLD( R_MEMSPY_MEMORY_TRACKING_IMPORT_FROM_USERDEFINED_XML_DIALOG ) ) |
|
292 { |
|
293 TRAP_IGNORE( ParseL( *iXMLFileNameUserSupplied ) ); |
|
294 } |
|
295 } |
|
296 |
|
297 SaveChangesL(); |
|
298 RefreshL(); |
|
299 iListBox->HandleItemRemovalL(); |
|
300 iListBox->DrawDeferred(); |
|
301 } |
|
302 |
|
303 |
|
304 TUid CMemSpyViewMemoryTrackingAutoStartConfig::ShowDialogL( TUid aUid ) |
|
305 { |
|
306 TUid uid = KNullUid; |
|
307 // |
|
308 _LIT( KProcessUidFormat, "%x" ); |
|
309 TBuf<128> buf; |
|
310 buf.Format( KProcessUidFormat, aUid ); |
|
311 // |
|
312 CAknTextQueryDialog* dialog = new(ELeave) CAknTextQueryDialog( buf ); |
|
313 const TBool dialogActioned = ( dialog->ExecuteLD( R_MEMSPY_MEMORY_TRACKING_PROCESS_UID_DIALOG ) ); |
|
314 // |
|
315 if ( dialogActioned ) |
|
316 { |
|
317 // Validate the text |
|
318 uid = ValidateProcessUid( buf ); |
|
319 } |
|
320 // |
|
321 return uid; |
|
322 } |
|
323 |
|
324 |
|
325 void CMemSpyViewMemoryTrackingAutoStartConfig::SaveChangesL() |
|
326 { |
|
327 iEngine.HelperProcess().SetMemoryTrackingAutoStartProcessListL( iProcessUids ); |
|
328 Settings().StoreSettingsL(); |
|
329 } |
|
330 |
|
331 |
|
332 TUid CMemSpyViewMemoryTrackingAutoStartConfig::ValidateProcessUid( const TDesC& aUid ) |
|
333 { |
|
334 TUid ret = KNullUid; |
|
335 TBool isValid = ETrue; |
|
336 // |
|
337 const TInt length = aUid.Length(); |
|
338 for( TInt i=0; i<length && isValid; i++ ) |
|
339 { |
|
340 const TChar charValue = aUid[ i ]; |
|
341 // |
|
342 switch( charValue ) |
|
343 { |
|
344 case '0': |
|
345 case '1': |
|
346 case '2': |
|
347 case '3': |
|
348 case '4': |
|
349 case '5': |
|
350 case '6': |
|
351 case '7': |
|
352 case '8': |
|
353 case '9': |
|
354 case 'a': |
|
355 case 'A': |
|
356 case 'b': |
|
357 case 'B': |
|
358 case 'c': |
|
359 case 'C': |
|
360 case 'd': |
|
361 case 'D': |
|
362 case 'e': |
|
363 case 'E': |
|
364 case 'f': |
|
365 case 'F': |
|
366 break; |
|
367 default: |
|
368 isValid = EFalse; |
|
369 break; |
|
370 } |
|
371 } |
|
372 // |
|
373 if ( isValid ) |
|
374 { |
|
375 TUint32 val = 0; |
|
376 TLex lexer( aUid ); |
|
377 if ( lexer.Val( val, EHex ) == KErrNone ) |
|
378 { |
|
379 ret.iUid = val; |
|
380 } |
|
381 } |
|
382 // |
|
383 return ret; |
|
384 } |
|
385 |
|
386 |
|
387 void CMemSpyViewMemoryTrackingAutoStartConfig::FindXmlInstallTimeL() |
|
388 { |
|
389 RFs& fsSession = iEngine.FsSession(); |
|
390 // |
|
391 TFileName* fileName = new(ELeave) TFileName(); |
|
392 CleanupStack::PushL( fileName ); |
|
393 // |
|
394 fsSession.PrivatePath( *fileName ); |
|
395 // |
|
396 TFindFile findFile( fsSession ); |
|
397 if ( findFile.FindByPath( KMemSpyProcessMemoryTrackingAutoStartConfigFileName, fileName ) == KErrNone ) |
|
398 { |
|
399 iXMLFileNameInstallTime = findFile.File().AllocL(); |
|
400 } |
|
401 else |
|
402 { |
|
403 iXMLFileNameInstallTime = KNullDesC().AllocL(); |
|
404 RDebug::Print( _L("CMemSpyViewMemoryTrackingAutoStartConfig::FindXmlInstallTimeL() - NO FILE FOUND") ); |
|
405 } |
|
406 // |
|
407 CleanupStack::PopAndDestroy( fileName ); |
|
408 } |
|
409 |
|
410 |
|
411 void CMemSpyViewMemoryTrackingAutoStartConfig::FindXmlUserSuppliedL() |
|
412 { |
|
413 TFindFile findFile( iEngine.FsSession() ); |
|
414 if ( findFile.FindByPath( KMemSpyProcessMemoryTrackingAutoStartConfigFileName, &KMemSpyProcessMemoryTrackingAutoStartConfigSearchPath ) == KErrNone ) |
|
415 { |
|
416 iXMLFileNameUserSupplied = findFile.File().AllocL(); |
|
417 } |
|
418 else |
|
419 { |
|
420 iXMLFileNameUserSupplied = KNullDesC().AllocL(); |
|
421 RDebug::Print( _L("CMemSpyViewMemoryTrackingAutoStartConfig::FindXmlUserSuppliedL() - NO FILE FOUND") ); |
|
422 } |
|
423 } |
|
424 |
|
425 |
|
426 void CMemSpyViewMemoryTrackingAutoStartConfig::ParseL( const TDesC& aFileName ) |
|
427 { |
|
428 Xml::ParseL( *iParser, iEngine.FsSession(), aFileName ); |
|
429 // |
|
430 const TInt error = iParserErrorCode; |
|
431 iParserErrorCode = KErrNone; |
|
432 // |
|
433 User::LeaveIfError( error ); |
|
434 } |
|
435 |
|
436 |
|
437 void CMemSpyViewMemoryTrackingAutoStartConfig::OnSectionProcessL( const RAttributeArray& aAttributes ) |
|
438 { |
|
439 TUid uid = KNullUid; |
|
440 TBool gotSID = EFalse; |
|
441 // |
|
442 const TInt count = aAttributes.Count(); |
|
443 for( TInt i=0; i<count; i++ ) |
|
444 { |
|
445 const TPtrC8 attrib( aAttributes[ i ].Attribute().LocalName().DesC() ); |
|
446 const TPtrC8 value( aAttributes[ i ].Value().DesC() ); |
|
447 // |
|
448 if ( attrib.CompareF( KMemSpyXmlSpec_EntryProcess_SID ) == 0 ) |
|
449 { |
|
450 if ( gotSID ) |
|
451 { |
|
452 User::LeaveIfError( KErrCorrupt ); |
|
453 } |
|
454 else |
|
455 { |
|
456 if ( value.Length() >= 8 ) |
|
457 { |
|
458 TRadix radix = EDecimal; |
|
459 TPtrC8 pValue( value ); |
|
460 // |
|
461 if ( value.Length() == 10 && value.Left( 2 ) == KMemSpyXmlSpec_HexPrefix ) |
|
462 { |
|
463 pValue.Set( value.Mid( 2 ) ); |
|
464 radix = EHex; |
|
465 } |
|
466 // |
|
467 TUint32 uidVal = 0; |
|
468 TLex8 lexer( pValue ); |
|
469 const TInt err = lexer.Val( uidVal, radix ); |
|
470 User::LeaveIfError( err ); |
|
471 uid.iUid = uidVal; |
|
472 gotSID = ETrue; |
|
473 } |
|
474 } |
|
475 } |
|
476 } |
|
477 // |
|
478 if ( gotSID ) |
|
479 { |
|
480 User::LeaveIfError( iProcessUids.Append( uid ) ); |
|
481 } |
|
482 else |
|
483 { |
|
484 User::Leave( KErrCorrupt ); |
|
485 } |
|
486 } |
|
487 |
|
488 |
|
489 void CMemSpyViewMemoryTrackingAutoStartConfig::OnStartDocumentL( const RDocumentParameters& /*aDocParam*/, TInt aErrorCode ) |
|
490 { |
|
491 User::LeaveIfError( aErrorCode ); |
|
492 } |
|
493 |
|
494 |
|
495 void CMemSpyViewMemoryTrackingAutoStartConfig::OnEndDocumentL( TInt aErrorCode ) |
|
496 { |
|
497 User::LeaveIfError( aErrorCode ); |
|
498 } |
|
499 |
|
500 |
|
501 void CMemSpyViewMemoryTrackingAutoStartConfig::OnStartElementL( const RTagInfo& aElement, const RAttributeArray& aAttributes, TInt aErrorCode ) |
|
502 { |
|
503 User::LeaveIfError( aErrorCode ); |
|
504 // |
|
505 const TPtrC8 name( aElement.LocalName().DesC() ); |
|
506 // |
|
507 if ( name.CompareF( KMemSpyXmlSpec_MasterSection ) == 0 ) |
|
508 { |
|
509 iSeenMasterSection = ETrue; |
|
510 } |
|
511 else if ( iSeenMasterSection && name.CompareF( KMemSpyXmlSpec_EntryProcess ) == 0 ) |
|
512 { |
|
513 OnSectionProcessL( aAttributes ); |
|
514 } |
|
515 } |
|
516 |
|
517 |
|
518 void CMemSpyViewMemoryTrackingAutoStartConfig::OnEndElementL( const RTagInfo& /*aElement*/, TInt aErrorCode ) |
|
519 { |
|
520 User::LeaveIfError( aErrorCode ); |
|
521 } |
|
522 |
|
523 |
|
524 void CMemSpyViewMemoryTrackingAutoStartConfig::OnContentL( const TDesC8& /*aBytes*/, TInt aErrorCode ) |
|
525 { |
|
526 User::LeaveIfError( aErrorCode ); |
|
527 } |
|
528 |
|
529 |
|
530 void CMemSpyViewMemoryTrackingAutoStartConfig::OnStartPrefixMappingL( const RString& /*aPrefix*/, const RString& /*aUri*/, TInt aErrorCode ) |
|
531 { |
|
532 User::LeaveIfError( aErrorCode ); |
|
533 } |
|
534 |
|
535 |
|
536 void CMemSpyViewMemoryTrackingAutoStartConfig::OnEndPrefixMappingL( const RString& /*aPrefix*/, TInt aErrorCode ) |
|
537 { |
|
538 User::LeaveIfError( aErrorCode ); |
|
539 } |
|
540 |
|
541 |
|
542 void CMemSpyViewMemoryTrackingAutoStartConfig::OnIgnorableWhiteSpaceL( const TDesC8& /*aBytes*/, TInt aErrorCode ) |
|
543 { |
|
544 User::LeaveIfError( aErrorCode ); |
|
545 } |
|
546 |
|
547 |
|
548 void CMemSpyViewMemoryTrackingAutoStartConfig::OnSkippedEntityL( const RString& /*aName*/, TInt aErrorCode ) |
|
549 { |
|
550 User::LeaveIfError( aErrorCode ); |
|
551 } |
|
552 |
|
553 |
|
554 void CMemSpyViewMemoryTrackingAutoStartConfig::OnProcessingInstructionL( const TDesC8& /*aTarget*/, const TDesC8& /*aData*/, TInt aErrorCode ) |
|
555 { |
|
556 User::LeaveIfError( aErrorCode ); |
|
557 } |
|
558 |
|
559 |
|
560 void CMemSpyViewMemoryTrackingAutoStartConfig::OnError( TInt aErrorCode ) |
|
561 { |
|
562 iParserErrorCode = aErrorCode; |
|
563 } |
|
564 |
|
565 |
|
566 TAny* CMemSpyViewMemoryTrackingAutoStartConfig::GetExtendedInterface( const TInt32 /*aUid*/ ) |
|
567 { |
|
568 return NULL; |
|
569 } |
|
570 |
|