Change IDL enumerations to be nested in their C++ class instead of at WebCore namespa...
[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 "FormData.h"
26 #include "ResourceResponse.h"
27 #include "ThreadableLoaderClient.h"
28 #include "XMLHttpRequestEventTarget.h"
29 #include "XMLHttpRequestProgressEventThrottle.h"
30 #include <wtf/text/StringBuilder.h>
31
32 namespace JSC {
33 class ArrayBuffer;
34 class ArrayBufferView;
35 }
36
37 namespace WebCore {
38
39 class Blob;
40 class Document;
41 class DOMFormData;
42 class SecurityOrigin;
43 class SharedBuffer;
44 class TextResourceDecoder;
45 class ThreadableLoader;
46
47 class XMLHttpRequest final : public RefCounted<XMLHttpRequest>, public XMLHttpRequestEventTarget, private ThreadableLoaderClient, public ActiveDOMObject {
48     WTF_MAKE_FAST_ALLOCATED;
49 public:
50     static Ref<XMLHttpRequest> create(ScriptExecutionContext&);
51     WEBCORE_EXPORT ~XMLHttpRequest();
52
53     enum State {
54         UNSENT = 0,
55         OPENED = 1,
56         HEADERS_RECEIVED = 2,
57         LOADING = 3,
58         DONE = 4
59     };
60     
61     virtual void didReachTimeout();
62
63     EventTargetInterface eventTargetInterface() const override { return XMLHttpRequestEventTargetInterfaceType; }
64     ScriptExecutionContext* scriptExecutionContext() const override { return ActiveDOMObject::scriptExecutionContext(); }
65
66     const URL& url() const { return m_url; }
67     String statusText() const;
68     int status() const;
69     State readyState() const;
70     bool withCredentials() const { return m_includeCredentials; }
71     void setWithCredentials(bool, ExceptionCode&);
72     void open(const String& method, const URL&, ExceptionCode&);
73     void open(const String& method, const URL&, bool async, ExceptionCode&);
74     void open(const String& method, const URL&, bool async, const String& user, ExceptionCode&);
75     void open(const String& method, const URL&, bool async, const String& user, const String& password, ExceptionCode&);
76     void send(ExceptionCode&);
77     void send(Document*, ExceptionCode&);
78     void send(const String&, ExceptionCode&);
79     void send(Blob*, ExceptionCode&);
80     void send(DOMFormData*, ExceptionCode&);
81     void send(JSC::ArrayBuffer*, ExceptionCode&);
82     void send(JSC::ArrayBufferView*, ExceptionCode&);
83     void abort();
84     void setRequestHeader(const String& name, const String& value, ExceptionCode&);
85     void overrideMimeType(const String& override, ExceptionCode&);
86     bool doneWithoutErrors() const { return !m_error && m_state == DONE; }
87     String getAllResponseHeaders() const;
88     String getResponseHeader(const String& name) const;
89     String responseText(ExceptionCode&);
90     String responseTextIgnoringResponseType() const { return m_responseBuilder.toStringPreserveCapacity(); }
91     String responseMIMEType() const;
92     Document* responseXML(ExceptionCode&);
93     Document* optionalResponseXML() const { return m_responseDocument.get(); }
94     Blob* responseBlob();
95     Blob* optionalResponseBlob() const { return m_responseBlob.get(); }
96     unsigned timeout() const { return m_timeoutMilliseconds; }
97     void setTimeout(unsigned timeout, ExceptionCode&);
98
99     bool responseCacheIsValid() const { return m_responseCacheIsValid; }
100     void didCacheResponseJSON();
101
102     // Expose HTTP validation methods for other untrusted requests.
103     static bool isAllowedHTTPMethod(const String&);
104     static String uppercaseKnownHTTPMethod(const String&);
105     static bool isAllowedHTTPHeader(const String&);
106
107     enum class ResponseType { EmptyString, Arraybuffer, Blob, Document, Json, Text };
108     void setResponseType(ResponseType, ExceptionCode&);
109     ResponseType responseType() const;
110
111     String responseURL() const;
112
113     // response attribute has custom getter.
114     JSC::ArrayBuffer* responseArrayBuffer();
115     JSC::ArrayBuffer* optionalResponseArrayBuffer() const { return m_responseArrayBuffer.get(); }
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     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, double finishTime) override;
153     void didFail(const ResourceError&) override;
154     void didFailRedirectCheck() override;
155
156     bool responseIsXML() const;
157
158     bool initSend(ExceptionCode&);
159     void sendBytesData(const void*, size_t, ExceptionCode&);
160
161     void changeState(State newState);
162     void callReadyStateChangeListener();
163     void dropProtection();
164
165     // Returns false when cancelling the loader within internalAbort() triggers an event whose callback creates a new loader. 
166     // In that case, the function calling internalAbort should exit.
167     bool internalAbort();
168
169     void clearResponse();
170     void clearResponseBuffers();
171     void clearRequest();
172
173     void createRequest(ExceptionCode&);
174
175     void genericError();
176     void networkError();
177     void abortError();
178
179     void dispatchErrorEvents(const AtomicString&);
180
181     void resumeTimerFired();
182
183     std::unique_ptr<XMLHttpRequestUpload> m_upload;
184
185     URL m_url;
186     String m_method;
187     HTTPHeaderMap m_requestHeaders;
188     RefPtr<FormData> m_requestEntityBody;
189     String m_mimeTypeOverride;
190     bool m_async { true };
191     bool m_includeCredentials { false };
192     RefPtr<Blob> m_responseBlob;
193
194     RefPtr<ThreadableLoader> m_loader;
195     State m_state { UNSENT };
196     bool m_sendFlag { false };
197
198     ResourceResponse m_response;
199     String m_responseEncoding;
200
201     RefPtr<TextResourceDecoder> m_decoder;
202
203     StringBuilder m_responseBuilder;
204     bool m_createdDocument { false };
205     RefPtr<Document> m_responseDocument;
206     
207     RefPtr<SharedBuffer> m_binaryResponseBuilder;
208     RefPtr<JSC::ArrayBuffer> m_responseArrayBuffer;
209
210     bool m_error { false };
211
212     bool m_uploadEventsAllowed { true };
213     bool m_uploadComplete { false };
214
215     bool m_sameOriginRequest { true };
216
217     // Used for progress event tracking.
218     long long m_receivedLength { 0 };
219
220     unsigned m_lastSendLineNumber { 0 };
221     unsigned m_lastSendColumnNumber { 0 };
222     String m_lastSendURL;
223     ExceptionCode m_exceptionCode { 0 };
224
225     XMLHttpRequestProgressEventThrottle m_progressEventThrottle;
226
227     ResponseType m_responseType { ResponseType::EmptyString };
228     bool m_responseCacheIsValid { false };
229
230     Timer m_resumeTimer;
231     bool m_dispatchErrorOnResuming { false };
232
233     Timer m_networkErrorTimer;
234     void networkErrorTimerFired();
235
236     unsigned m_timeoutMilliseconds { 0 };
237     std::chrono::steady_clock::time_point m_sendingTime;
238     Timer m_timeoutTimer;
239 };
240
241 inline auto XMLHttpRequest::responseType() const -> ResponseType
242 {
243     return m_responseType;
244 }
245
246 } // namespace WebCore