diff -r 000000000000 -r 3ce708148e4d pnpmobileservices/pnpms/OnlineSupport/src/MiniBrowser.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/pnpmobileservices/pnpms/OnlineSupport/src/MiniBrowser.cpp	Thu Dec 17 08:40:12 2009 +0200
@@ -0,0 +1,801 @@
+/*
+* Copyright (c) 2005-2006 Nokia Corporation and/or its subsidiary(-ies). 
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of "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:  Mini web browser for downloading settings files
+*
+*/
+
+
+// INCLUDE FILES
+#include <in_sock.h>
+#include <uri8.h>
+#include <http.h>
+#include <CWPEngine.h>
+#include <commdbconnpref.h>
+#include <etelmm.h>
+#include <basched.h>            // For KLeaveExit
+#include <AknGlobalNote.h> 
+#include <avkon.rsg>            // For R_AVKON_SOFTKEYS_CLOSE
+
+#include "MiniBrowser.h"
+#include "OnlineSupportLogger.h"
+#include "NHeadWrapperParser.h"
+#include "SupportedContentTypes.h"
+#include "VersionStrings.h"
+
+// 50 secs time-out
+const TInt KTimeOut( 50000000 );
+const TInt KInitialDataBufferSize( 2048 );
+const TInt KInitialReportUrlBufferSize( 512 );
+// maximum length of the info message (currently not supported)
+//const TInt KMaxMessageLength(256);
+//_LIT( KMiniBrowserPanic, "CMiniBrowser" );
+_LIT8( KHttpProtString, "HTTP/TCP" );
+_LIT8( KNokiaHeadWrapper, "application/vnd.nokia.headwrapper" );
+
+_LIT( KAmpersand, "&" );
+_LIT( KQuestionMark, "?" );
+_LIT( KStatus, "Status=" );
+
+CMiniBrowser* CMiniBrowser::NewLC(
+    MMiniBrowserObserver& aObserver,
+    RSocketServ& aSockerServ,
+    RConnection& aConnection )
+    {
+    CMiniBrowser* self = new (ELeave) CMiniBrowser( aObserver );
+    CleanupStack::PushL( self );
+    self->ConstructL( aSockerServ, aConnection );
+    return self;
+    }
+
+CMiniBrowser* CMiniBrowser::NewL(
+    MMiniBrowserObserver& aObserver,
+    RSocketServ& aSockerServ,
+    RConnection& aConnection )
+    {
+    CMiniBrowser* self = NewLC( aObserver, aSockerServ, aConnection );
+    CleanupStack::Pop( self );
+    return self;
+    }
+
+CMiniBrowser::~CMiniBrowser()
+    {
+    LOGSTRING( "CMiniBrowser::~CMiniBrowser" );
+    if( iPeriodic->IsActive() )
+        {
+        iPeriodic->Cancel();
+        }
+
+    delete iUri;
+    delete iPeriodic;
+    delete iResponseData;
+    delete iReportUrl;
+    iTransaction.Close();
+    iSession.Close();
+
+    LOGSTRING( "CMiniBrowser::~CMiniBrowser - done" );
+    }
+
+CMiniBrowser::CMiniBrowser( MMiniBrowserObserver& aObserver ) :
+    iObserver( aObserver ),
+    iContentType( EContentTypeUnknown ),
+    iProvisioningStatus( THttpProvStates::EStatusUnknown )
+    {
+    }
+
+void CMiniBrowser::ConstructL( RSocketServ& aSockerServ, RConnection& aConnection )
+    {
+    LOGSTRING( "CMiniBrowser::ConstructL" );
+
+    iUri = HBufC8::NewL(1);
+    iPeriodic = CPeriodic::NewL( CActive::EPriorityStandard );
+    iResponseData = HBufC8::NewL( KInitialDataBufferSize );
+    iReportUrl = HBufC8::NewL( KInitialReportUrlBufferSize );
+
+    // Opens session using protocol HTTP/TCP
+    LOGSTRING( "CMiniBrowser: iSession.OpenL" );
+    iSession.OpenL( KHttpProtString );
+    LOGSTRING( "CMiniBrowser: iSession.OpenL - done" );
+    iSessionStringPool = iSession.StringPool();
+
+    RHTTPConnectionInfo connectionInfo = iSession.ConnectionInfo();
+
+    // Set SocketServ and Connection explicitly as we do not want to show
+    // the AP selection list to the user when making submit for the request
+    connectionInfo.SetPropertyL(
+        iSessionStringPool.StringF( HTTP::EHttpSocketServ,
+        RHTTPSession::GetTable() ),
+        aSockerServ.Handle() );
+    connectionInfo.SetPropertyL(
+        iSessionStringPool.StringF( HTTP::EHttpSocketConnection,
+        RHTTPSession::GetTable() ),
+        reinterpret_cast< TInt > ( &aConnection ) );
+    LOGSTRING( "CMiniBrowser::ConstructL - done" );
+    }
+
+void CMiniBrowser::HttpGetL( const TDesC& aUri )
+    {
+    DoHttpGetL( aUri, EFalse, KNullDesC, 0 );
+    }
+
+void CMiniBrowser::HttpGetL( const TDesC& aUri, const TDesC& aProxyAddress,
+    const TUint aProxyPort )
+    {
+    DoHttpGetL( aUri, ETrue, aProxyAddress, aProxyPort );
+    }
+
+void CMiniBrowser::DoHttpGetL(
+    const TDesC& aUri,
+    const TBool aUseProxy,
+    const TDesC& aProxyAddress,
+    const TUint aProxyPort )
+    {
+    LOGSTRING( "CMiniBrowser::DoHttpGetL" );
+
+    ResetResponseDataL();
+
+    delete iUri;
+    iUri = 0;
+    iUri = HBufC8::NewL( aUri.Length() );
+    iUri->Des().Copy( aUri );
+
+    TUriParser8 uriParser;
+
+    // In case URL is not valid the transaction will fail with code KErrHttpInvalidUri
+    // uriParser does not leave in all invalid uri cases
+#ifdef _DEBUG
+    LOGSTRING( "CMiniBrowser::HttpGetL uri:" );
+    //LOGTEXT( aUri );
+    for( TInt i(0); i < aUri.Length(); i += 128 )
+        {
+        LOGTEXT( aUri.Right( aUri.Length() - i ) );
+        }
+#endif
+    User::LeaveIfError( uriParser.Parse( *iUri ) );
+
+    RHTTPConnectionInfo connectionInfo = iSession.ConnectionInfo();
+
+    // The default value is HTTP::EDoNotUseProxy
+    if( aUseProxy )
+        {
+        LOGSTRING("CMiniBrowser: using proxy");
+        connectionInfo.SetPropertyL(
+            iSessionStringPool.StringF( HTTP::EProxyUsage, RHTTPSession::GetTable() ),
+            iSessionStringPool.StringF( HTTP::EUseProxy, RHTTPSession::GetTable() ) );
+
+        LOGSTRING("Set Proxy address")
+        HBufC8* proxy = HBufC8::NewLC( aProxyAddress.Length() + 1 + 16 );
+        TPtr8 proxyPtr = proxy->Des();
+        proxyPtr.Copy( aProxyAddress );
+        proxyPtr.Append( _L8( ":" ) );
+        proxyPtr.AppendNum( aProxyPort );
+        LOGTEXT( proxyPtr );
+
+        RStringF proxyF = iSessionStringPool.OpenFStringL( *proxy );
+        CleanupClosePushL( proxyF );
+
+        connectionInfo.SetPropertyL(
+            iSessionStringPool.StringF( HTTP::EProxyAddress, RHTTPSession::GetTable() ),
+            proxyF );
+
+        CleanupStack::PopAndDestroy(1); // proxyF.Close()
+        CleanupStack::PopAndDestroy( proxy );
+        }
+    else
+        {
+        LOGSTRING("CMiniBrowser: NOT using proxy");
+        connectionInfo.SetPropertyL(
+            iSessionStringPool.StringF( HTTP::EProxyUsage, RHTTPSession::GetTable() ),
+            iSessionStringPool.StringF( HTTP::EDoNotUseProxy, RHTTPSession::GetTable() ) );
+        }
+
+    LOGSTRING( "CMiniBrowser: iSession.OpenTransactionL" );
+    iTransaction = iSession.OpenTransactionL( uriParser, *this,
+        iSessionStringPool.StringF( HTTP::EGET, RHTTPSession::GetTable() ) );
+    LOGSTRING( "CMiniBrowser: iSession.OpenTransactionL - done" );
+
+
+    // Set user agent string (we have our own user agent string definition,
+    // not Mozilla compatible)
+    HBufC8* userAgent = NULL;
+    TRAPD( err, userAgent = GetUserAgentStringL() );
+    if( err != KErrNone )
+        {
+        LOGSTRING2( "Error in GetUserAgentStringL: %i", err );
+        }
+    else
+        {
+        CleanupStack::PushL( userAgent );
+        LOGTEXT( *userAgent );
+        RHTTPHeaders headers = iTransaction.Request().GetHeaderCollection();
+        RStringF str = iSessionStringPool.OpenFStringL( *userAgent );
+        CleanupClosePushL( str );
+        headers.SetFieldL(
+            iSessionStringPool.StringF( HTTP::EUserAgent, RHTTPSession::GetTable() ),
+            str );
+        CleanupStack::PopAndDestroy(); // str.Close()
+        CleanupStack::PopAndDestroy( userAgent );
+        }
+
+
+    TCallBack callBack( TimeOutCallBack, this );
+    if( iPeriodic->IsActive() )
+        {
+        iPeriodic->Cancel();
+        }
+    iPeriodic->Start( KTimeOut, KTimeOut, callBack );
+
+    iTransaction.SubmitL();
+    LOGSTRING( "CMiniBrowser::HttpGetL - done" );
+    }
+
+HBufC8* CMiniBrowser::GetUserAgentStringL()
+    {
+    LOGSTRING("CMiniBrowser::GetUserAgentStringL");
+
+    _LIT8( KUserAgentName, "OnlineSupport");
+    _LIT8( KSlash, "/");
+    _LIT8( KSpace, " ");
+    _LIT8( KSymbianOS, "SymbianOS");
+    _LIT8( KS60, "Series60");
+    _LIT8( KQuestionMark, "?" );
+    _LIT( KPhoneModuleName, "Phonetsy.tsy");
+    _LIT( KPhoneName, "DefaultPhone");
+    const TChar lineFeedChar( 0xA );
+
+    RTelServer telServer;
+    User::LeaveIfError( telServer.Connect() );
+    CleanupClosePushL( telServer );
+    User::LeaveIfError( telServer.LoadPhoneModule( KPhoneModuleName ) );
+    RMobilePhone phone;
+    User::LeaveIfError( phone.Open( telServer, KPhoneName ) );
+    CleanupClosePushL( phone );
+    LOGSTRING("CMiniBrowser::GetUserAgentStringL 2");
+
+    RMobilePhone::TMobilePhoneIdentityV1 phoneIdentity;
+    TRequestStatus status( KRequestPending );
+    phone.GetPhoneId( status, phoneIdentity );
+    User::WaitForRequest( status );
+
+
+    // parse sw version from the string
+    // sw version is assumed to be string between first "V" and "\n"
+    LOGSTRING("Reading sw version info");
+    TBuf<KSysUtilVersionTextLength> versions;
+    User::LeaveIfError( SysUtil::GetSWVersion( versions ) );
+    LOGTEXT( versions );
+
+    // SW version
+    LOGSTRING("Locating sw version from the string");
+    TInt begin(0);
+    TInt len(0);
+    // Assume sw version is in the first row (use line feed as a token separator)
+    TBuf8<KSysUtilVersionTextLength> sw;
+    TVersionStrings::TokenLocationL( versions, lineFeedChar, 0, sw.MaxLength(), begin, len );
+    if( len <= 2 )
+        {
+        User::Leave( KErrNotFound );
+        }
+
+    _LIT(KVerStrStart,"V ");
+    TInt pos1 = versions.Find(KVerStrStart);
+    if (pos1 != KErrNotFound)
+        {
+        sw.Copy( versions.Mid( begin + 2, len - 2 ) ); // remove "V "
+        }
+    else
+        {
+        // SW version does not always start with "V "
+        sw.Copy( versions.Mid( begin, len ) );
+        }
+    
+    LOGTEXT( sw );
+
+
+    // Series 60 and Symbian OS versions
+    LOGSTRING("Reading OS versions");
+    TVersionBuf s60Version;
+    s60Version.Copy( KQuestionMark );
+    TVersionBuf symbianVersion;
+    symbianVersion.Copy( KQuestionMark );
+    TRAPD( err, TVersionStrings::GetUserAgentVersionsL( s60Version, symbianVersion ) );
+    if( err != KErrNone )
+        {
+        LOGSTRING2( "Error: %i", err );
+        }
+
+    LOGSTRING("Series60 version");
+    LOGTEXT( s60Version );
+    LOGSTRING("SymbianOS version");
+    LOGTEXT( symbianVersion );
+
+
+    LOGSTRING("CMiniBrowser::GetUserAgentStringL 3");
+    // The string is of format:
+    // OnlineSupport <manufacturer><model>/<sw> SymbianOS/<symbian_os_version> S60/<S60_version>
+    HBufC8* agent = HBufC8::NewLC(
+        KUserAgentName().Length() +
+        phoneIdentity.iManufacturer.Length() +
+        phoneIdentity.iModel.Length() +
+        sw.Length() +
+        KSymbianOS().Length() +
+        symbianVersion.Length() +
+        KS60().Length() +
+        s60Version.Length() +
+        3 * KSlash().Length() +      /* three slasles in the string */
+        3 * KSpace().Length()        /* three spaces in the string */
+        );
+    LOGSTRING("CMiniBrowser::GetUserAgentStringL 3.5");
+    TPtr8 agentPtr = agent->Des();
+    agentPtr.Append( KUserAgentName );
+    agentPtr.Append( KSpace);
+    agentPtr.Append( phoneIdentity.iManufacturer );
+    agentPtr.Append( phoneIdentity.iModel );
+    agentPtr.Append( KSlash );
+    agentPtr.Append( sw );
+    agentPtr.Append( KSpace);
+    agentPtr.Append( KSymbianOS );
+    agentPtr.Append( KSlash);
+    agentPtr.Append( symbianVersion );
+    agentPtr.Append( KSpace);
+    agentPtr.Append( KS60 );
+    agentPtr.Append( KSlash);
+    agentPtr.Append( s60Version );
+
+    LOGSTRING("CMiniBrowser::GetUserAgentStringL 4");
+    CleanupStack::Pop( agent );
+    CleanupStack::PopAndDestroy(); // phone.Close()
+    CleanupStack::PopAndDestroy(); // telServer.Close()
+    LOGSTRING("CMiniBrowser::GetUserAgentStringL - done");
+    return agent;
+    }
+
+
+TInt CMiniBrowser::TimeOutCallBack( TAny* aMiniBrowser)
+    {
+    TRAPD( err, ( ( CMiniBrowser* ) aMiniBrowser )->DoTimeOutCallBackL() );
+    if( err == KLeaveExit )
+        {
+        User::Leave( KLeaveExit );
+        }
+    return err;
+    }
+
+void CMiniBrowser::DoTimeOutCallBackL()
+    {
+    LOGSTRING( "CMiniBrowser::DoTimeOutCallBackL" );
+    if( iPeriodic->IsActive() )
+        {
+        iPeriodic->Cancel();
+        }
+
+    TRAPD( err, iObserver.MiniBrowserErrorL( KErrTimedOut ) );
+    if( err != KErrNone )
+        {
+        iObserver.MiniBrowserUnhandledLeave( err );
+        }
+    if( err == KLeaveExit )
+        {
+        User::Leave( err ); 
+        }
+
+    LOGSTRING( "CMiniBrowser::DoTimeOut - done" );
+    }
+
+void CMiniBrowser::MHFRunL( RHTTPTransaction aTransaction, const THTTPEvent &aEvent )
+    {
+    LOGSTRING( "CMiniBrowser::MHFRunL" );
+    if( iPeriodic->IsActive() )
+        {
+        iPeriodic->Cancel();
+        }
+
+    switch( aEvent.iStatus )
+        {
+        case THTTPEvent::ESubmit:
+            {
+            LOGSTRING( "CMiniBrowser::MHFRunL:ESubmit" );
+            LOGTEXT( aTransaction.Request().URI().UriDes() );
+
+            LOGSTRING( "CMiniBrowser: reset ResponseData" );
+            ResetResponseDataL();
+            break;
+            }
+        case THTTPEvent::EGotResponseHeaders:
+            {
+            LOGSTRING( "CMiniBrowser::MHFRunL:EGotResponseHeaders" );
+            THTTPHdrVal value;
+            TInt err = aTransaction.Response().GetHeaderCollection().GetField(
+                iSessionStringPool.StringF( HTTP::EContentType, RHTTPSession::GetTable() ), 0, value );
+
+            if( err == KErrNone )
+            {
+                LOGSTRING("Content type:");
+                const TDesC8& contentType = value.StrF().DesC();
+                LOGTEXT( contentType );
+                if( contentType.Compare( KNokiaHeadWrapper ) == 0 )
+                    {
+                    iContentType = EContentTypeNokiaHeadWrapper;
+                    }
+                else
+                    {
+                    iContentType = EContentTypeUnknown;
+                    }
+            }
+
+            TCallBack callBack( TimeOutCallBack, this );
+            if( iPeriodic->IsActive() )
+                {
+                iPeriodic->Cancel();
+                }
+            iPeriodic->Start( KTimeOut, KTimeOut, callBack );
+            break;
+            }
+        case THTTPEvent::EGotResponseBodyData:
+            {
+            LOGSTRING( "CMiniBrowser::MHFRunL:EGotResponseBodyData" );
+            MHTTPDataSupplier* pBody = aTransaction.Response().Body();
+            if( pBody )
+                {
+                TPtrC8 dataChunk;
+                pBody->GetNextDataPart( dataChunk );
+                // Log
+                LOGSTRING( "CMiniBrowser: MHTTPDataSupplier:" );
+#ifdef _DEBUG
+                for( TInt i(0); i < dataChunk.Length(); i += 128 )
+                    {
+                    LOGTEXT( dataChunk.Right( dataChunk.Length() - i ) );
+                    }
+#endif
+                AppendResponseDataL( dataChunk );
+                pBody->ReleaseData();
+                }
+            LOGSTRING( "CMiniBrowser::MHFRunL:EGotResponseBodyData - 2" );
+
+            TCallBack callBack( TimeOutCallBack, this );
+            if( iPeriodic->IsActive() )
+                {
+                iPeriodic->Cancel();
+                }
+            iPeriodic->Start( KTimeOut, KTimeOut, callBack );
+            break;
+            }
+        case THTTPEvent::EResponseComplete:
+            {
+            LOGSTRING( "CMiniBrowser::MHFRunL:EResponseComplete" );
+            break;
+            }
+        case THTTPEvent::ESucceeded:
+            {
+            LOGSTRING( "CMiniBrowser::MHFRunL:ESucceeded" );
+
+            if( iContentType == EContentTypeNokiaHeadWrapper )
+                {
+                TRAPD( err, ParseAndSaveProvisionedSettingsL() );
+                if( err != THttpProvStates::EStatusOk )
+                    {
+                    User::Leave( err );
+                    }
+                }
+            else if( iContentType == EContentTypeUnknown )
+                {
+                TRAPD( err, ParseAndSaveProvisionedSettingsL() );
+                if( err != THttpProvStates::EStatusOk )
+                    {
+                    User::Leave( err );
+                    }
+                }
+            iObserver.MiniBrowserRequestDoneL();
+            }
+            break;
+        case THTTPEvent::EFailed:
+            LOGSTRING( "CMiniBrowser::MHFRunL:EFailed" );
+            ResetResponseDataL();
+            User::Leave( KErrGeneral );
+            break;
+        default:
+            {
+            LOGSTRING2( "CMiniBrowser::MHFRunL:event: %i", aEvent.iStatus );
+            break;
+            }
+        }
+
+    LOGSTRING( "CMiniBrowser::MHFRunL - done" );
+    }
+
+// currently not supported
+//void CMiniBrowser::ShowMessageDialogL( const TDesC8& aMessage )
+//    {
+//    LOGSTRING( "ShowMessageDialogL" );
+//    LOGTEXT( aMessage );
+//    TInt length = aMessage.Length();
+//    if( length > KMaxMessageLength )
+//        {
+//        length = KMaxMessageLength;
+//        }
+//    HBufC* message = HBufC::NewLC( length );
+//    message->Des().Copy( aMessage.Left( length ) );
+//
+//    CAknGlobalNote* globalNote = CAknGlobalNote::NewL();
+//    CleanupStack::PushL( globalNote );
+//    globalNote->SetSoftkeys( R_AVKON_SOFTKEYS_CLOSE );
+//    globalNote->ShowNoteL( EAknGlobalInformationNote , *message );
+//
+//    LOGSTRING( "deleting globalNote" );
+//    CleanupStack::PopAndDestroy( globalNote );
+//    CleanupStack::PopAndDestroy( message );
+//    LOGSTRING( "ShowMessageDialogL - done" );
+//    }
+
+
+void CMiniBrowser::ParseAndSaveProvisionedSettingsL()
+    {
+    LOGSTRING( "CMiniBrowser::ParseAndSaveProvisionedSettingsL - begin" );
+    if( !iResponseData )
+        {
+        User::Leave( THttpProvStates::EStatusWrapperParsingFailed );
+        }
+    LOGSTRING( "CMiniBrowser::SaveProvisionedSettingsL - 2" );
+    CNHeadWrapperParser* NHwrParser = CNHeadWrapperParser::NewL( *iResponseData );
+    CleanupStack::PushL( NHwrParser );
+    LOGSTRING( "CMiniBrowser::SaveProvisionedSettingsL - 3" );
+    iProvisioningStatus = NHwrParser->Parse();
+    LOGSTRING( "CMiniBrowser::SaveProvisionedSettingsL - 4" );
+    if( iProvisioningStatus != THttpProvStates::EStatusOk )
+        {
+        LOGSTRING2( "status from parse:%i", iProvisioningStatus ); 
+        // Try to get report url anyways, this should succeed at leat in case
+        // Nokia HeadWrapper authentication failed while parsing an otherwise valid
+        // HeadWrapper document
+        GetReportUrlL( *NHwrParser );
+        User::Leave( iProvisioningStatus );
+        }
+    LOGSTRING( "CMiniBrowser::SaveProvisionedSettingsL - 5" );
+    GetReportUrlL( *NHwrParser );
+    LOGSTRING( "CMiniBrowser::SaveProvisionedSettingsL - 6" );
+    // Get provisioned data
+    TPtrC8 content;
+    TRAPD( err, content.Set( NHwrParser->GetContentL() ) );
+    if( err != KErrNone )
+        {
+        LOGSTRING2( "err from GetContentL:%i", err );
+        iProvisioningStatus = THttpProvStates::EStatusDocumentParsingFailed;
+        User::Leave( err );
+        }
+
+    LOGSTRING( "Response parsed" ); 
+
+    TPtrC8 contentType;
+    TRAP( err, contentType.Set( NHwrParser->GetContentTypeL() ) );
+    if( err != KErrNone )
+        {
+        LOGSTRING2( "err from GetContentTypeL:%i", err );
+        iProvisioningStatus = THttpProvStates::EStatusDocumentParsingFailed;
+        User::Leave( err );
+        }
+
+    if( contentType.Compare( KContentTypeApplicationWapConnectivityWbxml ) == 0 )
+        {
+        LOGSTRING( "CMiniBrowser: content type application/vnd.wap.connectivity-wbxml" );
+        TRAP( err, SaveProvisionedSettingsL( content ) );
+        iProvisioningStatus = (THttpProvStates::TProvisioningStatus) err;
+        if( iProvisioningStatus != THttpProvStates::EStatusOk )
+            {
+            LOGSTRING2( "ProvisioningStatus from SaveProvisionedSettingsL:%i", iProvisioningStatus ); 
+            User::Leave( iProvisioningStatus );
+            }
+        }
+// currently not supported
+//    else if( contentType.Compare( KContentTypeTextPlain ) == 0 )
+//        {
+//        LOGSTRING( "CMiniBrowser: content type text/plain" );
+//        ShowMessageDialogL( content );
+//        }
+    else
+        {
+        LOGSTRING( "CMiniBrowser: Unknown content type" );
+        User::Leave( THttpProvStates::EStatusWrapperParsingFailed );
+        }
+
+    CleanupStack::PopAndDestroy( NHwrParser );
+    LOGSTRING( "CMiniBrowser::SaveProvisionedSettingsL - done" );
+    }
+
+void CMiniBrowser::GetReportUrlL( const CNHeadWrapperParser& aNHwrParser )
+    {
+    LOGSTRING( "CMiniBrowser::GetReportUrlL - begin" );
+    // Store report URL for later reference
+    const TDesC8& reportUrl = aNHwrParser.GetReportUrlL();
+    if( iReportUrl->Des().MaxLength() < reportUrl.Length() )
+        {
+        delete iReportUrl;
+        iReportUrl = 0;
+        iReportUrl = HBufC8::NewL( reportUrl.Length() );
+        }
+    TPtr8 reportUrlPtr = iReportUrl->Des();
+    reportUrlPtr.Copy( reportUrl );
+    LOGTEXT( *iReportUrl );
+    LOGSTRING( "CMiniBrowser::GetReportUrlL - end" );
+    }
+
+HBufC* CMiniBrowser::GetReportUrlLC()
+    {
+    LOGSTRING( "CMiniBrowser::GetReportUrlLC - begin" );
+    if( iReportUrl && iReportUrl->Length() )
+        {
+        HBufC* url = HBufC::NewLC(
+            iReportUrl->Length() +
+            KAmpersand().Length() +
+            KQuestionMark().Length() +
+            KStatus().Length() );
+
+        TPtr urlPtr = url->Des();
+        urlPtr.Copy( *iReportUrl );
+
+        // Add provisioning status to the url if known
+        if( iProvisioningStatus != THttpProvStates::EStatusUnknown )
+            {
+            // Assume there might already be parameters in the URL given
+            if( urlPtr.Find( KQuestionMark ) != KErrNotFound )
+                {
+                urlPtr.Append( KAmpersand );
+                }
+            else
+                {
+                urlPtr.Append( KQuestionMark );
+                }
+            urlPtr.Append( KStatus );
+            urlPtr.AppendNum( (TInt) iProvisioningStatus );
+            }
+        LOGSTRING( "CMiniBrowser::GetReportUrlLC - end" );
+        return url;
+        }
+    else
+        {
+        LOGSTRING( "CMiniBrowser::GetReportUrlLC Leave KErrNotFound" );
+        User::Leave( KErrNotFound );
+        }
+    return NULL; // Not possible to end up here
+    }
+
+void CMiniBrowser::SaveProvisionedSettingsL( const TDesC8& aContent )
+    {
+    LOGSTRING( "CMiniBrowser::SaveProvisionedSettingsL" );
+    TInt status = THttpProvStates::EStatusOk;
+    // Create WPEngine
+    CWPEngine* wpengine = CWPEngine::NewL();
+    CleanupStack::PushL( wpengine );
+
+    LOGSTRING( "wpengine->ImportDocumentL" );   
+    TRAPD( err, wpengine->ImportDocumentL( aContent ) );
+    User::LeaveIfError( err );
+
+    LOGSTRING( "wpengine->PopulateL" );
+    TRAP( err, wpengine->PopulateL() );
+    if( err != KErrNone )
+        {
+        LOGSTRING2( "PopulateL err: %i", err );
+        User::Leave( err );
+        }
+    LOGSTRING( "wpengine->PopulateL success" );
+
+    TInt itemCount = wpengine->ItemCount();
+    // Empty messages are not supported
+    if( itemCount == 0 )
+        {
+        LOGSTRING("No items in provisioning message!");
+        User::Leave( THttpProvStates::EStatusWrapperParsingFailed );
+        }
+
+    for( TInt i(0); i < itemCount; i++ )
+        {
+        LOGSTRING( "Saving" );
+        TRAP( err, wpengine->SaveL( i ) );
+        if( wpengine->CanSetAsDefault( i ) )
+            {
+            LOGSTRING( "Setting as default" );
+            TRAP( err, wpengine->SetAsDefaultL( i ) );
+            }
+        else
+            {
+            LOGSTRING( "Cannot set as default" );
+            }
+        if( err != KErrNone )
+            {
+            LOGSTRING2( "Error while saving: %i", err );
+            status = THttpProvStates::EStatusStorageFailed;
+            }
+        }
+
+    if( status != THttpProvStates::EStatusOk )
+        {
+        User::Leave( status );
+        }
+    }
+
+TInt CMiniBrowser::MHFRunError( TInt aError, RHTTPTransaction /*aTransaction*/, const THTTPEvent& /*aEvent*/ )
+    {
+    LOGSTRING2( "CMiniBrowser::MHFRunError %i", aError );
+    iTransaction.Close();
+    TRAPD( err, iObserver.MiniBrowserErrorL( aError ) );
+    if( err != KErrNone )
+        {
+        iObserver.MiniBrowserUnhandledLeave( err );
+        }
+    LOGSTRING( "CMiniBrowser::MHFRunError - done" );
+    if( err == KLeaveExit )
+        {
+        return err;
+        }
+    return KErrNone;
+    }
+
+
+void CMiniBrowser::AppendResponseDataL( const TDesC8& aData )
+    {
+    LOGSTRING( "CMiniBrowser::AppendResponseDataL()" );
+    if( ( iResponseData->Des().MaxLength() - iResponseData->Length() ) < aData.Length() )
+        {
+        // ReAlloc
+        HBufC8* tempBuf = HBufC8::NewL( iResponseData->Length() + aData.Length() );
+        TPtr8 tempBufPtr = tempBuf->Des();
+        tempBufPtr.Append( *iResponseData );
+        delete iResponseData;
+        iResponseData = tempBuf; 
+        }
+
+    TPtr8 ptr = iResponseData->Des();
+    ptr.Append( aData );
+    LOGSTRING( "CMiniBrowser::AppendResponseDataL() - done" );
+    }
+
+void CMiniBrowser::ResetResponseDataL()
+    {
+    LOGSTRING( "CMiniBrowser::ResetResponseDataL()" );
+    if( iResponseData && iResponseData->Length() )
+        {
+        delete iResponseData;
+        iResponseData = 0;
+        iResponseData = HBufC8::NewL( KInitialDataBufferSize );
+        }
+    if( iReportUrl && iReportUrl->Length() )
+        {
+        delete iReportUrl;
+        iReportUrl = 0;
+        iReportUrl = HBufC8::NewL( KInitialReportUrlBufferSize );
+        }
+    iContentType = EContentTypeUnknown;
+    iProvisioningStatus = THttpProvStates::EStatusUnknown;
+    LOGSTRING( "CMiniBrowser::ResetResponseDataL() - done" );
+    }
+
+TBool CMiniBrowser::GetNextDataPart( TPtrC8 &aDataPart )
+    {
+    _LIT8( KEmpty, "");
+    aDataPart.Set( KEmpty() );
+    return ETrue;
+    }
+
+void CMiniBrowser::ReleaseData()
+    {
+    }
+
+TInt CMiniBrowser::OverallDataSize()
+    {
+    return KErrNotFound;
+    }
+
+TInt CMiniBrowser::Reset()
+    {
+    return KErrNone;
+    }