FCL/sf/mw/remoteconn: comparison mtpfws/mtpfw/src/cmtpconnection.cpp

equal deleted inserted replaced

-:2c19c7cf5550
+:c20dd21d1eb4
 #ifdef MTP_CAPTURE_TEST_DATA
 #include "cmtprequestlogger.h"
 #endif
+#include "mtpdebug.h"
+#include "OstTraceDefinitions.h"
+#ifdef OST_TRACE_COMPILER_IN_USE
+#include "cmtpconnectionTraces.h"
+#endif
 #define UNUSED_VAR(a) (a) = (a)
-__FLOG_STMT(_LIT8(KComponent,"MTPConnection");)
 /**
 CMTPConnection panics
 */
 _LIT(KMTPPanicCategory, "CMTPConnection");
 /**
 Destructor.
 */
 CMTPConnection::~CMTPConnection()
 {
-__FLOG(_L8("~CMTPConnection - Entry"));
+OstTraceFunctionEntry0( CMTPCONNECTION_CMTPCONNECTION_DES_ENTRY );
 CloseAllSessions();
 	//remove all events
 DequeueAllEvents();
 //close the property
 iProperty.Close();
 // delete the ‘name?property
 RProcess process;
 RProperty::Delete(process.SecureId(), EMTPConnStateKey);
-__FLOG(_L8("~CMTPConnection - Exit"));
+OstTraceFunctionExit0( CMTPCONNECTION_CMTPCONNECTION_DES_EXIT );
-	__FLOG_CLOSE;
 }
 /**
 Initiates MTP transaction data phase processing for initiator-to-responder
 data flows. This method should only be invoked when the MTP transaction phase
 connection.
 @panic CMTPConnection 2 If the MTP transaction phase is invalid.
 */
 void CMTPConnection::ReceiveDataL(MMTPType& aData, const TMTPTypeRequest& aRequest, TRequestStatus& aStatus)
 {
-__FLOG(_L8("ReceiveDataL - Entry"));
+OstTraceFunctionEntry0( CMTPCONNECTION_RECEIVEDATAL_ENTRY );
 iDataReceiveResult = KErrNone;
 const TUint KValidPhases(ERequestPhase);
 CMTPSession& session(SessionL(aRequest, TMTPTypeRequest::ERequestSessionID));
 if (ValidFrameworkRequest(&session, KValidPhases, &aStatus))
 ValidateAndPublishConnState(session, State());
 }
 iTransportConnection->ReceiveDataL(aData, aRequest);
 }
-__FLOG(_L8("ReceiveDataL - Exit"));
+OstTraceFunctionExit0( CMTPCONNECTION_RECEIVEDATAL_EXIT );
 }
 /**
 Initiates MTP transaction data phase processing for responder-to-initiator
 data flows. This method should only be invoked when the MTP transaction phase
 connection.
 @panic CMTPConnection 2 If the MTP transaction phase is invalid.
 */
 void CMTPConnection::SendDataL(const MMTPType& aData, const TMTPTypeRequest& aRequest, TRequestStatus& aStatus)
 {
-__FLOG(_L8("SendDataL - Entry"));
+OstTraceFunctionEntry0( CMTPCONNECTION_SENDDATAL_ENTRY );
 #ifdef MTP_CAPTURE_TEST_DATA
 iRequestLogger->WriteDataPhaseL(aData, EDataRToIPhase);
 #endif
 const TUint KValidPhases(ERequestPhase);
 //publish the connection state info to the subscriber.
 ValidateAndPublishConnState(session, State());
 }
 iTransportConnection->SendDataL(aData, aRequest);
 }
-__FLOG(_L8("SendDataL - Exit"));
+OstTraceFunctionExit0( CMTPCONNECTION_SENDDATAL_EXIT );
 }
 /**
 Sends an MTP event dataset.
 @param aEvent The MTP event dataset source.
 @leave KErrNotFound If the MTP event dataset specifies an invalid SessionID.
 */
 void CMTPConnection::SendEventL(const TMTPTypeEvent& aEvent)
 {
-__FLOG(_L8("SendEventL - Entry"));
+OstTraceFunctionEntry0( CMTPCONNECTION_SENDEVENTL_ENTRY );
 const TUint KValidPhases(EIdlePhase | ERequestPhase | EDataIToRPhase| EDataRToIPhase | EResponsePhase | ECompletingPhase);
 if (ValidFrameworkRequest(NULL, KValidPhases, NULL))
 {
 // Validate the SessionID
 TUint32 sessionId(aEvent.Uint32(TMTPTypeEvent::EEventSessionID));
 if (sessionId != KMTPSessionAll)
 {
-User::LeaveIfError(iSessions.FindInOrder(sessionId, SessionOrder));
+TInt ret = iSessions.FindInOrder(sessionId, SessionOrder);
+LEAVEIFERROR(ret,
+OstTrace1(TRACE_ERROR, CMTPCONNECTION_SENDEVENTL, "can't find according to session_id %d", sessionId));
 }
 		EnqueueEvent(new (ELeave) CMTPEventLink(aEvent));
 		if (iPendingEventCount == 1)
 			{
 			// Forward the event to the transport connection layer.
 			iTransportConnection->SendEventL(iEventQ.First()->iEvent);
 			}
 }
-__FLOG(_L8("SendEventL - Exit"));
+OstTraceFunctionExit0( CMTPCONNECTION_SENDEVENTL_EXIT );
 }
 /**
 Initiates MTP transaction response phase processing. This method should only
 be invoked when the MTP transaction phase state is either ERequestPhase, or
 connection.
 @panic CMTPConnection 2 If the MTP transaction phase is invalid.
 */
 void CMTPConnection::SendResponseL(const TMTPTypeResponse& aResponse, const TMTPTypeRequest& aRequest, TRequestStatus& aStatus)
 {
-__FLOG(_L8("SendResponseL - Entry"));
+OstTraceFunctionEntry0( CMTPCONNECTION_SENDRESPONSEL_ENTRY );
 #ifdef MTP_CAPTURE_TEST_DATA
 // Running under debug capture mode save this request off to disk.
 iRequestLogger->LogResponseL(aResponse);
 #endif
 Request/Response mismatch by the originating data provider plug-in.
 Fail the transport connection to avoid leaving the current
 transaction irrecoverably hanging.
 */
 UnrecoverableMTPError();
-User::Leave(KErrArgument);
+OstTrace0(TRACE_ERROR, CMTPCONNECTION_SENDRESPONSEL, "Request/Response mismatch");
+User::Leave(KErrArgument);
 }
 if (session.TransactionPhase() == ERequestPhase)
 {
 // Transaction has no data phase.
 session.SetRequestPending(aStatus);
 iTransportConnection->SendResponseL(aResponse, aRequest);
 }
-__FLOG(_L8("SendResponseL - Exit"));
+OstTraceFunctionExit0( CMTPCONNECTION_SENDRESPONSEL_EXIT );
 }
 /**
 Deletes the session object assigned to the specified session and notifies all
 loaded data providers.
 @leave One of the system wide error codes, if a general processing failure
 occurs.
 */
 EXPORT_C void CMTPConnection::SessionClosedL(TUint32 aMTPId)
 {
-__FLOG(_L8("SessionClosedL - Entry"));
+OstTraceFunctionEntry0( CMTPCONNECTION_SESSIONCLOSEDL_ENTRY );
 if(0x0FFFFFFF != aMTPId)
 	{
 	TInt idx(iSessions.FindInOrder(aMTPId, SessionOrder));
 	    __ASSERT_DEBUG((idx != KErrNotFound), Panic(EMTPPanicInvalidSession));
 	    CloseSession(idx);
 		    	SessionClosedL(id);
 		    	}
 		    session = NULL;
 		    }
 	    }
-__FLOG(_L8("SessionClosedL - Exit"));
+OstTraceFunctionExit0( CMTPCONNECTION_SESSIONCLOSEDL_EXIT );
 }
 /**
 Creates a new session object for the specified session and notifies all loaded
 data providers. The session is known by two identifiers:
 @leave One of the system wide error codes, if a general processing failure
 occurs.
 */
 EXPORT_C void CMTPConnection::SessionOpenedL(TUint32 aMTPId)
 {
-__FLOG(_L8("SessionOpenedL - Entry"));
+OstTraceFunctionEntry0( CMTPCONNECTION_SESSIONOPENEDL_ENTRY );
 // Validate the SessionID
 if (SessionWithMTPIdExists(aMTPId))
 {
-User::Leave(KErrAlreadyExists);
+OstTrace1(TRACE_ERROR, CMTPCONNECTION_SESSIONOPENEDL, "session %d alreay exist", aMTPId);
+User::Leave(KErrAlreadyExists);
 }
 // Create a new session object
 CMTPSession* session = CMTPSession::NewLC(aMTPId, aMTPId);
 session->SetTransactionPhase(EIdlePhase);
 // OpenSession Command coming and now it is really connected to host.
 PublishConnState(EConnectedToHost);
 TMTPNotificationParamsSessionChange params = {aMTPId, *this};
 iSingletons.DpController().NotifyDataProvidersL(EMTPSessionOpened, &params);
 }
-__FLOG(_L8("SessionOpenedL - Exit"));
+OstTraceFunctionExit0( CMTPCONNECTION_SESSIONOPENEDL_EXIT );
 }
 /*
 * Signals the connection is suspended, the connection state is set to EStateShutdown which
 * means that all the current transaction will not be able to send/receive any data via the
 * @return ETrue - there is an active transaction currently, and Connection will suspend when it finishes
 * EFalse - No active transaction, connection suspends immediately.
 */
 TBool CMTPConnection::ConnectionSuspended()
 {
-__FLOG(_L8("ConnectionSuspended - Entry"));
+OstTraceFunctionEntry0( CMTPCONNECTION_CONNECTIONSUSPENDED_ENTRY );
 TBool ret = EFalse;
 TUint currentState = State();
 if (currentState != EStateShutdown)
 {
 SetState(EStateShutdown);
 PublishConnState(EDisconnectedFromHost);
 }
-__FLOG(_L8("ConnectionSuspended - Exit"));
+OstTraceFunctionExit0( CMTPCONNECTION_CONNECTIONSUSPENDED_EXIT );
 return ret;
 }
 void CMTPConnection::CompleteCloseConnection()
 {
-__FLOG(_L8("CompleteCloseConnection - Entry"));
+OstTraceFunctionEntry0( CMTPCONNECTION_COMPLETECLOSECONNECTION_ENTRY );
 CloseAllSessions();
 iSessions.Reset();
 //notify ConnectionMgr and corresponding transports of completion of connection close
 iSingletons.ConnectionMgr().ConnectionCloseComplete(iConnectionId);
 iSingletons.Close();
-__FLOG(_L8("CompleteCloseConnection - Exit"));
+OstTraceFunctionExit0( CMTPCONNECTION_COMPLETECLOSECONNECTION_EXIT );
 }
 /*
 * Signals that the connection is resumed to EStateOpen state which means that data providers
 * can receive requests from host again.
 * @aTransportConnection The new transport connection object
 * @leave One of the system wide error codes, if a processing failure occurs.
 */
 void CMTPConnection::ConnectionResumedL(MMTPTransportConnection& aTransportConnection)
 {
-__FLOG(_L8("ConnectionResumed - Entry"));
+OstTraceFunctionEntry0( CMTPCONNECTION_CONNECTIONRESUMEDL_ENTRY );
 TUint currentState = State();
 if (currentState != EStateOpen && currentState != EStateErrorRecovery)
 {
 iSingletons.OpenL();
 iTransportConnection->BindL(*this);
 SetState(EStateOpen);
 }
-__FLOG(_L8("ConnectionResumed - Exit"));
+OstTraceFunctionExit0( CMTPCONNECTION_CONNECTIONRESUMEDL_EXIT );
 }
 /**
 Signals the completion of the current transaction processing sequence. This
 method should only be invoked when the MTP transaction phase state is
 @leave KErrNotFound If the MTP request dataset specifies an invalid SessionID.
 @panic CMTPConnection 2 If the MTP transaction phase is invalid.
 */
 void CMTPConnection::TransactionCompleteL(const TMTPTypeRequest& aRequest)
 {
-__FLOG(_L8("TransactionCompleteL - Entry"));
+OstTraceFunctionEntry0( CMTPCONNECTION_TRANSACTIONCOMPLETEL_ENTRY );
 const TUint KValidPhases(ECompletingPhase);
 CMTPSession& session(SessionL(aRequest, TMTPTypeRequest::ERequestSessionID));
 if (ValidFrameworkRequest(&session, KValidPhases, NULL))
 {
 if (State() == EStateShutdown && ActiveSessions() == 0)
 {
 CompleteCloseConnection();
 }
 }
-__FLOG(_L8("TransactionCompleteL - Exit"));
+OstTraceFunctionExit0( CMTPCONNECTION_TRANSACTIONCOMPLETEL_EXIT );
 }
 TUint CMTPConnection::ConnectionId() const
 {
 return iConnectionId;
 }
 MMTPSession& CMTPConnection::SessionWithMTPIdL(TUint32 aMTPId) const
 {
 TInt idx(iSessions.FindInOrder(aMTPId, SessionOrder));
-User::LeaveIfError(idx);
+LEAVEIFERROR(idx,
+OstTrace1(TRACE_ERROR, CMTPCONNECTION_SESSIONWITHMTPIDL, "can't find according to session_id %d", aMTPId));
 return *iSessions[idx];
 }
 TBool CMTPConnection::SessionWithUniqueIdExists(TUint32 aUniqueId) const
 {
 return SessionWithMTPIdL(aUniqueId);
 }
 void CMTPConnection::ReceivedEventL(const TMTPTypeEvent& aEvent)
 {
-__FLOG(_L8("ReceivedEventL - Entry"));
+OstTraceFunctionEntry0( CMTPCONNECTION_RECEIVEDEVENTL_ENTRY );
 TInt idx(KErrNotFound);
 // Validate the SessionID.
 TUint32 sessionId(aEvent.Uint32(TMTPTypeEvent::EEventSessionID));
 if (sessionId != KMTPSessionAll)
 {
 idx = iSessions.FindInOrder(sessionId, SessionOrder);
-User::LeaveIfError(idx);
+LEAVEIFERROR(idx,
+OstTrace1(TRACE_ERROR, CMTPCONNECTION_RECEIVEDEVENTL, "can't find according to session_id %d", sessionId));
 }
 // Check that this event is valid.
 CMTPSession& session(*iSessions[idx]);
 	{
 	session.StorePendingEventL(aEvent);
 	}
 else
 	{
-	   	if (request.Uint32(TMTPTypeRequest::ERequestTransactionID) >
+TUint32 requestTransactionId = request.Uint32(TMTPTypeRequest::ERequestTransactionID);
-	    	aEvent.Uint32(TMTPTypeEvent::EEventTransactionID) )
+TUint32 eventTransactionId = aEvent.Uint32(TMTPTypeEvent::EEventTransactionID);
+	   	if (eventTransactionId > requestTransactionId)
 	        {
 	        // Event to be queued for future use, we can only queue one event at a time
 	        session.StorePendingEventL(aEvent);
 	        }
+	   	else if (eventTransactionId == requestTransactionId)
-	    if (request.Uint32(TMTPTypeRequest::ERequestTransactionID) ==
-	         aEvent.Uint32(TMTPTypeEvent::EEventTransactionID) )
 	        {
 	        // Event is valid
 	        // Perform transport layer processing.
 	        if (aEvent.Uint16(TMTPTypeEvent::EEventCode) == EMTPEventCodeCancelTransaction)
 	            {
 	                {
 	                InitiateTransactionCancelL(idx);
 	                }
 	            }
-	         // Forward the event to the DP framework layer.
+	        // Forward the event to the DP framework layer.
 	        iSingletons.Router().ProcessEventL(aEvent, *this);
 	        }
+	   	//discard the event if the event transaction id < requestion transaction id
 	}
-__FLOG(_L8("ReceivedEventL - Exit"));
+OstTraceFunctionExit0( CMTPCONNECTION_RECEIVEDEVENTL_EXIT );
 }
 void CMTPConnection::ReceivedRequestL(const TMTPTypeRequest& aRequest)
 {
-__FLOG(_L8("ReceivedRequestL - Entry"));
+OstTraceFunctionEntry0( CMTPCONNECTION_RECEIVEDREQUESTL_ENTRY );
 #ifdef MTP_CAPTURE_TEST_DATA
 // Running under debug capture mode save this request off to disk.
 iRequestLogger->LogRequestL(aRequest);
 #endif
 // Forward the request to the DP framework layer.
 TRAPD(err,iSingletons.Router().ProcessRequestL(session.ActiveRequestL(), *this));
 if(err!=KErrNone)
 {
 session.SetTransactionPhase(EIdlePhase);
+OstTrace1(TRACE_ERROR, CMTPCONNECTION_RECEIVEDREQUESTL, "router process request error! error code %d", err);
 User::Leave(err);
 }
 }
 }
-__FLOG(_L8("ReceivedRequestL - Exit"));
+OstTraceFunctionExit0( CMTPCONNECTION_RECEIVEDREQUESTL_EXIT );
 }
 #ifdef MTP_CAPTURE_TEST_DATA
 void CMTPConnection::ReceiveDataCompleteL(TInt aErr, const MMTPType& aData, const TMTPTypeRequest& aRequest)
 #else
 void CMTPConnection::ReceiveDataCompleteL(TInt aErr, const MMTPType& aData, const TMTPTypeRequest& aRequest)
 #endif
 {
-__FLOG(_L8("ReceiveDataCompleteL - Entry"));
+OstTraceFunctionEntry0( CMTPCONNECTION_RECEIVEDATACOMPLETEL_ENTRY );
 CMTPSession& session(SessionL(aRequest, TMTPTypeRequest::ERequestSessionID));
 __ASSERT_DEBUG((session.TransactionPhase() == EDataIToRPhase), Panic(EMTPPanicInvalidState));
 	if(EMTPTypeFile == aData.Type())
 	{
 #endif
 	session.SetTransactionPhase(EResponsePhase);
 	iDataReceiveResult = aErr;
 	session.CompletePendingRequest(aErr);
+	OstTraceFunctionExit0( CMTPCONNECTION_RECEIVEDATACOMPLETEL_EXIT );
-__FLOG(_L8("ReceiveDataCompleteL - Exit"));
 }
 void CMTPConnection::SendDataCompleteL(TInt aErr, const MMTPType& aData, const TMTPTypeRequest& aRequest)
 {
-__FLOG(_L8("SendDataCompleteL - Entry"));
+OstTraceFunctionEntry0( CMTPCONNECTION_SENDDATACOMPLETEL_ENTRY );
 CMTPSession& session(SessionL(aRequest, TMTPTypeRequest::ERequestSessionID));
 __ASSERT_DEBUG((session.TransactionPhase() == EDataRToIPhase), Panic(EMTPPanicInvalidState));
 session.SetTransactionPhase(EResponsePhase);
 PublishConnState(EConnectedToHost);
 }
 session.CompletePendingRequest(aErr);
-__FLOG(_L8("SendDataCompleteL - Exit"));
+OstTraceFunctionExit0( CMTPCONNECTION_SENDDATACOMPLETEL_EXIT );
 }
 void CMTPConnection::SendEventCompleteL(TInt aErr, const TMTPTypeEvent& aEvent)
 {
-__FLOG(_L8("SendEventCompleteL - Entry"));
+OstTraceFunctionEntry0( CMTPCONNECTION_SENDEVENTCOMPLETEL_ENTRY );
 if (aErr != KErrNone)
 {
 UnrecoverableMTPError();
 	if (iPendingEventCount > 0)
 		{
 		if (NULL != iTransportConnection)
 			{
 			// Forward the event to the transport connection layer.
-			__FLOG(_L8("Sending queued event"));
+			OstTrace0( TRACE_NORMAL, CMTPCONNECTION_SENDEVENTCOMPLETEL, "Sending queued event");
 			iTransportConnection->SendEventL(iEventQ.First()->iEvent);
 			}
 		else
 			{
 			DequeueAllEvents();
 			}
 		}
-__FLOG(_L8("SendEventCompleteL - Exit"));
+OstTraceFunctionExit0( CMTPCONNECTION_SENDEVENTCOMPLETEL_EXIT );
 }
 void CMTPConnection::SendResponseCompleteL(TInt aErr, const TMTPTypeResponse& /*aResponse*/, const TMTPTypeRequest& aRequest)
 {
-__FLOG(_L8("SendResponseCompleteL - Entry"));
+OstTraceFunctionEntry0( CMTPCONNECTION_SENDRESPONSECOMPLETEL_ENTRY );
 	if(iState == EStateErrorRecovery)
 		{
 		MTPErrorRecoveryComplete();
 		iTransportConnection->TransactionCompleteL(aRequest);
 		}
 CMTPSession& session(SessionL(aRequest, TMTPTypeRequest::ERequestSessionID));
 	    __ASSERT_DEBUG((session.TransactionPhase() == EResponsePhase), Panic(EMTPPanicInvalidState));
 	session.SetTransactionPhase(ECompletingPhase);
 	session.CompletePendingRequest(aErr);
 		}
-__FLOG(_L8("SendResponseCompleteL - Exit"));
+OstTraceFunctionExit0( CMTPCONNECTION_SENDRESPONSECOMPLETEL_EXIT );
 }
 void CMTPConnection::Unbind(MMTPTransportConnection& /*aConnection*/)
 {
 iTransportConnection = NULL;
 TMTPTransactionPhase CMTPConnection::TransactionPhaseL(TUint32 aMTPId) const
 {
 TInt idx(iSessions.FindInOrder(aMTPId, SessionOrder));
-User::LeaveIfError(idx);
+LEAVEIFERROR(idx,
+OstTrace1(TRACE_ERROR, CMTPCONNECTION_TRANSACTIONPHASEL, "can't find according to session_id %d", aMTPId));
 return iSessions[idx]->TransactionPhase();
 }
 /**
 Constructor.
 Second phase constructor.
 @leave One of the system wide error code, if a processing failure occurs.
 */
 void CMTPConnection::ConstructL()
 {
-	__FLOG_OPEN(KMTPSubsystem, KComponent);
+OstTraceFunctionEntry0( CMTPCONNECTION_CONSTRUCTL_ENTRY );
-__FLOG(_L8("ConstructL - Entry"));
 //define the property for publishing connection state.
 DefineConnStatePropertyL();
 PublishConnState(EDisconnectedFromHost);
 #ifdef MTP_CAPTURE_TEST_DATA
 // Running under debug capture mode save this request off to disk.
 iRequestLogger = CMTPRequestLogger::NewL();
 #endif
-__FLOG(_L8("ConstructL - Exit"));
+OstTraceFunctionExit0( CMTPCONNECTION_CONSTRUCTL_EXIT );
 }
 /**
 Initiates an MTP connection level protocol error recovery sequence. This
 sequence is invoked when a recoverable protocol error is detected that cannot
 @leave One of the system wide error codes, if a processing failure occurs.
 @see MTPErrorRecoveryComplete
 */
 void CMTPConnection::InitiateMTPErrorRecoveryL(const TMTPTypeRequest& aRequest, TUint16 aResponseCode)
 {
-__FLOG(_L8("InitiateMTPErrorRecoveryL - Entry"));
+OstTraceFunctionEntry0( CMTPCONNECTION_INITIATEMTPERRORRECOVERYL_ENTRY );
 // Populate error response.
 iResponse.Reset();
 iResponse.SetUint16(TMTPTypeResponse::EResponseCode, aResponseCode);
 iResponse.SetUint32(TMTPTypeResponse::EResponseSessionID, aRequest.Uint32(TMTPTypeRequest::ERequestSessionID));
 iResponse.SetUint32(TMTPTypeResponse::EResponseTransactionID, aRequest.Uint32(TMTPTypeRequest::ERequestTransactionID));
 // Set the connection state pending completion, and send the response.
 SetState(EStateErrorRecovery);
 iTransportConnection->SendResponseL(iResponse, aRequest);
-__FLOG(_L8("InitiateMTPErrorRecoveryL - Exit"));
+OstTraceFunctionExit0( CMTPCONNECTION_INITIATEMTPERRORRECOVERYL_EXIT );
 }
 /**
 Concludes an MTP connection level protocol error recovery sequence.
 @see InitiateMTPErrorRecoveryL
 */
 void CMTPConnection::MTPErrorRecoveryComplete()
 {
-__FLOG(_L8("MTPErrorRecoveryComplete - Entry"));
+OstTraceFunctionEntry0( CMTPCONNECTION_MTPERRORRECOVERYCOMPLETE_ENTRY );
 SetState(EStateOpen);
 PublishConnState(EConnectedToHost);
-__FLOG(_L8("MTPErrorRecoveryComplete - Exit"));
+OstTraceFunctionExit0( CMTPCONNECTION_MTPERRORRECOVERYCOMPLETE_EXIT );
 }
 /**
 Forces the immediate shutdown of the MTP connection. This is invoked when a
 protocol error is detected that cannot be recovered from, e.g. if an attempt
 is detected to initiate an MTP transaction before a previous transaction has
 concluded.
 */
 void CMTPConnection::UnrecoverableMTPError()
 {
-__FLOG(_L8("UnrecoverableMTPError - Entry"));
+OstTraceFunctionEntry0( CMTPCONNECTION_UNRECOVERABLEMTPERROR_ENTRY );
 SetState(EStateErrorShutdown);
 PublishConnState(EDisconnectedFromHost);
 iTransportConnection->CloseConnection();
-__FLOG(_L8("UnrecoverableMTPError - Exit"));
+OstTraceFunctionExit0( CMTPCONNECTION_UNRECOVERABLEMTPERROR_EXIT );
 }
 /**
 Signals the MTP connection transport to terminate any in-progress data phase
 processing on the specified session.
 @param aidx The sessions table index of the required session.
 @leave One of the system wide error codes, if a processing failure occurs.
 */
 void CMTPConnection::InitiateTransactionCancelL(TInt aIdx)
 {
-__FLOG(_L8("InitiateTransactionCancelL - Entry"));
+OstTraceFunctionEntry0( CMTPCONNECTION_INITIATETRANSACTIONCANCELL_ENTRY );
 // Initiate transport connection level termination of the active data phase.
 CMTPSession& session(*iSessions[aIdx]);
 switch (session.TransactionPhase())
 {
 case EResponsePhase:
 case EDataRToIPhase:
 iTransportConnection->SendDataCancelL(session.ActiveRequestL());
 break;
 }
-__FLOG(_L8("InitiateTransactionCancelL - Exit"));
+OstTraceFunctionExit0( CMTPCONNECTION_INITIATETRANSACTIONCANCELL_EXIT );
 }
 /**
 Provides a count of the number of sessions with transactions in-progress.
 */
 TUint CMTPConnection::ActiveSessions() const
 {
-__FLOG(_L8("ActiveSessions - Entry"));
+OstTraceFunctionEntry0( CMTPCONNECTION_ACTIVESESSIONS_ENTRY );
 TUint active(0);
 const TUint count(iSessions.Count());
 for (TUint i(0); (i < count); i++)
 {
 if (iSessions[i]->TransactionPhase() > EIdlePhase)
 {
 active++;
 }
 }
-__FLOG_VA((_L8("Active sessions = %d"), active));
+OstTrace1( TRACE_NORMAL, CMTPCONNECTION_ACTIVESESSIONS, "Active sessions = %d", active );
-__FLOG(_L8("ActiveSessions - Exit"));
+OstTraceFunctionExit0( CMTPCONNECTION_ACTIVESESSIONS_EXIT );
 return active;
 }
 /**
 Closes all sessions which have been opened on the connection.
 */
 void CMTPConnection::CloseAllSessions()
 {
-__FLOG(_L8("CloseAllSessions - Entry"));
+OstTraceFunctionEntry0( CMTPCONNECTION_CLOSEALLSESSIONS_ENTRY );
 TInt count = iSessions.Count();
-__FLOG_VA((_L8("Sessions number to be closed = %d"), count));
+OstTrace1( TRACE_NORMAL, CMTPCONNECTION_CLOSEALLSESSIONS, "Sessions number to be closed = %d", count );
 	for (TInt i(count - 1); i>=0; i--)
 		{
 		CloseSession(i);
 		}
-__FLOG(_L8("CloseAllSessions - Exit"));
+OstTraceFunctionExit0( CMTPCONNECTION_CLOSEALLSESSIONS_EXIT );
 }
 /**
 Closes the sessions with the specified session index.
 @param aIdx The session index.
 */
 void CMTPConnection::CloseSession(TUint aIdx)
 {
-__FLOG(_L8("CloseSession - Entry"));
+OstTraceFunctionEntry0( CMTPCONNECTION_CLOSESESSION_ENTRY );
-__FLOG_VA((_L8("Session index to be closed = %d"), aIdx));
+OstTrace1(TRACE_NORMAL, CMTPCONNECTION_CLOSESESSION, "Session index to be closed = %d", aIdx);
 CMTPSession* session(iSessions[aIdx]);
 TUint id(session->SessionMTPId());
 if (id != KMTPSessionNone)
 {
 // Delete the session object.
 iSessions.Remove(aIdx);
 delete session;
-__FLOG(_L8("CloseSession - Exit"));
+OstTraceFunctionExit0( CMTPCONNECTION_CLOSESESSION_EXIT );
 }
 /**
 Provides a reference to the session with the MTP connection assigned identifier
 specified in the supplied MTP dataset.
 Get the data receive result.
 @return the data recevice result.
 */
 EXPORT_C TInt CMTPConnection::GetDataReceiveResult() const
 	{
-	__FLOG(_L8("GetDataReceiveResult - Entry"));
+OstTraceFunctionEntry0( CMTPCONNECTION_GETDATARECEIVERESULT_ENTRY );
-__FLOG_VA((_L8("Data receive result = %d"), iDataReceiveResult));
+OstTrace1( TRACE_NORMAL, CMTPCONNECTION_GETDATARECEIVERESULT, "Data receive result = %d", iDataReceiveResult);
-__FLOG(_L8("GetDataReceiveResult - Exit"));
+OstTraceFunctionExit0( CMTPCONNECTION_GETDATARECEIVERESULT_EXIT );
 return iDataReceiveResult;
 	}
 /**
 Sets the MTP connection state variable.
 @param aState The new MTP connection state value.
 */
 void CMTPConnection::SetState(TUint aState)
 {
-__FLOG(_L8("SetState - Entry"));
+OstTraceFunctionEntry0( CMTPCONNECTION_SETSTATE_ENTRY );
-__FLOG_VA((_L8("Setting state = %d"), aState));
+OstTrace1( TRACE_NORMAL, CMTPCONNECTION_SETSTATE, "CMTPConnection::SetState;aState=%d", aState );
 iState = aState;
-__FLOG(_L8("SetState - Exit"));
+OstTraceFunctionExit0( CMTPCONNECTION_SETSTATE_EXIT );
 }
 /**
 Provide the current MTP connection state.
 @return The current MTP connection state.
 */
 TUint CMTPConnection::State() const
 {
-__FLOG(_L8("State - Entry"));
+OstTraceFunctionEntry0( CMTPCONNECTION_STATE_ENTRY );
-__FLOG_VA((_L8("State = %d"), iState));
+OstTrace1( TRACE_NORMAL, CMTPCONNECTION_STATE, "State = %d", iState);
-__FLOG(_L8("State - Exit"));
+OstTraceFunctionExit0( CMTPCONNECTION_STATE_EXIT );
 return iState;
 }
 /**
 Performs common validation processing for requests initiated from the data
 connection.
 @panic CMTPConnection 2 If the MTP transaction phase is invalid.
 */
 TBool CMTPConnection::ValidFrameworkRequest(CMTPSession* aSession, TUint aValidPhases, TRequestStatus* aStatus)
 {
-__FLOG(_L8("ValidFrameworkRequest - Entry"));
+OstTraceFunctionEntry0( CMTPCONNECTION_VALIDFRAMEWORKREQUEST_ENTRY );
 __ASSERT_ALWAYS((!aSession || (aSession->TransactionPhase() & aValidPhases)), Panic(EMTPPanicInvalidState));
 __ASSERT_ALWAYS((!aStatus || (!aSession->RequestPending())), Panic(EMTPPanicBusy));
 TBool ret(ETrue);
 switch (State())
 ret = EFalse;
 }
 break;
 }
-__FLOG(_L8("ValidFrameworkRequest - Exit"));
+OstTraceFunctionExit0( CMTPCONNECTION_VALIDFRAMEWORKREQUEST_EXIT );
 return ret;
 }
 void CMTPConnection::RemoveEventsForSession(TUint32 aMTPId)
 	{
-__FLOG(_L8("RemoveEventsForSession - Entry"));
+OstTraceFunctionEntry0( CMTPCONNECTION_REMOVEEVENTSFORSESSION_ENTRY );
 TSglQueIter<CMTPEventLink> iter(iEventQ);
 iter.SetToFirst();
 CMTPEventLink* link = NULL;
 			{
 			DequeueEvent(link);
 			}
 		}
-__FLOG(_L8("RemoveEventsForSession - Exit"));
+	OstTraceFunctionExit0( CMTPCONNECTION_REMOVEEVENTSFORSESSION_EXIT );
 	}
 void CMTPConnection::DequeueAllEvents()
 	{
 	TSglQueIter<CMTPEventLink> iter(iEventQ);
 * This method define and attach the property for publishing connection state
 *  events.
 */
 void CMTPConnection::DefineConnStatePropertyL()
 	{
+	OstTraceFunctionEntry0( CMTPCONNECTION_DEFINECONNSTATEPROPERTYL_ENTRY );
-	 __FLOG(_L8("DefineConnStatePropertyL - Entry"));
 	 RProcess process;
 	 TUid tSid = process.SecureId();
 	//Property can read by anyone who subscribe for it.
 	_LIT_SECURITY_POLICY_PASS(KAllowReadAll);
 	_LIT_SECURITY_POLICY_S0(KAllowWrite, (TSecureId )KMTPPublishConnStateCat);
 	TInt error = RProperty::Define(tSid, EMTPConnStateKey, RProperty::EInt, KAllowReadAll, KAllowReadAll);
 	if (KErrAlreadyExists != error)
 		{
-		User::LeaveIfError(error);
+LEAVEIFERROR(error, OstTrace1(TRACE_ERROR, CMTPCONNECTION_DEFINECONNSTATEPROPERTYL, "property define error! error code %d", error));
 		}
-	User::LeaveIfError(iProperty.Attach(tSid, EMTPConnStateKey, EOwnerThread));
+	LEAVEIFERROR(iProperty.Attach(tSid, EMTPConnStateKey, EOwnerThread),
-	__FLOG(_L8("DefineConnStatePropertyL - Exit"));
+	        OstTrace0(TRACE_ERROR, DUP1_CMTPCONNECTION_DEFINECONNSTATEPROPERTYL, "property attach error"));
+	OstTraceFunctionExit0( CMTPCONNECTION_DEFINECONNSTATEPROPERTYL_EXIT );
 	}
 /**
 * This method is to publish various connection state.
 */
 void CMTPConnection::PublishConnState(TMTPConnStateType aConnState)
 	{
-	__FLOG_VA((_L8("PublishConnState - Entry \n publishing state = %d"), (TInt)aConnState));
+OstTraceFunctionEntry0( CMTPCONNECTION_PUBLISHCONNSTATE_ENTRY);
+	OstTrace1( TRACE_NORMAL, CMTPCONNECTION_PUBLISHCONNSTATE, "publishing state = %d", (TInt)aConnState );
 	RProcess process;
 	TInt error = iProperty.Set(process.SecureId(), EMTPConnStateKey, (TInt)aConnState);
 	 __ASSERT_DEBUG((error == KErrNone), Panic(EMTPPanicPublishEvent));;
-	__FLOG(_L8("PublishConnState - Exit"));
+	 OstTraceFunctionExit0( CMTPCONNECTION_PUBLISHCONNSTATE_EXIT);
 	}
 /**
 * This method is used to publish the events based on the TransactionPhase.
 *
 */
 void CMTPConnection::ValidateAndPublishConnState(CMTPSession& aSession, TInt aState)
 	{
-	__FLOG_VA((_L8("ValidateAndPublishConnState - Entry \n publishing state = %d"), aState));
+OstTraceFunctionEntry0(CMTPCONNECTION_VALIDATEANDPUBLISHCONNSTATE_ENTRY);
+OstTrace1( TRACE_NORMAL, CMTPCONNECTION_VALIDATEANDPUBLISHCONNSTATE, "publishing state = %d", aState );
 	TMTPConnStateType conState = EConnectedToHost;
 	switch((TStates)aState)
 		{
 		  case EStateOpen:
 		  	{
 		  default:
 		  	conState = EConnectedToHost;
 		  break;
 		}
 	PublishConnState(conState);
-	__FLOG(_L8("ValidateAndPublishConnStateL - Exit"));
+	OstTraceFunctionExit0(CMTPCONNECTION_VALIDATEANDPUBLISHCONNSTATE_EXIT);
 	}
 void CMTPConnection::DisconnectionNotifyL()
 	{
 	iSingletons.DpController().NotifyDataProvidersL(EMTPDisconnected,this);

changeset 49	c20dd21d1eb4
parent 37	d9d8313203af