/*
* 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 <e32svr.h>
#include <EscapeUtils.h>
#include <centralrepository.h>
#include "DownloadMgrCRKeys.h"
#include <BrowserUiSDKCRKeys.h>
#include <CodDownload.h>

// 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<TUid> uidPckg( iAppUid );
    TInt count( 0 );
    TPckg<TInt> pckgCount( count );
    TPckg<TInt> 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<TInt> 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<TInt32> 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<TBool> 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<KHashLength> 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--;
    }
