diff -r 000000000000 -r dd21522fd290 browserutilities/downloadmgr/DownloadMgrClntSrv/src/DownloadMgrClntSession.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/browserutilities/downloadmgr/DownloadMgrClntSrv/src/DownloadMgrClntSession.cpp Mon Mar 30 12:54:55 2009 +0300 @@ -0,0 +1,1528 @@ +/* +* Copyright (c) 2004 Nokia Corporation and/or its subsidiary(-ies). +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of the License "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* Nokia Corporation - initial contribution. +* +* Contributors: +* +* Description: +* This file contains the declaration of the Client interface of Download Mgr Server. +* +*/ + + +// INCLUDE FILES +#include "DownloadMgrLogger.h" +#include "DownloadMgrClient.h" +#include "DownloadMgrServer.h" +#include "DownloadMgrStart.h" +#include "DownloadMgrDef.h" +#include "DownloadMgrDefAttrib.h" +#include "DownloadMgrHandler.h" +#include +#include +#include +#include "DownloadMgrCRKeys.h" +#include +#include + +// CONSTANTS +const TInt KHttpDownloadMgrObserverArrayGranularity = 4; +const TInt KHttpDownloadMgrDefalutAttribsGranularity = 4; +const TInt KDefaultMsgSlots = 16; + +_LIT8( KHttpScheme, "http" ); +_LIT8( KHttpsScheme, "https" ); + +// GLOBAL FUNCTIONS +#if defined(_DEBUG) +void DMPanic( TInt aPanicCode ) + { + User::Panic( _L("DownloadManager"), aPanicCode ); + } +#endif + +// ================= MEMBER FUNCTIONS ======================= + +/** +* Extension class. +*/ +NONSHARABLE_CLASS( CRHttpDownloadMgrExtension ) : public CBase + { + public: // Constructors and destructor + + /** + * Two-phased constructor. + */ + static CRHttpDownloadMgrExtension* NewL(); + + /** + * Destructor. + */ + virtual ~CRHttpDownloadMgrExtension(); + + /* + * Next uri observer setter function + */ + void SetNextUriObserver( MHttpDownloadMgrNextUriObserver* aObserver ); + + /* + * Next uri observer getter function + */ + MHttpDownloadMgrNextUriObserver* NextUriObserver() const; + + + protected: // Constructors + + /** + * C++ default constructor. + */ + CRHttpDownloadMgrExtension(); + + /** + * By default Symbian 2nd phase constructor is private. + */ + void ConstructL(); + + public: + + static TInt GetRepositoryValue( TUint32 aSettingId, TInt& aSettingValue ); + + static TInt SetRepositoryValue( TUint32 aSettingId, TInt aSettingValue ); + + public: // Data + TInt iEventBroadcastLevel; + + MHttpDownloadMgrNextUriObserver* iNextUriObserver; ///< Not Owned. + + TInt iSessionId; + + TInt iAdjustEventPriorityFlag; + }; + +// ================= MEMBER FUNCTIONS ======================= + +// ----------------------------------------------------------------------------- +// CRHttpDownloadMgrExtension::CRHttpDownloadMgrExtension +// ----------------------------------------------------------------------------- +// +CRHttpDownloadMgrExtension::CRHttpDownloadMgrExtension() +:iEventBroadcastLevel( 0 ) +,iAdjustEventPriorityFlag( 0 ) + { + iNextUriObserver = NULL; + } + +// ----------------------------------------------------------------------------- +// CRHttpDownloadMgrExtension::ConstructL +// ----------------------------------------------------------------------------- +// +void CRHttpDownloadMgrExtension::ConstructL() + { + CLOG_ENTERFN("CRHttpDownloadMgrExtension::ConstructL"); + } + +// ----------------------------------------------------------------------------- +// CRHttpDownloadMgrExtension::NewL +// ----------------------------------------------------------------------------- +// +CRHttpDownloadMgrExtension* CRHttpDownloadMgrExtension::NewL() + { + CRHttpDownloadMgrExtension* self = new(ELeave)CRHttpDownloadMgrExtension(); + CleanupStack::PushL( self ); + self->ConstructL(); + CleanupStack::Pop(); + return self; + } + +// Destructor +CRHttpDownloadMgrExtension::~CRHttpDownloadMgrExtension() + { + CLOG_ENTERFN("CRHttpDownloadMgrExtension::~CRHttpDownloadMgrExtension"); + } + +// ----------------------------------------------------------------------------- +// CRHttpDownloadMgrExtension::SetNextUriObserver +// ----------------------------------------------------------------------------- +// +void CRHttpDownloadMgrExtension::SetNextUriObserver( MHttpDownloadMgrNextUriObserver* aObserver ) + { + iNextUriObserver = aObserver; + } + +// ----------------------------------------------------------------------------- +// CRHttpDownloadMgrExtension::NextUriObserver +// ----------------------------------------------------------------------------- +// +MHttpDownloadMgrNextUriObserver* CRHttpDownloadMgrExtension::NextUriObserver() const + { + return iNextUriObserver; + } + + +// ----------------------------------------------------------------------------- +// CRHttpDownloadMgrExtension::GetRepositoryValue +// ----------------------------------------------------------------------------- +// +TInt CRHttpDownloadMgrExtension::GetRepositoryValue( TUint32 aSettingId, TInt& aSettingValue ) + { + aSettingValue = KErrNotFound; + CRepository* rep = NULL; + + TRAPD( err, rep = CRepository::NewL( KCRUidBrowserUiLV ) ); + if( (err == KErrNone) && rep ) + { + err = rep->Get( aSettingId, aSettingValue ); + } + delete rep; + return err; + } + +// ----------------------------------------------------------------------------- +// CRHttpDownloadMgrExtension::SetRepositoryValue +// ----------------------------------------------------------------------------- +// +TInt CRHttpDownloadMgrExtension::SetRepositoryValue( TUint32 aSettingId, TInt aSettingValue ) + { + CRepository* rep = NULL; + + TRAPD( err, rep = CRepository::NewL( KCRUidBrowserUiLV ) ); + if( (err == KErrNone) && rep ) + { + err = rep->Set( aSettingId, aSettingValue ); + } + delete rep; + return err; + } + +// --------------------------------------------------------- +// RHttpDownloadMgr::RHttpDownloadMgr +// --------------------------------------------------------- +// +EXPORT_C RHttpDownloadMgr::RHttpDownloadMgr() + { + // Reset data members as R-objects are not zero'd. + iAppUid = TUid::Null(); + iDownloadArray = NULL; + iObservers = NULL; + iDefaultAttribs = NULL; + iManagerHandler = NULL; + iExtension = NULL; + } + +// --------------------------------------------------------- +// RHttpDownloadMgr::ConnectL +// --------------------------------------------------------- +// +EXPORT_C void RHttpDownloadMgr::ConnectL( TUid aAppUid, + MHttpDownloadMgrObserver& aObserver, + TBool aMaster ) + { + CLOG_CREATE; + + __ASSERT_DEBUG( !Handle(), DMPanic( KErrAlreadyExists ) ); + + TRAPD( err, DoConnectL( aAppUid, aObserver, aMaster ) ); + if( err ) + { + Close(); + User::Leave( err ); + } + } + +// --------------------------------------------------------- +// RHttpDownloadMgr::DoConnectL +// --------------------------------------------------------- +// +void RHttpDownloadMgr::DoConnectL( TUid aAppUid, + MHttpDownloadMgrObserver& aObserver, + TBool aMaster ) + { + CLOG_ENTERFN( "RHttpDownloadMgr::ConnectL" ); + + TInt error = KErrNone; + RProcess server; + error = server.Create( KDownloadMgrServerExe, TPtr( NULL, 0 ), + TUidType( KNullUid, KNullUid, KUidDownloadMgrSrvExe ) ); + CLOG_WRITE_FORMAT( "RHttpDownloadMgr::ConnectL after process creation, err %d", error ); + + if( !error ) + { + TRequestStatus status; + server.Rendezvous( status ); + if( status != KRequestPending ) + { + CLOG_WRITE( "RHttpDownloadMgr::ConnectL pending status error." ); + server.Kill( 0 ); + } + else + { + CLOG_WRITE( "RHttpDownloadMgr::ConnectL pending resume server." ); + server.Resume( ); + } + User::WaitForRequest( status ); + error = ( server.ExitType() == EExitPanic ) ? KErrGeneral : status.Int(); + server.Close(); + } + User::LeaveIfError( error ); + CLOG_WRITE( "Creating..." ); + User::LeaveIfError( CreateSession( KDownloadMgrServerName, Version(), KDefaultMsgSlots ) ); + CLOG_WRITE( "Created" ); + + CLOG_WRITE( "Starting initialization" ); + InitializeL( aAppUid, aObserver, aMaster ); + CLOG_WRITE( "Init OK" ); + } + +// --------------------------------------------------------- +// RHttpDownloadMgr::InitializeL +// --------------------------------------------------------- +// +void RHttpDownloadMgr::InitializeL( TUid aAppUid, + MHttpDownloadMgrObserver& aObserver, + TBool aMaster ) + { + CLOG_ENTERFN( "RHttpDownloadMgr::InitializeL" ) + + iAppUid = aAppUid; + AddObserverL( aObserver ); + iExtension = CRHttpDownloadMgrExtension::NewL(); + CLOG_ATTACH( iExtension, this ); + iDownloadArray = new (ELeave) CArrayPtrFlat< RHttpDownload >( 1 ); + if( aMaster ) + { + iManagerHandler = new (ELeave) CDownloadMgrHandler ( this ); + CLOG_ATTACH( iManagerHandler, this ); + iManagerHandler->StartL(); + } + + TPckg uidPckg( iAppUid ); + TInt count( 0 ); + TPckg pckgCount( count ); + TPckg sessionId( iExtension->iSessionId ); + // 0st param - application UID + // 1st param - the amount of downloads at server side belongs to the same UID + // 2st param - master flag + // 3rd param - session id + + User::LeaveIfError( SendReceive( EHttpDownloadMgrInitialize, + TIpcArgs( &uidPckg, &pckgCount, aMaster, + &sessionId ) ) ); + + CLOG_NAME_2( _L("Session_%x_%x"), aAppUid.iUid, iExtension->iSessionId ); + + CLOG_WRITE_FORMAT( "count: %d", count ) + // There are downloads at server side which needs to be attached + if( count ) + { + // Create a buffer which will contain the handles. + TPckgBuf arrayPckg; + HBufC8* buf = HBufC8::NewLC( count*arrayPckg.Size() ); + // Get the handles from the server + TPtr8 ptr = buf->Des(); + AttachL( ptr ); + // Create subsessions one by one. + for( TInt i = 0; i < count; i++ ) + { + RHttpDownload* download = new (ELeave) RHttpDownload ( this ); + CleanupStack::PushL( download ); + // Parse the handle from the buffer. + arrayPckg.Copy( buf->Mid( i*arrayPckg.Size(), arrayPckg.Size() ) ); + // Attach subsession to the server by the handle. + download->AttachL( arrayPckg() ); + TBool isCodDownload ( EFalse ); + download->GetBoolAttribute ( EDlAttrCodDownload , isCodDownload ); + if( isCodDownload ) + { + //paused Download + download->InitPausedCodDownloadL( iAppUid ); + + // Update CodData in Download Mgr Server + HBufC8* mediaInfo8 = NULL; + mediaInfo8 = download->iCodDownload->UpdatedDownloadDataL(); + if (mediaInfo8) + { + download->SetDownloadDataAttribute(*mediaInfo8); + delete mediaInfo8; + + // Buffer attributes in CRHttpDownloadExtension class + download->BufferAttributesL(); + } + User::LeaveIfError( download->GetProductDownloadedSize( ) ); + } + AddToArrayL( download ); + CleanupStack::Pop( download ); //download + } + + CleanupStack::PopAndDestroy( buf ); // buf + } + } + +// --------------------------------------------------------- +// RHttpDownloadMgr::AttachL +// --------------------------------------------------------- +// +void RHttpDownloadMgr::AttachL( TDes8& aBuf ) + { + CLOG_ENTERFN( "RHttpDownloadMgr::AttachL" ) + // 0st param - buffer will contain handles. + // The handles idetifies the download subsessions. + + User::LeaveIfError( SendReceive( EHttpDownloadMgrAttach, + TIpcArgs( &aBuf ) ) ); + } + +// --------------------------------------------------------- +// RHttpDownloadMgr::CloseDownload +// --------------------------------------------------------- +// +void RHttpDownloadMgr::CloseDownload( RHttpDownload* aElement ) + { + CLOG_ENTERFN( "RHttpDownloadMgr::CloseDownload" ); + + // As this class owns the array of subsessions, this role is + // to close them. + RemoveFromArray( aElement ); + aElement->Close(); + delete aElement; + aElement = NULL; + } + +// --------------------------------------------------------- +// RHttpDownloadMgr::Version +// --------------------------------------------------------- +// +EXPORT_C TVersion RHttpDownloadMgr::Version( void ) const + { + return TVersion( KDownloadMgrMajorVersionNumber, + KDownloadMgrMinorVersionNumber, + KDownloadMgrBuildVersionNumber ); + } + + +// --------------------------------------------------------- +// RHttpDownloadMgr::Close +// --------------------------------------------------------- +// +EXPORT_C void RHttpDownloadMgr::Close() + { + + if( !Handle() ) + { + return; + } + + CLOG_WRITE( "RHttpDownloadMgr::Close" ) + if( iDownloadArray ) + { + TInt count = iDownloadArray->Count(); + while( count-- ) + { + CLOG_WRITE_FORMAT( "Close download count[%d]", count ); + RHttpDownload* download = (*iDownloadArray)[count]; + CloseDownload( download ); + } + iDownloadArray->Reset(); + delete iDownloadArray; + iDownloadArray = NULL; + } + + if( iExtension ) + { + delete iExtension; + iExtension = NULL; + } + + if( iObservers ) + { + iObservers->Reset(); + delete iObservers; + iObservers = NULL; + } + + if( iDefaultAttribs ) + { + iDefaultAttribs->ResetAndDestroy(); + delete iDefaultAttribs; + iDefaultAttribs = NULL; + } + + if( iManagerHandler ) + { + iManagerHandler->Cancel(); + delete iManagerHandler; + iManagerHandler = NULL; + } + + RHandleBase::Close(); + + CLOG_CLOSE; + } + +// --------------------------------------------------------- +// RHttpDownloadMgr::AddObserverL +// --------------------------------------------------------- +// +EXPORT_C void RHttpDownloadMgr::AddObserverL( MHttpDownloadMgrObserver& aObserver ) + { + __ASSERT_DEBUG( Handle(), DMPanic( KErrDisconnected ) ); + + CLOG_ENTERFN( "RHttpDownloadMgr::AddObserverL" ) + + if ( iObservers == NULL ) + { + iObservers = new (ELeave) CDownloadMgrObserver( + KHttpDownloadMgrObserverArrayGranularity ); + } + + TInt index( 0 ); + if ( FindObserver( aObserver, index ) == KErrNone ) + { + // Observer already added. + } + else + { + iObservers->AppendL( &aObserver ); + } + } + +// --------------------------------------------------------- +// RHttpDownloadMgr::RemoveObserver +// --------------------------------------------------------- +// +EXPORT_C void RHttpDownloadMgr::RemoveObserver( MHttpDownloadMgrObserver& aObserver ) + { + __ASSERT_DEBUG( Handle(), DMPanic( KErrDisconnected ) ); + + CLOG_ENTERFN( "RHttpDownloadMgr::RemoveObserver" ) + + if ( iObservers ) + { + TInt index( 0 ); + if ( FindObserver( aObserver, index ) != KErrNone ) + { + // Observer not found. Do nothing. + } + else + { + // Observer found. + iObservers->Delete( index ); + // Free up memory. + if ( iObservers->Count() == 0 ) + { + delete iObservers; + iObservers = NULL; + } + } + } + } + +// --------------------------------------------------------- +// RHttpDownloadMgr::FindObserver +// --------------------------------------------------------- +// +TInt RHttpDownloadMgr::FindObserver( MHttpDownloadMgrObserver& aObserver, TInt& aIndex ) const + { + CLOG_ENTERFN( "RHttpDownloadMgr::FindObserver" ) + + TInt ret( KErrNotFound ); + + if ( iObservers == NULL ) + { + ret = KErrNotFound; + } + else + { + MHttpDownloadMgrObserver* obs = &aObserver; + TKeyArrayFix key( 0, ECmpTUint32 ); // Compare pointers + ret = iObservers->Find( obs, key, aIndex ); + } + + return ret; + } + +// --------------------------------------------------------- +// RHttpDownloadMgr::CurrentDownloads +// --------------------------------------------------------- +// +EXPORT_C const CDownloadArray& RHttpDownloadMgr::CurrentDownloads() const + { + __ASSERT_DEBUG( Handle(), DMPanic( KErrDisconnected ) ); + + CLOG_WRITE_FORMAT( "RHttpDownloadMgr::CurrentDownloads %d", iDownloadArray->Count() ) + return *iDownloadArray; + } + +// --------------------------------------------------------- +// RHttpDownloadMgr::CreateDownloadL +// --------------------------------------------------------- +// +EXPORT_C RHttpDownload& RHttpDownloadMgr::CreateDownloadL( const TDesC8& aUrl, + TBool& aResult ) + { + __ASSERT_DEBUG( Handle(), DMPanic( KErrDisconnected ) ); + + CLOG_ENTERFN( "RHttpDownloadMgr::CreateDownloadL" ) + RHttpDownload* download = DoFindDownloadL( aUrl, KNullDesC8 ); + + if( !download ) + { + // there is no ongoing download with this URL + // create one and add to the array + aResult = ETrue; + return CreateDownloadL( aUrl ); + } + else + { + // we already have a download, just return a reference to it. + aResult = EFalse; + return *download; + } + } + +// --------------------------------------------------------- +// RHttpDownloadMgr::CreateDownloadL +// --------------------------------------------------------- +// +EXPORT_C RHttpDownload& RHttpDownloadMgr::CreateDownloadL( const TDesC8& aUrl ) + { + __ASSERT_DEBUG( Handle(), DMPanic( KErrDisconnected ) ); + + CLOG_ENTERFN( "RHttpDownloadMgr::CreateDownloadL" ) + + RHttpDownload* download = new (ELeave) RHttpDownload ( this ); + CleanupStack::PushL( download ); + CleanupClosePushL( *download ); + HBufC8* buf = PackedDefaultAttributesLC(); + download->CreateL( aUrl, buf->Des() ); + RHttpDownload& item = AddToArrayL( download ); + CleanupStack::PopAndDestroy( buf ); // buf + CleanupStack::Pop( 2 ); // download->Close, download + + return item; + } + +// --------------------------------------------------------- +// RHttpDownloadMgr::CreateCodDownloadL +// --------------------------------------------------------- +// +EXPORT_C RHttpDownload& RHttpDownloadMgr::CreateCodDownloadL( const TDesC8& aUrl, + const TDesC8& aBuf, + const TDesC8& aMimeType, + CEikonEnv* aEikEnv, + TBool& aResult ) + { + __ASSERT_DEBUG( Handle(), DMPanic( KErrDisconnected ) ); + + CLOG_ENTERFN( "RHttpDownloadMgr::CreateCodDownloadL" ) + + RHttpDownload& download = CreateDownloadL( aUrl, aResult ); + download.InitCodDownloadL( aBuf, aMimeType, aEikEnv ); + download.SetBoolAttribute( EDlAttrCodDownload, ETrue ); + + return download; + } + +// --------------------------------------------------------- +// RHttpDownloadMgr::CreateClientSideDownloadL +// --------------------------------------------------------- +// +EXPORT_C RHttpDownload& RHttpDownloadMgr::CreateClientSideDownloadL( + TInt aHttpTransaction,TBool& aResult ) + { + __ASSERT_DEBUG( Handle(), DMPanic( KErrDisconnected ) ); + + RHTTPTransaction* httpTransaction = + REINTERPRET_CAST( RHTTPTransaction* , aHttpTransaction ); + RHttpDownload& download = + CreateDownloadL( httpTransaction->Request().URI().UriDes() ); + + download.SetBoolAttribute( EDlAttrContinue, ETrue ); + download.SetHttpTransactionL( aHttpTransaction ); + + // Set the disconnect notification + httpTransaction->PropertySet().SetPropertyL + ( + httpTransaction->Session().StringPool().StringF( HTTP::ENotifyOnDisconnect, RHTTPSession::GetTable() ), + httpTransaction->Session().StringPool().StringF( HTTP::EEnableDisconnectNotification, RHTTPSession::GetTable() ) + ); + + aResult = ETrue; // download is created + + return download; + } + +// --------------------------------------------------------- +// RHttpDownloadMgr::FindDownload +// --------------------------------------------------------- +// +EXPORT_C RHttpDownload* RHttpDownloadMgr::FindDownload( const TDesC8& aUrl, + const TDesC8& aMsgBody ) + { + __ASSERT_DEBUG( Handle(), DMPanic( KErrDisconnected ) ); + + CLOG_ENTERFN( "RHttpDownloadMgr::FindDownload" ) + RHttpDownload* retVal = NULL; + + TRAP_IGNORE( retVal = DoFindDownloadL( aUrl, aMsgBody) ); + + return retVal; + } + +// --------------------------------------------------------- +// RHttpDownloadMgr::DownloadFromHandleL +// --------------------------------------------------------- +// +RHttpDownload& RHttpDownloadMgr::DownloadFromHandleL( TUint aHandle ) + { + CLOG_ENTERFN( "RHttpDownloadMgr::DownloadFromHandleL" ) + // Check the download's handle in the array + for( TInt i = 0; i < iDownloadArray->Count(); i++ ) + { + if( (*iDownloadArray)[i]->IsDownload( aHandle ) ) + { + return *(*iDownloadArray)[i]; + } + } + User::Leave( KErrNotFound ); + + // Just let the compiler be satisfied + return *(*iDownloadArray)[iDownloadArray->Count()]; + } + +// --------------------------------------------------------- +// RHttpDownloadMgr::AddToArrayL +// --------------------------------------------------------- +// +RHttpDownload& RHttpDownloadMgr::AddToArrayL( RHttpDownload* aElement ) + { + CLOG_ENTERFN( "RHttpDownloadMgr::AddToArrayL" ); + + TInt index( 0 ); + TInt err = FindInArray( aElement, index ); + if ( !err ) + { + // Already added. Do nothing, just return a reference to the + // element in the array. + } + else + { + TInt count = iDownloadArray->Count(); + // 'count' will be the index of the new appended element: + index = count; + iDownloadArray->AppendL( aElement ); + } + + return *(*iDownloadArray)[index]; + } + +// --------------------------------------------------------- +// RHttpDownloadMgr::RemoveFromArray +// --------------------------------------------------------- +// +void RHttpDownloadMgr::RemoveFromArray( RHttpDownload* aElement ) + { + CLOG_ENTERFN( "RHttpDownloadMgr::RemoveFromArray" ) + + TInt index( 0 ); + TInt err = FindInArray( aElement, index ); + if ( !err ) + { + // Found. Remove from array: + iDownloadArray->Delete( index ); + iDownloadArray->Compress(); + } + } + +// --------------------------------------------------------- +// RHttpDownloadMgr::FindInArray +// --------------------------------------------------------- +// +TInt RHttpDownloadMgr::FindInArray( RHttpDownload* aElement, TInt& aIndex ) const + { + CLOG_ENTERFN( "RHttpDownloadMgr::FindInArray" ); + + //__ASSERT_DEBUG( iDownloadArray, Panic...) + TKeyArrayFix key( 0, ECmpTUint32 ); // Compare pointers + TInt ret = iDownloadArray->Find( aElement, key, aIndex ); + + return ret; + } + +// --------------------------------------------------------- +// RHttpDownloadMgr::PauseAll +// --------------------------------------------------------- +// +EXPORT_C TInt RHttpDownloadMgr::PauseAll() + { + __ASSERT_DEBUG( Handle(), DMPanic( KErrDisconnected ) ); + + CLOG_ENTERFN( "RHttpDownloadMgr::PauseAll" ) + + for( TInt i = 0; i < iDownloadArray->Count(); i++ ) + { + (*iDownloadArray)[i]->Pause(); + } + + return KErrNone; + } + +// --------------------------------------------------------- +// RHttpDownloadMgr::StartAll +// --------------------------------------------------------- +// +EXPORT_C TInt RHttpDownloadMgr::StartAll() + { + __ASSERT_DEBUG( Handle(), DMPanic( KErrDisconnected ) ); + + CLOG_ENTERFN( "RHttpDownloadMgr::StartAllL" ) + + for( TInt i = 0; i < iDownloadArray->Count(); i++ ) + { + (*iDownloadArray)[i]->Start(); + } + + return KErrNone; + } + +// --------------------------------------------------------- +// RHttpDownloadMgr::ResetAll +// --------------------------------------------------------- +// +EXPORT_C TInt RHttpDownloadMgr::ResetAll() + { + __ASSERT_DEBUG( Handle(), DMPanic( KErrDisconnected ) ); + + CLOG_ENTERFN( "RHttpDownloadMgr::ResetAll" ) + + for( TInt i = 0; i < iDownloadArray->Count(); i++ ) + { + (*iDownloadArray)[i]->Reset(); + } + + return KErrNone; + } + +// --------------------------------------------------------- +// RHttpDownloadMgr::DeleteAll +// --------------------------------------------------------- +// +EXPORT_C TInt RHttpDownloadMgr::DeleteAll() + { + __ASSERT_DEBUG( Handle(), DMPanic( KErrDisconnected ) ); + + CLOG_ENTERFN( "RHttpDownloadMgr::DeleteAll" ) + + TInt err( KErrNone ); + + TInt i = iDownloadArray->Count(); + while( i ) + { + TInt temp = (*iDownloadArray)[0]->Delete(); + if( temp ) + { + err = temp; + } + --i; + } + + return err; + } + +// --------------------------------------------------------- +// RHttpDownloadMgr::Disconnect +// --------------------------------------------------------- +// +EXPORT_C TInt RHttpDownloadMgr::Disconnect() + { + __ASSERT_DEBUG( Handle(), DMPanic( KErrDisconnected ) ); + + CLOG_ENTERFN( "RHttpDownloadMgr::Disconnect" ) + + // First pause all downloads. + // It'd be difficult to pause client side downloads from + // server side. + for( TInt i = 0; i < iDownloadArray->Count(); i++ ) + { + (*iDownloadArray)[i]->Pause(); + } + + return SendReceive( EHttpDownloadMgrDisconnect, TIpcArgs() ); + } + +// --------------------------------------------------------- +// RHttpDownloadMgr::GetIntAttribute +// --------------------------------------------------------- +// +EXPORT_C TInt RHttpDownloadMgr::GetIntAttribute( const TUint aAttribute, + TInt32& aValue ) + { + switch ( aAttribute ) + { + case EDlMgrHasActiveDownloads: + { + return CRHttpDownloadMgrExtension::GetRepositoryValue( KDownloadMgrHasActiveDownloads, (TInt&)aValue ); + } + case EDlMgrAutoAcceptCod: + { + return CRHttpDownloadMgrExtension::GetRepositoryValue( KDownloadMgrAutoAcceptCod, (TInt&)aValue ); + } + case EDlMgrNumOfClientSideDownload: + { + __ASSERT_DEBUG( Handle(), DMPanic( KErrDisconnected ) ); + return NumberOfClientSideDownload( aValue ); + } + default: + { + __ASSERT_DEBUG( Handle(), DMPanic( KErrDisconnected ) ); + TPckg pckg( aValue ); + return SendReceive( EHttpDownloadMgrGetIntAttribute, + TIpcArgs( aAttribute, &pckg ) ); + } + } + } + +// --------------------------------------------------------- +// RHttpDownloadMgr::NumberOfClientSideDownload +// --------------------------------------------------------- +// +TInt RHttpDownloadMgr::NumberOfClientSideDownload( TInt32& aValue ) + { + TInt err( KErrNone ); + + aValue = 0; + for( TInt i = 0; i < iDownloadArray->Count(); i++ ) + { + if( (*iDownloadArray)[i]->IsClientSideDownload() ) + { + aValue++; + } + } + + return err; + } + +// --------------------------------------------------------- +// RHttpDownloadMgr::GetBoolAttribute +// --------------------------------------------------------- +// +EXPORT_C TInt RHttpDownloadMgr::GetBoolAttribute( const TUint aAttribute, + TBool& aValue ) + { + __ASSERT_DEBUG( Handle(), DMPanic( KErrDisconnected ) ); + + CLOG_ENTERFN( "RHttpDownloadMgr::GetIntAttribute" ) + + TPckg pckg( aValue ); + + return SendReceive( EHttpDownloadMgrGetBoolAttribute, + TIpcArgs( aAttribute, &pckg ) ); + } + +// --------------------------------------------------------- +// RHttpDownloadMgr::GetStringAttributeL +// --------------------------------------------------------- +// +EXPORT_C TInt RHttpDownloadMgr::GetStringAttribute( const TUint aAttribute, + TDes16& aValue ) + { + __ASSERT_DEBUG( Handle(), DMPanic( KErrDisconnected ) ); + + CLOG_ENTERFN( "RHttpDownloadMgr::GetIntAttribute" ) + + return SendReceive( EHttpDownloadMgrGetStringAttribute, + TIpcArgs( aAttribute, &aValue ) ); + } + +// --------------------------------------------------------- +// RHttpDownloadMgr::GetStringAttribute +// --------------------------------------------------------- +// +EXPORT_C TInt RHttpDownloadMgr::GetStringAttribute( const TUint aAttribute, + TDes8& aValue ) + { + __ASSERT_DEBUG( Handle(), DMPanic( KErrDisconnected ) ); + + CLOG_ENTERFN( "RHttpDownloadMgr::GetIntAttribute" ) + + return SendReceive( EHttpDownloadMgrGetString8Attribute, + TIpcArgs( aAttribute, &aValue ) ); + } + +// --------------------------------------------------------- +// RHttpDownloadMgr::SetIntAttributeL +// --------------------------------------------------------- +// +EXPORT_C TInt RHttpDownloadMgr::SetIntAttribute( const TUint aAttribute, + TInt32 aValue ) + { + if( aAttribute == EDlMgrHasActiveDownloads ) + { + return CRHttpDownloadMgrExtension::SetRepositoryValue( + KDownloadMgrHasActiveDownloads, (TInt&)aValue ); + } + else + { + __ASSERT_DEBUG( Handle(), DMPanic( KErrDisconnected ) ); + return SendReceive( EHttpDownloadMgrSetIntAttribute, + TIpcArgs( aAttribute, aValue ) ); + } + } + +// --------------------------------------------------------- +// RHttpDownloadMgr::SetBoolAttributeL +// --------------------------------------------------------- +// +EXPORT_C TInt RHttpDownloadMgr::SetBoolAttribute( const TUint aAttribute, + TBool aValue ) + { + __ASSERT_DEBUG( Handle(), DMPanic( KErrDisconnected ) ); + + CLOG_ENTERFN( "RHttpDownloadMgr::SetBoolAttributeL" ) + + return SendReceive( EHttpDownloadMgrSetBoolAttribute, + TIpcArgs( aAttribute, aValue ) ); + } + +// --------------------------------------------------------- +// RHttpDownloadMgr::SetStringAttributeL +// --------------------------------------------------------- +// +EXPORT_C TInt RHttpDownloadMgr::SetStringAttribute( const TUint aAttribute, + const TDesC16& aValue ) + { + __ASSERT_DEBUG( Handle(), DMPanic( KErrDisconnected ) ); + + CLOG_ENTERFN( "RHttpDownloadMgr::SetStringAttributeL" ) + + return SendReceive( EHttpDownloadMgrSetStringAttribute, + TIpcArgs( aAttribute, &aValue ) ); + } + +// --------------------------------------------------------- +// RHttpDownloadMgr::SetStringAttribute +// --------------------------------------------------------- +// +EXPORT_C TInt RHttpDownloadMgr::SetStringAttribute( const TUint aAttribute, + const TDesC8& aValue ) + { + __ASSERT_DEBUG( Handle(), DMPanic( KErrDisconnected ) ); + + CLOG_ENTERFN( "RHttpDownloadMgr::SetStringAttributeL" ) + + return SendReceive( EHttpDownloadMgrSetString8Attribute, + TIpcArgs( aAttribute, &aValue ) ); + } + +// --------------------------------------------------------- +// RHttpDownloadMgr::SetDefaultIntAttribute +// --------------------------------------------------------- +// +EXPORT_C TInt RHttpDownloadMgr::SetDefaultIntAttribute( const TUint aAttribute, + TInt32 aValue ) + { + __ASSERT_DEBUG( Handle(), DMPanic( KErrDisconnected ) ); + + CLOG_ENTERFN( "RHttpDownloadMgr::SetDefaultIntAttributeL" ) + + TRAPD( err, DoSetDefaultAttributeL( aAttribute, aValue ) ); + + return err; + } + +// --------------------------------------------------------- +// RHttpDownloadMgr::SetDefaultBoolAttribute +// --------------------------------------------------------- +// +EXPORT_C TInt RHttpDownloadMgr::SetDefaultBoolAttribute( const TUint aAttribute, + TBool aValue ) + { + __ASSERT_DEBUG( Handle(), DMPanic( KErrDisconnected ) ); + + CLOG_ENTERFN( "RHttpDownloadMgr::SetDefaultBoolAttribute" ) + + TRAPD( err, DoSetDefaultAttributeL( aAttribute, aValue ) ); + + return err; + } + +// --------------------------------------------------------- +// RHttpDownloadMgr::SetDefaultStringAttribute +// --------------------------------------------------------- +// +EXPORT_C TInt RHttpDownloadMgr::SetDefaultStringAttribute( const TUint aAttribute, + const TDesC16& aValue ) + { + __ASSERT_DEBUG( Handle(), DMPanic( KErrDisconnected ) ); + + CLOG_ENTERFN( "RHttpDownloadMgr::SetDefaultBoolAttribute" ) + + TRAPD( err, DoSetDefaultAttributeL( aAttribute, aValue ) ); + + return err; + } + +// --------------------------------------------------------- +// RHttpDownloadMgr::SetDefaultStringAttribute +// --------------------------------------------------------- +// +EXPORT_C TInt RHttpDownloadMgr::SetDefaultStringAttribute( const TUint aAttribute, + const TDesC8& aValue ) + { + __ASSERT_DEBUG( Handle(), DMPanic( KErrDisconnected ) ); + + CLOG_ENTERFN( "RHttpDownloadMgr::SetDefaultBoolAttribute" ) + + TRAPD( err, DoSetDefaultAttributeL( aAttribute, aValue ) ); + + return err; + } + +// --------------------------------------------------------- +// RHttpDownloadMgr::SetNextUriObserver +// --------------------------------------------------------- +// +EXPORT_C void RHttpDownloadMgr::SetNextUriObserver( MHttpDownloadMgrNextUriObserver* aObserver ) + { + __ASSERT_DEBUG( Handle(), DMPanic( KErrDisconnected ) ); + + iExtension->SetNextUriObserver( aObserver ); + } + +// --------------------------------------------------------- +// RHttpDownloadMgr::NextUriObserver +// --------------------------------------------------------- +// +MHttpDownloadMgrNextUriObserver* RHttpDownloadMgr::NextUriObserver() const + { + return iExtension->iNextUriObserver; + } + +// --------------------------------------------------------- +// RHttpDownloadMgr::SessionId +// --------------------------------------------------------- +// +TInt RHttpDownloadMgr::SessionId() const + { + return iExtension->iSessionId; + } + +// --------------------------------------------------------- +// RHttpDownloadMgr::DoSetStringAttributeL +// --------------------------------------------------------- +// +void RHttpDownloadMgr::DoSetDefaultAttributeL( const TUint aAttribute, + TBool aValue ) + { + CLOG_ENTERFN( "RHttpDownloadMgr::SetDefaultBoolAttribute" ) + + if( iDefaultAttribs == NULL ) + { + iDefaultAttribs = new (ELeave) CArrayPtrFlat< CDefaultAttrib >( + KHttpDownloadMgrDefalutAttribsGranularity ); + } + CDefaultAttrib* attrib = CDefaultAttrib::NewL( (THttpDownloadAttrib)aAttribute, + aValue ); + iDefaultAttribs->AppendL( attrib ); + } + +// --------------------------------------------------------- +// RHttpDownloadMgr::DoSetStringAttributeL +// --------------------------------------------------------- +// +void RHttpDownloadMgr::DoSetDefaultAttributeL( const TUint aAttribute, + TInt32 aValue ) + { + CLOG_ENTERFN( "RHttpDownloadMgr::SetDefaultBoolAttribute" ) + + if( iDefaultAttribs == NULL ) + { + iDefaultAttribs = new (ELeave) CArrayPtrFlat< CDefaultAttrib >( + KHttpDownloadMgrDefalutAttribsGranularity ); + } + CDefaultAttrib* attrib = CDefaultAttrib::NewL( (THttpDownloadAttrib)aAttribute, + aValue ); + iDefaultAttribs->AppendL( attrib ); + } + +// --------------------------------------------------------- +// RHttpDownloadMgr::DoSetStringAttributeL +// --------------------------------------------------------- +// +void RHttpDownloadMgr::DoSetDefaultAttributeL( const TUint aAttribute, + const TDesC8& aValue ) + { + CLOG_ENTERFN( "RHttpDownloadMgr::SetDefaultBoolAttribute" ) + + if( iDefaultAttribs == NULL ) + { + iDefaultAttribs = new (ELeave) CArrayPtrFlat< CDefaultAttrib >( + KHttpDownloadMgrDefalutAttribsGranularity ); + } + CDefaultAttrib* attrib = CDefaultAttrib::NewL( (THttpDownloadAttrib)aAttribute, + aValue ); + iDefaultAttribs->AppendL( attrib ); + } + +// --------------------------------------------------------- +// RHttpDownloadMgr::DoSetStringAttributeL +// --------------------------------------------------------- +// +void RHttpDownloadMgr::DoSetDefaultAttributeL( const TUint aAttribute, + const TDesC16& aValue ) + { + CLOG_ENTERFN( "RHttpDownloadMgr::SetDefaultBoolAttribute" ) + + if( iDefaultAttribs == NULL ) + { + iDefaultAttribs = new (ELeave) CArrayPtrFlat< CDefaultAttrib >( + KHttpDownloadMgrDefalutAttribsGranularity ); + } + CDefaultAttrib* attrib = CDefaultAttrib::NewL( (THttpDownloadAttrib)aAttribute, + aValue ); + iDefaultAttribs->AppendL( attrib ); + } + +// --------------------------------------------------------- +// RHttpDownloadMgr::HandleDMgrEventL +// --------------------------------------------------------- +// + +void RHttpDownloadMgr::HandleDMgrEventL( RHttpDownload& aDownload, + THttpDownloadEvent aEvent ) + { + CLOG_ENTERFN( "RHttpDownloadMgr::HandleDMgrEventL" ) + iExtension->iEventBroadcastLevel++; + CLOG_WRITE_FORMAT( "aDownload = %x", &aDownload ); + CLOG_WRITE_FORMAT( "Inc iEventBroadcastLevel = %d", iExtension->iEventBroadcastLevel ); + // In case of EHttpDlDeleted getting most of the attributes are forbidden, + // because the engine is most likely is not ready to serve! Some of the + // attributes are buffered in client side. + aDownload.SetEventType( aEvent.iDownloadState ); + + if( (( EHttpDlInprogress == aEvent.iDownloadState ) && ( EHttpProgCodDescriptorDownloaded == aEvent.iProgressState ))|| + (( EHttpDlInprogress == aEvent.iDownloadState ) && ( EHttpProgCodDownloadShouldResume == aEvent.iProgressState ))|| + (( EHttpDlPaused == aEvent.iDownloadState ) && ( EHttpProgCodDescriptorDownloaded == aEvent.iProgressState )) + ) + { + TBool isCod( ETrue ); + + if(EHttpProgCodDownloadShouldResume == aEvent.iProgressState) + { + //resume only for apps with non-zero uid. otherwise the resume will happen from music player which sets the appuid as zero. + TInt32 clientAppUid(0); + GetIntAttribute(EDlMgrAppUid , clientAppUid); + if( !clientAppUid ) + { + iExtension->iEventBroadcastLevel--; + return; + } + } + + else + { + TRAPD( err, isCod = aDownload.CheckContentTypeAndCreateCodDownloadL() ); + if( isCod ) + { + if( err ) + { + // The error code is processed by the server + aDownload.SetOnError( err ); + iExtension->iEventBroadcastLevel--; + return; + } + } + + } + TRAPD( err, aDownload.DoStartCodL() ); + if( err ) + { + aDownload.SetOnError( err ); + iExtension->iEventBroadcastLevel--; + return; + } + + } + else if( EHttpDlCancelTransaction == aEvent.iDownloadState ) + { + aDownload.DeleteTransaction(); + } + + else if( EHttpProgCodDownloadPause == aEvent.iProgressState ) + { + if(aDownload.iCodDownload) + { + aDownload.iCodDownload->Pause(); + } + } + else if( EHttpDlProgProgressive == aEvent.iProgressState ) + { + if(aDownload.iCodDownload) + { + aDownload.iCodDownload->SetCodDlAttached(ETrue); + } + } + else if( EHttpDlProgNonProgressive == aEvent.iProgressState ) + { + if(aDownload.iCodDownload) + { + aDownload.iCodDownload->SetCodDlAttached(EFalse); + } + } + + // TODO: make sure that all COD test cases works OK + + // ...and close the download. + if( EHttpDlDeleted == aEvent.iDownloadState ) + { + CloseDownload( &aDownload ); + } + + iExtension->iEventBroadcastLevel--; + + // When a download completes, close the subsession to make a message slot free. + // Also the required information will be cached before closing the subsession + if( EHttpDlMultipleMOCompleted == aEvent.iDownloadState && + ( + EHttpProgContentFileMoved == aEvent.iProgressState || + EHttpProgContentFileMovedAndDestFNChanged == aEvent.iProgressState + ) + ) + { + //Store all the info clinet side in RHttpDownload's extension API + aDownload.SaveDownloadInfoL(); + //Close the subsession to free up the message slot + aDownload.CloseSubSession(); + } + TInt count = iObservers->Count(); + for( TInt i = 0; i < count; i++ ) + { + CLOG_WRITE_FORMAT( "HandleDMgrEventL( aDownload = 0x%x)", this ); + TRAP_IGNORE( (*iObservers)[i]->HandleDMgrEventL( aDownload, aEvent ) ); + if(!iObservers)break; + + } + + //CLOG_WRITE_FORMAT( "Dec iEventBroadcastLevel = %d", iExtension->iEventBroadcastLevel ); + } + +// --------------------------------------------------------- +// RHttpDownloadMgr::BroadcastEvent +// --------------------------------------------------------- +// +void RHttpDownloadMgr::BroadcastEvent( RHttpDownload& aDownload, + THttpDownloadEvent aEvent ) + { + CLOG_WRITE_3( "BroadcastEvent: dl [%x], DownloadState [%d], ProgressState [%d]", this, aEvent.iDownloadState, aEvent.iProgressState ); + for( TInt i = 0; i < iObservers->Count(); i++ ) + { + TRAP_IGNORE( (*iObservers)[i]->HandleDMgrEventL( aDownload, aEvent ) ); + // The download shouldn't be deleted in nested loops!!! + if( 1 == iExtension->iEventBroadcastLevel ) + { + if( aDownload.IsToBeDeleted() ) + { + // Decremented before delete because we check the + // value in aDownload.Delete(); + iExtension->iEventBroadcastLevel--; + CLOG_WRITE_FORMAT( "Dec iEventBroadcastLevel = %d", iExtension->iEventBroadcastLevel ); + aDownload.Delete(); + iExtension->iEventBroadcastLevel++; + return; + } + } + } + } + +// --------------------------------------------------------- +// RHttpDownloadMgr::HandleSessionEventL +// --------------------------------------------------------- +// +void RHttpDownloadMgr::HandleSessionEventL( TInt aHandle, THttpDownloadEvent aEvent ) + { + TRAP_IGNORE( DoHandleSessionEventL( aHandle, aEvent ) ); + } + +// --------------------------------------------------------- +// RHttpDownloadMgr::DoHandleSessionEventL +// --------------------------------------------------------- +// +void RHttpDownloadMgr::DoHandleSessionEventL( TInt aHandle, THttpDownloadEvent aEvent ) + { + RHttpDownload* download = new (ELeave) RHttpDownload ( this ); + CleanupStack::PushL( download ); + CleanupClosePushL( *download ); + // Attach subsession to the server by the handle. + download->AttachL( aHandle ); + AddToArrayL( download ); + CleanupStack::Pop( download ); //download + // Forward the event to the client + HandleDMgrEventL( *download, aEvent ); + } + +// --------------------------------------------------------- +// RHttpDownloadMgr::StartSessionEventNotification +// --------------------------------------------------------- +// +void RHttpDownloadMgr::StartSessionEventNotification( const TDesC8& aDownloadState, + const TDesC8& aProgressState, + const TDesC8& aHandle, + TRequestStatus& aStatus ) + { + CLOG_ENTERFN( "RHttpDownload::StartSessionEventNotification" ) + + SendReceive( EHttpDownloadMgrSessionEventSubscription, + TIpcArgs( &aDownloadState, &aProgressState, &aHandle ), + aStatus ); + } + +// --------------------------------------------------------- +// RHttpDownloadMgr::CancelSessionEventNotification +// --------------------------------------------------------- +// +void RHttpDownloadMgr::CancelSessionEventNotification() + { + CLOG_WRITE( "RHttpDownload::CancelSessionEventNotification" ) + + SendReceive( EHttpDownloadMgrSessionEventCancel, TIpcArgs() ); + } + +// --------------------------------------------------------- +// RHttpDownloadMgr::PackedDefaultAttributesLC +// --------------------------------------------------------- +// +HBufC8* RHttpDownloadMgr::PackedDefaultAttributesLC() + { + HBufC8* buf = NULL; + if( iDefaultAttribs ) + { + + buf = TDMgrUtils::PackedAttributesL( iDefaultAttribs ); + CleanupStack::PushL( buf ); + } + else + { + buf = HBufC8::NewLC( 0 ); + } + + return buf; + } + +// --------------------------------------------------------- +// RHttpDownloadMgr::DoFindDownloadL +// --------------------------------------------------------- +// +RHttpDownload* RHttpDownloadMgr::DoFindDownloadL( const TDesC8& aUrl, const TDesC8& aMsgBody ) + { + RHttpDownload* retVal = NULL; + TInt pushCounter( 0 ); + + HBufC8* escaped = EscapeUtils::EscapeDecodeL( aUrl ); + CleanupStack::PushL( escaped ); ++pushCounter; + + TUriParser8 compUri; + compUri.Parse( *escaped ); + + TPtrC8 scheme( compUri.Extract( EUriScheme ) ); + + CUri8* url = CUri8::NewLC(); ++pushCounter; + + if( scheme.Length() ) + { + if( scheme != KHttpScheme && + scheme != KHttpsScheme ) + // this url has an unsupported scheme + { + User::Leave( KErrArgument ); + } + else + { + url->SetComponentL( scheme, EUriScheme ); + } + } + else + { + url->SetComponentL( KHttpScheme, EUriScheme ); + } + + url->SetComponentL( compUri.Extract( EUriHost ), EUriHost ); + url->SetComponentL( compUri.Extract( EUriPath ), EUriPath ); + url->SetComponentL( compUri.Extract( EUriQuery ), EUriQuery ); + url->SetComponentL( compUri.Extract( EUriFragment ), EUriFragment ); + + if( compUri.IsPresent( EUriPort ) ) + { + url->SetComponentL( compUri.Extract( EUriPort ), EUriPort ); + } + else + { + TBuf8<10> port; + + port.Format( _L8("%d"), KDefaultPort ); + + url->SetComponentL( port, EUriPort ); + } + + TBuf8 hash_req; + HashL( aMsgBody, hash_req ); + + TUriParser8 parsed_req; + + parsed_req.Parse( url->Uri().UriDes() ); + + for( TInt i = 0; i < iDownloadArray->Count(); i++ ) + { + if( (*iDownloadArray)[i]->IsDownloadL( parsed_req, hash_req ) ) + { + retVal = (*iDownloadArray)[i]; + break; + } + } + + CleanupStack::PopAndDestroy( pushCounter ); + + return retVal; + } + +// --------------------------------------------------------- +// RHttpDownloadMgr::IsEventBroadcasting +// --------------------------------------------------------- +// +TBool RHttpDownloadMgr::IsEventBroadcasting() + { + CLOG_WRITE( "RHttpDownload::IsEventBroadcasting" ) + return (0 < iExtension->iEventBroadcastLevel); + } + +// --------------------------------------------------------- +// RHttpDownloadMgr::IsEventBroadcasting +// --------------------------------------------------------- +// +TInt RHttpDownloadMgr::EventPriorityFlag() const + { + return iExtension->iAdjustEventPriorityFlag; + } + +// --------------------------------------------------------- +// RHttpDownloadMgr::IncrementEventPriorityFlag +// --------------------------------------------------------- +// +void RHttpDownloadMgr::IncrementEventPriorityFlag() + { + iExtension->iAdjustEventPriorityFlag++; + } + +// --------------------------------------------------------- +// RHttpDownloadMgr::IncrementEventPriorityFlag +// --------------------------------------------------------- +// +void RHttpDownloadMgr::DecrementEventPriorityFlag() + { + iExtension->iAdjustEventPriorityFlag--; + }