2011-06-14 Anders Carlsson <andersca@apple.com>
[WebKit-https.git] / Source / WebKit2 / Platform / CoreIPC / ArgumentCoders.cpp
1 /*
2  * Copyright (C) 2011 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 #include "config.h"
27 #include "ArgumentCoders.h"
28
29 #include <wtf/text/CString.h>
30 #include <wtf/text/WTFString.h>
31
32 namespace CoreIPC {
33
34 void ArgumentCoder<AtomicString>::encode(ArgumentEncoder* encoder, const AtomicString& atomicString)
35 {
36     encoder->encode(atomicString.string());
37 }
38
39 bool ArgumentCoder<AtomicString>::decode(ArgumentDecoder* decoder, AtomicString& atomicString)
40 {
41     String string;
42     if (!decoder->decode(string))
43         return false;
44
45     atomicString = string;
46     return true;
47 }
48
49 void ArgumentCoder<CString>::encode(ArgumentEncoder* encoder, const CString& string)
50 {
51     // Special case the null string.
52     if (string.isNull()) {
53         encoder->encodeUInt32(std::numeric_limits<uint32_t>::max());
54         return;
55     }
56
57     uint32_t length = string.length();
58     encoder->encode(length);
59     encoder->encodeBytes(reinterpret_cast<const uint8_t*>(string.data()), length);
60 }
61
62 bool ArgumentCoder<CString>::decode(ArgumentDecoder* decoder, CString& result)
63 {
64     uint32_t length;
65     if (!decoder->decode(length))
66         return false;
67
68     if (length == std::numeric_limits<uint32_t>::max()) {
69         // This is the null string.
70         result = CString();
71         return true;
72     }
73
74     // Before allocating the string, make sure that the decoder buffer is big enough.
75     if (!decoder->bufferIsLargeEnoughToContain<char>(length)) {
76         decoder->markInvalid();
77         return false;
78     }
79
80     char* buffer;
81     CString string = CString::newUninitialized(length, buffer);
82     if (!decoder->decodeBytes(reinterpret_cast<uint8_t*>(buffer), length))
83         return false;
84
85     result = string;
86     return true;
87 }
88
89
90 void ArgumentCoder<String>::encode(ArgumentEncoder* encoder, const String& string)
91 {
92     // Special case the null string.
93     if (string.isNull()) {
94         encoder->encodeUInt32(std::numeric_limits<uint32_t>::max());
95         return;
96     }
97
98     uint32_t length = string.length();
99     encoder->encode(length);
100     encoder->encodeBytes(reinterpret_cast<const uint8_t*>(string.characters()), length * sizeof(UChar));
101 }
102
103 bool ArgumentCoder<String>::decode(ArgumentDecoder* decoder, String& result)
104 {
105     uint32_t length;
106     if (!decoder->decode(length))
107         return false;
108
109     if (length == std::numeric_limits<uint32_t>::max()) {
110         // This is the null string.
111         result = String();
112         return true;
113     }
114
115     // Before allocating the string, make sure that the decoder buffer is big enough.
116     if (!decoder->bufferIsLargeEnoughToContain<UChar>(length)) {
117         decoder->markInvalid();
118         return false;
119     }
120     
121     UChar* buffer;
122     String string = String::createUninitialized(length, buffer);
123     if (!decoder->decodeBytes(reinterpret_cast<uint8_t*>(buffer), length * sizeof(UChar)))
124         return false;
125     
126     result = string;
127     return true;
128 }
129
130 } // namespace CoreIPC