db6b40283726c0ecf9369b53efd4b34de9cf3768
[WebKit-https.git] / Source / WebCore / xml / XMLHttpRequest.cpp
1 /*
2  *  Copyright (C) 2004-2016 Apple Inc. All rights reserved.
3  *  Copyright (C) 2005-2007 Alexey Proskuryakov <ap@webkit.org>
4  *  Copyright (C) 2007, 2008 Julien Chaffraix <jchaffraix@webkit.org>
5  *  Copyright (C) 2008, 2011 Google Inc. All rights reserved.
6  *  Copyright (C) 2012 Intel Corporation
7  *
8  *  This library is free software; you can redistribute it and/or
9  *  modify it under the terms of the GNU Lesser General Public
10  *  License as published by the Free Software Foundation; either
11  *  version 2 of the License, or (at your option) any later version.
12  *
13  *  This library is distributed in the hope that it will be useful,
14  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
15  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16  *  Lesser General Public License for more details.
17  *
18  *  You should have received a copy of the GNU Lesser General Public
19  *  License along with this library; if not, write to the Free Software
20  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
21  */
22
23 #include "config.h"
24 #include "XMLHttpRequest.h"
25
26 #include "Blob.h"
27 #include "CachedResourceRequestInitiators.h"
28 #include "ContentSecurityPolicy.h"
29 #include "CrossOriginAccessControl.h"
30 #include "DOMFormData.h"
31 #include "DOMWindow.h"
32 #include "Event.h"
33 #include "EventNames.h"
34 #include "File.h"
35 #include "HTMLDocument.h"
36 #include "HTTPHeaderNames.h"
37 #include "HTTPHeaderValues.h"
38 #include "HTTPParsers.h"
39 #include "InspectorInstrumentation.h"
40 #include "JSDOMBinding.h"
41 #include "JSDOMWindow.h"
42 #include "MIMETypeRegistry.h"
43 #include "MemoryCache.h"
44 #include "ParsedContentType.h"
45 #include "ResourceError.h"
46 #include "ResourceRequest.h"
47 #include "RuntimeApplicationChecks.h"
48 #include "SecurityOriginPolicy.h"
49 #include "Settings.h"
50 #include "SharedBuffer.h"
51 #include "StringAdaptors.h"
52 #include "TextResourceDecoder.h"
53 #include "ThreadableLoader.h"
54 #include "XMLDocument.h"
55 #include "XMLHttpRequestProgressEvent.h"
56 #include "XMLHttpRequestUpload.h"
57 #include "markup.h"
58 #include <JavaScriptCore/ArrayBuffer.h>
59 #include <JavaScriptCore/ArrayBufferView.h>
60 #include <JavaScriptCore/JSCInlines.h>
61 #include <JavaScriptCore/JSLock.h>
62 #include <wtf/RefCountedLeakCounter.h>
63 #include <wtf/StdLibExtras.h>
64 #include <wtf/text/CString.h>
65
66 namespace WebCore {
67
68 DEFINE_DEBUG_ONLY_GLOBAL(WTF::RefCountedLeakCounter, xmlHttpRequestCounter, ("XMLHttpRequest"));
69
70 // Histogram enum to see when we can deprecate xhr.send(ArrayBuffer).
71 enum XMLHttpRequestSendArrayBufferOrView {
72     XMLHttpRequestSendArrayBuffer,
73     XMLHttpRequestSendArrayBufferView,
74     XMLHttpRequestSendArrayBufferOrViewMax,
75 };
76
77 static void replaceCharsetInMediaType(String& mediaType, const String& charsetValue)
78 {
79     unsigned pos = 0, len = 0;
80
81     findCharsetInMediaType(mediaType, pos, len);
82
83     if (!len) {
84         // When no charset found, do nothing.
85         return;
86     }
87
88     // Found at least one existing charset, replace all occurrences with new charset.
89     while (len) {
90         mediaType.replace(pos, len, charsetValue);
91         unsigned start = pos + charsetValue.length();
92         findCharsetInMediaType(mediaType, pos, len, start);
93     }
94 }
95
96 static void logConsoleError(ScriptExecutionContext* context, const String& message)
97 {
98     if (!context)
99         return;
100     // FIXME: It's not good to report the bad usage without indicating what source line it came from.
101     // We should pass additional parameters so we can tell the console where the mistake occurred.
102     context->addConsoleMessage(MessageSource::JS, MessageLevel::Error, message);
103 }
104
105 Ref<XMLHttpRequest> XMLHttpRequest::create(ScriptExecutionContext& context)
106 {
107     auto xmlHttpRequest = adoptRef(*new XMLHttpRequest(context));
108     xmlHttpRequest->suspendIfNeeded();
109     return xmlHttpRequest;
110 }
111
112 XMLHttpRequest::XMLHttpRequest(ScriptExecutionContext& context)
113     : ActiveDOMObject(&context)
114     , m_progressEventThrottle(this)
115     , m_resumeTimer(*this, &XMLHttpRequest::resumeTimerFired)
116     , m_networkErrorTimer(*this, &XMLHttpRequest::networkErrorTimerFired)
117     , m_timeoutTimer(*this, &XMLHttpRequest::didReachTimeout)
118 {
119 #ifndef NDEBUG
120     xmlHttpRequestCounter.increment();
121 #endif
122 }
123
124 XMLHttpRequest::~XMLHttpRequest()
125 {
126 #ifndef NDEBUG
127     xmlHttpRequestCounter.decrement();
128 #endif
129 }
130
131 Document* XMLHttpRequest::document() const
132 {
133     ASSERT(scriptExecutionContext());
134     return downcast<Document>(scriptExecutionContext());
135 }
136
137 SecurityOrigin* XMLHttpRequest::securityOrigin() const
138 {
139     return scriptExecutionContext()->securityOrigin();
140 }
141
142 #if ENABLE(DASHBOARD_SUPPORT)
143
144 bool XMLHttpRequest::usesDashboardBackwardCompatibilityMode() const
145 {
146     if (scriptExecutionContext()->isWorkerGlobalScope())
147         return false;
148     return document()->settings().usesDashboardBackwardCompatibilityMode();
149 }
150
151 #endif
152
153 XMLHttpRequest::State XMLHttpRequest::readyState() const
154 {
155     return m_state;
156 }
157
158 ExceptionOr<OwnedString> XMLHttpRequest::responseText()
159 {
160     if (m_responseType != ResponseType::EmptyString && m_responseType != ResponseType::Text)
161         return Exception { InvalidStateError };
162     return OwnedString { responseTextIgnoringResponseType() };
163 }
164
165 void XMLHttpRequest::didCacheResponse()
166 {
167     ASSERT(doneWithoutErrors());
168     m_responseCacheIsValid = true;
169     m_responseBuilder.clear();
170 }
171
172 ExceptionOr<Document*> XMLHttpRequest::responseXML()
173 {
174     ASSERT(scriptExecutionContext()->isDocument());
175     
176     if (m_responseType != ResponseType::EmptyString && m_responseType != ResponseType::Document)
177         return Exception { InvalidStateError };
178
179     if (!doneWithoutErrors())
180         return nullptr;
181
182     if (!m_createdDocument) {
183         String mimeType = responseMIMEType();
184         bool isHTML = equalLettersIgnoringASCIICase(mimeType, "text/html");
185
186         // The W3C spec requires the final MIME type to be some valid XML type, or text/html.
187         // If it is text/html, then the responseType of "document" must have been supplied explicitly.
188         if ((m_response.isHTTP() && !responseIsXML() && !isHTML)
189             || (isHTML && m_responseType == ResponseType::EmptyString)) {
190             m_responseDocument = nullptr;
191         } else {
192             if (isHTML)
193                 m_responseDocument = HTMLDocument::create(0, m_url);
194             else
195                 m_responseDocument = XMLDocument::create(0, m_url);
196             // FIXME: Set Last-Modified.
197             m_responseDocument->setContent(m_responseBuilder.toStringPreserveCapacity());
198             m_responseDocument->setContextDocument(downcast<Document>(*scriptExecutionContext()));
199             m_responseDocument->setSecurityOriginPolicy(scriptExecutionContext()->securityOriginPolicy());
200             m_responseDocument->overrideMIMEType(mimeType);
201
202             if (!m_responseDocument->wellFormed())
203                 m_responseDocument = nullptr;
204         }
205         m_createdDocument = true;
206     }
207
208     return m_responseDocument.get();
209 }
210
211 Ref<Blob> XMLHttpRequest::createResponseBlob()
212 {
213     ASSERT(m_responseType == ResponseType::Blob);
214     ASSERT(doneWithoutErrors());
215
216     if (!m_binaryResponseBuilder)
217         return Blob::create();
218
219     // FIXME: We just received the data from NetworkProcess, and are sending it back. This is inefficient.
220     Vector<uint8_t> data;
221     data.append(m_binaryResponseBuilder->data(), m_binaryResponseBuilder->size());
222     m_binaryResponseBuilder = nullptr;
223     String normalizedContentType = Blob::normalizedContentType(responseMIMEType()); // responseMIMEType defaults to text/xml which may be incorrect.
224     return Blob::create(WTFMove(data), normalizedContentType);
225 }
226
227 RefPtr<ArrayBuffer> XMLHttpRequest::createResponseArrayBuffer()
228 {
229     ASSERT(m_responseType == ResponseType::Arraybuffer);
230     ASSERT(doneWithoutErrors());
231
232     auto result = m_binaryResponseBuilder ? m_binaryResponseBuilder->tryCreateArrayBuffer() : ArrayBuffer::create(nullptr, 0);
233     m_binaryResponseBuilder = nullptr;
234     return result;
235 }
236
237 ExceptionOr<void> XMLHttpRequest::setTimeout(unsigned timeout)
238 {
239     if (scriptExecutionContext()->isDocument() && !m_async) {
240         logConsoleError(scriptExecutionContext(), "XMLHttpRequest.timeout cannot be set for synchronous HTTP(S) requests made from the window context.");
241         return Exception { InvalidAccessError };
242     }
243     m_timeoutMilliseconds = timeout;
244     if (!m_timeoutTimer.isActive())
245         return { };
246
247     // If timeout is zero, we should use the default network timeout. But we disabled it so let's mimic it with a 60 seconds timeout value.
248     Seconds interval = Seconds { m_timeoutMilliseconds ? m_timeoutMilliseconds / 1000. : 60. } - (MonotonicTime::now() - m_sendingTime);
249     m_timeoutTimer.startOneShot(std::max(interval, 0_s));
250     return { };
251 }
252
253 ExceptionOr<void> XMLHttpRequest::setResponseType(ResponseType type)
254 {
255     if (!scriptExecutionContext()->isDocument() && type == ResponseType::Document)
256         return { };
257
258     if (m_state >= LOADING)
259         return Exception { InvalidStateError };
260
261     // Newer functionality is not available to synchronous requests in window contexts, as a spec-mandated
262     // attempt to discourage synchronous XHR use. responseType is one such piece of functionality.
263     // We'll only disable this functionality for HTTP(S) requests since sync requests for local protocols
264     // such as file: and data: still make sense to allow.
265     if (!m_async && scriptExecutionContext()->isDocument() && m_url.protocolIsInHTTPFamily()) {
266         logConsoleError(scriptExecutionContext(), "XMLHttpRequest.responseType cannot be changed for synchronous HTTP(S) requests made from the window context.");
267         return Exception { InvalidAccessError };
268     }
269
270     m_responseType = type;
271     return { };
272 }
273
274 String XMLHttpRequest::responseURL() const
275 {
276     URL responseURL(m_response.url());
277     responseURL.removeFragmentIdentifier();
278
279     return responseURL.string();
280 }
281
282 XMLHttpRequestUpload& XMLHttpRequest::upload()
283 {
284     if (!m_upload)
285         m_upload = std::make_unique<XMLHttpRequestUpload>(*this);
286     return *m_upload;
287 }
288
289 void XMLHttpRequest::changeState(State newState)
290 {
291     if (m_state != newState) {
292         m_state = newState;
293         callReadyStateChangeListener();
294     }
295 }
296
297 void XMLHttpRequest::callReadyStateChangeListener()
298 {
299     if (!scriptExecutionContext())
300         return;
301
302     // Check whether sending load and loadend events before sending readystatechange event, as it may change m_error/m_state values.
303     bool shouldSendLoadEvent = (m_state == DONE && !m_error);
304
305     if (m_async || (m_state <= OPENED || m_state == DONE))
306         m_progressEventThrottle.dispatchReadyStateChangeEvent(Event::create(eventNames().readystatechangeEvent, false, false), m_state == DONE ? FlushProgressEvent : DoNotFlushProgressEvent);
307
308     if (shouldSendLoadEvent) {
309         m_progressEventThrottle.dispatchProgressEvent(eventNames().loadEvent);
310         m_progressEventThrottle.dispatchProgressEvent(eventNames().loadendEvent);
311     }
312 }
313
314 ExceptionOr<void> XMLHttpRequest::setWithCredentials(bool value)
315 {
316     if (m_state > OPENED || m_sendFlag)
317         return Exception { InvalidStateError };
318
319     m_includeCredentials = value;
320     return { };
321 }
322
323 ExceptionOr<void> XMLHttpRequest::open(const String& method, const String& url)
324 {
325     // If the async argument is omitted, set async to true.
326     return open(method, scriptExecutionContext()->completeURL(url), true);
327 }
328
329 ExceptionOr<void> XMLHttpRequest::open(const String& method, const URL& url, bool async)
330 {
331     if (!isValidHTTPToken(method))
332         return Exception { SyntaxError };
333
334     if (isForbiddenMethod(method))
335         return Exception { SecurityError };
336
337     if (!async && scriptExecutionContext()->isDocument()) {
338         // Newer functionality is not available to synchronous requests in window contexts, as a spec-mandated
339         // attempt to discourage synchronous XHR use. responseType is one such piece of functionality.
340         // We'll only disable this functionality for HTTP(S) requests since sync requests for local protocols
341         // such as file: and data: still make sense to allow.
342         if (url.protocolIsInHTTPFamily() && m_responseType != ResponseType::EmptyString) {
343             logConsoleError(scriptExecutionContext(), "Synchronous HTTP(S) requests made from the window context cannot have XMLHttpRequest.responseType set.");
344             return Exception { InvalidAccessError };
345         }
346
347         // Similarly, timeouts are disabled for synchronous requests as well.
348         if (m_timeoutMilliseconds > 0) {
349             logConsoleError(scriptExecutionContext(), "Synchronous XMLHttpRequests must not have a timeout value set.");
350             return Exception { InvalidAccessError };
351         }
352     }
353
354     if (!internalAbort())
355         return { };
356
357     m_sendFlag = false;
358     m_uploadListenerFlag = false;
359     m_method = normalizeHTTPMethod(method);
360     m_error = false;
361     m_uploadComplete = false;
362     m_wasAbortedByClient = false;
363
364     // clear stuff from possible previous load
365     clearResponse();
366     clearRequest();
367
368     m_url = url;
369     scriptExecutionContext()->contentSecurityPolicy()->upgradeInsecureRequestIfNeeded(m_url, ContentSecurityPolicy::InsecureRequestType::Load);
370
371     m_async = async;
372
373     ASSERT(!m_loader);
374
375     changeState(OPENED);
376
377     return { };
378 }
379
380 ExceptionOr<void> XMLHttpRequest::open(const String& method, const String& url, bool async, const String& user, const String& password)
381 {
382     URL urlWithCredentials = scriptExecutionContext()->completeURL(url);
383     if (!user.isNull()) {
384         urlWithCredentials.setUser(user);
385         if (!password.isNull())
386             urlWithCredentials.setPass(password);
387     }
388
389     return open(method, urlWithCredentials, async);
390 }
391
392 std::optional<ExceptionOr<void>> XMLHttpRequest::prepareToSend()
393 {
394     // A return value other than std::nullopt means we should not try to send, and we should return that value to the caller.
395     // std::nullopt means we are ready to send and should continue with the send algorithm.
396
397     if (!scriptExecutionContext())
398         return ExceptionOr<void> { };
399
400     auto& context = *scriptExecutionContext();
401
402     if (m_state != OPENED || m_sendFlag)
403         return ExceptionOr<void> { Exception { InvalidStateError } };
404     ASSERT(!m_loader);
405
406     // FIXME: Convert this to check the isolated world's Content Security Policy once webkit.org/b/104520 is solved.
407     if (!context.shouldBypassMainWorldContentSecurityPolicy() && !context.contentSecurityPolicy()->allowConnectToSource(m_url)) {
408         if (!m_async)
409             return ExceptionOr<void> { Exception { NetworkError } };
410         setPendingActivity(this);
411         m_timeoutTimer.stop();
412         m_networkErrorTimer.startOneShot(0_s);
413         return ExceptionOr<void> { };
414     }
415
416     m_error = false;
417     return std::nullopt;
418 }
419
420 ExceptionOr<void> XMLHttpRequest::send(std::optional<SendTypes>&& sendType)
421 {
422     InspectorInstrumentation::willSendXMLHttpRequest(scriptExecutionContext(), url());
423
424     ExceptionOr<void> result;
425     if (!sendType)
426         result = send();
427     else {
428         result = WTF::switchOn(sendType.value(),
429             [this] (const RefPtr<Document>& document) -> ExceptionOr<void> { return send(*document); },
430             [this] (const RefPtr<Blob>& blob) -> ExceptionOr<void> { return send(*blob); },
431             [this] (const RefPtr<JSC::ArrayBufferView>& arrayBufferView) -> ExceptionOr<void> { return send(*arrayBufferView); },
432             [this] (const RefPtr<JSC::ArrayBuffer>& arrayBuffer) -> ExceptionOr<void> { return send(*arrayBuffer); },
433             [this] (const RefPtr<DOMFormData>& formData) -> ExceptionOr<void> { return send(*formData); },
434             [this] (const String& string) -> ExceptionOr<void> { return send(string); }
435         );
436     }
437
438     return result;
439 }
440
441 ExceptionOr<void> XMLHttpRequest::send(Document& document)
442 {
443     if (auto result = prepareToSend())
444         return WTFMove(result.value());
445
446     if (m_method != "GET" && m_method != "HEAD" && m_url.protocolIsInHTTPFamily()) {
447         if (!m_requestHeaders.contains(HTTPHeaderName::ContentType)) {
448 #if ENABLE(DASHBOARD_SUPPORT)
449             if (usesDashboardBackwardCompatibilityMode())
450                 m_requestHeaders.set(HTTPHeaderName::ContentType, "application/x-www-form-urlencoded"_s);
451             else
452 #endif
453                 // FIXME: this should include the charset used for encoding.
454                 m_requestHeaders.set(HTTPHeaderName::ContentType, document.isHTMLDocument() ? "text/html;charset=UTF-8"_s : "application/xml;charset=UTF-8"_s);
455         }
456
457         // FIXME: According to XMLHttpRequest Level 2, this should use the Document.innerHTML algorithm
458         // from the HTML5 specification to serialize the document.
459         m_requestEntityBody = FormData::create(UTF8Encoding().encode(createMarkup(document), UnencodableHandling::Entities));
460         if (m_upload)
461             m_requestEntityBody->setAlwaysStream(true);
462     }
463
464     return createRequest();
465 }
466
467 ExceptionOr<void> XMLHttpRequest::send(const String& body)
468 {
469     if (auto result = prepareToSend())
470         return WTFMove(result.value());
471
472     if (!body.isNull() && m_method != "GET" && m_method != "HEAD" && m_url.protocolIsInHTTPFamily()) {
473         String contentType = m_requestHeaders.get(HTTPHeaderName::ContentType);
474         if (contentType.isNull()) {
475 #if ENABLE(DASHBOARD_SUPPORT)
476             if (usesDashboardBackwardCompatibilityMode())
477                 m_requestHeaders.set(HTTPHeaderName::ContentType, "application/x-www-form-urlencoded"_s);
478             else
479 #endif
480                 m_requestHeaders.set(HTTPHeaderName::ContentType, HTTPHeaderValues::textPlainContentType());
481         } else {
482             replaceCharsetInMediaType(contentType, "UTF-8");
483             m_requestHeaders.set(HTTPHeaderName::ContentType, contentType);
484         }
485
486         m_requestEntityBody = FormData::create(UTF8Encoding().encode(body, UnencodableHandling::Entities));
487         if (m_upload)
488             m_requestEntityBody->setAlwaysStream(true);
489     }
490
491     return createRequest();
492 }
493
494 ExceptionOr<void> XMLHttpRequest::send(Blob& body)
495 {
496     if (auto result = prepareToSend())
497         return WTFMove(result.value());
498
499     if (m_method != "GET" && m_method != "HEAD" && m_url.protocolIsInHTTPFamily()) {
500         if (!m_requestHeaders.contains(HTTPHeaderName::ContentType)) {
501             const String& blobType = body.type();
502             if (!blobType.isEmpty() && isValidContentType(blobType))
503                 m_requestHeaders.set(HTTPHeaderName::ContentType, blobType);
504             else {
505                 // From FileAPI spec, whenever media type cannot be determined, empty string must be returned.
506                 m_requestHeaders.set(HTTPHeaderName::ContentType, emptyString());
507             }
508         }
509
510         m_requestEntityBody = FormData::create();
511         m_requestEntityBody->appendBlob(body.url());
512     }
513
514     return createRequest();
515 }
516
517 ExceptionOr<void> XMLHttpRequest::send(DOMFormData& body)
518 {
519     if (auto result = prepareToSend())
520         return WTFMove(result.value());
521
522     if (m_method != "GET" && m_method != "HEAD" && m_url.protocolIsInHTTPFamily()) {
523         m_requestEntityBody = FormData::createMultiPart(body, document());
524         m_requestEntityBody->generateFiles(document());
525         if (!m_requestHeaders.contains(HTTPHeaderName::ContentType))
526             m_requestHeaders.set(HTTPHeaderName::ContentType, makeString("multipart/form-data; boundary=", m_requestEntityBody->boundary().data()));
527     }
528
529     return createRequest();
530 }
531
532 ExceptionOr<void> XMLHttpRequest::send(ArrayBuffer& body)
533 {
534     ASCIILiteral consoleMessage { "ArrayBuffer is deprecated in XMLHttpRequest.send(). Use ArrayBufferView instead."_s };
535     scriptExecutionContext()->addConsoleMessage(MessageSource::JS, MessageLevel::Warning, consoleMessage);
536     return sendBytesData(body.data(), body.byteLength());
537 }
538
539 ExceptionOr<void> XMLHttpRequest::send(ArrayBufferView& body)
540 {
541     return sendBytesData(body.baseAddress(), body.byteLength());
542 }
543
544 ExceptionOr<void> XMLHttpRequest::sendBytesData(const void* data, size_t length)
545 {
546     if (auto result = prepareToSend())
547         return WTFMove(result.value());
548
549     if (m_method != "GET" && m_method != "HEAD" && m_url.protocolIsInHTTPFamily()) {
550         m_requestEntityBody = FormData::create(data, length);
551         if (m_upload)
552             m_requestEntityBody->setAlwaysStream(true);
553     }
554
555     return createRequest();
556 }
557
558 ExceptionOr<void> XMLHttpRequest::createRequest()
559 {
560     // Only GET request is supported for blob URL.
561     if (!m_async && m_url.protocolIsBlob() && m_method != "GET")
562         return Exception { NetworkError };
563
564     if (m_async && m_upload && m_upload->hasEventListeners())
565         m_uploadListenerFlag = true;
566
567     ResourceRequest request(m_url);
568     request.setRequester(ResourceRequest::Requester::XHR);
569     request.setInitiatorIdentifier(scriptExecutionContext()->resourceRequestIdentifier());
570     request.setHTTPMethod(m_method);
571
572     if (m_requestEntityBody) {
573         ASSERT(m_method != "GET");
574         ASSERT(m_method != "HEAD");
575         request.setHTTPBody(WTFMove(m_requestEntityBody));
576     }
577
578     if (!m_requestHeaders.isEmpty())
579         request.setHTTPHeaderFields(m_requestHeaders);
580
581     ThreadableLoaderOptions options;
582     options.sendLoadCallbacks = SendCallbacks;
583     // The presence of upload event listeners forces us to use preflighting because POSTing to an URL that does not
584     // permit cross origin requests should look exactly like POSTing to an URL that does not respond at all.
585     options.preflightPolicy = m_uploadListenerFlag ? PreflightPolicy::Force : PreflightPolicy::Consider;
586     options.credentials = m_includeCredentials ? FetchOptions::Credentials::Include : FetchOptions::Credentials::SameOrigin;
587     options.mode = FetchOptions::Mode::Cors;
588     options.contentSecurityPolicyEnforcement = scriptExecutionContext()->shouldBypassMainWorldContentSecurityPolicy() ? ContentSecurityPolicyEnforcement::DoNotEnforce : ContentSecurityPolicyEnforcement::EnforceConnectSrcDirective;
589     options.initiator = cachedResourceRequestInitiators().xmlhttprequest;
590     options.sameOriginDataURLFlag = SameOriginDataURLFlag::Set;
591     options.filteringPolicy = ResponseFilteringPolicy::Enable;
592     options.sniffContentEncoding = ContentEncodingSniffingPolicy::DoNotSniff;
593
594     if (m_timeoutMilliseconds) {
595         if (!m_async)
596             request.setTimeoutInterval(m_timeoutMilliseconds / 1000.0);
597         else {
598             request.setTimeoutInterval(std::numeric_limits<double>::infinity());
599             m_sendingTime = MonotonicTime::now();
600             m_timeoutTimer.startOneShot(1_ms * m_timeoutMilliseconds);
601         }
602     }
603
604     m_exceptionCode = std::nullopt;
605     m_error = false;
606     m_uploadComplete = !request.httpBody();
607     m_sendFlag = true;
608
609     if (m_async) {
610         m_progressEventThrottle.dispatchProgressEvent(eventNames().loadstartEvent);
611         if (!m_uploadComplete && m_uploadListenerFlag)
612             m_upload->dispatchProgressEvent(eventNames().loadstartEvent);
613
614         if (m_state != OPENED || !m_sendFlag || m_loader)
615             return { };
616
617         // ThreadableLoader::create can return null here, for example if we're no longer attached to a page or if a content blocker blocks the load.
618         // This is true while running onunload handlers.
619         // FIXME: Maybe we need to be able to send XMLHttpRequests from onunload, <http://bugs.webkit.org/show_bug.cgi?id=10904>.
620         m_loader = ThreadableLoader::create(*scriptExecutionContext(), *this, WTFMove(request), options);
621
622         // Either loader is null or some error was synchronously sent to us.
623         ASSERT(m_loader || !m_sendFlag);
624
625         // Neither this object nor the JavaScript wrapper should be deleted while
626         // a request is in progress because we need to keep the listeners alive,
627         // and they are referenced by the JavaScript wrapper.
628         if (m_loader)
629             setPendingActivity(this);
630     } else {
631         request.setDomainForCachePartition(scriptExecutionContext()->domainForCachePartition());
632         InspectorInstrumentation::willLoadXHRSynchronously(scriptExecutionContext());
633         ThreadableLoader::loadResourceSynchronously(*scriptExecutionContext(), WTFMove(request), *this, options);
634         InspectorInstrumentation::didLoadXHRSynchronously(scriptExecutionContext());
635     }
636
637     if (m_exceptionCode)
638         return Exception { m_exceptionCode.value() };
639     if (m_error)
640         return Exception { NetworkError };
641     return { };
642 }
643
644 void XMLHttpRequest::abort()
645 {
646     // internalAbort() calls dropProtection(), which may release the last reference.
647     Ref<XMLHttpRequest> protectedThis(*this);
648
649     m_wasAbortedByClient = true;
650     if (!internalAbort())
651         return;
652
653     clearResponseBuffers();
654
655     m_requestHeaders.clear();
656     if ((m_state == OPENED && m_sendFlag) || m_state == HEADERS_RECEIVED || m_state == LOADING) {
657         ASSERT(!m_loader);
658         m_sendFlag = false;
659         changeState(DONE);
660         dispatchErrorEvents(eventNames().abortEvent);
661     }
662     if (m_state == DONE)
663         m_state = UNSENT;
664 }
665
666 bool XMLHttpRequest::internalAbort()
667 {
668     m_error = true;
669
670     // FIXME: when we add the support for multi-part XHR, we will have to think be careful with this initialization.
671     m_receivedLength = 0;
672
673     m_decoder = nullptr;
674
675     m_timeoutTimer.stop();
676
677     if (!m_loader)
678         return true;
679
680     // Cancelling m_loader may trigger a window.onload callback which can call open() on the same xhr.
681     // This would create internalAbort reentrant call.
682     // m_loader is set to null before being cancelled to exit early in any reentrant internalAbort() call.
683     auto loader = WTFMove(m_loader);
684     loader->cancel();
685
686     // If window.onload callback calls open() and send() on the same xhr, m_loader is now set to a new value.
687     // The function calling internalAbort() should abort to let the open() and send() calls continue properly.
688     // We ask the function calling internalAbort() to exit by returning false.
689     // Save this information to a local variable since we are going to drop protection.
690     bool newLoadStarted = m_loader;
691
692     dropProtection();
693
694     return !newLoadStarted;
695 }
696
697 void XMLHttpRequest::clearResponse()
698 {
699     m_response = ResourceResponse();
700     clearResponseBuffers();
701 }
702
703 void XMLHttpRequest::clearResponseBuffers()
704 {
705     m_responseBuilder.clear();
706     m_responseEncoding = String();
707     m_createdDocument = false;
708     m_responseDocument = nullptr;
709     m_binaryResponseBuilder = nullptr;
710     m_responseCacheIsValid = false;
711 }
712
713 void XMLHttpRequest::clearRequest()
714 {
715     m_requestHeaders.clear();
716     m_requestEntityBody = nullptr;
717 }
718
719 void XMLHttpRequest::genericError()
720 {
721     clearResponse();
722     clearRequest();
723     m_sendFlag = false;
724     m_error = true;
725
726     changeState(DONE);
727 }
728
729 void XMLHttpRequest::networkError()
730 {
731     genericError();
732     dispatchErrorEvents(eventNames().errorEvent);
733     internalAbort();
734 }
735
736 void XMLHttpRequest::networkErrorTimerFired()
737 {
738     networkError();
739     dropProtection();
740 }
741     
742 void XMLHttpRequest::abortError()
743 {
744     ASSERT(m_wasAbortedByClient);
745     genericError();
746     dispatchErrorEvents(eventNames().abortEvent);
747 }
748
749 void XMLHttpRequest::dropProtection()
750 {
751     // The XHR object itself holds on to the responseText, and
752     // thus has extra cost even independent of any
753     // responseText or responseXML objects it has handed
754     // out. But it is protected from GC while loading, so this
755     // can't be recouped until the load is done, so only
756     // report the extra cost at that point.
757     JSC::VM& vm = scriptExecutionContext()->vm();
758     JSC::JSLockHolder lock(vm);
759     // FIXME: Adopt reportExtraMemoryVisited, and switch to reportExtraMemoryAllocated.
760     // https://bugs.webkit.org/show_bug.cgi?id=142595
761     vm.heap.deprecatedReportExtraMemory(m_responseBuilder.length() * 2);
762
763     unsetPendingActivity(this);
764 }
765
766 ExceptionOr<void> XMLHttpRequest::overrideMimeType(const String& override)
767 {
768     if (m_state == LOADING || m_state == DONE)
769         return Exception { InvalidStateError };
770
771     m_mimeTypeOverride = override;
772     return { };
773 }
774
775 ExceptionOr<void> XMLHttpRequest::setRequestHeader(const String& name, const String& value)
776 {
777     if (m_state != OPENED || m_sendFlag) {
778 #if ENABLE(DASHBOARD_SUPPORT)
779         if (usesDashboardBackwardCompatibilityMode())
780             return { };
781 #endif
782         return Exception { InvalidStateError };
783     }
784
785     String normalizedValue = stripLeadingAndTrailingHTTPSpaces(value);
786     if (!isValidHTTPToken(name) || !isValidHTTPHeaderValue(normalizedValue))
787         return Exception { SyntaxError };
788
789     bool allowUnsafeHeaderField = false;
790 #if ENABLE(DASHBOARD_SUPPORT)
791     allowUnsafeHeaderField = usesDashboardBackwardCompatibilityMode();
792 #endif
793     if (securityOrigin()->canLoadLocalResources() && document()->settings().allowSettingAnyXHRHeaderFromFileURLs())
794         allowUnsafeHeaderField = true;
795     if (!allowUnsafeHeaderField && isForbiddenHeaderName(name)) {
796         logConsoleError(scriptExecutionContext(), "Refused to set unsafe header \"" + name + "\"");
797         return { };
798     }
799
800     m_requestHeaders.add(name, normalizedValue);
801     return { };
802 }
803
804 String XMLHttpRequest::getAllResponseHeaders() const
805 {
806     if (m_state < HEADERS_RECEIVED || m_error)
807         return emptyString();
808
809     if (!m_allResponseHeaders) {
810         Vector<String> headers;
811         headers.reserveInitialCapacity(m_response.httpHeaderFields().size());
812
813         for (auto& header : m_response.httpHeaderFields()) {
814             StringBuilder stringBuilder;
815             stringBuilder.append(header.key.convertToASCIILowercase());
816             stringBuilder.appendLiteral(": ");
817             stringBuilder.append(header.value);
818             stringBuilder.appendLiteral("\r\n");
819             headers.uncheckedAppend(stringBuilder.toString());
820         }
821         std::sort(headers.begin(), headers.end(), WTF::codePointCompareLessThan);
822
823         StringBuilder stringBuilder;
824         for (auto& header : headers)
825             stringBuilder.append(header);
826         m_allResponseHeaders = stringBuilder.toString();
827     }
828
829     return m_allResponseHeaders;
830 }
831
832 String XMLHttpRequest::getResponseHeader(const String& name) const
833 {
834     if (m_state < HEADERS_RECEIVED || m_error)
835         return String();
836
837     return m_response.httpHeaderField(name);
838 }
839
840 String XMLHttpRequest::responseMIMEType() const
841 {
842     String mimeType = extractMIMETypeFromMediaType(m_mimeTypeOverride);
843     if (mimeType.isEmpty()) {
844         if (m_response.isHTTP())
845             mimeType = extractMIMETypeFromMediaType(m_response.httpHeaderField(HTTPHeaderName::ContentType));
846         else
847             mimeType = m_response.mimeType();
848         if (mimeType.isEmpty())
849             mimeType = "text/xml"_s;
850     }
851     return mimeType;
852 }
853
854 bool XMLHttpRequest::responseIsXML() const
855 {
856     return MIMETypeRegistry::isXMLMIMEType(responseMIMEType());
857 }
858
859 int XMLHttpRequest::status() const
860 {
861     if (m_state == UNSENT || m_state == OPENED || m_error)
862         return 0;
863
864     return m_response.httpStatusCode();
865 }
866
867 String XMLHttpRequest::statusText() const
868 {
869     if (m_state == UNSENT || m_state == OPENED || m_error)
870         return String();
871
872     return m_response.httpStatusText();
873 }
874
875 void XMLHttpRequest::didFail(const ResourceError& error)
876 {
877     // If we are already in an error state, for instance we called abort(), bail out early.
878     if (m_error)
879         return;
880
881     // The XHR specification says we should only fire an abort event if the cancelation was requested by the client.
882     if (m_wasAbortedByClient && error.isCancellation()) {
883         m_exceptionCode = AbortError;
884         abortError();
885         return;
886     }
887
888     // In case of worker sync timeouts.
889     if (error.isTimeout()) {
890         didReachTimeout();
891         return;
892     }
893
894     // In case didFail is called synchronously on an asynchronous XHR call, let's dispatch network error asynchronously
895     if (m_async && m_sendFlag && !m_loader) {
896         m_sendFlag = false;
897         setPendingActivity(this);
898         m_timeoutTimer.stop();
899         m_networkErrorTimer.startOneShot(0_s);
900         return;
901     }
902     m_exceptionCode = NetworkError;
903     networkError();
904 }
905
906 void XMLHttpRequest::didFinishLoading(unsigned long)
907 {
908     if (m_error)
909         return;
910
911     if (m_state < HEADERS_RECEIVED)
912         changeState(HEADERS_RECEIVED);
913
914     if (m_decoder)
915         m_responseBuilder.append(m_decoder->flush());
916
917     m_responseBuilder.shrinkToFit();
918
919     bool hadLoader = m_loader;
920     m_loader = nullptr;
921
922     m_sendFlag = false;
923     changeState(DONE);
924     m_responseEncoding = String();
925     m_decoder = nullptr;
926
927     m_timeoutTimer.stop();
928
929     if (hadLoader)
930         dropProtection();
931 }
932
933 void XMLHttpRequest::didSendData(unsigned long long bytesSent, unsigned long long totalBytesToBeSent)
934 {
935     if (!m_upload)
936         return;
937
938     if (m_uploadListenerFlag)
939         m_upload->dispatchThrottledProgressEvent(true, bytesSent, totalBytesToBeSent);
940
941     if (bytesSent == totalBytesToBeSent && !m_uploadComplete) {
942         m_uploadComplete = true;
943         if (m_uploadListenerFlag) {
944             m_upload->dispatchProgressEvent(eventNames().loadEvent);
945             m_upload->dispatchProgressEvent(eventNames().loadendEvent);
946         }
947     }
948 }
949
950 void XMLHttpRequest::didReceiveResponse(unsigned long, const ResourceResponse& response)
951 {
952     m_response = response;
953     if (!m_mimeTypeOverride.isEmpty())
954         m_response.setHTTPHeaderField(HTTPHeaderName::ContentType, m_mimeTypeOverride);
955 }
956
957 static inline bool shouldDecodeResponse(XMLHttpRequest::ResponseType type)
958 {
959     switch (type) {
960     case XMLHttpRequest::ResponseType::EmptyString:
961     case XMLHttpRequest::ResponseType::Document:
962     case XMLHttpRequest::ResponseType::Json:
963     case XMLHttpRequest::ResponseType::Text:
964         return true;
965     case XMLHttpRequest::ResponseType::Arraybuffer:
966     case XMLHttpRequest::ResponseType::Blob:
967         return false;
968     }
969     ASSERT_NOT_REACHED();
970     return true;
971 }
972
973 Ref<TextResourceDecoder> XMLHttpRequest::createDecoder() const
974 {
975     if (!m_responseEncoding.isEmpty())
976         return TextResourceDecoder::create("text/plain", m_responseEncoding);
977
978     switch (m_responseType) {
979     case ResponseType::EmptyString:
980         if (responseIsXML()) {
981             auto decoder = TextResourceDecoder::create("application/xml");
982             // Don't stop on encoding errors, unlike it is done for other kinds of XML resources. This matches the behavior of previous WebKit versions, Firefox and Opera.
983             decoder->useLenientXMLDecoding();
984             return decoder;
985         }
986         FALLTHROUGH;
987     case ResponseType::Text:
988     case ResponseType::Json:
989         return TextResourceDecoder::create("text/plain", "UTF-8");
990     case ResponseType::Document: {
991         if (equalLettersIgnoringASCIICase(responseMIMEType(), "text/html"))
992             return TextResourceDecoder::create("text/html", "UTF-8");
993         auto decoder = TextResourceDecoder::create("application/xml");
994         // Don't stop on encoding errors, unlike it is done for other kinds of XML resources. This matches the behavior of previous WebKit versions, Firefox and Opera.
995         decoder->useLenientXMLDecoding();
996         return decoder;
997     }
998     case ResponseType::Arraybuffer:
999     case ResponseType::Blob:
1000         ASSERT_NOT_REACHED();
1001         break;
1002     }
1003     return TextResourceDecoder::create("text/plain", "UTF-8");
1004 }
1005
1006 void XMLHttpRequest::didReceiveData(const char* data, int len)
1007 {
1008     if (m_error)
1009         return;
1010
1011     if (m_state < HEADERS_RECEIVED)
1012         changeState(HEADERS_RECEIVED);
1013
1014     // FIXME: Should we update "Content-Type" header field with m_mimeTypeOverride value in case it has changed since didReceiveResponse?
1015     if (!m_mimeTypeOverride.isEmpty())
1016         m_responseEncoding = extractCharsetFromMediaType(m_mimeTypeOverride);
1017     if (m_responseEncoding.isEmpty())
1018         m_responseEncoding = m_response.textEncodingName();
1019
1020     bool useDecoder = shouldDecodeResponse(m_responseType);
1021
1022     if (useDecoder && !m_decoder)
1023         m_decoder = createDecoder();
1024
1025     if (!len)
1026         return;
1027
1028     if (len == -1)
1029         len = strlen(data);
1030
1031     if (useDecoder)
1032         m_responseBuilder.append(m_decoder->decode(data, len));
1033     else {
1034         // Buffer binary data.
1035         if (!m_binaryResponseBuilder)
1036             m_binaryResponseBuilder = SharedBuffer::create();
1037         m_binaryResponseBuilder->append(data, len);
1038     }
1039
1040     if (!m_error) {
1041         m_receivedLength += len;
1042
1043         if (m_async) {
1044             long long expectedLength = m_response.expectedContentLength();
1045             bool lengthComputable = expectedLength > 0 && m_receivedLength <= expectedLength;
1046             unsigned long long total = lengthComputable ? expectedLength : 0;
1047             m_progressEventThrottle.dispatchThrottledProgressEvent(lengthComputable, m_receivedLength, total);
1048         }
1049
1050         if (m_state != LOADING)
1051             changeState(LOADING);
1052         else
1053             // Firefox calls readyStateChanged every time it receives data, 4449442
1054             callReadyStateChangeListener();
1055     }
1056 }
1057
1058 void XMLHttpRequest::dispatchErrorEvents(const AtomicString& type)
1059 {
1060     if (!m_uploadComplete) {
1061         m_uploadComplete = true;
1062         if (m_upload && m_uploadListenerFlag) {
1063             m_upload->dispatchProgressEvent(type);
1064             m_upload->dispatchProgressEvent(eventNames().loadendEvent);
1065         }
1066     }
1067     m_progressEventThrottle.dispatchProgressEvent(type);
1068     m_progressEventThrottle.dispatchProgressEvent(eventNames().loadendEvent);
1069 }
1070
1071 void XMLHttpRequest::didReachTimeout()
1072 {
1073     // internalAbort() calls dropProtection(), which may release the last reference.
1074     Ref<XMLHttpRequest> protectedThis(*this);
1075     if (!internalAbort())
1076         return;
1077
1078     clearResponse();
1079     clearRequest();
1080
1081     m_sendFlag = false;
1082     m_error = true;
1083     m_exceptionCode = TimeoutError;
1084
1085     if (!m_async) {
1086         m_state = DONE;
1087         m_exceptionCode = TimeoutError;
1088         return;
1089     }
1090
1091     changeState(DONE);
1092
1093     dispatchErrorEvents(eventNames().timeoutEvent);
1094 }
1095
1096 bool XMLHttpRequest::canSuspendForDocumentSuspension() const
1097 {
1098     // If the load event has not fired yet, cancelling the load in suspend() may cause
1099     // the load event to be fired and arbitrary JS execution, which would be unsafe.
1100     // Therefore, we prevent suspending in this case.
1101     return document()->loadEventFinished();
1102 }
1103
1104 const char* XMLHttpRequest::activeDOMObjectName() const
1105 {
1106     return "XMLHttpRequest";
1107 }
1108
1109 void XMLHttpRequest::suspend(ReasonForSuspension reason)
1110 {
1111     m_progressEventThrottle.suspend();
1112
1113     if (m_resumeTimer.isActive()) {
1114         m_resumeTimer.stop();
1115         m_dispatchErrorOnResuming = true;
1116     }
1117
1118     if (reason == ReasonForSuspension::PageCache && m_loader) {
1119         // Going into PageCache, abort the request and dispatch a network error on resuming.
1120         genericError();
1121         m_dispatchErrorOnResuming = true;
1122         bool aborted = internalAbort();
1123         // It should not be possible to restart the load when aborting in suspend() because
1124         // we are not allowed to execute in JS in suspend().
1125         ASSERT_UNUSED(aborted, aborted);
1126     }
1127 }
1128
1129 void XMLHttpRequest::resume()
1130 {
1131     m_progressEventThrottle.resume();
1132
1133     // We are not allowed to execute arbitrary JS in resume() so dispatch
1134     // the error event in a timer.
1135     if (m_dispatchErrorOnResuming && !m_resumeTimer.isActive())
1136         m_resumeTimer.startOneShot(0_s);
1137 }
1138
1139 void XMLHttpRequest::resumeTimerFired()
1140 {
1141     ASSERT(m_dispatchErrorOnResuming);
1142     m_dispatchErrorOnResuming = false;
1143     dispatchErrorEvents(eventNames().errorEvent);
1144 }
1145
1146 void XMLHttpRequest::stop()
1147 {
1148     internalAbort();
1149 }
1150
1151 void XMLHttpRequest::contextDestroyed()
1152 {
1153     ASSERT(!m_loader);
1154     ActiveDOMObject::contextDestroyed();
1155 }
1156
1157 } // namespace WebCore