| Line | Source | Count | 
| 1 |  | - | 
| 2 |  | - | 
| 3 |  | - | 
| 4 |  | - | 
| 5 |  | - | 
| 6 |  | - | 
| 7 |  | - | 
| 8 |  | - | 
| 9 |  | - | 
| 10 |  | - | 
| 11 |  | - | 
| 12 | namespace { namespace Q_QGS_fileBackend { typedef QNetworkAccessFileBackendFactory Type; QBasicAtomicInt guard = { QtGlobalStatic::Uninitialized }; __attribute__((visibility("hidden"))) inline Type *innerFunction() { struct HolderBase { ~HolderBase() noexcept { if (guard.load() == QtGlobalStatic::Initialized) guard.store(QtGlobalStatic::Destroyed); } }; static struct Holder : public HolderBase { Type value; Holder() noexcept(noexcept(Type ())) : value () { guard.store(QtGlobalStatic::Initialized); } } holder; return &holder.value; } } } static QGlobalStatic<QNetworkAccessFileBackendFactory, Q_QGS_fileBackend::innerFunction, Q_QGS_fileBackend::guard> fileBackend; | - | 
| 13 |  | - | 
| 14 | namespace { namespace Q_QGS_ftpBackend { typedef QNetworkAccessFtpBackendFactory Type; QBasicAtomicInt guard = { QtGlobalStatic::Uninitialized }; __attribute__((visibility("hidden"))) inline Type *innerFunction() { struct HolderBase { ~HolderBase() noexcept { if (guard.load() == QtGlobalStatic::Initialized) guard.store(QtGlobalStatic::Destroyed); } }; static struct Holder : public HolderBase { Type value; Holder() noexcept(noexcept(Type ())) : value () { guard.store(QtGlobalStatic::Initialized); } } holder; return &holder.value; } } } static QGlobalStatic<QNetworkAccessFtpBackendFactory, Q_QGS_ftpBackend::innerFunction, Q_QGS_ftpBackend::guard> ftpBackend; | - | 
| 15 |  | - | 
| 16 |  | - | 
| 17 |  | - | 
| 18 | namespace { namespace Q_QGS_debugpipeBackend { typedef QNetworkAccessDebugPipeBackendFactory Type; QBasicAtomicInt guard = { QtGlobalStatic::Uninitialized }; __attribute__((visibility("hidden"))) inline Type *innerFunction() { struct HolderBase { ~HolderBase() noexcept { if (guard.load() == QtGlobalStatic::Initialized) guard.store(QtGlobalStatic::Destroyed); } }; static struct Holder : public HolderBase { Type value; Holder() noexcept(noexcept(Type ())) : value () { guard.store(QtGlobalStatic::Initialized); } } holder; return &holder.value; } } } static QGlobalStatic<QNetworkAccessDebugPipeBackendFactory, Q_QGS_debugpipeBackend::innerFunction, Q_QGS_debugpipeBackend::guard> debugpipeBackend; | - | 
| 19 | static void ensureInitialized() | - | 
| 20 | { | - | 
| 21 |  | - | 
| 22 |     (void) ftpBackend(); | - | 
| 23 |  | - | 
| 24 |  | - | 
| 25 |  | - | 
| 26 |     (void) debugpipeBackend(); | - | 
| 27 |  | - | 
| 28 |  | - | 
| 29 |  | - | 
| 30 |     (void) fileBackend(); | - | 
| 31 | } | - | 
| 32 | QNetworkAccessManager::QNetworkAccessManager(QObject *parent) | - | 
| 33 |     : QObject(*new QNetworkAccessManagerPrivate, parent) | - | 
| 34 | { | - | 
| 35 |     ensureInitialized(); | - | 
| 36 |  | - | 
| 37 |     qRegisterMetaType<QNetworkReply::NetworkError>(); | - | 
| 38 |  | - | 
| 39 |     qRegisterMetaType<QNetworkProxy>(); | - | 
| 40 |  | - | 
| 41 |  | - | 
| 42 |     qRegisterMetaType<QList<QSslError> >(); | - | 
| 43 |     qRegisterMetaType<QSslConfiguration>(); | - | 
| 44 |     qRegisterMetaType<QSslPreSharedKeyAuthenticator *>(); | - | 
| 45 |  | - | 
| 46 |     qRegisterMetaType<QList<QPair<QByteArray,QByteArray> > >(); | - | 
| 47 |  | - | 
| 48 |     qRegisterMetaType<QHttpNetworkRequest>(); | - | 
| 49 |  | - | 
| 50 |     qRegisterMetaType<QNetworkReply::NetworkError>(); | - | 
| 51 |     qRegisterMetaType<QSharedPointer<char> >(); | - | 
| 52 |  | - | 
| 53 |  | - | 
| 54 |     QNetworkAccessManagerPrivate * const d = d_func(); | - | 
| 55 |  | - | 
| 56 |  | - | 
| 57 |  | - | 
| 58 |  | - | 
| 59 |     connect(&d->networkConfigurationManager, qFlagLocation("2""onlineStateChanged(bool)" "\0" __FILE__ ":" "471""477"), | - | 
| 60 |             qFlagLocation("1""_q_onlineStateChanged(bool)" "\0" __FILE__ ":" "472""478")); | - | 
| 61 |     connect(&d->networkConfigurationManager, qFlagLocation("2""configurationChanged(const QNetworkConfiguration &)" "\0" __FILE__ ":" "473""479"), | - | 
| 62 |             qFlagLocation("1""_q_configurationChanged(const QNetworkConfiguration &)" "\0" __FILE__ ":" "474""480")); | - | 
| 63 |  | - | 
| 64 |  | - | 
| 65 | } | - | 
| 66 | QNetworkAccessManager::~QNetworkAccessManager() | - | 
| 67 | { | - | 
| 68 |  | - | 
| 69 |     delete d_func()->proxyFactory; | - | 
| 70 |  | - | 
| 71 |  | - | 
| 72 |  | - | 
| 73 |  | - | 
| 74 |  | - | 
| 75 |  | - | 
| 76 |     qDeleteAll(findChildren<QNetworkReply *>()); | - | 
| 77 |  | - | 
| 78 |  | - | 
| 79 |  | - | 
| 80 | } | - | 
| 81 | QNetworkProxy QNetworkAccessManager::proxy() const | - | 
| 82 | { | - | 
| 83 |     return d_func()->proxy; | - | 
| 84 | } | - | 
| 85 | void QNetworkAccessManager::setProxy(const QNetworkProxy &proxy) | - | 
| 86 | { | - | 
| 87 |     QNetworkAccessManagerPrivate * const d = d_func(); | - | 
| 88 |     delete d->proxyFactory; | - | 
| 89 |     d->proxy = proxy; | - | 
| 90 |     d->proxyFactory = 0; | - | 
| 91 | } | - | 
| 92 | QNetworkProxyFactory *QNetworkAccessManager::proxyFactory() const | - | 
| 93 | { | - | 
| 94 |     return d_func()->proxyFactory; | - | 
| 95 | } | - | 
| 96 | void QNetworkAccessManager::setProxyFactory(QNetworkProxyFactory *factory) | - | 
| 97 | { | - | 
| 98 |     QNetworkAccessManagerPrivate * const d = d_func(); | - | 
| 99 |     delete d->proxyFactory; | - | 
| 100 |     d->proxyFactory = factory; | - | 
| 101 |     d->proxy = QNetworkProxy(); | - | 
| 102 | } | - | 
| 103 | QAbstractNetworkCache *QNetworkAccessManager::cache() const | - | 
| 104 | { | - | 
| 105 |     const QNetworkAccessManagerPrivate * const d = d_func(); | - | 
| 106 |     return d->networkCache; | - | 
| 107 | } | - | 
| 108 | void QNetworkAccessManager::setCache(QAbstractNetworkCache *cache) | - | 
| 109 | { | - | 
| 110 |     QNetworkAccessManagerPrivate * const d = d_func(); | - | 
| 111 |     if (d->networkCache != cache) { | - | 
| 112 |         delete d->networkCache; | - | 
| 113 |         d->networkCache = cache; | - | 
| 114 |         if (d->networkCache) | - | 
| 115 |             d->networkCache->setParent(this); | - | 
| 116 |     } | - | 
| 117 | } | - | 
| 118 | QNetworkCookieJar *QNetworkAccessManager::cookieJar() const | - | 
| 119 | { | - | 
| 120 |     const QNetworkAccessManagerPrivate * const d = d_func(); | - | 
| 121 |     if (!d->cookieJar) | - | 
| 122 |         d->createCookieJar(); | - | 
| 123 |     return d->cookieJar; | - | 
| 124 | } | - | 
| 125 | void QNetworkAccessManager::setCookieJar(QNetworkCookieJar *cookieJar) | - | 
| 126 | { | - | 
| 127 |     QNetworkAccessManagerPrivate * const d = d_func(); | - | 
| 128 |     d->cookieJarCreated = true; | - | 
| 129 |     if (d->cookieJar != cookieJar) { | - | 
| 130 |         if (d->cookieJar && d->cookieJar->parent() == this) | - | 
| 131 |             delete d->cookieJar; | - | 
| 132 |         d->cookieJar = cookieJar; | - | 
| 133 |         if (thread() == cookieJar->thread()) | - | 
| 134 |             d->cookieJar->setParent(this); | - | 
| 135 |     } | - | 
| 136 | } | - | 
| 137 |  | - | 
| 138 |  | - | 
| 139 |  | - | 
| 140 |  | - | 
| 141 |  | - | 
| 142 |  | - | 
| 143 |  | - | 
| 144 | QNetworkReply *QNetworkAccessManager::head(const QNetworkRequest &request) | - | 
| 145 | { | - | 
| 146 |     return d_func()->postProcess(createRequest(QNetworkAccessManager::HeadOperation, request)); | - | 
| 147 | } | - | 
| 148 | QNetworkReply *QNetworkAccessManager::get(const QNetworkRequest &request) | - | 
| 149 | { | - | 
| 150 |     return d_func()->postProcess(createRequest(QNetworkAccessManager::GetOperation, request)); | - | 
| 151 | } | - | 
| 152 | QNetworkReply *QNetworkAccessManager::post(const QNetworkRequest &request, QIODevice *data) | - | 
| 153 | { | - | 
| 154 |     return d_func()->postProcess(createRequest(QNetworkAccessManager::PostOperation, request, data)); | - | 
| 155 | } | - | 
| 156 |  | - | 
| 157 |  | - | 
| 158 |  | - | 
| 159 |  | - | 
| 160 |  | - | 
| 161 |  | - | 
| 162 |  | - | 
| 163 | QNetworkReply *QNetworkAccessManager::post(const QNetworkRequest &request, const QByteArray &data) | - | 
| 164 | { | - | 
| 165 |     QBuffer *buffer = new QBuffer; | - | 
| 166 |     buffer->setData(data); | - | 
| 167 |     buffer->open(QIODevice::ReadOnly); | - | 
| 168 |  | - | 
| 169 |     QNetworkReply *reply = post(request, buffer); | - | 
| 170 |     buffer->setParent(reply); | - | 
| 171 |     return reply; | - | 
| 172 | } | - | 
| 173 | QNetworkReply *QNetworkAccessManager::post(const QNetworkRequest &request, QHttpMultiPart *multiPart) | - | 
| 174 | { | - | 
| 175 |     QNetworkRequest newRequest = d_func()->prepareMultipart(request, multiPart); | - | 
| 176 |     QIODevice *device = multiPart->d_func()->device; | - | 
| 177 |     QNetworkReply *reply = post(newRequest, device); | - | 
| 178 |     return reply; | - | 
| 179 | } | - | 
| 180 | QNetworkReply *QNetworkAccessManager::put(const QNetworkRequest &request, QHttpMultiPart *multiPart) | - | 
| 181 | { | - | 
| 182 |     QNetworkRequest newRequest = d_func()->prepareMultipart(request, multiPart); | - | 
| 183 |     QIODevice *device = multiPart->d_func()->device; | - | 
| 184 |     QNetworkReply *reply = put(newRequest, device); | - | 
| 185 |     return reply; | - | 
| 186 | } | - | 
| 187 | QNetworkReply *QNetworkAccessManager::put(const QNetworkRequest &request, QIODevice *data) | - | 
| 188 | { | - | 
| 189 |     return d_func()->postProcess(createRequest(QNetworkAccessManager::PutOperation, request, data)); | - | 
| 190 | } | - | 
| 191 |  | - | 
| 192 |  | - | 
| 193 |  | - | 
| 194 |  | - | 
| 195 |  | - | 
| 196 |  | - | 
| 197 |  | - | 
| 198 | QNetworkReply *QNetworkAccessManager::put(const QNetworkRequest &request, const QByteArray &data) | - | 
| 199 | { | - | 
| 200 |     QBuffer *buffer = new QBuffer; | - | 
| 201 |     buffer->setData(data); | - | 
| 202 |     buffer->open(QIODevice::ReadOnly); | - | 
| 203 |  | - | 
| 204 |     QNetworkReply *reply = put(request, buffer); | - | 
| 205 |     buffer->setParent(reply); | - | 
| 206 |     return reply; | - | 
| 207 | } | - | 
| 208 | QNetworkReply *QNetworkAccessManager::deleteResource(const QNetworkRequest &request) | - | 
| 209 | { | - | 
| 210 |     return d_func()->postProcess(createRequest(QNetworkAccessManager::DeleteOperation, request)); | - | 
| 211 | } | - | 
| 212 | void QNetworkAccessManager::setConfiguration(const QNetworkConfiguration &config) | - | 
| 213 | { | - | 
| 214 |     QNetworkAccessManagerPrivate * const d = d_func(); | - | 
| 215 |     d->networkConfiguration = config; | - | 
| 216 |     d->customNetworkConfiguration = true; | - | 
| 217 |     d->createSession(config); | - | 
| 218 | } | - | 
| 219 | QNetworkConfiguration QNetworkAccessManager::configuration() const | - | 
| 220 | { | - | 
| 221 |     const QNetworkAccessManagerPrivate * const d = d_func(); | - | 
| 222 |  | - | 
| 223 |     QSharedPointer<QNetworkSession> session(d->getNetworkSession()); | - | 
| 224 |     if (session) { | - | 
| 225 |         return session->configuration(); | - | 
| 226 |     } else { | - | 
| 227 |         QNetworkConfigurationManager manager; | - | 
| 228 |         return manager.defaultConfiguration(); | - | 
| 229 |     } | - | 
| 230 | } | - | 
| 231 | QNetworkConfiguration QNetworkAccessManager::activeConfiguration() const | - | 
| 232 | { | - | 
| 233 |     const QNetworkAccessManagerPrivate * const d = d_func(); | - | 
| 234 |  | - | 
| 235 |     QSharedPointer<QNetworkSession> networkSession(d->getNetworkSession()); | - | 
| 236 |     QNetworkConfigurationManager manager; | - | 
| 237 |     if (networkSession) { | - | 
| 238 |         return manager.configurationFromIdentifier( | - | 
| 239 |             networkSession->sessionProperty(QLatin1String("ActiveConfiguration")).toString()); | - | 
| 240 |     } else { | - | 
| 241 |         return manager.defaultConfiguration(); | - | 
| 242 |     } | - | 
| 243 | } | - | 
| 244 | void QNetworkAccessManager::setNetworkAccessible(QNetworkAccessManager::NetworkAccessibility accessible) | - | 
| 245 | { | - | 
| 246 |     QNetworkAccessManagerPrivate * const d = d_func(); | - | 
| 247 |  | - | 
| 248 |     d->defaultAccessControl = accessible == NotAccessible ? false : true; | - | 
| 249 |  | - | 
| 250 |     if (d->networkAccessible != accessible) { | - | 
| 251 |         NetworkAccessibility previous = networkAccessible(); | - | 
| 252 |         d->networkAccessible = accessible; | - | 
| 253 |         NetworkAccessibility current = networkAccessible(); | - | 
| 254 |         if (previous != current) | - | 
| 255 |             networkAccessibleChanged(current); | - | 
| 256 |     } | - | 
| 257 | } | - | 
| 258 |  | - | 
| 259 |  | - | 
| 260 |  | - | 
| 261 |  | - | 
| 262 |  | - | 
| 263 |  | - | 
| 264 | QNetworkAccessManager::NetworkAccessibility QNetworkAccessManager::networkAccessible() const | - | 
| 265 | { | - | 
| 266 |     const QNetworkAccessManagerPrivate * const d = d_func(); | - | 
| 267 |  | - | 
| 268 |     if (d->networkConfiguration.state().testFlag(QNetworkConfiguration::Undefined)) | - | 
| 269 |         return UnknownAccessibility; | - | 
| 270 |  | - | 
| 271 |     if (d->networkSessionRequired) { | - | 
| 272 |         QSharedPointer<QNetworkSession> networkSession(d->getNetworkSession()); | - | 
| 273 |         if (networkSession) { | - | 
| 274 |  | - | 
| 275 |             if (d->online) | - | 
| 276 |                 return d->networkAccessible; | - | 
| 277 |             else | - | 
| 278 |                 return NotAccessible; | - | 
| 279 |         } else { | - | 
| 280 |             if (d->defaultAccessControl) { | - | 
| 281 |                 if (d->online) | - | 
| 282 |                     return d->networkAccessible; | - | 
| 283 |                 else | - | 
| 284 |                     return NotAccessible; | - | 
| 285 |             } | - | 
| 286 |             return (d->networkAccessible); | - | 
| 287 |         } | - | 
| 288 |     } else { | - | 
| 289 |         if (d->online) | - | 
| 290 |             return d->networkAccessible; | - | 
| 291 |         else | - | 
| 292 |             return NotAccessible; | - | 
| 293 |     } | - | 
| 294 | } | - | 
| 295 |  | - | 
| 296 |  | - | 
| 297 |  | - | 
| 298 |  | - | 
| 299 |  | - | 
| 300 |  | - | 
| 301 |  | - | 
| 302 | const QWeakPointer<const QNetworkSession> QNetworkAccessManagerPrivate::getNetworkSession(const QNetworkAccessManager *q) | - | 
| 303 | { | - | 
| 304 |     return q->d_func()->networkSessionWeakRef; | - | 
| 305 | } | - | 
| 306 |  | - | 
| 307 | QSharedPointer<QNetworkSession> QNetworkAccessManagerPrivate::getNetworkSession() const | - | 
| 308 | { | - | 
| 309 |     if (networkSessionStrongRef) | - | 
| 310 |         return networkSessionStrongRef; | - | 
| 311 |     return networkSessionWeakRef.toStrongRef(); | - | 
| 312 | } | - | 
| 313 | void QNetworkAccessManager::connectToHostEncrypted(const QString &hostName, quint16 port, | - | 
| 314 |                                                    const QSslConfiguration &sslConfiguration) | - | 
| 315 | { | - | 
| 316 |     QUrl url; | - | 
| 317 |     url.setHost(hostName); | - | 
| 318 |     url.setPort(port); | - | 
| 319 |     url.setScheme(QLatin1String("preconnect-https")); | - | 
| 320 |     QNetworkRequest request(url); | - | 
| 321 |     if (sslConfiguration != QSslConfiguration::defaultConfiguration()) | - | 
| 322 |         request.setSslConfiguration(sslConfiguration); | - | 
| 323 |  | - | 
| 324 |  | - | 
| 325 |  | - | 
| 326 |     if (sslConfiguration.allowedNextProtocols().contains( | - | 
| 327 |                 QSslConfiguration::NextProtocolSpdy3_0)) | - | 
| 328 |         request.setAttribute(QNetworkRequest::SpdyAllowedAttribute, true); | - | 
| 329 |  | - | 
| 330 |     get(request); | - | 
| 331 | } | - | 
| 332 | void QNetworkAccessManager::connectToHost(const QString &hostName, quint16 port) | - | 
| 333 | { | - | 
| 334 |     QUrl url; | - | 
| 335 |     url.setHost(hostName); | - | 
| 336 |     url.setPort(port); | - | 
| 337 |     url.setScheme(QLatin1String("preconnect-http")); | - | 
| 338 |     QNetworkRequest request(url); | - | 
| 339 |     get(request); | - | 
| 340 | } | - | 
| 341 | QNetworkReply *QNetworkAccessManager::sendCustomRequest(const QNetworkRequest &request, const QByteArray &verb, QIODevice *data) | - | 
| 342 | { | - | 
| 343 |     QNetworkRequest newRequest(request); | - | 
| 344 |     newRequest.setAttribute(QNetworkRequest::CustomVerbAttribute, verb); | - | 
| 345 |     return d_func()->postProcess(createRequest(QNetworkAccessManager::CustomOperation, newRequest, data)); | - | 
| 346 | } | - | 
| 347 | QNetworkReply *QNetworkAccessManager::createRequest(QNetworkAccessManager::Operation op, | - | 
| 348 |                                                     const QNetworkRequest &req, | - | 
| 349 |                                                     QIODevice *outgoingData) | - | 
| 350 | { | - | 
| 351 |     QNetworkAccessManagerPrivate * const d = d_func(); | - | 
| 352 |  | - | 
| 353 |     bool isLocalFile = req.url().isLocalFile(); | - | 
| 354 |     QString scheme = req.url().scheme(); | - | 
| 355 |  | - | 
| 356 |  | - | 
| 357 |  | - | 
| 358 |     if (op == QNetworkAccessManager::GetOperation | - | 
| 359 |      || op == QNetworkAccessManager::HeadOperation) { | - | 
| 360 |         if (isLocalFile | - | 
| 361 |  | - | 
| 362 |  | - | 
| 363 |  | - | 
| 364 |             || scheme == QLatin1String("qrc")) { | - | 
| 365 |             return new QNetworkReplyFileImpl(this, req, op); | - | 
| 366 |         } | - | 
| 367 |  | - | 
| 368 |         if (scheme == QLatin1String("data")) | - | 
| 369 |             return new QNetworkReplyDataImpl(this, req, op); | - | 
| 370 |  | - | 
| 371 |  | - | 
| 372 |         QNetworkRequest::CacheLoadControl mode = | - | 
| 373 |             static_cast<QNetworkRequest::CacheLoadControl>( | - | 
| 374 |                 req.attribute(QNetworkRequest::CacheLoadControlAttribute, | - | 
| 375 |                               QNetworkRequest::PreferNetwork).toInt()); | - | 
| 376 |         if (mode == QNetworkRequest::AlwaysCache) { | - | 
| 377 |  | - | 
| 378 |             QNetworkReplyImpl *reply = new QNetworkReplyImpl(this); | - | 
| 379 |             QNetworkReplyImplPrivate *priv = reply->d_func(); | - | 
| 380 |             priv->manager = this; | - | 
| 381 |             priv->backend = new QNetworkAccessCacheBackend(); | - | 
| 382 |             priv->backend->manager = this->d_func(); | - | 
| 383 |             priv->backend->setParent(reply); | - | 
| 384 |             priv->backend->reply = priv; | - | 
| 385 |             priv->setup(op, req, outgoingData); | - | 
| 386 |             return reply; | - | 
| 387 |         } | - | 
| 388 |     } | - | 
| 389 |  | - | 
| 390 |  | - | 
| 391 |  | - | 
| 392 |  | - | 
| 393 |     if (d->networkAccessible == NotAccessible && !isLocalFile) { | - | 
| 394 |         return new QDisabledNetworkReply(this, req, op); | - | 
| 395 |     } | - | 
| 396 |  | - | 
| 397 |     if (!d->networkSessionStrongRef && (d->initializeSession || !d->networkConfiguration.identifier().isEmpty())) { | - | 
| 398 |         QNetworkConfigurationManager manager; | - | 
| 399 |         if (!d->networkConfiguration.identifier().isEmpty()) { | - | 
| 400 |             if ((d->networkConfiguration.state() & QNetworkConfiguration::Defined) | - | 
| 401 |                     && d->networkConfiguration != manager.defaultConfiguration()) | - | 
| 402 |                 d->createSession(manager.defaultConfiguration()); | - | 
| 403 |             else | - | 
| 404 |                 d->createSession(d->networkConfiguration); | - | 
| 405 |  | - | 
| 406 |         } else { | - | 
| 407 |             if (manager.capabilities() & QNetworkConfigurationManager::NetworkSessionRequired) | - | 
| 408 |                 d->createSession(manager.defaultConfiguration()); | - | 
| 409 |             else | - | 
| 410 |                 d->initializeSession = false; | - | 
| 411 |         } | - | 
| 412 |     } | - | 
| 413 |  | - | 
| 414 |  | - | 
| 415 |     QNetworkRequest request = req; | - | 
| 416 |     if (!request.header(QNetworkRequest::ContentLengthHeader).isValid() && | - | 
| 417 |         outgoingData && !outgoingData->isSequential()) { | - | 
| 418 |  | - | 
| 419 |  | - | 
| 420 |         request.setHeader(QNetworkRequest::ContentLengthHeader, outgoingData->size()); | - | 
| 421 |     } | - | 
| 422 |  | - | 
| 423 |     if (static_cast<QNetworkRequest::LoadControl> | - | 
| 424 |         (request.attribute(QNetworkRequest::CookieLoadControlAttribute, | - | 
| 425 |                            QNetworkRequest::Automatic).toInt()) == QNetworkRequest::Automatic) { | - | 
| 426 |         if (d->cookieJar) { | - | 
| 427 |             QList<QNetworkCookie> cookies = d->cookieJar->cookiesForUrl(request.url()); | - | 
| 428 |             if (!cookies.isEmpty()) | - | 
| 429 |                 request.setHeader(QNetworkRequest::CookieHeader, QVariant::fromValue(cookies)); | - | 
| 430 |         } | - | 
| 431 |     } | - | 
| 432 |  | - | 
| 433 |  | - | 
| 434 |  | - | 
| 435 |     if (scheme == QLatin1String("http") || scheme == QLatin1String("preconnect-http") | - | 
| 436 |  | - | 
| 437 |         || scheme == QLatin1String("https") || scheme == QLatin1String("preconnect-https") | - | 
| 438 |  | - | 
| 439 |         ) { | - | 
| 440 |         QNetworkReplyHttpImpl *reply = new QNetworkReplyHttpImpl(this, request, op, outgoingData); | - | 
| 441 |  | - | 
| 442 |         connect(this, qFlagLocation("2""networkSessionConnected()" "\0" __FILE__ ":" "1209""1215"), | - | 
| 443 |                 reply, qFlagLocation("1""_q_networkSessionConnected()" "\0" __FILE__ ":" "1210""1216")); | - | 
| 444 |  | - | 
| 445 |         return reply; | - | 
| 446 |     } | - | 
| 447 |  | - | 
| 448 |  | - | 
| 449 |  | - | 
| 450 |     QNetworkReplyImpl *reply = new QNetworkReplyImpl(this); | - | 
| 451 |  | - | 
| 452 |     if (!isLocalFile) { | - | 
| 453 |         connect(this, qFlagLocation("2""networkSessionConnected()" "\0" __FILE__ ":" "1220""1226"), | - | 
| 454 |                 reply, qFlagLocation("1""_q_networkSessionConnected()" "\0" __FILE__ ":" "1221""1227")); | - | 
| 455 |     } | - | 
| 456 |  | - | 
| 457 |     QNetworkReplyImplPrivate *priv = reply->d_func(); | - | 
| 458 |     priv->manager = this; | - | 
| 459 |  | - | 
| 460 |  | - | 
| 461 |  | - | 
| 462 |  | - | 
| 463 |  | - | 
| 464 |  | - | 
| 465 |     priv->backend = d->findBackend(op, request); | - | 
| 466 |  | - | 
| 467 |     if (priv->backend) { | - | 
| 468 |         priv->backend->setParent(reply); | - | 
| 469 |         priv->backend->reply = priv; | - | 
| 470 |     } | - | 
| 471 |  | - | 
| 472 |  | - | 
| 473 |     reply->setSslConfiguration(request.sslConfiguration()); | - | 
| 474 |  | - | 
| 475 |  | - | 
| 476 |  | - | 
| 477 |     priv->setup(op, request, outgoingData); | - | 
| 478 |  | - | 
| 479 |     return reply; | - | 
| 480 | } | - | 
| 481 | QStringList QNetworkAccessManager::supportedSchemes() const | - | 
| 482 | { | - | 
| 483 |     QStringList schemes; | - | 
| 484 |     QNetworkAccessManager *self = const_cast<QNetworkAccessManager *>(this); | - | 
| 485 |     QMetaObject::invokeMethod(self, "supportedSchemesImplementation", Qt::DirectConnection, | - | 
| 486 |                               QReturnArgument<QStringList >("QStringList", schemes)); | - | 
| 487 |     schemes.removeDuplicates(); | - | 
| 488 |     return schemes; | - | 
| 489 | } | - | 
| 490 | QStringList QNetworkAccessManager::supportedSchemesImplementation() const | - | 
| 491 | { | - | 
| 492 |     const QNetworkAccessManagerPrivate * const d = d_func(); | - | 
| 493 |  | - | 
| 494 |     QStringList schemes = d->backendSupportedSchemes(); | - | 
| 495 |  | - | 
| 496 |  | - | 
| 497 |     schemes << ([]() -> QString { enum { Size = sizeof(u"" "http")/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "http" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; const QString qstring_literal_temp(holder); return qstring_literal_temp; }()); | - | 
| 498 |  | - | 
| 499 |     if (QSslSocket::supportsSsl()) | - | 
| 500 |         schemes << ([]() -> QString { enum { Size = sizeof(u"" "https")/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "https" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; const QString qstring_literal_temp(holder); return qstring_literal_temp; }()); | - | 
| 501 |  | - | 
| 502 |  | - | 
| 503 |     schemes << ([]() -> QString { enum { Size = sizeof(u"" "data")/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "data" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; const QString qstring_literal_temp(holder); return qstring_literal_temp; }()); | - | 
| 504 |     return schemes; | - | 
| 505 | } | - | 
| 506 | void QNetworkAccessManager::clearAccessCache() | - | 
| 507 | { | - | 
| 508 |     QNetworkAccessManagerPrivate::clearCache(this); | - | 
| 509 | } | - | 
| 510 |  | - | 
| 511 | void QNetworkAccessManagerPrivate::_q_replyFinished() | - | 
| 512 | { | - | 
| 513 |     QNetworkAccessManager * const q = q_func(); | - | 
| 514 |  | - | 
| 515 |     QNetworkReply *reply = qobject_cast<QNetworkReply *>(q->sender()); | - | 
| 516 |     if (reply) | - | 
| 517 |         q->finished(reply); | - | 
| 518 |  | - | 
| 519 |  | - | 
| 520 |  | - | 
| 521 |  | - | 
| 522 |  | - | 
| 523 |     activeReplyCount--; | - | 
| 524 |     if (networkSessionStrongRef && activeReplyCount == 0) | - | 
| 525 |         networkSessionStrongRef.clear(); | - | 
| 526 |  | - | 
| 527 | } | - | 
| 528 |  | - | 
| 529 | void QNetworkAccessManagerPrivate::_q_replyEncrypted() | - | 
| 530 | { | - | 
| 531 |  | - | 
| 532 |     QNetworkAccessManager * const q = q_func(); | - | 
| 533 |     QNetworkReply *reply = qobject_cast<QNetworkReply *>(q->sender()); | - | 
| 534 |     if (reply) | - | 
| 535 |         q->encrypted(reply); | - | 
| 536 |  | - | 
| 537 | } | - | 
| 538 |  | - | 
| 539 | void QNetworkAccessManagerPrivate::_q_replySslErrors(const QList<QSslError> &errors) | - | 
| 540 | { | - | 
| 541 |  | - | 
| 542 |     QNetworkAccessManager * const q = q_func(); | - | 
| 543 |     QNetworkReply *reply = qobject_cast<QNetworkReply *>(q->sender()); | - | 
| 544 |     if (reply) | - | 
| 545 |         q->sslErrors(reply, errors); | - | 
| 546 |  | - | 
| 547 |  | - | 
| 548 |  | - | 
| 549 | } | - | 
| 550 |  | - | 
| 551 | void QNetworkAccessManagerPrivate::_q_replyPreSharedKeyAuthenticationRequired(QSslPreSharedKeyAuthenticator *authenticator) | - | 
| 552 | { | - | 
| 553 |  | - | 
| 554 |     QNetworkAccessManager * const q = q_func(); | - | 
| 555 |     QNetworkReply *reply = qobject_cast<QNetworkReply *>(q->sender()); | - | 
| 556 |     if (reply) | - | 
| 557 |     q->preSharedKeyAuthenticationRequired(reply, authenticator); | - | 
| 558 |  | - | 
| 559 |  | - | 
| 560 |  | - | 
| 561 | } | - | 
| 562 |  | - | 
| 563 | QNetworkReply *QNetworkAccessManagerPrivate::postProcess(QNetworkReply *reply) | - | 
| 564 | { | - | 
| 565 |     QNetworkAccessManager * const q = q_func(); | - | 
| 566 |     QNetworkReplyPrivate::setManager(reply, q); | - | 
| 567 |     q->connect(reply, qFlagLocation("2""finished()" "\0" __FILE__ ":" "1370""1376"), qFlagLocation("1""_q_replyFinished()" "\0" __FILE__ ":" "1370""1376")); | - | 
| 568 |  | - | 
| 569 |  | - | 
| 570 |  | - | 
| 571 |     q->connect(reply, qFlagLocation("2""encrypted()" "\0" __FILE__ ":" "1374""1380"), qFlagLocation("1""_q_replyEncrypted()" "\0" __FILE__ ":" "1374""1380")); | - | 
| 572 |     q->connect(reply, qFlagLocation("2""sslErrors(QList<QSslError>)" "\0" __FILE__ ":" "1375""1381"), qFlagLocation("1""_q_replySslErrors(QList<QSslError>)" "\0" __FILE__ ":" "1375""1381")); | - | 
| 573 |     q->connect(reply, qFlagLocation("2""preSharedKeyAuthenticationRequired(QSslPreSharedKeyAuthenticator*)" "\0" __FILE__ ":" "1376""1382"), qFlagLocation("1""_q_replyPreSharedKeyAuthenticationRequired(QSslPreSharedKeyAuthenticator*)" "\0" __FILE__ ":" "1376""1382")); | - | 
| 574 |  | - | 
| 575 |  | - | 
| 576 |     activeReplyCount++; | - | 
| 577 |  | - | 
| 578 |  | - | 
| 579 |     return reply; | - | 
| 580 | } | - | 
| 581 |  | - | 
| 582 | void QNetworkAccessManagerPrivate::createCookieJar() const | - | 
| 583 | { | - | 
| 584 |     if (!cookieJarCreated) { | - | 
| 585 |  | - | 
| 586 |         QNetworkAccessManagerPrivate *that = const_cast<QNetworkAccessManagerPrivate *>(this); | - | 
| 587 |         that->cookieJar = new QNetworkCookieJar(that->q_func()); | - | 
| 588 |         that->cookieJarCreated = true; | - | 
| 589 |     } | - | 
| 590 | } | - | 
| 591 |  | - | 
| 592 | void QNetworkAccessManagerPrivate::authenticationRequired(QAuthenticator *authenticator, | - | 
| 593 |                                                           QNetworkReply *reply, | - | 
| 594 |                                                           bool synchronous, | - | 
| 595 |                                                           QUrl &url, | - | 
| 596 |                                                           QUrl *urlForLastAuthentication, | - | 
| 597 |                                                           bool allowAuthenticationReuse) | - | 
| 598 | { | - | 
| 599 |     QNetworkAccessManager * const q = q_func(); | - | 
| 600 |  | - | 
| 601 |  | - | 
| 602 |  | - | 
| 603 |  | - | 
| 604 |     if (allowAuthenticationReuse && (urlForLastAuthentication->isEmpty() | - | 
| 605 |             || url != *urlForLastAuthentication)) { | - | 
| 606 |  | - | 
| 607 |         if (!url.userName().isEmpty() | - | 
| 608 |             && !url.password().isEmpty()) { | - | 
| 609 |             authenticator->setUser(url.userName(QUrl::FullyDecoded)); | - | 
| 610 |             authenticator->setPassword(url.password(QUrl::FullyDecoded)); | - | 
| 611 |             *urlForLastAuthentication = url; | - | 
| 612 |             authenticationManager->cacheCredentials(url, authenticator); | - | 
| 613 |             return; | - | 
| 614 |         } | - | 
| 615 |  | - | 
| 616 |         QNetworkAuthenticationCredential cred = authenticationManager->fetchCachedCredentials(url, authenticator); | - | 
| 617 |         if (!cred.isNull()) { | - | 
| 618 |             authenticator->setUser(cred.user); | - | 
| 619 |             authenticator->setPassword(cred.password); | - | 
| 620 |             *urlForLastAuthentication = url; | - | 
| 621 |             return; | - | 
| 622 |         } | - | 
| 623 |     } | - | 
| 624 |  | - | 
| 625 |  | - | 
| 626 |  | - | 
| 627 |     if (synchronous) | - | 
| 628 |         return; | - | 
| 629 |  | - | 
| 630 |     *urlForLastAuthentication = url; | - | 
| 631 |     q->authenticationRequired(reply, authenticator); | - | 
| 632 |     if (allowAuthenticationReuse) | - | 
| 633 |         authenticationManager->cacheCredentials(url, authenticator); | - | 
| 634 | } | - | 
| 635 |  | - | 
| 636 |  | - | 
| 637 | void QNetworkAccessManagerPrivate::proxyAuthenticationRequired(const QUrl &url, | - | 
| 638 |                                                                const QNetworkProxy &proxy, | - | 
| 639 |                                                                bool synchronous, | - | 
| 640 |                                                                QAuthenticator *authenticator, | - | 
| 641 |                                                                QNetworkProxy *lastProxyAuthentication) | - | 
| 642 | { | - | 
| 643 |     QNetworkAccessManager * const q = q_func(); | - | 
| 644 |     QAuthenticatorPrivate *priv = QAuthenticatorPrivate::getPrivate(*authenticator); | - | 
| 645 |     if (proxy != *lastProxyAuthentication && (!priv || !priv->hasFailed)) { | - | 
| 646 |         QNetworkAuthenticationCredential cred = authenticationManager->fetchCachedProxyCredentials(proxy); | - | 
| 647 |         if (!cred.isNull()) { | - | 
| 648 |             authenticator->setUser(cred.user); | - | 
| 649 |             authenticator->setPassword(cred.password); | - | 
| 650 |             return; | - | 
| 651 |         } | - | 
| 652 |     } | - | 
| 653 |     (void)url;; | - | 
| 654 |  | - | 
| 655 |  | - | 
| 656 |  | - | 
| 657 |  | - | 
| 658 |     if (synchronous) | - | 
| 659 |         return; | - | 
| 660 |  | - | 
| 661 |     *lastProxyAuthentication = proxy; | - | 
| 662 |     q->proxyAuthenticationRequired(proxy, authenticator); | - | 
| 663 |     authenticationManager->cacheProxyCredentials(proxy, authenticator); | - | 
| 664 | } | - | 
| 665 |  | - | 
| 666 | QList<QNetworkProxy> QNetworkAccessManagerPrivate::queryProxy(const QNetworkProxyQuery &query) | - | 
| 667 | { | - | 
| 668 |     QList<QNetworkProxy> proxies; | - | 
| 669 |     if (proxyFactory) { | - | 
| 670 |         proxies = proxyFactory->queryProxy(query); | - | 
| 671 |         if (proxies.isEmpty()) { | - | 
| 672 |             QMessageLogger(__FILE__, 14931499, __PRETTY_FUNCTION__).warning("QNetworkAccessManager: factory %p has returned an empty result set", | - | 
| 673 |                      proxyFactory); | - | 
| 674 |             proxies << QNetworkProxy::NoProxy; | - | 
| 675 |         } | - | 
| 676 |     } else if (proxy.type() == QNetworkProxy::DefaultProxy) { | - | 
| 677 |  | - | 
| 678 |         return QNetworkProxyFactory::proxyForQuery(query); | - | 
| 679 |     } else { | - | 
| 680 |         proxies << proxy; | - | 
| 681 |     } | - | 
| 682 |  | - | 
| 683 |     return proxies; | - | 
| 684 | } | - | 
| 685 |  | - | 
| 686 |  | - | 
| 687 | void QNetworkAccessManagerPrivate::clearCache(QNetworkAccessManager *manager) | - | 
| 688 | { | - | 
| 689 |     manager->d_func()->objectCache.clear(); | - | 
| 690 |     manager->d_func()->authenticationManager->clearCache(); | - | 
| 691 |  | - | 
| 692 |     if (manager->d_func()->httpThread) { | - | 
| 693 |         manager->d_func()->httpThread->quit(); | - | 
| 694 |         manager->d_func()->httpThread->wait(5000); | - | 
| 695 |         if (manager->d_func()->httpThread->isFinished()) | - | 
| 696 |             delete manager->d_func()->httpThread; | - | 
| 697 |         else | - | 
| 698 |             QObject::connect(manager->d_func()->httpThread, qFlagLocation("2""finished()" "\0" __FILE__ ":" "1519""1525"), manager->d_func()->httpThread, qFlagLocation("1""deleteLater()" "\0" __FILE__ ":" "1519""1525")); | - | 
| 699 |         manager->d_func()->httpThread = 0; | - | 
| 700 |     } | - | 
| 701 | } | - | 
| 702 |  | - | 
| 703 | QNetworkAccessManagerPrivate::~QNetworkAccessManagerPrivate() | - | 
| 704 | { | - | 
| 705 |     if (httpThread) { | - | 
| 706 |         httpThread->quit(); | - | 
| 707 |         httpThread->wait(5000); | - | 
| 708 |         if (httpThread->isFinished()) | - | 
| 709 |             delete httpThread; | - | 
| 710 |         else | - | 
| 711 |             QObject::connect(httpThread, qFlagLocation("2""finished()" "\0" __FILE__ ":" "1532""1538"), httpThread, qFlagLocation("1""deleteLater()" "\0" __FILE__ ":" "1532""1538")); | - | 
| 712 |         httpThread = 0; | - | 
| 713 |     } | - | 
| 714 | } | - | 
| 715 |  | - | 
| 716 |  | - | 
| 717 | void QNetworkAccessManagerPrivate::createSession(const QNetworkConfiguration &config) | - | 
| 718 | { | - | 
| 719 |     QNetworkAccessManager * const q = q_func(); | - | 
| 720 |  | - | 
| 721 |     initializeSession = false; | - | 
| 722 |  | - | 
| 723 |  | - | 
| 724 |     networkSessionStrongRef = networkSessionWeakRef.toStrongRef(); | - | 
| 725 |  | - | 
| 726 |     QSharedPointer<QNetworkSession> newSession; | - | 
| 727 |     if (config.isValid()) | - | 
| 728 |         newSession = QSharedNetworkSessionManager::getSession(config); | - | 
| 729 |  | - | 
| 730 |     if (networkSessionStrongRef) { | - | 
| 731 |  | - | 
| 732 |         if (networkSessionStrongRef == newSession) | - | 
| 733 |             return; | - | 
| 734 |  | - | 
| 735 |         QObject::disconnect(networkSessionStrongRef.data(), qFlagLocation("2""opened()" "\0" __FILE__ ":" "1556""1562"), q, qFlagLocation("2""networkSessionConnected()" "\0" __FILE__ ":" "1556""1562")); | - | 
| 736 |         QObject::disconnect(networkSessionStrongRef.data(), qFlagLocation("2""closed()" "\0" __FILE__ ":" "1557""1563"), q, qFlagLocation("1""_q_networkSessionClosed()" "\0" __FILE__ ":" "1557""1563")); | - | 
| 737 |         QObject::disconnect(networkSessionStrongRef.data(), qFlagLocation("2""stateChanged(QNetworkSession::State)" "\0" __FILE__ ":" "1558""1564"), | - | 
| 738 |             q, qFlagLocation("1""_q_networkSessionStateChanged(QNetworkSession::State)" "\0" __FILE__ ":" "1559""1565")); | - | 
| 739 |         QObject::disconnect(networkSessionStrongRef.data(), qFlagLocation("2""error(QNetworkSession::SessionError)" "\0" __FILE__ ":" "1560""1566"), | - | 
| 740 |                             q, qFlagLocation("1""_q_networkSessionFailed(QNetworkSession::SessionError)" "\0" __FILE__ ":" "1561""1567")); | - | 
| 741 |     } | - | 
| 742 |  | - | 
| 743 |  | - | 
| 744 |     networkSessionStrongRef = newSession; | - | 
| 745 |     networkSessionWeakRef = networkSessionStrongRef.toWeakRef(); | - | 
| 746 |  | - | 
| 747 |     if (!networkSessionStrongRef) { | - | 
| 748 |  | - | 
| 749 |         if (networkAccessible == QNetworkAccessManager::NotAccessible || !online) | - | 
| 750 |             q->networkAccessibleChanged(QNetworkAccessManager::NotAccessible); | - | 
| 751 |         else | - | 
| 752 |             q->networkAccessibleChanged(QNetworkAccessManager::UnknownAccessibility); | - | 
| 753 |  | - | 
| 754 |         return; | - | 
| 755 |     } | - | 
| 756 |  | - | 
| 757 |  | - | 
| 758 |     QObject::connect(networkSessionStrongRef.data(), qFlagLocation("2""opened()" "\0" __FILE__ ":" "1579""1585"), q, qFlagLocation("2""networkSessionConnected()" "\0" __FILE__ ":" "1579""1585"), Qt::QueuedConnection); | - | 
| 759 |  | - | 
| 760 |     QObject::connect(networkSessionStrongRef.data(), qFlagLocation("2""closed()" "\0" __FILE__ ":" "1581""1587"), q, qFlagLocation("1""_q_networkSessionClosed()" "\0" __FILE__ ":" "1581""1587"), Qt::QueuedConnection); | - | 
| 761 |     QObject::connect(networkSessionStrongRef.data(), qFlagLocation("2""stateChanged(QNetworkSession::State)" "\0" __FILE__ ":" "1582""1588"), | - | 
| 762 |                      q, qFlagLocation("1""_q_networkSessionStateChanged(QNetworkSession::State)" "\0" __FILE__ ":" "1583""1589"), Qt::QueuedConnection); | - | 
| 763 |     QObject::connect(networkSessionStrongRef.data(), qFlagLocation("2""error(QNetworkSession::SessionError)" "\0" __FILE__ ":" "1584""1590"), | - | 
| 764 |                         q, qFlagLocation("1""_q_networkSessionFailed(QNetworkSession::SessionError)" "\0" __FILE__ ":" "1585""1591")); | - | 
| 765 |  | - | 
| 766 |     _q_networkSessionStateChanged(networkSessionStrongRef->state()); | - | 
| 767 | } | - | 
| 768 |  | - | 
| 769 | void QNetworkAccessManagerPrivate::_q_networkSessionClosed() | - | 
| 770 | { | - | 
| 771 |     QNetworkAccessManager * const q = q_func(); | - | 
| 772 |     QSharedPointer<QNetworkSession> networkSession(getNetworkSession()); | - | 
| 773 |     if (networkSession) { | - | 
| 774 |         networkConfiguration = networkSession->configuration(); | - | 
| 775 |  | - | 
| 776 |  | - | 
| 777 |         QObject::disconnect(networkSession.data(), qFlagLocation("2""opened()" "\0" __FILE__ ":" "1598""1604"), q, qFlagLocation("2""networkSessionConnected()" "\0" __FILE__ ":" "1598""1604")); | - | 
| 778 |         QObject::disconnect(networkSession.data(), qFlagLocation("2""closed()" "\0" __FILE__ ":" "1599""1605"), q, qFlagLocation("1""_q_networkSessionClosed()" "\0" __FILE__ ":" "1599""1605")); | - | 
| 779 |         QObject::disconnect(networkSession.data(), qFlagLocation("2""stateChanged(QNetworkSession::State)" "\0" __FILE__ ":" "1600""1606"), | - | 
| 780 |             q, qFlagLocation("1""_q_networkSessionStateChanged(QNetworkSession::State)" "\0" __FILE__ ":" "1601""1607")); | - | 
| 781 |         QObject::disconnect(networkSession.data(), qFlagLocation("2""error(QNetworkSession::SessionError)" "\0" __FILE__ ":" "1602""1608"), | - | 
| 782 |                             q, qFlagLocation("1""_q_networkSessionFailed(QNetworkSession::SessionError)" "\0" __FILE__ ":" "1603""1609")); | - | 
| 783 |  | - | 
| 784 |         networkSessionStrongRef.clear(); | - | 
| 785 |         networkSessionWeakRef.clear(); | - | 
| 786 |     } | - | 
| 787 | } | - | 
| 788 |  | - | 
| 789 | void QNetworkAccessManagerPrivate::_q_networkSessionStateChanged(QNetworkSession::State state) | - | 
| 790 | { | - | 
| 791 |     QNetworkAccessManager * const q = q_func(); | - | 
| 792 |     bool reallyOnline = false; | - | 
| 793 |  | - | 
| 794 |  | - | 
| 795 |     if (state == QNetworkSession::Connected| TRUE | evaluated 99 times by 9 testsEvaluated by:- tst_QAbstractNetworkCache
 - tst_QHttpNetworkConnection
 - tst_QNetworkAccessManager
 - tst_QNetworkAccessManager_And_QProgressDialog
 - tst_QNetworkDiskCache
 - tst_QNetworkProxyFactory
 - tst_QNetworkReply
 - tst_QXmlInputSource
 - tst_Spdy
 
   |  | FALSE | never evaluated |  
   && lastSessionState != QNetworkSession::Roaming| TRUE | evaluated 99 times by 9 testsEvaluated by:- tst_QAbstractNetworkCache
 - tst_QHttpNetworkConnection
 - tst_QNetworkAccessManager
 - tst_QNetworkAccessManager_And_QProgressDialog
 - tst_QNetworkDiskCache
 - tst_QNetworkProxyFactory
 - tst_QNetworkReply
 - tst_QXmlInputSource
 - tst_Spdy
 
   |  | FALSE | never evaluated |  
  ) | 0-99 | 
| 796 |         q->networkSessionConnected();executed 99 times by 9 tests:  q->networkSessionConnected();Executed by:- tst_QAbstractNetworkCache
 - tst_QHttpNetworkConnection
 - tst_QNetworkAccessManager
 - tst_QNetworkAccessManager_And_QProgressDialog
 - tst_QNetworkDiskCache
 - tst_QNetworkProxyFactory
 - tst_QNetworkReply
 - tst_QXmlInputSource
 - tst_Spdy
 
    | 99 | 
| 797 |     lastSessionState = state; | - | 
| 798 |  | - | 
| 799 |     if (online| TRUE | evaluated 99 times by 9 testsEvaluated by:- tst_QAbstractNetworkCache
 - tst_QHttpNetworkConnection
 - tst_QNetworkAccessManager
 - tst_QNetworkAccessManager_And_QProgressDialog
 - tst_QNetworkDiskCache
 - tst_QNetworkProxyFactory
 - tst_QNetworkReply
 - tst_QXmlInputSource
 - tst_Spdy
 
   |  | FALSE | never evaluated |  
   && state == QNetworkSession::Disconnected| TRUE | never evaluated |  | FALSE | evaluated 99 times by 9 testsEvaluated by:- tst_QAbstractNetworkCache
 - tst_QHttpNetworkConnection
 - tst_QNetworkAccessManager
 - tst_QNetworkAccessManager_And_QProgressDialog
 - tst_QNetworkDiskCache
 - tst_QNetworkProxyFactory
 - tst_QNetworkReply
 - tst_QXmlInputSource
 - tst_Spdy
 
   |  
  ) { | 0-99 | 
| 800 |         for (QForeachContainer<typename QtPrivate::remove_reference<decltype(networkConfigurationManager.allConfigurations())>::type> _container_((const auto cfgs = networkConfigurationManager.allConfigurations())); _container_.control && _container_.i != _container_.e; ++_container_.i, _container_.control ^= 1)(); | - | 
| 801 |         for (const QNetworkConfiguration &cfg = *_container_.i; _container_.control; _container_.control = 0: cfgs) { | - | 
| 802 |             if (cfg.state().testFlag(QNetworkConfiguration::Active)| TRUE | never evaluated |  | FALSE | never evaluated |  
  ) { | 0 | 
| 803 |                 reallyOnline = true; | - | 
| 804 |             } never executed: end of block  | 0 | 
| 805 |         } never executed: end of block  | 0 | 
| 806 |     } never executed: end of block  else if (state == QNetworkSession::Connected| TRUE | evaluated 99 times by 9 testsEvaluated by:- tst_QAbstractNetworkCache
 - tst_QHttpNetworkConnection
 - tst_QNetworkAccessManager
 - tst_QNetworkAccessManager_And_QProgressDialog
 - tst_QNetworkDiskCache
 - tst_QNetworkProxyFactory
 - tst_QNetworkReply
 - tst_QXmlInputSource
 - tst_Spdy
 
   |  | FALSE | never evaluated |  
   || state == QNetworkSession::Roaming| TRUE | never evaluated |  | FALSE | never evaluated |  
  ) { | 0-99 | 
| 807 |         reallyOnline = true; | - | 
| 808 |     }executed 99 times by 9 tests:  end of blockExecuted by:- tst_QAbstractNetworkCache
 - tst_QHttpNetworkConnection
 - tst_QNetworkAccessManager
 - tst_QNetworkAccessManager_And_QProgressDialog
 - tst_QNetworkDiskCache
 - tst_QNetworkProxyFactory
 - tst_QNetworkReply
 - tst_QXmlInputSource
 - tst_Spdy
 
    | 99 | 
| 809 |  | - | 
| 810 |     if (!reallyOnline| TRUE | never evaluated |  | FALSE | evaluated 99 times by 9 testsEvaluated by:- tst_QAbstractNetworkCache
 - tst_QHttpNetworkConnection
 - tst_QNetworkAccessManager
 - tst_QNetworkAccessManager_And_QProgressDialog
 - tst_QNetworkDiskCache
 - tst_QNetworkProxyFactory
 - tst_QNetworkReply
 - tst_QXmlInputSource
 - tst_Spdy
 
   |  
  ) { | 0-99 | 
| 811 |         if (state != QNetworkSession::Connected| TRUE | never evaluated |  | FALSE | never evaluated |  
   && state != QNetworkSession::Roaming| TRUE | never evaluated |  | FALSE | never evaluated |  
  ) { | 0 | 
| 812 |             if (networkAccessible != QNetworkAccessManager::NotAccessible| TRUE | never evaluated |  | FALSE | never evaluated |  
  ) { | 0 | 
| 813 |                 networkAccessible = QNetworkAccessManager::NotAccessible; | - | 
| 814 |                 q->networkAccessibleChanged(networkAccessible); | - | 
| 815 |             } never executed: end of block  | 0 | 
| 816 |         } never executed: end of block  | 0 | 
| 817 |     } never executed: end of block  else { | 0 | 
| 818 |         if (defaultAccessControl| TRUE | evaluated 99 times by 9 testsEvaluated by:- tst_QAbstractNetworkCache
 - tst_QHttpNetworkConnection
 - tst_QNetworkAccessManager
 - tst_QNetworkAccessManager_And_QProgressDialog
 - tst_QNetworkDiskCache
 - tst_QNetworkProxyFactory
 - tst_QNetworkReply
 - tst_QXmlInputSource
 - tst_Spdy
 
   |  | FALSE | never evaluated |  
  ) | 0-99 | 
| 819 |             if (networkAccessible != QNetworkAccessManager::Accessible| TRUE | never evaluated |  | FALSE | evaluated 99 times by 9 testsEvaluated by:- tst_QAbstractNetworkCache
 - tst_QHttpNetworkConnection
 - tst_QNetworkAccessManager
 - tst_QNetworkAccessManager_And_QProgressDialog
 - tst_QNetworkDiskCache
 - tst_QNetworkProxyFactory
 - tst_QNetworkReply
 - tst_QXmlInputSource
 - tst_Spdy
 
   |  
  ) { | 0-99 | 
| 820 |                 networkAccessible = QNetworkAccessManager::Accessible; | - | 
| 821 |                 q->networkAccessibleChanged(networkAccessible); | - | 
| 822 |             } never executed: end of block  | 0 | 
| 823 |     }executed 99 times by 9 tests:  end of blockExecuted by:- tst_QAbstractNetworkCache
 - tst_QHttpNetworkConnection
 - tst_QNetworkAccessManager
 - tst_QNetworkAccessManager_And_QProgressDialog
 - tst_QNetworkDiskCache
 - tst_QNetworkProxyFactory
 - tst_QNetworkReply
 - tst_QXmlInputSource
 - tst_Spdy
 
    | 99 | 
| 824 |     online = reallyOnline; | - | 
| 825 |     if (online| TRUE | evaluated 99 times by 9 testsEvaluated by:- tst_QAbstractNetworkCache
 - tst_QHttpNetworkConnection
 - tst_QNetworkAccessManager
 - tst_QNetworkAccessManager_And_QProgressDialog
 - tst_QNetworkDiskCache
 - tst_QNetworkProxyFactory
 - tst_QNetworkReply
 - tst_QXmlInputSource
 - tst_Spdy
 
   |  | FALSE | never evaluated |  
   && (state != QNetworkSession::Connected| TRUE | never evaluated |  | FALSE | evaluated 99 times by 9 testsEvaluated by:- tst_QAbstractNetworkCache
 - tst_QHttpNetworkConnection
 - tst_QNetworkAccessManager
 - tst_QNetworkAccessManager_And_QProgressDialog
 - tst_QNetworkDiskCache
 - tst_QNetworkProxyFactory
 - tst_QNetworkReply
 - tst_QXmlInputSource
 - tst_Spdy
 
   |  
   && state != QNetworkSession::Roaming| TRUE | never evaluated |  | FALSE | never evaluated |  
  )) { | 0-99 | 
| 826 |         _q_networkSessionClosed(); | - | 
| 827 |         createSession(q->configuration()); | - | 
| 828 |     } never executed: end of block  | 0 | 
| 829 | }executed 99 times by 9 tests:  end of blockExecuted by:- tst_QAbstractNetworkCache
 - tst_QHttpNetworkConnection
 - tst_QNetworkAccessManager
 - tst_QNetworkAccessManager_And_QProgressDialog
 - tst_QNetworkDiskCache
 - tst_QNetworkProxyFactory
 - tst_QNetworkReply
 - tst_QXmlInputSource
 - tst_Spdy
 
    | 99 | 
| 830 |  | - | 
| 831 | void QNetworkAccessManagerPrivate::_q_onlineStateChanged(bool isOnline) | - | 
| 832 | { | - | 
| 833 |    QNetworkAccessManager * const q = q_func(); | - | 
| 834 |  | - | 
| 835 |  | - | 
| 836 |  | - | 
| 837 |     if (customNetworkConfiguration) { | - | 
| 838 |         online = (networkConfiguration.state() & QNetworkConfiguration::Active); | - | 
| 839 |     } else { | - | 
| 840 |         if (online != isOnline) { | - | 
| 841 |                 _q_networkSessionClosed(); | - | 
| 842 |                 createSession(q->configuration()); | - | 
| 843 |             online = isOnline; | - | 
| 844 |         } | - | 
| 845 |     } | - | 
| 846 |     if (online) { | - | 
| 847 |         if (defaultAccessControl) { | - | 
| 848 |             if (networkAccessible != QNetworkAccessManager::Accessible) { | - | 
| 849 |                 networkAccessible = QNetworkAccessManager::Accessible; | - | 
| 850 |                 q->networkAccessibleChanged(networkAccessible); | - | 
| 851 |             } | - | 
| 852 |         } | - | 
| 853 |     } else { | - | 
| 854 |         if (networkAccessible != QNetworkAccessManager::NotAccessible) { | - | 
| 855 |             networkAccessible = QNetworkAccessManager::NotAccessible; | - | 
| 856 |             q->networkAccessibleChanged(networkAccessible); | - | 
| 857 |         } | - | 
| 858 |     } | - | 
| 859 | } | - | 
| 860 |  | - | 
| 861 | void QNetworkAccessManagerPrivate::_q_configurationChanged(const QNetworkConfiguration &configuration) | - | 
| 862 | { | - | 
| 863 |     const QString id = configuration.identifier(); | - | 
| 864 |     if (configuration.state().testFlag(QNetworkConfiguration::Active)) { | - | 
| 865 |         if (!onlineConfigurations.contains(id)) { | - | 
| 866 |  | - | 
| 867 |             QSharedPointer<QNetworkSession> session(getNetworkSession()); | - | 
| 868 |             if (session) { | - | 
| 869 |                 if (online && session->configuration().identifier() | - | 
| 870 |                         != networkConfigurationManager.defaultConfiguration().identifier()) { | - | 
| 871 |  | - | 
| 872 |                     onlineConfigurations.insert(id); | - | 
| 873 |  | - | 
| 874 |  | - | 
| 875 |                     _q_networkSessionClosed(); | - | 
| 876 |                     createSession(networkConfigurationManager.defaultConfiguration()); | - | 
| 877 |                 } | - | 
| 878 |             } | - | 
| 879 |         } | - | 
| 880 |  | - | 
| 881 |     } else if (onlineConfigurations.contains(id)) { | - | 
| 882 |  | - | 
| 883 |         onlineConfigurations.remove(id); | - | 
| 884 |         if (!onlineConfigurations.isEmpty()) { | - | 
| 885 |             _q_networkSessionClosed(); | - | 
| 886 |             createSession(configuration); | - | 
| 887 |         } | - | 
| 888 |     } | - | 
| 889 | } | - | 
| 890 |  | - | 
| 891 |  | - | 
| 892 | void QNetworkAccessManagerPrivate::_q_networkSessionFailed(QNetworkSession::SessionError) | - | 
| 893 | { | - | 
| 894 |     for (QForeachContainer<typename QtPrivate::remove_reference<decltype(networkConfigurationManager.allConfigurations())>::type> _container_((const auto cfgs = networkConfigurationManager.allConfigurations())); _container_.control && _container_.i != _container_.e; ++_container_.i, _container_.control ^= 1)(); | - | 
| 895 |     for (const QNetworkConfiguration &cfg = *_container_.i; _container_.control; _container_.control = 0: cfgs) { | - | 
| 896 |         if (cfg.state().testFlag(QNetworkConfiguration::Active)| TRUE | never evaluated |  | FALSE | never evaluated |  
  ) { | 0 | 
| 897 |             online = true; | - | 
| 898 |             _q_networkSessionClosed(); | - | 
| 899 |             createSession(networkConfigurationManager.defaultConfiguration()); | - | 
| 900 |             return; never executed: return;  | 0 | 
| 901 |         } | - | 
| 902 |     } never executed: end of block  | 0 | 
| 903 | } never executed: end of block  | 0 | 
| 904 |  | - | 
| 905 |  | - | 
| 906 |  | - | 
| 907 | QNetworkRequest QNetworkAccessManagerPrivate::prepareMultipart(const QNetworkRequest &request, QHttpMultiPart *multiPart) | - | 
| 908 | { | - | 
| 909 |  | - | 
| 910 |     QNetworkRequest newRequest(request); | - | 
| 911 |  | - | 
| 912 |  | - | 
| 913 |     if (!request.header(QNetworkRequest::ContentTypeHeader).isValid()) { | - | 
| 914 |         QByteArray contentType; | - | 
| 915 |         contentType.reserve(34 + multiPart->d_func()->boundary.count()); | - | 
| 916 |         contentType += "multipart/"; | - | 
| 917 |         switch (multiPart->d_func()->contentType) { | - | 
| 918 |         case QHttpMultiPart::RelatedType: | - | 
| 919 |             contentType += "related"; | - | 
| 920 |             break; | - | 
| 921 |         case QHttpMultiPart::FormDataType: | - | 
| 922 |             contentType += "form-data"; | - | 
| 923 |             break; | - | 
| 924 |         case QHttpMultiPart::AlternativeType: | - | 
| 925 |             contentType += "alternative"; | - | 
| 926 |             break; | - | 
| 927 |         default: | - | 
| 928 |             contentType += "mixed"; | - | 
| 929 |             break; | - | 
| 930 |         } | - | 
| 931 |  | - | 
| 932 |         contentType += "; boundary=\"" + multiPart->d_func()->boundary + '"'; | - | 
| 933 |         newRequest.setHeader(QNetworkRequest::ContentTypeHeader, QVariant(contentType)); | - | 
| 934 |     } | - | 
| 935 |  | - | 
| 936 |  | - | 
| 937 |  | - | 
| 938 |     QByteArray mimeHeader("MIME-Version"); | - | 
| 939 |     if (!request.hasRawHeader(mimeHeader)) | - | 
| 940 |         newRequest.setRawHeader(mimeHeader, QByteArray("1.0")); | - | 
| 941 |  | - | 
| 942 |     QIODevice *device = multiPart->d_func()->device; | - | 
| 943 |     if (!device->isReadable()) { | - | 
| 944 |         if (!device->isOpen()) { | - | 
| 945 |             if (!device->open(QIODevice::ReadOnly)) | - | 
| 946 |                 QMessageLogger(__FILE__, 17651773, __PRETTY_FUNCTION__).warning("could not open device for reading"); | - | 
| 947 |         } else { | - | 
| 948 |             QMessageLogger(__FILE__, 17671775, __PRETTY_FUNCTION__).warning("device is not readable"); | - | 
| 949 |         } | - | 
| 950 |     } | - | 
| 951 |  | - | 
| 952 |     return newRequest; | - | 
| 953 | } | - | 
| 954 |  | - | 
| 955 |  | - | 
| 956 |  | - | 
 |  |  |