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