| 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 <stdint.h> | 5 #include <stdint.h> |
| 6 #include <stdio.h> | 6 #include <stdio.h> |
| 7 #include <string.h> | 7 #include <string.h> |
| 8 | 8 |
| 9 #include <memory> | 9 #include <memory> |
| 10 #include <utility> | 10 #include <utility> |
| (...skipping 622 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
| 633 | 633 |
| 634 // Prepare to wait on MP 1, port 1. (Add the waiter now. Otherwise, if we do | 634 // Prepare to wait on MP 1, port 1. (Add the waiter now. Otherwise, if we do |
| 635 // it later, it might already be readable.) | 635 // it later, it might already be readable.) |
| 636 waiter.Init(); | 636 waiter.Init(); |
| 637 ASSERT_EQ( | 637 ASSERT_EQ( |
| 638 MOJO_RESULT_OK, | 638 MOJO_RESULT_OK, |
| 639 mp1->AddAwakable(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 123, nullptr)); | 639 mp1->AddAwakable(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 123, nullptr)); |
| 640 | 640 |
| 641 // Write to MP 0, port 0. | 641 // Write to MP 0, port 0. |
| 642 { | 642 { |
| 643 DispatcherTransport transport(test::HandleTryStartTransport(handle)); | 643 HandleTransport transport(test::HandleTryStartTransport(handle)); |
| 644 EXPECT_TRUE(transport.is_valid()); | 644 EXPECT_TRUE(transport.is_valid()); |
| 645 | 645 |
| 646 std::vector<DispatcherTransport> transports; | 646 std::vector<HandleTransport> transports; |
| 647 transports.push_back(transport); | 647 transports.push_back(transport); |
| 648 EXPECT_EQ( | 648 EXPECT_EQ( |
| 649 MOJO_RESULT_OK, | 649 MOJO_RESULT_OK, |
| 650 mp0->WriteMessage(0, UserPointer<const void>(kHello), sizeof(kHello), | 650 mp0->WriteMessage(0, UserPointer<const void>(kHello), sizeof(kHello), |
| 651 &transports, MOJO_WRITE_MESSAGE_FLAG_NONE)); | 651 &transports, MOJO_WRITE_MESSAGE_FLAG_NONE)); |
| 652 transport.End(); | 652 transport.End(); |
| 653 | 653 |
| 654 // |handle.dispatcher| should have been closed. This is |DCHECK()|ed when | 654 // |handle.dispatcher| should have been closed. This is |DCHECK()|ed when |
| 655 // the |handle.dispatcher| is destroyed. | 655 // the |handle.dispatcher| is destroyed. |
| 656 EXPECT_TRUE(handle.dispatcher->HasOneRef()); | 656 EXPECT_TRUE(handle.dispatcher->HasOneRef()); |
| (...skipping 153 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
| 810 | 810 |
| 811 // Prepare to wait on MP 1, port 1. (Add the waiter now. Otherwise, if we do | 811 // Prepare to wait on MP 1, port 1. (Add the waiter now. Otherwise, if we do |
| 812 // it later, it might already be readable.) | 812 // it later, it might already be readable.) |
| 813 waiter.Init(); | 813 waiter.Init(); |
| 814 ASSERT_EQ( | 814 ASSERT_EQ( |
| 815 MOJO_RESULT_OK, | 815 MOJO_RESULT_OK, |
| 816 mp1->AddAwakable(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 123, nullptr)); | 816 mp1->AddAwakable(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 123, nullptr)); |
| 817 | 817 |
| 818 // Write to MP 0, port 0. | 818 // Write to MP 0, port 0. |
| 819 { | 819 { |
| 820 DispatcherTransport transport(test::HandleTryStartTransport(handle)); | 820 HandleTransport transport(test::HandleTryStartTransport(handle)); |
| 821 EXPECT_TRUE(transport.is_valid()); | 821 EXPECT_TRUE(transport.is_valid()); |
| 822 | 822 |
| 823 std::vector<DispatcherTransport> transports; | 823 std::vector<HandleTransport> transports; |
| 824 transports.push_back(transport); | 824 transports.push_back(transport); |
| 825 EXPECT_EQ( | 825 EXPECT_EQ( |
| 826 MOJO_RESULT_OK, | 826 MOJO_RESULT_OK, |
| 827 mp0->WriteMessage(0, UserPointer<const void>(kHello), sizeof(kHello), | 827 mp0->WriteMessage(0, UserPointer<const void>(kHello), sizeof(kHello), |
| 828 &transports, MOJO_WRITE_MESSAGE_FLAG_NONE)); | 828 &transports, MOJO_WRITE_MESSAGE_FLAG_NONE)); |
| 829 transport.End(); | 829 transport.End(); |
| 830 | 830 |
| 831 // |handle.dispatcher| should have been closed. This is |DCHECK()|ed when | 831 // |handle.dispatcher| should have been closed. This is |DCHECK()|ed when |
| 832 // the |handle.dispatcher| is destroyed. | 832 // the |handle.dispatcher| is destroyed. |
| 833 EXPECT_TRUE(handle.dispatcher->HasOneRef()); | 833 EXPECT_TRUE(handle.dispatcher->HasOneRef()); |
| (...skipping 107 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
| 941 | 941 |
| 942 // Prepare to wait on MP 1, port 1. (Add the waiter now. Otherwise, if we do | 942 // Prepare to wait on MP 1, port 1. (Add the waiter now. Otherwise, if we do |
| 943 // it later, it might already be readable.) | 943 // it later, it might already be readable.) |
| 944 waiter.Init(); | 944 waiter.Init(); |
| 945 ASSERT_EQ( | 945 ASSERT_EQ( |
| 946 MOJO_RESULT_OK, | 946 MOJO_RESULT_OK, |
| 947 mp1->AddAwakable(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 123, nullptr)); | 947 mp1->AddAwakable(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 123, nullptr)); |
| 948 | 948 |
| 949 // Write to MP 0, port 0. | 949 // Write to MP 0, port 0. |
| 950 { | 950 { |
| 951 DispatcherTransport transport(test::HandleTryStartTransport(handle)); | 951 HandleTransport transport(test::HandleTryStartTransport(handle)); |
| 952 EXPECT_TRUE(transport.is_valid()); | 952 EXPECT_TRUE(transport.is_valid()); |
| 953 | 953 |
| 954 std::vector<DispatcherTransport> transports; | 954 std::vector<HandleTransport> transports; |
| 955 transports.push_back(transport); | 955 transports.push_back(transport); |
| 956 EXPECT_EQ( | 956 EXPECT_EQ( |
| 957 MOJO_RESULT_OK, | 957 MOJO_RESULT_OK, |
| 958 mp0->WriteMessage(0, UserPointer<const void>(kHello), sizeof(kHello), | 958 mp0->WriteMessage(0, UserPointer<const void>(kHello), sizeof(kHello), |
| 959 &transports, MOJO_WRITE_MESSAGE_FLAG_NONE)); | 959 &transports, MOJO_WRITE_MESSAGE_FLAG_NONE)); |
| 960 transport.End(); | 960 transport.End(); |
| 961 | 961 |
| 962 // |handle.dispatcher| should have been closed. This is |DCHECK()|ed when | 962 // |handle.dispatcher| should have been closed. This is |DCHECK()|ed when |
| 963 // the |handle.dispatcher| is destroyed. | 963 // the |handle.dispatcher| is destroyed. |
| 964 EXPECT_TRUE(handle.dispatcher->HasOneRef()); | 964 EXPECT_TRUE(handle.dispatcher->HasOneRef()); |
| (...skipping 89 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
| 1054 | 1054 |
| 1055 // Prepare to wait on MP 1, port 1. (Add the waiter now. Otherwise, if we do | 1055 // Prepare to wait on MP 1, port 1. (Add the waiter now. Otherwise, if we do |
| 1056 // it later, it might already be readable.) | 1056 // it later, it might already be readable.) |
| 1057 waiter.Init(); | 1057 waiter.Init(); |
| 1058 ASSERT_EQ( | 1058 ASSERT_EQ( |
| 1059 MOJO_RESULT_OK, | 1059 MOJO_RESULT_OK, |
| 1060 mp1->AddAwakable(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 123, nullptr)); | 1060 mp1->AddAwakable(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 123, nullptr)); |
| 1061 | 1061 |
| 1062 // Write to MP 0, port 0. | 1062 // Write to MP 0, port 0. |
| 1063 { | 1063 { |
| 1064 DispatcherTransport transport(test::HandleTryStartTransport(handle)); | 1064 HandleTransport transport(test::HandleTryStartTransport(handle)); |
| 1065 EXPECT_TRUE(transport.is_valid()); | 1065 EXPECT_TRUE(transport.is_valid()); |
| 1066 | 1066 |
| 1067 std::vector<DispatcherTransport> transports; | 1067 std::vector<HandleTransport> transports; |
| 1068 transports.push_back(transport); | 1068 transports.push_back(transport); |
| 1069 EXPECT_EQ( | 1069 EXPECT_EQ( |
| 1070 MOJO_RESULT_OK, | 1070 MOJO_RESULT_OK, |
| 1071 mp0->WriteMessage(0, UserPointer<const void>(kWorld), sizeof(kWorld), | 1071 mp0->WriteMessage(0, UserPointer<const void>(kWorld), sizeof(kWorld), |
| 1072 &transports, MOJO_WRITE_MESSAGE_FLAG_NONE)); | 1072 &transports, MOJO_WRITE_MESSAGE_FLAG_NONE)); |
| 1073 transport.End(); | 1073 transport.End(); |
| 1074 | 1074 |
| 1075 // |handle.dispatcher| should have been closed. This is |DCHECK()|ed when | 1075 // |handle.dispatcher| should have been closed. This is |DCHECK()|ed when |
| 1076 // the |handle.dispatcher| is destroyed. | 1076 // the |handle.dispatcher| is destroyed. |
| 1077 EXPECT_TRUE(handle.dispatcher->HasOneRef()); | 1077 EXPECT_TRUE(handle.dispatcher->HasOneRef()); |
| (...skipping 113 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
| 1191 | 1191 |
| 1192 // Prepare to wait on MP 1, port 1. (Add the waiter now. Otherwise, if we do | 1192 // Prepare to wait on MP 1, port 1. (Add the waiter now. Otherwise, if we do |
| 1193 // it later, it might already be readable.) | 1193 // it later, it might already be readable.) |
| 1194 waiter.Init(); | 1194 waiter.Init(); |
| 1195 ASSERT_EQ( | 1195 ASSERT_EQ( |
| 1196 MOJO_RESULT_OK, | 1196 MOJO_RESULT_OK, |
| 1197 mp1->AddAwakable(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 123, nullptr)); | 1197 mp1->AddAwakable(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 123, nullptr)); |
| 1198 | 1198 |
| 1199 // Write to MP 0, port 0. | 1199 // Write to MP 0, port 0. |
| 1200 { | 1200 { |
| 1201 DispatcherTransport transport(test::HandleTryStartTransport(handle)); | 1201 HandleTransport transport(test::HandleTryStartTransport(handle)); |
| 1202 EXPECT_TRUE(transport.is_valid()); | 1202 EXPECT_TRUE(transport.is_valid()); |
| 1203 | 1203 |
| 1204 std::vector<DispatcherTransport> transports; | 1204 std::vector<HandleTransport> transports; |
| 1205 transports.push_back(transport); | 1205 transports.push_back(transport); |
| 1206 EXPECT_EQ( | 1206 EXPECT_EQ( |
| 1207 MOJO_RESULT_OK, | 1207 MOJO_RESULT_OK, |
| 1208 mp0->WriteMessage(0, UserPointer<const void>(kHello), sizeof(kHello), | 1208 mp0->WriteMessage(0, UserPointer<const void>(kHello), sizeof(kHello), |
| 1209 &transports, MOJO_WRITE_MESSAGE_FLAG_NONE)); | 1209 &transports, MOJO_WRITE_MESSAGE_FLAG_NONE)); |
| 1210 transport.End(); | 1210 transport.End(); |
| 1211 | 1211 |
| 1212 // |handle.dispatcher| should have been closed. This is |DCHECK()|ed when | 1212 // |handle.dispatcher| should have been closed. This is |DCHECK()|ed when |
| 1213 // the |handle.dispatcher| is destroyed. | 1213 // the |handle.dispatcher| is destroyed. |
| 1214 EXPECT_TRUE(handle.dispatcher->HasOneRef()); | 1214 EXPECT_TRUE(handle.dispatcher->HasOneRef()); |
| (...skipping 39 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
| 1254 | 1254 |
| 1255 // Prepare to wait on MP 0, port 0. (Add the waiter now. Otherwise, if we do | 1255 // Prepare to wait on MP 0, port 0. (Add the waiter now. Otherwise, if we do |
| 1256 // it later, it might already be readable.) | 1256 // it later, it might already be readable.) |
| 1257 waiter.Init(); | 1257 waiter.Init(); |
| 1258 ASSERT_EQ( | 1258 ASSERT_EQ( |
| 1259 MOJO_RESULT_OK, | 1259 MOJO_RESULT_OK, |
| 1260 mp0->AddAwakable(0, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 456, nullptr)); | 1260 mp0->AddAwakable(0, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 456, nullptr)); |
| 1261 | 1261 |
| 1262 // Write to MP 1, port 1. | 1262 // Write to MP 1, port 1. |
| 1263 { | 1263 { |
| 1264 DispatcherTransport transport(test::HandleTryStartTransport(handle)); | 1264 HandleTransport transport(test::HandleTryStartTransport(handle)); |
| 1265 EXPECT_TRUE(transport.is_valid()); | 1265 EXPECT_TRUE(transport.is_valid()); |
| 1266 | 1266 |
| 1267 std::vector<DispatcherTransport> transports; | 1267 std::vector<HandleTransport> transports; |
| 1268 transports.push_back(transport); | 1268 transports.push_back(transport); |
| 1269 EXPECT_EQ( | 1269 EXPECT_EQ( |
| 1270 MOJO_RESULT_OK, | 1270 MOJO_RESULT_OK, |
| 1271 mp1->WriteMessage(1, UserPointer<const void>(kWorld), sizeof(kWorld), | 1271 mp1->WriteMessage(1, UserPointer<const void>(kWorld), sizeof(kWorld), |
| 1272 &transports, MOJO_WRITE_MESSAGE_FLAG_NONE)); | 1272 &transports, MOJO_WRITE_MESSAGE_FLAG_NONE)); |
| 1273 transport.End(); | 1273 transport.End(); |
| 1274 | 1274 |
| 1275 // |handle.dispatcher| should have been closed. This is |DCHECK()|ed when | 1275 // |handle.dispatcher| should have been closed. This is |DCHECK()|ed when |
| 1276 // the |handle.dispatcher| is destroyed. | 1276 // the |handle.dispatcher| is destroyed. |
| 1277 EXPECT_TRUE(handle.dispatcher->HasOneRef()); | 1277 EXPECT_TRUE(handle.dispatcher->HasOneRef()); |
| (...skipping 97 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
| 1375 mp0->Close(0); | 1375 mp0->Close(0); |
| 1376 mp1->Close(1); | 1376 mp1->Close(1); |
| 1377 EXPECT_EQ(MOJO_RESULT_OK, dispatcher->Close()); | 1377 EXPECT_EQ(MOJO_RESULT_OK, dispatcher->Close()); |
| 1378 // Note that |local_mp|'s port 0 belong to |dispatcher|, which was closed. | 1378 // Note that |local_mp|'s port 0 belong to |dispatcher|, which was closed. |
| 1379 local_mp->Close(1); | 1379 local_mp->Close(1); |
| 1380 } | 1380 } |
| 1381 | 1381 |
| 1382 } // namespace | 1382 } // namespace |
| 1383 } // namespace system | 1383 } // namespace system |
| 1384 } // namespace mojo | 1384 } // namespace mojo |
| OLD | NEW |