1 /* 2 * Copyright (C) 2011, 2012 Google Inc. All rights reserved. 3 * Copyright (C) 2013, Intel Corporation 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions are 7 * met: 8 * 9 * * Redistributions of source code must retain the above copyright 10 * notice, this list of conditions and the following disclaimer. 11 * * Redistributions in binary form must reproduce the above 12 * copyright notice, this list of conditions and the following disclaimer 13 * in the documentation and/or other materials provided with the 14 * distribution. 15 * * Neither the name of Google Inc. nor the names of its 16 * contributors may be used to endorse or promote products derived from 17 * this software without specific prior written permission. 18 * 19 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 20 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 21 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 22 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 23 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 24 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 25 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 26 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 27 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 28 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 29 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 30 */ 31 32 #include "config.h" 33 #include "core/loader/DocumentThreadableLoader.h" 34 35 #include "core/dom/Document.h" 36 #include "core/fetch/CrossOriginAccessControl.h" 37 #include "core/fetch/FetchRequest.h" 38 #include "core/fetch/FetchUtils.h" 39 #include "core/fetch/Resource.h" 40 #include "core/fetch/ResourceFetcher.h" 41 #include "core/frame/FrameConsole.h" 42 #include "core/frame/LocalFrame.h" 43 #include "core/frame/csp/ContentSecurityPolicy.h" 44 #include "core/inspector/InspectorInstrumentation.h" 45 #include "core/inspector/InspectorTraceEvents.h" 46 #include "core/loader/CrossOriginPreflightResultCache.h" 47 #include "core/loader/DocumentThreadableLoaderClient.h" 48 #include "core/loader/FrameLoader.h" 49 #include "core/loader/ThreadableLoaderClient.h" 50 #include "platform/SharedBuffer.h" 51 #include "platform/network/ResourceRequest.h" 52 #include "platform/weborigin/SchemeRegistry.h" 53 #include "platform/weborigin/SecurityOrigin.h" 54 #include "public/platform/WebURLRequest.h" 55 #include "wtf/Assertions.h" 56 57 namespace blink { 58 59 void DocumentThreadableLoader::loadResourceSynchronously(Document& document, const ResourceRequest& request, ThreadableLoaderClient& client, const ThreadableLoaderOptions& options, const ResourceLoaderOptions& resourceLoaderOptions) 60 { 61 // The loader will be deleted as soon as this function exits. 62 RefPtr<DocumentThreadableLoader> loader = adoptRef(new DocumentThreadableLoader(document, &client, LoadSynchronously, request, options, resourceLoaderOptions)); 63 ASSERT(loader->hasOneRef()); 64 } 65 66 PassRefPtr<DocumentThreadableLoader> DocumentThreadableLoader::create(Document& document, ThreadableLoaderClient* client, const ResourceRequest& request, const ThreadableLoaderOptions& options, const ResourceLoaderOptions& resourceLoaderOptions) 67 { 68 RefPtr<DocumentThreadableLoader> loader = adoptRef(new DocumentThreadableLoader(document, client, LoadAsynchronously, request, options, resourceLoaderOptions)); 69 if (!loader->resource()) 70 loader = nullptr; 71 return loader.release(); 72 } 73 74 DocumentThreadableLoader::DocumentThreadableLoader(Document& document, ThreadableLoaderClient* client, BlockingBehavior blockingBehavior, const ResourceRequest& request, const ThreadableLoaderOptions& options, const ResourceLoaderOptions& resourceLoaderOptions) 75 : m_client(client) 76 , m_document(document) 77 , m_options(options) 78 , m_resourceLoaderOptions(resourceLoaderOptions) 79 , m_forceDoNotAllowStoredCredentials(false) 80 , m_securityOrigin(m_resourceLoaderOptions.securityOrigin) 81 , m_sameOriginRequest(securityOrigin()->canRequest(request.url())) 82 , m_simpleRequest(true) 83 , m_async(blockingBehavior == LoadAsynchronously) 84 , m_timeoutTimer(this, &DocumentThreadableLoader::didTimeout) 85 , m_requestStartedSeconds(0.0) 86 { 87 ASSERT(client); 88 // Setting an outgoing referer is only supported in the async code path. 89 ASSERT(m_async || request.httpReferrer().isEmpty()); 90 91 m_requestStartedSeconds = monotonicallyIncreasingTime(); 92 93 // Save any CORS simple headers on the request here. If this request redirects cross-origin, we cancel the old request 94 // create a new one, and copy these headers. 95 const HTTPHeaderMap& headerMap = request.httpHeaderFields(); 96 HTTPHeaderMap::const_iterator end = headerMap.end(); 97 for (HTTPHeaderMap::const_iterator it = headerMap.begin(); it != end; ++it) { 98 if (FetchUtils::isSimpleHeader(it->key, it->value)) 99 m_simpleRequestHeaders.add(it->key, it->value); 100 } 101 102 if (m_sameOriginRequest || m_options.crossOriginRequestPolicy == AllowCrossOriginRequests) { 103 loadRequest(request, m_resourceLoaderOptions); 104 return; 105 } 106 107 if (m_options.crossOriginRequestPolicy == DenyCrossOriginRequests) { 108 m_client->didFail(ResourceError(errorDomainBlinkInternal, 0, request.url().string(), "Cross origin requests are not supported.")); 109 return; 110 } 111 112 makeCrossOriginAccessRequest(request); 113 } 114 115 void DocumentThreadableLoader::makeCrossOriginAccessRequest(const ResourceRequest& request) 116 { 117 ASSERT(m_options.crossOriginRequestPolicy == UseAccessControl); 118 119 // Cross-origin requests are only allowed certain registered schemes. 120 // We would catch this when checking response headers later, but there 121 // is no reason to send a request, preflighted or not, that's guaranteed 122 // to be denied. 123 if (!SchemeRegistry::shouldTreatURLSchemeAsCORSEnabled(request.url().protocol())) { 124 m_client->didFailAccessControlCheck(ResourceError(errorDomainBlinkInternal, 0, request.url().string(), "Cross origin requests are only supported for protocol schemes: " + SchemeRegistry::listOfCORSEnabledURLSchemes() + ".")); 125 return; 126 } 127 128 if ((m_options.preflightPolicy == ConsiderPreflight && FetchUtils::isSimpleOrForbiddenRequest(request.httpMethod(), request.httpHeaderFields())) || m_options.preflightPolicy == PreventPreflight) { 129 ResourceRequest crossOriginRequest(request); 130 ResourceLoaderOptions crossOriginOptions(m_resourceLoaderOptions); 131 updateRequestForAccessControl(crossOriginRequest, securityOrigin(), effectiveAllowCredentials()); 132 loadRequest(crossOriginRequest, crossOriginOptions); 133 } else { 134 m_simpleRequest = false; 135 136 OwnPtr<ResourceRequest> crossOriginRequest = adoptPtr(new ResourceRequest(request)); 137 OwnPtr<ResourceLoaderOptions> crossOriginOptions = adoptPtr(new ResourceLoaderOptions(m_resourceLoaderOptions)); 138 // Do not set the Origin header for preflight requests. 139 updateRequestForAccessControl(*crossOriginRequest, 0, effectiveAllowCredentials()); 140 m_actualRequest = crossOriginRequest.release(); 141 m_actualOptions = crossOriginOptions.release(); 142 143 bool shouldForcePreflight = InspectorInstrumentation::shouldForceCORSPreflight(&m_document); 144 bool canSkipPreflight = CrossOriginPreflightResultCache::shared().canSkipPreflight(securityOrigin()->toString(), m_actualRequest->url(), effectiveAllowCredentials(), m_actualRequest->httpMethod(), m_actualRequest->httpHeaderFields()); 145 if (canSkipPreflight && !shouldForcePreflight) { 146 loadActualRequest(); 147 } else { 148 ResourceRequest preflightRequest = createAccessControlPreflightRequest(*m_actualRequest, securityOrigin()); 149 // Create a ResourceLoaderOptions for preflight. 150 ResourceLoaderOptions preflightOptions = *m_actualOptions; 151 preflightOptions.allowCredentials = DoNotAllowStoredCredentials; 152 loadRequest(preflightRequest, preflightOptions); 153 } 154 } 155 } 156 157 DocumentThreadableLoader::~DocumentThreadableLoader() 158 { 159 } 160 161 void DocumentThreadableLoader::overrideTimeout(unsigned long timeoutMilliseconds) 162 { 163 ASSERT(m_async); 164 ASSERT(m_requestStartedSeconds > 0.0); 165 m_timeoutTimer.stop(); 166 // At the time of this method's implementation, it is only ever called by 167 // XMLHttpRequest, when the timeout attribute is set after sending the 168 // request. 169 // 170 // The XHR request says to resolve the time relative to when the request 171 // was initially sent, however other uses of this method may need to 172 // behave differently, in which case this should be re-arranged somehow. 173 if (timeoutMilliseconds) { 174 double elapsedTime = monotonicallyIncreasingTime() - m_requestStartedSeconds; 175 double nextFire = timeoutMilliseconds / 1000.0; 176 double resolvedTime = std::max(nextFire - elapsedTime, 0.0); 177 m_timeoutTimer.startOneShot(resolvedTime, FROM_HERE); 178 } 179 } 180 181 void DocumentThreadableLoader::cancel() 182 { 183 cancelWithError(ResourceError()); 184 } 185 186 void DocumentThreadableLoader::cancelWithError(const ResourceError& error) 187 { 188 RefPtr<DocumentThreadableLoader> protect(this); 189 190 // Cancel can re-enter and m_resource might be null here as a result. 191 if (m_client && resource()) { 192 ResourceError errorForCallback = error; 193 if (errorForCallback.isNull()) { 194 // FIXME: This error is sent to the client in didFail(), so it should not be an internal one. Use FrameLoaderClient::cancelledError() instead. 195 errorForCallback = ResourceError(errorDomainBlinkInternal, 0, resource()->url().string(), "Load cancelled"); 196 errorForCallback.setIsCancellation(true); 197 } 198 m_client->didFail(errorForCallback); 199 } 200 clearResource(); 201 m_client = 0; 202 m_requestStartedSeconds = 0.0; 203 } 204 205 void DocumentThreadableLoader::setDefersLoading(bool value) 206 { 207 if (resource()) 208 resource()->setDefersLoading(value); 209 } 210 211 void DocumentThreadableLoader::redirectReceived(Resource* resource, ResourceRequest& request, const ResourceResponse& redirectResponse) 212 { 213 ASSERT(m_client); 214 ASSERT_UNUSED(resource, resource == this->resource()); 215 216 RefPtr<DocumentThreadableLoader> protect(this); 217 218 // FIXME: Support redirect in Fetch API. 219 if (resource->resourceRequest().requestContext() == blink::WebURLRequest::RequestContextFetch) { 220 m_client->didFailRedirectCheck(); 221 request = ResourceRequest(); 222 return; 223 } 224 225 if (!isAllowedByPolicy(request.url())) { 226 m_client->didFailRedirectCheck(); 227 request = ResourceRequest(); 228 m_requestStartedSeconds = 0.0; 229 return; 230 } 231 232 // Allow same origin requests to continue after allowing clients to audit the redirect. 233 if (isAllowedRedirect(request.url())) { 234 if (m_client->isDocumentThreadableLoaderClient()) 235 static_cast<DocumentThreadableLoaderClient*>(m_client)->willSendRequest(request, redirectResponse); 236 return; 237 } 238 239 // When using access control, only simple cross origin requests are allowed to redirect. The new request URL must have a supported 240 // scheme and not contain the userinfo production. In addition, the redirect response must pass the access control check if the 241 // original request was not same-origin. 242 if (m_options.crossOriginRequestPolicy == UseAccessControl) { 243 244 InspectorInstrumentation::didReceiveCORSRedirectResponse(m_document.frame(), resource->identifier(), m_document.frame()->loader().documentLoader(), redirectResponse, 0); 245 246 bool allowRedirect = false; 247 String accessControlErrorDescription; 248 249 if (m_simpleRequest) { 250 allowRedirect = CrossOriginAccessControl::isLegalRedirectLocation(request.url(), accessControlErrorDescription) 251 && (m_sameOriginRequest || passesAccessControlCheck(redirectResponse, effectiveAllowCredentials(), securityOrigin(), accessControlErrorDescription)); 252 } else { 253 accessControlErrorDescription = "The request was redirected to '"+ request.url().string() + "', which is disallowed for cross-origin requests that require preflight."; 254 } 255 256 if (allowRedirect) { 257 // FIXME: consider combining this with CORS redirect handling performed by 258 // CrossOriginAccessControl::handleRedirect(). 259 clearResource(); 260 261 RefPtr<SecurityOrigin> originalOrigin = SecurityOrigin::create(redirectResponse.url()); 262 RefPtr<SecurityOrigin> requestOrigin = SecurityOrigin::create(request.url()); 263 // If the original request wasn't same-origin, then if the request URL origin is not same origin with the original URL origin, 264 // set the source origin to a globally unique identifier. (If the original request was same-origin, the origin of the new request 265 // should be the original URL origin.) 266 if (!m_sameOriginRequest && !originalOrigin->isSameSchemeHostPort(requestOrigin.get())) 267 m_securityOrigin = SecurityOrigin::createUnique(); 268 // Force any subsequent requests to use these checks. 269 m_sameOriginRequest = false; 270 271 // Since the request is no longer same-origin, if the user didn't request credentials in 272 // the first place, update our state so we neither request them nor expect they must be allowed. 273 if (m_resourceLoaderOptions.credentialsRequested == ClientDidNotRequestCredentials) 274 m_forceDoNotAllowStoredCredentials = true; 275 276 // Remove any headers that may have been added by the network layer that cause access control to fail. 277 request.clearHTTPReferrer(); 278 request.clearHTTPOrigin(); 279 request.clearHTTPUserAgent(); 280 // Add any CORS simple request headers which we previously saved from the original request. 281 HTTPHeaderMap::const_iterator end = m_simpleRequestHeaders.end(); 282 for (HTTPHeaderMap::const_iterator it = m_simpleRequestHeaders.begin(); it != end; ++it) { 283 request.setHTTPHeaderField(it->key, it->value); 284 } 285 makeCrossOriginAccessRequest(request); 286 return; 287 } 288 289 ResourceError error(errorDomainBlinkInternal, 0, redirectResponse.url().string(), accessControlErrorDescription); 290 m_client->didFailAccessControlCheck(error); 291 } else { 292 m_client->didFailRedirectCheck(); 293 } 294 request = ResourceRequest(); 295 m_requestStartedSeconds = 0.0; 296 } 297 298 void DocumentThreadableLoader::dataSent(Resource* resource, unsigned long long bytesSent, unsigned long long totalBytesToBeSent) 299 { 300 ASSERT(m_client); 301 ASSERT_UNUSED(resource, resource == this->resource()); 302 m_client->didSendData(bytesSent, totalBytesToBeSent); 303 } 304 305 void DocumentThreadableLoader::dataDownloaded(Resource* resource, int dataLength) 306 { 307 ASSERT(m_client); 308 ASSERT_UNUSED(resource, resource == this->resource()); 309 ASSERT(!m_actualRequest); 310 311 m_client->didDownloadData(dataLength); 312 } 313 314 void DocumentThreadableLoader::responseReceived(Resource* resource, const ResourceResponse& response) 315 { 316 ASSERT_UNUSED(resource, resource == this->resource()); 317 handleResponse(resource->identifier(), response); 318 } 319 320 void DocumentThreadableLoader::handlePreflightResponse(const ResourceResponse& response) 321 { 322 String accessControlErrorDescription; 323 324 if (!passesAccessControlCheck(response, effectiveAllowCredentials(), securityOrigin(), accessControlErrorDescription)) { 325 handlePreflightFailure(response.url().string(), accessControlErrorDescription); 326 return; 327 } 328 329 if (!passesPreflightStatusCheck(response, accessControlErrorDescription)) { 330 handlePreflightFailure(response.url().string(), accessControlErrorDescription); 331 return; 332 } 333 334 OwnPtr<CrossOriginPreflightResultCacheItem> preflightResult = adoptPtr(new CrossOriginPreflightResultCacheItem(effectiveAllowCredentials())); 335 if (!preflightResult->parse(response, accessControlErrorDescription) 336 || !preflightResult->allowsCrossOriginMethod(m_actualRequest->httpMethod(), accessControlErrorDescription) 337 || !preflightResult->allowsCrossOriginHeaders(m_actualRequest->httpHeaderFields(), accessControlErrorDescription)) { 338 handlePreflightFailure(response.url().string(), accessControlErrorDescription); 339 return; 340 } 341 342 CrossOriginPreflightResultCache::shared().appendEntry(securityOrigin()->toString(), m_actualRequest->url(), preflightResult.release()); 343 } 344 345 void DocumentThreadableLoader::notifyResponseReceived(unsigned long identifier, const ResourceResponse& response) 346 { 347 DocumentLoader* loader = m_document.frame()->loader().documentLoader(); 348 TRACE_EVENT_INSTANT1(TRACE_DISABLED_BY_DEFAULT("devtools.timeline"), "ResourceReceiveResponse", "data", InspectorReceiveResponseEvent::data(identifier, m_document.frame(), response)); 349 LocalFrame* frame = m_document.frame(); 350 InspectorInstrumentation::didReceiveResourceResponse(frame, identifier, loader, response, resource() ? resource()->loader() : 0); 351 // It is essential that inspector gets resource response BEFORE console. 352 frame->console().reportResourceResponseReceived(loader, identifier, response); 353 } 354 355 void DocumentThreadableLoader::handleResponse(unsigned long identifier, const ResourceResponse& response) 356 { 357 ASSERT(m_client); 358 359 if (m_actualRequest) { 360 notifyResponseReceived(identifier, response); 361 handlePreflightResponse(response); 362 return; 363 } 364 365 // If the response is fetched via ServiceWorker, the original URL of the response could be different from the URL of the request. 366 bool isCrossOriginResponse = false; 367 if (response.wasFetchedViaServiceWorker()) { 368 if (!isAllowedByPolicy(response.url())) { 369 notifyResponseReceived(identifier, response); 370 m_client->didFailRedirectCheck(); 371 return; 372 } 373 isCrossOriginResponse = !securityOrigin()->canRequest(response.url()); 374 if (m_options.crossOriginRequestPolicy == DenyCrossOriginRequests && isCrossOriginResponse) { 375 notifyResponseReceived(identifier, response); 376 m_client->didFail(ResourceError(errorDomainBlinkInternal, 0, response.url().string(), "Cross origin requests are not supported.")); 377 return; 378 } 379 if (isCrossOriginResponse && m_resourceLoaderOptions.credentialsRequested == ClientDidNotRequestCredentials) { 380 // Since the request is no longer same-origin, if the user didn't request credentials in 381 // the first place, update our state so we neither request them nor expect they must be allowed. 382 m_forceDoNotAllowStoredCredentials = true; 383 } 384 } else { 385 isCrossOriginResponse = !m_sameOriginRequest; 386 } 387 if (isCrossOriginResponse && m_options.crossOriginRequestPolicy == UseAccessControl) { 388 String accessControlErrorDescription; 389 if (!passesAccessControlCheck(response, effectiveAllowCredentials(), securityOrigin(), accessControlErrorDescription)) { 390 notifyResponseReceived(identifier, response); 391 m_client->didFailAccessControlCheck(ResourceError(errorDomainBlinkInternal, 0, response.url().string(), accessControlErrorDescription)); 392 return; 393 } 394 } 395 396 m_client->didReceiveResponse(identifier, response); 397 } 398 399 void DocumentThreadableLoader::dataReceived(Resource* resource, const char* data, int dataLength) 400 { 401 ASSERT_UNUSED(resource, resource == this->resource()); 402 handleReceivedData(data, dataLength); 403 } 404 405 void DocumentThreadableLoader::handleReceivedData(const char* data, int dataLength) 406 { 407 ASSERT(m_client); 408 // Preflight data should be invisible to clients. 409 if (!m_actualRequest) 410 m_client->didReceiveData(data, dataLength); 411 } 412 413 void DocumentThreadableLoader::notifyFinished(Resource* resource) 414 { 415 ASSERT(m_client); 416 ASSERT(resource == this->resource()); 417 418 m_timeoutTimer.stop(); 419 420 if (resource->errorOccurred()) 421 m_client->didFail(resource->resourceError()); 422 else 423 handleSuccessfulFinish(resource->identifier(), resource->loadFinishTime()); 424 } 425 426 void DocumentThreadableLoader::handleSuccessfulFinish(unsigned long identifier, double finishTime) 427 { 428 if (m_actualRequest) { 429 ASSERT(!m_sameOriginRequest); 430 ASSERT(m_options.crossOriginRequestPolicy == UseAccessControl); 431 loadActualRequest(); 432 } else { 433 // FIXME: Should prevent timeout from being overridden after finished loading, without 434 // resetting m_requestStartedSeconds to 0.0 435 m_client->didFinishLoading(identifier, finishTime); 436 } 437 } 438 439 void DocumentThreadableLoader::didTimeout(Timer<DocumentThreadableLoader>* timer) 440 { 441 ASSERT_UNUSED(timer, timer == &m_timeoutTimer); 442 443 // Using values from net/base/net_error_list.h ERR_TIMED_OUT, 444 // Same as existing FIXME above - this error should be coming from FrameLoaderClient to be identifiable. 445 static const int timeoutError = -7; 446 ResourceError error("net", timeoutError, resource()->url(), String()); 447 error.setIsTimeout(true); 448 cancelWithError(error); 449 } 450 451 void DocumentThreadableLoader::loadActualRequest() 452 { 453 OwnPtr<ResourceRequest> actualRequest; 454 actualRequest.swap(m_actualRequest); 455 OwnPtr<ResourceLoaderOptions> actualOptions; 456 actualOptions.swap(m_actualOptions); 457 458 actualRequest->setHTTPOrigin(securityOrigin()->toAtomicString()); 459 460 clearResource(); 461 462 loadRequest(*actualRequest, *actualOptions); 463 } 464 465 void DocumentThreadableLoader::handlePreflightFailure(const String& url, const String& errorDescription) 466 { 467 ResourceError error(errorDomainBlinkInternal, 0, url, errorDescription); 468 469 // Prevent handleSuccessfulFinish() from bypassing access check. 470 m_actualRequest = nullptr; 471 472 // FIXME: Should prevent timeout from being overridden after preflight failure, without 473 // resetting m_requestStartedSeconds to 0.0 474 m_client->didFailAccessControlCheck(error); 475 } 476 477 void DocumentThreadableLoader::loadRequest(const ResourceRequest& request, ResourceLoaderOptions resourceLoaderOptions) 478 { 479 // Any credential should have been removed from the cross-site requests. 480 const KURL& requestURL = request.url(); 481 ASSERT(m_sameOriginRequest || requestURL.user().isEmpty()); 482 ASSERT(m_sameOriginRequest || requestURL.pass().isEmpty()); 483 484 // Update resourceLoaderOptions with enforced values. 485 if (m_forceDoNotAllowStoredCredentials) 486 resourceLoaderOptions.allowCredentials = DoNotAllowStoredCredentials; 487 resourceLoaderOptions.securityOrigin = m_securityOrigin; 488 if (m_async) { 489 if (m_actualRequest) 490 resourceLoaderOptions.dataBufferingPolicy = BufferData; 491 492 if (m_options.timeoutMilliseconds > 0) 493 m_timeoutTimer.startOneShot(m_options.timeoutMilliseconds / 1000.0, FROM_HERE); 494 495 FetchRequest newRequest(request, m_options.initiator, resourceLoaderOptions); 496 if (m_options.crossOriginRequestPolicy == AllowCrossOriginRequests) 497 newRequest.setOriginRestriction(FetchRequest::NoOriginRestriction); 498 ASSERT(!resource()); 499 if (request.requestContext() == blink::WebURLRequest::RequestContextVideo || request.requestContext() == blink::WebURLRequest::RequestContextAudio) 500 setResource(m_document.fetcher()->fetchMedia(newRequest)); 501 else 502 setResource(m_document.fetcher()->fetchRawResource(newRequest)); 503 if (resource() && resource()->loader()) { 504 unsigned long identifier = resource()->identifier(); 505 InspectorInstrumentation::documentThreadableLoaderStartedLoadingForClient(&m_document, identifier, m_client); 506 } 507 return; 508 } 509 510 FetchRequest fetchRequest(request, m_options.initiator, resourceLoaderOptions); 511 if (m_options.crossOriginRequestPolicy == AllowCrossOriginRequests) 512 fetchRequest.setOriginRestriction(FetchRequest::NoOriginRestriction); 513 ResourcePtr<Resource> resource = m_document.fetcher()->fetchSynchronously(fetchRequest); 514 ResourceResponse response = resource ? resource->response() : ResourceResponse(); 515 unsigned long identifier = resource ? resource->identifier() : std::numeric_limits<unsigned long>::max(); 516 ResourceError error = resource ? resource->resourceError() : ResourceError(); 517 518 InspectorInstrumentation::documentThreadableLoaderStartedLoadingForClient(&m_document, identifier, m_client); 519 520 if (!resource) { 521 m_client->didFail(error); 522 return; 523 } 524 525 // No exception for file:/// resources, see <rdar://problem/4962298>. 526 // Also, if we have an HTTP response, then it wasn't a network error in fact. 527 if (!error.isNull() && !requestURL.isLocalFile() && response.httpStatusCode() <= 0) { 528 m_client->didFail(error); 529 return; 530 } 531 532 // FIXME: A synchronous request does not tell us whether a redirect happened or not, so we guess by comparing the 533 // request and response URLs. This isn't a perfect test though, since a server can serve a redirect to the same URL that was 534 // requested. Also comparing the request and response URLs as strings will fail if the requestURL still has its credentials. 535 if (requestURL != response.url() && (!isAllowedByPolicy(response.url()) || !isAllowedRedirect(response.url()))) { 536 m_client->didFailRedirectCheck(); 537 return; 538 } 539 540 handleResponse(identifier, response); 541 542 SharedBuffer* data = resource->resourceBuffer(); 543 if (data) 544 handleReceivedData(data->data(), data->size()); 545 546 handleSuccessfulFinish(identifier, 0.0); 547 } 548 549 bool DocumentThreadableLoader::isAllowedRedirect(const KURL& url) const 550 { 551 if (m_options.crossOriginRequestPolicy == AllowCrossOriginRequests) 552 return true; 553 554 return m_sameOriginRequest && securityOrigin()->canRequest(url); 555 } 556 557 bool DocumentThreadableLoader::isAllowedByPolicy(const KURL& url) const 558 { 559 if (m_options.contentSecurityPolicyEnforcement != EnforceConnectSrcDirective) 560 return true; 561 return m_document.contentSecurityPolicy()->allowConnectToSource(url); 562 } 563 564 StoredCredentials DocumentThreadableLoader::effectiveAllowCredentials() const 565 { 566 if (m_forceDoNotAllowStoredCredentials) 567 return DoNotAllowStoredCredentials; 568 return m_resourceLoaderOptions.allowCredentials; 569 } 570 571 SecurityOrigin* DocumentThreadableLoader::securityOrigin() const 572 { 573 return m_securityOrigin ? m_securityOrigin.get() : m_document.securityOrigin(); 574 } 575 576 } // namespace blink 577
