27ff879e72cb895b85236519830587a70130c27e
[WebKit-https.git] / Source / WebCore / xml / XMLHttpRequest.h
1 /*
2  *  Copyright (C) 2003, 2006, 2008 Apple Inc. All rights reserved.
3  *  Copyright (C) 2005, 2006 Alexey Proskuryakov <ap@nypop.com>
4  *  Copyright (C) 2011 Google Inc. All rights reserved.
5  *  Copyright (C) 2012 Intel Corporation
6  *
7  *  This library is free software; you can redistribute it and/or
8  *  modify it under the terms of the GNU Lesser General Public
9  *  License as published by the Free Software Foundation; either
10  *  version 2 of the License, or (at your option) any later version.
11  *
12  *  This library is distributed in the hope that it will be useful,
13  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
14  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  *  Lesser General Public License for more details.
16  *
17  *  You should have received a copy of the GNU Lesser General Public
18  *  License along with this library; if not, write to the Free Software
19  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
20  */
21
22 #pragma once
23
24 #include "ActiveDOMObject.h"
25 #include "ExceptionOr.h"
26 #include "FormData.h"
27 #include "ResourceResponse.h"
28 #include "ThreadableLoaderClient.h"
29 #include "URL.h"
30 #include "XMLHttpRequestEventTarget.h"
31 #include "XMLHttpRequestProgressEventThrottle.h"
32 #include <wtf/Variant.h>
33 #include <wtf/text/StringBuilder.h>
34
35 namespace JSC {
36 class ArrayBuffer;
37 class ArrayBufferView;
38 class ExecState;
39 }
40
41 namespace WebCore {
42
43 class Blob;
44 class Document;
45 class DOMFormData;
46 class SecurityOrigin;
47 class SharedBuffer;
48 class TextResourceDecoder;
49 class ThreadableLoader;
50 class XMLHttpRequestUpload;
51 struct OwnedString;
52
53 class XMLHttpRequest final : public RefCounted<XMLHttpRequest>, public XMLHttpRequestEventTarget, private ThreadableLoaderClient, public ActiveDOMObject {
54     WTF_MAKE_FAST_ALLOCATED;
55 public:
56     static Ref<XMLHttpRequest> create(ScriptExecutionContext&);
57     WEBCORE_EXPORT ~XMLHttpRequest();
58
59     enum State {
60         UNSENT = 0,
61         OPENED = 1,
62         HEADERS_RECEIVED = 2,
63         LOADING = 3,
64         DONE = 4
65     };
66
67     virtual void didReachTimeout();
68
69     EventTargetInterface eventTargetInterface() const override { return XMLHttpRequestEventTargetInterfaceType; }
70     ScriptExecutionContext* scriptExecutionContext() const override { return ActiveDOMObject::scriptExecutionContext(); }
71
72     using SendTypes = Variant<RefPtr<Document>, RefPtr<Blob>, RefPtr<JSC::ArrayBufferView>, RefPtr<JSC::ArrayBuffer>, RefPtr<DOMFormData>, String>;
73
74     const URL& url() const { return m_url; }
75     String statusText() const;
76     int status() const;
77     State readyState() const;
78     bool withCredentials() const { return m_includeCredentials; }
79     ExceptionOr<void> setWithCredentials(bool);
80     ExceptionOr<void> open(const String& method, const String& url);
81     ExceptionOr<void> open(const String& method, const URL&, bool async);
82     ExceptionOr<void> open(const String& method, const String&, bool async, const String& user, const String& password);
83     ExceptionOr<void> send(JSC::ExecState&, std::optional<SendTypes>&&);
84     void abort();
85     ExceptionOr<void> setRequestHeader(const String& name, const String& value);
86     ExceptionOr<void> overrideMimeType(const String& override);
87     bool doneWithoutErrors() const { return !m_error && m_state == DONE; }
88     String getAllResponseHeaders() const;
89     String getResponseHeader(const String& name) const;
90     ExceptionOr<OwnedString> responseText();
91     String responseTextIgnoringResponseType() const { return m_responseBuilder.toStringPreserveCapacity(); }
92     String responseMIMEType() const;
93
94     Document* optionalResponseXML() const { return m_responseDocument.get(); }
95     ExceptionOr<Document*> responseXML();
96
97     Ref<Blob> createResponseBlob();
98     RefPtr<JSC::ArrayBuffer> createResponseArrayBuffer();
99
100     unsigned timeout() const { return m_timeoutMilliseconds; }
101     ExceptionOr<void> setTimeout(unsigned);
102
103     bool responseCacheIsValid() const { return m_responseCacheIsValid; }
104     void didCacheResponse();
105
106     // Expose HTTP validation methods for other untrusted requests.
107     static bool isAllowedHTTPMethod(const String&);
108     static String uppercaseKnownHTTPMethod(const String&);
109
110     enum class ResponseType { EmptyString, Arraybuffer, Blob, Document, Json, Text };
111     ExceptionOr<void> setResponseType(ResponseType);
112     ResponseType responseType() const;
113
114     String responseURL() const;
115
116     void setLastSendLineAndColumnNumber(unsigned lineNumber, unsigned columnNumber);
117     void setLastSendURL(const String& url) { m_lastSendURL = url; }
118
119     XMLHttpRequestUpload* upload();
120     XMLHttpRequestUpload* optionalUpload() const { return m_upload.get(); }
121
122     const ResourceResponse& resourceResponse() const { return m_response; }
123
124     using RefCounted<XMLHttpRequest>::ref;
125     using RefCounted<XMLHttpRequest>::deref;
126
127 private:
128     explicit XMLHttpRequest(ScriptExecutionContext&);
129
130     // ActiveDOMObject
131     void contextDestroyed() override;
132     bool canSuspendForDocumentSuspension() const override;
133     void suspend(ReasonForSuspension) override;
134     void resume() override;
135     void stop() override;
136     const char* activeDOMObjectName() const override;
137
138     void refEventTarget() override { ref(); }
139     void derefEventTarget() override { deref(); }
140
141     Document* document() const;
142     SecurityOrigin* securityOrigin() const;
143
144 #if ENABLE(DASHBOARD_SUPPORT)
145     bool usesDashboardBackwardCompatibilityMode() const;
146 #endif
147
148     // ThreadableLoaderClient
149     void didSendData(unsigned long long bytesSent, unsigned long long totalBytesToBeSent) override;
150     void didReceiveResponse(unsigned long identifier, const ResourceResponse&) override;
151     void didReceiveData(const char* data, int dataLength) override;
152     void didFinishLoading(unsigned long identifier) override;
153     void didFail(const ResourceError&) override;
154
155     bool responseIsXML() const;
156
157     std::optional<ExceptionOr<void>> prepareToSend();
158     ExceptionOr<void> send(Document&);
159     ExceptionOr<void> send(const String& = { });
160     ExceptionOr<void> send(Blob&);
161     ExceptionOr<void> send(DOMFormData&);
162     ExceptionOr<void> send(JSC::ArrayBuffer&);
163     ExceptionOr<void> send(JSC::ArrayBufferView&);
164     ExceptionOr<void> sendBytesData(const void*, size_t);
165
166     void changeState(State);
167     void callReadyStateChangeListener();
168     void dropProtection();
169
170     // Returns false when cancelling the loader within internalAbort() triggers an event whose callback creates a new loader. 
171     // In that case, the function calling internalAbort should exit.
172     bool internalAbort();
173
174     void clearResponse();
175     void clearResponseBuffers();
176     void clearRequest();
177
178     ExceptionOr<void> createRequest();
179
180     void genericError();
181     void networkError();
182     void abortError();
183
184     void dispatchErrorEvents(const AtomicString&);
185
186     void resumeTimerFired();
187
188     std::unique_ptr<XMLHttpRequestUpload> m_upload;
189
190     URL m_url;
191     String m_method;
192     HTTPHeaderMap m_requestHeaders;
193     RefPtr<FormData> m_requestEntityBody;
194     String m_mimeTypeOverride;
195     bool m_async { true };
196     bool m_includeCredentials { false };
197
198     RefPtr<ThreadableLoader> m_loader;
199     State m_state { UNSENT };
200     bool m_sendFlag { false };
201
202     ResourceResponse m_response;
203     String m_responseEncoding;
204
205     RefPtr<TextResourceDecoder> m_decoder;
206
207     StringBuilder m_responseBuilder;
208     bool m_createdDocument { false };
209     RefPtr<Document> m_responseDocument;
210
211     RefPtr<SharedBuffer> m_binaryResponseBuilder;
212
213     bool m_error { false };
214
215     bool m_uploadEventsAllowed { true };
216     bool m_uploadComplete { false };
217
218     bool m_sameOriginRequest { true };
219     bool m_wasAbortedByClient { false };
220
221     // Used for progress event tracking.
222     long long m_receivedLength { 0 };
223
224     unsigned m_lastSendLineNumber { 0 };
225     unsigned m_lastSendColumnNumber { 0 };
226     String m_lastSendURL;
227     std::optional<ExceptionCode> m_exceptionCode;
228
229     XMLHttpRequestProgressEventThrottle m_progressEventThrottle;
230
231     ResponseType m_responseType { ResponseType::EmptyString };
232     bool m_responseCacheIsValid { false };
233     mutable String m_allResponseHeaders;
234
235     Timer m_resumeTimer;
236     bool m_dispatchErrorOnResuming { false };
237
238     Timer m_networkErrorTimer;
239     void networkErrorTimerFired();
240
241     unsigned m_timeoutMilliseconds { 0 };
242     MonotonicTime m_sendingTime;
243     Timer m_timeoutTimer;
244 };
245
246 inline auto XMLHttpRequest::responseType() const -> ResponseType
247 {
248     return m_responseType;
249 }
250
251 } // namespace WebCore