1 // Created by TraceCompiler 2.1.2

     2 // DO NOT EDIT, CHANGES WILL BE LOST

     3 

     4 #ifndef __BOOKMARKSPLUGINTRACES_H__

     5 #define __BOOKMARKSPLUGINTRACES_H__

     6 

     7 #define KOstTraceComponentID 0x2001a9d3

     8 

     9 #define CBOOKMARKSPLUGIN_STARTHARVESTINGL 0x860001

    10 #define DUP1_CBOOKMARKSPLUGIN_STARTHARVESTINGL 0x860002

    11 #define CBOOKMARKSPLUGIN_DELAYEDCALLBACKL 0x860003

    12 #define DUP1_CBOOKMARKSPLUGIN_DELAYEDCALLBACKL 0x860004

    13 #define DUP2_CBOOKMARKSPLUGIN_DELAYEDCALLBACKL 0x860005

    14 #define DUP3_CBOOKMARKSPLUGIN_DELAYEDCALLBACKL 0x860006

    15 #define CBOOKMARKSPLUGIN_GETDOMAINNAMEL 0x860007

    16 #define DUP1_CBOOKMARKSPLUGIN_GETDOMAINNAMEL 0x860008

    17 #define CBOOKMARKSPLUGIN_DOINDEXINGL 0x860009

    18 #define DUP1_CBOOKMARKSPLUGIN_DOINDEXINGL 0x86000a

    19 #define DUP2_CBOOKMARKSPLUGIN_DOINDEXINGL 0x86000b

    20 #define DUP3_CBOOKMARKSPLUGIN_DOINDEXINGL 0x86000c

    21 #define DUP4_CBOOKMARKSPLUGIN_DOINDEXINGL 0x86000d

    22 #define DUP5_CBOOKMARKSPLUGIN_DOINDEXINGL 0x86000e

    23 #define CBOOKMARKSPLUGIN_CREATEBOOKMARKSINDEXITEML 0x86000f

    24 #define DUP1_CBOOKMARKSPLUGIN_CREATEBOOKMARKSINDEXITEML 0x860010

    25 #define DUP2_CBOOKMARKSPLUGIN_CREATEBOOKMARKSINDEXITEML 0x860011

    26 #define CBOOKMARKSPLUGIN_HANDLEFAVOURITESDBEVENTL 0x860012

    27 #define DUP1_CBOOKMARKSPLUGIN_HANDLEFAVOURITESDBEVENTL 0x860013

    28 #define CBOOKMARKSPLUGIN_DOINDEXINGL_ENTRY 0x8a0001

    29 #define CBOOKMARKSPLUGIN_DOINDEXINGL_EXIT 0x8a0002

    30 

    31 

    32 inline TBool OstTraceGen2( TUint32 aTraceID, TInt aParam1, TInt aParam2 )

    33     {

    34     TBool retval = BTraceFiltered8( EXTRACT_GROUP_ID(aTraceID), EOstTraceActivationQuery, KOstTraceComponentID, aTraceID );

    35     if ( retval )

    36         {

    37         TUint8 data[ 8 ];

    38         TUint8* ptr = data;

    39         *( ( TInt* )ptr ) = aParam1;

    40         ptr += sizeof ( TInt );

    41         *( ( TInt* )ptr ) = aParam2;

    42         ptr += sizeof ( TInt );

    43         ptr -= 8;

    44         retval = OstSendNBytes( EXTRACT_GROUP_ID(aTraceID), EOstTrace, KOstTraceComponentID, aTraceID, ptr, 8 );

    45         }

    46     return retval;

    47     }

    48 

    49 inline TBool OstTraceGen2( TUint32 aTraceID, TInt32 aParam1, TInt32 aParam2 )

    50     {

    51     TBool retval = BTraceFiltered8( EXTRACT_GROUP_ID(aTraceID), EOstTraceActivationQuery, KOstTraceComponentID, aTraceID );

    52     if ( retval )

    53         {

    54         TUint8 data[ 8 ];

    55         TUint8* ptr = data;

    56         *( ( TInt* )ptr ) = aParam1;

    57         ptr += sizeof ( TInt );

    58         *( ( TInt* )ptr ) = aParam2;

    59         ptr += sizeof ( TInt );

    60         ptr -= 8;

    61         retval = OstSendNBytes( EXTRACT_GROUP_ID(aTraceID), EOstTrace, KOstTraceComponentID, aTraceID, ptr, 8 );

    62         }

    63     return retval;

    64     }

    65 

    66 

    67 #ifndef __KERNEL_MODE__

    68 inline TBool OstTraceGen1( TUint32 aTraceID, const TDesC16& aParam1 )

    69     {

    70     TBool retval;

    71     TInt size = aParam1.Size();

    72     // BTrace assumes that parameter size is atleast 4 bytes

    73     if (size % 4 == 0)

    74         {

    75         TUint8* ptr = ( TUint8* )aParam1.Ptr();

    76         // Data is written directly and length is determined from trace message length

    77         retval = OstSendNBytes( EXTRACT_GROUP_ID(aTraceID), EOstTrace, KOstTraceComponentID, aTraceID, ptr, size );

    78         }

    79     else

    80         {

    81         TUint8 data[ KOstMaxDataLength ];

    82         TUint8* ptr = data;

    83         if (size > KOstMaxDataLength)

    84             {

    85             size = KOstMaxDataLength;

    86             }

    87         TInt sizeAligned = ( size + 3 ) & ~3;

    88         memcpy( ptr, aParam1.Ptr(), size );

    89         ptr += size;

    90         // Fillers are written to get 32-bit alignment

    91         while ( size++ < sizeAligned )

    92             {

    93             *ptr++ = 0;

    94             }

    95         ptr -= sizeAligned;

    96         size = sizeAligned;

    97         // Data is written directly and length is determined from trace message length

    98         retval = OstSendNBytes( EXTRACT_GROUP_ID(aTraceID), EOstTrace, KOstTraceComponentID, aTraceID, ptr, size );

    99         }

   100     return retval;

   101     }

   102 #endif

   103 

   104 

   105 #ifndef __KERNEL_MODE__

   106 inline TBool OstTraceGen2( TUint32 aTraceID, const TDesC16& aParam1, const TDesC16& aParam2 )

   107     {

   108     TBool retval = BTraceFiltered8( EXTRACT_GROUP_ID(aTraceID), EOstTraceActivationQuery, KOstTraceComponentID, aTraceID );

   109     if ( retval )

   110         {

   111         TInt length = 0;

   112         // Check that parameter lenght is not too long

   113         TInt length1 = aParam1.Size();

   114         if ((length + length1 + sizeof ( TUint32 )) > KOstMaxDataLength)

   115             {

   116             length1 = KOstMaxDataLength - (length + sizeof ( TUint32 ));

   117             }

   118         TInt lengthAligned1 = ( length1 + 3 ) & ~3;

   119         if (lengthAligned1 > 0)

   120             {

   121             length = length + sizeof ( TUint32 ) + lengthAligned1;

   122             }

   123         // Check that parameter lenght is not too long

   124         TInt length2 = aParam2.Size();

   125         if ((length + length2 + sizeof ( TUint32 )) > KOstMaxDataLength)

   126             {

   127             length2 = KOstMaxDataLength - (length + sizeof ( TUint32 ));

   128             }

   129         TInt lengthAligned2 = ( length2 + 3 ) & ~3;

   130         if (lengthAligned2 > 0)

   131             {

   132             length = length + sizeof ( TUint32 ) + lengthAligned2;

   133             }

   134         TUint8 data[ KOstMaxDataLength ];

   135         TUint8* ptr = data;

   136         // Set length to zero and calculate it againg

   137         // when adding parameters

   138         length = 0;

   139         if (length1 > 0)

   140             {

   141             // Number of elements is written before data

   142             // In case of Unicode string, number of elements is half of length

   143             *( ( TUint32* )ptr ) = length1 / (aParam1.Size() / aParam1.Length());

   144             ptr += sizeof ( TUint32 );

   145             memcpy( ptr, aParam1.Ptr(), length1 );

   146             ptr += length1;

   147             // Fillers are written to get 32-bit alignment

   148             while ( length1++ < lengthAligned1 )

   149                 {

   150                 *ptr++ = 0;

   151                 }

   152             length += sizeof ( TUint32 ) + lengthAligned1;

   153             }

   154         else if (length + sizeof ( TUint32 ) <= KOstMaxDataLength)

   155             {

   156             *( ( TUint32* )ptr ) = 0;

   157             ptr += sizeof ( TUint32 );

   158             length += sizeof ( TUint32 );

   159             }

   160         if (length2 > 0)

   161             {

   162             // Number of elements is written before data

   163             // In case of Unicode string, number of elements is half of length

   164             *( ( TUint32* )ptr ) = length2 / (aParam2.Size() / aParam2.Length());

   165             ptr += sizeof ( TUint32 );

   166             memcpy( ptr, aParam2.Ptr(), length2 );

   167             ptr += length2;

   168             // Fillers are written to get 32-bit alignment

   169             while ( length2++ < lengthAligned2 )

   170                 {

   171                 *ptr++ = 0;

   172                 }

   173             length += sizeof ( TUint32 ) + lengthAligned2;

   174             }

   175         else if (length + sizeof ( TUint32 ) <= KOstMaxDataLength)

   176             {

   177             *( ( TUint32* )ptr ) = 0;

   178             ptr += sizeof ( TUint32 );

   179             length += sizeof ( TUint32 );

   180             }

   181         ptr -= length;

   182         retval = OstSendNBytes( EXTRACT_GROUP_ID(aTraceID), EOstTrace, KOstTraceComponentID, aTraceID, ptr, length );

   183         }

   184     return retval;

   185     }

   186 #endif

   187 

   188 

   189 #endif

   190 

   191 // End of file

   192