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 16 matching lines...) Expand all Loading... |
27 // |ValidateCreateOptions()| on already-validated options. The validated options | 27 // |ValidateCreateOptions()| on already-validated options. The validated options |
28 // should be valid, and the revalidated copy should be the same. | 28 // should be valid, and the revalidated copy should be the same. |
29 void RevalidateCreateOptions( | 29 void RevalidateCreateOptions( |
30 const MojoCreateSharedBufferOptions& validated_options) { | 30 const MojoCreateSharedBufferOptions& validated_options) { |
31 EXPECT_EQ(kSizeOfCreateOptions, validated_options.struct_size); | 31 EXPECT_EQ(kSizeOfCreateOptions, validated_options.struct_size); |
32 // Nothing to check for flags. | 32 // Nothing to check for flags. |
33 | 33 |
34 MojoCreateSharedBufferOptions revalidated_options = {}; | 34 MojoCreateSharedBufferOptions revalidated_options = {}; |
35 EXPECT_EQ(MOJO_RESULT_OK, | 35 EXPECT_EQ(MOJO_RESULT_OK, |
36 SharedBufferDispatcher::ValidateCreateOptions( | 36 SharedBufferDispatcher::ValidateCreateOptions( |
37 &validated_options, &revalidated_options)); | 37 MakeUserPointer(&validated_options), &revalidated_options)); |
38 EXPECT_EQ(validated_options.struct_size, revalidated_options.struct_size); | 38 EXPECT_EQ(validated_options.struct_size, revalidated_options.struct_size); |
39 EXPECT_EQ(validated_options.flags, revalidated_options.flags); | 39 EXPECT_EQ(validated_options.flags, revalidated_options.flags); |
40 } | 40 } |
41 | 41 |
42 // Tests valid inputs to |ValidateCreateOptions()|. | 42 // Tests valid inputs to |ValidateCreateOptions()|. |
43 TEST(SharedBufferDispatcherTest, ValidateCreateOptionsValid) { | 43 TEST(SharedBufferDispatcherTest, ValidateCreateOptionsValid) { |
44 // Default options. | 44 // Default options. |
45 { | 45 { |
46 MojoCreateSharedBufferOptions validated_options = {}; | 46 MojoCreateSharedBufferOptions validated_options = {}; |
47 EXPECT_EQ(MOJO_RESULT_OK, | 47 EXPECT_EQ(MOJO_RESULT_OK, |
48 SharedBufferDispatcher::ValidateCreateOptions( | 48 SharedBufferDispatcher::ValidateCreateOptions( |
49 NULL, &validated_options)); | 49 NullUserPointer(), &validated_options)); |
50 RevalidateCreateOptions(validated_options); | 50 RevalidateCreateOptions(validated_options); |
51 } | 51 } |
52 | 52 |
53 // Different flags. | 53 // Different flags. |
54 MojoCreateSharedBufferOptionsFlags flags_values[] = { | 54 MojoCreateSharedBufferOptionsFlags flags_values[] = { |
55 MOJO_CREATE_SHARED_BUFFER_OPTIONS_FLAG_NONE | 55 MOJO_CREATE_SHARED_BUFFER_OPTIONS_FLAG_NONE |
56 }; | 56 }; |
57 for (size_t i = 0; i < arraysize(flags_values); i++) { | 57 for (size_t i = 0; i < arraysize(flags_values); i++) { |
58 const MojoCreateSharedBufferOptionsFlags flags = flags_values[i]; | 58 const MojoCreateSharedBufferOptionsFlags flags = flags_values[i]; |
59 | 59 |
60 // Different capacities (size 1). | 60 // Different capacities (size 1). |
61 for (uint32_t capacity = 1; capacity <= 100 * 1000 * 1000; capacity *= 10) { | 61 for (uint32_t capacity = 1; capacity <= 100 * 1000 * 1000; capacity *= 10) { |
62 MojoCreateSharedBufferOptions options = { | 62 MojoCreateSharedBufferOptions options = { |
63 kSizeOfCreateOptions, // |struct_size|. | 63 kSizeOfCreateOptions, // |struct_size|. |
64 flags // |flags|. | 64 flags // |flags|. |
65 }; | 65 }; |
66 MojoCreateSharedBufferOptions validated_options = {}; | 66 MojoCreateSharedBufferOptions validated_options = {}; |
67 EXPECT_EQ(MOJO_RESULT_OK, | 67 EXPECT_EQ(MOJO_RESULT_OK, |
68 SharedBufferDispatcher::ValidateCreateOptions( | 68 SharedBufferDispatcher::ValidateCreateOptions( |
69 &options, &validated_options)) | 69 MakeUserPointer(&options), &validated_options)) |
70 << capacity; | 70 << capacity; |
71 RevalidateCreateOptions(validated_options); | 71 RevalidateCreateOptions(validated_options); |
72 EXPECT_EQ(options.flags, validated_options.flags); | 72 EXPECT_EQ(options.flags, validated_options.flags); |
73 } | 73 } |
74 } | 74 } |
75 } | 75 } |
76 | 76 |
77 TEST(SharedBufferDispatcherTest, ValidateCreateOptionsInvalid) { | 77 TEST(SharedBufferDispatcherTest, ValidateCreateOptionsInvalid) { |
78 // Invalid |struct_size|. | 78 // Invalid |struct_size|. |
79 { | 79 { |
80 MojoCreateSharedBufferOptions options = { | 80 MojoCreateSharedBufferOptions options = { |
81 1, // |struct_size|. | 81 1, // |struct_size|. |
82 MOJO_CREATE_SHARED_BUFFER_OPTIONS_FLAG_NONE // |flags|. | 82 MOJO_CREATE_SHARED_BUFFER_OPTIONS_FLAG_NONE // |flags|. |
83 }; | 83 }; |
84 MojoCreateSharedBufferOptions unused; | 84 MojoCreateSharedBufferOptions unused; |
85 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, | 85 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, |
86 SharedBufferDispatcher::ValidateCreateOptions(&options, &unused)); | 86 SharedBufferDispatcher::ValidateCreateOptions( |
| 87 MakeUserPointer(&options), &unused)); |
87 } | 88 } |
88 | 89 |
89 // Unknown |flags|. | 90 // Unknown |flags|. |
90 { | 91 { |
91 MojoCreateSharedBufferOptions options = { | 92 MojoCreateSharedBufferOptions options = { |
92 kSizeOfCreateOptions, // |struct_size|. | 93 kSizeOfCreateOptions, // |struct_size|. |
93 ~0u // |flags|. | 94 ~0u // |flags|. |
94 }; | 95 }; |
95 MojoCreateSharedBufferOptions unused; | 96 MojoCreateSharedBufferOptions unused; |
96 EXPECT_EQ(MOJO_RESULT_UNIMPLEMENTED, | 97 EXPECT_EQ(MOJO_RESULT_UNIMPLEMENTED, |
97 SharedBufferDispatcher::ValidateCreateOptions(&options, &unused)); | 98 SharedBufferDispatcher::ValidateCreateOptions( |
| 99 MakeUserPointer(&options), &unused)); |
98 } | 100 } |
99 } | 101 } |
100 | 102 |
101 TEST(SharedBufferDispatcherTest, CreateAndMapBuffer) { | 103 TEST(SharedBufferDispatcherTest, CreateAndMapBuffer) { |
102 scoped_refptr<SharedBufferDispatcher> dispatcher; | 104 scoped_refptr<SharedBufferDispatcher> dispatcher; |
103 EXPECT_EQ(MOJO_RESULT_OK, | 105 EXPECT_EQ(MOJO_RESULT_OK, |
104 SharedBufferDispatcher::Create( | 106 SharedBufferDispatcher::Create( |
105 SharedBufferDispatcher::kDefaultCreateOptions, 100, | 107 SharedBufferDispatcher::kDefaultCreateOptions, 100, |
106 &dispatcher)); | 108 &dispatcher)); |
107 ASSERT_TRUE(dispatcher); | 109 ASSERT_TRUE(dispatcher); |
(...skipping 38 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
146 scoped_ptr<RawSharedBufferMapping> mapping; | 148 scoped_ptr<RawSharedBufferMapping> mapping; |
147 EXPECT_EQ(MOJO_RESULT_OK, | 149 EXPECT_EQ(MOJO_RESULT_OK, |
148 dispatcher1->MapBuffer(0, 100, MOJO_MAP_BUFFER_FLAG_NONE, | 150 dispatcher1->MapBuffer(0, 100, MOJO_MAP_BUFFER_FLAG_NONE, |
149 &mapping)); | 151 &mapping)); |
150 static_cast<char*>(mapping->base())[0] = 'x'; | 152 static_cast<char*>(mapping->base())[0] = 'x'; |
151 mapping.reset(); | 153 mapping.reset(); |
152 | 154 |
153 // Duplicate |dispatcher1| and then close it. | 155 // Duplicate |dispatcher1| and then close it. |
154 scoped_refptr<Dispatcher> dispatcher2; | 156 scoped_refptr<Dispatcher> dispatcher2; |
155 EXPECT_EQ(MOJO_RESULT_OK, | 157 EXPECT_EQ(MOJO_RESULT_OK, |
156 dispatcher1->DuplicateBufferHandle(NULL, &dispatcher2)); | 158 dispatcher1->DuplicateBufferHandle(NullUserPointer(), |
| 159 &dispatcher2)); |
157 ASSERT_TRUE(dispatcher2); | 160 ASSERT_TRUE(dispatcher2); |
158 EXPECT_EQ(Dispatcher::kTypeSharedBuffer, dispatcher2->GetType()); | 161 EXPECT_EQ(Dispatcher::kTypeSharedBuffer, dispatcher2->GetType()); |
159 | 162 |
160 EXPECT_EQ(MOJO_RESULT_OK, dispatcher1->Close()); | 163 EXPECT_EQ(MOJO_RESULT_OK, dispatcher1->Close()); |
161 | 164 |
162 // Map |dispatcher2| and read something. | 165 // Map |dispatcher2| and read something. |
163 EXPECT_EQ(MOJO_RESULT_OK, | 166 EXPECT_EQ(MOJO_RESULT_OK, |
164 dispatcher2->MapBuffer(0, 100, MOJO_MAP_BUFFER_FLAG_NONE, | 167 dispatcher2->MapBuffer(0, 100, MOJO_MAP_BUFFER_FLAG_NONE, |
165 &mapping)); | 168 &mapping)); |
166 EXPECT_EQ('x', static_cast<char*>(mapping->base())[0]); | 169 EXPECT_EQ('x', static_cast<char*>(mapping->base())[0]); |
167 | 170 |
168 EXPECT_EQ(MOJO_RESULT_OK, dispatcher2->Close()); | 171 EXPECT_EQ(MOJO_RESULT_OK, dispatcher2->Close()); |
169 } | 172 } |
170 | 173 |
171 TEST(SharedBufferDispatcherTest, DuplicateBufferHandleOptionsValid) { | 174 TEST(SharedBufferDispatcherTest, DuplicateBufferHandleOptionsValid) { |
172 scoped_refptr<SharedBufferDispatcher> dispatcher1; | 175 scoped_refptr<SharedBufferDispatcher> dispatcher1; |
173 EXPECT_EQ(MOJO_RESULT_OK, | 176 EXPECT_EQ(MOJO_RESULT_OK, |
174 SharedBufferDispatcher::Create( | 177 SharedBufferDispatcher::Create( |
175 SharedBufferDispatcher::kDefaultCreateOptions, 100, | 178 SharedBufferDispatcher::kDefaultCreateOptions, 100, |
176 &dispatcher1)); | 179 &dispatcher1)); |
177 | 180 |
178 MojoDuplicateBufferHandleOptions options[] = { | 181 MojoDuplicateBufferHandleOptions options[] = { |
179 {sizeof(MojoDuplicateBufferHandleOptions), | 182 {sizeof(MojoDuplicateBufferHandleOptions), |
180 MOJO_DUPLICATE_BUFFER_HANDLE_OPTIONS_FLAG_NONE}, | 183 MOJO_DUPLICATE_BUFFER_HANDLE_OPTIONS_FLAG_NONE}, |
181 {sizeof(MojoDuplicateBufferHandleOptionsFlags), ~0u} | 184 {sizeof(MojoDuplicateBufferHandleOptionsFlags), ~0u} |
182 }; | 185 }; |
183 for (size_t i = 0; i < arraysize(options); i++) { | 186 for (size_t i = 0; i < arraysize(options); i++) { |
184 scoped_refptr<Dispatcher> dispatcher2; | 187 scoped_refptr<Dispatcher> dispatcher2; |
185 EXPECT_EQ(MOJO_RESULT_OK, | 188 EXPECT_EQ(MOJO_RESULT_OK, |
186 dispatcher1->DuplicateBufferHandle(&options[i], &dispatcher2)); | 189 dispatcher1->DuplicateBufferHandle(MakeUserPointer(&options[i]), |
| 190 &dispatcher2)); |
187 ASSERT_TRUE(dispatcher2); | 191 ASSERT_TRUE(dispatcher2); |
188 EXPECT_EQ(Dispatcher::kTypeSharedBuffer, dispatcher2->GetType()); | 192 EXPECT_EQ(Dispatcher::kTypeSharedBuffer, dispatcher2->GetType()); |
189 EXPECT_EQ(MOJO_RESULT_OK, dispatcher2->Close()); | 193 EXPECT_EQ(MOJO_RESULT_OK, dispatcher2->Close()); |
190 } | 194 } |
191 | 195 |
192 EXPECT_EQ(MOJO_RESULT_OK, dispatcher1->Close()); | 196 EXPECT_EQ(MOJO_RESULT_OK, dispatcher1->Close()); |
193 } | 197 } |
194 | 198 |
195 TEST(SharedBufferDispatcherTest, DuplicateBufferHandleOptionsInvalid) { | 199 TEST(SharedBufferDispatcherTest, DuplicateBufferHandleOptionsInvalid) { |
196 scoped_refptr<SharedBufferDispatcher> dispatcher1; | 200 scoped_refptr<SharedBufferDispatcher> dispatcher1; |
197 EXPECT_EQ(MOJO_RESULT_OK, | 201 EXPECT_EQ(MOJO_RESULT_OK, |
198 SharedBufferDispatcher::Create( | 202 SharedBufferDispatcher::Create( |
199 SharedBufferDispatcher::kDefaultCreateOptions, 100, | 203 SharedBufferDispatcher::kDefaultCreateOptions, 100, |
200 &dispatcher1)); | 204 &dispatcher1)); |
201 | 205 |
202 // Invalid |struct_size|. | 206 // Invalid |struct_size|. |
203 { | 207 { |
204 MojoDuplicateBufferHandleOptions options = { | 208 MojoDuplicateBufferHandleOptions options = { |
205 1u, MOJO_DUPLICATE_BUFFER_HANDLE_OPTIONS_FLAG_NONE | 209 1u, MOJO_DUPLICATE_BUFFER_HANDLE_OPTIONS_FLAG_NONE |
206 }; | 210 }; |
207 scoped_refptr<Dispatcher> dispatcher2; | 211 scoped_refptr<Dispatcher> dispatcher2; |
208 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, | 212 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, |
209 dispatcher1->DuplicateBufferHandle(&options, &dispatcher2)); | 213 dispatcher1->DuplicateBufferHandle(MakeUserPointer(&options), |
| 214 &dispatcher2)); |
210 EXPECT_FALSE(dispatcher2); | 215 EXPECT_FALSE(dispatcher2); |
211 } | 216 } |
212 | 217 |
213 // Unknown |flags|. | 218 // Unknown |flags|. |
214 { | 219 { |
215 MojoDuplicateBufferHandleOptions options = { | 220 MojoDuplicateBufferHandleOptions options = { |
216 sizeof(MojoDuplicateBufferHandleOptions), ~0u | 221 sizeof(MojoDuplicateBufferHandleOptions), ~0u |
217 }; | 222 }; |
218 scoped_refptr<Dispatcher> dispatcher2; | 223 scoped_refptr<Dispatcher> dispatcher2; |
219 EXPECT_EQ(MOJO_RESULT_UNIMPLEMENTED, | 224 EXPECT_EQ(MOJO_RESULT_UNIMPLEMENTED, |
220 dispatcher1->DuplicateBufferHandle(&options, &dispatcher2)); | 225 dispatcher1->DuplicateBufferHandle(MakeUserPointer(&options), |
| 226 &dispatcher2)); |
221 EXPECT_FALSE(dispatcher2); | 227 EXPECT_FALSE(dispatcher2); |
222 } | 228 } |
223 | 229 |
224 EXPECT_EQ(MOJO_RESULT_OK, dispatcher1->Close()); | 230 EXPECT_EQ(MOJO_RESULT_OK, dispatcher1->Close()); |
225 } | 231 } |
226 | 232 |
227 TEST(SharedBufferDispatcherTest, CreateInvalidNumBytes) { | 233 TEST(SharedBufferDispatcherTest, CreateInvalidNumBytes) { |
228 // Size too big. | 234 // Size too big. |
229 scoped_refptr<SharedBufferDispatcher> dispatcher; | 235 scoped_refptr<SharedBufferDispatcher> dispatcher; |
230 EXPECT_EQ(MOJO_RESULT_RESOURCE_EXHAUSTED, | 236 EXPECT_EQ(MOJO_RESULT_RESOURCE_EXHAUSTED, |
(...skipping 28 matching lines...) Expand all Loading... |
259 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, | 265 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, |
260 dispatcher->MapBuffer(0, 0, MOJO_MAP_BUFFER_FLAG_NONE, &mapping)); | 266 dispatcher->MapBuffer(0, 0, MOJO_MAP_BUFFER_FLAG_NONE, &mapping)); |
261 EXPECT_FALSE(mapping); | 267 EXPECT_FALSE(mapping); |
262 | 268 |
263 EXPECT_EQ(MOJO_RESULT_OK, dispatcher->Close()); | 269 EXPECT_EQ(MOJO_RESULT_OK, dispatcher->Close()); |
264 } | 270 } |
265 | 271 |
266 } // namespace | 272 } // namespace |
267 } // namespace system | 273 } // namespace system |
268 } // namespace mojo | 274 } // namespace mojo |
OLD | NEW |