OLD | NEW |
1 // Copyright 2014 The Chromium Authors. All rights reserved. | 1 // Copyright 2014 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "mojo/system/shared_buffer_dispatcher.h" | 5 #include "mojo/system/shared_buffer_dispatcher.h" |
6 | 6 |
7 #include <limits> | 7 #include <limits> |
8 | 8 |
9 #include "base/macros.h" | 9 #include "base/macros.h" |
10 #include "base/memory/ref_counted.h" | 10 #include "base/memory/ref_counted.h" |
(...skipping 82 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
93 kSizeOfCreateOptions, // |struct_size|. | 93 kSizeOfCreateOptions, // |struct_size|. |
94 ~0u // |flags|. | 94 ~0u // |flags|. |
95 }; | 95 }; |
96 MojoCreateSharedBufferOptions unused; | 96 MojoCreateSharedBufferOptions unused; |
97 EXPECT_EQ(MOJO_RESULT_UNIMPLEMENTED, | 97 EXPECT_EQ(MOJO_RESULT_UNIMPLEMENTED, |
98 SharedBufferDispatcher::ValidateCreateOptions(&options, &unused)); | 98 SharedBufferDispatcher::ValidateCreateOptions(&options, &unused)); |
99 } | 99 } |
100 } | 100 } |
101 | 101 |
102 TEST(SharedBufferDispatcherTest, CreateAndMapBuffer) { | 102 TEST(SharedBufferDispatcherTest, CreateAndMapBuffer) { |
103 MojoCreateSharedBufferOptions validated_options = {}; | |
104 EXPECT_EQ(MOJO_RESULT_OK, | |
105 SharedBufferDispatcher::ValidateCreateOptions(NULL, | |
106 &validated_options)); | |
107 | |
108 scoped_refptr<SharedBufferDispatcher> dispatcher; | 103 scoped_refptr<SharedBufferDispatcher> dispatcher; |
109 EXPECT_EQ(MOJO_RESULT_OK, | 104 EXPECT_EQ(MOJO_RESULT_OK, |
110 SharedBufferDispatcher::Create(validated_options, 100, | 105 SharedBufferDispatcher::Create( |
111 &dispatcher)); | 106 SharedBufferDispatcher::kDefaultCreateOptions, 100, |
| 107 &dispatcher)); |
112 ASSERT_TRUE(dispatcher); | 108 ASSERT_TRUE(dispatcher); |
113 EXPECT_EQ(Dispatcher::kTypeSharedBuffer, dispatcher->GetType()); | 109 EXPECT_EQ(Dispatcher::kTypeSharedBuffer, dispatcher->GetType()); |
114 | 110 |
115 // Make a couple of mappings. | 111 // Make a couple of mappings. |
116 scoped_ptr<RawSharedBufferMapping> mapping1; | 112 scoped_ptr<RawSharedBufferMapping> mapping1; |
117 EXPECT_EQ(MOJO_RESULT_OK, | 113 EXPECT_EQ(MOJO_RESULT_OK, |
118 dispatcher->MapBuffer(0, 100, MOJO_MAP_BUFFER_FLAG_NONE, | 114 dispatcher->MapBuffer(0, 100, MOJO_MAP_BUFFER_FLAG_NONE, |
119 &mapping1)); | 115 &mapping1)); |
120 ASSERT_TRUE(mapping1); | 116 ASSERT_TRUE(mapping1); |
121 ASSERT_TRUE(mapping1->base()); | 117 ASSERT_TRUE(mapping1->base()); |
(...skipping 12 matching lines...) Expand all Loading... |
134 | 130 |
135 EXPECT_EQ(MOJO_RESULT_OK, dispatcher->Close()); | 131 EXPECT_EQ(MOJO_RESULT_OK, dispatcher->Close()); |
136 | 132 |
137 // Check that we can still read/write to mappings after the dispatcher has | 133 // Check that we can still read/write to mappings after the dispatcher has |
138 // gone away. | 134 // gone away. |
139 static_cast<char*>(mapping2->base())[1] = 'y'; | 135 static_cast<char*>(mapping2->base())[1] = 'y'; |
140 EXPECT_EQ('y', static_cast<char*>(mapping1->base())[51]); | 136 EXPECT_EQ('y', static_cast<char*>(mapping1->base())[51]); |
141 } | 137 } |
142 | 138 |
143 TEST(SharedBufferDispatcher, DuplicateBufferHandle) { | 139 TEST(SharedBufferDispatcher, DuplicateBufferHandle) { |
144 MojoCreateSharedBufferOptions validated_options = {}; | |
145 EXPECT_EQ(MOJO_RESULT_OK, | |
146 SharedBufferDispatcher::ValidateCreateOptions(NULL, | |
147 &validated_options)); | |
148 scoped_refptr<SharedBufferDispatcher> dispatcher1; | 140 scoped_refptr<SharedBufferDispatcher> dispatcher1; |
149 EXPECT_EQ(MOJO_RESULT_OK, | 141 EXPECT_EQ(MOJO_RESULT_OK, |
150 SharedBufferDispatcher::Create(validated_options, 100, | 142 SharedBufferDispatcher::Create( |
| 143 SharedBufferDispatcher::kDefaultCreateOptions, 100, |
151 &dispatcher1)); | 144 &dispatcher1)); |
152 | 145 |
153 // Map and write something. | 146 // Map and write something. |
154 scoped_ptr<RawSharedBufferMapping> mapping; | 147 scoped_ptr<RawSharedBufferMapping> mapping; |
155 EXPECT_EQ(MOJO_RESULT_OK, | 148 EXPECT_EQ(MOJO_RESULT_OK, |
156 dispatcher1->MapBuffer(0, 100, MOJO_MAP_BUFFER_FLAG_NONE, | 149 dispatcher1->MapBuffer(0, 100, MOJO_MAP_BUFFER_FLAG_NONE, |
157 &mapping)); | 150 &mapping)); |
158 static_cast<char*>(mapping->base())[0] = 'x'; | 151 static_cast<char*>(mapping->base())[0] = 'x'; |
159 mapping.reset(); | 152 mapping.reset(); |
160 | 153 |
161 // Duplicate |dispatcher1| and then close it. | 154 // Duplicate |dispatcher1| and then close it. |
162 scoped_refptr<Dispatcher> dispatcher2; | 155 scoped_refptr<Dispatcher> dispatcher2; |
163 EXPECT_EQ(MOJO_RESULT_OK, | 156 EXPECT_EQ(MOJO_RESULT_OK, |
164 dispatcher1->DuplicateBufferHandle(NULL, &dispatcher2)); | 157 dispatcher1->DuplicateBufferHandle(NULL, &dispatcher2)); |
165 ASSERT_TRUE(dispatcher2); | 158 ASSERT_TRUE(dispatcher2); |
166 EXPECT_EQ(Dispatcher::kTypeSharedBuffer, dispatcher2->GetType()); | 159 EXPECT_EQ(Dispatcher::kTypeSharedBuffer, dispatcher2->GetType()); |
167 | 160 |
168 EXPECT_EQ(MOJO_RESULT_OK, dispatcher1->Close()); | 161 EXPECT_EQ(MOJO_RESULT_OK, dispatcher1->Close()); |
169 | 162 |
170 // Map |dispatcher2| and read something. | 163 // Map |dispatcher2| and read something. |
171 EXPECT_EQ(MOJO_RESULT_OK, | 164 EXPECT_EQ(MOJO_RESULT_OK, |
172 dispatcher2->MapBuffer(0, 100, MOJO_MAP_BUFFER_FLAG_NONE, | 165 dispatcher2->MapBuffer(0, 100, MOJO_MAP_BUFFER_FLAG_NONE, |
173 &mapping)); | 166 &mapping)); |
174 EXPECT_EQ('x', static_cast<char*>(mapping->base())[0]); | 167 EXPECT_EQ('x', static_cast<char*>(mapping->base())[0]); |
175 | 168 |
176 EXPECT_EQ(MOJO_RESULT_OK, dispatcher2->Close()); | 169 EXPECT_EQ(MOJO_RESULT_OK, dispatcher2->Close()); |
177 } | 170 } |
178 | 171 |
179 TEST(SharedBufferDispatcherTest, DuplicateBufferHandleOptionsValid) { | 172 TEST(SharedBufferDispatcherTest, DuplicateBufferHandleOptionsValid) { |
180 MojoCreateSharedBufferOptions validated_options = {}; | |
181 EXPECT_EQ(MOJO_RESULT_OK, | |
182 SharedBufferDispatcher::ValidateCreateOptions(NULL, | |
183 &validated_options)); | |
184 scoped_refptr<SharedBufferDispatcher> dispatcher1; | 173 scoped_refptr<SharedBufferDispatcher> dispatcher1; |
185 EXPECT_EQ(MOJO_RESULT_OK, | 174 EXPECT_EQ(MOJO_RESULT_OK, |
186 SharedBufferDispatcher::Create(validated_options, 100, | 175 SharedBufferDispatcher::Create( |
187 &dispatcher1)); | 176 SharedBufferDispatcher::kDefaultCreateOptions, 100, |
| 177 &dispatcher1)); |
188 | 178 |
189 MojoDuplicateBufferHandleOptions options[] = { | 179 MojoDuplicateBufferHandleOptions options[] = { |
190 {sizeof(MojoDuplicateBufferHandleOptions), | 180 {sizeof(MojoDuplicateBufferHandleOptions), |
191 MOJO_DUPLICATE_BUFFER_HANDLE_OPTIONS_FLAG_NONE}, | 181 MOJO_DUPLICATE_BUFFER_HANDLE_OPTIONS_FLAG_NONE}, |
192 {sizeof(MojoDuplicateBufferHandleOptionsFlags), ~0} | 182 {sizeof(MojoDuplicateBufferHandleOptionsFlags), ~0} |
193 }; | 183 }; |
194 for (size_t i = 0; i < arraysize(options); i++) { | 184 for (size_t i = 0; i < arraysize(options); i++) { |
195 scoped_refptr<Dispatcher> dispatcher2; | 185 scoped_refptr<Dispatcher> dispatcher2; |
196 EXPECT_EQ(MOJO_RESULT_OK, | 186 EXPECT_EQ(MOJO_RESULT_OK, |
197 dispatcher1->DuplicateBufferHandle(&options[i], &dispatcher2)); | 187 dispatcher1->DuplicateBufferHandle(&options[i], &dispatcher2)); |
198 ASSERT_TRUE(dispatcher2); | 188 ASSERT_TRUE(dispatcher2); |
199 EXPECT_EQ(Dispatcher::kTypeSharedBuffer, dispatcher2->GetType()); | 189 EXPECT_EQ(Dispatcher::kTypeSharedBuffer, dispatcher2->GetType()); |
200 EXPECT_EQ(MOJO_RESULT_OK, dispatcher2->Close()); | 190 EXPECT_EQ(MOJO_RESULT_OK, dispatcher2->Close()); |
201 } | 191 } |
202 | 192 |
203 EXPECT_EQ(MOJO_RESULT_OK, dispatcher1->Close()); | 193 EXPECT_EQ(MOJO_RESULT_OK, dispatcher1->Close()); |
204 } | 194 } |
205 | 195 |
206 TEST(SharedBufferDispatcherTest, DuplicateBufferHandleOptionsInvalid) { | 196 TEST(SharedBufferDispatcherTest, DuplicateBufferHandleOptionsInvalid) { |
207 MojoCreateSharedBufferOptions validated_options = {}; | |
208 EXPECT_EQ(MOJO_RESULT_OK, | |
209 SharedBufferDispatcher::ValidateCreateOptions(NULL, | |
210 &validated_options)); | |
211 scoped_refptr<SharedBufferDispatcher> dispatcher1; | 197 scoped_refptr<SharedBufferDispatcher> dispatcher1; |
212 EXPECT_EQ(MOJO_RESULT_OK, | 198 EXPECT_EQ(MOJO_RESULT_OK, |
213 SharedBufferDispatcher::Create(validated_options, 100, | 199 SharedBufferDispatcher::Create( |
214 &dispatcher1)); | 200 SharedBufferDispatcher::kDefaultCreateOptions, 100, |
| 201 &dispatcher1)); |
215 | 202 |
216 // Invalid |struct_size|. | 203 // Invalid |struct_size|. |
217 { | 204 { |
218 MojoDuplicateBufferHandleOptions options = { | 205 MojoDuplicateBufferHandleOptions options = { |
219 1u, MOJO_DUPLICATE_BUFFER_HANDLE_OPTIONS_FLAG_NONE | 206 1u, MOJO_DUPLICATE_BUFFER_HANDLE_OPTIONS_FLAG_NONE |
220 }; | 207 }; |
221 scoped_refptr<Dispatcher> dispatcher2; | 208 scoped_refptr<Dispatcher> dispatcher2; |
222 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, | 209 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, |
223 dispatcher1->DuplicateBufferHandle(&options, &dispatcher2)); | 210 dispatcher1->DuplicateBufferHandle(&options, &dispatcher2)); |
224 EXPECT_FALSE(dispatcher2); | 211 EXPECT_FALSE(dispatcher2); |
225 } | 212 } |
226 | 213 |
227 // Unknown |flags|. | 214 // Unknown |flags|. |
228 { | 215 { |
229 MojoDuplicateBufferHandleOptions options = { | 216 MojoDuplicateBufferHandleOptions options = { |
230 static_cast<uint32_t>(sizeof(MojoDuplicateBufferHandleOptions)), ~0u | 217 static_cast<uint32_t>(sizeof(MojoDuplicateBufferHandleOptions)), ~0u |
231 }; | 218 }; |
232 scoped_refptr<Dispatcher> dispatcher2; | 219 scoped_refptr<Dispatcher> dispatcher2; |
233 EXPECT_EQ(MOJO_RESULT_UNIMPLEMENTED, | 220 EXPECT_EQ(MOJO_RESULT_UNIMPLEMENTED, |
234 dispatcher1->DuplicateBufferHandle(&options, &dispatcher2)); | 221 dispatcher1->DuplicateBufferHandle(&options, &dispatcher2)); |
235 EXPECT_FALSE(dispatcher2); | 222 EXPECT_FALSE(dispatcher2); |
236 } | 223 } |
237 | 224 |
238 EXPECT_EQ(MOJO_RESULT_OK, dispatcher1->Close()); | 225 EXPECT_EQ(MOJO_RESULT_OK, dispatcher1->Close()); |
239 } | 226 } |
240 | 227 |
241 TEST(SharedBufferDispatcherTest, CreateInvalidNumBytes) { | 228 TEST(SharedBufferDispatcherTest, CreateInvalidNumBytes) { |
242 MojoCreateSharedBufferOptions validated_options = {}; | |
243 EXPECT_EQ(MOJO_RESULT_OK, | |
244 SharedBufferDispatcher::ValidateCreateOptions(NULL, | |
245 &validated_options)); | |
246 | |
247 // Size too big. | 229 // Size too big. |
248 scoped_refptr<SharedBufferDispatcher> dispatcher; | 230 scoped_refptr<SharedBufferDispatcher> dispatcher; |
249 EXPECT_EQ(MOJO_RESULT_RESOURCE_EXHAUSTED, | 231 EXPECT_EQ(MOJO_RESULT_RESOURCE_EXHAUSTED, |
250 SharedBufferDispatcher::Create(validated_options, | 232 SharedBufferDispatcher::Create( |
251 std::numeric_limits<uint64_t>::max(), | 233 SharedBufferDispatcher::kDefaultCreateOptions, |
252 &dispatcher)); | 234 std::numeric_limits<uint64_t>::max(), &dispatcher)); |
253 EXPECT_FALSE(dispatcher); | 235 EXPECT_FALSE(dispatcher); |
254 | 236 |
255 // Zero size. | 237 // Zero size. |
256 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, | 238 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, |
257 SharedBufferDispatcher::Create(validated_options, 0, &dispatcher)); | 239 SharedBufferDispatcher::Create( |
| 240 SharedBufferDispatcher::kDefaultCreateOptions, 0, &dispatcher)); |
258 EXPECT_FALSE(dispatcher); | 241 EXPECT_FALSE(dispatcher); |
259 } | 242 } |
260 | 243 |
261 TEST(SharedBufferDispatcherTest, MapBufferInvalidArguments) { | 244 TEST(SharedBufferDispatcherTest, MapBufferInvalidArguments) { |
262 MojoCreateSharedBufferOptions validated_options = {}; | |
263 EXPECT_EQ(MOJO_RESULT_OK, | |
264 SharedBufferDispatcher::ValidateCreateOptions(NULL, | |
265 &validated_options)); | |
266 | |
267 scoped_refptr<SharedBufferDispatcher> dispatcher; | 245 scoped_refptr<SharedBufferDispatcher> dispatcher; |
268 EXPECT_EQ(MOJO_RESULT_OK, | 246 EXPECT_EQ(MOJO_RESULT_OK, |
269 SharedBufferDispatcher::Create(validated_options, 100, | 247 SharedBufferDispatcher::Create( |
270 &dispatcher)); | 248 SharedBufferDispatcher::kDefaultCreateOptions, 100, |
| 249 &dispatcher)); |
271 | 250 |
272 scoped_ptr<RawSharedBufferMapping> mapping; | 251 scoped_ptr<RawSharedBufferMapping> mapping; |
273 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, | 252 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, |
274 dispatcher->MapBuffer(0, 101, MOJO_MAP_BUFFER_FLAG_NONE, &mapping)); | 253 dispatcher->MapBuffer(0, 101, MOJO_MAP_BUFFER_FLAG_NONE, &mapping)); |
275 EXPECT_FALSE(mapping); | 254 EXPECT_FALSE(mapping); |
276 | 255 |
277 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, | 256 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, |
278 dispatcher->MapBuffer(1, 100, MOJO_MAP_BUFFER_FLAG_NONE, &mapping)); | 257 dispatcher->MapBuffer(1, 100, MOJO_MAP_BUFFER_FLAG_NONE, &mapping)); |
279 EXPECT_FALSE(mapping); | 258 EXPECT_FALSE(mapping); |
280 | 259 |
281 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, | 260 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, |
282 dispatcher->MapBuffer(0, 0, MOJO_MAP_BUFFER_FLAG_NONE, &mapping)); | 261 dispatcher->MapBuffer(0, 0, MOJO_MAP_BUFFER_FLAG_NONE, &mapping)); |
283 EXPECT_FALSE(mapping); | 262 EXPECT_FALSE(mapping); |
284 | 263 |
285 EXPECT_EQ(MOJO_RESULT_OK, dispatcher->Close()); | 264 EXPECT_EQ(MOJO_RESULT_OK, dispatcher->Close()); |
286 } | 265 } |
287 | 266 |
288 } // namespace | 267 } // namespace |
289 } // namespace system | 268 } // namespace system |
290 } // namespace mojo | 269 } // namespace mojo |
OLD | NEW |