Modernize how many platform/network classes do isolatedCopy().
[WebKit-https.git] / Source / WebCore / platform / network / FormData.h
1 /*
2  * Copyright (C) 2004, 2006, 2008, 2011 Apple Inc. All rights reserved.
3  *
4  * This library is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU Library General Public
6  * License as published by the Free Software Foundation; either
7  * version 2 of the License, or (at your option) any later version.
8  *
9  * This library is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12  * Library General Public License for more details.
13  *
14  * You should have received a copy of the GNU Library General Public License
15  * along with this library; see the file COPYING.LIB. If not, write to
16  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
17  * Boston, MA 02110-1301, USA.
18  */
19
20 #ifndef FormData_h
21 #define FormData_h
22
23 #include "BlobData.h"
24 #include "URL.h"
25 #include <wtf/Forward.h>
26 #include <wtf/RefCounted.h>
27 #include <wtf/Vector.h>
28 #include <wtf/text/WTFString.h>
29
30 namespace WebCore {
31
32 class Document;
33 class FormDataList;
34 class TextEncoding;
35
36 class FormDataElement {
37 public:
38     enum class Type {
39         Data,
40         EncodedFile,
41         EncodedBlob,
42     };
43
44     FormDataElement()
45         : m_type(Type::Data)
46     {
47     }
48
49     explicit FormDataElement(const Vector<char>& array)
50         : m_type(Type::Data)
51         , m_data(array)
52     {
53     }
54
55     FormDataElement(const String& filename, long long fileStart, long long fileLength, double expectedFileModificationTime, bool shouldGenerateFile)
56         : m_type(Type::EncodedFile)
57         , m_filename(filename)
58         , m_fileStart(fileStart)
59         , m_fileLength(fileLength)
60         , m_expectedFileModificationTime(expectedFileModificationTime)
61         , m_shouldGenerateFile(shouldGenerateFile)
62         , m_ownsGeneratedFile(false)
63     {
64     }
65
66     explicit FormDataElement(const URL& blobURL)
67         : m_type(Type::EncodedBlob)
68         , m_url(blobURL)
69     {
70     }
71
72     FormDataElement isolatedCopy() const;
73
74     template<typename Encoder>
75     void encode(Encoder&) const;
76     template<typename Decoder>
77     static bool decode(Decoder&, FormDataElement& result);
78
79     Type m_type;
80     Vector<char> m_data;
81     String m_filename;
82     URL m_url; // For Blob or URL.
83     int64_t m_fileStart;
84     int64_t m_fileLength;
85     double m_expectedFileModificationTime;
86     // FIXME: Generated file support in FormData is almost identical to Blob, they should be merged.
87     // We can't just switch to using Blobs for all files for two reasons:
88     // 1. Not all platforms enable BLOB support.
89     // 2. EncodedFile form data elements do not have a valid m_expectedFileModificationTime, meaning that we always upload the latest content from disk.
90     String m_generatedFilename;
91     bool m_shouldGenerateFile;
92     bool m_ownsGeneratedFile;
93 };
94
95 inline bool operator==(const FormDataElement& a, const FormDataElement& b)
96 {
97     if (&a == &b)
98         return true;
99
100     if (a.m_type != b.m_type)
101         return false;
102     if (a.m_type == FormDataElement::Type::Data)
103         return a.m_data == b.m_data;
104     if (a.m_type == FormDataElement::Type::EncodedFile)
105         return a.m_filename == b.m_filename && a.m_fileStart == b.m_fileStart && a.m_fileLength == b.m_fileLength && a.m_expectedFileModificationTime == b.m_expectedFileModificationTime;
106     if (a.m_type == FormDataElement::Type::EncodedBlob)
107         return a.m_url == b.m_url;
108
109     return true;
110 }
111
112 inline bool operator!=(const FormDataElement& a, const FormDataElement& b)
113 {
114     return !(a == b);
115 }
116
117
118 template<typename Encoder>
119 void FormDataElement::encode(Encoder& encoder) const
120 {
121     encoder.encodeEnum(m_type);
122
123     switch (m_type) {
124     case Type::Data:
125         encoder << m_data;
126         break;
127
128     case Type::EncodedFile:
129         encoder << m_filename;
130         encoder << m_generatedFilename;
131         encoder << m_shouldGenerateFile;
132         encoder << m_fileStart;
133         encoder << m_fileLength;
134         encoder << m_expectedFileModificationTime;
135         break;
136
137     case Type::EncodedBlob:
138         encoder << m_url.string();
139         break;
140     }
141 }
142
143 template<typename Decoder>
144 bool FormDataElement::decode(Decoder& decoder, FormDataElement& result)
145 {
146     if (!decoder.decodeEnum(result.m_type))
147         return false;
148
149     switch (result.m_type) {
150     case Type::Data:
151         if (!decoder.decode(result.m_data))
152             return false;
153
154         return true;
155
156     case Type::EncodedFile:
157         if (!decoder.decode(result.m_filename))
158             return false;
159         if (!decoder.decode(result.m_generatedFilename))
160             return false;
161         if (!decoder.decode(result.m_shouldGenerateFile))
162             return false;
163         result.m_ownsGeneratedFile = false;
164         if (!decoder.decode(result.m_fileStart))
165             return false;
166         if (!decoder.decode(result.m_fileLength))
167             return false;
168
169         if (result.m_fileLength != BlobDataItem::toEndOfFile && result.m_fileLength < result.m_fileStart)
170             return false;
171
172         if (!decoder.decode(result.m_expectedFileModificationTime))
173             return false;
174
175         return true;
176
177     case Type::EncodedBlob: {
178         String blobURLString;
179         if (!decoder.decode(blobURLString))
180             return false;
181
182         result.m_url = URL(URL(), blobURLString);
183
184         return true;
185     }
186     }
187
188     return false;
189 }
190
191 class FormData : public RefCounted<FormData> {
192 public:
193     enum EncodingType {
194         FormURLEncoded, // for application/x-www-form-urlencoded
195         TextPlain, // for text/plain
196         MultipartFormData // for multipart/form-data
197     };
198
199     WEBCORE_EXPORT static Ref<FormData> create();
200     WEBCORE_EXPORT static Ref<FormData> create(const void*, size_t);
201     static Ref<FormData> create(const CString&);
202     static Ref<FormData> create(const Vector<char>&);
203     static Ref<FormData> create(const FormDataList&, const TextEncoding&, EncodingType = FormURLEncoded);
204     static Ref<FormData> createMultiPart(const FormDataList&, const TextEncoding&, Document*);
205     WEBCORE_EXPORT ~FormData();
206
207     // FIXME: Both these functions perform a deep copy of m_elements, but differ in handling of other data members.
208     // How much of that is intentional? We need better names that explain the difference.
209     Ref<FormData> copy() const;
210     Ref<FormData> isolatedCopy() const;
211
212     template<typename Encoder>
213     void encode(Encoder&) const;
214     template<typename Decoder>
215     static RefPtr<FormData> decode(Decoder&);
216
217     WEBCORE_EXPORT void appendData(const void* data, size_t);
218     void appendFile(const String& filePath, bool shouldGenerateFile = false);
219     WEBCORE_EXPORT void appendFileRange(const String& filename, long long start, long long length, double expectedModificationTime, bool shouldGenerateFile = false);
220     WEBCORE_EXPORT void appendBlob(const URL& blobURL);
221     char* expandDataStore(size_t);
222
223     void flatten(Vector<char>&) const; // omits files
224     String flattenToString() const; // omits files
225
226     // Resolve all blob references so we only have file and data.
227     // If the FormData has no blob references to resolve, this is returned.
228     Ref<FormData> resolveBlobReferences();
229
230     bool isEmpty() const { return m_elements.isEmpty(); }
231     const Vector<FormDataElement>& elements() const { return m_elements; }
232     const Vector<char>& boundary() const { return m_boundary; }
233
234     void generateFiles(Document*);
235     void removeGeneratedFilesIfNeeded();
236
237     bool alwaysStream() const { return m_alwaysStream; }
238     void setAlwaysStream(bool alwaysStream) { m_alwaysStream = alwaysStream; }
239
240     // Identifies a particular form submission instance.  A value of 0 is used
241     // to indicate an unspecified identifier.
242     void setIdentifier(int64_t identifier) { m_identifier = identifier; }
243     int64_t identifier() const { return m_identifier; }
244
245     bool containsPasswordData() const { return m_containsPasswordData; }
246     void setContainsPasswordData(bool containsPasswordData) { m_containsPasswordData = containsPasswordData; }
247
248     static EncodingType parseEncodingType(const String& type)
249     {
250         if (equalLettersIgnoringASCIICase(type, "text/plain"))
251             return TextPlain;
252         if (equalLettersIgnoringASCIICase(type, "multipart/form-data"))
253             return MultipartFormData;
254         return FormURLEncoded;
255     }
256
257 private:
258     FormData();
259     FormData(const FormData&);
260
261     void appendKeyValuePairItems(const FormDataList&, const TextEncoding&, bool isMultiPartForm, Document*, EncodingType = FormURLEncoded);
262
263     bool hasGeneratedFiles() const;
264     bool hasOwnedGeneratedFiles() const;
265
266     Vector<FormDataElement> m_elements;
267
268     int64_t m_identifier { 0 };
269     bool m_alwaysStream { false };
270     Vector<char> m_boundary;
271     bool m_containsPasswordData { false };
272 };
273
274 inline bool operator==(const FormData& a, const FormData& b)
275 {
276     return a.elements() == b.elements();
277 }
278
279 inline bool operator!=(const FormData& a, const FormData& b)
280 {
281     return !(a == b);
282 }
283
284 template<typename Encoder>
285 void FormData::encode(Encoder& encoder) const
286 {
287     encoder << m_alwaysStream;
288     encoder << m_boundary;
289     encoder << m_elements;
290     encoder << m_identifier;
291 }
292
293 template<typename Decoder>
294 RefPtr<FormData> FormData::decode(Decoder& decoder)
295 {
296     RefPtr<FormData> data = FormData::create();
297
298     if (!decoder.decode(data->m_alwaysStream))
299         return nullptr;
300
301     if (!decoder.decode(data->m_boundary))
302         return nullptr;
303
304     if (!decoder.decode(data->m_elements))
305         return nullptr;
306
307     if (!decoder.decode(data->m_identifier))
308         return nullptr;
309
310     return data;
311 }
312
313 } // namespace WebCore
314
315 #endif