1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
|
#include "http_file_source.hpp"
#include "http_request.hpp"
#include <mbgl/platform/log.hpp>
#include <QByteArray>
#include <QDir>
#include <QNetworkProxyFactory>
#include <QNetworkReply>
#include <QSslConfiguration>
// Needs to be on the global namespace
// for linking purposes.
void initResources() {
Q_INIT_RESOURCE(qmapbox);
}
namespace mbgl {
HTTPFileSource::Impl::Impl() : m_manager(new QNetworkAccessManager(this))
{
initResources();
QNetworkProxyFactory::setUseSystemConfiguration(true);
#if QT_VERSION >= 0x050000
m_ssl.setProtocol(QSsl::SecureProtocols);
#else
// Qt 4 defines SecureProtocols as TLS1 or SSL3, but we don't want SSL3.
m_ssl.setProtocol(QSsl::TlsV1);
#endif
m_ssl.setCaCertificates(QSslCertificate::fromPath(":ca-bundle.crt"));
if (m_ssl.caCertificates().isEmpty()) {
mbgl::Log::Warning(mbgl::Event::HttpRequest, "Could not load list of certificate authorities");
}
}
void HTTPFileSource::Impl::request(HTTPRequest* req)
{
QUrl url = req->requestUrl();
QPair<QNetworkReply*, QVector<HTTPRequest*>>& data = m_pending[url];
QVector<HTTPRequest*>& requestsVector = data.second;
requestsVector.append(req);
if (requestsVector.size() > 1) {
return;
}
QNetworkRequest networkRequest = req->networkRequest();
networkRequest.setSslConfiguration(m_ssl);
data.first = m_manager->get(networkRequest);
connect(data.first, SIGNAL(finished()), this, SLOT(onReplyFinished()));
connect(data.first, SIGNAL(error(QNetworkReply::NetworkError)), this, SLOT(onReplyFinished()));
}
void HTTPFileSource::Impl::cancel(HTTPRequest* req)
{
QUrl url = req->requestUrl();
auto it = m_pending.find(url);
if (it == m_pending.end()) {
return;
}
QPair<QNetworkReply*, QVector<HTTPRequest*>>& data = it.value();
QNetworkReply* reply = data.first;
QVector<HTTPRequest*>& requestsVector = data.second;
for (int i = 0; i < requestsVector.size(); ++i) {
if (req == requestsVector.at(i)) {
requestsVector.remove(i);
break;
}
}
if (requestsVector.empty()) {
m_pending.erase(it);
#if QT_VERSION >= 0x050000
reply->abort();
#else
// XXX: We should be aborting the reply here
// but a bug on Qt4 causes the connection of
// other ongoing requests to drop if we call
// abort() too often (and we do).
Q_UNUSED(reply);
#endif
}
}
void HTTPFileSource::Impl::onReplyFinished()
{
QNetworkReply* reply = qobject_cast<QNetworkReply *>(sender());
const QUrl& url = reply->url();
auto it = m_pending.find(url);
if (it == m_pending.end()) {
reply->deleteLater();
return;
}
QVector<HTTPRequest*>& requestsVector = it.value().second;
for (auto req : requestsVector) {
req->handleNetworkReply(reply);
}
m_pending.erase(it);
reply->deleteLater();
}
HTTPFileSource::HTTPFileSource()
: impl(std::make_unique<Impl>()) {
}
HTTPFileSource::~HTTPFileSource() = default;
std::unique_ptr<AsyncRequest> HTTPFileSource::request(const Resource& resource, Callback callback)
{
return std::make_unique<HTTPRequest>(impl.get(), resource, callback);
}
uint32_t HTTPFileSource::maximumConcurrentRequests() {
#if QT_VERSION >= 0x050000
return 20;
#else
return 10;
#endif
}
} // mbgl
|
