/****************************************************************************

**

** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).

** All rights reserved.

** Contact: Nokia Corporation (qt-info@nokia.com)

**

** This file is part of the QtNetwork module of the Qt Toolkit.

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

** This file contains pre-release code and may not be distributed.

** You may use this file in accordance with the terms and conditions

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

** Alternatively, this file may be used under the terms of the GNU Lesser

** General Public License version 2.1 as published by the Free Software

** Foundation and appearing in the file LICENSE.LGPL included in the

** packaging of this file.  Please review the following information to

** ensure the GNU Lesser General Public License version 2.1 requirements

** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

**

** In addition, as a special exception, Nokia gives you certain additional

** rights.  These rights are described in the Nokia Qt LGPL Exception

** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

** Nokia at qt-info@nokia.com.

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

****************************************************************************/

#ifndef QNETWORKREPLYIMPL_P_H

#define QNETWORKREPLYIMPL_P_H

//

//  W A R N I N G

//  -------------

//

// This file is not part of the Qt API.  It exists for the convenience

// of the Network Access API.  This header file may change from

// version to version without notice, or even be removed.

//

// We mean it.

//

#include "qnetworkreply.h"

#include "qnetworkreply_p.h"

#include "qnetworkaccessmanager.h"

#include "qnetworkproxy.h"

#include "QtCore/qmap.h"

#include "QtCore/qqueue.h"

#include "QtCore/qbuffer.h"

#include "private/qringbuffer_p.h"

#include "private/qbytedata_p.h"

QT_BEGIN_NAMESPACE

class QAbstractNetworkCache;

class QNetworkAccessBackend;

class QNetworkReplyImplPrivate;

class QNetworkReplyImpl: public QNetworkReply

{

    Q_OBJECT

public:

    QNetworkReplyImpl(QObject *parent = 0);

    ~QNetworkReplyImpl();

    virtual void abort();

    // reimplemented from QNetworkReply / QIODevice

    virtual void close();

    virtual qint64 bytesAvailable() const;

    virtual void setReadBufferSize(qint64 size);

    virtual bool canReadLine () const;

    virtual qint64 readData(char *data, qint64 maxlen);

    virtual bool event(QEvent *);

#ifndef QT_NO_OPENSSL

    Q_INVOKABLE QSslConfiguration sslConfigurationImplementation() const;

    Q_INVOKABLE void setSslConfigurationImplementation(const QSslConfiguration &configuration);

    virtual void ignoreSslErrors();

    Q_INVOKABLE virtual void ignoreSslErrorsImplementation(const QList<QSslError> &errors);

#endif

    Q_DECLARE_PRIVATE(QNetworkReplyImpl)

    Q_PRIVATE_SLOT(d_func(), void _q_startOperation())

    Q_PRIVATE_SLOT(d_func(), void _q_copyReadyRead())

    Q_PRIVATE_SLOT(d_func(), void _q_copyReadChannelFinished())

    Q_PRIVATE_SLOT(d_func(), void _q_bufferOutgoingData())

    Q_PRIVATE_SLOT(d_func(), void _q_bufferOutgoingDataFinished())

#ifndef QT_NO_BEARERMANAGEMENT

    Q_PRIVATE_SLOT(d_func(), void _q_networkSessionConnected())

    Q_PRIVATE_SLOT(d_func(), void _q_networkSessionFailed())

#endif

};

class QNetworkReplyImplPrivate: public QNetworkReplyPrivate

{

public:

    enum InternalNotifications {

        NotifyDownstreamReadyWrite,

        NotifyCloseDownstreamChannel,

        NotifyCopyFinished

    };

    enum State {

        Idle,               // The reply is idle.

        Buffering,          // The reply is buffering outgoing data.

        Working,            // The reply is uploading/downloading data.

        Finished,           // The reply has finished.

        Aborted,            // The reply has been aborted.

        WaitingForSession,  // The reply is waiting for the session to open before connecting.

        Reconnecting        // The reply will reconnect to once roaming has completed.

    };

    typedef QQueue<InternalNotifications> NotificationQueue;

    QNetworkReplyImplPrivate();

    void _q_startOperation();

    void _q_sourceReadyRead();

    void _q_sourceReadChannelFinished();

    void _q_copyReadyRead();

    void _q_copyReadChannelFinished();

    void _q_bufferOutgoingData();

    void _q_bufferOutgoingDataFinished();

#ifndef QT_NO_BEARERMANAGEMENT

    void _q_networkSessionConnected();

    void _q_networkSessionFailed();

#endif

    void setup(QNetworkAccessManager::Operation op, const QNetworkRequest &request,

               QIODevice *outgoingData);

    void pauseNotificationHandling();

    void resumeNotificationHandling();

    void backendNotify(InternalNotifications notification);

    void handleNotifications();

    void createCache();

    void completeCacheSave();

    // callbacks from the backend (through the manager):

    void setCachingEnabled(bool enable);

    bool isCachingEnabled() const;

    void consume(qint64 count);

    void emitUploadProgress(qint64 bytesSent, qint64 bytesTotal);

    qint64 nextDownstreamBlockSize() const;

    void initCacheSaveDevice();

    void appendDownstreamDataSignalEmissions();

    void appendDownstreamData(QByteDataBuffer &data);

    void appendDownstreamData(QIODevice *data);

    void appendDownstreamData(const QByteArray &data);

    void finished();

    void error(QNetworkReply::NetworkError code, const QString &errorString);

    void metaDataChanged();

    void redirectionRequested(const QUrl &target);

    void sslErrors(const QList<QSslError> &errors);

    bool isFinished() const;

    QNetworkAccessBackend *backend;

    QIODevice *outgoingData;

    QRingBuffer *outgoingDataBuffer;

    QIODevice *copyDevice;

    QAbstractNetworkCache *networkCache() const;

    bool migrateBackend();

    bool cacheEnabled;

    QIODevice *cacheSaveDevice;

    NotificationQueue pendingNotifications;

    bool notificationHandlingPaused;

    QUrl urlForLastAuthentication;

#ifndef QT_NO_NETWORKPROXY

    QNetworkProxy lastProxyAuthentication;

    QList<QNetworkProxy> proxyList;

#endif

    QByteDataBuffer readBuffer;

    qint64 bytesDownloaded;

    qint64 lastBytesDownloaded;

    qint64 bytesUploaded;

    qint64 preMigrationDownloaded;

    QString httpReasonPhrase;

    int httpStatusCode;

    State state;

    Q_DECLARE_PUBLIC(QNetworkReplyImpl)

};

#ifndef QT_NO_BEARERMANAGEMENT

class QDisabledNetworkReply : public QNetworkReply

{

    Q_OBJECT

public:

    QDisabledNetworkReply(QObject *parent, const QNetworkRequest &req,

                          QNetworkAccessManager::Operation op);

    ~QDisabledNetworkReply();

    void abort() { }

protected:

    qint64 readData(char *, qint64) { return -1; }

};

#endif

QT_END_NAMESPACE

#endif