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

equal deleted inserted replaced

-:2c19c7cf5550
+:c20dd21d1eb4
 */
 #include <mtp/mtpprotocolconstants.h>
 #include "cmtpsession.h"
+#include "mtpdebug.h"
+#include "OstTraceDefinitions.h"
+#ifdef OST_TRACE_COMPILER_IN_USE
+#include "cmtpsessionTraces.h"
+#endif
 // Class constants.
-__FLOG_STMT(_LIT8(KComponent,"Session");)
 #ifdef _DEBUG
 /**
 CMTPSession panics
 /**
 Destructor.
 */
 CMTPSession::~CMTPSession()
 {
-__FLOG(_L8("~CMTPSession - Entry"));
+OstTraceFunctionEntry0( CMTPSESSION_CMTPSESSION_DES_ENTRY );
 iRoutingRegistrations.Close();
-__FLOG(_L8("~CMTPSession - Exit"));
+OstTraceFunctionExit0( CMTPSESSION_CMTPSESSION_DES_EXIT );
-__FLOG_CLOSE;
 }
 /**
 Provides the next expected TransactionID. Transaction IDs are assigned
 in incremental sequence by the MTP initiator in the range 0x00000001 to
 0xFFFFFFFE.
 @return The next TransactionID expected on the session.
 */
 TUint32 CMTPSession::ExpectedTransactionId() const
 {
-__FLOG(_L8("ExpectedTransactionId - Entry"));
+OstTraceFunctionEntry0( CMTPSESSION_EXPECTEDTRANSACTIONID_ENTRY );
-__FLOG_VA((_L8("iExpectedTransactionId = 0x%08X"), iExpectedTransactionId));
+OstTrace1(TRACE_NORMAL, CMTPSESSION_EXPECTEDTRANSACTIONID,
-__FLOG(_L8("ExpectedTransactionId - Exit"));
+"iExpectedTransactionId = 0x%08X", iExpectedTransactionId);
+OstTraceFunctionExit0( CMTPSESSION_EXPECTEDTRANSACTIONID_EXIT );
 return iExpectedTransactionId;
 }
 /**
 Increments the next expected TransactionID to the next value in the sequence.
 TransactionIDs are assigned by the MTP initiator starting from 0x00000001.
 When the TransactionID increments to 0xFFFFFFFF it wraps back to 0x00000001.
 */
 void CMTPSession::IncrementExpectedTransactionId()
 {
-__FLOG(_L8("IncrementExpectedTransactionId - Entry"));
+OstTraceFunctionEntry0( CMTPSESSION_INCREMENTEXPECTEDTRANSACTIONID_ENTRY );
 if (++iExpectedTransactionId == KMTPTransactionIdLast)
 {
 iExpectedTransactionId = KMTPTransactionIdFirst;
 }
-__FLOG_VA((_L8("iExpectedTransactionId = 0x%08X"), iExpectedTransactionId));
+OstTrace1(TRACE_NORMAL, CMTPSESSION_INCREMENTEXPECTEDTRANSACTIONID,
-__FLOG(_L8("IncrementExpectedTransactionId - Exit"));
+"iExpectedTransactionId = 0x%08X", iExpectedTransactionId);
+OstTraceFunctionExit0( CMTPSESSION_INCREMENTEXPECTEDTRANSACTIONID_EXIT );
 }
 /**
 Sets or resets the session's active transaction request dataset. The active
 transaction request dataset should only be set at the start of the transaction
 (ERequestPhase), and reset and the end of the transaction (ECompletingPhase).
 @param aRequest The active transaction request dataset.
 */
 void CMTPSession::SetActiveRequestL(const TMTPTypeRequest& aRequest)
 {
-__FLOG(_L8("SetActiveRequestL - Entry"));
+OstTraceFunctionEntry0( CMTPSESSION_SETACTIVEREQUESTL_ENTRY );
 MMTPType::CopyL(aRequest, iActiveRequest);
-__FLOG(_L8("SetActiveRequestL - Exit"));
+OstTraceFunctionExit0( CMTPSESSION_SETACTIVEREQUESTL_EXIT );
 }
 /**
 Sets the session's transaction phase state variable.
 @param aPhase The new transaction phase state value.
 */
 void CMTPSession::SetTransactionPhase(TMTPTransactionPhase aPhase)
 {
-__FLOG(_L8("SetTransactionPhase - Entry"));
+OstTraceFunctionEntry0( CMTPSESSION_SETTRANSACTIONPHASE_ENTRY );
 iTransactionPhase = aPhase;
-__FLOG_VA((_L8("iTransactionPhase = 0x%08X"), iTransactionPhase));
+OstTrace1(TRACE_NORMAL, CMTPSESSION_SETTRANSACTIONPHASE,
-__FLOG(_L8("SetTransactionPhase - Exit"));
+"iTransactionPhase = 0x%08X", iTransactionPhase);
+OstTraceFunctionExit0( CMTPSESSION_SETTRANSACTIONPHASE_EXIT );
 }
 /**
 Provides the current MTP transaction state for the session.
 @return The MTP transaction state for the session.
 */
 TMTPTransactionPhase CMTPSession::TransactionPhase() const
 {
-__FLOG(_L8("TransactionPhase - Entry"));
+OstTraceFunctionEntry0( CMTPSESSION_TRANSACTIONPHASE_ENTRY );
-__FLOG_VA((_L8("iTransactionPhase = 0x%08X"), iTransactionPhase));
+OstTrace1(TRACE_NORMAL, CMTPSESSION_TRANSACTIONPHASE,
-__FLOG(_L8("TransactionPhase - Exit"));
+"iTransactionPhase = 0x%08X", iTransactionPhase);
+	OstTraceFunctionExit0( CMTPSESSION_TRANSACTIONPHASE_EXIT );
 	return  iTransactionPhase;
 }
 TInt CMTPSession::RouteRequest(const TMTPTypeRequest& aRequest)
 {
-__FLOG(_L8("RouteRequest - Entry"));
+OstTraceFunctionEntry0( CMTPSESSION_ROUTEREQUEST_ENTRY );
 TInt ret(KErrNotFound);
 // Attempt to match the request to existing registrations.
 TInt idx(iRoutingRegistrations.FindInOrder(aRequest, CMTPSession::RouteRequestOrder));
 if (idx != KErrNotFound)
 */
 TUint16 op(aRequest.Uint16(TMTPTypeRequest::ERequestOperationCode));
 if ((op == EMTPOpCodeSendObject) ||
 (op == EMTPOpCodeTerminateOpenCapture))
 {
-__FLOG_VA((_L8("Unregistering follow-on request 0x%08X"), op));
+OstTrace1(TRACE_NORMAL, CMTPSESSION_ROUTEREQUEST,
+"Unregistering follow-on request 0x%08X", op);
 iRoutingRegistrations.Remove(idx);
 }
 }
-__FLOG_VA((_L8("DP ID = %d"), ret));
+OstTrace1(TRACE_NORMAL, DUP1_CMTPSESSION_ROUTEREQUEST,
-__FLOG(_L8("RouteRequest - Exit"));
+"DP ID = %d", ret);
+OstTraceFunctionExit0( CMTPSESSION_ROUTEREQUEST_EXIT );
 return ret;
 }
 void CMTPSession::RouteRequestRegisterL(const TMTPTypeRequest& aRequest, TInt aDpId)
 {
-__FLOG(_L8("RouteRequestRegisterL - Entry"));
+OstTraceFunctionEntry0( CMTPSESSION_ROUTEREQUESTREGISTERL_ENTRY );
 // Locate any pre-existing registration (which if found, will be overwritten).
 TInt idx(iRoutingRegistrations.FindInOrder(aRequest, CMTPSession::RouteRequestOrder));
 if (idx == KErrNotFound)
 {
 iRoutingRegistrations.InsertInOrderL(aRequest, CMTPSession::RouteRequestOrder);
-User::LeaveIfError(idx = iRoutingRegistrations.FindInOrder(aRequest, CMTPSession::RouteRequestOrder));
+LEAVEIFERROR(idx = iRoutingRegistrations.FindInOrder(aRequest, CMTPSession::RouteRequestOrder),
+OstTrace1( TRACE_ERROR, CMTPSESSION_ROUTEREQUESTREGISTERL, "can't find in routing registrations for request, dpId %d",  aDpId));
 }
 /*
 For convenience the DP ID is saved in the registered request, in the
 TransactionID element (which is unused for routing).
 */
 iRoutingRegistrations[idx].SetUint32(TMTPTypeRequest::ERequestTransactionID, aDpId);
-__FLOG(_L8("RouteRequestRegisterL - Exit"));
+OstTraceFunctionExit0( CMTPSESSION_ROUTEREQUESTREGISTERL_EXIT );
 }
 /**
 Indicates if a routing request is registered on the session with the
 specified MTP operation code.
 @return ETrue if a routing request with the specified MTP operation code is
 registered on the session, otherwise EFalse.
 */
 TBool CMTPSession::RouteRequestRegistered(TUint16 aOpCode) const
 {
-__FLOG(_L8("RouteRequestPending - Entry"));
+OstTraceFunctionEntry0( CMTPSESSION_ROUTEREQUESTREGISTERED_ENTRY );
-__FLOG(_L8("RouteRequestPending - Entry"));
+OstTraceFunctionExit0( CMTPSESSION_ROUTEREQUESTREGISTERED_EXIT );
 return (iRoutingRegistrations.Find(aOpCode, CMTPSession::RouteRequestMatchOpCode) != KErrNotFound);
 }
 void CMTPSession::RouteRequestUnregister(const TMTPTypeRequest& aRequest)
 {
-__FLOG(_L8("RouteRequestUnregister - Entry"));
+OstTraceFunctionEntry0( CMTPSESSION_ROUTEREQUESTUNREGISTER_ENTRY );
 TInt idx(iRoutingRegistrations.FindInOrder(aRequest, CMTPSession::RouteRequestOrder));
 if (idx != KErrNotFound)
 {
 iRoutingRegistrations.Remove(idx);
 }
-__FLOG(_L8("RouteRequestUnregister - Exit"));
+OstTraceFunctionExit0( CMTPSESSION_ROUTEREQUESTUNREGISTER_EXIT );
 }
 void CMTPSession::StorePendingEventL(const TMTPTypeEvent& aEvent)
 {
 MMTPType::CopyL(aEvent, iPendingEvent);
 completion code.
 @param aErr The asynchronous request completion request.
 */
 void CMTPSession::CompletePendingRequest(TInt aErr)
 {
-__FLOG(_L8("CompletePendingRequest - Entry"));
+OstTraceFunctionEntry0( CMTPSESSION_COMPLETEPENDINGREQUEST_ENTRY );
 if (iRequestStatus != NULL)
 {
 __ASSERT_DEBUG(*iRequestStatus == KRequestPending, Panic(EMTPPanicStraySignal));
 User::RequestComplete(iRequestStatus, aErr);
 }
-__FLOG(_L8("CompletePendingRequest - Exit"));
+OstTraceFunctionExit0( CMTPSESSION_COMPLETEPENDINGREQUEST_EXIT );
 }
 /**
 Indicates if an asynchronous request is currently pending.
 Set the status to complete for the currently pending asynchronous request.
 @param aStatus The asynchronous request status to complete.
 */
 void CMTPSession::SetRequestPending(TRequestStatus& aStatus)
 {
-__FLOG(_L8("SetRequestPending - Entry"));
+OstTraceFunctionEntry0( CMTPSESSION_SETREQUESTPENDING_ENTRY );
 __ASSERT_DEBUG(!iRequestStatus, Panic(EMTPPanicBusy));
 iRequestStatus = &aStatus;
 *iRequestStatus = KRequestPending;
-__FLOG(_L8("SetRequestPending - Exit"));
+OstTraceFunctionExit0( CMTPSESSION_SETREQUESTPENDING_EXIT );
 }
 const TMTPTypeRequest& CMTPSession::ActiveRequestL() const
 {
-__FLOG(_L8("ActiveRequestL - Entry"));
+OstTraceFunctionEntry0( CMTPSESSION_ACTIVEREQUESTL_ENTRY );
 if (iTransactionPhase == EIdlePhase)
 {
+OstTrace0( TRACE_ERROR, CMTPSESSION_ACTIVEREQUESTL, "transaction in EIdlePhase!" );
 User::Leave(KErrNotFound);
 }
-__FLOG(_L8("ActiveRequestL - Exit"));
+OstTraceFunctionExit0( CMTPSESSION_ACTIVEREQUESTL_EXIT );
 return iActiveRequest;
 }
 TUint32 CMTPSession::SessionMTPId() const
 {
-__FLOG(_L8("SessionMTPId - Entry"));
+OstTraceFunctionEntry0( CMTPSESSION_SESSIONMTPID_ENTRY );
-__FLOG_VA( (_L8("Session MTP ID = %d"), iIdMTP) );
+OstTrace1(TRACE_NORMAL, CMTPSESSION_SESSIONMTPID, "Session MTP ID = %d", iIdMTP);
-__FLOG(_L8("SessionMTPId - Exit"));
+OstTraceFunctionExit0( CMTPSESSION_SESSIONMTPID_EXIT );
 return iIdMTP;
 }
 TUint CMTPSession::SessionUniqueId() const
 {
-__FLOG(_L8("SessionUniqueId - Entry"));
+OstTraceFunctionEntry0( CMTPSESSION_SESSIONUNIQUEID_ENTRY );
-__FLOG(_L8("SessionUniqueId - Exit"));
+OstTraceFunctionExit0( CMTPSESSION_SESSIONUNIQUEID_EXIT );
 return iIdUnique;
 }
 TAny* CMTPSession::GetExtendedInterface(TUid /*aInterfaceUid*/)
 {
-__FLOG(_L8("GetExtendedInterface - Entry"));
+OstTraceFunctionEntry0( CMTPSESSION_GETEXTENDEDINTERFACE_ENTRY );
-__FLOG(_L8("GetExtendedInterface - Exit"));
+OstTraceFunctionExit0( CMTPSESSION_GETEXTENDEDINTERFACE_EXIT );
 return NULL;
 }
 /**
 Constructor.
 }
 void CMTPSession::ConstructL()
 {
-__FLOG_OPEN(KMTPSubsystem, KComponent);
+OstTraceFunctionEntry0( CMTPSESSION_CONSTRUCTL_ENTRY );
-__FLOG(_L8("ConstructL - Entry"));
+OstTraceFunctionExit0( CMTPSESSION_CONSTRUCTL_EXIT );
-__FLOG(_L8("ConstructL - Exit"));
 }
 TBool CMTPSession::RouteRequestMatchOpCode(const TUint16* aOpCode, const TMTPTypeRequest& aRequest)
 {
 return (aRequest.Uint16(TMTPTypeRequest::ERequestOperationCode) == *aOpCode);

changeset 49	c20dd21d1eb4
parent 0	d0791faffa3f