78ceb85c6471a40561b36c65404093747d2d143d
[WebKit-https.git] / Source / WebKit2 / Platform / CoreIPC / ArgumentEncoder.cpp
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 #include "config.h"
27 #include "ArgumentEncoder.h"
28
29 #include "DataReference.h"
30 #include <algorithm>
31 #include <stdio.h>
32
33 namespace CoreIPC {
34
35 PassOwnPtr<ArgumentEncoder> ArgumentEncoder::create()
36 {
37     return adoptPtr(new ArgumentEncoder);
38 }
39
40 ArgumentEncoder::ArgumentEncoder()
41     : m_buffer(0)
42     , m_bufferSize(0)
43     , m_bufferCapacity(inlineBufferSize)
44 {
45 }
46
47 ArgumentEncoder::~ArgumentEncoder()
48 {
49     if (m_buffer)
50         free(m_buffer);
51 #if !USE(UNIX_DOMAIN_SOCKETS)
52     // FIXME: We need to dispose of the attachments in cases of failure.
53 #else
54     for (size_t i = 0; i < m_attachments.size(); ++i)
55         m_attachments[i].dispose();
56 #endif
57 }
58
59 static inline size_t roundUpToAlignment(size_t value, unsigned alignment)
60 {
61     return ((value + alignment - 1) / alignment) * alignment;
62 }
63
64 uint8_t* ArgumentEncoder::grow(unsigned alignment, size_t size)
65 {
66     size_t alignedSize = roundUpToAlignment(m_bufferSize, alignment);
67     
68     if (alignedSize + size > m_bufferCapacity) {
69         size_t newCapacity = std::max(alignedSize + size, std::max(static_cast<size_t>(32), m_bufferCapacity + m_bufferCapacity / 4 + 1));
70
71         if (newCapacity > inlineBufferSize) {
72             // Use system malloc / realloc instead of fastMalloc due to
73             // fastMalloc using MADV_FREE_REUSABLE which doesn't work with
74             // mach messages with OOL message and MACH_MSG_VIRTUAL_COPY.
75             // System malloc also calls madvise(MADV_FREE_REUSABLE) but after first
76             // checking via madvise(CAN_REUSE) that it will succeed. Should this
77             // behavior change we'll need to revisit this.
78             if (!m_buffer)
79                 m_buffer = static_cast<uint8_t*>(malloc(newCapacity));
80             else
81                 m_buffer = static_cast<uint8_t*>(realloc(m_buffer, newCapacity));
82
83             if (!m_buffer)
84                 CRASH();
85
86             if (usesInlineBuffer())
87                 memcpy(m_buffer, m_inlineBuffer, m_bufferCapacity);
88         }
89
90         m_bufferCapacity = newCapacity;        
91     }
92
93     m_bufferSize = alignedSize + size;
94     return buffer() + alignedSize;
95 }
96
97 void ArgumentEncoder::encodeFixedLengthData(const uint8_t* data, size_t size, unsigned alignment)
98 {
99     ASSERT(!(reinterpret_cast<uintptr_t>(data) % alignment));
100
101     uint8_t* buffer = grow(alignment, size);
102     memcpy(buffer, data, size);
103 }
104
105 void ArgumentEncoder::encodeVariableLengthByteArray(const DataReference& dataReference)
106 {
107     encode(static_cast<uint64_t>(dataReference.size()));
108     encodeFixedLengthData(dataReference.data(), dataReference.size(), 1);
109 }
110
111 void ArgumentEncoder::encode(bool n)
112 {
113     uint8_t* buffer = grow(sizeof(n), sizeof(n));
114     
115     *reinterpret_cast<bool*>(buffer) = n;
116 }
117
118 void ArgumentEncoder::encode(uint8_t n)
119 {
120     uint8_t* buffer = grow(sizeof(n), sizeof(n));
121
122     *reinterpret_cast<uint8_t*>(buffer) = n;
123 }
124
125 void ArgumentEncoder::encode(uint16_t n)
126 {
127     uint8_t* buffer = grow(sizeof(n), sizeof(n));
128
129     *reinterpret_cast<uint16_t*>(buffer) = n;
130 }
131
132 void ArgumentEncoder::encode(uint32_t n)
133 {
134     uint8_t* buffer = grow(sizeof(n), sizeof(n));
135     
136     *reinterpret_cast<uint32_t*>(buffer) = n;
137 }
138
139 void ArgumentEncoder::encode(uint64_t n)
140 {
141     uint8_t* buffer = grow(sizeof(n), sizeof(n));
142     
143     *reinterpret_cast<uint64_t*>(buffer) = n;
144 }
145
146 void ArgumentEncoder::encode(int32_t n)
147 {
148     uint8_t* buffer = grow(sizeof(n), sizeof(n));
149     
150     *reinterpret_cast<int32_t*>(buffer) = n;
151 }
152
153 void ArgumentEncoder::encode(int64_t n)
154 {
155     uint8_t* buffer = grow(sizeof(n), sizeof(n));
156     
157     *reinterpret_cast<int64_t*>(buffer) = n;
158 }
159
160 void ArgumentEncoder::encode(float n)
161 {
162     uint8_t* buffer = grow(sizeof(n), sizeof(n));
163
164     *reinterpret_cast<float*>(buffer) = n;
165 }
166
167 void ArgumentEncoder::encode(double n)
168 {
169     uint8_t* buffer = grow(sizeof(n), sizeof(n));
170
171     *reinterpret_cast<double*>(buffer) = n;
172 }
173
174 void ArgumentEncoder::addAttachment(const Attachment& attachment)
175 {
176     m_attachments.append(attachment);
177 }
178
179 Vector<Attachment> ArgumentEncoder::releaseAttachments()
180 {
181     Vector<Attachment> newList;
182     newList.swap(m_attachments);
183     return newList;
184 }
185
186 } // namespace CoreIPC