MCL/sf/mw/imghandling: comparison imagehandlingutilities/thumbnailmanager/thumbnailserver/src/thumbnailserversession.cpp

equal deleted inserted replaced

-:2b4b06654caa
+:6257223ede8a
 #endif // RD_MDS_2_5
 #include "thumbnaillog.h"
 #include "thumbnailpanic.h"
 #include "thumbnailcenrep.h"
+#include "OstTraceDefinitions.h"
+#ifdef OST_TRACE_COMPILER_IN_USE
+#include "thumbnailserversessionTraces.h"
+#endif
 // ======== MEMBER FUNCTIONS ========
 // ---------------------------------------------------------------------------
 // CThumbnailServerSession::CThumbnailServerSession()
 // ---------------------------------------------------------------------------
 //
 void CThumbnailServerSession::CreateL()
 {
 TN_DEBUG2( "CThumbnailServerSession::AddSession() = 0x%08x", this );
+OstTrace1( TRACE_NORMAL, CTHUMBNAILSERVERSESSION_CREATEL, "CThumbnailServerSession::CreateL;this=%o", this );
 Server()->AddSession();
 }
 // -----------------------------------------------------------------------------
 //
 void CThumbnailServerSession::ServiceL( const RMessage2& aMessage )
 {
 TN_DEBUG1( "CThumbnailServerSession::ServiceL() - begin" );
+OstTrace0( TRACE_NORMAL, CTHUMBNAILSERVERSESSION_SERVICEL, "CThumbnailServerSession::ServiceL - begin" );
 __ASSERT_DEBUG( !iMessage.Handle(), ThumbnailPanic(EThumbnailMessageNotCompleted));
 if ( iMessage.Handle())
 {
 iMessage.Complete( KErrUnknown );
 // get client thread
 TInt err = iMessage.Client( iClientThread );
 if (err != KErrNone)
 {
 TN_DEBUG1( "CThumbnailServerSession::ServiceL() - client thread not found");
+OstTrace0( TRACE_NORMAL, DUP1_CTHUMBNAILSERVERSESSION_SERVICEL, "CThumbnailServerSession::ServiceL - client thread not found" );
 iMessage = RMessage2();
 }
 }
 else
 {
 TN_DEBUG1( "CThumbnailServerSession::ServiceL() - message null");
+OstTrace0( TRACE_NORMAL, DUP2_CTHUMBNAILSERVERSESSION_SERVICEL, "CThumbnailServerSession::ServiceL - message null" );
 }
 // clean up possible trash
 if (iBitmapHandle)
 {
 // close thread handle
 iClientThread.Close();
 TN_DEBUG1( "CThumbnailServerSession::ServiceL() - end" );
+OstTrace0( TRACE_NORMAL, DUP3_CTHUMBNAILSERVERSESSION_SERVICEL, "CThumbnailServerSession::ServiceL - end" );
 }
 // -----------------------------------------------------------------------------
 // CThumbnailServerSession::Server()
 // -----------------------------------------------------------------------------
 //
 void CThumbnailServerSession::UpdateThumbnailsL( const RMessage2& aMessage )
 {
 TN_DEBUG1( "CThumbnailServerSession::UpdateThumbnailsL()" );
+OstTrace0( TRACE_NORMAL, CTHUMBNAILSERVERSESSION_UPDATETHUMBNAILSL, "CThumbnailServerSession::UpdateThumbnailsL" );
 if(aMessage.Int1() != KCheckValue)
 {
 TN_DEBUG1( "CThumbnailServerSession::UpdateThumbnailsL() - error in aMessage - leaving" );
 User::Leave(KErrArgument);
 // source type
 TDataType mimeType;
 TInt sourceType = 0;
 TInt err = Server()->MimeTypeFromFileExt( params.iFileName, mimeType );
+// need to use recognizer
+if (err == KErrNotFound)
+{
+Server()->Fs().ShareProtected();
+RFile64 file;
+CleanupClosePushL( file );
+User::LeaveIfError( file.Open( Server()->Fs(), params.iFileName, EFileShareReadersOrWriters ));
+TN_DEBUG2( "CThumbnailServerSession::UpdateThumbnailsL - file handle opened for %S", &params.iFileName );
+mimeType = Server()->ResolveMimeTypeL(file);
+file.Close();
+TN_DEBUG1("CThumbnailServerSession::UpdateThumbnailsL - file handle closed");
+CleanupStack::Pop( &file );
+}
 // get missing sizes
-if ( err == KErrNone && ( params.iControlFlags & EThumbnailGeneratePersistentSizesOnly ) != 0 )
+if ( ( params.iControlFlags & EThumbnailGeneratePersistentSizesOnly ) != 0 )
 {
 sourceType = Server()->SourceTypeFromMimeType( mimeType );
 missingSizes = new (ELeave) RArray < TThumbnailPersistentSize >;
 CleanupClosePushL( *missingSizes );
 }
 if(!missingSizes)
 {
 TN_DEBUG1( "CThumbnailServerSession::UpdateThumbnailsL() - finished part 1" );
+OstTrace0( TRACE_NORMAL, DUP1_CTHUMBNAILSERVERSESSION_UPDATETHUMBNAILSL, "CThumbnailServerSession::UpdateThumbnailsL - finished part 1" );
 aMessage.Complete( KErrNone );
 }
 else
 {
+OstTrace0( TRACE_NORMAL, DUP2_CTHUMBNAILSERVERSESSION_UPDATETHUMBNAILSL, "CThumbnailServerSession::UpdateThumbnailsL  - some sizes missing..." );
 TN_DEBUG1( "CThumbnailServerSession::UpdateThumbnailsL() - some sizes missing..." );
 }
 }
 if (missingSizes || !finished)
 {
 TN_DEBUG1( "CThumbnailServerSession::UpdateThumbnailsL() - need to create (some) thumbs" );
+OstTrace0( TRACE_NORMAL, DUP3_CTHUMBNAILSERVERSESSION_UPDATETHUMBNAILSL, "CThumbnailServerSession::UpdateThumbnailsL - need to create (some) thumbs" );
 if(missingSizes)
 {
 CleanupStack::PopAndDestroy( missingSizes );
 delete missingSizes;
 aMessage.Complete( KThumbnailErrThumbnailNotFound );
 }
 else
 {
 TN_DEBUG1( "CThumbnailServerSession::UpdateThumbnailsL() - finished part 2" );
+OstTrace0( TRACE_NORMAL, DUP4_CTHUMBNAILSERVERSESSION_UPDATETHUMBNAILSL, "CThumbnailServerSession::UpdateThumbnailsL - finished part 2" );
 }
 iMessage = RMessage2();
 }
 void CThumbnailServerSession::RenameThumbnailsL( const RMessage2& aMessage )
 {
 if(aMessage.Int1() != KCheckValue)
 {
 TN_DEBUG1( "CThumbnailServerSession::RenameThumbnailsL() - error in aMessage - leaving" );
+OstTrace0( TRACE_NORMAL, CTHUMBNAILSERVERSESSION_RENAMETHUMBNAILSL, "CThumbnailServerSession::RenameThumbnailsL - error in aMessage - leaving" );
 User::Leave(KErrArgument);
 }
 // read message params
 aMessage.ReadL( 0, iRequestParams );
 TN_DEBUG1( "CThumbnailServerSession::RequestThumbByIdAsyncL() - begin" );
 if(aMessage.Int1() != KCheckValue)
 {
 TN_DEBUG1( "CThumbnailServerSession::RequestThumbByIdAsync() - error in aMessage - leaving" );
+OstTrace0( TRACE_NORMAL, CTHUMBNAILSERVERSESSION_REQUESTTHUMBBYIDASYNCL, "CThumbnailServerSession::RequestThumbByIdAsyncL - leaving" );
 User::Leave(KErrArgument);
 }
 aMessage.ReadL( 0, iRequestParams );
 const TThumbnailRequestParams& params = iRequestParams();
 #endif // RD_MDS_2_5
 #ifdef _DEBUG
 aStop.UniversalTime();
+TInt tookTime = (TInt)aStop.MicroSecondsFrom(aStart).Int64()/1000;
 TN_DEBUG2( "CThumbnailServerSession::RequestThumbByIdAsyncL() request took %d ms", (TInt)aStop.MicroSecondsFrom(aStart).Int64()/1000 );
+OstTrace1( TRACE_NORMAL, DUP1_CTHUMBNAILSERVERSESSION_REQUESTTHUMBBYIDASYNCL, "CThumbnailServerSession::RequestThumbByIdAsyncL;tookTime=%d", tookTime );
 #endif
 TN_DEBUG1("CThumbnailServerSession::RequestThumbByIdAsyncL() - end" );
+OstTrace0( TRACE_NORMAL, DUP2_CTHUMBNAILSERVERSESSION_REQUESTTHUMBBYIDASYNCL, "CThumbnailServerSession::RequestThumbByIdAsyncL - end" );
 }
 // -----------------------------------------------------------------------------
 // CThumbnailServerSession::RequestThumbByFileHandleAsync()
 // -----------------------------------------------------------------------------
 //
 void CThumbnailServerSession::RequestThumbByFileHandleAsyncL( const RMessage2&
 aMessage )
 {
 TN_DEBUG1( "CThumbnailServerSession::RequestThumbByFileHandleAsyncL()" );
+OstTrace0( TRACE_NORMAL, CTHUMBNAILSERVERSESSION_REQUESTTHUMBBYFILEHANDLEASYNCL, "CThumbnailServerSession::RequestThumbByFileHandleAsyncL" );
 if(aMessage.Int1() != KCheckValue)
 {
 TN_DEBUG1( "CThumbnailServerSession::RequestThumbByFileHandleAsync() - error in aMessage - leaving" );
+OstTrace0( TRACE_NORMAL, DUP1_CTHUMBNAILSERVERSESSION_REQUESTTHUMBBYFILEHANDLEASYNCL, "CThumbnailServerSession::RequestThumbByFileHandleAsyncL - error in aMessage - leaving" );
 User::Leave(KErrArgument);
 }
 aMessage.ReadL( 0, iRequestParams );
 const TThumbnailRequestParams& params = iRequestParams();
 // CreateThumbnails
 if (params.iControlFlags == EThumbnailGeneratePersistentSizesOnly)
 {
 TN_DEBUG1( "CThumbnailServerSession::RequestThumbByFileHandleAsyncL() - EThumbnailGeneratePersistentSizesOnly" );
+OstTrace0( TRACE_NORMAL, DUP2_CTHUMBNAILSERVERSESSION_REQUESTTHUMBBYFILEHANDLEASYNCL, "CThumbnailServerSession::RequestThumbByFileHandleAsyncL - EThumbnailGeneratePersistentSizesOnly" );
 CreateGenerateTaskFromFileHandleL( &file );
 // ownership of the file transferred
 CleanupStack::Pop(&file);
 }
 if( err == KErrCompletion )
 {
 // If thumbnail of requested size is blacklisted, fetching is left with KErrCompletion
 TN_DEBUG1( "CThumbnailServerSession::RequestThumbByFileHandleAsyncL() - thumbnail blacklisted" );
+OstTrace0( TRACE_NORMAL, DUP4_CTHUMBNAILSERVERSESSION_REQUESTTHUMBBYFILEHANDLEASYNCL, "CThumbnailServerSession::RequestThumbByFileHandleAsyncL - thumbnail blacklisted" );
 aMessage.Complete( err );
 iMessage = RMessage2();
 // close file
 CleanupStack::PopAndDestroy(&file);
 }
 else if ( !err && iBitmap )
 {
 TN_DEBUG1( "CThumbnailServerSession::RequestThumbByFileHandleAsyncL() - found existing thumbnail - bitmap " );
+OstTrace0( TRACE_NORMAL, DUP3_CTHUMBNAILSERVERSESSION_REQUESTTHUMBBYFILEHANDLEASYNCL, "CThumbnailServerSession::RequestThumbByFileHandleAsyncL - found existing thumbnail - bitmap " );
 // Thumbnail already stored
 CleanupStack::PopAndDestroy(&file);
 TN_DEBUG1("CThumbnailServerSession::RequestThumbByFileHandleAsyncL - file handle closed");
+OstTrace0( TRACE_NORMAL, DUP5_CTHUMBNAILSERVERSESSION_REQUESTTHUMBBYFILEHANDLEASYNCL, "CThumbnailServerSession::RequestThumbByFileHandleAsyncL - file handle closed" );
 ProcessBitmapL();
 }
 else if ( (err == KErrNotFound || err == KErrAccessDenied) &&
 !(params.iFlags& CThumbnailManager::EDoNotCreate) )
 {
 TN_DEBUG1( "CThumbnailServerSession::RequestThumbByFileHandleAsyncL() - KErrNotFound & !EDoNotCreate" );
+OstTrace0( TRACE_NORMAL, DUP6_CTHUMBNAILSERVERSESSION_REQUESTTHUMBBYFILEHANDLEASYNCL, "CThumbnailServerSession::RequestThumbByFileHandleAsyncL - KErrNotFound & !EDoNotCreate" );
 CreateGenerateTaskFromFileHandleL( &file);
 // ownership of the file transferred
 	CleanupStack::Pop(&file);
 }
 else if (!err && iBuffer)
 {
 TN_DEBUG1( "CThumbnailServerSession::RequestThumbByFileHandleAsyncL() - found existing thumbnail - jpeg " );
+OstTrace0( TRACE_NORMAL, DUP7_CTHUMBNAILSERVERSESSION_REQUESTTHUMBBYFILEHANDLEASYNCL, "CThumbnailServerSession::RequestThumbByFileHandleAsyncL - found existing thumbnail - jpeg" );
 CThumbnailDecodeTask* task = new( ELeave )CThumbnailDecodeTask( Server()
 ->Processor(), * Server(), iBuffer, params.iPriority, params.iDisplayMode );
 CleanupStack::PushL( task );
 iBuffer = NULL;
 // close file
 CleanupStack::PopAndDestroy(&file);
 TN_DEBUG1("CThumbnailServerSession::RequestThumbByFileHandleAsyncL - file handle closed");
+OstTrace0( TRACE_NORMAL, DUP8_CTHUMBNAILSERVERSESSION_REQUESTTHUMBBYFILEHANDLEASYNCL, "CThumbnailServerSession::RequestThumbByFileHandleAsyncL - file handle closed" );
 }
 else
 {
 TN_DEBUG2( "CThumbnailServerSession::RequestThumbByFileHandleAsyncL() - thumbnail not found, err=%d", err );
+OstTrace1( TRACE_NORMAL, DUP9_CTHUMBNAILSERVERSESSION_REQUESTTHUMBBYFILEHANDLEASYNCL, "CThumbnailServerSession::RequestThumbByFileHandleAsyncL - thumbnail not found;err=%d", err );
 aMessage.Complete( ConvertSqlErrToE32Err( err ));
 iMessage = RMessage2();
 // close file
 //
 void CThumbnailServerSession::RequestThumbByPathAsyncL( const RMessage2&
 aMessage )
 {
 TN_DEBUG1( "CThumbnailServerSession::RequestThumbByPathAsyncL()" );
+OstTrace0( TRACE_NORMAL, CTHUMBNAILSERVERSESSION_REQUESTTHUMBBYPATHASYNCL, "CThumbnailServerSession::RequestThumbByPathAsyncL" );
 #ifdef _DEBUG
 TTime aStart, aStop;
 aStart.UniversalTime();
 #endif
 if(aMessage.Int1() != KCheckValue)
 {
 TN_DEBUG1( "CThumbnailServerSession::RequestThumbByPathAsync() - error in aMessage - leaving" );
+OstTrace0( TRACE_NORMAL, DUP1_CTHUMBNAILSERVERSESSION_REQUESTTHUMBBYPATHASYNCL, "CThumbnailServerSession::RequestThumbByPathAsyncL - error in aMessage - leaving" );
 User::Leave(KErrArgument);
 }
 aMessage.ReadL( 0, iRequestParams );
 const TThumbnailRequestParams& params = iRequestParams();
 	    if ( !err && iBitmap )
 	        {
 	        TN_DEBUG1(
 	            "CThumbnailServerSession::RequestThumbByPathAsyncL() - found existing thumbnail- bitmap" );
+	        OstTrace0( TRACE_NORMAL, DUP2_CTHUMBNAILSERVERSESSION_REQUESTTHUMBBYPATHASYNCL, "CThumbnailServerSession::RequestThumbByPathAsyncL - found existing thumbnail- bitmap" );
 	        ProcessBitmapL();
 	        }
 	    else if ( !err && iBuffer)
 	        {
 	        TN_DEBUG1(
 	            "CThumbnailServerSession::RequestThumbByPathAsyncL() - found existing thumbnail- jpeg" );
+	        OstTrace0( TRACE_NORMAL, DUP3_CTHUMBNAILSERVERSESSION_REQUESTTHUMBBYPATHASYNCL, "CThumbnailServerSession::RequestThumbByPathAsyncL - found existing thumbnail- jpeg" );
 	        CThumbnailDecodeTask* task = new( ELeave )CThumbnailDecodeTask( Server()
 	               ->Processor(), * Server(), iBuffer, params.iPriority, params.iDisplayMode );
 	        CleanupStack::PushL( task );
 	        }
 	    else if( err == KErrCompletion )
 	        {
 // If thumbnail of requested size is blacklisted, fetching is left with KErrCompletion
 TN_DEBUG1( "CThumbnailServerSession::RequestThumbByPathAsyncL() - thumbnail blacklisted" );
+OstTrace0( TRACE_NORMAL, DUP4_CTHUMBNAILSERVERSESSION_REQUESTTHUMBBYPATHASYNCL, "CThumbnailServerSession::RequestThumbByPathAsyncL - thumbnail blacklisted" );
 aMessage.Complete( err );
 iMessage = RMessage2();
 	        }
 	    else
 	        {
 	        TN_DEBUG2(
 	            "CThumbnailServerSession::RequestThumbByPathAsyncL() - thumbnail not found, err = %d", err );
+	        OstTrace1( TRACE_NORMAL, DUP5_CTHUMBNAILSERVERSESSION_REQUESTTHUMBBYPATHASYNCL, "CThumbnailServerSession::RequestThumbByPathAsyncL  - thumbnail not found;err=%d", err );
 	        // don't try to create from virtual URI
 	        if ( params.iVirtualUri )
 	            {
 User::Leave(err);
 	        }
 	   }
 #ifdef _DEBUG
 aStop.UniversalTime();
+TInt tookTime = (TInt)aStop.MicroSecondsFrom(aStart).Int64()/1000;
 TN_DEBUG2( "CThumbnailStore::RequestThumbByPathAsyncL() request took %d ms", (TInt)aStop.MicroSecondsFrom(aStart).Int64()/1000 );
+OstTrace1( TRACE_NORMAL, DUP6_CTHUMBNAILSERVERSESSION_REQUESTTHUMBBYPATHASYNCL, "CThumbnailServerSession::RequestThumbByPathAsyncL;tookTime=%d", tookTime );
 #endif
 }
 void CThumbnailServerSession::RequestSetThumbnailByBufferL( const RMessage2& aMessage )
 {
 TN_DEBUG1( "CThumbnailServerSession::RequestSetThumbnailByBufferL()" );
+OstTrace0( TRACE_NORMAL, CTHUMBNAILSERVERSESSION_REQUESTSETTHUMBNAILBYBUFFERL, "CThumbnailServerSession::RequestSetThumbnailByBufferL" );
 if(aMessage.Int3() != KCheckValue)
 {
 TN_DEBUG1( "CThumbnailServerSession::RequestSetThumbnailByBufferL() - error in aMessage - leaving" );
+OstTrace0( TRACE_NORMAL, DUP1_CTHUMBNAILSERVERSESSION_REQUESTSETTHUMBNAILBYBUFFERL, "CThumbnailServerSession::RequestSetThumbnailByBufferL - error in aMessage - leaving" );
 User::Leave(KErrArgument);
 }
 aMessage.ReadL( 0, iRequestParams );
 const TThumbnailRequestParams& params = iRequestParams();
 }
 void CThumbnailServerSession::RequestSetThumbnailByBitmapL( const RMessage2& aMessage )
 {
 TN_DEBUG1( "CThumbnailServerSession::RequestSetThumbnailByBitmapL()" );
+OstTrace0( TRACE_NORMAL, CTHUMBNAILSERVERSESSION_REQUESTSETTHUMBNAILBYBITMAPL, "CThumbnailServerSession::RequestSetThumbnailByBitmapL" );
 if(aMessage.Int2() != KCheckValue)
 {
 TN_DEBUG1( "CThumbnailServerSession::RequestSetThumbnailByBitmapL() - error in aMessage - leaving" );
+OstTrace0( TRACE_NORMAL, DUP1_CTHUMBNAILSERVERSESSION_REQUESTSETTHUMBNAILBYBITMAPL, "CThumbnailServerSession::RequestSetThumbnailByBitmapL - error in aMessage - leaving" );
 User::Leave(KErrArgument);
 }
 aMessage.ReadL( 0, iRequestParams );
 const TThumbnailRequestParams& params = iRequestParams();
 TInt height = (*missingSizes)[i].iSize.iHeight;
 (*missingSizes)[i].iSize.iHeight = (*missingSizes)[i].iSize.iWidth;
 (*missingSizes)[i].iSize.iWidth = height;
 TN_DEBUG1( "CThumbnailServerSession::RequestSetThumbnailByBitmapL() - portrait");
+OstTrace0( TRACE_NORMAL, DUP2_CTHUMBNAILSERVERSESSION_REQUESTSETTHUMBNAILBYBITMAPL, "CThumbnailServerSession::RequestSetThumbnailByBitmapL - portrait" );
 }
 }
 CThumbnailScaleTask* scaleTask = CThumbnailScaleTask::NewL( Server()->Processor(),
 *Server(), params.iTargetUri, bitmap, bitmapSize,
 {
 TThumbnailRequestParams& params = iRequestParams();
 TN_DEBUG2(
 "CThumbnailServerSession::CreateGenerateTaskFromFileHandleL() -- create thumbnail generation task for %S", &params.iFileName );
+OstTraceExt1( TRACE_NORMAL, CTHUMBNAILSERVERSESSION_CREATEGENERATETASKFROMFILEHANDLEL, "CThumbnailServerSession::CreateGenerateTaskFromFileHandleL -- create thumbnail generation task for;params.iFileName=%S", params.iFileName );
 // disk space check only for stored sizes
 if ( params.iImport &&
 Server()->StoreForPathL(params.iTargetUri)->IsDiskFull() )
 {
 // create new task
 if( !aFile)
 {
 TN_DEBUG1("CThumbnailServerSession::CreateGenerateTaskFromFileHandleL() - KErrArgument");
+OstTrace0( TRACE_NORMAL, DUP1_CTHUMBNAILSERVERSESSION_CREATEGENERATETASKFROMFILEHANDLEL, "CThumbnailServerSession::CreateGenerateTaskFromFileHandleL - KErrArgument" );
 User::Leave( KErrArgument );
 }
 CleanupClosePushL( *aFile );
 CThumbnailGenerateTask* task = new( ELeave )CThumbnailGenerateTask( Server()
 ->Processor(), * Server(), aFile, NULL, &params.iMimeType, params.iFlags,
 {
 const TThumbnailRequestParams& params = iRequestParams();
 TN_DEBUG2(
 "CThumbnailServerSession::CreateGenerateTaskFromBufferL() -- create thumbnail generation task for %S", &params.iTargetUri );
+OstTraceExt1( TRACE_NORMAL, CTHUMBNAILSERVERSESSION_CREATEGENERATETASKFROMBUFFERL, "CThumbnailServerSession::CreateGenerateTaskFromBufferL -  -- create thumbnail generation task for;params.iTargetUri=%S", params.iTargetUri );
 // disk space check only for stored sizes
 if ( params.iThumbnailSize != ECustomThumbnailSize &&
 Server()->StoreForPathL(params.iTargetUri)->IsDiskFull() )
 {
 RFile64 file;
 CleanupClosePushL( file );
 User::LeaveIfError( file.Open( Server()->Fs(), params.iTargetUri, EFileShareReadersOrWriters ));
 TN_DEBUG2( "CThumbnailServerSession::CreateGenerateTaskFromBufferL - file handle opened for %S", &params.iFileName );
+OstTraceExt1( TRACE_NORMAL, DUP1_CTHUMBNAILSERVERSESSION_CREATEGENERATETASKFROMBUFFERL, "CThumbnailServerSession::CreateGenerateTaskFromBufferL;params.iFileName=%S", params.iFileName );
 mimetype = Server()->ResolveMimeTypeL(file);
 file.Close();
 TN_DEBUG1("CThumbnailServerSession::CreateGenerateTaskFromBufferL - file handle closed");
+OstTrace0( TRACE_NORMAL, DUP2_CTHUMBNAILSERVERSESSION_CREATEGENERATETASKFROMBUFFERL, "CThumbnailServerSession::CreateGenerateTaskFromBufferL - file handle closed" );
 CleanupStack::Pop( &file );
 }
 sourceType = Server()->SourceTypeFromMimeType( mimetype );
 // create new task
 if( !aBuffer)
 {
 TN_DEBUG1( "CThumbnailServerSession::UpdateThumbnailsL() - KErrArgument" );
+OstTrace0( TRACE_NORMAL, DUP3_CTHUMBNAILSERVERSESSION_CREATEGENERATETASKFROMBUFFERL, "CThumbnailServerSession::CreateGenerateTaskFromBufferL - KErrArgument" );
 User::Leave( KErrArgument );
 }
 CThumbnailGenerateTask* task = new( ELeave )CThumbnailGenerateTask( Server()
 ->Processor(), * Server(), NULL, aBuffer, &params.iMimeType, params.iFlags,
 // -----------------------------------------------------------------------------
 //
 void CThumbnailServerSession::FetchThumbnailL()
 {
 TN_DEBUG1("CThumbnailServerSession::FetchThumbnailL()");
+OstTrace0( TRACE_NORMAL, CTHUMBNAILSERVERSESSION_FETCHTHUMBNAILL, "CThumbnailServerSession::FetchThumbnailL" );
 __ASSERT_DEBUG( !iBitmap, ThumbnailPanic( EThumbnailBitmapNotReleased ));
 __ASSERT_DEBUG( !iBuffer, ThumbnailPanic( EThumbnailBitmapNotReleased ));
 delete iBitmap;
 iBitmap = NULL;
 if( params.iFileName != KNullDesC )
 {
 TN_DEBUG3( "CThumbnailServerSession::FetchThumbnailL( ThumbnailSize=%d ( Path=%S ))",
 params.iThumbnailSize, &params.iFileName );
+OstTraceExt1( TRACE_NORMAL, DUP1_CTHUMBNAILSERVERSESSION_FETCHTHUMBNAILL, "CThumbnailServerSession::FetchThumbnailL;params.iFileName=%S", params.iFileName );
 Server()->FetchThumbnailL( params.iFileName, iBitmap, iBuffer, params.iThumbnailSize, iOriginalSize);
 }
 else
 {
 User::Leave( KErrNotSupported );
 }
 #ifdef _DEBUG
 if( iBitmap)
 {
 TN_DEBUG4( "CThumbnailServerSession::FetchThumbnailL() size %d x %d displaymode %d", iBitmap->SizeInPixels().iWidth, iBitmap->SizeInPixels().iHeight, iBitmap->DisplayMode());
+OstTraceExt3( TRACE_NORMAL, DUP2_CTHUMBNAILSERVERSESSION_FETCHTHUMBNAILL, "CThumbnailServerSession::FetchThumbnailL;iBitmap->SizeInPixels().iWidth=%d;iBitmap->SizeInPixels().iHeight=%d;iBitmap->DisplayMode()=%u", iBitmap->SizeInPixels().iWidth, iBitmap->SizeInPixels().iHeight, iBitmap->DisplayMode() );
 }
 #endif
 }
 // -----------------------------------------------------------------------------
 TThumbnailRequestParams& params = iRequestParams();
 if ( ClientThreadAlive() )
 {
 TN_DEBUG2("CThumbnailServerSession::ProcessBitmapL(), iBitmap handle= 0x%08x", iBitmap->Handle());
+OstTrace1( TRACE_NORMAL, CTHUMBNAILSERVERSESSION_PROCESSBITMAPL, "CThumbnailServerSession::ProcessBitmapL;iBitmap->Handle()=%o", iBitmap->Handle() );
 params.iBitmapHandle = iBitmap->Handle();
 const TSize bitmapSize = iBitmap->SizeInPixels();
 if ( params.iQualityPreference == CThumbnailManager
 }
 iMessage.WriteL( 0, iRequestParams );
 TN_DEBUG1("CThumbnailServerSession()::ProcessBitmapL() bitmap to pool");
+OstTrace0( TRACE_NORMAL, DUP1_CTHUMBNAILSERVERSESSION_PROCESSBITMAPL, "CThumbnailServerSession::ProcessBitmapL - bitmap to pool" );
 Server()->AddBitmapToPoolL( this, iBitmap, TThumbnailServerRequestId( this, params.iRequestId ) );
 iMessage.Complete( KErrNone );
 iMessage = RMessage2();
 // -----------------------------------------------------------------------------
 //
 void CThumbnailServerSession::ReleaseBitmap( const RMessage2& aMessage )
 {
 TN_DEBUG2( "CThumbnailServerSession::ReleaseBitmap(%d)", aMessage.Int0());
+OstTrace1( TRACE_NORMAL, CTHUMBNAILSERVERSESSION_RELEASEBITMAP, "CThumbnailServerSession::ReleaseBitmap;aMessage.Int0()=%d", aMessage.Int0() );
 Server()->DeleteBitmapFromPool( aMessage.Int0());
 }
 // -----------------------------------------------------------------------------
 // -----------------------------------------------------------------------------
 //
 TInt CThumbnailServerSession::CancelRequest( const RMessage2& aMessage )
 {
 TN_DEBUG1( "CThumbnailServerSession::CancelRequest()" );
+OstTrace0( TRACE_NORMAL, CTHUMBNAILSERVERSESSION_CANCELREQUEST, "CThumbnailServerSession::CancelRequest" );
 const TThumbnailServerRequestId requestId( this, aMessage.Int0());
 const TInt err = Server()->DequeTask( requestId );
 TN_DEBUG4(
 "CThumbnailServerSession::CancelRequest(0x%08x/%d) - returning %d",
 requestId.iSession, requestId.iRequestId, err );
+OstTrace1( TRACE_NORMAL, DUP1_CTHUMBNAILSERVERSESSION_CANCELREQUEST, "CThumbnailServerSession::CancelRequest;requestId.iSession=%o", requestId.iSession );
+OstTrace1( TRACE_NORMAL, DUP2_CTHUMBNAILSERVERSESSION_CANCELREQUEST, "CThumbnailServerSession::CancelRequest;err=%d", err );
 return err;
 }
 // -----------------------------------------------------------------------------
 // CThumbnailServerSession::ChangePriority()
 // -----------------------------------------------------------------------------
 //
 TInt CThumbnailServerSession::ChangePriority( const RMessage2& aMessage )
 {
 TN_DEBUG1( "CThumbnailServerSession::ChangePriority()" );
+OstTrace0( TRACE_NORMAL, CTHUMBNAILSERVERSESSION_CHANGEPRIORITY, "CThumbnailServerSession::ChangePriority" );
 const TThumbnailServerRequestId requestId( this, aMessage.Int0());
 const TInt newPriority = aMessage.Int1();
 const TInt err = Server()->ChangeTaskPriority( requestId, newPriority );
 TN_DEBUG5(
 "CThumbnailServerSession::ChangePriority(0x%08x/%d, %d) - returning %d",
 requestId.iSession, requestId.iRequestId, newPriority, err );
+OstTrace1( TRACE_NORMAL, DUP1_CTHUMBNAILSERVERSESSION_CHANGEPRIORITY, "CThumbnailServerSession::ChangePriority;requestId.iSession=%o", requestId.iSession );
+OstTraceExt2( TRACE_NORMAL, DUP2_CTHUMBNAILSERVERSESSION_CHANGEPRIORITY, "CThumbnailServerSession::ChangePriority;requestId.iRequestId=%u;err=%d", requestId.iRequestId, err );
 return err;
 }
 // -----------------------------------------------------------------------------
 // CThumbnailServerSession::DeleteThumbnailsL()
 void CThumbnailServerSession::DeleteThumbnailsL( const RMessage2& aMessage )
 {
 if(aMessage.Int2() != KCheckValue)
 {
 TN_DEBUG1( "CThumbnailServerSession::DeleteThumbnailsL() - error in aMessage - leaving" );
+OstTrace0( TRACE_NORMAL, CTHUMBNAILSERVERSESSION_DELETETHUMBNAILSL, "CThumbnailServerSession::DeleteThumbnailsL - error in aMessage - leaving" );
 User::Leave(KErrArgument);
 }
 HBufC* fileName = HBufC::NewLC( KMaxFileName );
 TPtr ptr = fileName->Des();
 void CThumbnailServerSession::DeleteThumbnailsByIdL( const RMessage2& aMessage )
 {
 if(aMessage.Int2() != KCheckValue)
 {
 TN_DEBUG1( "CThumbnailServerSession::DeleteThumbnailsByIdL() - error in aMessage - leaving" );
+OstTrace0( TRACE_NORMAL, CTHUMBNAILSERVERSESSION_DELETETHUMBNAILSBYIDL, "CThumbnailServerSession::DeleteThumbnailsByIdL - error in aMessage - leaving" );
 User::Leave(KErrArgument);
 }
 // read message params
 aMessage.ReadL( 0, iRequestParams );
 // -----------------------------------------------------------------------------
 //
 void CThumbnailServerSession::GetMimeTypeListL( const RMessage2& aMessage )
 {
 TN_DEBUG1( "CThumbnailServerSession::GetMimeTypeListL()" );
+OstTrace0( TRACE_NORMAL, CTHUMBNAILSERVERSESSION_GETMIMETYPELISTL, "CThumbnailServerSession::GetMimeTypeListL" );
 TInt len = aMessage.GetDesMaxLengthL( 0 );
 HBufC* buf = HBufC::NewLC( len );
 TPtr ptr = buf->Des();
 Server()->GetMimeTypeList( ptr );
 RFile64 file;
 CleanupClosePushL( file );
 User::LeaveIfError( file.Open( Server()->Fs(), params.iFileName, EFileShareReadersOrWriters ));
 TN_DEBUG2( "CThumbnailServerSession::ResolveMimeType - file handle opened for %S", &params.iFileName );
+OstTraceExt1( TRACE_NORMAL, CTHUMBNAILSERVERSESSION_RESOLVEMIMETYPEL, "CThumbnailServerSession::ResolveMimeTypeL - file handle opened;params.iFileName=%S", params.iFileName );
 params.iMimeType = Server()->ResolveMimeTypeL(file);
 file.Close();
 TN_DEBUG1("CThumbnailServerSession::ResolveMimeType - file handle closed");
+OstTrace0( TRACE_NORMAL, DUP1_CTHUMBNAILSERVERSESSION_RESOLVEMIMETYPEL, "CThumbnailServerSession::ResolveMimeTypeL - file handle closed" );
 CleanupStack::Pop( &file );
 }
 }
 }
 // ---------------------------------------------------------------------------
 //
 TInt CThumbnailServerSession::ConvertSqlErrToE32Err( TInt aReason )
 {
 TN_DEBUG2("CThumbnailServerSession::ConvertSqlErrToE32Err(%d)", aReason);
+OstTrace1( TRACE_NORMAL, CTHUMBNAILSERVERSESSION_CONVERTSQLERRTOE32ERR, "CThumbnailServerSession::ConvertSqlErrToE32Err;aReason=%d", aReason );
 TInt e32Err(aReason);
 if ( aReason >=  - 144 )
 // magic: [-1..-144] is E32 error range
 {
 // ---------------------------------------------------------------------------
 //
 TBool CThumbnailServerSession::ClientThreadAlive()
 {
 TN_DEBUG1( "CThumbnailServerSession::ClientThreadAlive()");
+OstTrace0( TRACE_NORMAL, CTHUMBNAILSERVERSESSION_CLIENTTHREADALIVE, "CThumbnailServerSession::ClientThreadAlive" );
 if ( iMessage.Handle())
 {
 // check if client thread alive
 TExitType exitType = iClientThread.ExitType();
 if( exitType != EExitPending )
 {
 TN_DEBUG1( "CThumbnailServerSession::ClientThreadAlive() - client thread died");
+OstTrace0( TRACE_NORMAL, DUP1_CTHUMBNAILSERVERSESSION_CLIENTTHREADALIVE, "CThumbnailServerSession::ClientThreadAlive - client thread died" );
 iMessage = RMessage2();
 return EFalse;
 }
 }
 }
 else
 {
 TN_DEBUG1( "CThumbnailServerSession::ClientThreadAlive() - message null");
+OstTrace0( TRACE_NORMAL, DUP2_CTHUMBNAILSERVERSESSION_CLIENTTHREADALIVE, "CThumbnailServerSession::ClientThreadAlive - message null" );
 return EFalse;
 }
 }

branch	RCL_3
changeset 21	6257223ede8a
parent 20	2b4b06654caa
child 22	9d4d3445ce6e