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 "ipc/mojo/ipc_channel_mojo.h" | 5 #include "ipc/mojo/ipc_channel_mojo.h" |
6 | 6 |
7 #include <stdint.h> | 7 #include <stdint.h> |
8 | 8 |
9 #include "base/base_paths.h" | 9 #include "base/base_paths.h" |
10 #include "base/files/file.h" | 10 #include "base/files/file.h" |
(...skipping 26 matching lines...) Expand all Loading... |
37 : received_ok_(false) {} | 37 : received_ok_(false) {} |
38 | 38 |
39 ~ListenerThatExpectsOK() override {} | 39 ~ListenerThatExpectsOK() override {} |
40 | 40 |
41 bool OnMessageReceived(const IPC::Message& message) override { | 41 bool OnMessageReceived(const IPC::Message& message) override { |
42 base::PickleIterator iter(message); | 42 base::PickleIterator iter(message); |
43 std::string should_be_ok; | 43 std::string should_be_ok; |
44 EXPECT_TRUE(iter.ReadString(&should_be_ok)); | 44 EXPECT_TRUE(iter.ReadString(&should_be_ok)); |
45 EXPECT_EQ(should_be_ok, "OK"); | 45 EXPECT_EQ(should_be_ok, "OK"); |
46 received_ok_ = true; | 46 received_ok_ = true; |
47 base::MessageLoop::current()->Quit(); | 47 base::MessageLoop::current()->QuitWhenIdle(); |
48 return true; | 48 return true; |
49 } | 49 } |
50 | 50 |
51 void OnChannelError() override { | 51 void OnChannelError() override { |
52 // The connection should be healthy while the listener is waiting | 52 // The connection should be healthy while the listener is waiting |
53 // message. An error can occur after that because the peer | 53 // message. An error can occur after that because the peer |
54 // process dies. | 54 // process dies. |
55 DCHECK(received_ok_); | 55 DCHECK(received_ok_); |
56 } | 56 } |
57 | 57 |
(...skipping 137 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
195 return 0; | 195 return 0; |
196 } | 196 } |
197 | 197 |
198 class ListenerExpectingErrors : public IPC::Listener { | 198 class ListenerExpectingErrors : public IPC::Listener { |
199 public: | 199 public: |
200 ListenerExpectingErrors() | 200 ListenerExpectingErrors() |
201 : has_error_(false) { | 201 : has_error_(false) { |
202 } | 202 } |
203 | 203 |
204 void OnChannelConnected(int32_t peer_pid) override { | 204 void OnChannelConnected(int32_t peer_pid) override { |
205 base::MessageLoop::current()->Quit(); | 205 base::MessageLoop::current()->QuitWhenIdle(); |
206 } | 206 } |
207 | 207 |
208 bool OnMessageReceived(const IPC::Message& message) override { return true; } | 208 bool OnMessageReceived(const IPC::Message& message) override { return true; } |
209 | 209 |
210 void OnChannelError() override { | 210 void OnChannelError() override { |
211 has_error_ = true; | 211 has_error_ = true; |
212 base::MessageLoop::current()->Quit(); | 212 base::MessageLoop::current()->QuitWhenIdle(); |
213 } | 213 } |
214 | 214 |
215 bool has_error() const { return has_error_; } | 215 bool has_error() const { return has_error_; } |
216 | 216 |
217 private: | 217 private: |
218 bool has_error_; | 218 bool has_error_; |
219 }; | 219 }; |
220 | 220 |
221 | 221 |
222 class IPCChannelMojoErrorTest : public IPCChannelMojoTestBase { | 222 class IPCChannelMojoErrorTest : public IPCChannelMojoTestBase { |
(...skipping 14 matching lines...) Expand all Loading... |
237 class ListenerThatQuits : public IPC::Listener { | 237 class ListenerThatQuits : public IPC::Listener { |
238 public: | 238 public: |
239 ListenerThatQuits() { | 239 ListenerThatQuits() { |
240 } | 240 } |
241 | 241 |
242 bool OnMessageReceived(const IPC::Message& message) override { | 242 bool OnMessageReceived(const IPC::Message& message) override { |
243 return true; | 243 return true; |
244 } | 244 } |
245 | 245 |
246 void OnChannelConnected(int32_t peer_pid) override { | 246 void OnChannelConnected(int32_t peer_pid) override { |
247 base::MessageLoop::current()->Quit(); | 247 base::MessageLoop::current()->QuitWhenIdle(); |
248 } | 248 } |
249 }; | 249 }; |
250 | 250 |
251 // A long running process that connects to us. | 251 // A long running process that connects to us. |
252 MULTIPROCESS_IPC_TEST_CLIENT_MAIN(IPCChannelMojoErraticTestClient) { | 252 MULTIPROCESS_IPC_TEST_CLIENT_MAIN(IPCChannelMojoErraticTestClient) { |
253 ListenerThatQuits listener; | 253 ListenerThatQuits listener; |
254 ChannelClient client(&listener, "IPCChannelMojoErraticTestClient"); | 254 ChannelClient client(&listener, "IPCChannelMojoErraticTestClient"); |
255 client.Connect(); | 255 client.Connect(); |
256 | 256 |
257 base::MessageLoop::current()->Run(); | 257 base::MessageLoop::current()->Run(); |
(...skipping 129 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
387 | 387 |
388 class ListenerThatExpectsMessagePipe : public IPC::Listener { | 388 class ListenerThatExpectsMessagePipe : public IPC::Listener { |
389 public: | 389 public: |
390 ListenerThatExpectsMessagePipe() : sender_(NULL) {} | 390 ListenerThatExpectsMessagePipe() : sender_(NULL) {} |
391 | 391 |
392 ~ListenerThatExpectsMessagePipe() override {} | 392 ~ListenerThatExpectsMessagePipe() override {} |
393 | 393 |
394 bool OnMessageReceived(const IPC::Message& message) override { | 394 bool OnMessageReceived(const IPC::Message& message) override { |
395 base::PickleIterator iter(message); | 395 base::PickleIterator iter(message); |
396 HandleSendingHelper::ReadReceivedPipe(message, &iter); | 396 HandleSendingHelper::ReadReceivedPipe(message, &iter); |
397 base::MessageLoop::current()->Quit(); | 397 base::MessageLoop::current()->QuitWhenIdle(); |
398 ListenerThatExpectsOK::SendOK(sender_); | 398 ListenerThatExpectsOK::SendOK(sender_); |
399 return true; | 399 return true; |
400 } | 400 } |
401 | 401 |
402 void OnChannelError() override { NOTREACHED(); } | 402 void OnChannelError() override { NOTREACHED(); } |
403 | 403 |
404 void set_sender(IPC::Sender* sender) { sender_ = sender; } | 404 void set_sender(IPC::Sender* sender) { sender_ = sender; } |
405 | 405 |
406 private: | 406 private: |
407 IPC::Sender* sender_; | 407 IPC::Sender* sender_; |
(...skipping 63 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
471 base::PickleIterator iter(message); | 471 base::PickleIterator iter(message); |
472 mojo::MessagePipeHandle handle; | 472 mojo::MessagePipeHandle handle; |
473 EXPECT_TRUE(IPC::ParamTraits<mojo::MessagePipeHandle>::Read(&message, &iter, | 473 EXPECT_TRUE(IPC::ParamTraits<mojo::MessagePipeHandle>::Read(&message, &iter, |
474 &handle)); | 474 &handle)); |
475 EXPECT_EQ(handle.is_valid(), receiving_valid_); | 475 EXPECT_EQ(handle.is_valid(), receiving_valid_); |
476 if (receiving_valid_) { | 476 if (receiving_valid_) { |
477 ReadOK(handle); | 477 ReadOK(handle); |
478 MojoClose(handle.value()); | 478 MojoClose(handle.value()); |
479 } | 479 } |
480 | 480 |
481 base::MessageLoop::current()->Quit(); | 481 base::MessageLoop::current()->QuitWhenIdle(); |
482 ListenerThatExpectsOK::SendOK(sender_); | 482 ListenerThatExpectsOK::SendOK(sender_); |
483 return true; | 483 return true; |
484 } | 484 } |
485 | 485 |
486 void OnChannelError() override { NOTREACHED(); } | 486 void OnChannelError() override { NOTREACHED(); } |
487 void set_sender(IPC::Sender* sender) { sender_ = sender; } | 487 void set_sender(IPC::Sender* sender) { sender_ = sender; } |
488 | 488 |
489 private: | 489 private: |
490 IPC::Sender* sender_; | 490 IPC::Sender* sender_; |
491 bool receiving_valid_; | 491 bool receiving_valid_; |
(...skipping 98 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
590 public: | 590 public: |
591 ListenerSendingOneOk() { | 591 ListenerSendingOneOk() { |
592 } | 592 } |
593 | 593 |
594 bool OnMessageReceived(const IPC::Message& message) override { | 594 bool OnMessageReceived(const IPC::Message& message) override { |
595 return true; | 595 return true; |
596 } | 596 } |
597 | 597 |
598 void OnChannelConnected(int32_t peer_pid) override { | 598 void OnChannelConnected(int32_t peer_pid) override { |
599 ListenerThatExpectsOK::SendOK(sender_); | 599 ListenerThatExpectsOK::SendOK(sender_); |
600 base::MessageLoop::current()->Quit(); | 600 base::MessageLoop::current()->QuitWhenIdle(); |
601 } | 601 } |
602 | 602 |
603 void set_sender(IPC::Sender* sender) { sender_ = sender; } | 603 void set_sender(IPC::Sender* sender) { sender_ = sender; } |
604 | 604 |
605 private: | 605 private: |
606 IPC::Sender* sender_; | 606 IPC::Sender* sender_; |
607 }; | 607 }; |
608 | 608 |
609 MULTIPROCESS_IPC_TEST_CLIENT_MAIN(IPCChannelMojoTestSendOkClient) { | 609 MULTIPROCESS_IPC_TEST_CLIENT_MAIN(IPCChannelMojoTestSendOkClient) { |
610 ListenerSendingOneOk listener; | 610 ListenerSendingOneOk listener; |
(...skipping 68 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
679 class ListenerThatExpectsFile : public IPC::Listener { | 679 class ListenerThatExpectsFile : public IPC::Listener { |
680 public: | 680 public: |
681 ListenerThatExpectsFile() | 681 ListenerThatExpectsFile() |
682 : sender_(NULL) {} | 682 : sender_(NULL) {} |
683 | 683 |
684 ~ListenerThatExpectsFile() override {} | 684 ~ListenerThatExpectsFile() override {} |
685 | 685 |
686 bool OnMessageReceived(const IPC::Message& message) override { | 686 bool OnMessageReceived(const IPC::Message& message) override { |
687 base::PickleIterator iter(message); | 687 base::PickleIterator iter(message); |
688 HandleSendingHelper::ReadReceivedFile(message, &iter); | 688 HandleSendingHelper::ReadReceivedFile(message, &iter); |
689 base::MessageLoop::current()->Quit(); | 689 base::MessageLoop::current()->QuitWhenIdle(); |
690 ListenerThatExpectsOK::SendOK(sender_); | 690 ListenerThatExpectsOK::SendOK(sender_); |
691 return true; | 691 return true; |
692 } | 692 } |
693 | 693 |
694 void OnChannelError() override { | 694 void OnChannelError() override { |
695 NOTREACHED(); | 695 NOTREACHED(); |
696 } | 696 } |
697 | 697 |
698 void set_sender(IPC::Sender* sender) { sender_ = sender; } | 698 void set_sender(IPC::Sender* sender) { sender_ = sender; } |
699 | 699 |
(...skipping 44 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
744 class ListenerThatExpectsFileAndPipe : public IPC::Listener { | 744 class ListenerThatExpectsFileAndPipe : public IPC::Listener { |
745 public: | 745 public: |
746 ListenerThatExpectsFileAndPipe() : sender_(NULL) {} | 746 ListenerThatExpectsFileAndPipe() : sender_(NULL) {} |
747 | 747 |
748 ~ListenerThatExpectsFileAndPipe() override {} | 748 ~ListenerThatExpectsFileAndPipe() override {} |
749 | 749 |
750 bool OnMessageReceived(const IPC::Message& message) override { | 750 bool OnMessageReceived(const IPC::Message& message) override { |
751 base::PickleIterator iter(message); | 751 base::PickleIterator iter(message); |
752 HandleSendingHelper::ReadReceivedFile(message, &iter); | 752 HandleSendingHelper::ReadReceivedFile(message, &iter); |
753 HandleSendingHelper::ReadReceivedPipe(message, &iter); | 753 HandleSendingHelper::ReadReceivedPipe(message, &iter); |
754 base::MessageLoop::current()->Quit(); | 754 base::MessageLoop::current()->QuitWhenIdle(); |
755 ListenerThatExpectsOK::SendOK(sender_); | 755 ListenerThatExpectsOK::SendOK(sender_); |
756 return true; | 756 return true; |
757 } | 757 } |
758 | 758 |
759 void OnChannelError() override { NOTREACHED(); } | 759 void OnChannelError() override { NOTREACHED(); } |
760 | 760 |
761 void set_sender(IPC::Sender* sender) { sender_ = sender; } | 761 void set_sender(IPC::Sender* sender) { sender_ = sender; } |
762 | 762 |
763 private: | 763 private: |
764 IPC::Sender* sender_; | 764 IPC::Sender* sender_; |
(...skipping 44 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
809 #endif | 809 #endif |
810 | 810 |
811 #if defined(OS_LINUX) | 811 #if defined(OS_LINUX) |
812 | 812 |
813 const base::ProcessId kMagicChildId = 54321; | 813 const base::ProcessId kMagicChildId = 54321; |
814 | 814 |
815 class ListenerThatVerifiesPeerPid : public IPC::Listener { | 815 class ListenerThatVerifiesPeerPid : public IPC::Listener { |
816 public: | 816 public: |
817 void OnChannelConnected(int32_t peer_pid) override { | 817 void OnChannelConnected(int32_t peer_pid) override { |
818 EXPECT_EQ(peer_pid, kMagicChildId); | 818 EXPECT_EQ(peer_pid, kMagicChildId); |
819 base::MessageLoop::current()->Quit(); | 819 base::MessageLoop::current()->QuitWhenIdle(); |
820 } | 820 } |
821 | 821 |
822 bool OnMessageReceived(const IPC::Message& message) override { | 822 bool OnMessageReceived(const IPC::Message& message) override { |
823 NOTREACHED(); | 823 NOTREACHED(); |
824 return true; | 824 return true; |
825 } | 825 } |
826 }; | 826 }; |
827 | 827 |
828 TEST_F(IPCChannelMojoTest, VerifyGlobalPid) { | 828 TEST_F(IPCChannelMojoTest, VerifyGlobalPid) { |
829 InitWithMojo("IPCChannelMojoTestVerifyGlobalPidClient"); | 829 InitWithMojo("IPCChannelMojoTestVerifyGlobalPidClient"); |
(...skipping 20 matching lines...) Expand all Loading... |
850 base::MessageLoop::current()->Run(); | 850 base::MessageLoop::current()->Run(); |
851 | 851 |
852 client.Close(); | 852 client.Close(); |
853 | 853 |
854 return 0; | 854 return 0; |
855 } | 855 } |
856 | 856 |
857 #endif // OS_LINUX | 857 #endif // OS_LINUX |
858 | 858 |
859 } // namespace | 859 } // namespace |
OLD | NEW |