Clean up ExceptionCode enumeration
[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     static bool isAllowedHTTPHeader(const String&);
110
111     enum class ResponseType { EmptyString, Arraybuffer, Blob, Document, Json, Text };
112     ExceptionOr<void> setResponseType(ResponseType);
113     ResponseType responseType() const;
114
115     String responseURL() const;
116
117     void setLastSendLineAndColumnNumber(unsigned lineNumber, unsigned columnNumber);
118     void setLastSendURL(const String& url) { m_lastSendURL = url; }
119
120     XMLHttpRequestUpload* upload();
121     XMLHttpRequestUpload* optionalUpload() const { return m_upload.get(); }
122
123     const ResourceResponse& resourceResponse() const { return m_response; }
124
125     using RefCounted<XMLHttpRequest>::ref;
126     using RefCounted<XMLHttpRequest>::deref;
127
128 private:
129     explicit XMLHttpRequest(ScriptExecutionContext&);
130
131     // ActiveDOMObject
132     void contextDestroyed() override;
133     bool canSuspendForDocumentSuspension() const override;
134     void suspend(ReasonForSuspension) override;
135     void resume() override;
136     void stop() override;
137     const char* activeDOMObjectName() const override;
138
139     void refEventTarget() override { ref(); }
140     void derefEventTarget() override { deref(); }
141
142     Document* document() const;
143     SecurityOrigin* securityOrigin() const;
144
145 #if ENABLE(DASHBOARD_SUPPORT)
146     bool usesDashboardBackwardCompatibilityMode() const;
147 #endif
148
149     // ThreadableLoaderClient
150     void didSendData(unsigned long long bytesSent, unsigned long long totalBytesToBeSent) override;
151     void didReceiveResponse(unsigned long identifier, const ResourceResponse&) override;
152     void didReceiveData(const char* data, int dataLength) override;
153     void didFinishLoading(unsigned long identifier) override;
154     void didFail(const ResourceError&) override;
155
156     bool responseIsXML() const;
157
158     std::optional<ExceptionOr<void>> prepareToSend();
159     ExceptionOr<void> send(Document&);
160     ExceptionOr<void> send(const String& = { });
161     ExceptionOr<void> send(Blob&);
162     ExceptionOr<void> send(DOMFormData&);
163     ExceptionOr<void> send(JSC::ArrayBuffer&);
164     ExceptionOr<void> send(JSC::ArrayBufferView&);
165     ExceptionOr<void> sendBytesData(const void*, size_t);
166
167     void changeState(State);
168     void callReadyStateChangeListener();
169     void dropProtection();
170
171     // Returns false when cancelling the loader within internalAbort() triggers an event whose callback creates a new loader. 
172     // In that case, the function calling internalAbort should exit.
173     bool internalAbort();
174
175     void clearResponse();
176     void clearResponseBuffers();
177     void clearRequest();
178
179     ExceptionOr<void> createRequest();
180
181     void genericError();
182     void networkError();
183     void abortError();
184
185     void dispatchErrorEvents(const AtomicString&);
186
187     void resumeTimerFired();
188
189     std::unique_ptr<XMLHttpRequestUpload> m_upload;
190
191     URL m_url;
192     String m_method;
193     HTTPHeaderMap m_requestHeaders;
194     RefPtr<FormData> m_requestEntityBody;
195     String m_mimeTypeOverride;
196     bool m_async { true };
197     bool m_includeCredentials { false };
198
199     RefPtr<ThreadableLoader> m_loader;
200     State m_state { UNSENT };
201     bool m_sendFlag { false };
202
203     ResourceResponse m_response;
204     String m_responseEncoding;
205
206     RefPtr<TextResourceDecoder> m_decoder;
207
208     StringBuilder m_responseBuilder;
209     bool m_createdDocument { false };
210     RefPtr<Document> m_responseDocument;
211
212     RefPtr<SharedBuffer> m_binaryResponseBuilder;
213
214     bool m_error { false };
215
216     bool m_uploadEventsAllowed { true };
217     bool m_uploadComplete { false };
218
219     bool m_sameOriginRequest { true };
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