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