575e6fdee95967e4c5eebee8733131ed90ceffc4
[WebKit.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 "Event.h"
32 #include "EventNames.h"
33 #include "File.h"
34 #include "HTMLDocument.h"
35 #include "HTTPHeaderNames.h"
36 #include "HTTPHeaderValues.h"
37 #include "HTTPParsers.h"
38 #include "InspectorInstrumentation.h"
39 #include "JSDOMBinding.h"
40 #include "JSDOMWindow.h"
41 #include "MIMETypeRegistry.h"
42 #include "MemoryCache.h"
43 #include "ParsedContentType.h"
44 #include "ResourceError.h"
45 #include "ResourceRequest.h"
46 #include "ScriptController.h"
47 #include "SecurityOriginPolicy.h"
48 #include "Settings.h"
49 #include "SharedBuffer.h"
50 #include "StringAdaptors.h"
51 #include "TextResourceDecoder.h"
52 #include "ThreadableLoader.h"
53 #include "XMLDocument.h"
54 #include "XMLHttpRequestProgressEvent.h"
55 #include "XMLHttpRequestUpload.h"
56 #include "markup.h"
57 #include <interpreter/StackVisitor.h>
58 #include <mutex>
59 #include <runtime/ArrayBuffer.h>
60 #include <runtime/ArrayBufferView.h>
61 #include <runtime/JSCInlines.h>
62 #include <runtime/JSLock.h>
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 void XMLHttpRequest::setLastSendLineAndColumnNumber(unsigned lineNumber, unsigned columnNumber)
284 {
285     m_lastSendLineNumber = lineNumber;
286     m_lastSendColumnNumber = columnNumber;
287 }
288
289 XMLHttpRequestUpload* XMLHttpRequest::upload()
290 {
291     if (!m_upload)
292         m_upload = std::make_unique<XMLHttpRequestUpload>(this);
293     return m_upload.get();
294 }
295
296 void XMLHttpRequest::changeState(State newState)
297 {
298     if (m_state != newState) {
299         m_state = newState;
300         callReadyStateChangeListener();
301     }
302 }
303
304 void XMLHttpRequest::callReadyStateChangeListener()
305 {
306     if (!scriptExecutionContext())
307         return;
308
309     // Check whether sending load and loadend events before sending readystatechange event, as it may change m_error/m_state values.
310     bool shouldSendLoadEvent = (m_state == DONE && !m_error);
311
312     if (m_async || (m_state <= OPENED || m_state == DONE))
313         m_progressEventThrottle.dispatchReadyStateChangeEvent(Event::create(eventNames().readystatechangeEvent, false, false), m_state == DONE ? FlushProgressEvent : DoNotFlushProgressEvent);
314
315     if (shouldSendLoadEvent) {
316         m_progressEventThrottle.dispatchProgressEvent(eventNames().loadEvent);
317         m_progressEventThrottle.dispatchProgressEvent(eventNames().loadendEvent);
318     }
319 }
320
321 ExceptionOr<void> XMLHttpRequest::setWithCredentials(bool value)
322 {
323     if (m_state > OPENED || m_sendFlag)
324         return Exception { InvalidStateError };
325
326     m_includeCredentials = value;
327     return { };
328 }
329
330 bool XMLHttpRequest::isAllowedHTTPMethod(const String& method)
331 {
332     return !equalLettersIgnoringASCIICase(method, "trace")
333         && !equalLettersIgnoringASCIICase(method, "track")
334         && !equalLettersIgnoringASCIICase(method, "connect");
335 }
336
337 String XMLHttpRequest::uppercaseKnownHTTPMethod(const String& method)
338 {
339     const char* const methods[] = { "DELETE", "GET", "HEAD", "OPTIONS", "POST", "PUT" };
340     for (auto* value : methods) {
341         if (equalIgnoringASCIICase(method, value)) {
342             // Don't bother allocating a new string if it's already all uppercase.
343             if (method == value)
344                 break;
345             return ASCIILiteral(value);
346         }
347     }
348     return method;
349 }
350
351 ExceptionOr<void> XMLHttpRequest::open(const String& method, const String& url)
352 {
353     // If the async argument is omitted, set async to true.
354     return open(method, scriptExecutionContext()->completeURL(url), true);
355 }
356
357 ExceptionOr<void> XMLHttpRequest::open(const String& method, const URL& url, bool async)
358 {
359     if (!internalAbort())
360         return { };
361
362     State previousState = m_state;
363     m_state = UNSENT;
364     m_error = false;
365     m_sendFlag = false;
366     m_uploadComplete = false;
367     m_wasAbortedByClient = false;
368
369     // clear stuff from possible previous load
370     clearResponse();
371     clearRequest();
372
373     ASSERT(m_state == UNSENT);
374
375     if (!isValidHTTPToken(method))
376         return Exception { SyntaxError };
377
378     if (!isAllowedHTTPMethod(method))
379         return Exception { SecurityError };
380
381     if (!async && scriptExecutionContext()->isDocument()) {
382         // Newer functionality is not available to synchronous requests in window contexts, as a spec-mandated
383         // attempt to discourage synchronous XHR use. responseType is one such piece of functionality.
384         // We'll only disable this functionality for HTTP(S) requests since sync requests for local protocols
385         // such as file: and data: still make sense to allow.
386         if (url.protocolIsInHTTPFamily() && m_responseType != ResponseType::EmptyString) {
387             logConsoleError(scriptExecutionContext(), "Synchronous HTTP(S) requests made from the window context cannot have XMLHttpRequest.responseType set.");
388             return Exception { InvalidAccessError };
389         }
390
391         // Similarly, timeouts are disabled for synchronous requests as well.
392         if (m_timeoutMilliseconds > 0) {
393             logConsoleError(scriptExecutionContext(), "Synchronous XMLHttpRequests must not have a timeout value set.");
394             return Exception { InvalidAccessError };
395         }
396     }
397
398     m_method = uppercaseKnownHTTPMethod(method);
399
400     m_url = url;
401     scriptExecutionContext()->contentSecurityPolicy()->upgradeInsecureRequestIfNeeded(m_url, ContentSecurityPolicy::InsecureRequestType::Load);
402
403     m_async = async;
404
405     ASSERT(!m_loader);
406
407     // Check previous state to avoid dispatching readyState event
408     // when calling open several times in a row.
409     if (previousState != OPENED)
410         changeState(OPENED);
411     else
412         m_state = OPENED;
413
414     return { };
415 }
416
417 ExceptionOr<void> XMLHttpRequest::open(const String& method, const String& url, bool async, const String& user, const String& password)
418 {
419     URL urlWithCredentials = scriptExecutionContext()->completeURL(url);
420     if (!user.isNull()) {
421         urlWithCredentials.setUser(user);
422         if (!password.isNull())
423             urlWithCredentials.setPass(password);
424     }
425
426     return open(method, urlWithCredentials, async);
427 }
428
429 std::optional<ExceptionOr<void>> XMLHttpRequest::prepareToSend()
430 {
431     // A return value other than std::nullopt means we should not try to send, and we should return that value to the caller.
432     // std::nullopt means we are ready to send and should continue with the send algorithm.
433
434     if (!scriptExecutionContext())
435         return ExceptionOr<void> { };
436
437     auto& context = *scriptExecutionContext();
438
439     if (m_state != OPENED || m_sendFlag)
440         return ExceptionOr<void> { Exception { InvalidStateError } };
441     ASSERT(!m_loader);
442
443     // FIXME: Convert this to check the isolated world's Content Security Policy once webkit.org/b/104520 is solved.
444     if (!context.shouldBypassMainWorldContentSecurityPolicy() && !context.contentSecurityPolicy()->allowConnectToSource(m_url)) {
445         if (!m_async)
446             return ExceptionOr<void> { Exception { NetworkError } };
447         setPendingActivity(this);
448         m_timeoutTimer.stop();
449         m_networkErrorTimer.startOneShot(0_s);
450         return ExceptionOr<void> { };
451     }
452
453     m_error = false;
454     return std::nullopt;
455 }
456
457 namespace {
458
459 // FIXME: This should be abstracted out, so that any IDL function can be passed the line/column/url tuple.
460
461 // FIXME: This should probably use ShadowChicken so that we get the right frame even when it did a tail call.
462 // https://bugs.webkit.org/show_bug.cgi?id=155688
463
464 class SendFunctor {
465 public:
466     SendFunctor() = default;
467
468     unsigned line() const { return m_line; }
469     unsigned column() const { return m_column; }
470     String url() const { return m_url; }
471
472     JSC::StackVisitor::Status operator()(JSC::StackVisitor& visitor) const
473     {
474         if (!m_hasSkippedFirstFrame) {
475             m_hasSkippedFirstFrame = true;
476             return JSC::StackVisitor::Continue;
477         }
478
479         unsigned line = 0;
480         unsigned column = 0;
481         visitor->computeLineAndColumn(line, column);
482         m_line = line;
483         m_column = column;
484         m_url = visitor->sourceURL();
485         return JSC::StackVisitor::Done;
486     }
487
488 private:
489     mutable bool m_hasSkippedFirstFrame { false };
490     mutable unsigned m_line { 0 };
491     mutable unsigned m_column { 0 };
492     mutable String m_url;
493 };
494
495 }
496
497 ExceptionOr<void> XMLHttpRequest::send(JSC::ExecState& state, std::optional<SendTypes>&& sendType)
498 {
499     InspectorInstrumentation::willSendXMLHttpRequest(scriptExecutionContext(), url());
500
501     ExceptionOr<void> result;
502     if (!sendType)
503         result = send();
504     else {
505         result = WTF::switchOn(sendType.value(),
506             [this] (const RefPtr<Document>& document) -> ExceptionOr<void> { return send(*document); },
507             [this] (const RefPtr<Blob>& blob) -> ExceptionOr<void> { return send(*blob); },
508             [this] (const RefPtr<JSC::ArrayBufferView>& arrayBufferView) -> ExceptionOr<void> { return send(*arrayBufferView); },
509             [this] (const RefPtr<JSC::ArrayBuffer>& arrayBuffer) -> ExceptionOr<void> { return send(*arrayBuffer); },
510             [this] (const RefPtr<DOMFormData>& formData) -> ExceptionOr<void> { return send(*formData); },
511             [this] (const String& string) -> ExceptionOr<void> { return send(string); }
512         );
513     }
514
515     SendFunctor functor;
516     state.iterate(functor);
517     setLastSendLineAndColumnNumber(functor.line(), functor.column());
518     setLastSendURL(functor.url());
519
520     return result;
521 }
522
523 ExceptionOr<void> XMLHttpRequest::send(Document& document)
524 {
525     if (auto result = prepareToSend())
526         return WTFMove(result.value());
527
528     if (m_method != "GET" && m_method != "HEAD" && m_url.protocolIsInHTTPFamily()) {
529         if (!m_requestHeaders.contains(HTTPHeaderName::ContentType)) {
530 #if ENABLE(DASHBOARD_SUPPORT)
531             if (usesDashboardBackwardCompatibilityMode())
532                 m_requestHeaders.set(HTTPHeaderName::ContentType, ASCIILiteral("application/x-www-form-urlencoded"));
533             else
534 #endif
535                 // FIXME: this should include the charset used for encoding.
536                 m_requestHeaders.set(HTTPHeaderName::ContentType, document.isHTMLDocument() ? ASCIILiteral("text/html;charset=UTF-8") : ASCIILiteral("application/xml;charset=UTF-8"));
537         }
538
539         // FIXME: According to XMLHttpRequest Level 2, this should use the Document.innerHTML algorithm
540         // from the HTML5 specification to serialize the document.
541         m_requestEntityBody = FormData::create(UTF8Encoding().encode(createMarkup(document), EntitiesForUnencodables));
542         if (m_upload)
543             m_requestEntityBody->setAlwaysStream(true);
544     }
545
546     return createRequest();
547 }
548
549 ExceptionOr<void> XMLHttpRequest::send(const String& body)
550 {
551     if (auto result = prepareToSend())
552         return WTFMove(result.value());
553
554     if (!body.isNull() && m_method != "GET" && m_method != "HEAD" && m_url.protocolIsInHTTPFamily()) {
555         String contentType = m_requestHeaders.get(HTTPHeaderName::ContentType);
556         if (contentType.isNull()) {
557 #if ENABLE(DASHBOARD_SUPPORT)
558             if (usesDashboardBackwardCompatibilityMode())
559                 m_requestHeaders.set(HTTPHeaderName::ContentType, ASCIILiteral("application/x-www-form-urlencoded"));
560             else
561 #endif
562                 m_requestHeaders.set(HTTPHeaderName::ContentType, HTTPHeaderValues::textPlainContentType());
563         } else {
564             replaceCharsetInMediaType(contentType, "UTF-8");
565             m_requestHeaders.set(HTTPHeaderName::ContentType, contentType);
566         }
567
568         m_requestEntityBody = FormData::create(UTF8Encoding().encode(body, EntitiesForUnencodables));
569         if (m_upload)
570             m_requestEntityBody->setAlwaysStream(true);
571     }
572
573     return createRequest();
574 }
575
576 ExceptionOr<void> XMLHttpRequest::send(Blob& body)
577 {
578     if (auto result = prepareToSend())
579         return WTFMove(result.value());
580
581     if (m_method != "GET" && m_method != "HEAD" && m_url.protocolIsInHTTPFamily()) {
582         if (!m_requestHeaders.contains(HTTPHeaderName::ContentType)) {
583             const String& blobType = body.type();
584             if (!blobType.isEmpty() && isValidContentType(blobType))
585                 m_requestHeaders.set(HTTPHeaderName::ContentType, blobType);
586             else {
587                 // From FileAPI spec, whenever media type cannot be determined, empty string must be returned.
588                 m_requestHeaders.set(HTTPHeaderName::ContentType, emptyString());
589             }
590         }
591
592         m_requestEntityBody = FormData::create();
593         m_requestEntityBody->appendBlob(body.url());
594     }
595
596     return createRequest();
597 }
598
599 ExceptionOr<void> XMLHttpRequest::send(DOMFormData& body)
600 {
601     if (auto result = prepareToSend())
602         return WTFMove(result.value());
603
604     if (m_method != "GET" && m_method != "HEAD" && m_url.protocolIsInHTTPFamily()) {
605         m_requestEntityBody = FormData::createMultiPart(body, document());
606         m_requestEntityBody->generateFiles(document());
607         if (!m_requestHeaders.contains(HTTPHeaderName::ContentType))
608             m_requestHeaders.set(HTTPHeaderName::ContentType, makeString("multipart/form-data; boundary=", m_requestEntityBody->boundary().data()));
609     }
610
611     return createRequest();
612 }
613
614 ExceptionOr<void> XMLHttpRequest::send(ArrayBuffer& body)
615 {
616     ASCIILiteral consoleMessage("ArrayBuffer is deprecated in XMLHttpRequest.send(). Use ArrayBufferView instead.");
617     scriptExecutionContext()->addConsoleMessage(MessageSource::JS, MessageLevel::Warning, consoleMessage);
618     return sendBytesData(body.data(), body.byteLength());
619 }
620
621 ExceptionOr<void> XMLHttpRequest::send(ArrayBufferView& body)
622 {
623     return sendBytesData(body.baseAddress(), body.byteLength());
624 }
625
626 ExceptionOr<void> XMLHttpRequest::sendBytesData(const void* data, size_t length)
627 {
628     if (auto result = prepareToSend())
629         return WTFMove(result.value());
630
631     if (m_method != "GET" && m_method != "HEAD" && m_url.protocolIsInHTTPFamily()) {
632         m_requestEntityBody = FormData::create(data, length);
633         if (m_upload)
634             m_requestEntityBody->setAlwaysStream(true);
635     }
636
637     return createRequest();
638 }
639
640 ExceptionOr<void> XMLHttpRequest::createRequest()
641 {
642     // Only GET request is supported for blob URL.
643     if (!m_async && m_url.protocolIsBlob() && m_method != "GET")
644         return Exception { NetworkError };
645
646     m_sendFlag = true;
647
648     // The presence of upload event listeners forces us to use preflighting because POSTing to an URL that does not
649     // permit cross origin requests should look exactly like POSTing to an URL that does not respond at all.
650     // Also, only async requests support upload progress events.
651     bool uploadEvents = false;
652     if (m_async) {
653         m_progressEventThrottle.dispatchProgressEvent(eventNames().loadstartEvent);
654         if (m_requestEntityBody && m_upload) {
655             uploadEvents = m_upload->hasEventListeners();
656             m_upload->dispatchProgressEvent(eventNames().loadstartEvent);
657         }
658     }
659
660     m_sameOriginRequest = securityOrigin()->canRequest(m_url);
661
662     // We also remember whether upload events should be allowed for this request in case the upload listeners are
663     // added after the request is started.
664     m_uploadEventsAllowed = m_sameOriginRequest || uploadEvents || !isSimpleCrossOriginAccessRequest(m_method, m_requestHeaders);
665
666     ResourceRequest request(m_url);
667     request.setRequester(ResourceRequest::Requester::XHR);
668     request.setInitiatorIdentifier(scriptExecutionContext()->resourceRequestIdentifier());
669     request.setHTTPMethod(m_method);
670
671     if (m_requestEntityBody) {
672         ASSERT(m_method != "GET");
673         ASSERT(m_method != "HEAD");
674         request.setHTTPBody(WTFMove(m_requestEntityBody));
675     }
676
677     if (!m_requestHeaders.isEmpty())
678         request.setHTTPHeaderFields(m_requestHeaders);
679
680     ThreadableLoaderOptions options;
681     options.sendLoadCallbacks = SendCallbacks;
682     options.preflightPolicy = uploadEvents ? ForcePreflight : ConsiderPreflight;
683     options.credentials = m_includeCredentials ? FetchOptions::Credentials::Include : FetchOptions::Credentials::SameOrigin;
684     options.mode = FetchOptions::Mode::Cors;
685     options.contentSecurityPolicyEnforcement = scriptExecutionContext()->shouldBypassMainWorldContentSecurityPolicy() ? ContentSecurityPolicyEnforcement::DoNotEnforce : ContentSecurityPolicyEnforcement::EnforceConnectSrcDirective;
686     options.initiator = cachedResourceRequestInitiators().xmlhttprequest;
687     options.sameOriginDataURLFlag = SameOriginDataURLFlag::Set;
688     options.filteringPolicy = ResponseFilteringPolicy::Enable;
689
690     if (m_timeoutMilliseconds) {
691         if (!m_async)
692             request.setTimeoutInterval(m_timeoutMilliseconds / 1000.0);
693         else {
694             request.setTimeoutInterval(std::numeric_limits<double>::infinity());
695             m_sendingTime = MonotonicTime::now();
696             m_timeoutTimer.startOneShot(1_ms * m_timeoutMilliseconds);
697         }
698     }
699
700     m_exceptionCode = std::nullopt;
701     m_error = false;
702
703     if (m_async) {
704         // 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.
705         // This is true while running onunload handlers.
706         // FIXME: Maybe we need to be able to send XMLHttpRequests from onunload, <http://bugs.webkit.org/show_bug.cgi?id=10904>.
707         m_loader = ThreadableLoader::create(*scriptExecutionContext(), *this, WTFMove(request), options);
708
709         // Either loader is null or some error was synchronously sent to us.
710         ASSERT(m_loader || !m_sendFlag);
711
712         // Neither this object nor the JavaScript wrapper should be deleted while
713         // a request is in progress because we need to keep the listeners alive,
714         // and they are referenced by the JavaScript wrapper.
715         if (m_loader)
716             setPendingActivity(this);
717     } else {
718         request.setDomainForCachePartition(scriptExecutionContext()->topOrigin().domainForCachePartition());
719         InspectorInstrumentation::willLoadXHRSynchronously(scriptExecutionContext());
720         ThreadableLoader::loadResourceSynchronously(*scriptExecutionContext(), WTFMove(request), *this, options);
721         InspectorInstrumentation::didLoadXHRSynchronously(scriptExecutionContext());
722     }
723
724     if (m_exceptionCode)
725         return Exception { m_exceptionCode.value() };
726     if (m_error)
727         return Exception { NetworkError };
728     return { };
729 }
730
731 void XMLHttpRequest::abort()
732 {
733     // internalAbort() calls dropProtection(), which may release the last reference.
734     Ref<XMLHttpRequest> protectedThis(*this);
735
736     m_wasAbortedByClient = true;
737     if (!internalAbort())
738         return;
739
740     clearResponseBuffers();
741
742     // Clear headers as required by the spec
743     m_requestHeaders.clear();
744     if ((m_state == OPENED && m_sendFlag) || m_state == HEADERS_RECEIVED || m_state == LOADING) {
745         ASSERT(!m_loader);
746         m_sendFlag = false;
747         changeState(DONE);
748         dispatchErrorEvents(eventNames().abortEvent);
749     }
750     m_state = UNSENT;
751 }
752
753 bool XMLHttpRequest::internalAbort()
754 {
755     m_error = true;
756
757     // FIXME: when we add the support for multi-part XHR, we will have to think be careful with this initialization.
758     m_receivedLength = 0;
759
760     m_decoder = nullptr;
761
762     m_timeoutTimer.stop();
763
764     if (!m_loader)
765         return true;
766
767     // Cancelling m_loader may trigger a window.onload callback which can call open() on the same xhr.
768     // This would create internalAbort reentrant call.
769     // m_loader is set to null before being cancelled to exit early in any reentrant internalAbort() call.
770     auto loader = WTFMove(m_loader);
771     loader->cancel();
772
773     // If window.onload callback calls open() and send() on the same xhr, m_loader is now set to a new value.
774     // The function calling internalAbort() should abort to let the open() and send() calls continue properly.
775     // We ask the function calling internalAbort() to exit by returning false.
776     // Save this information to a local variable since we are going to drop protection.
777     bool newLoadStarted = m_loader;
778
779     dropProtection();
780
781     return !newLoadStarted;
782 }
783
784 void XMLHttpRequest::clearResponse()
785 {
786     m_response = ResourceResponse();
787     clearResponseBuffers();
788 }
789
790 void XMLHttpRequest::clearResponseBuffers()
791 {
792     m_responseBuilder.clear();
793     m_responseEncoding = String();
794     m_createdDocument = false;
795     m_responseDocument = nullptr;
796     m_binaryResponseBuilder = nullptr;
797     m_responseCacheIsValid = false;
798 }
799
800 void XMLHttpRequest::clearRequest()
801 {
802     m_requestHeaders.clear();
803     m_requestEntityBody = nullptr;
804 }
805
806 void XMLHttpRequest::genericError()
807 {
808     clearResponse();
809     clearRequest();
810     m_sendFlag = false;
811     m_error = true;
812
813     changeState(DONE);
814 }
815
816 void XMLHttpRequest::networkError()
817 {
818     genericError();
819     dispatchErrorEvents(eventNames().errorEvent);
820     internalAbort();
821 }
822
823 void XMLHttpRequest::networkErrorTimerFired()
824 {
825     networkError();
826     dropProtection();
827 }
828     
829 void XMLHttpRequest::abortError()
830 {
831     ASSERT(m_wasAbortedByClient);
832     genericError();
833     dispatchErrorEvents(eventNames().abortEvent);
834 }
835
836 void XMLHttpRequest::dropProtection()
837 {
838     // The XHR object itself holds on to the responseText, and
839     // thus has extra cost even independent of any
840     // responseText or responseXML objects it has handed
841     // out. But it is protected from GC while loading, so this
842     // can't be recouped until the load is done, so only
843     // report the extra cost at that point.
844     JSC::VM& vm = scriptExecutionContext()->vm();
845     JSC::JSLockHolder lock(vm);
846     // FIXME: Adopt reportExtraMemoryVisited, and switch to reportExtraMemoryAllocated.
847     // https://bugs.webkit.org/show_bug.cgi?id=142595
848     vm.heap.deprecatedReportExtraMemory(m_responseBuilder.length() * 2);
849
850     unsetPendingActivity(this);
851 }
852
853 ExceptionOr<void> XMLHttpRequest::overrideMimeType(const String& override)
854 {
855     if (m_state == LOADING || m_state == DONE)
856         return Exception { InvalidStateError };
857
858     m_mimeTypeOverride = override;
859     return { };
860 }
861
862 ExceptionOr<void> XMLHttpRequest::setRequestHeader(const String& name, const String& value)
863 {
864     if (m_state != OPENED || m_sendFlag) {
865 #if ENABLE(DASHBOARD_SUPPORT)
866         if (usesDashboardBackwardCompatibilityMode())
867             return { };
868 #endif
869         return Exception { InvalidStateError };
870     }
871
872     String normalizedValue = stripLeadingAndTrailingHTTPSpaces(value);
873     if (!isValidHTTPToken(name) || !isValidHTTPHeaderValue(normalizedValue))
874         return Exception { SyntaxError };
875
876     bool allowUnsafeHeaderField = false;
877 #if ENABLE(DASHBOARD_SUPPORT)
878     allowUnsafeHeaderField = usesDashboardBackwardCompatibilityMode();
879 #endif
880     if (!allowUnsafeHeaderField && isForbiddenHeaderName(name)) {
881         logConsoleError(scriptExecutionContext(), "Refused to set unsafe header \"" + name + "\"");
882         return { };
883     }
884
885     m_requestHeaders.add(name, normalizedValue);
886     return { };
887 }
888
889 String XMLHttpRequest::getAllResponseHeaders() const
890 {
891     if (m_state < HEADERS_RECEIVED || m_error)
892         return emptyString();
893
894     if (!m_allResponseHeaders) {
895         Vector<String> headers;
896         headers.reserveInitialCapacity(m_response.httpHeaderFields().size());
897
898         for (auto& header : m_response.httpHeaderFields()) {
899             StringBuilder stringBuilder;
900             stringBuilder.append(header.key.convertToASCIILowercase());
901             stringBuilder.appendLiteral(": ");
902             stringBuilder.append(header.value);
903             stringBuilder.appendLiteral("\r\n");
904             headers.uncheckedAppend(stringBuilder.toString());
905         }
906         std::sort(headers.begin(), headers.end(), WTF::codePointCompareLessThan);
907
908         StringBuilder stringBuilder;
909         for (auto& header : headers)
910             stringBuilder.append(header);
911         m_allResponseHeaders = stringBuilder.toString();
912     }
913
914     return m_allResponseHeaders;
915 }
916
917 String XMLHttpRequest::getResponseHeader(const String& name) const
918 {
919     if (m_state < HEADERS_RECEIVED || m_error)
920         return String();
921
922     return m_response.httpHeaderField(name);
923 }
924
925 String XMLHttpRequest::responseMIMEType() const
926 {
927     String mimeType = extractMIMETypeFromMediaType(m_mimeTypeOverride);
928     if (mimeType.isEmpty()) {
929         if (m_response.isHTTP())
930             mimeType = extractMIMETypeFromMediaType(m_response.httpHeaderField(HTTPHeaderName::ContentType));
931         else
932             mimeType = m_response.mimeType();
933         if (mimeType.isEmpty())
934             mimeType = ASCIILiteral("text/xml");
935     }
936     return mimeType;
937 }
938
939 bool XMLHttpRequest::responseIsXML() const
940 {
941     return MIMETypeRegistry::isXMLMIMEType(responseMIMEType());
942 }
943
944 int XMLHttpRequest::status() const
945 {
946     if (m_state == UNSENT || m_state == OPENED || m_error)
947         return 0;
948
949     return m_response.httpStatusCode();
950 }
951
952 String XMLHttpRequest::statusText() const
953 {
954     if (m_state == UNSENT || m_state == OPENED || m_error)
955         return String();
956
957     return m_response.httpStatusText();
958 }
959
960 void XMLHttpRequest::didFail(const ResourceError& error)
961 {
962     // If we are already in an error state, for instance we called abort(), bail out early.
963     if (m_error)
964         return;
965
966     // The XHR specification says we should only fire an abort event if the cancelation was requested by the client.
967     if (m_wasAbortedByClient && error.isCancellation()) {
968         m_exceptionCode = AbortError;
969         abortError();
970         return;
971     }
972
973     // In case of worker sync timeouts.
974     if (error.isTimeout()) {
975         didReachTimeout();
976         return;
977     }
978
979     // Network failures are already reported to Web Inspector by ResourceLoader.
980     if (error.domain() == errorDomainWebKitInternal) {
981         String message = makeString("XMLHttpRequest cannot load ", error.failingURL().string(), ". ", error.localizedDescription());
982         logConsoleError(scriptExecutionContext(), message);
983     } else if (error.isAccessControl()) {
984         String message = makeString("XMLHttpRequest cannot load ", error.failingURL().string(), " due to access control checks.");
985         logConsoleError(scriptExecutionContext(), message);
986     }
987
988     // In case didFail is called synchronously on an asynchronous XHR call, let's dispatch network error asynchronously
989     if (m_async && m_sendFlag && !m_loader) {
990         m_sendFlag = false;
991         setPendingActivity(this);
992         m_timeoutTimer.stop();
993         m_networkErrorTimer.startOneShot(0_s);
994         return;
995     }
996     m_exceptionCode = NetworkError;
997     networkError();
998 }
999
1000 void XMLHttpRequest::didFinishLoading(unsigned long identifier)
1001 {
1002     if (m_error)
1003         return;
1004
1005     if (m_state < HEADERS_RECEIVED)
1006         changeState(HEADERS_RECEIVED);
1007
1008     if (m_decoder)
1009         m_responseBuilder.append(m_decoder->flush());
1010
1011     m_responseBuilder.shrinkToFit();
1012
1013     std::optional<String> decodedText;
1014     if (!m_binaryResponseBuilder)
1015         decodedText = m_responseBuilder.toStringPreserveCapacity();
1016     InspectorInstrumentation::didFinishXHRLoading(scriptExecutionContext(), identifier, decodedText, m_url, m_lastSendURL, m_lastSendLineNumber, m_lastSendColumnNumber);
1017
1018     bool hadLoader = m_loader;
1019     m_loader = nullptr;
1020
1021     m_sendFlag = false;
1022     changeState(DONE);
1023     m_responseEncoding = String();
1024     m_decoder = nullptr;
1025
1026     m_timeoutTimer.stop();
1027
1028     if (hadLoader)
1029         dropProtection();
1030 }
1031
1032 void XMLHttpRequest::didSendData(unsigned long long bytesSent, unsigned long long totalBytesToBeSent)
1033 {
1034     if (!m_upload)
1035         return;
1036
1037     if (m_uploadEventsAllowed)
1038         m_upload->dispatchThrottledProgressEvent(true, bytesSent, totalBytesToBeSent);
1039     if (bytesSent == totalBytesToBeSent && !m_uploadComplete) {
1040         m_uploadComplete = true;
1041         if (m_uploadEventsAllowed) {
1042             m_upload->dispatchProgressEvent(eventNames().loadEvent);
1043             m_upload->dispatchProgressEvent(eventNames().loadendEvent);
1044         }
1045     }
1046 }
1047
1048 void XMLHttpRequest::didReceiveResponse(unsigned long, const ResourceResponse& response)
1049 {
1050     m_response = response;
1051     if (!m_mimeTypeOverride.isEmpty())
1052         m_response.setHTTPHeaderField(HTTPHeaderName::ContentType, m_mimeTypeOverride);
1053 }
1054
1055 static inline bool shouldDecodeResponse(XMLHttpRequest::ResponseType type)
1056 {
1057     switch (type) {
1058     case XMLHttpRequest::ResponseType::EmptyString:
1059     case XMLHttpRequest::ResponseType::Document:
1060     case XMLHttpRequest::ResponseType::Json:
1061     case XMLHttpRequest::ResponseType::Text:
1062         return true;
1063     case XMLHttpRequest::ResponseType::Arraybuffer:
1064     case XMLHttpRequest::ResponseType::Blob:
1065         return false;
1066     }
1067     ASSERT_NOT_REACHED();
1068     return true;
1069 }
1070
1071 void XMLHttpRequest::didReceiveData(const char* data, int len)
1072 {
1073     if (m_error)
1074         return;
1075
1076     if (m_state < HEADERS_RECEIVED)
1077         changeState(HEADERS_RECEIVED);
1078
1079     // FIXME: Should we update "Content-Type" header field with m_mimeTypeOverride value in case it has changed since didReceiveResponse?
1080     if (!m_mimeTypeOverride.isEmpty())
1081         m_responseEncoding = extractCharsetFromMediaType(m_mimeTypeOverride);
1082     if (m_responseEncoding.isEmpty())
1083         m_responseEncoding = m_response.textEncodingName();
1084
1085     bool useDecoder = shouldDecodeResponse(m_responseType);
1086
1087     if (useDecoder && !m_decoder) {
1088         if (!m_responseEncoding.isEmpty())
1089             m_decoder = TextResourceDecoder::create("text/plain", m_responseEncoding);
1090         // allow TextResourceDecoder to look inside the m_response if it's XML or HTML
1091         else if (responseIsXML()) {
1092             m_decoder = TextResourceDecoder::create("application/xml");
1093             // 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.
1094             m_decoder->useLenientXMLDecoding();
1095         } else if (equalLettersIgnoringASCIICase(responseMIMEType(), "text/html"))
1096             m_decoder = TextResourceDecoder::create("text/html", "UTF-8");
1097         else
1098             m_decoder = TextResourceDecoder::create("text/plain", "UTF-8");
1099     }
1100
1101     if (!len)
1102         return;
1103
1104     if (len == -1)
1105         len = strlen(data);
1106
1107     if (useDecoder)
1108         m_responseBuilder.append(m_decoder->decode(data, len));
1109     else {
1110         // Buffer binary data.
1111         if (!m_binaryResponseBuilder)
1112             m_binaryResponseBuilder = SharedBuffer::create();
1113         m_binaryResponseBuilder->append(data, len);
1114     }
1115
1116     if (!m_error) {
1117         m_receivedLength += len;
1118
1119         if (m_async) {
1120             long long expectedLength = m_response.expectedContentLength();
1121             bool lengthComputable = expectedLength > 0 && m_receivedLength <= expectedLength;
1122             unsigned long long total = lengthComputable ? expectedLength : 0;
1123             m_progressEventThrottle.dispatchThrottledProgressEvent(lengthComputable, m_receivedLength, total);
1124         }
1125
1126         if (m_state != LOADING)
1127             changeState(LOADING);
1128         else
1129             // Firefox calls readyStateChanged every time it receives data, 4449442
1130             callReadyStateChangeListener();
1131     }
1132 }
1133
1134 void XMLHttpRequest::dispatchErrorEvents(const AtomicString& type)
1135 {
1136     if (!m_uploadComplete) {
1137         m_uploadComplete = true;
1138         if (m_upload && m_uploadEventsAllowed) {
1139             m_upload->dispatchProgressEvent(eventNames().progressEvent);
1140             m_upload->dispatchProgressEvent(type);
1141             m_upload->dispatchProgressEvent(eventNames().loadendEvent);
1142         }
1143     }
1144     m_progressEventThrottle.dispatchProgressEvent(eventNames().progressEvent);
1145     m_progressEventThrottle.dispatchProgressEvent(type);
1146     m_progressEventThrottle.dispatchProgressEvent(eventNames().loadendEvent);
1147 }
1148
1149 void XMLHttpRequest::didReachTimeout()
1150 {
1151     // internalAbort() calls dropProtection(), which may release the last reference.
1152     Ref<XMLHttpRequest> protectedThis(*this);
1153     if (!internalAbort())
1154         return;
1155
1156     clearResponse();
1157     clearRequest();
1158
1159     m_sendFlag = false;
1160     m_error = true;
1161     m_exceptionCode = TimeoutError;
1162
1163     if (!m_async) {
1164         m_state = DONE;
1165         m_exceptionCode = TimeoutError;
1166         return;
1167     }
1168
1169     changeState(DONE);
1170
1171     dispatchErrorEvents(eventNames().timeoutEvent);
1172 }
1173
1174 bool XMLHttpRequest::canSuspendForDocumentSuspension() const
1175 {
1176     // If the load event has not fired yet, cancelling the load in suspend() may cause
1177     // the load event to be fired and arbitrary JS execution, which would be unsafe.
1178     // Therefore, we prevent suspending in this case.
1179     return document()->loadEventFinished();
1180 }
1181
1182 const char* XMLHttpRequest::activeDOMObjectName() const
1183 {
1184     return "XMLHttpRequest";
1185 }
1186
1187 void XMLHttpRequest::suspend(ReasonForSuspension reason)
1188 {
1189     m_progressEventThrottle.suspend();
1190
1191     if (m_resumeTimer.isActive()) {
1192         m_resumeTimer.stop();
1193         m_dispatchErrorOnResuming = true;
1194     }
1195
1196     if (reason == ActiveDOMObject::PageCache && m_loader) {
1197         // Going into PageCache, abort the request and dispatch a network error on resuming.
1198         genericError();
1199         m_dispatchErrorOnResuming = true;
1200         bool aborted = internalAbort();
1201         // It should not be possible to restart the load when aborting in suspend() because
1202         // we are not allowed to execute in JS in suspend().
1203         ASSERT_UNUSED(aborted, aborted);
1204     }
1205 }
1206
1207 void XMLHttpRequest::resume()
1208 {
1209     m_progressEventThrottle.resume();
1210
1211     // We are not allowed to execute arbitrary JS in resume() so dispatch
1212     // the error event in a timer.
1213     if (m_dispatchErrorOnResuming && !m_resumeTimer.isActive())
1214         m_resumeTimer.startOneShot(0_s);
1215 }
1216
1217 void XMLHttpRequest::resumeTimerFired()
1218 {
1219     ASSERT(m_dispatchErrorOnResuming);
1220     m_dispatchErrorOnResuming = false;
1221     dispatchErrorEvents(eventNames().errorEvent);
1222 }
1223
1224 void XMLHttpRequest::stop()
1225 {
1226     internalAbort();
1227 }
1228
1229 void XMLHttpRequest::contextDestroyed()
1230 {
1231     ASSERT(!m_loader);
1232     ActiveDOMObject::contextDestroyed();
1233 }
1234
1235 } // namespace WebCore