[WTF] Import std::optional reference implementation as WTF::Optional
[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 "XMLHttpRequestEventTarget.h"
30 #include "XMLHttpRequestProgressEventThrottle.h"
31 #include <wtf/text/StringBuilder.h>
32
33 namespace JSC {
34 class ArrayBuffer;
35 class ArrayBufferView;
36 }
37
38 namespace WebCore {
39
40 class Blob;
41 class Document;
42 class DOMFormData;
43 class SecurityOrigin;
44 class SharedBuffer;
45 class TextResourceDecoder;
46 class ThreadableLoader;
47 class XMLHttpRequestUpload;
48
49 class XMLHttpRequest final : public RefCounted<XMLHttpRequest>, public XMLHttpRequestEventTarget, private ThreadableLoaderClient, public ActiveDOMObject {
50     WTF_MAKE_FAST_ALLOCATED;
51 public:
52     static Ref<XMLHttpRequest> create(ScriptExecutionContext&);
53     WEBCORE_EXPORT ~XMLHttpRequest();
54
55     enum State {
56         UNSENT = 0,
57         OPENED = 1,
58         HEADERS_RECEIVED = 2,
59         LOADING = 3,
60         DONE = 4
61     };
62
63     virtual void didReachTimeout();
64
65     EventTargetInterface eventTargetInterface() const override { return XMLHttpRequestEventTargetInterfaceType; }
66     ScriptExecutionContext* scriptExecutionContext() const override { return ActiveDOMObject::scriptExecutionContext(); }
67
68     const URL& url() const { return m_url; }
69     String statusText() const;
70     int status() const;
71     State readyState() const;
72     bool withCredentials() const { return m_includeCredentials; }
73     ExceptionOr<void> setWithCredentials(bool);
74     ExceptionOr<void> open(const String& method, const String& url);
75     ExceptionOr<void> open(const String& method, const URL&, bool async);
76     ExceptionOr<void> open(const String& method, const String&, bool async, const String& user, const String& password);
77     ExceptionOr<void> send(Document&);
78     ExceptionOr<void> send(const String& = { });
79     ExceptionOr<void> send(Blob&);
80     ExceptionOr<void> send(DOMFormData&);
81     ExceptionOr<void> send(JSC::ArrayBuffer&);
82     ExceptionOr<void> send(JSC::ArrayBufferView&);
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     void didSendData(unsigned long long bytesSent, unsigned long long totalBytesToBeSent) override;
149     void didReceiveResponse(unsigned long identifier, const ResourceResponse&) override;
150     void didReceiveData(const char* data, int dataLength) override;
151     void didFinishLoading(unsigned long identifier, double finishTime) override;
152     void didFail(const ResourceError&) override;
153
154     bool responseIsXML() const;
155
156     std::optional<ExceptionOr<void>> prepareToSend();
157     ExceptionOr<void> sendBytesData(const void*, size_t);
158
159     void changeState(State);
160     void callReadyStateChangeListener();
161     void dropProtection();
162
163     // Returns false when cancelling the loader within internalAbort() triggers an event whose callback creates a new loader. 
164     // In that case, the function calling internalAbort should exit.
165     bool internalAbort();
166
167     void clearResponse();
168     void clearResponseBuffers();
169     void clearRequest();
170
171     ExceptionOr<void> createRequest();
172
173     void genericError();
174     void networkError();
175     void abortError();
176
177     void dispatchErrorEvents(const AtomicString&);
178
179     void resumeTimerFired();
180
181     std::unique_ptr<XMLHttpRequestUpload> m_upload;
182
183     URL m_url;
184     String m_method;
185     HTTPHeaderMap m_requestHeaders;
186     RefPtr<FormData> m_requestEntityBody;
187     String m_mimeTypeOverride;
188     bool m_async { true };
189     bool m_includeCredentials { false };
190
191     RefPtr<ThreadableLoader> m_loader;
192     State m_state { UNSENT };
193     bool m_sendFlag { false };
194
195     ResourceResponse m_response;
196     String m_responseEncoding;
197
198     RefPtr<TextResourceDecoder> m_decoder;
199
200     StringBuilder m_responseBuilder;
201     bool m_createdDocument { false };
202     RefPtr<Document> m_responseDocument;
203
204     RefPtr<SharedBuffer> m_binaryResponseBuilder;
205
206     bool m_error { false };
207
208     bool m_uploadEventsAllowed { true };
209     bool m_uploadComplete { false };
210
211     bool m_sameOriginRequest { true };
212
213     // Used for progress event tracking.
214     long long m_receivedLength { 0 };
215
216     unsigned m_lastSendLineNumber { 0 };
217     unsigned m_lastSendColumnNumber { 0 };
218     String m_lastSendURL;
219     ExceptionCode m_exceptionCode { 0 };
220
221     XMLHttpRequestProgressEventThrottle m_progressEventThrottle;
222
223     ResponseType m_responseType { ResponseType::EmptyString };
224     bool m_responseCacheIsValid { false };
225
226     Timer m_resumeTimer;
227     bool m_dispatchErrorOnResuming { false };
228
229     Timer m_networkErrorTimer;
230     void networkErrorTimerFired();
231
232     unsigned m_timeoutMilliseconds { 0 };
233     std::chrono::steady_clock::time_point m_sendingTime;
234     Timer m_timeoutTimer;
235 };
236
237 inline auto XMLHttpRequest::responseType() const -> ResponseType
238 {
239     return m_responseType;
240 }
241
242 } // namespace WebCore