/*
* Copyright (c) 2006 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:  Implementation of CHttpCachePostponeWriteUtilities
*
*/

// INCLUDE FILES
#include "HttpCachePostponeWriteUtilities.h"
#include "HttpCacheUtil.h"

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES

// CONSTANTS

// MACROS

// LOCAL CONSTANTS AND MACROS

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

// FORWARD DECLARATIONS

// ============================= LOCAL FUNCTIONS ===============================

// ============================ MEMBER FUNCTIONS ===============================

// -----------------------------------------------------------------------------
// CHttpCacheEntryAsyncWriteHelper::CHttpCacheEntryAsyncWriteHelper
// -----------------------------------------------------------------------------
//
CHttpCacheEntryAsyncWriteHelper::CHttpCacheEntryAsyncWriteHelper(TRequestStatus& aStatus, MHttpCacheWriteSource* aSource, TInt aPriority)
    : CActive(aPriority),
      iSignalStatus(aStatus),
      iSource(aSource)
    {
    }

// -----------------------------------------------------------------------------
// CHttpCacheEntryAsyncWriteHelper::NewL
// -----------------------------------------------------------------------------
//
CHttpCacheEntryAsyncWriteHelper* CHttpCacheEntryAsyncWriteHelper::NewL(MHttpCacheWriteSource* aSource, TRequestStatus& aStatus)
    {
    CHttpCacheEntryAsyncWriteHelper *obj = new (ELeave) CHttpCacheEntryAsyncWriteHelper(aStatus, aSource, EPriorityHigh);
    CleanupStack::PushL(obj);
    obj->ConstructL();
    CleanupStack::Pop(obj);
    return obj;
    }

// -----------------------------------------------------------------------------
// CHttpCacheEntryAsyncWriteHelper::~CHttpCacheEntryAsyncWriteHelper
// -----------------------------------------------------------------------------
//
CHttpCacheEntryAsyncWriteHelper::~CHttpCacheEntryAsyncWriteHelper()
    {
    Cancel();
    }

// -----------------------------------------------------------------------------
// CHttpCacheEntryAsyncWriteHelper::DoCancel
// -----------------------------------------------------------------------------
//
void CHttpCacheEntryAsyncWriteHelper::DoCancel()
    {
    TRequestStatus *stat = &(TRequestStatus&)iSignalStatus;
    User::RequestComplete(stat, KErrCancel);    // Signal cancellation to the observer.
    // cannot meaningfully do anything with the unwritten data assuming there is some.
    // we will clean it up when we are deleted.
    iSource->BodyFile().Close();
    iSource->BodyWriteComplete();
#ifdef __CACHELOG__
    HttpCacheUtil::WriteFormatLog(0, _L("CACHEPOSTPONE: CHttpCacheEntryAsyncWriteHelper::DoCancel called on object %08x"), this);
#endif
    }

// -----------------------------------------------------------------------------
// CHttpCacheEntryAsyncWriteHelper::WriteNextBodyBlock
// -----------------------------------------------------------------------------
//
void CHttpCacheEntryAsyncWriteHelper::WriteNextBodyBlock()
    {
#ifdef __CACHELOG__
    HttpCacheUtil::WriteFormatLog(0, _L("CACHEPOSTPONE: CHttpCacheEntryAsyncWriteHelper::WriteNextBodyBlock called on object %08x for block %d"), this, iBodyPart );
#endif

    TPtrC8 bufferPtr( iSource->BodyData().GetSegmentData(iBodyPart) );
    iSource->BodyFile().Write(bufferPtr, iStatus);
    }

// -----------------------------------------------------------------------------
// CHttpCacheEntryAsyncWriteHelper::RunL
// -----------------------------------------------------------------------------
//
void CHttpCacheEntryAsyncWriteHelper::RunL()
    {
    /* General algorithm.
     * Write out next section of body data unless done.  Then write out header data.
     */
#ifdef __CACHELOG__
    HttpCacheUtil::WriteFormatLog(0, _L("CACHEPOSTPONE: CHttpCacheEntryAsyncWriteHelper::RunL called on object %08x"), this);
#endif
    if ( iSource->BodyData().Count() > iBodyPart )
        {
        WriteNextBodyBlock();
        SetActive();
        }
    else
        {
#ifdef __CACHELOG__
        HttpCacheUtil::WriteFormatLog(0, _L("CACHEPOSTPONE:   - body write completed with status code %d"), iStatus.Int());
#endif
        // Body file writing is complete
        iSource->BodyFile().Close();
        iSource->BodyWriteComplete();
        TRequestStatus *stat = &(TRequestStatus&)iSignalStatus;
        User::RequestComplete(stat, iStatus.Int()); // signal completion to observer
        }
    }

// -----------------------------------------------------------------------------
// CHttpCacheEntryAsyncWriteHelper::GetResult
// -----------------------------------------------------------------------------
//
TInt CHttpCacheEntryAsyncWriteHelper::GetResult()
    {
    return iStatus.Int();
    }

// -----------------------------------------------------------------------------
// CHttpCacheEntryAsyncWriteHelper::ConstructL
// -----------------------------------------------------------------------------
//
void CHttpCacheEntryAsyncWriteHelper::ConstructL()
    {
    CActiveScheduler::Add(this);
    iSource->BodyWriteInProgress();
    // setup to arrive in RunL when next possible.
    SetActive();
    TRequestStatus *stat = &(TRequestStatus&)iStatus;
    User::RequestComplete(stat, KErrNone);
    }

// -----------------------------------------------------------------------------
// CSegmentedHeapBuffer::~CSegmentedHeapBuffer
// -----------------------------------------------------------------------------
//
CSegmentedHeapBuffer::~CSegmentedHeapBuffer()
    {
    Reset();
    }

// -----------------------------------------------------------------------------
// CSegmentedHeapBuffer::ConstructL
// -----------------------------------------------------------------------------
//
void CSegmentedHeapBuffer::ConstructL()
    {
    }

// -----------------------------------------------------------------------------
// CSegmentedHeapBuffer::NewL
// -----------------------------------------------------------------------------
//
CSegmentedHeapBuffer *CSegmentedHeapBuffer::NewL(TInt aBufferSize, TInt aCompressGranularity)
    {
    CSegmentedHeapBuffer *obj= new (ELeave) CSegmentedHeapBuffer(aBufferSize, aCompressGranularity);
    CleanupStack::PushL(obj);
    obj->ConstructL();
    CleanupStack::Pop(obj);

    return obj;
    }

// -----------------------------------------------------------------------------
// CSegmentedHeapBuffer::AppendL
// -----------------------------------------------------------------------------
//
void CSegmentedHeapBuffer::AppendL(TInt& aRemainder, const TDesC8& aDes)
    {
    aRemainder = aDes.Length(); // consumed nothing yet.
    TInt workingLen;
    TInt workingOffset=0;   // read position in source descriptor
    HBufC8* currentBuffer;

    TInt lastBuffer = iBufferList.Count()-1;
    if ( lastBuffer < 0 )
        {
        // TODO: Make the first block only equal to the size of data we need?
        // Take some traces to see what happens.

        // no blocks allocated.  May leave here if we can't get space.
        currentBuffer = HBufC8::NewLC(iBufferSize);
        iBufferList.AppendL(currentBuffer);
        CleanupStack::Pop(currentBuffer);
        lastBuffer = 0;
        }
    else
        {
        currentBuffer = iBufferList[lastBuffer];
        }

    // here, currentBuffer always points to a buffer we can use.
    while ( aRemainder )
        {
        workingLen = iBufferSize - currentBuffer->Length(); // workingLen = amount of space left in this segment
        workingLen = (aRemainder > workingLen) ? workingLen : aRemainder;   // workingLen = smaller of (amount of data left in source) or (amount of space left in current segment)
        if ( workingLen )
            {
            // we have some space in this block to store data.
            TPtr8 ptr(currentBuffer->Des());
            ptr.Append(aDes.Mid(workingOffset ,workingLen));
            }
        aRemainder -= workingLen;   // track how much is consumed
        workingOffset += workingLen;    // remember where we get the next bit from in the source
        if ( aRemainder )
            {
            // we have more data to store, append another block.  Might result in a leave.
            currentBuffer = HBufC8::NewLC(iBufferSize);
            iBufferList.AppendL(currentBuffer);
            CleanupStack::Pop(currentBuffer);
            }
        }
    // will only exit here if we consumed all data
    }

// -----------------------------------------------------------------------------
// CSegmentedHeapBuffer::Length
// -----------------------------------------------------------------------------
//
TInt CSegmentedHeapBuffer::Length()
    {
    // all segments are same size except last one
    TInt len = 0;
    TInt count = iBufferList.Count();
    if ( count )
        {
        len = iBufferSize * (count - 1);    // all segments are same size except last one
        len += iBufferList[count-1]->Length();
        }
    return len;
    }

// -----------------------------------------------------------------------------
// CSegmentedHeapBuffer::SpareCapacity
// -----------------------------------------------------------------------------
//
TInt CSegmentedHeapBuffer::SpareCapacity()
    {
    TInt len = 0;
    TInt count = iBufferList.Count();
    if ( count )
        {
        len = iBufferSize - (iBufferList[count-1]->Length());
        }

    // return how much is left in last segment.
    return len;
    }

// -----------------------------------------------------------------------------
// CSegmentedHeapBuffer::Count
// -----------------------------------------------------------------------------
//
TInt CSegmentedHeapBuffer::Count()
    {
    return iBufferList.Count(); // number of segments
    }

// -----------------------------------------------------------------------------
// CSegmentedHeapBuffer::GetSegmentData
// -----------------------------------------------------------------------------
//
TPtrC8 CSegmentedHeapBuffer::GetSegmentData(TInt& aSegment)
    {
    return iBufferList[aSegment++]->Des();
    }

// -----------------------------------------------------------------------------
// CSegmentedHeapBuffer::ReleaseSegmentData
// -----------------------------------------------------------------------------
//
void CSegmentedHeapBuffer::ReleaseSegmentData(const TInt aSegment)
    {
    HBufC8* buf = iBufferList[aSegment];
    iBufferList[aSegment] = 0;  // don't want to reshuffle contents
    delete buf;
    }

// -----------------------------------------------------------------------------
// CSegmentedHeapBuffer::Compress
// -----------------------------------------------------------------------------
//
void CSegmentedHeapBuffer::Compress()
    {
    TInt count = iBufferList.Count();
    if ( count )
        {
        HBufC8* buf = iBufferList[count-1];
        // first, see if we can shrink by at least one iCompressGranularity
        if ( iBufferSize - buf->Length() >= iCompressGranularity )
            {
            // calculate new size
            TInt newsize = (iCompressGranularity * (1 + (buf->Length() / iCompressGranularity)));
            HBufC8 *newbuf = buf->ReAlloc(newsize);
            // we should be realloc'ing in place since we're shrinking this piece, but you never know.
            // don't care if realloc operation fails since it will leave original data alone.
            if ( newbuf )
                {
                iBufferList[count-1] = newbuf;
                }
            }
        }
    }

// -----------------------------------------------------------------------------
//  CSegmentedHeapBuffer::Reset
// -----------------------------------------------------------------------------
//
void CSegmentedHeapBuffer::Reset()
    {
    iBufferList.ResetAndDestroy();  // call delete on all buffers
    }

// -----------------------------------------------------------------------------
// CSegmentedHeapBuffer::CSegmentedHeapBuffer
// -----------------------------------------------------------------------------
//
CSegmentedHeapBuffer::CSegmentedHeapBuffer(TInt aBufferSize, TInt aCompressGranularity) : iBufferSize(aBufferSize), iCompressGranularity(aCompressGranularity)
    {
    }

// -----------------------------------------------------------------------------
// CHttpCacheWriteTimeout::CHttpCacheWriteTimeout
// -----------------------------------------------------------------------------
//
CHttpCacheWriteTimeout::CHttpCacheWriteTimeout( const TInt aTimeout )
    : CActive(EPriorityStandard),
      iTimeout(aTimeout) // Standard priority
    {
    }

// -----------------------------------------------------------------------------
// CHttpCacheWriteTimeout::NewLC
// -----------------------------------------------------------------------------
//
CHttpCacheWriteTimeout* CHttpCacheWriteTimeout::NewLC(const TInt aTimeout)
    {
    CHttpCacheWriteTimeout* self = new ( ELeave ) CHttpCacheWriteTimeout(aTimeout);
    CleanupStack::PushL(self);
    self->ConstructL();
    return self;
    }

// -----------------------------------------------------------------------------
// CHttpCacheWriteTimeout::NewL
// -----------------------------------------------------------------------------
//
CHttpCacheWriteTimeout* CHttpCacheWriteTimeout::NewL(const TInt aTimeout)
    {
    CHttpCacheWriteTimeout* self = CHttpCacheWriteTimeout::NewLC(aTimeout);
    CleanupStack::Pop(); // self;
    return self;
    }

// -----------------------------------------------------------------------------
// CHttpCacheWriteTimeout::ConstructL
// -----------------------------------------------------------------------------
//
void CHttpCacheWriteTimeout::ConstructL()
    {
    User::LeaveIfError(iTimer.CreateLocal()); // Initialize timer
    CActiveScheduler::Add(this); // Add to scheduler
    }

// -----------------------------------------------------------------------------
// CHttpCacheWriteTimeout::~CHttpCacheWriteTimeout
// -----------------------------------------------------------------------------
//
CHttpCacheWriteTimeout::~CHttpCacheWriteTimeout()
    {
    Cancel(); // Cancel any request, if outstanding
    iTimer.Close(); // Destroy the RTimer object
    // Delete instance variables if any
    }

// -----------------------------------------------------------------------------
// CHttpCacheWriteTimeout::DoCancel
// -----------------------------------------------------------------------------
//
void CHttpCacheWriteTimeout::DoCancel()
    {
    iTimer.Cancel();
    }

// -----------------------------------------------------------------------------
// CHttpCacheWriteTimeout::Start
// -----------------------------------------------------------------------------
//
void CHttpCacheWriteTimeout::Start(TCallBack aCallbackFn, TAny *aToken)
    {
    Cancel(); // Cancel any request, just to be sure

    iToken = aToken;
    iCallbackFn = aCallbackFn;

    iTimer.After(iStatus, iTimeout); // Set for later
    SetActive(); // Tell scheduler a request is active
    }

// -----------------------------------------------------------------------------
// CHttpCacheWriteTimeout::RunL
// -----------------------------------------------------------------------------
//
void CHttpCacheWriteTimeout::RunL()
    {
    iCallbackFn.iFunction(iToken);
    }

// -----------------------------------------------------------------------------
// CHttpCacheWriteTimeout::RunError
// -----------------------------------------------------------------------------
//
TInt CHttpCacheWriteTimeout::RunError(TInt aError)
    {
    return aError;
    }

//  End of File