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