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