diff -r e16d72588c28 -r 8a03a285ab14 omadrm/drmengine/ro/src/DRMConstraint.cpp
--- a/omadrm/drmengine/ro/src/DRMConstraint.cpp	Fri Mar 12 15:43:46 2010 +0200
+++ b/omadrm/drmengine/ro/src/DRMConstraint.cpp	Mon Mar 15 12:41:43 2010 +0200
@@ -19,18 +19,18 @@
 // INCLUDE FILES
 #include <s32strm.h>
 #include <s32mem.h>
-#include "DRMConstraint.h"
+#include "DrmConstraint.h"
 
 // CONSTANTS
 
 // Synchronizing marker in the beginning of the stream in order to synchronize
-// to an externalized Constraint object having the new structure.  
+// to an externalized Constraint object having the new structure.
 const TInt32 KSyncMark = 0xAFCE;
 
 // Old and new version number of the Constraint object
 const TInt8 KVersion3_2_0 = 0;
-const TInt8 KVersion3_2_1 = 1; 
-   
+const TInt8 KVersion3_2_1 = 1;
+
 const TInt KSanityDataLengthLow = 0;
 const TInt KSanityDataLengthHigh = 32768;
 
@@ -55,17 +55,17 @@
 // Appends the strings of array aFrom to array aTo
 // -----------------------------------------------------------------------------
 //
-LOCAL_C void AppendToArrayL( RPointerArray<HBufC8>& aTo, 
+LOCAL_C void AppendToArrayL( RPointerArray<HBufC8>& aTo,
                              const RPointerArray<HBufC8>& aFrom )
     {
     HBufC8* addData = NULL;
-    
+
     for( TInt i = 0; i < aFrom.Count(); i++ )
         {
         addData = aFrom[i]->AllocLC();
         aTo.AppendL( addData );
-        CleanupStack::Pop( addData ); 
-        }    
+        CleanupStack::Pop( addData );
+        }
     }
 
 // -----------------------------------------------------------------------------
@@ -76,13 +76,13 @@
 LOCAL_C TInt CountArrayStoreSize( const RPointerArray<HBufC8>& aArray )
     {
     TInt size = 0;
-    
+
     for(TInt i = 0; i < aArray.Count(); i++ )
         {
         size += sizeof(TInt);
         size += aArray[i]->Size();
         }
-    return size;    
+    return size;
     }
 // -----------------------------------------------------------------------------
 // WriteArrayToStreamL
@@ -98,12 +98,12 @@
         aStream.WriteL( aArray[i]->Des() );
         }
     }
-    
+
 // -----------------------------------------------------------------------------
 // ReadArrayFromStringL
 // Reads the array from the string
 // -----------------------------------------------------------------------------
-//    
+//
 LOCAL_C void ReadArrayFromStringL( const TDesC8& aString,
                                    RPointerArray<HBufC8>& aArray )
     {
@@ -112,29 +112,29 @@
     HBufC8* addData = NULL;
     TPtr8 dataBuffer(NULL,0,0);
     CleanupClosePushL( inRead );
-    
-    
+
+
     aArray.ResetAndDestroy();
-    
-    
+
+
     for( TInt i = 0; i < aString.Size();)
         {
-        // If there is not enough data to read the integer 
+        // If there is not enough data to read the integer
         // it means that it's an old version and the whole thing is the
-        // string since in previous versions only one string is stored        
+        // string since in previous versions only one string is stored
         if(( aString.Size() - i) < sizeof(TInt) )
             {
             aArray.ResetAndDestroy();
             addData = aString.AllocLC();
             aArray.AppendL( addData );
             CleanupStack::Pop();
-            CleanupStack::PopAndDestroy(); // inRead              
-            return;            
+            CleanupStack::PopAndDestroy(); // inRead
+            return;
             }
-        
+
         size = inRead.ReadInt32L();
         i += sizeof(TInt);
-        
+
         // If the size is negative or the size left is not large enough
         // it means that it's an old version and the whole thing is the
         // string since in previous versions only one string is stored.
@@ -144,35 +144,35 @@
             addData = aString.AllocLC();
             aArray.AppendL( addData );
             CleanupStack::Pop();
-            CleanupStack::PopAndDestroy(); // inRead            
+            CleanupStack::PopAndDestroy(); // inRead
             return;
             }
-        addData = HBufC8::NewMaxLC( size );    
+        addData = HBufC8::NewMaxLC( size );
 
         // Set the read buffer:
         dataBuffer.Set(const_cast<TUint8*>(addData->Ptr()), 0, size);
-        
+
         // Read the data:
         inRead.ReadL( dataBuffer );
-        
+
         aArray.AppendL( addData );
         CleanupStack::Pop( addData );
 
         i += size;
         }
-    CleanupStack::PopAndDestroy();    
+    CleanupStack::PopAndDestroy();
     return;
     }
-    
+
 // -----------------------------------------------------------------------------
 // IsIndividualConstraintValid
 // -----------------------------------------------------------------------------
 //
-LOCAL_C TBool IsIndividualConstraintValid( const RPointerArray<HBufC8>& aConstraint, 
+LOCAL_C TBool IsIndividualConstraintValid( const RPointerArray<HBufC8>& aConstraint,
                                            const RPointerArray<HBufC8>& aValidConstraints)
     {
     TInt retVal = 0;
-    
+
     for( TInt i = 0; i < aConstraint.Count(); i++ )
         {
         for( TInt j = 0; j < aValidConstraints.Count(); j++ )
@@ -184,7 +184,7 @@
                 }
             }
         }
-    return EFalse;    
+    return EFalse;
     };
 
 // ============================ MEMBER FUNCTIONS ===============================
@@ -200,8 +200,8 @@
     CDRMConstraint* self = new( ELeave ) CDRMConstraint();
     CleanupStack::PushL( self );
     self->ConstructL();
-    
-    return self;    
+
+    return self;
     };
 
 // -----------------------------------------------------------------------------
@@ -213,9 +213,9 @@
     {
     CDRMConstraint* self = NewLC();
     CleanupStack::Pop();
-    
+
     return self;
-    }; 
+    };
 
 // -----------------------------------------------------------------------------
 // Default Constructor - First phase.
@@ -224,8 +224,8 @@
 //
 EXPORT_C CDRMConstraint::CDRMConstraint() :
     iSyncMark( KSyncMark ),
-    iVersion( KVersion3_2_1 ), // Version number for differentiation 
-                               // in InternalizeL. 
+    iVersion( KVersion3_2_1 ), // Version number for differentiation
+                               // in InternalizeL.
     iStartTime( Time::NullTTime() ),
     iEndTime( Time::NullTTime() ),
     iIntervalStart( Time::NullTTime() ),
@@ -233,38 +233,38 @@
     iCounter( 0 ),
     iOriginalCounter( 0 ),
     iTimedCounter( 0 ),
-	iTimedInterval( 0 ),
-	iAccumulatedTime( 0 ),
-	iVendorId( TUid::Null() ),
-	iSecureId( TUid::Null() ),
+    iTimedInterval( 0 ),
+    iAccumulatedTime( 0 ),
+    iVendorId( TUid::Null() ),
+    iSecureId( TUid::Null() ),
     iActiveConstraints( 0 ),
     iDrmMeteringInfo( NULL ),
-    iOriginalTimedCounter( 0 ) 
+    iOriginalTimedCounter( 0 )
     {
     }
-    
+
 // -----------------------------------------------------------------------------
 // Destructor
 // -----------------------------------------------------------------------------
-// 
+//
 EXPORT_C CDRMConstraint::~CDRMConstraint()
     {
 
     iIndividual.ResetAndDestroy();
     iIndividual.Close();
-    
+
     iSystem.ResetAndDestroy();
-    iSystem.Close(); 
-            
-#ifdef RD_DRM_METERING       
+    iSystem.Close();
+
+#ifdef RD_DRM_METERING
     if( iDrmMeteringInfo )
         {
         delete iDrmMeteringInfo;
         iDrmMeteringInfo = NULL;
         }
 #endif
-        
-    }; 
+
+    };
 
 // -----------------------------------------------------------------------------
 // CDRMConstraint::ExternalizeL
@@ -272,43 +272,43 @@
 //
 EXPORT_C void CDRMConstraint::ExternalizeL( RWriteStream& aStream ) const
     {
-    
+
     // used for the buffers
     TInt32 dataLength = 0;
-    
+
     // write the synchronizing marker
     aStream.WriteInt32L( iSyncMark );
-    
+
     // Write the version number
     aStream.WriteInt32L( iVersion );
-    
+
     // Write the start time
     WriteInt64L( iStartTime.Int64(), aStream );
-    
+
     // Write the end time
     WriteInt64L( iEndTime.Int64(), aStream );
-    
+
     // Write the interval start time
-    WriteInt64L( iIntervalStart.Int64(), aStream ); 
-    
-    // Write the interval   
+    WriteInt64L( iIntervalStart.Int64(), aStream );
+
+    // Write the interval
     aStream.WriteInt32L( iInterval.Int() );
-    
+
     // Write the counter
     aStream.WriteInt32L( iCounter );
-    
+
     // Write the original counter
     aStream.WriteInt32L( iOriginalCounter );
-    
+
     // Write the timed counter
     aStream.WriteInt32L( iTimedCounter );
 
     // Write the timed interval
     aStream.WriteInt32L( iTimedInterval.Int() );
-    
+
     // Write the accumulated time
     aStream.WriteInt32L( iAccumulatedTime.Int() );
-    
+
     // Write the individual
     dataLength = 0;
     if ( iIndividual.Count() )
@@ -319,58 +319,58 @@
 
     if ( dataLength )
         {
-        WriteArrayToStreamL( aStream, iIndividual );       
-        }         
-    
+        WriteArrayToStreamL( aStream, iIndividual );
+        }
+
     // Software Vendor Id
     aStream.WriteInt32L( iVendorId.iUid );
-    
+
     // Secure Id of the allowed application
     aStream.WriteInt32L( iSecureId.iUid );
-    
+
     // Active constraints
     aStream.WriteUint32L( iActiveConstraints );
-    
+
     // Metering info
-#ifdef RD_DRM_METERING    
+#ifdef RD_DRM_METERING
     dataLength = 0;
     if ( iDrmMeteringInfo )
         {
         dataLength = sizeof( TTimeIntervalSeconds ) + sizeof( TUint8 );
         }
-    
+
     aStream.WriteInt32L( dataLength );
-    
+
     if ( dataLength )
         {
         aStream.WriteInt32L( iDrmMeteringInfo->iGraceTime.Int() );
         aStream.WriteInt8L( iDrmMeteringInfo->iAllowUseWithoutMetering );
         }
-   
+
 #endif
-    
+
     // Write the system
     dataLength = 0;
     if ( iSystem.Count() )
         {
         dataLength = CountArrayStoreSize( iSystem );
         }
-    
+
     aStream.WriteInt32L( dataLength );
-        
+
     if ( dataLength )
         {
         WriteArrayToStreamL( aStream, iSystem );
         }
-            
+
     // write the original timed counter
     aStream.WriteInt32L( iOriginalTimedCounter );
-        
+
     // For future use
     aStream.WriteInt32L( 0 );
-    
+
     };
-    
+
 // -----------------------------------------------------------------------------
 // CDRMConstraint::InternalizeL
 // -----------------------------------------------------------------------------
@@ -380,271 +380,271 @@
 
     TInt64 timeData = 0;
     TInt32 temp = 0;
-    
+
     // used for the buffers
     TInt dataLength = 0;
     HBufC8* dataPart = NULL;
     TPtr8 dataBuffer(NULL,0,0);
-    
+
     // Read the (possible) synchronizing marker.
     iSyncMark = aStream.ReadInt32L();
-    
+
     if ( iSyncMark != KSyncMark )
         {
-         
+
         // The structure of the externalized Permission object is the old one.
         // The first four bytes constitute half of the eight bytes of Start time.
-        // Read another four bytes from the stream (and apply bit modifications) 
+        // Read another four bytes from the stream (and apply bit modifications)
         // in order to reconstruct the Start time (iStartTime).
         temp = aStream.ReadInt32L();
-        
+
         timeData = temp;
         timeData <<= 32;
-        
+
         Mem::Copy( &timeData, &iSyncMark, sizeof(TInt32) );
-        
+
         iStartTime = timeData;
         timeData = 0;
-         
-        // The version is marked as old version for differentiation in 
+
+        // The version is marked as old version for differentiation in
         // InternalizeL.
         iVersion = KVersion3_2_0;
-                             
+
         }
-    else 
+    else
         {
         // The structure of the externalized Permission object is the new one.
-        // Read the version and Start time.    
+        // Read the version and Start time.
         iVersion = aStream.ReadInt32L();
-        
+
         // Read the start time
         ReadInt64L( timeData, aStream );
         iStartTime = timeData;
-        
+
         }
-     
+
     // Read the end time
     ReadInt64L( timeData, aStream );
     iEndTime = timeData;
-    
+
     // Read the interval start time
-    ReadInt64L( timeData, aStream ); 
+    ReadInt64L( timeData, aStream );
     iIntervalStart = timeData;
-    
-    // Read the interval   
+
+    // Read the interval
     iInterval = aStream.ReadInt32L();
-    
+
     // Read the counter
     iCounter = aStream.ReadInt32L();
-    
+
     // Read the original counter
     iOriginalCounter = aStream.ReadInt32L();
-    
+
     // Read the timed counter
     iTimedCounter = aStream.ReadInt32L();
 
     // Read the timed interval
     iTimedInterval = aStream.ReadInt32L();
-    
+
     // Read the accumulated time
     iAccumulatedTime = aStream.ReadInt32L();
-    
+
     // Read the individual
     dataLength = aStream.ReadInt32L();
-    
+
     SanitizeL( dataLength );
-    
+
     if( dataLength > 0 )
         {
         // Reserve a new buffer:
         dataPart = HBufC8::NewMaxLC( dataLength );
-        
+
         // Set the read buffer:
         dataBuffer.Set(const_cast<TUint8*>(dataPart->Ptr()), 0, dataLength);
-        
+
         // Read the data:
         aStream.ReadL( dataBuffer );
-        
-        
+
+
         // Fill the array from the string
         ReadArrayFromStringL( dataBuffer, iIndividual);
-        
-        // Pop the buffer 
+
+        // Pop the buffer
         CleanupStack::PopAndDestroy(); // dataPart
-                    
+
         }
     else
         {
-        iIndividual.ResetAndDestroy();       
-        }           
-    
-    
-    // Read the system 
+        iIndividual.ResetAndDestroy();
+        }
+
+
+    // Read the system
     if ( iVersion == KVersion3_2_0 ) // Constraint has the old structure.
         {
-        
+
         dataLength = aStream.ReadInt32L();
-        
+
         SanitizeL( dataLength );
-        
+
         if( dataLength > 0 )
             {
             // Reserve a new buffer:
             dataPart = HBufC8::NewMaxLC( dataLength );
-        
+
             // Set the read buffer:
-            dataBuffer.Set( const_cast<TUint8*>(dataPart->Ptr()), 0, 
+            dataBuffer.Set( const_cast<TUint8*>(dataPart->Ptr()), 0,
                             dataLength );
-        
+
             // Read the data:
             aStream.ReadL( dataBuffer );
-        
-            // Pop the buffer 
+
+            // Pop the buffer
             CleanupStack::Pop(); // dataPart
-                
-            // If an old content identifier exists delete it        
+
+            // If an old content identifier exists delete it
+            if ( iSystem.Count() )
+                {
+                iSystem.ResetAndDestroy();
+                }
+
+            // assign the new content id
+            iSystem.AppendL( dataPart );
+            }
+        else
+            {
+            // If an old system exists delete it
             if ( iSystem.Count() )
                 {
                 iSystem.ResetAndDestroy();
                 }
-        
-            // assign the new content id
-            iSystem.AppendL( dataPart );    
             }
-        else
-            {
-            // If an old system exists delete it 
-            if ( iSystem.Count() )
-                {
-                iSystem.ResetAndDestroy();
-                }        
-            }  
         }
-    
+
     // Software Vendor Id
     iVendorId.iUid = aStream.ReadInt32L();
-    
+
     // Secure Id of the allowed application
-    iSecureId.iUid = aStream.ReadInt32L(); 
-    
+    iSecureId.iUid = aStream.ReadInt32L();
+
     // Active constraints
-    iActiveConstraints = aStream.ReadUint32L();    
+    iActiveConstraints = aStream.ReadUint32L();
 
-#ifdef RD_DRM_METERING    
-    
+#ifdef RD_DRM_METERING
+
     // Do not read metering information if the version
     // is the old one because Metering is not activated in it.
     if ( iVersion == KVersion3_2_1 )
         {
-        
+
         // Metering info
         dataLength = aStream.ReadInt32L();
-    
+
         SanitizeL( dataLength );
-        
+
         if( dataLength > 0 )
             {
-        
+
             if( !iDrmMeteringInfo )
                 {
                 // Reserve a new metering information instance
                 iDrmMeteringInfo = new (ELeave)TDrmMeteringInfo;
                 }
-            else 
+            else
                 {
                 iDrmMeteringInfo->iGraceTime = 0;
                 iDrmMeteringInfo->iAllowUseWithoutMetering = EFalse;
                 }
-        
-            // Read grace time 
+
+            // Read grace time
             iDrmMeteringInfo->iGraceTime = aStream.ReadInt32L();
-        
-            // Read whether content can be consumed without 
+
+            // Read whether content can be consumed without
             // metering being used
-            iDrmMeteringInfo->iAllowUseWithoutMetering = 
+            iDrmMeteringInfo->iAllowUseWithoutMetering =
                 aStream.ReadInt8L();
-           
+
             }
         else
             {
-        
-            // If old metering information exists delete it 
+
+            // If old metering information exists delete it
             if( iDrmMeteringInfo )
                 {
                 delete iDrmMeteringInfo;
                 iDrmMeteringInfo = NULL;
-                }        
+                }
             }
         }
-    
+
 #endif //RD_DRM_METERING
 
     // Read the system and original timed counter
     // according to the new structure.
     if ( iVersion == KVersion3_2_1 )
         {
-        
+
         dataLength = aStream.ReadInt32L();
-        
+
         SanitizeL( dataLength );
-            
+
         if( dataLength > 0 )
             {
             // Reserve a new buffer:
             dataPart = HBufC8::NewMaxLC( dataLength );
-        
+
             // Set the read buffer:
             dataBuffer.Set(const_cast<TUint8*>(dataPart->Ptr()), 0, dataLength);
-        
+
             // Read the data:
             aStream.ReadL( dataBuffer );
-        
+
             // Fill the array from the string
             ReadArrayFromStringL( dataBuffer, iSystem);
-        
-            // Pop the buffer 
+
+            // Pop the buffer
             CleanupStack::PopAndDestroy(); // dataPart
-                    
+
             }
         else
             {
-            iSystem.ResetAndDestroy();       
-            }         
-    
+            iSystem.ResetAndDestroy();
+            }
+
         // Read the original timed counter
         iOriginalTimedCounter = aStream.ReadInt32L();
-    
+
         // For future use or development, reads the data at the end of the stream
         dataLength = aStream.ReadInt32L();
-        
+
         SanitizeL( dataLength );
-        
+
         if ( dataLength > 0 )
             {
-      
+
             // Reserve a new buffer:
             dataPart = HBufC8::NewMaxLC( dataLength );
-        
+
             // Set the read buffer:
             dataBuffer.Set(const_cast<TUint8*>(dataPart->Ptr()), 0, dataLength);
-        
+
             // Read the data:
             aStream.ReadL( dataBuffer );
-        
-            // Pop the buffer 
+
+            // Pop the buffer
             CleanupStack::PopAndDestroy( dataPart );
             }
         }
-    
-    // Constraint can be considered to have the new structure from now on. 
-    if ( iVersion == KVersion3_2_0 ) 
+
+    // Constraint can be considered to have the new structure from now on.
+    if ( iVersion == KVersion3_2_0 )
         {
         iSyncMark = KSyncMark;
-        iVersion = KVersion3_2_1; 
+        iVersion = KVersion3_2_1;
         }
-    
+
     };
-    
+
 // -----------------------------------------------------------------------------
 // CDRMConstraint::Stateful
 // -----------------------------------------------------------------------------
@@ -654,35 +654,35 @@
     // counters, timed counters and accumulated are stateful
     if ( iActiveConstraints &  (EConstraintCounter |
                                EConstraintTimedCounter |
-                               EConstraintAccumulated ) ) 
+                               EConstraintAccumulated ) )
         {
         return ETrue;
         }
-        
+
      // Non-Activated interval is stateful
     if ( ( iActiveConstraints & EConstraintInterval ) &&
-        iIntervalStart == Time::NullTTime() ) 
+        iIntervalStart == Time::NullTTime() )
         {
         return ETrue;
         }
-        
+
     return EFalse;
     };
 
 // -----------------------------------------------------------------------------
 // CDRMConstraint::Size
 // -----------------------------------------------------------------------------
-//   
+//
 EXPORT_C TInt CDRMConstraint::Size() const
     {
     TInt size = 0;
-    
+
     // synchronizing marker
     size += sizeof(TInt32);
-    
+
     // version number
     size += sizeof(TInt32);
-    
+
     // usage start time
     size += sizeof(TTime);
 
@@ -702,13 +702,13 @@
     size += sizeof(TDRMCounter);
 
     // timed counter
-	size += sizeof(TDRMCounter);
+    size += sizeof(TDRMCounter);
 
     // Interval of the timed counter constraint
-	size += sizeof(TTimeIntervalSeconds);
+    size += sizeof(TTimeIntervalSeconds);
 
     // accumulated time
-	size += sizeof(TTimeIntervalSeconds);
+    size += sizeof(TTimeIntervalSeconds);
 
     // individual allowed usage
     size += sizeof(TInt32);
@@ -716,114 +716,114 @@
 
     // Software Vendor Id
     size += sizeof(TUid);
-    
+
     // Secure Id of the allowed application
     size += sizeof(TUid);
-	
-	// Bitmask of active constraints
+
+    // Bitmask of active constraints
     size += sizeof(TUint32);
-    
-#ifdef RD_DRM_METERING    
+
+#ifdef RD_DRM_METERING
     // Metering information
     size += sizeof(TInt32);
-    
+
     if (iDrmMeteringInfo)
         {
-        size += sizeof(TTimeIntervalSeconds); 
+        size += sizeof(TTimeIntervalSeconds);
         size += sizeof(TUint8);
         }
-    
+
 #endif //RD_DRM_METERING
-    
+
     // system allowed usage
     size += sizeof(TInt32);
     size += CountArrayStoreSize(iSystem);
-    
+
     // original timed counter value
     size += sizeof(TDRMCounter);
-    
+
     // For future use
     size += sizeof(TInt32);
-    
+
     return size;
-       
-    };    
+
+    };
 
 // -----------------------------------------------------------------------------
 // CDRMConstraint::Expired
 // -----------------------------------------------------------------------------
-//      
+//
 EXPORT_C TBool CDRMConstraint::Expired( const TTime& aTime ) const
     {
-	// Full Rights do not expire
-	if ( iActiveConstraints == EConstraintNone )
-		{
-		return EFalse;
-		}
+    // Full Rights do not expire
+    if ( iActiveConstraints == EConstraintNone )
+        {
+        return EFalse;
+        }
 
-	// First check counters, accumulated time and timed counters
-	// if any of these is expired the whole thing is expired regardless of the
-	// actual time based constrants or future rights
-	
+    // First check counters, accumulated time and timed counters
+    // if any of these is expired the whole thing is expired regardless of the
+    // actual time based constrants or future rights
+
     // Counters
-    if ( ( iActiveConstraints & EConstraintCounter ) && iCounter < 1 ) 
-    	{
-    	return ETrue;	
-    	}
-    		
-    // Accumulated time	
+    if ( ( iActiveConstraints & EConstraintCounter ) && iCounter < 1 )
+        {
+        return ETrue;
+        }
+
+    // Accumulated time
     if ( ( iActiveConstraints & EConstraintAccumulated ) && iAccumulatedTime.Int() == 0 )
-    	{
-    	return ETrue;
-    	}
-    		
+        {
+        return ETrue;
+        }
+
      // Timed Counters
-    if ( ( iActiveConstraints & EConstraintTimedCounter ) && iTimedCounter < 1 ) 
-    	{
-    	return ETrue;	
-    	} 
-    		
+    if ( ( iActiveConstraints & EConstraintTimedCounter ) && iTimedCounter < 1 )
+        {
+        return ETrue;
+        }
+
 
     // Dont check time based rights
     if ( aTime != Time::NullTTime() )
-    	{	
-    	
-    	// Check for activated intervals
-    	if ( ( iActiveConstraints & EConstraintInterval) && iIntervalStart != Time::NullTTime() )
-    		{
-        	TTimeIntervalSeconds current;
-        
-        	aTime.SecondsFrom( iIntervalStart, current );
-        
-        	if ( current >= iInterval )
-            	{
-            	return ETrue;
-            	}    			
-    		}
-    	
-    	// Check for end time
-    	if ( ( iActiveConstraints & EConstraintEndTime ) && aTime >= iEndTime )
-    		{
-    		return ETrue;	
-    		}	
-    		
-    	// Check for start time, future rights	
-    	if ( ( iActiveConstraints & EConstraintStartTime ) && aTime < iStartTime )
-    		{
-    		return EFalse;	
-    		}
-    	}
+        {
+
+        // Check for activated intervals
+        if ( ( iActiveConstraints & EConstraintInterval) && iIntervalStart != Time::NullTTime() )
+            {
+            TTimeIntervalSeconds current;
+
+            aTime.SecondsFrom( iIntervalStart, current );
+
+            if ( current >= iInterval )
+                {
+                return ETrue;
+                }
+            }
+
+        // Check for end time
+        if ( ( iActiveConstraints & EConstraintEndTime ) && aTime >= iEndTime )
+            {
+            return ETrue;
+            }
+
+        // Check for start time, future rights
+        if ( ( iActiveConstraints & EConstraintStartTime ) && aTime < iStartTime )
+            {
+            return EFalse;
+            }
+        }
 
     return EFalse;
     }
 // -----------------------------------------------------------------------------
 // CDRMConstraint::Merge
 // -----------------------------------------------------------------------------
-//      
+//
 EXPORT_C void CDRMConstraint::Merge( const CDRMConstraint& aConstraint )
     {
     TInt error = KErrNone;
-    
+
     if ( this != &aConstraint )
         {
         if ( aConstraint.iActiveConstraints & EConstraintStartTime )
@@ -838,7 +838,7 @@
                 iActiveConstraints |= EConstraintStartTime;
                 }
             }
-            
+
         if ( aConstraint.iActiveConstraints & EConstraintEndTime )
             {
             if ( iActiveConstraints & EConstraintEndTime )
@@ -851,7 +851,7 @@
                 iActiveConstraints |= EConstraintEndTime;
                 }
             }
-            
+
         if ( aConstraint.iActiveConstraints & EConstraintCounter )
             {
             if ( iActiveConstraints & EConstraintCounter )
@@ -866,7 +866,7 @@
                 iActiveConstraints |= EConstraintCounter;
                 }
             }
-        
+
         if ( aConstraint.iActiveConstraints & EConstraintInterval )
             {
             if ( iActiveConstraints & EConstraintInterval )
@@ -881,7 +881,7 @@
                 iActiveConstraints |= EConstraintInterval;
                 }
             }
-            
+
         if ( aConstraint.iActiveConstraints & EConstraintTimedCounter )
             {
             if ( iActiveConstraints & EConstraintTimedCounter )
@@ -899,7 +899,7 @@
                 iActiveConstraints |= EConstraintTimedCounter;
                 }
             }
-        
+
         if ( aConstraint.iActiveConstraints & EConstraintAccumulated )
             {
             if ( iActiveConstraints & EConstraintAccumulated )
@@ -912,20 +912,20 @@
                 iActiveConstraints |= EConstraintAccumulated;
                 }
             }
-             
+
         if( aConstraint.iActiveConstraints & EConstraintIndividual )
             {
             // Ignore the error since we don't return an error code or leave
             TRAP( error, AppendToArrayL( iIndividual, aConstraint.iIndividual ) );
             }
-            
+
         }
     }
 
 // -----------------------------------------------------------------------------
-// CDRMConstraint::Consume  
+// CDRMConstraint::Consume
 // -----------------------------------------------------------------------------
-//  
+//
 EXPORT_C void CDRMConstraint::Consume( const TTime& aCurrentTime )
     {
     if ( ( iActiveConstraints & EConstraintInterval ) &&
@@ -933,7 +933,7 @@
         {
         iIntervalStart = aCurrentTime;
         }
-        
+
     if ( iActiveConstraints & EConstraintCounter )
         {
         --iCounter;
@@ -946,13 +946,13 @@
 //
 EXPORT_C void CDRMConstraint::DuplicateL( const CDRMConstraint& aConstraint )
     {
-    
+
     // synchronizing marker
     iSyncMark = aConstraint.iSyncMark;
-    
+
     // version number
     iVersion = aConstraint.iVersion;
-    
+
     // usage start time
     iStartTime = aConstraint.iStartTime;
 
@@ -972,50 +972,50 @@
     iOriginalCounter = aConstraint.iOriginalCounter;
 
     // timed counter
-	iTimedCounter = aConstraint.iTimedCounter;
+    iTimedCounter = aConstraint.iTimedCounter;
 
     // Interval of the timed counter constraint
-	iTimedInterval = aConstraint.iTimedInterval;
+    iTimedInterval = aConstraint.iTimedInterval;
 
     // accumulated time
-	iAccumulatedTime = aConstraint.iAccumulatedTime;
+    iAccumulatedTime = aConstraint.iAccumulatedTime;
 
     // individual allowed usage
     iIndividual.ResetAndDestroy();
-    
+
     AppendToArrayL( iIndividual, aConstraint.iIndividual );
-	
+
     // Software Vendor Id
     iVendorId = aConstraint.iVendorId;
-	
+
     // Secure Id of the allowed application
     iSecureId = aConstraint.iSecureId;
-	
-	// Bitmask of active constraints
-    iActiveConstraints = aConstraint.iActiveConstraints;	// Bitmask
 
-#ifdef RD_DRM_METERING    
+    // Bitmask of active constraints
+    iActiveConstraints = aConstraint.iActiveConstraints;    // Bitmask
+
+#ifdef RD_DRM_METERING
     // Metering information
     if ( aConstraint.iDrmMeteringInfo )
         {
-        
+
         if( !iDrmMeteringInfo )
             {
             iDrmMeteringInfo = new (ELeave) TDrmMeteringInfo;
             }
-    
+
         iDrmMeteringInfo->iGraceTime = aConstraint.iDrmMeteringInfo->iGraceTime;
-        iDrmMeteringInfo->iAllowUseWithoutMetering = aConstraint.iDrmMeteringInfo->iAllowUseWithoutMetering; 
+        iDrmMeteringInfo->iAllowUseWithoutMetering = aConstraint.iDrmMeteringInfo->iAllowUseWithoutMetering;
         }
 #endif
-    
+
     // system allowed usage
     iSystem.ResetAndDestroy();
     AppendToArrayL( iSystem, aConstraint.iSystem );
-    
+
     // original timed counter value
     iOriginalTimedCounter = aConstraint.iOriginalTimedCounter;
-    
+
     };
 
 
@@ -1026,88 +1026,88 @@
 EXPORT_C TBool CDRMConstraint::Valid( const TTime& aTime,
                                       const RPointerArray<HBufC8>& aIndividual,
                                       TUint32& aRejection ) const
-	{
-	TBool drmTime = EFalse;
-	// Null the rejection requirement:
-	aRejection = EConstraintNone;
-	
-	// Full Rights are always valid
-	if ( iActiveConstraints == EConstraintNone )
-		{
-		return ETrue;
-		}
+    {
+    TBool drmTime = EFalse;
+    // Null the rejection requirement:
+    aRejection = EConstraintNone;
 
-	// First check counters, accumulated time and timed counters
-	// if any of these are invalid the whole thing is invalid regardless of the
-	// actual time based constraints
-	
+    // Full Rights are always valid
+    if ( iActiveConstraints == EConstraintNone )
+        {
+        return ETrue;
+        }
+
+    // First check counters, accumulated time and timed counters
+    // if any of these are invalid the whole thing is invalid regardless of the
+    // actual time based constraints
+
     // Counters
-    if ( ( iActiveConstraints & EConstraintCounter ) && iCounter < 1 ) 
-    	{
-    	aRejection |= EConstraintCounter;
-    	}
-    		
-    // Accumulated time	
+    if ( ( iActiveConstraints & EConstraintCounter ) && iCounter < 1 )
+        {
+        aRejection |= EConstraintCounter;
+        }
+
+    // Accumulated time
     if ( ( iActiveConstraints & EConstraintAccumulated ) && iAccumulatedTime.Int() == 0 )
-    	{
-    	aRejection |= EConstraintAccumulated;
-    	}
-    		
+        {
+        aRejection |= EConstraintAccumulated;
+        }
+
      // Timed Counters
-    if ( ( iActiveConstraints & EConstraintTimedCounter ) && iTimedCounter < 1 ) 
-    	{
-    	aRejection |= EConstraintTimedCounter;	
-    	} 
-    		
+    if ( ( iActiveConstraints & EConstraintTimedCounter ) && iTimedCounter < 1 )
+        {
+        aRejection |= EConstraintTimedCounter;
+        }
+
     // Dont check time based rights
     if ( aTime != Time::NullTTime() )
-    	{	
-    	drmTime = ETrue;
-    	// Check for activated intervals
-    	if ( (iActiveConstraints & EConstraintInterval) && iIntervalStart != Time::NullTTime() )
-    		{
-        	TTimeIntervalSeconds current;
-        
-        	aTime.SecondsFrom( iIntervalStart, current );
-        
-        	if ( ( current >= iInterval ) || ( aTime < iIntervalStart ) )
-            	{
-            	aRejection |= EConstraintInterval;
-            	}    			
-    		}
-    	
-    	// Check for end time
-    	if ( ( iActiveConstraints & EConstraintEndTime ) && aTime >= iEndTime ) 
-    	    {
-    	    aRejection |= EConstraintEndTime;
-    	    }
-    	    
-    	if ( ( iActiveConstraints & EConstraintStartTime ) && aTime < iStartTime )     
-    		{
-    		aRejection |= EConstraintStartTime;	
-    		}	
-    	}
+        {
+        drmTime = ETrue;
+        // Check for activated intervals
+        if ( (iActiveConstraints & EConstraintInterval) && iIntervalStart != Time::NullTTime() )
+            {
+            TTimeIntervalSeconds current;
+
+            aTime.SecondsFrom( iIntervalStart, current );
+
+            if ( ( current >= iInterval ) || ( aTime < iIntervalStart ) )
+                {
+                aRejection |= EConstraintInterval;
+                }
+            }
+
+        // Check for end time
+        if ( ( iActiveConstraints & EConstraintEndTime ) && aTime >= iEndTime )
+            {
+            aRejection |= EConstraintEndTime;
+            }
+
+        if ( ( iActiveConstraints & EConstraintStartTime ) && aTime < iStartTime )
+            {
+            aRejection |= EConstraintStartTime;
+            }
+        }
     else
         {
         drmTime = EFalse;
-        
-    	// Check for activated intervals
-    	if ( (iActiveConstraints & EConstraintInterval) )
-    		{
-            aRejection |= EConstraintInterval; 			
-    		}
-    	
-    	// Check for end time
-    	if ( ( iActiveConstraints & EConstraintEndTime ) ) 
-    	    {
-    	    aRejection |= EConstraintEndTime;
-    	    }
-    	    
-    	if( ( iActiveConstraints & EConstraintStartTime ) )     
-    		{
-    		aRejection |= EConstraintStartTime;	
-    		}
-        }	
+
+        // Check for activated intervals
+        if ( (iActiveConstraints & EConstraintInterval) )
+            {
+            aRejection |= EConstraintInterval;
+            }
+
+        // Check for end time
+        if ( ( iActiveConstraints & EConstraintEndTime ) )
+            {
+            aRejection |= EConstraintEndTime;
+            }
+
+        if( ( iActiveConstraints & EConstraintStartTime ) )
+            {
+            aRejection |= EConstraintStartTime;
+            }
+        }
 
     // IMSI Checking:
     if( iActiveConstraints & EConstraintIndividual )
@@ -1120,7 +1120,7 @@
             {
             aRejection |= EConstraintIndividual;
             }
-        }        
+        }
 
     if( aRejection )
         {
@@ -1128,12 +1128,12 @@
         if( !drmTime )
             {
             aRejection |= EConstraintNullDrmTime;
-            }       
-        return EFalse;        
+            }
+        return EFalse;
         }
 
-    return ETrue;		
-	};
+    return ETrue;
+    };
 
 
 // -----------------------------------------------------------------------------
@@ -1144,7 +1144,7 @@
 void CDRMConstraint::ConstructL()
     {
     };
-    
+
 // -----------------------------------------------------------------------------
 // CDRMConstraint::WriteInt64L
 // -----------------------------------------------------------------------------
@@ -1152,10 +1152,10 @@
 void CDRMConstraint::WriteInt64L( const TInt64& aWrite, RWriteStream& aStream ) const
     {
     TPtr8 output(NULL,0,0);
-    
-    output.Set( reinterpret_cast<TUint8*>(const_cast<TInt64*>(&aWrite)), 
+
+    output.Set( reinterpret_cast<TUint8*>(const_cast<TInt64*>(&aWrite)),
                 sizeof(TInt64), sizeof(TInt64) );
-    
+
     aStream.WriteL( output, sizeof(TInt64) );
     };
 
@@ -1166,9 +1166,9 @@
 void CDRMConstraint::ReadInt64L( TInt64& aRead, RReadStream& aStream )
     {
     TPtr8 input(NULL,0,0);
-    
+
     input.Set( reinterpret_cast<TUint8*>(&aRead), 0, sizeof(TInt64) );
-    
-    aStream.ReadL( input, sizeof(TInt64) );    
-    };        
+
+    aStream.ReadL( input, sizeof(TInt64) );
+    };
 // End of File