f4658a9e1470dd7dad291af96b2e35aa5ece63ef
[WebKit-https.git] / Source / WebKit2 / Platform / CoreIPC / ArgumentCoders.h
1 /*
2  * Copyright (C) 2010 Apple Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  * 1. Redistributions of source code must retain the above copyright
8  *    notice, this list of conditions and the following disclaimer.
9  * 2. Redistributions in binary form must reproduce the above copyright
10  *    notice, this list of conditions and the following disclaimer in the
11  *    documentation and/or other materials provided with the distribution.
12  *
13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
14  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
15  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
17  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
18  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
19  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
20  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
21  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
22  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
23  * THE POSSIBILITY OF SUCH DAMAGE.
24  */
25
26 #ifndef SimpleArgumentCoder_h
27 #define SimpleArgumentCoder_h
28
29 #include "ArgumentDecoder.h"
30 #include "ArgumentEncoder.h"
31 #include <utility>
32 #include <wtf/Forward.h>
33 #include <wtf/HashMap.h>
34 #include <wtf/TypeTraits.h>
35 #include <wtf/Vector.h>
36
37 namespace CoreIPC {
38
39 // An argument coder works on POD types
40 template<typename T> struct SimpleArgumentCoder {
41     static void encode(ArgumentEncoder& encoder, const T& t)
42     {
43         encoder.encodeFixedLengthData(reinterpret_cast<const uint8_t*>(&t), sizeof(T), __alignof(T));
44     }
45
46     static bool decode(ArgumentDecoder* decoder, T& t)
47     {
48         return decoder->decodeFixedLengthData(reinterpret_cast<uint8_t*>(&t), sizeof(T), __alignof(T));
49     }
50 };
51
52 template<typename T, typename U> struct ArgumentCoder<std::pair<T, U> > {
53     static void encode(ArgumentEncoder& encoder, const std::pair<T, U>& pair)
54     {
55         encoder << pair.first << pair.second;
56     }
57
58     static bool decode(ArgumentDecoder* decoder, std::pair<T, U>& pair)
59     {
60         T first;
61         if (!decoder->decode(first))
62             return false;
63
64         U second;
65         if (!decoder->decode(second))
66             return false;
67
68         pair.first = first;
69         pair.second = second;
70         return true;
71     }
72 };
73
74 template<typename KeyType, typename ValueType> struct ArgumentCoder<WTF::KeyValuePair<KeyType, ValueType> > {
75     static void encode(ArgumentEncoder& encoder, const WTF::KeyValuePair<KeyType, ValueType>& pair)
76     {
77         encoder << pair.key << pair.value;
78     }
79
80     static bool decode(ArgumentDecoder* decoder, WTF::KeyValuePair<KeyType, ValueType>& pair)
81     {
82         KeyType key;
83         if (!decoder->decode(key))
84             return false;
85
86         ValueType value;
87         if (!decoder->decode(value))
88             return false;
89
90         pair.key = key;
91         pair.value = value;
92         return true;
93     }
94 };
95
96 template<bool fixedSizeElements, typename T> struct VectorArgumentCoder;
97
98 template<typename T> struct VectorArgumentCoder<false, T> {
99     static void encode(ArgumentEncoder& encoder, const Vector<T>& vector)
100     {
101         encoder << static_cast<uint64_t>(vector.size());
102         for (size_t i = 0; i < vector.size(); ++i)
103             encoder << vector[i];
104     }
105
106     static bool decode(ArgumentDecoder* decoder, Vector<T>& vector)
107     {
108         uint64_t size;
109         if (!decoder->decode(size))
110             return false;
111
112         Vector<T> tmp;
113         for (size_t i = 0; i < size; ++i) {
114             T element;
115             if (!decoder->decode(element))
116                 return false;
117             
118             tmp.append(element);
119         }
120
121         tmp.shrinkToFit();
122         vector.swap(tmp);
123         return true;
124     }
125 };
126
127 template<typename T> struct VectorArgumentCoder<true, T> {
128     static void encode(ArgumentEncoder& encoder, const Vector<T>& vector)
129     {
130         encoder << static_cast<uint64_t>(vector.size());
131         encoder.encodeFixedLengthData(reinterpret_cast<const uint8_t*>(vector.data()), vector.size() * sizeof(T), __alignof(T));
132     }
133     
134     static bool decode(ArgumentDecoder* decoder, Vector<T>& vector)
135     {
136         uint64_t size;
137         if (!decoder->decode(size))
138             return false;
139
140         // Since we know the total size of the elements, we can allocate the vector in
141         // one fell swoop. Before allocating we must however make sure that the decoder buffer
142         // is big enough.
143         if (!decoder->bufferIsLargeEnoughToContain<T>(size)) {
144             decoder->markInvalid();
145             return false;
146         }
147
148         Vector<T> temp;
149         temp.resize(size);
150
151         decoder->decodeFixedLengthData(reinterpret_cast<uint8_t*>(temp.data()), size * sizeof(T), __alignof(T));
152
153         vector.swap(temp);
154         return true;
155     }
156 };
157
158 template<typename T> struct ArgumentCoder<Vector<T> > : VectorArgumentCoder<WTF::IsArithmetic<T>::value, T> { };
159
160 template<typename KeyArg, typename MappedArg, typename HashArg, typename KeyTraitsArg, typename MappedTraitsArg> struct ArgumentCoder<HashMap<KeyArg, MappedArg, HashArg, KeyTraitsArg, MappedTraitsArg> > {
161     typedef HashMap<KeyArg, MappedArg, HashArg, KeyTraitsArg, MappedTraitsArg> HashMapType;
162
163     static void encode(ArgumentEncoder& encoder, const HashMapType& hashMap)
164     {
165         encoder << static_cast<uint64_t>(hashMap.size());
166         for (typename HashMapType::const_iterator it = hashMap.begin(), end = hashMap.end(); it != end; ++it)
167             encoder << *it;
168     }
169
170     static bool decode(ArgumentDecoder* decoder, HashMapType& hashMap)
171     {
172         uint64_t hashMapSize;
173         if (!decoder->decode(hashMapSize))
174             return false;
175
176         HashMapType tempHashMap;
177         for (uint64_t i = 0; i < hashMapSize; ++i) {
178             KeyArg key;
179             MappedArg value;
180             if (!decoder->decode(key))
181                 return false;
182             if (!decoder->decode(value))
183                 return false;
184
185             if (!tempHashMap.add(key, value).isNewEntry) {
186                 // The hash map already has the specified key, bail.
187                 decoder->markInvalid();
188                 return false;
189             }
190         }
191
192         hashMap.swap(tempHashMap);
193         return true;
194     }
195 };
196
197 template<> struct ArgumentCoder<AtomicString> {
198     static void encode(ArgumentEncoder&, const AtomicString&);
199     static bool decode(ArgumentDecoder*, AtomicString&);
200 };
201
202 template<> struct ArgumentCoder<CString> {
203     static void encode(ArgumentEncoder&, const CString&);
204     static bool decode(ArgumentDecoder*, CString&);
205 };
206
207 template<> struct ArgumentCoder<String> {
208     static void encode(ArgumentEncoder&, const String&);
209     static bool decode(ArgumentDecoder*, String&);
210 };
211
212 } // namespace CoreIPC
213
214 #endif // ArgumentCoders_h