Initial import from the monolithic Qt.

This is the beginning of revision history for this module. If you
want to look at revision history older than this, please refer to the
Qt Git wiki for how to use Git history grafting. At the time of
writing, this wiki is located here:

http://qt.gitorious.org/qt/pages/GitIntroductionWithQt

If you have already performed the grafting and you don't see any
history beyond this commit, try running "git log" with the "--follow"
argument.

Branched from the monolithic repo, Qt master branch, at commit
896db169ea224deb96c59ce8af800d019de63f12

1 files changed, 536 insertions, 0 deletions

diff --git a/src/network/access/qabstractnetworkcache.cpp b/src/network/access/qabstractnetworkcache.cpp
new file mode 100644
index 0000000000..de3fcc3286
--- /dev/null
+++ b/src/network/access/qabstractnetworkcache.cpp
@@ -0,0 +1,536 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 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$
+**
+****************************************************************************/
+
+#include "qabstractnetworkcache.h"
+#include "qabstractnetworkcache_p.h"
+
+#include <qdatetime.h>
+#include <qurl.h>
+
+#include <qdebug.h>
+
+QT_BEGIN_NAMESPACE
+
+class QNetworkCacheMetaDataPrivate : public QSharedData
+{
+
+public:
+    QNetworkCacheMetaDataPrivate()
+        : QSharedData()
+        , saveToDisk(true)
+    {}
+
+    bool operator==(const QNetworkCacheMetaDataPrivate &other) const
+    {
+        return
+            url == other.url
+            && lastModified == other.lastModified
+            && expirationDate == other.expirationDate
+            && headers == other.headers
+            && saveToDisk == other.saveToDisk;
+    }
+
+    QUrl url;
+    QDateTime lastModified;
+    QDateTime expirationDate;
+    QNetworkCacheMetaData::RawHeaderList headers;
+    QNetworkCacheMetaData::AttributesMap attributes;
+    bool saveToDisk;
+
+    static void save(QDataStream &out, const QNetworkCacheMetaData &metaData);
+    static void load(QDataStream &in, QNetworkCacheMetaData &metaData);
+};
+Q_GLOBAL_STATIC(QNetworkCacheMetaDataPrivate, metadata_shared_invalid)
+
+/*!
+    \class QNetworkCacheMetaData
+    \since 4.5
+    \inmodule QtNetwork
+
+    \brief The QNetworkCacheMetaData class provides cache information.
+
+    QNetworkCacheMetaData provides information about a cache file including
+    the url, when it was last modified, when the cache file was created, headers
+    for file and if the file should be saved onto a disk.
+
+    \sa QAbstractNetworkCache
+*/
+
+/*!
+    \typedef QNetworkCacheMetaData::RawHeader
+
+    Synonym for QPair<QByteArray, QByteArray>
+*/
+
+/*!
+    \typedef QNetworkCacheMetaData::RawHeaderList
+
+    Synonym for QList<RawHeader>
+*/
+
+/*!
+  \typedef  QNetworkCacheMetaData::AttributesMap
+
+  Synonym for QHash<QNetworkRequest::Attribute, QVariant>
+*/
+
+/*!
+    Constructs an invalid network cache meta data.
+
+    \sa isValid()
+ */
+QNetworkCacheMetaData::QNetworkCacheMetaData()
+    : d(new QNetworkCacheMetaDataPrivate)
+{
+}
+
+/*!
+    Destroys the network cache meta data.
+ */
+QNetworkCacheMetaData::~QNetworkCacheMetaData()
+{
+    // QSharedDataPointer takes care of freeing d
+}
+
+/*!
+    Constructs a copy of the \a other QNetworkCacheMetaData.
+ */
+QNetworkCacheMetaData::QNetworkCacheMetaData(const QNetworkCacheMetaData &other)
+    : d(other.d)
+{
+}
+
+/*!
+    Makes a copy of the \a other QNetworkCacheMetaData and returns a reference to the copy.
+ */
+QNetworkCacheMetaData &QNetworkCacheMetaData::operator=(const QNetworkCacheMetaData &other)
+{
+    d = other.d;
+    return *this;
+}
+
+/*!
+    Returns true if this meta data is equal to the \a other meta data; otherwise returns false.
+
+    \sa operator!=()
+ */
+bool QNetworkCacheMetaData::operator==(const QNetworkCacheMetaData &other) const
+{
+    if (d == other.d)
+        return true;
+    if (d && other.d)
+        return *d == *other.d;
+    return false;
+}
+
+/*!
+    \fn bool QNetworkCacheMetaData::operator!=(const QNetworkCacheMetaData &other) const
+
+    Returns true if this meta data is not equal to the \a other meta data; otherwise returns false.
+
+    \sa operator==()
+ */
+
+/*!
+    Returns true if this network cache meta data has attributes that have been set otherwise false.
+ */
+bool QNetworkCacheMetaData::isValid() const
+{
+    return !(*d == *metadata_shared_invalid());
+}
+
+/*!
+    Returns is this cache should be allowed to be stored on disk.
+
+    Some cache implementations can keep these cache items in memory for performance reasons,
+    but for security reasons they should not be written to disk.
+
+    Specifically with http, documents marked with Pragma: no-cache, or have a Cache-control set to
+    no-store or no-cache or any https document that doesn't have "Cache-control: public" set will
+    set the saveToDisk to false.
+
+    \sa setSaveToDisk()
+ */
+bool QNetworkCacheMetaData::saveToDisk() const
+{
+    return d->saveToDisk;
+}
+
+/*!
+    Sets whether this network cache meta data and associated content should be
+    allowed to be stored on disk to \a allow.
+
+    \sa saveToDisk()
+ */
+void QNetworkCacheMetaData::setSaveToDisk(bool allow)
+{
+    d->saveToDisk = allow;
+}
+
+/*!
+    Returns the URL this network cache meta data is referring to.
+
+    \sa setUrl()
+ */
+QUrl QNetworkCacheMetaData::url() const
+{
+    return d->url;
+}
+
+/*!
+    Sets the URL this network cache meta data to to be \a url.
+
+    The password and fragment are removed from the url.
+
+    \sa url()
+ */
+void QNetworkCacheMetaData::setUrl(const QUrl &url)
+{
+    d->url = url;
+    d->url.setPassword(QString());
+    d->url.setFragment(QString());
+}
+
+/*!
+    Returns a list of all raw headers that are set in this meta data.
+    The list is in the same order that the headers were set.
+
+    \sa setRawHeaders()
+ */
+QNetworkCacheMetaData::RawHeaderList QNetworkCacheMetaData::rawHeaders() const
+{
+    return d->headers;
+}
+
+/*!
+    Sets the raw headers to \a list.
+
+    \sa rawHeaders()
+ */
+void QNetworkCacheMetaData::setRawHeaders(const RawHeaderList &list)
+{
+    d->headers = list;
+}
+
+/*!
+    Returns the date and time when the meta data was last modified.
+ */
+QDateTime QNetworkCacheMetaData::lastModified() const
+{
+    return d->lastModified;
+}
+
+/*!
+    Sets the date and time when the meta data was last modified to \a dateTime.
+ */
+void QNetworkCacheMetaData::setLastModified(const QDateTime &dateTime)
+{
+    d->lastModified = dateTime;
+}
+
+/*!
+    Returns the date and time when the meta data expires.
+ */
+QDateTime QNetworkCacheMetaData::expirationDate() const
+{
+    return d->expirationDate;
+}
+
+/*!
+    Sets the date and time when the meta data expires to \a dateTime.
+ */
+void QNetworkCacheMetaData::setExpirationDate(const QDateTime &dateTime)
+{
+    d->expirationDate = dateTime;
+}
+
+/*!
+    \since 4.6
+
+    Returns all the attributes stored with this cache item.
+
+    \sa setAttributes(), QNetworkRequest::Attribute
+*/
+QNetworkCacheMetaData::AttributesMap QNetworkCacheMetaData::attributes() const
+{
+    return d->attributes;
+}
+
+/*!
+    \since 4.6
+
+    Sets all attributes of this cache item to be the map \a attributes.
+
+    \sa attributes(), QNetworkRequest::setAttribute()
+*/
+void QNetworkCacheMetaData::setAttributes(const AttributesMap &attributes)
+{
+    d->attributes = attributes;
+}
+
+/*!
+    \relates QNetworkCacheMetaData
+    \since 4.5
+
+    Writes \a metaData to the \a out stream.
+
+    \sa {Serializing Qt Data Types}
+*/
+QDataStream &operator<<(QDataStream &out, const QNetworkCacheMetaData &metaData)
+{
+    QNetworkCacheMetaDataPrivate::save(out, metaData);
+    return out;
+}
+
+static inline QDataStream &operator<<(QDataStream &out, const QNetworkCacheMetaData::AttributesMap &hash)
+{
+    out << quint32(hash.size());
+    QNetworkCacheMetaData::AttributesMap::ConstIterator it = hash.end();
+    QNetworkCacheMetaData::AttributesMap::ConstIterator begin = hash.begin();
+    while (it != begin) {
+        --it;
+        out << int(it.key()) << it.value();
+    }
+    return out;
+}
+
+void QNetworkCacheMetaDataPrivate::save(QDataStream &out, const QNetworkCacheMetaData &metaData)
+{
+    // note: if you change the contents of the meta data here
+    // remember to bump the cache version in qnetworkdiskcache.cpp CurrentCacheVersion
+    out << metaData.url();
+    out << metaData.expirationDate();
+    out << metaData.lastModified();
+    out << metaData.saveToDisk();
+    out << metaData.attributes();
+    out << metaData.rawHeaders();
+}
+
+/*!
+    \relates QNetworkCacheMetaData
+    \since 4.5
+
+    Reads a QNetworkCacheMetaData from the stream \a in into \a metaData.
+
+    \sa {Serializing Qt Data Types}
+*/
+QDataStream &operator>>(QDataStream &in, QNetworkCacheMetaData &metaData)
+{
+    QNetworkCacheMetaDataPrivate::load(in, metaData);
+    return in;
+}
+
+static inline QDataStream &operator>>(QDataStream &in, QNetworkCacheMetaData::AttributesMap &hash)
+{
+    hash.clear();
+    QDataStream::Status oldStatus = in.status();
+    in.resetStatus();
+    hash.clear();
+
+    quint32 n;
+    in >> n;
+
+    for (quint32 i = 0; i < n; ++i) {
+        if (in.status() != QDataStream::Ok)
+            break;
+
+        int k;
+        QVariant t;
+        in >> k >> t;
+        hash.insertMulti(QNetworkRequest::Attribute(k), t);
+    }
+
+    if (in.status() != QDataStream::Ok)
+        hash.clear();
+    if (oldStatus != QDataStream::Ok)
+        in.setStatus(oldStatus);
+    return in;
+}
+
+void QNetworkCacheMetaDataPrivate::load(QDataStream &in, QNetworkCacheMetaData &metaData)
+{
+    in >> metaData.d->url;
+    in >> metaData.d->expirationDate;
+    in >> metaData.d->lastModified;
+    in >> metaData.d->saveToDisk;
+    in >> metaData.d->attributes;
+    in >> metaData.d->headers;
+}
+
+/*!
+    \class QAbstractNetworkCache
+    \since 4.5
+    \inmodule QtNetwork
+
+    \brief The QAbstractNetworkCache class provides the interface for cache implementations.
+
+    QAbstractNetworkCache is the base class for every standard cache that is used be
+    QNetworkAccessManager.  QAbstractNetworkCache is an abstract class and cannot be
+    instantiated.
+
+    \sa QNetworkDiskCache
+*/
+
+/*!
+    Constructs an abstract network cache with the given \a parent.
+*/
+QAbstractNetworkCache::QAbstractNetworkCache(QObject *parent)
+    : QObject(*new QAbstractNetworkCachePrivate, parent)
+{
+}
+
+/*!
+    \internal
+*/
+QAbstractNetworkCache::QAbstractNetworkCache(QAbstractNetworkCachePrivate &dd, QObject *parent)
+    : QObject(dd, parent)
+{
+}
+
+/*!
+    Destroys the cache.
+
+    Any operations that have not been inserted are discarded.
+
+    \sa insert()
+ */
+QAbstractNetworkCache::~QAbstractNetworkCache()
+{
+}
+
+/*!
+    \fn QNetworkCacheMetaData QAbstractNetworkCache::metaData(const QUrl &url) = 0
+    Returns the meta data for the url \a url.
+
+    If the url is valid and the cache contains the data for url,
+    a valid QNetworkCacheMetaData is returned.
+
+    In the base class this is a pure virtual function.
+
+    \sa updateMetaData(), data()
+*/
+
+/*!
+    \fn void QAbstractNetworkCache::updateMetaData(const QNetworkCacheMetaData &metaData) = 0
+    Updates the cache meta date for the metaData's url to \a metaData
+
+    If the cache does not contains a cache item for the url then no action is taken.
+
+    In the base class this is a pure virtual function.
+
+    \sa metaData(), prepare()
+*/
+
+/*!
+    \fn QIODevice *QAbstractNetworkCache::data(const QUrl &url) = 0
+    Returns the data associated with \a url.
+
+    It is up to the application that requests the data to delete
+    the QIODevice when done with it.
+
+    If there is no cache for \a url, the url is invalid, or if there
+    is an internal cache error 0 is returned.
+
+    In the base class this is a pure virtual function.
+
+    \sa metaData(), prepare()
+*/
+
+/*!
+    \fn bool QAbstractNetworkCache::remove(const QUrl &url) = 0
+    Removes the cache entry for \a url, returning true if success otherwise false.
+
+    In the base class this is a pure virtual function.
+
+    \sa clear(), prepare()
+*/
+
+/*!
+    \fn QIODevice *QAbstractNetworkCache::prepare(const QNetworkCacheMetaData &metaData) = 0
+    Returns the device that should be populated with the data for
+    the cache item \a metaData.  When all of the data has been written
+    insert() should be called.  If metaData is invalid or the url in
+    the metadata is invalid 0 is returned.
+
+    The cache owns the device and will take care of deleting it when
+    it is inserted or removed.
+
+    To cancel a prepared inserted call remove() on the metadata's url.
+
+    In the base class this is a pure virtual function.
+
+    \sa remove(), updateMetaData(), insert()
+*/
+
+/*!
+    \fn void QAbstractNetworkCache::insert(QIODevice *device) = 0
+    Inserts the data in \a device and the prepared meta data into the cache.
+    After this function is called the data and meta data should be retrievable
+    using data() and metaData().
+
+    To cancel a prepared inserted call remove() on the metadata's url.
+
+    In the base class this is a pure virtual function.
+
+    \sa prepare(), remove()
+*/
+
+/*!
+    \fn qint64 QAbstractNetworkCache::cacheSize() const = 0
+    Returns the current size taken up by the cache.  Depending upon
+    the cache implementation this might be disk or memory size.
+
+    In the base class this is a pure virtual function.
+
+    \sa clear()
+*/
+
+/*!
+    \fn void QAbstractNetworkCache::clear() = 0
+    Removes all items from the cache.  Unless there was failures
+    clearing the cache cacheSize() should return 0 after a call to clear.
+
+    In the base class this is a pure virtual function.
+
+    \sa cacheSize(), remove()
+*/
+
+QT_END_NAMESPACE