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 <utility> |
| 6 |
5 #include "base/macros.h" | 7 #include "base/macros.h" |
6 #include "base/memory/scoped_ptr.h" | 8 #include "base/memory/scoped_ptr.h" |
7 #include "base/run_loop.h" | 9 #include "base/run_loop.h" |
8 #include "mojo/application/public/cpp/application_connection.h" | 10 #include "mojo/application/public/cpp/application_connection.h" |
9 #include "mojo/application/public/cpp/application_impl.h" | 11 #include "mojo/application/public/cpp/application_impl.h" |
10 #include "mojo/application/public/cpp/application_test_base.h" | 12 #include "mojo/application/public/cpp/application_test_base.h" |
11 #include "mojo/public/cpp/bindings/callback.h" | 13 #include "mojo/public/cpp/bindings/callback.h" |
12 #include "mojo/services/network/public/cpp/udp_socket_wrapper.h" | 14 #include "mojo/services/network/public/cpp/udp_socket_wrapper.h" |
13 #include "mojo/services/network/public/interfaces/network_service.mojom.h" | 15 #include "mojo/services/network/public/interfaces/network_service.mojom.h" |
14 #include "mojo/services/network/public/interfaces/udp_socket.mojom.h" | 16 #include "mojo/services/network/public/interfaces/udp_socket.mojom.h" |
15 #include "net/base/net_errors.h" | 17 #include "net/base/net_errors.h" |
16 #include "testing/gtest/include/gtest/gtest.h" | 18 #include "testing/gtest/include/gtest/gtest.h" |
17 | 19 |
18 namespace mojo { | 20 namespace mojo { |
19 namespace service { | 21 namespace service { |
20 namespace { | 22 namespace { |
21 | 23 |
22 NetAddressPtr GetLocalHostWithAnyPort() { | 24 NetAddressPtr GetLocalHostWithAnyPort() { |
23 NetAddressPtr addr(NetAddress::New()); | 25 NetAddressPtr addr(NetAddress::New()); |
24 addr->family = NET_ADDRESS_FAMILY_IPV4; | 26 addr->family = NET_ADDRESS_FAMILY_IPV4; |
25 addr->ipv4 = NetAddressIPv4::New(); | 27 addr->ipv4 = NetAddressIPv4::New(); |
26 addr->ipv4->port = 0; | 28 addr->ipv4->port = 0; |
27 addr->ipv4->addr.resize(4); | 29 addr->ipv4->addr.resize(4); |
28 addr->ipv4->addr[0] = 127; | 30 addr->ipv4->addr[0] = 127; |
29 addr->ipv4->addr[1] = 0; | 31 addr->ipv4->addr[1] = 0; |
30 addr->ipv4->addr[2] = 0; | 32 addr->ipv4->addr[2] = 0; |
31 addr->ipv4->addr[3] = 1; | 33 addr->ipv4->addr[3] = 1; |
32 | 34 |
33 return addr.Pass(); | 35 return addr; |
34 } | 36 } |
35 | 37 |
36 Array<uint8_t> CreateTestMessage(uint8_t initial, size_t size) { | 38 Array<uint8_t> CreateTestMessage(uint8_t initial, size_t size) { |
37 Array<uint8_t> array(size); | 39 Array<uint8_t> array(size); |
38 for (size_t i = 0; i < size; ++i) | 40 for (size_t i = 0; i < size; ++i) |
39 array[i] = static_cast<uint8_t>((i + initial) % 256); | 41 array[i] = static_cast<uint8_t>((i + initial) % 256); |
40 return array.Pass(); | 42 return array; |
41 } | 43 } |
42 | 44 |
43 template <typename CallbackType> | 45 template <typename CallbackType> |
44 class TestCallbackBase { | 46 class TestCallbackBase { |
45 public: | 47 public: |
46 TestCallbackBase() : state_(nullptr), run_loop_(nullptr), ran_(false) {} | 48 TestCallbackBase() : state_(nullptr), run_loop_(nullptr), ran_(false) {} |
47 | 49 |
48 ~TestCallbackBase() { | 50 ~TestCallbackBase() { |
49 state_->set_test_callback(nullptr); | 51 state_->set_test_callback(nullptr); |
50 } | 52 } |
(...skipping 62 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
113 | 115 |
114 const NetworkErrorPtr& result() const { return result_; } | 116 const NetworkErrorPtr& result() const { return result_; } |
115 | 117 |
116 private: | 118 private: |
117 struct State: public StateBase { | 119 struct State: public StateBase { |
118 ~State() override {} | 120 ~State() override {} |
119 | 121 |
120 void Run(NetworkErrorPtr result) const override { | 122 void Run(NetworkErrorPtr result) const override { |
121 if (test_callback_) { | 123 if (test_callback_) { |
122 TestCallback* callback = static_cast<TestCallback*>(test_callback_); | 124 TestCallback* callback = static_cast<TestCallback*>(test_callback_); |
123 callback->result_ = result.Pass(); | 125 callback->result_ = std::move(result); |
124 } | 126 } |
125 NotifyRun(); | 127 NotifyRun(); |
126 } | 128 } |
127 }; | 129 }; |
128 | 130 |
129 NetworkErrorPtr result_; | 131 NetworkErrorPtr result_; |
130 }; | 132 }; |
131 | 133 |
132 class TestCallbackWithAddressAndReceiver | 134 class TestCallbackWithAddressAndReceiver |
133 : public TestCallbackBase< | 135 : public TestCallbackBase< |
(...skipping 11 matching lines...) Expand all Loading... |
145 private: | 147 private: |
146 struct State : public StateBase { | 148 struct State : public StateBase { |
147 ~State() override {} | 149 ~State() override {} |
148 | 150 |
149 void Run(NetworkErrorPtr result, | 151 void Run(NetworkErrorPtr result, |
150 NetAddressPtr net_address, | 152 NetAddressPtr net_address, |
151 InterfaceRequest<UDPSocketReceiver> receiver) const override { | 153 InterfaceRequest<UDPSocketReceiver> receiver) const override { |
152 if (test_callback_) { | 154 if (test_callback_) { |
153 TestCallbackWithAddressAndReceiver* callback = | 155 TestCallbackWithAddressAndReceiver* callback = |
154 static_cast<TestCallbackWithAddressAndReceiver*>(test_callback_); | 156 static_cast<TestCallbackWithAddressAndReceiver*>(test_callback_); |
155 callback->result_ = result.Pass(); | 157 callback->result_ = std::move(result); |
156 callback->net_address_ = net_address.Pass(); | 158 callback->net_address_ = std::move(net_address); |
157 callback->receiver_ = receiver.Pass(); | 159 callback->receiver_ = std::move(receiver); |
158 } | 160 } |
159 NotifyRun(); | 161 NotifyRun(); |
160 } | 162 } |
161 }; | 163 }; |
162 | 164 |
163 NetworkErrorPtr result_; | 165 NetworkErrorPtr result_; |
164 NetAddressPtr net_address_; | 166 NetAddressPtr net_address_; |
165 InterfaceRequest<UDPSocketReceiver> receiver_; | 167 InterfaceRequest<UDPSocketReceiver> receiver_; |
166 }; | 168 }; |
167 | 169 |
168 class TestCallbackWithAddress | 170 class TestCallbackWithAddress |
169 : public TestCallbackBase<Callback<void(NetworkErrorPtr, NetAddressPtr)>> { | 171 : public TestCallbackBase<Callback<void(NetworkErrorPtr, NetAddressPtr)>> { |
170 public: | 172 public: |
171 TestCallbackWithAddress() { | 173 TestCallbackWithAddress() { |
172 Initialize(new State()); | 174 Initialize(new State()); |
173 } | 175 } |
174 ~TestCallbackWithAddress() {} | 176 ~TestCallbackWithAddress() {} |
175 | 177 |
176 const NetworkErrorPtr& result() const { return result_; } | 178 const NetworkErrorPtr& result() const { return result_; } |
177 const NetAddressPtr& net_address() const { return net_address_; } | 179 const NetAddressPtr& net_address() const { return net_address_; } |
178 | 180 |
179 private: | 181 private: |
180 struct State : public StateBase { | 182 struct State : public StateBase { |
181 ~State() override {} | 183 ~State() override {} |
182 | 184 |
183 void Run(NetworkErrorPtr result, NetAddressPtr net_address) const override { | 185 void Run(NetworkErrorPtr result, NetAddressPtr net_address) const override { |
184 if (test_callback_) { | 186 if (test_callback_) { |
185 TestCallbackWithAddress* callback = | 187 TestCallbackWithAddress* callback = |
186 static_cast<TestCallbackWithAddress*>(test_callback_); | 188 static_cast<TestCallbackWithAddress*>(test_callback_); |
187 callback->result_ = result.Pass(); | 189 callback->result_ = std::move(result); |
188 callback->net_address_ = net_address.Pass(); | 190 callback->net_address_ = std::move(net_address); |
189 } | 191 } |
190 NotifyRun(); | 192 NotifyRun(); |
191 } | 193 } |
192 }; | 194 }; |
193 | 195 |
194 NetworkErrorPtr result_; | 196 NetworkErrorPtr result_; |
195 NetAddressPtr net_address_; | 197 NetAddressPtr net_address_; |
196 }; | 198 }; |
197 | 199 |
198 class TestCallbackWithUint32 | 200 class TestCallbackWithUint32 |
(...skipping 39 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
238 private: | 240 private: |
239 struct State : public StateBase { | 241 struct State : public StateBase { |
240 ~State() override {} | 242 ~State() override {} |
241 | 243 |
242 void Run(NetworkErrorPtr result, | 244 void Run(NetworkErrorPtr result, |
243 NetAddressPtr src_addr, | 245 NetAddressPtr src_addr, |
244 Array<uint8_t> data) const override { | 246 Array<uint8_t> data) const override { |
245 if (test_callback_) { | 247 if (test_callback_) { |
246 TestReceiveCallback* callback = | 248 TestReceiveCallback* callback = |
247 static_cast<TestReceiveCallback*>(test_callback_); | 249 static_cast<TestReceiveCallback*>(test_callback_); |
248 callback->result_ = result.Pass(); | 250 callback->result_ = std::move(result); |
249 callback->src_addr_ = src_addr.Pass(); | 251 callback->src_addr_ = std::move(src_addr); |
250 callback->data_ = data.Pass(); | 252 callback->data_ = std::move(data); |
251 } | 253 } |
252 NotifyRun(); | 254 NotifyRun(); |
253 } | 255 } |
254 }; | 256 }; |
255 | 257 |
256 NetworkErrorPtr result_; | 258 NetworkErrorPtr result_; |
257 NetAddressPtr src_addr_; | 259 NetAddressPtr src_addr_; |
258 Array<uint8_t> data_; | 260 Array<uint8_t> data_; |
259 }; | 261 }; |
260 | 262 |
(...skipping 27 matching lines...) Expand all Loading... |
288 run_loop_ = &run_loop; | 290 run_loop_ = &run_loop; |
289 run_loop.Run(); | 291 run_loop.Run(); |
290 run_loop_ = nullptr; | 292 run_loop_ = nullptr; |
291 } | 293 } |
292 | 294 |
293 private: | 295 private: |
294 void OnReceived(NetworkErrorPtr result, | 296 void OnReceived(NetworkErrorPtr result, |
295 NetAddressPtr src_addr, | 297 NetAddressPtr src_addr, |
296 Array<uint8_t> data) override { | 298 Array<uint8_t> data) override { |
297 ReceiveResult* entry = new ReceiveResult(); | 299 ReceiveResult* entry = new ReceiveResult(); |
298 entry->result = result.Pass(); | 300 entry->result = std::move(result); |
299 entry->addr = src_addr.Pass(); | 301 entry->addr = std::move(src_addr); |
300 entry->data = data.Pass(); | 302 entry->data = std::move(data); |
301 | 303 |
302 results_.push(entry); | 304 results_.push(entry); |
303 | 305 |
304 if (results_.size() == expected_receive_count_ && run_loop_) { | 306 if (results_.size() == expected_receive_count_ && run_loop_) { |
305 expected_receive_count_ = 0; | 307 expected_receive_count_ = 0; |
306 run_loop_->Quit(); | 308 run_loop_->Quit(); |
307 } | 309 } |
308 } | 310 } |
309 | 311 |
310 base::RunLoop* run_loop_; | 312 base::RunLoop* run_loop_; |
(...skipping 77 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
388 EXPECT_GT(callback9.result(), 0u); | 390 EXPECT_GT(callback9.result(), 0u); |
389 } | 391 } |
390 | 392 |
391 TEST_F(UDPSocketAppTest, TestReadWrite) { | 393 TEST_F(UDPSocketAppTest, TestReadWrite) { |
392 TestCallbackWithAddressAndReceiver callback1; | 394 TestCallbackWithAddressAndReceiver callback1; |
393 socket_->Bind(GetLocalHostWithAnyPort(), callback1.callback()); | 395 socket_->Bind(GetLocalHostWithAnyPort(), callback1.callback()); |
394 callback1.WaitForResult(); | 396 callback1.WaitForResult(); |
395 ASSERT_EQ(net::OK, callback1.result()->code); | 397 ASSERT_EQ(net::OK, callback1.result()->code); |
396 ASSERT_NE(0u, callback1.net_address()->ipv4->port); | 398 ASSERT_NE(0u, callback1.net_address()->ipv4->port); |
397 | 399 |
398 receiver_binding_.Bind(callback1.receiver().Pass()); | 400 receiver_binding_.Bind(std::move(callback1.receiver())); |
399 | 401 |
400 NetAddressPtr server_addr = callback1.net_address().Clone(); | 402 NetAddressPtr server_addr = callback1.net_address().Clone(); |
401 | 403 |
402 UDPSocketPtr client_socket; | 404 UDPSocketPtr client_socket; |
403 network_service_->CreateUDPSocket(GetProxy(&client_socket)); | 405 network_service_->CreateUDPSocket(GetProxy(&client_socket)); |
404 | 406 |
405 TestCallbackWithAddressAndReceiver callback2; | 407 TestCallbackWithAddressAndReceiver callback2; |
406 client_socket->Bind(GetLocalHostWithAnyPort(), callback2.callback()); | 408 client_socket->Bind(GetLocalHostWithAnyPort(), callback2.callback()); |
407 callback2.WaitForResult(); | 409 callback2.WaitForResult(); |
408 ASSERT_EQ(net::OK, callback2.result()->code); | 410 ASSERT_EQ(net::OK, callback2.result()->code); |
(...skipping 27 matching lines...) Expand all Loading... |
436 } | 438 } |
437 } | 439 } |
438 | 440 |
439 TEST_F(UDPSocketAppTest, TestConnectedReadWrite) { | 441 TEST_F(UDPSocketAppTest, TestConnectedReadWrite) { |
440 TestCallbackWithAddressAndReceiver callback1; | 442 TestCallbackWithAddressAndReceiver callback1; |
441 socket_->Bind(GetLocalHostWithAnyPort(), callback1.callback()); | 443 socket_->Bind(GetLocalHostWithAnyPort(), callback1.callback()); |
442 callback1.WaitForResult(); | 444 callback1.WaitForResult(); |
443 ASSERT_EQ(net::OK, callback1.result()->code); | 445 ASSERT_EQ(net::OK, callback1.result()->code); |
444 ASSERT_NE(0u, callback1.net_address()->ipv4->port); | 446 ASSERT_NE(0u, callback1.net_address()->ipv4->port); |
445 | 447 |
446 receiver_binding_.Bind(callback1.receiver().Pass()); | 448 receiver_binding_.Bind(std::move(callback1.receiver())); |
447 | 449 |
448 NetAddressPtr server_addr = callback1.net_address().Clone(); | 450 NetAddressPtr server_addr = callback1.net_address().Clone(); |
449 | 451 |
450 UDPSocketPtr client_socket; | 452 UDPSocketPtr client_socket; |
451 network_service_->CreateUDPSocket(GetProxy(&client_socket)); | 453 network_service_->CreateUDPSocket(GetProxy(&client_socket)); |
452 | 454 |
453 TestCallbackWithAddressAndReceiver callback2; | 455 TestCallbackWithAddressAndReceiver callback2; |
454 client_socket->Connect(server_addr.Clone(), callback2.callback()); | 456 client_socket->Connect(server_addr.Clone(), callback2.callback()); |
455 callback2.WaitForResult(); | 457 callback2.WaitForResult(); |
456 ASSERT_EQ(net::OK, callback2.result()->code); | 458 ASSERT_EQ(net::OK, callback2.result()->code); |
457 ASSERT_NE(0u, callback2.net_address()->ipv4->port); | 459 ASSERT_NE(0u, callback2.net_address()->ipv4->port); |
458 | 460 |
459 UDPSocketReceiverImpl client_socket_receiver; | 461 UDPSocketReceiverImpl client_socket_receiver; |
460 Binding<UDPSocketReceiver> client_receiver_binding( | 462 Binding<UDPSocketReceiver> client_receiver_binding( |
461 &client_socket_receiver, callback2.receiver().Pass()); | 463 &client_socket_receiver, std::move(callback2.receiver())); |
462 | 464 |
463 NetAddressPtr client_addr = callback2.net_address().Clone(); | 465 NetAddressPtr client_addr = callback2.net_address().Clone(); |
464 | 466 |
465 const size_t kDatagramCount = 6; | 467 const size_t kDatagramCount = 6; |
466 const size_t kDatagramSize = 255; | 468 const size_t kDatagramSize = 255; |
467 | 469 |
468 // Test send using a connected socket. | 470 // Test send using a connected socket. |
469 socket_->ReceiveMore(kDatagramCount); | 471 socket_->ReceiveMore(kDatagramCount); |
470 | 472 |
471 for (size_t i = 0; i < kDatagramCount; ++i) { | 473 for (size_t i = 0; i < kDatagramCount; ++i) { |
(...skipping 36 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
508 client_socket_receiver.results()->pop(); | 510 client_socket_receiver.results()->pop(); |
509 | 511 |
510 EXPECT_EQ(static_cast<int>(kDatagramSize), result->result->code); | 512 EXPECT_EQ(static_cast<int>(kDatagramSize), result->result->code); |
511 EXPECT_FALSE(result->addr); | 513 EXPECT_FALSE(result->addr); |
512 EXPECT_TRUE(result->data.Equals( | 514 EXPECT_TRUE(result->data.Equals( |
513 CreateTestMessage(static_cast<uint8_t>(i), kDatagramSize))); | 515 CreateTestMessage(static_cast<uint8_t>(i), kDatagramSize))); |
514 } | 516 } |
515 } | 517 } |
516 | 518 |
517 TEST_F(UDPSocketAppTest, TestWrapperReadWrite) { | 519 TEST_F(UDPSocketAppTest, TestWrapperReadWrite) { |
518 UDPSocketWrapper socket(socket_.Pass(), 4, 4); | 520 UDPSocketWrapper socket(std::move(socket_), 4, 4); |
519 | 521 |
520 TestCallbackWithAddress callback1; | 522 TestCallbackWithAddress callback1; |
521 socket.Bind(GetLocalHostWithAnyPort(), callback1.callback()); | 523 socket.Bind(GetLocalHostWithAnyPort(), callback1.callback()); |
522 callback1.WaitForResult(); | 524 callback1.WaitForResult(); |
523 ASSERT_EQ(net::OK, callback1.result()->code); | 525 ASSERT_EQ(net::OK, callback1.result()->code); |
524 ASSERT_NE(0u, callback1.net_address()->ipv4->port); | 526 ASSERT_NE(0u, callback1.net_address()->ipv4->port); |
525 | 527 |
526 NetAddressPtr server_addr = callback1.net_address().Clone(); | 528 NetAddressPtr server_addr = callback1.net_address().Clone(); |
527 | 529 |
528 UDPSocketPtr raw_client_socket; | 530 UDPSocketPtr raw_client_socket; |
529 network_service_->CreateUDPSocket(GetProxy(&raw_client_socket)); | 531 network_service_->CreateUDPSocket(GetProxy(&raw_client_socket)); |
530 UDPSocketWrapper client_socket(raw_client_socket.Pass(), 4, 4); | 532 UDPSocketWrapper client_socket(std::move(raw_client_socket), 4, 4); |
531 | 533 |
532 TestCallbackWithAddress callback2; | 534 TestCallbackWithAddress callback2; |
533 client_socket.Bind(GetLocalHostWithAnyPort(), callback2.callback()); | 535 client_socket.Bind(GetLocalHostWithAnyPort(), callback2.callback()); |
534 callback2.WaitForResult(); | 536 callback2.WaitForResult(); |
535 ASSERT_EQ(net::OK, callback2.result()->code); | 537 ASSERT_EQ(net::OK, callback2.result()->code); |
536 ASSERT_NE(0u, callback2.net_address()->ipv4->port); | 538 ASSERT_NE(0u, callback2.net_address()->ipv4->port); |
537 | 539 |
538 NetAddressPtr client_addr = callback2.net_address().Clone(); | 540 NetAddressPtr client_addr = callback2.net_address().Clone(); |
539 | 541 |
540 const size_t kDatagramCount = 16; | 542 const size_t kDatagramCount = 16; |
(...skipping 19 matching lines...) Expand all Loading... |
560 EXPECT_EQ(static_cast<int>(kDatagramSize), | 562 EXPECT_EQ(static_cast<int>(kDatagramSize), |
561 receive_callbacks[j].result()->code); | 563 receive_callbacks[j].result()->code); |
562 EXPECT_TRUE(receive_callbacks[j].src_addr().Equals(client_addr)); | 564 EXPECT_TRUE(receive_callbacks[j].src_addr().Equals(client_addr)); |
563 EXPECT_TRUE(receive_callbacks[j].data().Equals( | 565 EXPECT_TRUE(receive_callbacks[j].data().Equals( |
564 CreateTestMessage(static_cast<uint8_t>(j), kDatagramSize))); | 566 CreateTestMessage(static_cast<uint8_t>(j), kDatagramSize))); |
565 } | 567 } |
566 } | 568 } |
567 } | 569 } |
568 | 570 |
569 TEST_F(UDPSocketAppTest, TestWrapperConnectedReadWrite) { | 571 TEST_F(UDPSocketAppTest, TestWrapperConnectedReadWrite) { |
570 UDPSocketWrapper socket(socket_.Pass(), 4, 4); | 572 UDPSocketWrapper socket(std::move(socket_), 4, 4); |
571 | 573 |
572 TestCallbackWithAddress callback1; | 574 TestCallbackWithAddress callback1; |
573 socket.Bind(GetLocalHostWithAnyPort(), callback1.callback()); | 575 socket.Bind(GetLocalHostWithAnyPort(), callback1.callback()); |
574 callback1.WaitForResult(); | 576 callback1.WaitForResult(); |
575 ASSERT_EQ(net::OK, callback1.result()->code); | 577 ASSERT_EQ(net::OK, callback1.result()->code); |
576 ASSERT_NE(0u, callback1.net_address()->ipv4->port); | 578 ASSERT_NE(0u, callback1.net_address()->ipv4->port); |
577 | 579 |
578 NetAddressPtr server_addr = callback1.net_address().Clone(); | 580 NetAddressPtr server_addr = callback1.net_address().Clone(); |
579 | 581 |
580 UDPSocketPtr raw_client_socket; | 582 UDPSocketPtr raw_client_socket; |
581 network_service_->CreateUDPSocket(GetProxy(&raw_client_socket)); | 583 network_service_->CreateUDPSocket(GetProxy(&raw_client_socket)); |
582 UDPSocketWrapper client_socket(raw_client_socket.Pass(), 4, 4); | 584 UDPSocketWrapper client_socket(std::move(raw_client_socket), 4, 4); |
583 | 585 |
584 TestCallbackWithAddress callback2; | 586 TestCallbackWithAddress callback2; |
585 client_socket.Connect(server_addr.Pass(), callback2.callback()); | 587 client_socket.Connect(std::move(server_addr), callback2.callback()); |
586 callback2.WaitForResult(); | 588 callback2.WaitForResult(); |
587 ASSERT_EQ(net::OK, callback2.result()->code); | 589 ASSERT_EQ(net::OK, callback2.result()->code); |
588 ASSERT_NE(0u, callback2.net_address()->ipv4->port); | 590 ASSERT_NE(0u, callback2.net_address()->ipv4->port); |
589 | 591 |
590 NetAddressPtr client_addr = callback2.net_address().Clone(); | 592 NetAddressPtr client_addr = callback2.net_address().Clone(); |
591 | 593 |
592 const size_t kDatagramCount = 16; | 594 const size_t kDatagramCount = 16; |
593 const size_t kDatagramSize = 255; | 595 const size_t kDatagramSize = 255; |
594 | 596 |
595 // Test send using a connected socket. | 597 // Test send using a connected socket. |
(...skipping 44 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
640 receive_callbacks[j].result()->code); | 642 receive_callbacks[j].result()->code); |
641 EXPECT_FALSE(receive_callbacks[j].src_addr()); | 643 EXPECT_FALSE(receive_callbacks[j].src_addr()); |
642 EXPECT_TRUE(receive_callbacks[j].data().Equals( | 644 EXPECT_TRUE(receive_callbacks[j].data().Equals( |
643 CreateTestMessage(static_cast<uint8_t>(j), kDatagramSize))); | 645 CreateTestMessage(static_cast<uint8_t>(j), kDatagramSize))); |
644 } | 646 } |
645 } | 647 } |
646 } | 648 } |
647 | 649 |
648 } // namespace service | 650 } // namespace service |
649 } // namespace mojo | 651 } // namespace mojo |
OLD | NEW |