OLD | NEW |
1 // Copyright 2013 The Chromium Authors. All rights reserved. | 1 // Copyright 2013 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/public/cpp/bindings/lib/connector.h" |
| 6 |
5 #include <stddef.h> | 7 #include <stddef.h> |
6 #include <stdlib.h> | 8 #include <stdlib.h> |
7 #include <string.h> | 9 #include <string.h> |
| 10 #include <utility> |
8 | 11 |
9 #include "base/message_loop/message_loop.h" | 12 #include "base/message_loop/message_loop.h" |
10 #include "mojo/message_pump/message_pump_mojo.h" | 13 #include "mojo/message_pump/message_pump_mojo.h" |
11 #include "mojo/public/cpp/bindings/lib/connector.h" | |
12 #include "mojo/public/cpp/bindings/lib/message_builder.h" | 14 #include "mojo/public/cpp/bindings/lib/message_builder.h" |
13 #include "mojo/public/cpp/bindings/tests/message_queue.h" | 15 #include "mojo/public/cpp/bindings/tests/message_queue.h" |
14 #include "mojo/public/cpp/system/macros.h" | 16 #include "mojo/public/cpp/system/macros.h" |
15 #include "testing/gtest/include/gtest/gtest.h" | 17 #include "testing/gtest/include/gtest/gtest.h" |
16 | 18 |
17 namespace mojo { | 19 namespace mojo { |
18 namespace test { | 20 namespace test { |
19 namespace { | 21 namespace { |
20 | 22 |
21 class MessageAccumulator : public MessageReceiver { | 23 class MessageAccumulator : public MessageReceiver { |
(...skipping 72 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
94 | 96 |
95 protected: | 97 protected: |
96 ScopedMessagePipeHandle handle0_; | 98 ScopedMessagePipeHandle handle0_; |
97 ScopedMessagePipeHandle handle1_; | 99 ScopedMessagePipeHandle handle1_; |
98 | 100 |
99 private: | 101 private: |
100 base::MessageLoop loop_; | 102 base::MessageLoop loop_; |
101 }; | 103 }; |
102 | 104 |
103 TEST_F(ConnectorTest, Basic) { | 105 TEST_F(ConnectorTest, Basic) { |
104 internal::Connector connector0(handle0_.Pass(), | 106 internal::Connector connector0(std::move(handle0_), |
105 internal::Connector::SINGLE_THREADED_SEND); | 107 internal::Connector::SINGLE_THREADED_SEND); |
106 internal::Connector connector1(handle1_.Pass(), | 108 internal::Connector connector1(std::move(handle1_), |
107 internal::Connector::SINGLE_THREADED_SEND); | 109 internal::Connector::SINGLE_THREADED_SEND); |
108 | 110 |
109 const char kText[] = "hello world"; | 111 const char kText[] = "hello world"; |
110 | 112 |
111 Message message; | 113 Message message; |
112 AllocMessage(kText, &message); | 114 AllocMessage(kText, &message); |
113 | 115 |
114 connector0.Accept(&message); | 116 connector0.Accept(&message); |
115 | 117 |
116 MessageAccumulator accumulator; | 118 MessageAccumulator accumulator; |
117 connector1.set_incoming_receiver(&accumulator); | 119 connector1.set_incoming_receiver(&accumulator); |
118 | 120 |
119 PumpMessages(); | 121 PumpMessages(); |
120 | 122 |
121 ASSERT_FALSE(accumulator.IsEmpty()); | 123 ASSERT_FALSE(accumulator.IsEmpty()); |
122 | 124 |
123 Message message_received; | 125 Message message_received; |
124 accumulator.Pop(&message_received); | 126 accumulator.Pop(&message_received); |
125 | 127 |
126 EXPECT_EQ( | 128 EXPECT_EQ( |
127 std::string(kText), | 129 std::string(kText), |
128 std::string(reinterpret_cast<const char*>(message_received.payload()))); | 130 std::string(reinterpret_cast<const char*>(message_received.payload()))); |
129 } | 131 } |
130 | 132 |
131 TEST_F(ConnectorTest, Basic_Synchronous) { | 133 TEST_F(ConnectorTest, Basic_Synchronous) { |
132 internal::Connector connector0(handle0_.Pass(), | 134 internal::Connector connector0(std::move(handle0_), |
133 internal::Connector::SINGLE_THREADED_SEND); | 135 internal::Connector::SINGLE_THREADED_SEND); |
134 internal::Connector connector1(handle1_.Pass(), | 136 internal::Connector connector1(std::move(handle1_), |
135 internal::Connector::SINGLE_THREADED_SEND); | 137 internal::Connector::SINGLE_THREADED_SEND); |
136 | 138 |
137 const char kText[] = "hello world"; | 139 const char kText[] = "hello world"; |
138 | 140 |
139 Message message; | 141 Message message; |
140 AllocMessage(kText, &message); | 142 AllocMessage(kText, &message); |
141 | 143 |
142 connector0.Accept(&message); | 144 connector0.Accept(&message); |
143 | 145 |
144 MessageAccumulator accumulator; | 146 MessageAccumulator accumulator; |
145 connector1.set_incoming_receiver(&accumulator); | 147 connector1.set_incoming_receiver(&accumulator); |
146 | 148 |
147 connector1.WaitForIncomingMessage(MOJO_DEADLINE_INDEFINITE); | 149 connector1.WaitForIncomingMessage(MOJO_DEADLINE_INDEFINITE); |
148 | 150 |
149 ASSERT_FALSE(accumulator.IsEmpty()); | 151 ASSERT_FALSE(accumulator.IsEmpty()); |
150 | 152 |
151 Message message_received; | 153 Message message_received; |
152 accumulator.Pop(&message_received); | 154 accumulator.Pop(&message_received); |
153 | 155 |
154 EXPECT_EQ( | 156 EXPECT_EQ( |
155 std::string(kText), | 157 std::string(kText), |
156 std::string(reinterpret_cast<const char*>(message_received.payload()))); | 158 std::string(reinterpret_cast<const char*>(message_received.payload()))); |
157 } | 159 } |
158 | 160 |
159 TEST_F(ConnectorTest, Basic_EarlyIncomingReceiver) { | 161 TEST_F(ConnectorTest, Basic_EarlyIncomingReceiver) { |
160 internal::Connector connector0(handle0_.Pass(), | 162 internal::Connector connector0(std::move(handle0_), |
161 internal::Connector::SINGLE_THREADED_SEND); | 163 internal::Connector::SINGLE_THREADED_SEND); |
162 internal::Connector connector1(handle1_.Pass(), | 164 internal::Connector connector1(std::move(handle1_), |
163 internal::Connector::SINGLE_THREADED_SEND); | 165 internal::Connector::SINGLE_THREADED_SEND); |
164 | 166 |
165 MessageAccumulator accumulator; | 167 MessageAccumulator accumulator; |
166 connector1.set_incoming_receiver(&accumulator); | 168 connector1.set_incoming_receiver(&accumulator); |
167 | 169 |
168 const char kText[] = "hello world"; | 170 const char kText[] = "hello world"; |
169 | 171 |
170 Message message; | 172 Message message; |
171 AllocMessage(kText, &message); | 173 AllocMessage(kText, &message); |
172 | 174 |
173 connector0.Accept(&message); | 175 connector0.Accept(&message); |
174 | 176 |
175 PumpMessages(); | 177 PumpMessages(); |
176 | 178 |
177 ASSERT_FALSE(accumulator.IsEmpty()); | 179 ASSERT_FALSE(accumulator.IsEmpty()); |
178 | 180 |
179 Message message_received; | 181 Message message_received; |
180 accumulator.Pop(&message_received); | 182 accumulator.Pop(&message_received); |
181 | 183 |
182 EXPECT_EQ( | 184 EXPECT_EQ( |
183 std::string(kText), | 185 std::string(kText), |
184 std::string(reinterpret_cast<const char*>(message_received.payload()))); | 186 std::string(reinterpret_cast<const char*>(message_received.payload()))); |
185 } | 187 } |
186 | 188 |
187 TEST_F(ConnectorTest, Basic_TwoMessages) { | 189 TEST_F(ConnectorTest, Basic_TwoMessages) { |
188 internal::Connector connector0(handle0_.Pass(), | 190 internal::Connector connector0(std::move(handle0_), |
189 internal::Connector::SINGLE_THREADED_SEND); | 191 internal::Connector::SINGLE_THREADED_SEND); |
190 internal::Connector connector1(handle1_.Pass(), | 192 internal::Connector connector1(std::move(handle1_), |
191 internal::Connector::SINGLE_THREADED_SEND); | 193 internal::Connector::SINGLE_THREADED_SEND); |
192 | 194 |
193 const char* kText[] = {"hello", "world"}; | 195 const char* kText[] = {"hello", "world"}; |
194 | 196 |
195 for (size_t i = 0; i < MOJO_ARRAYSIZE(kText); ++i) { | 197 for (size_t i = 0; i < MOJO_ARRAYSIZE(kText); ++i) { |
196 Message message; | 198 Message message; |
197 AllocMessage(kText[i], &message); | 199 AllocMessage(kText[i], &message); |
198 | 200 |
199 connector0.Accept(&message); | 201 connector0.Accept(&message); |
200 } | 202 } |
201 | 203 |
202 MessageAccumulator accumulator; | 204 MessageAccumulator accumulator; |
203 connector1.set_incoming_receiver(&accumulator); | 205 connector1.set_incoming_receiver(&accumulator); |
204 | 206 |
205 PumpMessages(); | 207 PumpMessages(); |
206 | 208 |
207 for (size_t i = 0; i < MOJO_ARRAYSIZE(kText); ++i) { | 209 for (size_t i = 0; i < MOJO_ARRAYSIZE(kText); ++i) { |
208 ASSERT_FALSE(accumulator.IsEmpty()); | 210 ASSERT_FALSE(accumulator.IsEmpty()); |
209 | 211 |
210 Message message_received; | 212 Message message_received; |
211 accumulator.Pop(&message_received); | 213 accumulator.Pop(&message_received); |
212 | 214 |
213 EXPECT_EQ( | 215 EXPECT_EQ( |
214 std::string(kText[i]), | 216 std::string(kText[i]), |
215 std::string(reinterpret_cast<const char*>(message_received.payload()))); | 217 std::string(reinterpret_cast<const char*>(message_received.payload()))); |
216 } | 218 } |
217 } | 219 } |
218 | 220 |
219 TEST_F(ConnectorTest, Basic_TwoMessages_Synchronous) { | 221 TEST_F(ConnectorTest, Basic_TwoMessages_Synchronous) { |
220 internal::Connector connector0(handle0_.Pass(), | 222 internal::Connector connector0(std::move(handle0_), |
221 internal::Connector::SINGLE_THREADED_SEND); | 223 internal::Connector::SINGLE_THREADED_SEND); |
222 internal::Connector connector1(handle1_.Pass(), | 224 internal::Connector connector1(std::move(handle1_), |
223 internal::Connector::SINGLE_THREADED_SEND); | 225 internal::Connector::SINGLE_THREADED_SEND); |
224 | 226 |
225 const char* kText[] = {"hello", "world"}; | 227 const char* kText[] = {"hello", "world"}; |
226 | 228 |
227 for (size_t i = 0; i < MOJO_ARRAYSIZE(kText); ++i) { | 229 for (size_t i = 0; i < MOJO_ARRAYSIZE(kText); ++i) { |
228 Message message; | 230 Message message; |
229 AllocMessage(kText[i], &message); | 231 AllocMessage(kText[i], &message); |
230 | 232 |
231 connector0.Accept(&message); | 233 connector0.Accept(&message); |
232 } | 234 } |
233 | 235 |
234 MessageAccumulator accumulator; | 236 MessageAccumulator accumulator; |
235 connector1.set_incoming_receiver(&accumulator); | 237 connector1.set_incoming_receiver(&accumulator); |
236 | 238 |
237 connector1.WaitForIncomingMessage(MOJO_DEADLINE_INDEFINITE); | 239 connector1.WaitForIncomingMessage(MOJO_DEADLINE_INDEFINITE); |
238 | 240 |
239 ASSERT_FALSE(accumulator.IsEmpty()); | 241 ASSERT_FALSE(accumulator.IsEmpty()); |
240 | 242 |
241 Message message_received; | 243 Message message_received; |
242 accumulator.Pop(&message_received); | 244 accumulator.Pop(&message_received); |
243 | 245 |
244 EXPECT_EQ( | 246 EXPECT_EQ( |
245 std::string(kText[0]), | 247 std::string(kText[0]), |
246 std::string(reinterpret_cast<const char*>(message_received.payload()))); | 248 std::string(reinterpret_cast<const char*>(message_received.payload()))); |
247 | 249 |
248 ASSERT_TRUE(accumulator.IsEmpty()); | 250 ASSERT_TRUE(accumulator.IsEmpty()); |
249 } | 251 } |
250 | 252 |
251 TEST_F(ConnectorTest, WriteToClosedPipe) { | 253 TEST_F(ConnectorTest, WriteToClosedPipe) { |
252 internal::Connector connector0(handle0_.Pass(), | 254 internal::Connector connector0(std::move(handle0_), |
253 internal::Connector::SINGLE_THREADED_SEND); | 255 internal::Connector::SINGLE_THREADED_SEND); |
254 | 256 |
255 const char kText[] = "hello world"; | 257 const char kText[] = "hello world"; |
256 | 258 |
257 Message message; | 259 Message message; |
258 AllocMessage(kText, &message); | 260 AllocMessage(kText, &message); |
259 | 261 |
260 // Close the other end of the pipe. | 262 // Close the other end of the pipe. |
261 handle1_.reset(); | 263 handle1_.reset(); |
262 | 264 |
263 // Not observed yet because we haven't spun the message loop yet. | 265 // Not observed yet because we haven't spun the message loop yet. |
264 EXPECT_FALSE(connector0.encountered_error()); | 266 EXPECT_FALSE(connector0.encountered_error()); |
265 | 267 |
266 // Write failures are not reported. | 268 // Write failures are not reported. |
267 bool ok = connector0.Accept(&message); | 269 bool ok = connector0.Accept(&message); |
268 EXPECT_TRUE(ok); | 270 EXPECT_TRUE(ok); |
269 | 271 |
270 // Still not observed. | 272 // Still not observed. |
271 EXPECT_FALSE(connector0.encountered_error()); | 273 EXPECT_FALSE(connector0.encountered_error()); |
272 | 274 |
273 // Spin the message loop, and then we should start observing the closed pipe. | 275 // Spin the message loop, and then we should start observing the closed pipe. |
274 PumpMessages(); | 276 PumpMessages(); |
275 | 277 |
276 EXPECT_TRUE(connector0.encountered_error()); | 278 EXPECT_TRUE(connector0.encountered_error()); |
277 } | 279 } |
278 | 280 |
279 TEST_F(ConnectorTest, MessageWithHandles) { | 281 TEST_F(ConnectorTest, MessageWithHandles) { |
280 internal::Connector connector0(handle0_.Pass(), | 282 internal::Connector connector0(std::move(handle0_), |
281 internal::Connector::SINGLE_THREADED_SEND); | 283 internal::Connector::SINGLE_THREADED_SEND); |
282 internal::Connector connector1(handle1_.Pass(), | 284 internal::Connector connector1(std::move(handle1_), |
283 internal::Connector::SINGLE_THREADED_SEND); | 285 internal::Connector::SINGLE_THREADED_SEND); |
284 | 286 |
285 const char kText[] = "hello world"; | 287 const char kText[] = "hello world"; |
286 | 288 |
287 Message message1; | 289 Message message1; |
288 AllocMessage(kText, &message1); | 290 AllocMessage(kText, &message1); |
289 | 291 |
290 MessagePipe pipe; | 292 MessagePipe pipe; |
291 message1.mutable_handles()->push_back(pipe.handle0.release()); | 293 message1.mutable_handles()->push_back(pipe.handle0.release()); |
292 | 294 |
(...skipping 19 matching lines...) Expand all Loading... |
312 | 314 |
313 // Now send a message to the transferred handle and confirm it's sent through | 315 // Now send a message to the transferred handle and confirm it's sent through |
314 // to the orginal pipe. | 316 // to the orginal pipe. |
315 // TODO(vtl): Do we need a better way of "downcasting" the handle types? | 317 // TODO(vtl): Do we need a better way of "downcasting" the handle types? |
316 ScopedMessagePipeHandle smph; | 318 ScopedMessagePipeHandle smph; |
317 smph.reset(MessagePipeHandle(message_received.handles()->front().value())); | 319 smph.reset(MessagePipeHandle(message_received.handles()->front().value())); |
318 message_received.mutable_handles()->front() = Handle(); | 320 message_received.mutable_handles()->front() = Handle(); |
319 // |smph| now owns this handle. | 321 // |smph| now owns this handle. |
320 | 322 |
321 internal::Connector connector_received( | 323 internal::Connector connector_received( |
322 smph.Pass(), internal::Connector::SINGLE_THREADED_SEND); | 324 std::move(smph), internal::Connector::SINGLE_THREADED_SEND); |
323 internal::Connector connector_original( | 325 internal::Connector connector_original( |
324 pipe.handle1.Pass(), internal::Connector::SINGLE_THREADED_SEND); | 326 std::move(pipe.handle1), internal::Connector::SINGLE_THREADED_SEND); |
325 | 327 |
326 Message message2; | 328 Message message2; |
327 AllocMessage(kText, &message2); | 329 AllocMessage(kText, &message2); |
328 | 330 |
329 connector_received.Accept(&message2); | 331 connector_received.Accept(&message2); |
330 connector_original.set_incoming_receiver(&accumulator); | 332 connector_original.set_incoming_receiver(&accumulator); |
331 PumpMessages(); | 333 PumpMessages(); |
332 | 334 |
333 ASSERT_FALSE(accumulator.IsEmpty()); | 335 ASSERT_FALSE(accumulator.IsEmpty()); |
334 | 336 |
335 accumulator.Pop(&message_received); | 337 accumulator.Pop(&message_received); |
336 | 338 |
337 EXPECT_EQ( | 339 EXPECT_EQ( |
338 std::string(kText), | 340 std::string(kText), |
339 std::string(reinterpret_cast<const char*>(message_received.payload()))); | 341 std::string(reinterpret_cast<const char*>(message_received.payload()))); |
340 } | 342 } |
341 | 343 |
342 TEST_F(ConnectorTest, WaitForIncomingMessageWithError) { | 344 TEST_F(ConnectorTest, WaitForIncomingMessageWithError) { |
343 internal::Connector connector0(handle0_.Pass(), | 345 internal::Connector connector0(std::move(handle0_), |
344 internal::Connector::SINGLE_THREADED_SEND); | 346 internal::Connector::SINGLE_THREADED_SEND); |
345 // Close the other end of the pipe. | 347 // Close the other end of the pipe. |
346 handle1_.reset(); | 348 handle1_.reset(); |
347 ASSERT_FALSE(connector0.WaitForIncomingMessage(MOJO_DEADLINE_INDEFINITE)); | 349 ASSERT_FALSE(connector0.WaitForIncomingMessage(MOJO_DEADLINE_INDEFINITE)); |
348 } | 350 } |
349 | 351 |
350 TEST_F(ConnectorTest, WaitForIncomingMessageWithDeletion) { | 352 TEST_F(ConnectorTest, WaitForIncomingMessageWithDeletion) { |
351 internal::Connector connector0(handle0_.Pass(), | 353 internal::Connector connector0(std::move(handle0_), |
352 internal::Connector::SINGLE_THREADED_SEND); | 354 internal::Connector::SINGLE_THREADED_SEND); |
353 internal::Connector* connector1 = new internal::Connector( | 355 internal::Connector* connector1 = new internal::Connector( |
354 handle1_.Pass(), internal::Connector::SINGLE_THREADED_SEND); | 356 std::move(handle1_), internal::Connector::SINGLE_THREADED_SEND); |
355 | 357 |
356 const char kText[] = "hello world"; | 358 const char kText[] = "hello world"; |
357 | 359 |
358 Message message; | 360 Message message; |
359 AllocMessage(kText, &message); | 361 AllocMessage(kText, &message); |
360 | 362 |
361 connector0.Accept(&message); | 363 connector0.Accept(&message); |
362 | 364 |
363 ConnectorDeletingMessageAccumulator accumulator(&connector1); | 365 ConnectorDeletingMessageAccumulator accumulator(&connector1); |
364 connector1->set_incoming_receiver(&accumulator); | 366 connector1->set_incoming_receiver(&accumulator); |
365 | 367 |
366 connector1->WaitForIncomingMessage(MOJO_DEADLINE_INDEFINITE); | 368 connector1->WaitForIncomingMessage(MOJO_DEADLINE_INDEFINITE); |
367 | 369 |
368 ASSERT_FALSE(connector1); | 370 ASSERT_FALSE(connector1); |
369 ASSERT_FALSE(accumulator.IsEmpty()); | 371 ASSERT_FALSE(accumulator.IsEmpty()); |
370 | 372 |
371 Message message_received; | 373 Message message_received; |
372 accumulator.Pop(&message_received); | 374 accumulator.Pop(&message_received); |
373 | 375 |
374 EXPECT_EQ( | 376 EXPECT_EQ( |
375 std::string(kText), | 377 std::string(kText), |
376 std::string(reinterpret_cast<const char*>(message_received.payload()))); | 378 std::string(reinterpret_cast<const char*>(message_received.payload()))); |
377 } | 379 } |
378 | 380 |
379 TEST_F(ConnectorTest, WaitForIncomingMessageWithReentrancy) { | 381 TEST_F(ConnectorTest, WaitForIncomingMessageWithReentrancy) { |
380 internal::Connector connector0(handle0_.Pass(), | 382 internal::Connector connector0(std::move(handle0_), |
381 internal::Connector::SINGLE_THREADED_SEND); | 383 internal::Connector::SINGLE_THREADED_SEND); |
382 internal::Connector connector1(handle1_.Pass(), | 384 internal::Connector connector1(std::move(handle1_), |
383 internal::Connector::SINGLE_THREADED_SEND); | 385 internal::Connector::SINGLE_THREADED_SEND); |
384 | 386 |
385 const char* kText[] = {"hello", "world"}; | 387 const char* kText[] = {"hello", "world"}; |
386 | 388 |
387 for (size_t i = 0; i < MOJO_ARRAYSIZE(kText); ++i) { | 389 for (size_t i = 0; i < MOJO_ARRAYSIZE(kText); ++i) { |
388 Message message; | 390 Message message; |
389 AllocMessage(kText[i], &message); | 391 AllocMessage(kText[i], &message); |
390 | 392 |
391 connector0.Accept(&message); | 393 connector0.Accept(&message); |
392 } | 394 } |
(...skipping 11 matching lines...) Expand all Loading... |
404 | 406 |
405 EXPECT_EQ( | 407 EXPECT_EQ( |
406 std::string(kText[i]), | 408 std::string(kText[i]), |
407 std::string(reinterpret_cast<const char*>(message_received.payload()))); | 409 std::string(reinterpret_cast<const char*>(message_received.payload()))); |
408 } | 410 } |
409 | 411 |
410 ASSERT_EQ(2, accumulator.number_of_calls()); | 412 ASSERT_EQ(2, accumulator.number_of_calls()); |
411 } | 413 } |
412 | 414 |
413 TEST_F(ConnectorTest, RaiseError) { | 415 TEST_F(ConnectorTest, RaiseError) { |
414 internal::Connector connector0(handle0_.Pass(), | 416 internal::Connector connector0(std::move(handle0_), |
415 internal::Connector::SINGLE_THREADED_SEND); | 417 internal::Connector::SINGLE_THREADED_SEND); |
416 bool error_handler_called0 = false; | 418 bool error_handler_called0 = false; |
417 connector0.set_connection_error_handler( | 419 connector0.set_connection_error_handler( |
418 [&error_handler_called0]() { error_handler_called0 = true; }); | 420 [&error_handler_called0]() { error_handler_called0 = true; }); |
419 | 421 |
420 internal::Connector connector1(handle1_.Pass(), | 422 internal::Connector connector1(std::move(handle1_), |
421 internal::Connector::SINGLE_THREADED_SEND); | 423 internal::Connector::SINGLE_THREADED_SEND); |
422 bool error_handler_called1 = false; | 424 bool error_handler_called1 = false; |
423 connector1.set_connection_error_handler( | 425 connector1.set_connection_error_handler( |
424 [&error_handler_called1]() { error_handler_called1 = true; }); | 426 [&error_handler_called1]() { error_handler_called1 = true; }); |
425 | 427 |
426 const char kText[] = "hello world"; | 428 const char kText[] = "hello world"; |
427 | 429 |
428 Message message; | 430 Message message; |
429 AllocMessage(kText, &message); | 431 AllocMessage(kText, &message); |
430 | 432 |
(...skipping 26 matching lines...) Expand all Loading... |
457 EXPECT_TRUE(connector1.encountered_error()); | 459 EXPECT_TRUE(connector1.encountered_error()); |
458 | 460 |
459 // The message pipe handle is valid at both sides. | 461 // The message pipe handle is valid at both sides. |
460 EXPECT_TRUE(connector0.is_valid()); | 462 EXPECT_TRUE(connector0.is_valid()); |
461 EXPECT_TRUE(connector1.is_valid()); | 463 EXPECT_TRUE(connector1.is_valid()); |
462 } | 464 } |
463 | 465 |
464 } // namespace | 466 } // namespace |
465 } // namespace test | 467 } // namespace test |
466 } // namespace mojo | 468 } // namespace mojo |
OLD | NEW |