whytofly
/
qt6-bb10
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

QNAM - rename Redirect*s*Nnn to RedirectNnn 

As discussed in API code-review.

Change-Id: Ib54cfd43d5bef8c7d99a7fb3b09a9d16dc1dc1dc
Reviewed-by: Edward Welbourne <edward.welbourne@qt.io>
bb10
Timur Pocheptsov 2017-02-23 10:18:43 +01:00
parent 758a56e662
commit 09ca03e1aa
10 changed files with 100 additions and 100 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
src/network/access/qhttpnetworkconnection.cpp
View File

@ -550,15 +550,15 @@ QUrl QHttpNetworkConnectionPrivate::parseRedirectResponse(QAbstractSocket *socke
// Check redirect url protocol
const QUrl priorUrl(reply->request().url());
if (redirectUrl.scheme() == QLatin1String("http") || redirectUrl.scheme() == QLatin1String("https")) {
switch (reply->request().redirectsPolicy()) {
case QNetworkRequest::NoLessSafeRedirectsPolicy:
switch (reply->request().redirectPolicy()) {
case QNetworkRequest::NoLessSafeRedirectPolicy:
// Here we could handle https->http redirects as InsecureProtocolError.
// However, if HSTS is enabled and redirectUrl.host() is a known STS
// host, then we'll replace its scheme and this won't downgrade protocol,
// after all. We cannot access QNAM's STS cache from here, so delegate
// this check to QNetworkReplyHttpImpl.
break;
case QNetworkRequest::SameOriginRedirectsPolicy:
case QNetworkRequest::SameOriginRedirectPolicy:
if (priorUrl.host() != redirectUrl.host()
|| priorUrl.scheme() != redirectUrl.scheme()
|| priorUrl.port() != redirectUrl.port()) {
@ -566,7 +566,7 @@ QUrl QHttpNetworkConnectionPrivate::parseRedirectResponse(QAbstractSocket *socke
return QUrl();
}
break;
case QNetworkRequest::UserVerifiedRedirectsPolicy:
case QNetworkRequest::UserVerifiedRedirectPolicy:
break;
default:
Q_ASSERT(!"Unexpected redirect policy");

16
src/network/access/qhttpnetworkrequest.cpp
View File

@ -49,7 +49,7 @@ QHttpNetworkRequestPrivate::QHttpNetworkRequestPrivate(QHttpNetworkRequest::Oper
: QHttpNetworkHeaderPrivate(newUrl), operation(op), priority(pri), uploadByteDevice(0),
autoDecompress(false), pipeliningAllowed(false), spdyAllowed(false), http2Allowed(false),
withCredentials(true), preConnect(false), redirectCount(0),
redirectsPolicy(QNetworkRequest::ManualRedirectsPolicy)
redirectPolicy(QNetworkRequest::ManualRedirectPolicy)
{
}
@ -67,7 +67,7 @@ QHttpNetworkRequestPrivate::QHttpNetworkRequestPrivate(const QHttpNetworkRequest
ssl(other.ssl),
preConnect(other.preConnect),
redirectCount(other.redirectCount),
redirectsPolicy(other.redirectsPolicy)
redirectPolicy(other.redirectPolicy)
{
}
@ -90,7 +90,7 @@ bool QHttpNetworkRequestPrivate::operator==(const QHttpNetworkRequestPrivate &ot
&& (withCredentials == other.withCredentials)
&& (ssl == other.ssl)
&& (preConnect == other.preConnect)
&& (redirectsPolicy == other.redirectsPolicy);
&& (redirectPolicy == other.redirectPolicy);
}
QByteArray QHttpNetworkRequest::methodName() const
@ -231,17 +231,17 @@ void QHttpNetworkRequest::setPreConnect(bool preConnect)
bool QHttpNetworkRequest::isFollowRedirects() const
{
return d->redirectsPolicy != QNetworkRequest::ManualRedirectsPolicy;
return d->redirectPolicy != QNetworkRequest::ManualRedirectPolicy;
}
void QHttpNetworkRequest::setRedirectsPolicy(QNetworkRequest::RedirectsPolicy policy)
void QHttpNetworkRequest::setRedirectPolicy(QNetworkRequest::RedirectPolicy policy)
{
d->redirectsPolicy = policy;
d->redirectPolicy = policy;
}
QNetworkRequest::RedirectsPolicy QHttpNetworkRequest::redirectsPolicy() const
QNetworkRequest::RedirectPolicy QHttpNetworkRequest::redirectPolicy() const
{
return d->redirectsPolicy;
return d->redirectPolicy;
}
int QHttpNetworkRequest::redirectCount() const

6
src/network/access/qhttpnetworkrequest_p.h
View File

@ -131,8 +131,8 @@ public:
void setPreConnect(bool preConnect);
bool isFollowRedirects() const;
void setRedirectsPolicy(QNetworkRequest::RedirectsPolicy policy);
QNetworkRequest::RedirectsPolicy redirectsPolicy() const;
void setRedirectPolicy(QNetworkRequest::RedirectPolicy policy);
QNetworkRequest::RedirectPolicy redirectPolicy() const;
int redirectCount() const;
void setRedirectCount(int count);
@ -176,7 +176,7 @@ public:
bool ssl;
bool preConnect;
int redirectCount;
QNetworkRequest::RedirectsPolicy redirectsPolicy;
QNetworkRequest::RedirectPolicy redirectPolicy;
};

22
src/network/access/qnetworkaccessmanager.cpp
View File

@ -1157,7 +1157,7 @@ void QNetworkAccessManager::connectToHost(const QString &hostName, quint16 port)
/*!
\since 5.9
Sets the manager's redirects policy to be the \a policy specified. This policy
Sets the manager's redirect policy to be the \a policy specified. This policy
will affect all subsequent requests created by the manager.
Use this function to enable or disable HTTP redirects on the manager's level.
@ -1166,18 +1166,18 @@ void QNetworkAccessManager::connectToHost(const QString &hostName, quint16 port)
the highest priority, next by priority is QNetworkRequest::FollowRedirectsAttribute.
Finally, the manager's policy has the lowest priority.
For backwards compatibility the default value is QNetworkRequest::ManualRedirectsPolicy.
For backwards compatibility the default value is QNetworkRequest::ManualRedirectPolicy.
This may change in the future and some type of auto-redirect policy will become
the default; clients relying on manual redirect handling are encouraged to set
this policy explicitly in their code.
\sa redirectsPolicy(), QNetworkRequest::RedirectsPolicy,
\sa redirectPolicy(), QNetworkRequest::RedirectPolicy,
QNetworkRequest::FollowRedirectsAttribute
*/
void QNetworkAccessManager::setRedirectsPolicy(QNetworkRequest::RedirectsPolicy policy)
void QNetworkAccessManager::setRedirectPolicy(QNetworkRequest::RedirectPolicy policy)
{
Q_D(QNetworkAccessManager);
d->redirectsPolicy = policy;
d->redirectPolicy = policy;
}
/*!
@ -1185,12 +1185,12 @@ void QNetworkAccessManager::setRedirectsPolicy(QNetworkRequest::RedirectsPolicy
Returns the redirect policy that is used when creating new requests.
\sa setRedirectsPolicy(), QNetworkRequest::RedirectsPolicy
\sa setRedirectPolicy(), QNetworkRequest::RedirectPolicy
*/
QNetworkRequest::RedirectsPolicy QNetworkAccessManager::redirectsPolicy() const
QNetworkRequest::RedirectPolicy QNetworkAccessManager::redirectPolicy() const
{
Q_D(const QNetworkAccessManager);
return d->redirectsPolicy;
return d->redirectPolicy;
}
/*!
@ -1280,12 +1280,12 @@ QNetworkReply *QNetworkAccessManager::createRequest(QNetworkAccessManager::Opera
Q_D(QNetworkAccessManager);
QNetworkRequest req(originalReq);
if (req.attribute(QNetworkRequest::RedirectsPolicyAttribute).isNull()
if (req.attribute(QNetworkRequest::RedirectPolicyAttribute).isNull()
&& req.attribute(QNetworkRequest::FollowRedirectsAttribute).isNull()) {
// We only apply the general manager's policy if:
// - RedirectsPolicyAttribute is not set already on request and
// - RedirectPolicyAttribute is not set already on request and
// - no FollowRedirectsAttribute is set.
req.setAttribute(QNetworkRequest::RedirectsPolicyAttribute, redirectsPolicy());
req.setAttribute(QNetworkRequest::RedirectPolicyAttribute, redirectPolicy());
}
bool isLocalFile = req.url().isLocalFile();

4
src/network/access/qnetworkaccessmanager.h
View File

@ -155,8 +155,8 @@ public:
#endif
void connectToHost(const QString &hostName, quint16 port = 80);
void setRedirectsPolicy(QNetworkRequest::RedirectsPolicy policy);
QNetworkRequest::RedirectsPolicy redirectsPolicy() const;
void setRedirectPolicy(QNetworkRequest::RedirectPolicy policy);
QNetworkRequest::RedirectPolicy redirectPolicy() const;
Q_SIGNALS:
#ifndef QT_NO_NETWORKPROXY

4
src/network/access/qnetworkaccessmanager_p.h
View File

@ -93,7 +93,7 @@ public:
#endif
cookieJarCreated(false),
defaultAccessControl(true),
redirectsPolicy(QNetworkRequest::ManualRedirectsPolicy),
redirectPolicy(QNetworkRequest::ManualRedirectPolicy),
authenticationManager(QSharedPointer<QNetworkAccessAuthenticationManager>::create())
{
#ifndef QT_NO_BEARERMANAGEMENT
@ -196,7 +196,7 @@ public:
bool cookieJarCreated;
bool defaultAccessControl;
QNetworkRequest::RedirectsPolicy redirectsPolicy;
QNetworkRequest::RedirectPolicy redirectPolicy;
// The cache with authorization data:
QSharedPointer<QNetworkAccessAuthenticationManager> authenticationManager;

14
src/network/access/qnetworkreplyhttpimpl.cpp
View File

@ -668,14 +668,14 @@ void QNetworkReplyHttpImplPrivate::postRequest(const QNetworkRequest &newHttpReq
}
#endif
auto redirectsPolicy = QNetworkRequest::ManualRedirectsPolicy;
const QVariant value = newHttpRequest.attribute(QNetworkRequest::RedirectsPolicyAttribute);
auto redirectPolicy = QNetworkRequest::ManualRedirectPolicy;
const QVariant value = newHttpRequest.attribute(QNetworkRequest::RedirectPolicyAttribute);
if (value.isValid())
redirectsPolicy = value.value<QNetworkRequest::RedirectsPolicy>();
redirectPolicy = value.value<QNetworkRequest::RedirectPolicy>();
else if (newHttpRequest.attribute(QNetworkRequest::FollowRedirectsAttribute).toBool())
redirectsPolicy = QNetworkRequest::NoLessSafeRedirectsPolicy;
redirectPolicy = QNetworkRequest::NoLessSafeRedirectPolicy;
httpRequest.setRedirectsPolicy(redirectsPolicy);
httpRequest.setRedirectPolicy(redirectPolicy);
httpRequest.setPriority(convert(newHttpRequest.priority()));
@ -1155,7 +1155,7 @@ void QNetworkReplyHttpImplPrivate::onRedirected(const QUrl &redirectUrl, int htt
const bool isLessSafe = schemeBefore == QLatin1String("https")
&& url.scheme() == QLatin1String("http");
if (httpRequest.redirectsPolicy() == QNetworkRequest::NoLessSafeRedirectsPolicy
if (httpRequest.redirectPolicy() == QNetworkRequest::NoLessSafeRedirectPolicy
&& isLessSafe) {
error(QNetworkReply::InsecureRedirectError,
QCoreApplication::translate("QHttp", "Insecure redirect"));
@ -1165,7 +1165,7 @@ void QNetworkReplyHttpImplPrivate::onRedirected(const QUrl &redirectUrl, int htt
redirectRequest = createRedirectRequest(originalRequest, url, maxRedirectsRemaining);
operation = getRedirectOperation(operation, httpStatus);
if (httpRequest.redirectsPolicy() != QNetworkRequest::UserVerifiedRedirectsPolicy)
if (httpRequest.redirectPolicy() != QNetworkRequest::UserVerifiedRedirectPolicy)
followRedirect();
emit q->redirected(url);

42
src/network/access/qnetworkrequest.cpp
View File

@ -289,9 +289,9 @@ QT_BEGIN_NAMESPACE
marked to be decompressed automatically.
(This value was introduced in 5.9.)
\value RedirectsPolicyAttribute
\value RedirectPolicyAttribute
Requests only, type: QMetaType::Int, should be one of the
QNetworkRequest::RedirectsPolicy values (default: ManualRedirectsPolicy).
QNetworkRequest::RedirectPolicy values (default: ManualRedirectPolicy).
This attribute obsoletes FollowRedirectsAttribute.
(This value was introduced in 5.9.)
@ -343,33 +343,33 @@ QT_BEGIN_NAMESPACE
*/
/*!
\enum QNetworkRequest::RedirectsPolicy
\enum QNetworkRequest::RedirectPolicy
\since 5.9
Indicates whether the Network Access API should automatically follow a
HTTP redirect response or not.
\value ManualRedirectsPolicy Default value: not following any redirects.
\value ManualRedirectPolicy Default value: not following any redirects.
\value NoLessSafeRedirectsPolicy Only "http"->"http", "http" -> "https"
or "https" -> "https" redirects are allowed.
Equivalent to setting the old FollowRedirectsAttribute
to true
\value NoLessSafeRedirectPolicy Only "http"->"http", "http" -> "https"
or "https" -> "https" redirects are allowed.
Equivalent to setting the old FollowRedirectsAttribute
to true
\value SameOriginRedirectsPolicy Require the same protocol, host and port.
Note, http://example.com and http://example.com:80
will fail with this policy (implicit/explicit ports
are considered to be a mismatch).
\value SameOriginRedirectPolicy Require the same protocol, host and port.
Note, http://example.com and http://example.com:80
will fail with this policy (implicit/explicit ports
are considered to be a mismatch).
\value UserVerifiedRedirectsPolicy Client decides whether to follow each
redirect by handling the redirected()
signal, emitting redirectAllowed() on
the QNetworkReply object to allow
the redirect or aborting/finishing it to
reject the redirect. This can be used,
for example, to ask the user whether to
accept the redirect, or to decide
based on some app-specific configuration.
\value UserVerifiedRedirectPolicy Client decides whether to follow each
redirect by handling the redirected()
signal, emitting redirectAllowed() on
the QNetworkReply object to allow
the redirect or aborting/finishing it to
reject the redirect. This can be used,
for example, to ask the user whether to
accept the redirect, or to decide
based on some app-specific configuration.
*/
class QNetworkRequestPrivate: public QSharedData, public QNetworkHeadersPrivate

14
src/network/access/qnetworkrequest.h
View File

@ -91,7 +91,7 @@ public:
HTTP2AllowedAttribute,
HTTP2WasUsedAttribute,
OriginalContentLengthAttribute,
RedirectsPolicyAttribute,
RedirectPolicyAttribute,
User = 1000,
UserMax = 32767
@ -113,11 +113,11 @@ public:
LowPriority = 5
};
enum RedirectsPolicy {
ManualRedirectsPolicy,
NoLessSafeRedirectsPolicy,
SameOriginRedirectsPolicy,
UserVerifiedRedirectsPolicy
enum RedirectPolicy {
ManualRedirectPolicy,
NoLessSafeRedirectPolicy,
SameOriginRedirectPolicy,
UserVerifiedRedirectPolicy
};
@ -177,6 +177,6 @@ Q_DECLARE_SHARED(QNetworkRequest)
QT_END_NAMESPACE
Q_DECLARE_METATYPE(QNetworkRequest)
Q_DECLARE_METATYPE(QNetworkRequest::RedirectsPolicy)
Q_DECLARE_METATYPE(QNetworkRequest::RedirectPolicy)
#endif

70
tests/auto/network/access/qnetworkreply/tst_qnetworkreply.cpp
View File

@ -8194,22 +8194,22 @@ struct SameOriginRedirector : MiniHttpServer
void tst_QNetworkReply::ioHttpRedirectPolicy_data()
{
QTest::addColumn<QNetworkRequest::RedirectsPolicy>("policy");
QTest::addColumn<QNetworkRequest::RedirectPolicy>("policy");
QTest::addColumn<bool>("ssl");
QTest::addColumn<int>("redirectCount");
QTest::addColumn<int>("statusCode");
QTest::newRow("manual-nossl") << QNetworkRequest::ManualRedirectsPolicy << false << 0 << 307;
QTest::newRow("manual-ssl") << QNetworkRequest::ManualRedirectsPolicy << true << 0 << 307;
QTest::newRow("nolesssafe-nossl") << QNetworkRequest::NoLessSafeRedirectsPolicy << false << 1 << 200;
QTest::newRow("nolesssafe-ssl") << QNetworkRequest::NoLessSafeRedirectsPolicy << true << 1 << 200;
QTest::newRow("same-origin-nossl") << QNetworkRequest::SameOriginRedirectsPolicy << false << 1 << 200;
QTest::newRow("same-origin-ssl") << QNetworkRequest::SameOriginRedirectsPolicy << true << 1 << 200;
QTest::newRow("manual-nossl") << QNetworkRequest::ManualRedirectPolicy << false << 0 << 307;
QTest::newRow("manual-ssl") << QNetworkRequest::ManualRedirectPolicy << true << 0 << 307;
QTest::newRow("nolesssafe-nossl") << QNetworkRequest::NoLessSafeRedirectPolicy << false << 1 << 200;
QTest::newRow("nolesssafe-ssl") << QNetworkRequest::NoLessSafeRedirectPolicy << true << 1 << 200;
QTest::newRow("same-origin-nossl") << QNetworkRequest::SameOriginRedirectPolicy << false << 1 << 200;
QTest::newRow("same-origin-ssl") << QNetworkRequest::SameOriginRedirectPolicy << true << 1 << 200;
}
void tst_QNetworkReply::ioHttpRedirectPolicy()
{
QFETCH(const QNetworkRequest::RedirectsPolicy, policy);
QFETCH(const QNetworkRequest::RedirectPolicy, policy);
QFETCH(const bool, ssl);
#ifdef QT_NO_SSL
@ -8234,16 +8234,16 @@ void tst_QNetworkReply::ioHttpRedirectPolicy()
redirectServer.responses.push_back(tempRedirectReplyStr().arg(QString(url.toEncoded())).toLatin1());
// This is the default one we preserve between tests.
QCOMPARE(manager.redirectsPolicy(), QNetworkRequest::ManualRedirectsPolicy);
QCOMPARE(manager.redirectPolicy(), QNetworkRequest::ManualRedirectPolicy);
manager.setRedirectsPolicy(policy);
QCOMPARE(manager.redirectsPolicy(), policy);
manager.setRedirectPolicy(policy);
QCOMPARE(manager.redirectPolicy(), policy);
QNetworkReplyPtr reply(manager.get(QNetworkRequest(url)));
if (ssl)
reply->ignoreSslErrors();
// Restore default:
manager.setRedirectsPolicy(QNetworkRequest::ManualRedirectsPolicy);
manager.setRedirectPolicy(QNetworkRequest::ManualRedirectPolicy);
QSignalSpy redirectSpy(reply.data(), SIGNAL(redirected(QUrl)));
QSignalSpy finishedSpy(reply.data(), SIGNAL(finished()));
QVERIFY2(waitForFinish(reply) == Success, msgWaitForFinished(reply));
@ -8254,43 +8254,43 @@ void tst_QNetworkReply::ioHttpRedirectPolicy()
void tst_QNetworkReply::ioHttpRedirectPolicyErrors_data()
{
QTest::addColumn<QNetworkRequest::RedirectsPolicy>("policy");
QTest::addColumn<QNetworkRequest::RedirectPolicy>("policy");
QTest::addColumn<bool>("ssl");
QTest::addColumn<QString>("location");
QTest::addColumn<int>("maxRedirects");
QTest::addColumn<QNetworkReply::NetworkError>("expectedError");
// 1. NoLessSafeRedirectsPolicy
QTest::newRow("nolesssafe-nossl-nossl-too-many") << QNetworkRequest::NoLessSafeRedirectsPolicy
QTest::newRow("nolesssafe-nossl-nossl-too-many") << QNetworkRequest::NoLessSafeRedirectPolicy
<< false << QString("http://localhost:%1") << 0 << QNetworkReply::TooManyRedirectsError;
QTest::newRow("nolesssafe-ssl-ssl-too-many") << QNetworkRequest::NoLessSafeRedirectsPolicy
QTest::newRow("nolesssafe-ssl-ssl-too-many") << QNetworkRequest::NoLessSafeRedirectPolicy
<< true << QString("https:/localhost:%1") << 0 << QNetworkReply::TooManyRedirectsError;
QTest::newRow("nolesssafe-ssl-nossl-insecure-redirect") << QNetworkRequest::NoLessSafeRedirectsPolicy
QTest::newRow("nolesssafe-ssl-nossl-insecure-redirect") << QNetworkRequest::NoLessSafeRedirectPolicy
<< true << QString("http://localhost:%1") << 50 << QNetworkReply::InsecureRedirectError;
// 2. SameOriginRedirectsPolicy
QTest::newRow("same-origin-nossl-nossl-too-many") << QNetworkRequest::SameOriginRedirectsPolicy
QTest::newRow("same-origin-nossl-nossl-too-many") << QNetworkRequest::SameOriginRedirectPolicy
<< false << QString("http://localhost:%1") << 0 << QNetworkReply::TooManyRedirectsError;
QTest::newRow("same-origin-ssl-ssl-too-many") << QNetworkRequest::SameOriginRedirectsPolicy
QTest::newRow("same-origin-ssl-ssl-too-many") << QNetworkRequest::SameOriginRedirectPolicy
<< true << QString("https://localhost:%1") << 0 << QNetworkReply::TooManyRedirectsError;
QTest::newRow("same-origin-https-http-wrong-protocol") << QNetworkRequest::SameOriginRedirectsPolicy
QTest::newRow("same-origin-https-http-wrong-protocol") << QNetworkRequest::SameOriginRedirectPolicy
<< true << QString("http://localhost:%1") << 50 << QNetworkReply::InsecureRedirectError;
QTest::newRow("same-origin-http-https-wrong-protocol") << QNetworkRequest::SameOriginRedirectsPolicy
QTest::newRow("same-origin-http-https-wrong-protocol") << QNetworkRequest::SameOriginRedirectPolicy
<< false << QString("https://localhost:%1") << 50 << QNetworkReply::InsecureRedirectError;
QTest::newRow("same-origin-http-http-wrong-host") << QNetworkRequest::SameOriginRedirectsPolicy
QTest::newRow("same-origin-http-http-wrong-host") << QNetworkRequest::SameOriginRedirectPolicy
<< false << QString("http://not-so-localhost:%1") << 50 << QNetworkReply::InsecureRedirectError;
QTest::newRow("same-origin-https-https-wrong-host") << QNetworkRequest::SameOriginRedirectsPolicy
QTest::newRow("same-origin-https-https-wrong-host") << QNetworkRequest::SameOriginRedirectPolicy
<< true << QString("https://not-so-localhost:%1") << 50 << QNetworkReply::InsecureRedirectError;
QTest::newRow("same-origin-http-http-wrong-port") << QNetworkRequest::SameOriginRedirectsPolicy
QTest::newRow("same-origin-http-http-wrong-port") << QNetworkRequest::SameOriginRedirectPolicy
<< false << QString("http://localhost/%1") << 50 << QNetworkReply::InsecureRedirectError;
QTest::newRow("same-origin-https-https-wrong-port") << QNetworkRequest::SameOriginRedirectsPolicy
QTest::newRow("same-origin-https-https-wrong-port") << QNetworkRequest::SameOriginRedirectPolicy
<< true << QString("https://localhost/%1") << 50 << QNetworkReply::InsecureRedirectError;
}
void tst_QNetworkReply::ioHttpRedirectPolicyErrors()
{
QFETCH(const QNetworkRequest::RedirectsPolicy, policy);
QFETCH(const QNetworkRequest::RedirectPolicy, policy);
// This should never happen:
QVERIFY(policy != QNetworkRequest::ManualRedirectsPolicy);
QVERIFY(policy != QNetworkRequest::ManualRedirectPolicy);
QFETCH(const bool, ssl);
QFETCH(const QString, location);
@ -8317,13 +8317,13 @@ void tst_QNetworkReply::ioHttpRedirectPolicyErrors()
request.setMaximumRedirectsAllowed(maxRedirects);
// We always reset the policy to the default one ('Manual') after any related
// test is finished:
QCOMPARE(manager.redirectsPolicy(), QNetworkRequest::ManualRedirectsPolicy);
manager.setRedirectsPolicy(policy);
QCOMPARE(manager.redirectsPolicy(), policy);
QCOMPARE(manager.redirectPolicy(), QNetworkRequest::ManualRedirectPolicy);
manager.setRedirectPolicy(policy);
QCOMPARE(manager.redirectPolicy(), policy);
QNetworkReplyPtr reply(manager.get(request));
// Set it back to default:
manager.setRedirectsPolicy(QNetworkRequest::ManualRedirectsPolicy);
manager.setRedirectPolicy(QNetworkRequest::ManualRedirectPolicy);
if (ssl)
reply->ignoreSslErrors();
@ -8358,9 +8358,9 @@ void tst_QNetworkReply::ioHttpUserVerifiedRedirect()
redirectServer.setDataToTransmit(tempRedirectReplyStr().arg(QString(url.toEncoded())).toLatin1());
url.setPort(redirectServer.serverPort());
QCOMPARE(manager.redirectsPolicy(), QNetworkRequest::ManualRedirectsPolicy);
manager.setRedirectsPolicy(QNetworkRequest::UserVerifiedRedirectsPolicy);
QCOMPARE(manager.redirectsPolicy(), QNetworkRequest::UserVerifiedRedirectsPolicy);
QCOMPARE(manager.redirectPolicy(), QNetworkRequest::ManualRedirectPolicy);
manager.setRedirectPolicy(QNetworkRequest::UserVerifiedRedirectPolicy);
QCOMPARE(manager.redirectPolicy(), QNetworkRequest::UserVerifiedRedirectPolicy);
QNetworkReplyPtr reply(manager.get(QNetworkRequest(url)));
reply->connect(reply.data(), &QNetworkReply::redirected,
@ -8376,8 +8376,8 @@ void tst_QNetworkReply::ioHttpUserVerifiedRedirect()
});
// Before any test failed, reset the policy to default:
manager.setRedirectsPolicy(QNetworkRequest::ManualRedirectsPolicy);
QCOMPARE(manager.redirectsPolicy(), QNetworkRequest::ManualRedirectsPolicy);
manager.setRedirectPolicy(QNetworkRequest::ManualRedirectPolicy);
QCOMPARE(manager.redirectPolicy(), QNetworkRequest::ManualRedirectPolicy);
QSignalSpy finishedSpy(reply.data(), SIGNAL(finished()));
waitForFinish(reply);