/*
* 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 CSynchRequest
*
*/


// INCLUDE FILES
#include <../bidi.h>
#include <e32std.h>
#include <eikenv.h>

#include "config.h"

#include "BrCtl.h"
#include "ResourceHandleInternal.h"
#include "ResourceHandleManagerSymbian.h"
#include "ResourceLoaderDelegate.h"
#include "StaticObjectsContainer.h"

#include "SynchRequest.h"

namespace WebCore
{

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

// ----------------------------------------------------------------------------
// CSynchRequest::NewL()
// Two-phased constructor.
// ----------------------------------------------------------------------------
//
CSynchRequest* CSynchRequest::NewL()
{
    CSynchRequest* self = NewLC();
    CleanupStack::Pop(self);
    return self;
}

// ----------------------------------------------------------------------------
// CSynchRequest::NewLC()
// Two-phased constructor.
// ----------------------------------------------------------------------------
//
CSynchRequest* CSynchRequest::NewLC()
{
    CSynchRequest* self = new ( ELeave ) CSynchRequest();
    CleanupStack::PushL(self);
    self->ConstructL();
    return self;
}

// ----------------------------------------------------------------------------
// CSynchRequest::~CSynchRequest()
// Destructor.
// ----------------------------------------------------------------------------
//
CSynchRequest::~CSynchRequest()
{
    if (IsActive()) {
        Cancel();
    }

    if (iActiveSchedulerWait) {
        delete iActiveSchedulerWait;
        iActiveSchedulerWait = NULL;
    }
}

// ----------------------------------------------------------------------------
// CSynchRequest::CSynchRequest()
// Constructor.
// ----------------------------------------------------------------------------
//
CSynchRequest::CSynchRequest()
    : CActive(CActive::EPriorityStandard)
    , m_synchLoader(0)
    , m_error(String(), KErrNone, String(), String())
{
    CActiveScheduler::Add( this);
}

// ----------------------------------------------------------------------------
// CSynchRequest::ConstructL()
// Perform second phase construction of this object.
// ----------------------------------------------------------------------------
//
void CSynchRequest::ConstructL()
{
    // Initializing the ActiveShedulerWait.
    iActiveSchedulerWait = new (ELeave) CActiveSchedulerWait();
}

// ----------------------------------------------------------------------------
// CSynchRequest::RunL()
// Respond to an event.
// ----------------------------------------------------------------------------
//
void CSynchRequest::RunL()
{
    if (KErrNone == iStatus.Int()) {
        m_error = ResourceError();
    } else {
        m_error = ResourceError(String(), iStatus.Int(), String(), String());
    }
    	
    if (iActiveSchedulerWait->IsStarted()) {
        iActiveSchedulerWait->AsyncStop();
    }
}

// ----------------------------------------------------------------------------
// CSynchRequest::DoCancel()
// Cancel any outstanding requests.
// ----------------------------------------------------------------------------
//
void CSynchRequest::DoCancel()
{
	if (m_synchLoader) {
		m_synchLoader->cancel();
	} else {
        // Complete pending request
        if (KRequestPending == iStatus.Int()) {
        	TRequestStatus* status = &iStatus;
            User::RequestComplete(status, KErrAbort);
        }        
	}
}

// ----------------------------------------------------------------------------
// CSynchRequest::RunError(TInt aError)
// Handles a leave occurring in the request completion event handler RunL().
// ----------------------------------------------------------------------------
//
TInt CSynchRequest::RunError(TInt /*aError*/)
{
    return KErrNone;
}

// ----------------------------------------------------------------------------
//  CSynchRequest::CreateResource()
//  
// ----------------------------------------------------------------------------
//

void CSynchRequest::CreateResource(const ResourceRequest& request,
                                   ResourceError& error,
                                   ResourceResponse& response,
                                   Vector<char>& data,
                                   Frame* frame)
{
    if (IsActive()) {
        Cancel();
    }
    iStatus = KRequestPending;
        
    SetActive();

    // Initialize loader for processing responses
    m_synchLoader =  SynchResourceHandleClient::create(iStatus, request, frame);
    if (!m_synchLoader) {
        if (IsActive()) {
            Cancel();
        }
        error = m_error;
        return;
    }
    
    // Wait for request finished or other failure/cancel events
    iActiveSchedulerWait->Start();

    if (m_error.errorCode() != KErrNone) {
    	// Prefer local override of error (e.g., to signal user cancel)
    	error = m_error;
    }
    else {
    	error = m_synchLoader->resourceError();
    }
    data = m_synchLoader->data();
    response = m_synchLoader->resourceResponse();
    
    m_synchLoader = 0;
}

} // end namespace WebCore

// End of File