Drop std::chrono support from Timer class
[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
52 class XMLHttpRequest final : public RefCounted<XMLHttpRequest>, public XMLHttpRequestEventTarget, private ThreadableLoaderClient, public ActiveDOMObject {
53     WTF_MAKE_FAST_ALLOCATED;
54 public:
55     static Ref<XMLHttpRequest> create(ScriptExecutionContext&);
56     WEBCORE_EXPORT ~XMLHttpRequest();
57
58     enum State {
59         UNSENT = 0,
60         OPENED = 1,
61         HEADERS_RECEIVED = 2,
62         LOADING = 3,
63         DONE = 4
64     };
65
66     virtual void didReachTimeout();
67
68     EventTargetInterface eventTargetInterface() const override { return XMLHttpRequestEventTargetInterfaceType; }
69     ScriptExecutionContext* scriptExecutionContext() const override { return ActiveDOMObject::scriptExecutionContext(); }
70
71     using SendTypes = Variant<RefPtr<Document>, RefPtr<Blob>, RefPtr<JSC::ArrayBufferView>, RefPtr<JSC::ArrayBuffer>, RefPtr<DOMFormData>, String>;
72
73     const URL& url() const { return m_url; }
74     String statusText() const;
75     int status() const;
76     State readyState() const;
77     bool withCredentials() const { return m_includeCredentials; }
78     ExceptionOr<void> setWithCredentials(bool);
79     ExceptionOr<void> open(const String& method, const String& url);
80     ExceptionOr<void> open(const String& method, const URL&, bool async);
81     ExceptionOr<void> open(const String& method, const String&, bool async, const String& user, const String& password);
82     ExceptionOr<void> send(JSC::ExecState&, std::optional<SendTypes>&&);
83     void abort();
84     ExceptionOr<void> setRequestHeader(const String& name, const String& value);
85     ExceptionOr<void> overrideMimeType(const String& override);
86     bool doneWithoutErrors() const { return !m_error && m_state == DONE; }
87     String getAllResponseHeaders() const;
88     String getResponseHeader(const String& name) const;
89     ExceptionOr<String> responseText();
90     String responseTextIgnoringResponseType() const { return m_responseBuilder.toStringPreserveCapacity(); }
91     String responseMIMEType() const;
92
93     Document* optionalResponseXML() const { return m_responseDocument.get(); }
94     ExceptionOr<Document*> responseXML();
95
96     Ref<Blob> createResponseBlob();
97     RefPtr<JSC::ArrayBuffer> createResponseArrayBuffer();
98
99     unsigned timeout() const { return m_timeoutMilliseconds; }
100     ExceptionOr<void> setTimeout(unsigned);
101
102     bool responseCacheIsValid() const { return m_responseCacheIsValid; }
103     void didCacheResponse();
104
105     // Expose HTTP validation methods for other untrusted requests.
106     static bool isAllowedHTTPMethod(const String&);
107     static String uppercaseKnownHTTPMethod(const String&);
108     static bool isAllowedHTTPHeader(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
220     // Used for progress event tracking.
221     long long m_receivedLength { 0 };
222
223     unsigned m_lastSendLineNumber { 0 };
224     unsigned m_lastSendColumnNumber { 0 };
225     String m_lastSendURL;
226     ExceptionCode m_exceptionCode { 0 };
227
228     XMLHttpRequestProgressEventThrottle m_progressEventThrottle;
229
230     ResponseType m_responseType { ResponseType::EmptyString };
231     bool m_responseCacheIsValid { false };
232     mutable String m_allResponseHeaders;
233
234     Timer m_resumeTimer;
235     bool m_dispatchErrorOnResuming { false };
236
237     Timer m_networkErrorTimer;
238     void networkErrorTimerFired();
239
240     unsigned m_timeoutMilliseconds { 0 };
241     MonotonicTime m_sendingTime;
242     Timer m_timeoutTimer;
243 };
244
245 inline auto XMLHttpRequest::responseType() const -> ResponseType
246 {
247     return m_responseType;
248 }
249
250 } // namespace WebCore