OLD | NEW |
1 // Copyright (c) 2011 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2011 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 "net/socket/client_socket_pool_base.h" | 5 #include "net/socket/client_socket_pool_base.h" |
6 | 6 |
| 7 #include "base/bind.h" |
| 8 #include "base/bind_helpers.h" |
7 #include "base/callback.h" | 9 #include "base/callback.h" |
8 #include "base/compiler_specific.h" | 10 #include "base/compiler_specific.h" |
9 #include "base/memory/ref_counted.h" | 11 #include "base/memory/ref_counted.h" |
10 #include "base/memory/scoped_vector.h" | 12 #include "base/memory/scoped_vector.h" |
11 #include "base/message_loop.h" | 13 #include "base/message_loop.h" |
12 #include "base/stringprintf.h" | 14 #include "base/stringprintf.h" |
13 #include "base/string_number_conversions.h" | 15 #include "base/string_number_conversions.h" |
14 #include "base/threading/platform_thread.h" | 16 #include "base/threading/platform_thread.h" |
15 #include "base/values.h" | 17 #include "base/values.h" |
16 #include "net/base/net_errors.h" | 18 #include "net/base/net_errors.h" |
(...skipping 761 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
778 NetLog::PHASE_NONE)); | 780 NetLog::PHASE_NONE)); |
779 EXPECT_TRUE(LogContainsEndEvent( | 781 EXPECT_TRUE(LogContainsEndEvent( |
780 entries, 4, NetLog::TYPE_SOCKET_POOL_CONNECT_JOB_CONNECT)); | 782 entries, 4, NetLog::TYPE_SOCKET_POOL_CONNECT_JOB_CONNECT)); |
781 EXPECT_TRUE(LogContainsEndEvent( | 783 EXPECT_TRUE(LogContainsEndEvent( |
782 entries, 5, NetLog::TYPE_SOCKET_POOL_CONNECT_JOB)); | 784 entries, 5, NetLog::TYPE_SOCKET_POOL_CONNECT_JOB)); |
783 } | 785 } |
784 | 786 |
785 TEST_F(ClientSocketPoolBaseTest, BasicSynchronous) { | 787 TEST_F(ClientSocketPoolBaseTest, BasicSynchronous) { |
786 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); | 788 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); |
787 | 789 |
788 TestOldCompletionCallback callback; | 790 TestCompletionCallback callback; |
789 ClientSocketHandle handle; | 791 ClientSocketHandle handle; |
790 CapturingBoundNetLog log(CapturingNetLog::kUnbounded); | 792 CapturingBoundNetLog log(CapturingNetLog::kUnbounded); |
791 | 793 |
792 EXPECT_EQ(OK, | 794 EXPECT_EQ(OK, |
793 handle.Init("a", | 795 handle.Init("a", |
794 params_, | 796 params_, |
795 kDefaultPriority, | 797 kDefaultPriority, |
796 &callback, | 798 callback.callback(), |
797 pool_.get(), | 799 pool_.get(), |
798 log.bound())); | 800 log.bound())); |
799 EXPECT_TRUE(handle.is_initialized()); | 801 EXPECT_TRUE(handle.is_initialized()); |
800 EXPECT_TRUE(handle.socket()); | 802 EXPECT_TRUE(handle.socket()); |
801 handle.Reset(); | 803 handle.Reset(); |
802 | 804 |
803 net::CapturingNetLog::EntryList entries; | 805 net::CapturingNetLog::EntryList entries; |
804 log.GetEntries(&entries); | 806 log.GetEntries(&entries); |
805 | 807 |
806 EXPECT_EQ(4u, entries.size()); | 808 EXPECT_EQ(4u, entries.size()); |
807 EXPECT_TRUE(LogContainsBeginEvent( | 809 EXPECT_TRUE(LogContainsBeginEvent( |
808 entries, 0, NetLog::TYPE_SOCKET_POOL)); | 810 entries, 0, NetLog::TYPE_SOCKET_POOL)); |
809 EXPECT_TRUE(LogContainsEvent( | 811 EXPECT_TRUE(LogContainsEvent( |
810 entries, 1, NetLog::TYPE_SOCKET_POOL_BOUND_TO_CONNECT_JOB, | 812 entries, 1, NetLog::TYPE_SOCKET_POOL_BOUND_TO_CONNECT_JOB, |
811 NetLog::PHASE_NONE)); | 813 NetLog::PHASE_NONE)); |
812 EXPECT_TRUE(LogContainsEvent( | 814 EXPECT_TRUE(LogContainsEvent( |
813 entries, 2, NetLog::TYPE_SOCKET_POOL_BOUND_TO_SOCKET, | 815 entries, 2, NetLog::TYPE_SOCKET_POOL_BOUND_TO_SOCKET, |
814 NetLog::PHASE_NONE)); | 816 NetLog::PHASE_NONE)); |
815 EXPECT_TRUE(LogContainsEndEvent( | 817 EXPECT_TRUE(LogContainsEndEvent( |
816 entries, 3, NetLog::TYPE_SOCKET_POOL)); | 818 entries, 3, NetLog::TYPE_SOCKET_POOL)); |
817 } | 819 } |
818 | 820 |
819 TEST_F(ClientSocketPoolBaseTest, InitConnectionFailure) { | 821 TEST_F(ClientSocketPoolBaseTest, InitConnectionFailure) { |
820 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); | 822 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); |
821 | 823 |
822 connect_job_factory_->set_job_type(TestConnectJob::kMockFailingJob); | 824 connect_job_factory_->set_job_type(TestConnectJob::kMockFailingJob); |
823 CapturingBoundNetLog log(CapturingNetLog::kUnbounded); | 825 CapturingBoundNetLog log(CapturingNetLog::kUnbounded); |
824 | 826 |
825 ClientSocketHandle handle; | 827 ClientSocketHandle handle; |
826 TestOldCompletionCallback callback; | 828 TestCompletionCallback callback; |
827 // Set the additional error state members to ensure that they get cleared. | 829 // Set the additional error state members to ensure that they get cleared. |
828 handle.set_is_ssl_error(true); | 830 handle.set_is_ssl_error(true); |
829 HttpResponseInfo info; | 831 HttpResponseInfo info; |
830 info.headers = new HttpResponseHeaders(""); | 832 info.headers = new HttpResponseHeaders(""); |
831 handle.set_ssl_error_response_info(info); | 833 handle.set_ssl_error_response_info(info); |
832 EXPECT_EQ(ERR_CONNECTION_FAILED, | 834 EXPECT_EQ(ERR_CONNECTION_FAILED, |
833 handle.Init("a", | 835 handle.Init("a", |
834 params_, | 836 params_, |
835 kDefaultPriority, | 837 kDefaultPriority, |
836 &callback, | 838 callback.callback(), |
837 pool_.get(), | 839 pool_.get(), |
838 log.bound())); | 840 log.bound())); |
839 EXPECT_FALSE(handle.socket()); | 841 EXPECT_FALSE(handle.socket()); |
840 EXPECT_FALSE(handle.is_ssl_error()); | 842 EXPECT_FALSE(handle.is_ssl_error()); |
841 EXPECT_TRUE(handle.ssl_error_response_info().headers.get() == NULL); | 843 EXPECT_TRUE(handle.ssl_error_response_info().headers.get() == NULL); |
842 | 844 |
843 net::CapturingNetLog::EntryList entries; | 845 net::CapturingNetLog::EntryList entries; |
844 log.GetEntries(&entries); | 846 log.GetEntries(&entries); |
845 | 847 |
846 EXPECT_EQ(3u, entries.size()); | 848 EXPECT_EQ(3u, entries.size()); |
(...skipping 213 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1060 EXPECT_TRUE(ReleaseOneConnection(ClientSocketPoolTest::KEEP_ALIVE)); | 1062 EXPECT_TRUE(ReleaseOneConnection(ClientSocketPoolTest::KEEP_ALIVE)); |
1061 EXPECT_TRUE(ReleaseOneConnection(ClientSocketPoolTest::KEEP_ALIVE)); | 1063 EXPECT_TRUE(ReleaseOneConnection(ClientSocketPoolTest::KEEP_ALIVE)); |
1062 EXPECT_EQ(kDefaultMaxSockets + 2, client_socket_factory_.allocation_count()); | 1064 EXPECT_EQ(kDefaultMaxSockets + 2, client_socket_factory_.allocation_count()); |
1063 } | 1065 } |
1064 | 1066 |
1065 TEST_F(ClientSocketPoolBaseTest, StallAndThenCancelAndTriggerAvailableSocket) { | 1067 TEST_F(ClientSocketPoolBaseTest, StallAndThenCancelAndTriggerAvailableSocket) { |
1066 CreatePool(kDefaultMaxSockets, kDefaultMaxSockets); | 1068 CreatePool(kDefaultMaxSockets, kDefaultMaxSockets); |
1067 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); | 1069 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); |
1068 | 1070 |
1069 ClientSocketHandle handle; | 1071 ClientSocketHandle handle; |
1070 TestOldCompletionCallback callback; | 1072 TestCompletionCallback callback; |
1071 EXPECT_EQ(ERR_IO_PENDING, | 1073 EXPECT_EQ(ERR_IO_PENDING, |
1072 handle.Init("a", | 1074 handle.Init("a", |
1073 params_, | 1075 params_, |
1074 kDefaultPriority, | 1076 kDefaultPriority, |
1075 &callback, | 1077 callback.callback(), |
1076 pool_.get(), | 1078 pool_.get(), |
1077 BoundNetLog())); | 1079 BoundNetLog())); |
1078 | 1080 |
1079 ClientSocketHandle handles[4]; | 1081 ClientSocketHandle handles[4]; |
1080 for (size_t i = 0; i < arraysize(handles); ++i) { | 1082 for (size_t i = 0; i < arraysize(handles); ++i) { |
1081 TestOldCompletionCallback callback; | 1083 TestCompletionCallback callback; |
1082 EXPECT_EQ(ERR_IO_PENDING, | 1084 EXPECT_EQ(ERR_IO_PENDING, |
1083 handles[i].Init("b", | 1085 handles[i].Init("b", |
1084 params_, | 1086 params_, |
1085 kDefaultPriority, | 1087 kDefaultPriority, |
1086 &callback, | 1088 callback.callback(), |
1087 pool_.get(), | 1089 pool_.get(), |
1088 BoundNetLog())); | 1090 BoundNetLog())); |
1089 } | 1091 } |
1090 | 1092 |
1091 // One will be stalled, cancel all the handles now. | 1093 // One will be stalled, cancel all the handles now. |
1092 // This should hit the OnAvailableSocketSlot() code where we previously had | 1094 // This should hit the OnAvailableSocketSlot() code where we previously had |
1093 // stalled groups, but no longer have any. | 1095 // stalled groups, but no longer have any. |
1094 for (size_t i = 0; i < arraysize(handles); ++i) | 1096 for (size_t i = 0; i < arraysize(handles); ++i) |
1095 handles[i].Reset(); | 1097 handles[i].Reset(); |
1096 } | 1098 } |
1097 | 1099 |
1098 TEST_F(ClientSocketPoolBaseTest, CancelStalledSocketAtSocketLimit) { | 1100 TEST_F(ClientSocketPoolBaseTest, CancelStalledSocketAtSocketLimit) { |
1099 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); | 1101 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); |
1100 connect_job_factory_->set_job_type(TestConnectJob::kMockJob); | 1102 connect_job_factory_->set_job_type(TestConnectJob::kMockJob); |
1101 | 1103 |
1102 { | 1104 { |
1103 ClientSocketHandle handles[kDefaultMaxSockets]; | 1105 ClientSocketHandle handles[kDefaultMaxSockets]; |
1104 TestOldCompletionCallback callbacks[kDefaultMaxSockets]; | 1106 TestCompletionCallback callbacks[kDefaultMaxSockets]; |
1105 for (int i = 0; i < kDefaultMaxSockets; ++i) { | 1107 for (int i = 0; i < kDefaultMaxSockets; ++i) { |
1106 EXPECT_EQ(OK, handles[i].Init(base::IntToString(i), | 1108 EXPECT_EQ(OK, handles[i].Init(base::IntToString(i), |
1107 params_, | 1109 params_, |
1108 kDefaultPriority, | 1110 kDefaultPriority, |
1109 &callbacks[i], | 1111 callbacks[i].callback(), |
1110 pool_.get(), | 1112 pool_.get(), |
1111 BoundNetLog())); | 1113 BoundNetLog())); |
1112 } | 1114 } |
1113 | 1115 |
1114 // Force a stalled group. | 1116 // Force a stalled group. |
1115 ClientSocketHandle stalled_handle; | 1117 ClientSocketHandle stalled_handle; |
1116 TestOldCompletionCallback callback; | 1118 TestCompletionCallback callback; |
1117 EXPECT_EQ(ERR_IO_PENDING, stalled_handle.Init("foo", | 1119 EXPECT_EQ(ERR_IO_PENDING, stalled_handle.Init("foo", |
1118 params_, | 1120 params_, |
1119 kDefaultPriority, | 1121 kDefaultPriority, |
1120 &callback, | 1122 callback.callback(), |
1121 pool_.get(), | 1123 pool_.get(), |
1122 BoundNetLog())); | 1124 BoundNetLog())); |
1123 | 1125 |
1124 // Cancel the stalled request. | 1126 // Cancel the stalled request. |
1125 stalled_handle.Reset(); | 1127 stalled_handle.Reset(); |
1126 | 1128 |
1127 EXPECT_EQ(kDefaultMaxSockets, client_socket_factory_.allocation_count()); | 1129 EXPECT_EQ(kDefaultMaxSockets, client_socket_factory_.allocation_count()); |
1128 EXPECT_EQ(0, pool_->IdleSocketCount()); | 1130 EXPECT_EQ(0, pool_->IdleSocketCount()); |
1129 | 1131 |
1130 // Dropping out of scope will close all handles and return them to idle. | 1132 // Dropping out of scope will close all handles and return them to idle. |
1131 } | 1133 } |
1132 | 1134 |
1133 EXPECT_EQ(kDefaultMaxSockets, client_socket_factory_.allocation_count()); | 1135 EXPECT_EQ(kDefaultMaxSockets, client_socket_factory_.allocation_count()); |
1134 EXPECT_EQ(kDefaultMaxSockets, pool_->IdleSocketCount()); | 1136 EXPECT_EQ(kDefaultMaxSockets, pool_->IdleSocketCount()); |
1135 } | 1137 } |
1136 | 1138 |
1137 TEST_F(ClientSocketPoolBaseTest, CancelPendingSocketAtSocketLimit) { | 1139 TEST_F(ClientSocketPoolBaseTest, CancelPendingSocketAtSocketLimit) { |
1138 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); | 1140 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); |
1139 connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob); | 1141 connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob); |
1140 | 1142 |
1141 { | 1143 { |
1142 ClientSocketHandle handles[kDefaultMaxSockets]; | 1144 ClientSocketHandle handles[kDefaultMaxSockets]; |
1143 for (int i = 0; i < kDefaultMaxSockets; ++i) { | 1145 for (int i = 0; i < kDefaultMaxSockets; ++i) { |
1144 TestOldCompletionCallback callback; | 1146 TestCompletionCallback callback; |
1145 EXPECT_EQ(ERR_IO_PENDING, handles[i].Init(base::IntToString(i), | 1147 EXPECT_EQ(ERR_IO_PENDING, handles[i].Init(base::IntToString(i), |
1146 params_, | 1148 params_, |
1147 kDefaultPriority, | 1149 kDefaultPriority, |
1148 &callback, | 1150 callback.callback(), |
1149 pool_.get(), | 1151 pool_.get(), |
1150 BoundNetLog())); | 1152 BoundNetLog())); |
1151 } | 1153 } |
1152 | 1154 |
1153 // Force a stalled group. | 1155 // Force a stalled group. |
1154 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); | 1156 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); |
1155 ClientSocketHandle stalled_handle; | 1157 ClientSocketHandle stalled_handle; |
1156 TestOldCompletionCallback callback; | 1158 TestCompletionCallback callback; |
1157 EXPECT_EQ(ERR_IO_PENDING, stalled_handle.Init("foo", | 1159 EXPECT_EQ(ERR_IO_PENDING, stalled_handle.Init("foo", |
1158 params_, | 1160 params_, |
1159 kDefaultPriority, | 1161 kDefaultPriority, |
1160 &callback, | 1162 callback.callback(), |
1161 pool_.get(), | 1163 pool_.get(), |
1162 BoundNetLog())); | 1164 BoundNetLog())); |
1163 | 1165 |
1164 // Since it is stalled, it should have no connect jobs. | 1166 // Since it is stalled, it should have no connect jobs. |
1165 EXPECT_EQ(0, pool_->NumConnectJobsInGroup("foo")); | 1167 EXPECT_EQ(0, pool_->NumConnectJobsInGroup("foo")); |
1166 | 1168 |
1167 // Cancel the stalled request. | 1169 // Cancel the stalled request. |
1168 handles[0].Reset(); | 1170 handles[0].Reset(); |
1169 | 1171 |
1170 // Now we should have a connect job. | 1172 // Now we should have a connect job. |
(...skipping 11 matching lines...) Expand all Loading... |
1182 } | 1184 } |
1183 | 1185 |
1184 EXPECT_EQ(1, pool_->IdleSocketCount()); | 1186 EXPECT_EQ(1, pool_->IdleSocketCount()); |
1185 } | 1187 } |
1186 | 1188 |
1187 TEST_F(ClientSocketPoolBaseTest, WaitForStalledSocketAtSocketLimit) { | 1189 TEST_F(ClientSocketPoolBaseTest, WaitForStalledSocketAtSocketLimit) { |
1188 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); | 1190 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); |
1189 connect_job_factory_->set_job_type(TestConnectJob::kMockJob); | 1191 connect_job_factory_->set_job_type(TestConnectJob::kMockJob); |
1190 | 1192 |
1191 ClientSocketHandle stalled_handle; | 1193 ClientSocketHandle stalled_handle; |
1192 TestOldCompletionCallback callback; | 1194 TestCompletionCallback callback; |
1193 { | 1195 { |
1194 EXPECT_FALSE(pool_->IsStalled()); | 1196 EXPECT_FALSE(pool_->IsStalled()); |
1195 ClientSocketHandle handles[kDefaultMaxSockets]; | 1197 ClientSocketHandle handles[kDefaultMaxSockets]; |
1196 for (int i = 0; i < kDefaultMaxSockets; ++i) { | 1198 for (int i = 0; i < kDefaultMaxSockets; ++i) { |
1197 TestOldCompletionCallback callback; | 1199 TestCompletionCallback callback; |
1198 EXPECT_EQ(OK, handles[i].Init(base::StringPrintf( | 1200 EXPECT_EQ(OK, handles[i].Init(base::StringPrintf( |
1199 "Take 2: %d", i), | 1201 "Take 2: %d", i), |
1200 params_, | 1202 params_, |
1201 kDefaultPriority, | 1203 kDefaultPriority, |
1202 &callback, | 1204 callback.callback(), |
1203 pool_.get(), | 1205 pool_.get(), |
1204 BoundNetLog())); | 1206 BoundNetLog())); |
1205 } | 1207 } |
1206 | 1208 |
1207 EXPECT_EQ(kDefaultMaxSockets, client_socket_factory_.allocation_count()); | 1209 EXPECT_EQ(kDefaultMaxSockets, client_socket_factory_.allocation_count()); |
1208 EXPECT_EQ(0, pool_->IdleSocketCount()); | 1210 EXPECT_EQ(0, pool_->IdleSocketCount()); |
1209 EXPECT_FALSE(pool_->IsStalled()); | 1211 EXPECT_FALSE(pool_->IsStalled()); |
1210 | 1212 |
1211 // Now we will hit the socket limit. | 1213 // Now we will hit the socket limit. |
1212 EXPECT_EQ(ERR_IO_PENDING, stalled_handle.Init("foo", | 1214 EXPECT_EQ(ERR_IO_PENDING, stalled_handle.Init("foo", |
1213 params_, | 1215 params_, |
1214 kDefaultPriority, | 1216 kDefaultPriority, |
1215 &callback, | 1217 callback.callback(), |
1216 pool_.get(), | 1218 pool_.get(), |
1217 BoundNetLog())); | 1219 BoundNetLog())); |
1218 EXPECT_TRUE(pool_->IsStalled()); | 1220 EXPECT_TRUE(pool_->IsStalled()); |
1219 | 1221 |
1220 // Dropping out of scope will close all handles and return them to idle. | 1222 // Dropping out of scope will close all handles and return them to idle. |
1221 } | 1223 } |
1222 | 1224 |
1223 // But if we wait for it, the released idle sockets will be closed in | 1225 // But if we wait for it, the released idle sockets will be closed in |
1224 // preference of the waiting request. | 1226 // preference of the waiting request. |
1225 EXPECT_EQ(OK, callback.WaitForResult()); | 1227 EXPECT_EQ(OK, callback.WaitForResult()); |
1226 | 1228 |
1227 EXPECT_EQ(kDefaultMaxSockets + 1, client_socket_factory_.allocation_count()); | 1229 EXPECT_EQ(kDefaultMaxSockets + 1, client_socket_factory_.allocation_count()); |
1228 EXPECT_EQ(3, pool_->IdleSocketCount()); | 1230 EXPECT_EQ(3, pool_->IdleSocketCount()); |
1229 } | 1231 } |
1230 | 1232 |
1231 // Regression test for http://crbug.com/40952. | 1233 // Regression test for http://crbug.com/40952. |
1232 TEST_F(ClientSocketPoolBaseTest, CloseIdleSocketAtSocketLimitDeleteGroup) { | 1234 TEST_F(ClientSocketPoolBaseTest, CloseIdleSocketAtSocketLimitDeleteGroup) { |
1233 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); | 1235 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); |
1234 pool_->EnableConnectBackupJobs(); | 1236 pool_->EnableConnectBackupJobs(); |
1235 connect_job_factory_->set_job_type(TestConnectJob::kMockJob); | 1237 connect_job_factory_->set_job_type(TestConnectJob::kMockJob); |
1236 | 1238 |
1237 for (int i = 0; i < kDefaultMaxSockets; ++i) { | 1239 for (int i = 0; i < kDefaultMaxSockets; ++i) { |
1238 ClientSocketHandle handle; | 1240 ClientSocketHandle handle; |
1239 TestOldCompletionCallback callback; | 1241 TestCompletionCallback callback; |
1240 EXPECT_EQ(OK, handle.Init(base::IntToString(i), | 1242 EXPECT_EQ(OK, handle.Init(base::IntToString(i), |
1241 params_, | 1243 params_, |
1242 kDefaultPriority, | 1244 kDefaultPriority, |
1243 &callback, | 1245 callback.callback(), |
1244 pool_.get(), | 1246 pool_.get(), |
1245 BoundNetLog())); | 1247 BoundNetLog())); |
1246 } | 1248 } |
1247 | 1249 |
1248 // Flush all the DoReleaseSocket tasks. | 1250 // Flush all the DoReleaseSocket tasks. |
1249 MessageLoop::current()->RunAllPending(); | 1251 MessageLoop::current()->RunAllPending(); |
1250 | 1252 |
1251 // Stall a group. Set a pending job so it'll trigger a backup job if we don't | 1253 // Stall a group. Set a pending job so it'll trigger a backup job if we don't |
1252 // reuse a socket. | 1254 // reuse a socket. |
1253 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); | 1255 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); |
1254 ClientSocketHandle handle; | 1256 ClientSocketHandle handle; |
1255 TestOldCompletionCallback callback; | 1257 TestCompletionCallback callback; |
1256 | 1258 |
1257 // "0" is special here, since it should be the first entry in the sorted map, | 1259 // "0" is special here, since it should be the first entry in the sorted map, |
1258 // which is the one which we would close an idle socket for. We shouldn't | 1260 // which is the one which we would close an idle socket for. We shouldn't |
1259 // close an idle socket though, since we should reuse the idle socket. | 1261 // close an idle socket though, since we should reuse the idle socket. |
1260 EXPECT_EQ(OK, handle.Init("0", | 1262 EXPECT_EQ(OK, handle.Init("0", |
1261 params_, | 1263 params_, |
1262 kDefaultPriority, | 1264 kDefaultPriority, |
1263 &callback, | 1265 callback.callback(), |
1264 pool_.get(), | 1266 pool_.get(), |
1265 BoundNetLog())); | 1267 BoundNetLog())); |
1266 | 1268 |
1267 EXPECT_EQ(kDefaultMaxSockets, client_socket_factory_.allocation_count()); | 1269 EXPECT_EQ(kDefaultMaxSockets, client_socket_factory_.allocation_count()); |
1268 EXPECT_EQ(kDefaultMaxSockets - 1, pool_->IdleSocketCount()); | 1270 EXPECT_EQ(kDefaultMaxSockets - 1, pool_->IdleSocketCount()); |
1269 } | 1271 } |
1270 | 1272 |
1271 TEST_F(ClientSocketPoolBaseTest, PendingRequests) { | 1273 TEST_F(ClientSocketPoolBaseTest, PendingRequests) { |
1272 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); | 1274 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); |
1273 | 1275 |
(...skipping 49 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1323 } | 1325 } |
1324 | 1326 |
1325 // This test will start up a RequestSocket() and then immediately Cancel() it. | 1327 // This test will start up a RequestSocket() and then immediately Cancel() it. |
1326 // The pending connect job will be cancelled and should not call back into | 1328 // The pending connect job will be cancelled and should not call back into |
1327 // ClientSocketPoolBase. | 1329 // ClientSocketPoolBase. |
1328 TEST_F(ClientSocketPoolBaseTest, CancelRequestClearGroup) { | 1330 TEST_F(ClientSocketPoolBaseTest, CancelRequestClearGroup) { |
1329 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); | 1331 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); |
1330 | 1332 |
1331 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); | 1333 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); |
1332 ClientSocketHandle handle; | 1334 ClientSocketHandle handle; |
1333 TestOldCompletionCallback callback; | 1335 TestCompletionCallback callback; |
1334 EXPECT_EQ(ERR_IO_PENDING, handle.Init("a", | 1336 EXPECT_EQ(ERR_IO_PENDING, handle.Init("a", |
1335 params_, | 1337 params_, |
1336 kDefaultPriority, | 1338 kDefaultPriority, |
1337 &callback, | 1339 callback.callback(), |
1338 pool_.get(), | 1340 pool_.get(), |
1339 BoundNetLog())); | 1341 BoundNetLog())); |
1340 handle.Reset(); | 1342 handle.Reset(); |
1341 } | 1343 } |
1342 | 1344 |
1343 TEST_F(ClientSocketPoolBaseTest, ConnectCancelConnect) { | 1345 TEST_F(ClientSocketPoolBaseTest, ConnectCancelConnect) { |
1344 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); | 1346 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); |
1345 | 1347 |
1346 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); | 1348 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); |
1347 ClientSocketHandle handle; | 1349 ClientSocketHandle handle; |
1348 TestOldCompletionCallback callback; | 1350 TestCompletionCallback callback; |
1349 | 1351 |
1350 EXPECT_EQ(ERR_IO_PENDING, handle.Init("a", | 1352 EXPECT_EQ(ERR_IO_PENDING, handle.Init("a", |
1351 params_, | 1353 params_, |
1352 kDefaultPriority, | 1354 kDefaultPriority, |
1353 &callback, | 1355 callback.callback(), |
1354 pool_.get(), | 1356 pool_.get(), |
1355 BoundNetLog())); | 1357 BoundNetLog())); |
1356 | 1358 |
1357 handle.Reset(); | 1359 handle.Reset(); |
1358 | 1360 |
1359 TestOldCompletionCallback callback2; | 1361 TestCompletionCallback callback2; |
1360 EXPECT_EQ(ERR_IO_PENDING, | 1362 EXPECT_EQ(ERR_IO_PENDING, |
1361 handle.Init("a", | 1363 handle.Init("a", |
1362 params_, | 1364 params_, |
1363 kDefaultPriority, | 1365 kDefaultPriority, |
1364 &callback2, | 1366 callback2.callback(), |
1365 pool_.get(), | 1367 pool_.get(), |
1366 BoundNetLog())); | 1368 BoundNetLog())); |
1367 | 1369 |
1368 EXPECT_EQ(OK, callback2.WaitForResult()); | 1370 EXPECT_EQ(OK, callback2.WaitForResult()); |
1369 EXPECT_FALSE(callback.have_result()); | 1371 EXPECT_FALSE(callback.have_result()); |
1370 | 1372 |
1371 handle.Reset(); | 1373 handle.Reset(); |
1372 } | 1374 } |
1373 | 1375 |
1374 TEST_F(ClientSocketPoolBaseTest, CancelRequest) { | 1376 TEST_F(ClientSocketPoolBaseTest, CancelRequest) { |
(...skipping 25 matching lines...) Expand all Loading... |
1400 EXPECT_EQ(3, GetOrderOfRequest(4)); | 1402 EXPECT_EQ(3, GetOrderOfRequest(4)); |
1401 EXPECT_EQ(ClientSocketPoolTest::kRequestNotFound, | 1403 EXPECT_EQ(ClientSocketPoolTest::kRequestNotFound, |
1402 GetOrderOfRequest(5)); // Canceled request. | 1404 GetOrderOfRequest(5)); // Canceled request. |
1403 EXPECT_EQ(4, GetOrderOfRequest(6)); | 1405 EXPECT_EQ(4, GetOrderOfRequest(6)); |
1404 EXPECT_EQ(6, GetOrderOfRequest(7)); | 1406 EXPECT_EQ(6, GetOrderOfRequest(7)); |
1405 | 1407 |
1406 // Make sure we test order of all requests made. | 1408 // Make sure we test order of all requests made. |
1407 EXPECT_EQ(ClientSocketPoolTest::kIndexOutOfBounds, GetOrderOfRequest(8)); | 1409 EXPECT_EQ(ClientSocketPoolTest::kIndexOutOfBounds, GetOrderOfRequest(8)); |
1408 } | 1410 } |
1409 | 1411 |
1410 class RequestSocketCallback : public CallbackRunner< Tuple1<int> > { | 1412 class RequestSocketCallback : public TestCompletionCallbackBase { |
1411 public: | 1413 public: |
1412 RequestSocketCallback(ClientSocketHandle* handle, | 1414 RequestSocketCallback(ClientSocketHandle* handle, |
1413 TestClientSocketPool* pool, | 1415 TestClientSocketPool* pool, |
1414 TestConnectJobFactory* test_connect_job_factory, | 1416 TestConnectJobFactory* test_connect_job_factory, |
1415 TestConnectJob::JobType next_job_type) | 1417 TestConnectJob::JobType next_job_type) |
1416 : handle_(handle), | 1418 : handle_(handle), |
1417 pool_(pool), | 1419 pool_(pool), |
1418 within_callback_(false), | 1420 within_callback_(false), |
1419 test_connect_job_factory_(test_connect_job_factory), | 1421 test_connect_job_factory_(test_connect_job_factory), |
1420 next_job_type_(next_job_type) {} | 1422 next_job_type_(next_job_type), |
| 1423 ALLOW_THIS_IN_INITIALIZER_LIST(callback_( |
| 1424 base::Bind(&RequestSocketCallback::OnComplete, |
| 1425 base::Unretained(this)))) { |
| 1426 } |
1421 | 1427 |
1422 virtual void RunWithParams(const Tuple1<int>& params) { | 1428 virtual ~RequestSocketCallback() {} |
1423 callback_.RunWithParams(params); | 1429 |
1424 ASSERT_EQ(OK, params.a); | 1430 const CompletionCallback& callback() const { return callback_; } |
| 1431 |
| 1432 private: |
| 1433 void OnComplete(int result) { |
| 1434 SetResult(result); |
| 1435 ASSERT_EQ(OK, result); |
1425 | 1436 |
1426 if (!within_callback_) { | 1437 if (!within_callback_) { |
1427 test_connect_job_factory_->set_job_type(next_job_type_); | 1438 test_connect_job_factory_->set_job_type(next_job_type_); |
1428 | 1439 |
1429 // Don't allow reuse of the socket. Disconnect it and then release it and | 1440 // Don't allow reuse of the socket. Disconnect it and then release it and |
1430 // run through the MessageLoop once to get it completely released. | 1441 // run through the MessageLoop once to get it completely released. |
1431 handle_->socket()->Disconnect(); | 1442 handle_->socket()->Disconnect(); |
1432 handle_->Reset(); | 1443 handle_->Reset(); |
1433 { | 1444 { |
1434 MessageLoop::ScopedNestableTaskAllower nestable( | 1445 MessageLoop::ScopedNestableTaskAllower nestable( |
1435 MessageLoop::current()); | 1446 MessageLoop::current()); |
1436 MessageLoop::current()->RunAllPending(); | 1447 MessageLoop::current()->RunAllPending(); |
1437 } | 1448 } |
1438 within_callback_ = true; | 1449 within_callback_ = true; |
1439 TestOldCompletionCallback next_job_callback; | 1450 TestCompletionCallback next_job_callback; |
1440 scoped_refptr<TestSocketParams> params(new TestSocketParams()); | 1451 scoped_refptr<TestSocketParams> params(new TestSocketParams()); |
1441 int rv = handle_->Init("a", | 1452 int rv = handle_->Init("a", |
1442 params, | 1453 params, |
1443 kDefaultPriority, | 1454 kDefaultPriority, |
1444 &next_job_callback, | 1455 next_job_callback.callback(), |
1445 pool_, | 1456 pool_, |
1446 BoundNetLog()); | 1457 BoundNetLog()); |
1447 switch (next_job_type_) { | 1458 switch (next_job_type_) { |
1448 case TestConnectJob::kMockJob: | 1459 case TestConnectJob::kMockJob: |
1449 EXPECT_EQ(OK, rv); | 1460 EXPECT_EQ(OK, rv); |
1450 break; | 1461 break; |
1451 case TestConnectJob::kMockPendingJob: | 1462 case TestConnectJob::kMockPendingJob: |
1452 EXPECT_EQ(ERR_IO_PENDING, rv); | 1463 EXPECT_EQ(ERR_IO_PENDING, rv); |
1453 | 1464 |
1454 // For pending jobs, wait for new socket to be created. This makes | 1465 // For pending jobs, wait for new socket to be created. This makes |
1455 // sure there are no more pending operations nor any unclosed sockets | 1466 // sure there are no more pending operations nor any unclosed sockets |
1456 // when the test finishes. | 1467 // when the test finishes. |
1457 // We need to give it a little bit of time to run, so that all the | 1468 // We need to give it a little bit of time to run, so that all the |
1458 // operations that happen on timers (e.g. cleanup of idle | 1469 // operations that happen on timers (e.g. cleanup of idle |
1459 // connections) can execute. | 1470 // connections) can execute. |
1460 { | 1471 { |
1461 MessageLoop::ScopedNestableTaskAllower nestable( | 1472 MessageLoop::ScopedNestableTaskAllower nestable( |
1462 MessageLoop::current()); | 1473 MessageLoop::current()); |
1463 base::PlatformThread::Sleep(10); | 1474 base::PlatformThread::Sleep(10); |
1464 EXPECT_EQ(OK, next_job_callback.WaitForResult()); | 1475 EXPECT_EQ(OK, next_job_callback.WaitForResult()); |
1465 } | 1476 } |
1466 break; | 1477 break; |
1467 default: | 1478 default: |
1468 FAIL() << "Unexpected job type: " << next_job_type_; | 1479 FAIL() << "Unexpected job type: " << next_job_type_; |
1469 break; | 1480 break; |
1470 } | 1481 } |
1471 } | 1482 } |
1472 } | 1483 } |
1473 | 1484 |
1474 int WaitForResult() { | |
1475 return callback_.WaitForResult(); | |
1476 } | |
1477 | |
1478 private: | |
1479 ClientSocketHandle* const handle_; | 1485 ClientSocketHandle* const handle_; |
1480 TestClientSocketPool* const pool_; | 1486 TestClientSocketPool* const pool_; |
1481 bool within_callback_; | 1487 bool within_callback_; |
1482 TestConnectJobFactory* const test_connect_job_factory_; | 1488 TestConnectJobFactory* const test_connect_job_factory_; |
1483 TestConnectJob::JobType next_job_type_; | 1489 TestConnectJob::JobType next_job_type_; |
1484 TestOldCompletionCallback callback_; | 1490 CompletionCallback callback_; |
1485 }; | 1491 }; |
1486 | 1492 |
1487 TEST_F(ClientSocketPoolBaseTest, RequestPendingJobTwice) { | 1493 TEST_F(ClientSocketPoolBaseTest, RequestPendingJobTwice) { |
1488 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); | 1494 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); |
1489 | 1495 |
1490 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); | 1496 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); |
1491 ClientSocketHandle handle; | 1497 ClientSocketHandle handle; |
1492 RequestSocketCallback callback( | 1498 RequestSocketCallback callback( |
1493 &handle, pool_.get(), connect_job_factory_, | 1499 &handle, pool_.get(), connect_job_factory_, |
1494 TestConnectJob::kMockPendingJob); | 1500 TestConnectJob::kMockPendingJob); |
1495 int rv = handle.Init("a", | 1501 int rv = handle.Init("a", |
1496 params_, | 1502 params_, |
1497 kDefaultPriority, | 1503 kDefaultPriority, |
1498 &callback, | 1504 callback.callback(), |
1499 pool_.get(), | 1505 pool_.get(), |
1500 BoundNetLog()); | 1506 BoundNetLog()); |
1501 ASSERT_EQ(ERR_IO_PENDING, rv); | 1507 ASSERT_EQ(ERR_IO_PENDING, rv); |
1502 | 1508 |
1503 EXPECT_EQ(OK, callback.WaitForResult()); | 1509 EXPECT_EQ(OK, callback.WaitForResult()); |
1504 } | 1510 } |
1505 | 1511 |
1506 TEST_F(ClientSocketPoolBaseTest, RequestPendingJobThenSynchronous) { | 1512 TEST_F(ClientSocketPoolBaseTest, RequestPendingJobThenSynchronous) { |
1507 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); | 1513 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); |
1508 | 1514 |
1509 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); | 1515 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); |
1510 ClientSocketHandle handle; | 1516 ClientSocketHandle handle; |
1511 RequestSocketCallback callback( | 1517 RequestSocketCallback callback( |
1512 &handle, pool_.get(), connect_job_factory_, TestConnectJob::kMockJob); | 1518 &handle, pool_.get(), connect_job_factory_, TestConnectJob::kMockJob); |
1513 int rv = handle.Init("a", | 1519 int rv = handle.Init("a", |
1514 params_, | 1520 params_, |
1515 kDefaultPriority, | 1521 kDefaultPriority, |
1516 &callback, | 1522 callback.callback(), |
1517 pool_.get(), | 1523 pool_.get(), |
1518 BoundNetLog()); | 1524 BoundNetLog()); |
1519 ASSERT_EQ(ERR_IO_PENDING, rv); | 1525 ASSERT_EQ(ERR_IO_PENDING, rv); |
1520 | 1526 |
1521 EXPECT_EQ(OK, callback.WaitForResult()); | 1527 EXPECT_EQ(OK, callback.WaitForResult()); |
1522 } | 1528 } |
1523 | 1529 |
1524 // Make sure that pending requests get serviced after active requests get | 1530 // Make sure that pending requests get serviced after active requests get |
1525 // cancelled. | 1531 // cancelled. |
1526 TEST_F(ClientSocketPoolBaseTest, CancelActiveRequestWithPendingRequests) { | 1532 TEST_F(ClientSocketPoolBaseTest, CancelActiveRequestWithPendingRequests) { |
(...skipping 43 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1570 for (size_t i = 0; i < kNumberOfRequests; ++i) | 1576 for (size_t i = 0; i < kNumberOfRequests; ++i) |
1571 EXPECT_EQ(ERR_CONNECTION_FAILED, request(i)->WaitForResult()); | 1577 EXPECT_EQ(ERR_CONNECTION_FAILED, request(i)->WaitForResult()); |
1572 } | 1578 } |
1573 | 1579 |
1574 TEST_F(ClientSocketPoolBaseTest, CancelActiveRequestThenRequestSocket) { | 1580 TEST_F(ClientSocketPoolBaseTest, CancelActiveRequestThenRequestSocket) { |
1575 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); | 1581 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); |
1576 | 1582 |
1577 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); | 1583 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); |
1578 | 1584 |
1579 ClientSocketHandle handle; | 1585 ClientSocketHandle handle; |
1580 TestOldCompletionCallback callback; | 1586 TestCompletionCallback callback; |
1581 int rv = handle.Init("a", | 1587 int rv = handle.Init("a", |
1582 params_, | 1588 params_, |
1583 kDefaultPriority, | 1589 kDefaultPriority, |
1584 &callback, | 1590 callback.callback(), |
1585 pool_.get(), | 1591 pool_.get(), |
1586 BoundNetLog()); | 1592 BoundNetLog()); |
1587 EXPECT_EQ(ERR_IO_PENDING, rv); | 1593 EXPECT_EQ(ERR_IO_PENDING, rv); |
1588 | 1594 |
1589 // Cancel the active request. | 1595 // Cancel the active request. |
1590 handle.Reset(); | 1596 handle.Reset(); |
1591 | 1597 |
1592 rv = handle.Init("a", | 1598 rv = handle.Init("a", |
1593 params_, | 1599 params_, |
1594 kDefaultPriority, | 1600 kDefaultPriority, |
1595 &callback, | 1601 callback.callback(), |
1596 pool_.get(), | 1602 pool_.get(), |
1597 BoundNetLog()); | 1603 BoundNetLog()); |
1598 EXPECT_EQ(ERR_IO_PENDING, rv); | 1604 EXPECT_EQ(ERR_IO_PENDING, rv); |
1599 EXPECT_EQ(OK, callback.WaitForResult()); | 1605 EXPECT_EQ(OK, callback.WaitForResult()); |
1600 | 1606 |
1601 EXPECT_FALSE(handle.is_reused()); | 1607 EXPECT_FALSE(handle.is_reused()); |
1602 EXPECT_EQ(2, client_socket_factory_.allocation_count()); | 1608 EXPECT_EQ(2, client_socket_factory_.allocation_count()); |
1603 } | 1609 } |
1604 | 1610 |
1605 // Regression test for http://crbug.com/17985. | 1611 // Regression test for http://crbug.com/17985. |
(...skipping 30 matching lines...) Expand all Loading... |
1636 pool_->CloseIdleSockets(); | 1642 pool_->CloseIdleSockets(); |
1637 | 1643 |
1638 MessageLoop::current()->RunAllPending(); // Run the released socket wakeups | 1644 MessageLoop::current()->RunAllPending(); // Run the released socket wakeups |
1639 } | 1645 } |
1640 | 1646 |
1641 TEST_F(ClientSocketPoolBaseTest, BasicAsynchronous) { | 1647 TEST_F(ClientSocketPoolBaseTest, BasicAsynchronous) { |
1642 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); | 1648 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); |
1643 | 1649 |
1644 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); | 1650 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); |
1645 ClientSocketHandle handle; | 1651 ClientSocketHandle handle; |
1646 TestOldCompletionCallback callback; | 1652 TestCompletionCallback callback; |
1647 CapturingBoundNetLog log(CapturingNetLog::kUnbounded); | 1653 CapturingBoundNetLog log(CapturingNetLog::kUnbounded); |
1648 int rv = handle.Init("a", | 1654 int rv = handle.Init("a", |
1649 params_, | 1655 params_, |
1650 LOWEST, | 1656 LOWEST, |
1651 &callback, | 1657 callback.callback(), |
1652 pool_.get(), | 1658 pool_.get(), |
1653 log.bound()); | 1659 log.bound()); |
1654 EXPECT_EQ(ERR_IO_PENDING, rv); | 1660 EXPECT_EQ(ERR_IO_PENDING, rv); |
1655 EXPECT_EQ(LOAD_STATE_CONNECTING, pool_->GetLoadState("a", &handle)); | 1661 EXPECT_EQ(LOAD_STATE_CONNECTING, pool_->GetLoadState("a", &handle)); |
1656 EXPECT_EQ(OK, callback.WaitForResult()); | 1662 EXPECT_EQ(OK, callback.WaitForResult()); |
1657 EXPECT_TRUE(handle.is_initialized()); | 1663 EXPECT_TRUE(handle.is_initialized()); |
1658 EXPECT_TRUE(handle.socket()); | 1664 EXPECT_TRUE(handle.socket()); |
1659 handle.Reset(); | 1665 handle.Reset(); |
1660 | 1666 |
1661 net::CapturingNetLog::EntryList entries; | 1667 net::CapturingNetLog::EntryList entries; |
(...skipping 11 matching lines...) Expand all Loading... |
1673 EXPECT_TRUE(LogContainsEndEvent( | 1679 EXPECT_TRUE(LogContainsEndEvent( |
1674 entries, 3, NetLog::TYPE_SOCKET_POOL)); | 1680 entries, 3, NetLog::TYPE_SOCKET_POOL)); |
1675 } | 1681 } |
1676 | 1682 |
1677 TEST_F(ClientSocketPoolBaseTest, | 1683 TEST_F(ClientSocketPoolBaseTest, |
1678 InitConnectionAsynchronousFailure) { | 1684 InitConnectionAsynchronousFailure) { |
1679 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); | 1685 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); |
1680 | 1686 |
1681 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingFailingJob); | 1687 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingFailingJob); |
1682 ClientSocketHandle handle; | 1688 ClientSocketHandle handle; |
1683 TestOldCompletionCallback callback; | 1689 TestCompletionCallback callback; |
1684 CapturingBoundNetLog log(CapturingNetLog::kUnbounded); | 1690 CapturingBoundNetLog log(CapturingNetLog::kUnbounded); |
1685 // Set the additional error state members to ensure that they get cleared. | 1691 // Set the additional error state members to ensure that they get cleared. |
1686 handle.set_is_ssl_error(true); | 1692 handle.set_is_ssl_error(true); |
1687 HttpResponseInfo info; | 1693 HttpResponseInfo info; |
1688 info.headers = new HttpResponseHeaders(""); | 1694 info.headers = new HttpResponseHeaders(""); |
1689 handle.set_ssl_error_response_info(info); | 1695 handle.set_ssl_error_response_info(info); |
1690 EXPECT_EQ(ERR_IO_PENDING, handle.Init("a", | 1696 EXPECT_EQ(ERR_IO_PENDING, handle.Init("a", |
1691 params_, | 1697 params_, |
1692 kDefaultPriority, | 1698 kDefaultPriority, |
1693 &callback, | 1699 callback.callback(), |
1694 pool_.get(), | 1700 pool_.get(), |
1695 log.bound())); | 1701 log.bound())); |
1696 EXPECT_EQ(LOAD_STATE_CONNECTING, pool_->GetLoadState("a", &handle)); | 1702 EXPECT_EQ(LOAD_STATE_CONNECTING, pool_->GetLoadState("a", &handle)); |
1697 EXPECT_EQ(ERR_CONNECTION_FAILED, callback.WaitForResult()); | 1703 EXPECT_EQ(ERR_CONNECTION_FAILED, callback.WaitForResult()); |
1698 EXPECT_FALSE(handle.is_ssl_error()); | 1704 EXPECT_FALSE(handle.is_ssl_error()); |
1699 EXPECT_TRUE(handle.ssl_error_response_info().headers.get() == NULL); | 1705 EXPECT_TRUE(handle.ssl_error_response_info().headers.get() == NULL); |
1700 | 1706 |
1701 net::CapturingNetLog::EntryList entries; | 1707 net::CapturingNetLog::EntryList entries; |
1702 log.GetEntries(&entries); | 1708 log.GetEntries(&entries); |
1703 | 1709 |
1704 EXPECT_EQ(3u, entries.size()); | 1710 EXPECT_EQ(3u, entries.size()); |
1705 EXPECT_TRUE(LogContainsBeginEvent( | 1711 EXPECT_TRUE(LogContainsBeginEvent( |
1706 entries, 0, NetLog::TYPE_SOCKET_POOL)); | 1712 entries, 0, NetLog::TYPE_SOCKET_POOL)); |
1707 EXPECT_TRUE(LogContainsEvent( | 1713 EXPECT_TRUE(LogContainsEvent( |
1708 entries, 1, NetLog::TYPE_SOCKET_POOL_BOUND_TO_CONNECT_JOB, | 1714 entries, 1, NetLog::TYPE_SOCKET_POOL_BOUND_TO_CONNECT_JOB, |
1709 NetLog::PHASE_NONE)); | 1715 NetLog::PHASE_NONE)); |
1710 EXPECT_TRUE(LogContainsEndEvent( | 1716 EXPECT_TRUE(LogContainsEndEvent( |
1711 entries, 2, NetLog::TYPE_SOCKET_POOL)); | 1717 entries, 2, NetLog::TYPE_SOCKET_POOL)); |
1712 } | 1718 } |
1713 | 1719 |
1714 TEST_F(ClientSocketPoolBaseTest, TwoRequestsCancelOne) { | 1720 TEST_F(ClientSocketPoolBaseTest, TwoRequestsCancelOne) { |
1715 // TODO(eroman): Add back the log expectations! Removed them because the | 1721 // TODO(eroman): Add back the log expectations! Removed them because the |
1716 // ordering is difficult, and some may fire during destructor. | 1722 // ordering is difficult, and some may fire during destructor. |
1717 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); | 1723 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); |
1718 | 1724 |
1719 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); | 1725 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); |
1720 ClientSocketHandle handle; | 1726 ClientSocketHandle handle; |
1721 TestOldCompletionCallback callback; | 1727 TestCompletionCallback callback; |
1722 ClientSocketHandle handle2; | 1728 ClientSocketHandle handle2; |
1723 TestOldCompletionCallback callback2; | 1729 TestCompletionCallback callback2; |
1724 | 1730 |
1725 EXPECT_EQ(ERR_IO_PENDING, | 1731 EXPECT_EQ(ERR_IO_PENDING, |
1726 handle.Init("a", | 1732 handle.Init("a", |
1727 params_, | 1733 params_, |
1728 kDefaultPriority, | 1734 kDefaultPriority, |
1729 &callback, | 1735 callback.callback(), |
1730 pool_.get(), | 1736 pool_.get(), |
1731 BoundNetLog())); | 1737 BoundNetLog())); |
1732 CapturingBoundNetLog log2(CapturingNetLog::kUnbounded); | 1738 CapturingBoundNetLog log2(CapturingNetLog::kUnbounded); |
1733 EXPECT_EQ(ERR_IO_PENDING, | 1739 EXPECT_EQ(ERR_IO_PENDING, |
1734 handle2.Init("a", | 1740 handle2.Init("a", |
1735 params_, | 1741 params_, |
1736 kDefaultPriority, | 1742 kDefaultPriority, |
1737 &callback2, | 1743 callback2.callback(), |
1738 pool_.get(), | 1744 pool_.get(), |
1739 BoundNetLog())); | 1745 BoundNetLog())); |
1740 | 1746 |
1741 handle.Reset(); | 1747 handle.Reset(); |
1742 | 1748 |
1743 | 1749 |
1744 // At this point, request 2 is just waiting for the connect job to finish. | 1750 // At this point, request 2 is just waiting for the connect job to finish. |
1745 | 1751 |
1746 EXPECT_EQ(OK, callback2.WaitForResult()); | 1752 EXPECT_EQ(OK, callback2.WaitForResult()); |
1747 handle2.Reset(); | 1753 handle2.Reset(); |
(...skipping 31 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1779 | 1785 |
1780 // Start job 1 (async OK) | 1786 // Start job 1 (async OK) |
1781 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); | 1787 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); |
1782 | 1788 |
1783 std::vector<TestSocketRequest*> request_order; | 1789 std::vector<TestSocketRequest*> request_order; |
1784 size_t completion_count; // unused | 1790 size_t completion_count; // unused |
1785 TestSocketRequest req1(&request_order, &completion_count); | 1791 TestSocketRequest req1(&request_order, &completion_count); |
1786 int rv = req1.handle()->Init("a", | 1792 int rv = req1.handle()->Init("a", |
1787 params_, | 1793 params_, |
1788 kDefaultPriority, | 1794 kDefaultPriority, |
1789 &req1, pool_.get(), | 1795 req1.callback(), pool_.get(), |
1790 BoundNetLog()); | 1796 BoundNetLog()); |
1791 EXPECT_EQ(ERR_IO_PENDING, rv); | 1797 EXPECT_EQ(ERR_IO_PENDING, rv); |
1792 EXPECT_EQ(OK, req1.WaitForResult()); | 1798 EXPECT_EQ(OK, req1.WaitForResult()); |
1793 | 1799 |
1794 // Job 1 finished OK. Start job 2 (also async OK). Request 3 is pending | 1800 // Job 1 finished OK. Start job 2 (also async OK). Request 3 is pending |
1795 // without a job. | 1801 // without a job. |
1796 connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob); | 1802 connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob); |
1797 | 1803 |
1798 TestSocketRequest req2(&request_order, &completion_count); | 1804 TestSocketRequest req2(&request_order, &completion_count); |
1799 rv = req2.handle()->Init("a", | 1805 rv = req2.handle()->Init("a", |
1800 params_, | 1806 params_, |
1801 kDefaultPriority, | 1807 kDefaultPriority, |
1802 &req2, | 1808 req2.callback(), |
1803 pool_.get(), | 1809 pool_.get(), |
1804 BoundNetLog()); | 1810 BoundNetLog()); |
1805 EXPECT_EQ(ERR_IO_PENDING, rv); | 1811 EXPECT_EQ(ERR_IO_PENDING, rv); |
1806 TestSocketRequest req3(&request_order, &completion_count); | 1812 TestSocketRequest req3(&request_order, &completion_count); |
1807 rv = req3.handle()->Init("a", | 1813 rv = req3.handle()->Init("a", |
1808 params_, | 1814 params_, |
1809 kDefaultPriority, | 1815 kDefaultPriority, |
1810 &req3, | 1816 req3.callback(), |
1811 pool_.get(), | 1817 pool_.get(), |
1812 BoundNetLog()); | 1818 BoundNetLog()); |
1813 EXPECT_EQ(ERR_IO_PENDING, rv); | 1819 EXPECT_EQ(ERR_IO_PENDING, rv); |
1814 | 1820 |
1815 // Both Requests 2 and 3 are pending. We release socket 1 which should | 1821 // Both Requests 2 and 3 are pending. We release socket 1 which should |
1816 // service request 2. Request 3 should still be waiting. | 1822 // service request 2. Request 3 should still be waiting. |
1817 req1.handle()->Reset(); | 1823 req1.handle()->Reset(); |
1818 MessageLoop::current()->RunAllPending(); // Run the released socket wakeups | 1824 MessageLoop::current()->RunAllPending(); // Run the released socket wakeups |
1819 ASSERT_TRUE(req2.handle()->socket()); | 1825 ASSERT_TRUE(req2.handle()->socket()); |
1820 EXPECT_EQ(OK, req2.WaitForResult()); | 1826 EXPECT_EQ(OK, req2.WaitForResult()); |
(...skipping 17 matching lines...) Expand all Loading... |
1838 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); | 1844 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); |
1839 // First two jobs are async. | 1845 // First two jobs are async. |
1840 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingFailingJob); | 1846 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingFailingJob); |
1841 | 1847 |
1842 std::vector<TestSocketRequest*> request_order; | 1848 std::vector<TestSocketRequest*> request_order; |
1843 size_t completion_count; // unused | 1849 size_t completion_count; // unused |
1844 TestSocketRequest req1(&request_order, &completion_count); | 1850 TestSocketRequest req1(&request_order, &completion_count); |
1845 int rv = req1.handle()->Init("a", | 1851 int rv = req1.handle()->Init("a", |
1846 params_, | 1852 params_, |
1847 kDefaultPriority, | 1853 kDefaultPriority, |
1848 &req1, | 1854 req1.callback(), |
1849 pool_.get(), | 1855 pool_.get(), |
1850 BoundNetLog()); | 1856 BoundNetLog()); |
1851 EXPECT_EQ(ERR_IO_PENDING, rv); | 1857 EXPECT_EQ(ERR_IO_PENDING, rv); |
1852 | 1858 |
1853 TestSocketRequest req2(&request_order, &completion_count); | 1859 TestSocketRequest req2(&request_order, &completion_count); |
1854 rv = req2.handle()->Init("a", | 1860 rv = req2.handle()->Init("a", |
1855 params_, | 1861 params_, |
1856 kDefaultPriority, | 1862 kDefaultPriority, |
1857 &req2, | 1863 req2.callback(), |
1858 pool_.get(), | 1864 pool_.get(), |
1859 BoundNetLog()); | 1865 BoundNetLog()); |
1860 EXPECT_EQ(ERR_IO_PENDING, rv); | 1866 EXPECT_EQ(ERR_IO_PENDING, rv); |
1861 | 1867 |
1862 // The pending job is sync. | 1868 // The pending job is sync. |
1863 connect_job_factory_->set_job_type(TestConnectJob::kMockJob); | 1869 connect_job_factory_->set_job_type(TestConnectJob::kMockJob); |
1864 | 1870 |
1865 TestSocketRequest req3(&request_order, &completion_count); | 1871 TestSocketRequest req3(&request_order, &completion_count); |
1866 rv = req3.handle()->Init("a", | 1872 rv = req3.handle()->Init("a", |
1867 params_, | 1873 params_, |
1868 kDefaultPriority, | 1874 kDefaultPriority, |
1869 &req3, | 1875 req3.callback(), |
1870 pool_.get(), | 1876 pool_.get(), |
1871 BoundNetLog()); | 1877 BoundNetLog()); |
1872 EXPECT_EQ(ERR_IO_PENDING, rv); | 1878 EXPECT_EQ(ERR_IO_PENDING, rv); |
1873 | 1879 |
1874 EXPECT_EQ(ERR_CONNECTION_FAILED, req1.WaitForResult()); | 1880 EXPECT_EQ(ERR_CONNECTION_FAILED, req1.WaitForResult()); |
1875 EXPECT_EQ(OK, req2.WaitForResult()); | 1881 EXPECT_EQ(OK, req2.WaitForResult()); |
1876 EXPECT_EQ(ERR_CONNECTION_FAILED, req3.WaitForResult()); | 1882 EXPECT_EQ(ERR_CONNECTION_FAILED, req3.WaitForResult()); |
1877 | 1883 |
1878 ASSERT_EQ(3U, request_order.size()); | 1884 ASSERT_EQ(3U, request_order.size()); |
1879 EXPECT_EQ(&req1, request_order[0]); | 1885 EXPECT_EQ(&req1, request_order[0]); |
1880 EXPECT_EQ(&req2, request_order[1]); | 1886 EXPECT_EQ(&req2, request_order[1]); |
1881 EXPECT_EQ(&req3, request_order[2]); | 1887 EXPECT_EQ(&req3, request_order[2]); |
1882 } | 1888 } |
1883 | 1889 |
1884 TEST_F(ClientSocketPoolBaseTest, LoadState) { | 1890 TEST_F(ClientSocketPoolBaseTest, LoadState) { |
1885 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); | 1891 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); |
1886 connect_job_factory_->set_job_type( | 1892 connect_job_factory_->set_job_type( |
1887 TestConnectJob::kMockAdvancingLoadStateJob); | 1893 TestConnectJob::kMockAdvancingLoadStateJob); |
1888 | 1894 |
1889 ClientSocketHandle handle; | 1895 ClientSocketHandle handle; |
1890 TestOldCompletionCallback callback; | 1896 TestCompletionCallback callback; |
1891 int rv = handle.Init("a", | 1897 int rv = handle.Init("a", |
1892 params_, | 1898 params_, |
1893 kDefaultPriority, | 1899 kDefaultPriority, |
1894 &callback, | 1900 callback.callback(), |
1895 pool_.get(), | 1901 pool_.get(), |
1896 BoundNetLog()); | 1902 BoundNetLog()); |
1897 EXPECT_EQ(ERR_IO_PENDING, rv); | 1903 EXPECT_EQ(ERR_IO_PENDING, rv); |
1898 EXPECT_EQ(LOAD_STATE_IDLE, handle.GetLoadState()); | 1904 EXPECT_EQ(LOAD_STATE_IDLE, handle.GetLoadState()); |
1899 | 1905 |
1900 MessageLoop::current()->RunAllPending(); | 1906 MessageLoop::current()->RunAllPending(); |
1901 | 1907 |
1902 ClientSocketHandle handle2; | 1908 ClientSocketHandle handle2; |
1903 TestOldCompletionCallback callback2; | 1909 TestCompletionCallback callback2; |
1904 rv = handle2.Init("a", | 1910 rv = handle2.Init("a", params_, kDefaultPriority, callback2.callback(), |
1905 params_, | 1911 pool_.get(), BoundNetLog()); |
1906 kDefaultPriority, | |
1907 &callback2, pool_.get(), | |
1908 BoundNetLog()); | |
1909 EXPECT_EQ(ERR_IO_PENDING, rv); | 1912 EXPECT_EQ(ERR_IO_PENDING, rv); |
1910 EXPECT_NE(LOAD_STATE_IDLE, handle.GetLoadState()); | 1913 EXPECT_NE(LOAD_STATE_IDLE, handle.GetLoadState()); |
1911 EXPECT_NE(LOAD_STATE_IDLE, handle2.GetLoadState()); | 1914 EXPECT_NE(LOAD_STATE_IDLE, handle2.GetLoadState()); |
1912 } | 1915 } |
1913 | 1916 |
1914 TEST_F(ClientSocketPoolBaseTest, Recoverable) { | 1917 TEST_F(ClientSocketPoolBaseTest, Recoverable) { |
1915 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); | 1918 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); |
1916 connect_job_factory_->set_job_type(TestConnectJob::kMockRecoverableJob); | 1919 connect_job_factory_->set_job_type(TestConnectJob::kMockRecoverableJob); |
1917 | 1920 |
1918 ClientSocketHandle handle; | 1921 ClientSocketHandle handle; |
1919 TestOldCompletionCallback callback; | 1922 TestCompletionCallback callback; |
1920 EXPECT_EQ(ERR_PROXY_AUTH_REQUESTED, handle.Init("a", | 1923 EXPECT_EQ(ERR_PROXY_AUTH_REQUESTED, |
1921 params_, | 1924 handle.Init("a", params_, kDefaultPriority, callback.callback(), |
1922 kDefaultPriority, | 1925 pool_.get(), BoundNetLog())); |
1923 &callback, pool_.get(), | |
1924 BoundNetLog())); | |
1925 EXPECT_TRUE(handle.is_initialized()); | 1926 EXPECT_TRUE(handle.is_initialized()); |
1926 EXPECT_TRUE(handle.socket()); | 1927 EXPECT_TRUE(handle.socket()); |
1927 } | 1928 } |
1928 | 1929 |
1929 TEST_F(ClientSocketPoolBaseTest, AsyncRecoverable) { | 1930 TEST_F(ClientSocketPoolBaseTest, AsyncRecoverable) { |
1930 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); | 1931 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); |
1931 | 1932 |
1932 connect_job_factory_->set_job_type( | 1933 connect_job_factory_->set_job_type( |
1933 TestConnectJob::kMockPendingRecoverableJob); | 1934 TestConnectJob::kMockPendingRecoverableJob); |
1934 ClientSocketHandle handle; | 1935 ClientSocketHandle handle; |
1935 TestOldCompletionCallback callback; | 1936 TestCompletionCallback callback; |
1936 EXPECT_EQ(ERR_IO_PENDING, | 1937 EXPECT_EQ(ERR_IO_PENDING, |
1937 handle.Init("a", | 1938 handle.Init("a", |
1938 params_, | 1939 params_, |
1939 kDefaultPriority, | 1940 kDefaultPriority, |
1940 &callback, | 1941 callback.callback(), |
1941 pool_.get(), | 1942 pool_.get(), |
1942 BoundNetLog())); | 1943 BoundNetLog())); |
1943 EXPECT_EQ(LOAD_STATE_CONNECTING, pool_->GetLoadState("a", &handle)); | 1944 EXPECT_EQ(LOAD_STATE_CONNECTING, pool_->GetLoadState("a", &handle)); |
1944 EXPECT_EQ(ERR_PROXY_AUTH_REQUESTED, callback.WaitForResult()); | 1945 EXPECT_EQ(ERR_PROXY_AUTH_REQUESTED, callback.WaitForResult()); |
1945 EXPECT_TRUE(handle.is_initialized()); | 1946 EXPECT_TRUE(handle.is_initialized()); |
1946 EXPECT_TRUE(handle.socket()); | 1947 EXPECT_TRUE(handle.socket()); |
1947 } | 1948 } |
1948 | 1949 |
1949 TEST_F(ClientSocketPoolBaseTest, AdditionalErrorStateSynchronous) { | 1950 TEST_F(ClientSocketPoolBaseTest, AdditionalErrorStateSynchronous) { |
1950 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); | 1951 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); |
1951 connect_job_factory_->set_job_type( | 1952 connect_job_factory_->set_job_type( |
1952 TestConnectJob::kMockAdditionalErrorStateJob); | 1953 TestConnectJob::kMockAdditionalErrorStateJob); |
1953 | 1954 |
1954 ClientSocketHandle handle; | 1955 ClientSocketHandle handle; |
1955 TestOldCompletionCallback callback; | 1956 TestCompletionCallback callback; |
1956 EXPECT_EQ(ERR_CONNECTION_FAILED, | 1957 EXPECT_EQ(ERR_CONNECTION_FAILED, |
1957 handle.Init("a", | 1958 handle.Init("a", |
1958 params_, | 1959 params_, |
1959 kDefaultPriority, | 1960 kDefaultPriority, |
1960 &callback, | 1961 callback.callback(), |
1961 pool_.get(), | 1962 pool_.get(), |
1962 BoundNetLog())); | 1963 BoundNetLog())); |
1963 EXPECT_FALSE(handle.is_initialized()); | 1964 EXPECT_FALSE(handle.is_initialized()); |
1964 EXPECT_FALSE(handle.socket()); | 1965 EXPECT_FALSE(handle.socket()); |
1965 EXPECT_TRUE(handle.is_ssl_error()); | 1966 EXPECT_TRUE(handle.is_ssl_error()); |
1966 EXPECT_FALSE(handle.ssl_error_response_info().headers.get() == NULL); | 1967 EXPECT_FALSE(handle.ssl_error_response_info().headers.get() == NULL); |
1967 } | 1968 } |
1968 | 1969 |
1969 TEST_F(ClientSocketPoolBaseTest, AdditionalErrorStateAsynchronous) { | 1970 TEST_F(ClientSocketPoolBaseTest, AdditionalErrorStateAsynchronous) { |
1970 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); | 1971 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); |
1971 | 1972 |
1972 connect_job_factory_->set_job_type( | 1973 connect_job_factory_->set_job_type( |
1973 TestConnectJob::kMockPendingAdditionalErrorStateJob); | 1974 TestConnectJob::kMockPendingAdditionalErrorStateJob); |
1974 ClientSocketHandle handle; | 1975 ClientSocketHandle handle; |
1975 TestOldCompletionCallback callback; | 1976 TestCompletionCallback callback; |
1976 EXPECT_EQ(ERR_IO_PENDING, | 1977 EXPECT_EQ(ERR_IO_PENDING, |
1977 handle.Init("a", | 1978 handle.Init("a", |
1978 params_, | 1979 params_, |
1979 kDefaultPriority, | 1980 kDefaultPriority, |
1980 &callback, | 1981 callback.callback(), |
1981 pool_.get(), | 1982 pool_.get(), |
1982 BoundNetLog())); | 1983 BoundNetLog())); |
1983 EXPECT_EQ(LOAD_STATE_CONNECTING, pool_->GetLoadState("a", &handle)); | 1984 EXPECT_EQ(LOAD_STATE_CONNECTING, pool_->GetLoadState("a", &handle)); |
1984 EXPECT_EQ(ERR_CONNECTION_FAILED, callback.WaitForResult()); | 1985 EXPECT_EQ(ERR_CONNECTION_FAILED, callback.WaitForResult()); |
1985 EXPECT_FALSE(handle.is_initialized()); | 1986 EXPECT_FALSE(handle.is_initialized()); |
1986 EXPECT_FALSE(handle.socket()); | 1987 EXPECT_FALSE(handle.socket()); |
1987 EXPECT_TRUE(handle.is_ssl_error()); | 1988 EXPECT_TRUE(handle.is_ssl_error()); |
1988 EXPECT_FALSE(handle.ssl_error_response_info().headers.get() == NULL); | 1989 EXPECT_FALSE(handle.ssl_error_response_info().headers.get() == NULL); |
1989 } | 1990 } |
1990 | 1991 |
1991 TEST_F(ClientSocketPoolBaseTest, DisableCleanupTimer) { | 1992 TEST_F(ClientSocketPoolBaseTest, DisableCleanupTimer) { |
1992 // Disable cleanup timer. | 1993 // Disable cleanup timer. |
1993 internal::ClientSocketPoolBaseHelper::set_cleanup_timer_enabled(false); | 1994 internal::ClientSocketPoolBaseHelper::set_cleanup_timer_enabled(false); |
1994 | 1995 |
1995 CreatePoolWithIdleTimeouts( | 1996 CreatePoolWithIdleTimeouts( |
1996 kDefaultMaxSockets, kDefaultMaxSocketsPerGroup, | 1997 kDefaultMaxSockets, kDefaultMaxSocketsPerGroup, |
1997 base::TimeDelta::FromMilliseconds(10), // Time out unused sockets | 1998 base::TimeDelta::FromMilliseconds(10), // Time out unused sockets |
1998 base::TimeDelta::FromMilliseconds(10)); // Time out used sockets | 1999 base::TimeDelta::FromMilliseconds(10)); // Time out used sockets |
1999 | 2000 |
2000 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); | 2001 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); |
2001 | 2002 |
2002 // Startup two mock pending connect jobs, which will sit in the MessageLoop. | 2003 // Startup two mock pending connect jobs, which will sit in the MessageLoop. |
2003 | 2004 |
2004 ClientSocketHandle handle; | 2005 ClientSocketHandle handle; |
2005 TestOldCompletionCallback callback; | 2006 TestCompletionCallback callback; |
2006 int rv = handle.Init("a", | 2007 int rv = handle.Init("a", |
2007 params_, | 2008 params_, |
2008 LOWEST, | 2009 LOWEST, |
2009 &callback, | 2010 callback.callback(), |
2010 pool_.get(), | 2011 pool_.get(), |
2011 BoundNetLog()); | 2012 BoundNetLog()); |
2012 EXPECT_EQ(ERR_IO_PENDING, rv); | 2013 EXPECT_EQ(ERR_IO_PENDING, rv); |
2013 EXPECT_EQ(LOAD_STATE_CONNECTING, pool_->GetLoadState("a", &handle)); | 2014 EXPECT_EQ(LOAD_STATE_CONNECTING, pool_->GetLoadState("a", &handle)); |
2014 | 2015 |
2015 ClientSocketHandle handle2; | 2016 ClientSocketHandle handle2; |
2016 TestOldCompletionCallback callback2; | 2017 TestCompletionCallback callback2; |
2017 rv = handle2.Init("a", | 2018 rv = handle2.Init("a", |
2018 params_, | 2019 params_, |
2019 LOWEST, | 2020 LOWEST, |
2020 &callback2, | 2021 callback2.callback(), |
2021 pool_.get(), | 2022 pool_.get(), |
2022 BoundNetLog()); | 2023 BoundNetLog()); |
2023 EXPECT_EQ(ERR_IO_PENDING, rv); | 2024 EXPECT_EQ(ERR_IO_PENDING, rv); |
2024 EXPECT_EQ(LOAD_STATE_CONNECTING, pool_->GetLoadState("a", &handle2)); | 2025 EXPECT_EQ(LOAD_STATE_CONNECTING, pool_->GetLoadState("a", &handle2)); |
2025 | 2026 |
2026 // Cancel one of the requests. Wait for the other, which will get the first | 2027 // Cancel one of the requests. Wait for the other, which will get the first |
2027 // job. Release the socket. Run the loop again to make sure the second | 2028 // job. Release the socket. Run the loop again to make sure the second |
2028 // socket is sitting idle and the first one is released (since ReleaseSocket() | 2029 // socket is sitting idle and the first one is released (since ReleaseSocket() |
2029 // just posts a DoReleaseSocket() task). | 2030 // just posts a DoReleaseSocket() task). |
2030 | 2031 |
2031 handle.Reset(); | 2032 handle.Reset(); |
2032 EXPECT_EQ(OK, callback2.WaitForResult()); | 2033 EXPECT_EQ(OK, callback2.WaitForResult()); |
2033 // Use the socket. | 2034 // Use the socket. |
2034 EXPECT_EQ(1, handle2.socket()->Write(NULL, 1, CompletionCallback())); | 2035 EXPECT_EQ(1, handle2.socket()->Write(NULL, 1, CompletionCallback())); |
2035 handle2.Reset(); | 2036 handle2.Reset(); |
2036 | 2037 |
2037 // The idle socket timeout value was set to 10 milliseconds. Wait 100 | 2038 // The idle socket timeout value was set to 10 milliseconds. Wait 100 |
2038 // milliseconds so the sockets timeout. | 2039 // milliseconds so the sockets timeout. |
2039 base::PlatformThread::Sleep(100); | 2040 base::PlatformThread::Sleep(100); |
2040 MessageLoop::current()->RunAllPending(); | 2041 MessageLoop::current()->RunAllPending(); |
2041 | 2042 |
2042 ASSERT_EQ(2, pool_->IdleSocketCount()); | 2043 ASSERT_EQ(2, pool_->IdleSocketCount()); |
2043 | 2044 |
2044 // Request a new socket. This should cleanup the unused and timed out ones. | 2045 // Request a new socket. This should cleanup the unused and timed out ones. |
2045 // A new socket will be created rather than reusing the idle one. | 2046 // A new socket will be created rather than reusing the idle one. |
2046 CapturingBoundNetLog log(CapturingNetLog::kUnbounded); | 2047 CapturingBoundNetLog log(CapturingNetLog::kUnbounded); |
| 2048 TestCompletionCallback callback3; |
2047 rv = handle.Init("a", | 2049 rv = handle.Init("a", |
2048 params_, | 2050 params_, |
2049 LOWEST, | 2051 LOWEST, |
2050 &callback, | 2052 callback3.callback(), |
2051 pool_.get(), | 2053 pool_.get(), |
2052 log.bound()); | 2054 log.bound()); |
2053 EXPECT_EQ(ERR_IO_PENDING, rv); | 2055 EXPECT_EQ(ERR_IO_PENDING, rv); |
2054 EXPECT_EQ(OK, callback.WaitForResult()); | 2056 EXPECT_EQ(OK, callback3.WaitForResult()); |
2055 EXPECT_FALSE(handle.is_reused()); | 2057 EXPECT_FALSE(handle.is_reused()); |
2056 | 2058 |
2057 // Make sure the idle socket is closed | 2059 // Make sure the idle socket is closed |
2058 ASSERT_TRUE(pool_->HasGroup("a")); | 2060 ASSERT_TRUE(pool_->HasGroup("a")); |
2059 EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a")); | 2061 EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a")); |
2060 EXPECT_EQ(1, pool_->NumActiveSocketsInGroup("a")); | 2062 EXPECT_EQ(1, pool_->NumActiveSocketsInGroup("a")); |
2061 | 2063 |
2062 net::CapturingNetLog::EntryList entries; | 2064 net::CapturingNetLog::EntryList entries; |
2063 log.GetEntries(&entries); | 2065 log.GetEntries(&entries); |
2064 EXPECT_FALSE(LogContainsEntryWithType( | 2066 EXPECT_FALSE(LogContainsEntryWithType( |
2065 entries, 1, NetLog::TYPE_SOCKET_POOL_REUSED_AN_EXISTING_SOCKET)); | 2067 entries, 1, NetLog::TYPE_SOCKET_POOL_REUSED_AN_EXISTING_SOCKET)); |
2066 } | 2068 } |
2067 | 2069 |
2068 TEST_F(ClientSocketPoolBaseTest, CleanupTimedOutIdleSockets) { | 2070 TEST_F(ClientSocketPoolBaseTest, CleanupTimedOutIdleSockets) { |
2069 CreatePoolWithIdleTimeouts( | 2071 CreatePoolWithIdleTimeouts( |
2070 kDefaultMaxSockets, kDefaultMaxSocketsPerGroup, | 2072 kDefaultMaxSockets, kDefaultMaxSocketsPerGroup, |
2071 base::TimeDelta(), // Time out unused sockets immediately. | 2073 base::TimeDelta(), // Time out unused sockets immediately. |
2072 base::TimeDelta::FromDays(1)); // Don't time out used sockets. | 2074 base::TimeDelta::FromDays(1)); // Don't time out used sockets. |
2073 | 2075 |
2074 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); | 2076 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); |
2075 | 2077 |
2076 // Startup two mock pending connect jobs, which will sit in the MessageLoop. | 2078 // Startup two mock pending connect jobs, which will sit in the MessageLoop. |
2077 | 2079 |
2078 ClientSocketHandle handle; | 2080 ClientSocketHandle handle; |
2079 TestOldCompletionCallback callback; | 2081 TestCompletionCallback callback; |
2080 int rv = handle.Init("a", | 2082 int rv = handle.Init("a", |
2081 params_, | 2083 params_, |
2082 LOWEST, | 2084 LOWEST, |
2083 &callback, | 2085 callback.callback(), |
2084 pool_.get(), | 2086 pool_.get(), |
2085 BoundNetLog()); | 2087 BoundNetLog()); |
2086 EXPECT_EQ(ERR_IO_PENDING, rv); | 2088 EXPECT_EQ(ERR_IO_PENDING, rv); |
2087 EXPECT_EQ(LOAD_STATE_CONNECTING, pool_->GetLoadState("a", &handle)); | 2089 EXPECT_EQ(LOAD_STATE_CONNECTING, pool_->GetLoadState("a", &handle)); |
2088 | 2090 |
2089 ClientSocketHandle handle2; | 2091 ClientSocketHandle handle2; |
2090 TestOldCompletionCallback callback2; | 2092 TestCompletionCallback callback2; |
2091 rv = handle2.Init("a", | 2093 rv = handle2.Init("a", |
2092 params_, | 2094 params_, |
2093 LOWEST, | 2095 LOWEST, |
2094 &callback2, | 2096 callback2.callback(), |
2095 pool_.get(), | 2097 pool_.get(), |
2096 BoundNetLog()); | 2098 BoundNetLog()); |
2097 EXPECT_EQ(ERR_IO_PENDING, rv); | 2099 EXPECT_EQ(ERR_IO_PENDING, rv); |
2098 EXPECT_EQ(LOAD_STATE_CONNECTING, pool_->GetLoadState("a", &handle2)); | 2100 EXPECT_EQ(LOAD_STATE_CONNECTING, pool_->GetLoadState("a", &handle2)); |
2099 | 2101 |
2100 // Cancel one of the requests. Wait for the other, which will get the first | 2102 // Cancel one of the requests. Wait for the other, which will get the first |
2101 // job. Release the socket. Run the loop again to make sure the second | 2103 // job. Release the socket. Run the loop again to make sure the second |
2102 // socket is sitting idle and the first one is released (since ReleaseSocket() | 2104 // socket is sitting idle and the first one is released (since ReleaseSocket() |
2103 // just posts a DoReleaseSocket() task). | 2105 // just posts a DoReleaseSocket() task). |
2104 | 2106 |
(...skipping 13 matching lines...) Expand all Loading... |
2118 ASSERT_EQ(2, pool_->IdleSocketCount()); | 2120 ASSERT_EQ(2, pool_->IdleSocketCount()); |
2119 | 2121 |
2120 // Invoke the idle socket cleanup check. Only one socket should be left, the | 2122 // Invoke the idle socket cleanup check. Only one socket should be left, the |
2121 // used socket. Request it to make sure that it's used. | 2123 // used socket. Request it to make sure that it's used. |
2122 | 2124 |
2123 pool_->CleanupTimedOutIdleSockets(); | 2125 pool_->CleanupTimedOutIdleSockets(); |
2124 CapturingBoundNetLog log(CapturingNetLog::kUnbounded); | 2126 CapturingBoundNetLog log(CapturingNetLog::kUnbounded); |
2125 rv = handle.Init("a", | 2127 rv = handle.Init("a", |
2126 params_, | 2128 params_, |
2127 LOWEST, | 2129 LOWEST, |
2128 &callback, | 2130 callback.callback(), |
2129 pool_.get(), | 2131 pool_.get(), |
2130 log.bound()); | 2132 log.bound()); |
2131 EXPECT_EQ(OK, rv); | 2133 EXPECT_EQ(OK, rv); |
2132 EXPECT_TRUE(handle.is_reused()); | 2134 EXPECT_TRUE(handle.is_reused()); |
2133 | 2135 |
2134 net::CapturingNetLog::EntryList entries; | 2136 net::CapturingNetLog::EntryList entries; |
2135 log.GetEntries(&entries); | 2137 log.GetEntries(&entries); |
2136 EXPECT_TRUE(LogContainsEntryWithType( | 2138 EXPECT_TRUE(LogContainsEntryWithType( |
2137 entries, 1, NetLog::TYPE_SOCKET_POOL_REUSED_AN_EXISTING_SOCKET)); | 2139 entries, 1, NetLog::TYPE_SOCKET_POOL_REUSED_AN_EXISTING_SOCKET)); |
2138 } | 2140 } |
2139 | 2141 |
2140 // Make sure that we process all pending requests even when we're stalling | 2142 // Make sure that we process all pending requests even when we're stalling |
2141 // because of multiple releasing disconnected sockets. | 2143 // because of multiple releasing disconnected sockets. |
2142 TEST_F(ClientSocketPoolBaseTest, MultipleReleasingDisconnectedSockets) { | 2144 TEST_F(ClientSocketPoolBaseTest, MultipleReleasingDisconnectedSockets) { |
2143 CreatePoolWithIdleTimeouts( | 2145 CreatePoolWithIdleTimeouts( |
2144 kDefaultMaxSockets, kDefaultMaxSocketsPerGroup, | 2146 kDefaultMaxSockets, kDefaultMaxSocketsPerGroup, |
2145 base::TimeDelta(), // Time out unused sockets immediately. | 2147 base::TimeDelta(), // Time out unused sockets immediately. |
2146 base::TimeDelta::FromDays(1)); // Don't time out used sockets. | 2148 base::TimeDelta::FromDays(1)); // Don't time out used sockets. |
2147 | 2149 |
2148 connect_job_factory_->set_job_type(TestConnectJob::kMockJob); | 2150 connect_job_factory_->set_job_type(TestConnectJob::kMockJob); |
2149 | 2151 |
2150 // Startup 4 connect jobs. Two of them will be pending. | 2152 // Startup 4 connect jobs. Two of them will be pending. |
2151 | 2153 |
2152 ClientSocketHandle handle; | 2154 ClientSocketHandle handle; |
2153 TestOldCompletionCallback callback; | 2155 TestCompletionCallback callback; |
2154 int rv = handle.Init("a", | 2156 int rv = handle.Init("a", |
2155 params_, | 2157 params_, |
2156 LOWEST, | 2158 LOWEST, |
2157 &callback, | 2159 callback.callback(), |
2158 pool_.get(), | 2160 pool_.get(), |
2159 BoundNetLog()); | 2161 BoundNetLog()); |
2160 EXPECT_EQ(OK, rv); | 2162 EXPECT_EQ(OK, rv); |
2161 | 2163 |
2162 ClientSocketHandle handle2; | 2164 ClientSocketHandle handle2; |
2163 TestOldCompletionCallback callback2; | 2165 TestCompletionCallback callback2; |
2164 rv = handle2.Init("a", | 2166 rv = handle2.Init("a", |
2165 params_, | 2167 params_, |
2166 LOWEST, | 2168 LOWEST, |
2167 &callback2, | 2169 callback2.callback(), |
2168 pool_.get(), | 2170 pool_.get(), |
2169 BoundNetLog()); | 2171 BoundNetLog()); |
2170 EXPECT_EQ(OK, rv); | 2172 EXPECT_EQ(OK, rv); |
2171 | 2173 |
2172 ClientSocketHandle handle3; | 2174 ClientSocketHandle handle3; |
2173 TestOldCompletionCallback callback3; | 2175 TestCompletionCallback callback3; |
2174 rv = handle3.Init("a", | 2176 rv = handle3.Init("a", |
2175 params_, | 2177 params_, |
2176 LOWEST, | 2178 LOWEST, |
2177 &callback3, | 2179 callback3.callback(), |
2178 pool_.get(), | 2180 pool_.get(), |
2179 BoundNetLog()); | 2181 BoundNetLog()); |
2180 EXPECT_EQ(ERR_IO_PENDING, rv); | 2182 EXPECT_EQ(ERR_IO_PENDING, rv); |
2181 | 2183 |
2182 ClientSocketHandle handle4; | 2184 ClientSocketHandle handle4; |
2183 TestOldCompletionCallback callback4; | 2185 TestCompletionCallback callback4; |
2184 rv = handle4.Init("a", | 2186 rv = handle4.Init("a", |
2185 params_, | 2187 params_, |
2186 LOWEST, | 2188 LOWEST, |
2187 &callback4, | 2189 callback4.callback(), |
2188 pool_.get(), | 2190 pool_.get(), |
2189 BoundNetLog()); | 2191 BoundNetLog()); |
2190 EXPECT_EQ(ERR_IO_PENDING, rv); | 2192 EXPECT_EQ(ERR_IO_PENDING, rv); |
2191 | 2193 |
2192 // Release two disconnected sockets. | 2194 // Release two disconnected sockets. |
2193 | 2195 |
2194 handle.socket()->Disconnect(); | 2196 handle.socket()->Disconnect(); |
2195 handle.Reset(); | 2197 handle.Reset(); |
2196 handle2.socket()->Disconnect(); | 2198 handle2.socket()->Disconnect(); |
2197 handle2.Reset(); | 2199 handle2.Reset(); |
(...skipping 11 matching lines...) Expand all Loading... |
2209 CreatePoolWithIdleTimeouts( | 2211 CreatePoolWithIdleTimeouts( |
2210 4 /* socket limit */, 4 /* socket limit per group */, | 2212 4 /* socket limit */, 4 /* socket limit per group */, |
2211 base::TimeDelta(), // Time out unused sockets immediately. | 2213 base::TimeDelta(), // Time out unused sockets immediately. |
2212 base::TimeDelta::FromDays(1)); // Don't time out used sockets. | 2214 base::TimeDelta::FromDays(1)); // Don't time out used sockets. |
2213 | 2215 |
2214 connect_job_factory_->set_job_type(TestConnectJob::kMockJob); | 2216 connect_job_factory_->set_job_type(TestConnectJob::kMockJob); |
2215 | 2217 |
2216 // Max out the socket limit with 2 per group. | 2218 // Max out the socket limit with 2 per group. |
2217 | 2219 |
2218 ClientSocketHandle handle_a[4]; | 2220 ClientSocketHandle handle_a[4]; |
2219 TestOldCompletionCallback callback_a[4]; | 2221 TestCompletionCallback callback_a[4]; |
2220 ClientSocketHandle handle_b[4]; | 2222 ClientSocketHandle handle_b[4]; |
2221 TestOldCompletionCallback callback_b[4]; | 2223 TestCompletionCallback callback_b[4]; |
2222 | 2224 |
2223 for (int i = 0; i < 2; ++i) { | 2225 for (int i = 0; i < 2; ++i) { |
2224 EXPECT_EQ(OK, handle_a[i].Init("a", | 2226 EXPECT_EQ(OK, handle_a[i].Init("a", |
2225 params_, | 2227 params_, |
2226 LOWEST, | 2228 LOWEST, |
2227 &callback_a[i], | 2229 callback_a[i].callback(), |
2228 pool_.get(), | 2230 pool_.get(), |
2229 BoundNetLog())); | 2231 BoundNetLog())); |
2230 EXPECT_EQ(OK, handle_b[i].Init("b", | 2232 EXPECT_EQ(OK, handle_b[i].Init("b", |
2231 params_, | 2233 params_, |
2232 LOWEST, | 2234 LOWEST, |
2233 &callback_b[i], | 2235 callback_b[i].callback(), |
2234 pool_.get(), | 2236 pool_.get(), |
2235 BoundNetLog())); | 2237 BoundNetLog())); |
2236 } | 2238 } |
2237 | 2239 |
2238 // Make 4 pending requests, 2 per group. | 2240 // Make 4 pending requests, 2 per group. |
2239 | 2241 |
2240 for (int i = 2; i < 4; ++i) { | 2242 for (int i = 2; i < 4; ++i) { |
2241 EXPECT_EQ(ERR_IO_PENDING, | 2243 EXPECT_EQ(ERR_IO_PENDING, |
2242 handle_a[i].Init("a", | 2244 handle_a[i].Init("a", |
2243 params_, | 2245 params_, |
2244 LOWEST, | 2246 LOWEST, |
2245 &callback_a[i], | 2247 callback_a[i].callback(), |
2246 pool_.get(), | 2248 pool_.get(), |
2247 BoundNetLog())); | 2249 BoundNetLog())); |
2248 EXPECT_EQ(ERR_IO_PENDING, | 2250 EXPECT_EQ(ERR_IO_PENDING, |
2249 handle_b[i].Init("b", | 2251 handle_b[i].Init("b", |
2250 params_, | 2252 params_, |
2251 LOWEST, | 2253 LOWEST, |
2252 &callback_b[i], | 2254 callback_b[i].callback(), |
2253 pool_.get(), | 2255 pool_.get(), |
2254 BoundNetLog())); | 2256 BoundNetLog())); |
2255 } | 2257 } |
2256 | 2258 |
2257 // Release b's socket first. The order is important, because in | 2259 // Release b's socket first. The order is important, because in |
2258 // DoReleaseSocket(), we'll process b's released socket, and since both b and | 2260 // DoReleaseSocket(), we'll process b's released socket, and since both b and |
2259 // a are stalled, but 'a' is lower lexicographically, we'll process group 'a' | 2261 // a are stalled, but 'a' is lower lexicographically, we'll process group 'a' |
2260 // first, which has a releasing socket, so it refuses to start up another | 2262 // first, which has a releasing socket, so it refuses to start up another |
2261 // ConnectJob. So, we used to infinite loop on this. | 2263 // ConnectJob. So, we used to infinite loop on this. |
2262 handle_b[0].socket()->Disconnect(); | 2264 handle_b[0].socket()->Disconnect(); |
(...skipping 40 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2303 | 2305 |
2304 EXPECT_EQ(1, GetOrderOfRequest(1)); | 2306 EXPECT_EQ(1, GetOrderOfRequest(1)); |
2305 EXPECT_EQ(2, GetOrderOfRequest(2)); | 2307 EXPECT_EQ(2, GetOrderOfRequest(2)); |
2306 EXPECT_EQ(3, GetOrderOfRequest(3)); | 2308 EXPECT_EQ(3, GetOrderOfRequest(3)); |
2307 EXPECT_EQ(4, GetOrderOfRequest(4)); | 2309 EXPECT_EQ(4, GetOrderOfRequest(4)); |
2308 | 2310 |
2309 // Make sure we test order of all requests made. | 2311 // Make sure we test order of all requests made. |
2310 EXPECT_EQ(ClientSocketPoolTest::kIndexOutOfBounds, GetOrderOfRequest(5)); | 2312 EXPECT_EQ(ClientSocketPoolTest::kIndexOutOfBounds, GetOrderOfRequest(5)); |
2311 } | 2313 } |
2312 | 2314 |
2313 class TestReleasingSocketRequest : public CallbackRunner< Tuple1<int> > { | 2315 class TestReleasingSocketRequest : public TestCompletionCallbackBase { |
2314 public: | 2316 public: |
2315 TestReleasingSocketRequest(TestClientSocketPool* pool, | 2317 TestReleasingSocketRequest(TestClientSocketPool* pool, |
2316 int expected_result, | 2318 int expected_result, |
2317 bool reset_releasing_handle) | 2319 bool reset_releasing_handle) |
2318 : pool_(pool), | 2320 : pool_(pool), |
2319 expected_result_(expected_result), | 2321 expected_result_(expected_result), |
2320 reset_releasing_handle_(reset_releasing_handle) {} | 2322 reset_releasing_handle_(reset_releasing_handle), |
| 2323 ALLOW_THIS_IN_INITIALIZER_LIST(callback_( |
| 2324 base::Bind(&TestReleasingSocketRequest::OnComplete, |
| 2325 base::Unretained(this)))) { |
| 2326 } |
| 2327 |
| 2328 virtual ~TestReleasingSocketRequest() {} |
2321 | 2329 |
2322 ClientSocketHandle* handle() { return &handle_; } | 2330 ClientSocketHandle* handle() { return &handle_; } |
2323 | 2331 |
2324 int WaitForResult() { | 2332 const CompletionCallback& callback() const { return callback_; } |
2325 return callback_.WaitForResult(); | 2333 |
| 2334 private: |
| 2335 void OnComplete(int result) { |
| 2336 SetResult(result); |
| 2337 if (reset_releasing_handle_) |
| 2338 handle_.Reset(); |
| 2339 |
| 2340 scoped_refptr<TestSocketParams> con_params(new TestSocketParams()); |
| 2341 EXPECT_EQ(expected_result_, |
| 2342 handle2_.Init("a", con_params, kDefaultPriority, |
| 2343 callback2_.callback(), pool_, BoundNetLog())); |
2326 } | 2344 } |
2327 | 2345 |
2328 virtual void RunWithParams(const Tuple1<int>& params) { | |
2329 callback_.RunWithParams(params); | |
2330 if (reset_releasing_handle_) | |
2331 handle_.Reset(); | |
2332 scoped_refptr<TestSocketParams> con_params(new TestSocketParams()); | |
2333 EXPECT_EQ(expected_result_, handle2_.Init("a", | |
2334 con_params, | |
2335 kDefaultPriority, | |
2336 &callback2_, | |
2337 pool_, | |
2338 BoundNetLog())); | |
2339 } | |
2340 | |
2341 private: | |
2342 TestClientSocketPool* const pool_; | 2346 TestClientSocketPool* const pool_; |
2343 int expected_result_; | 2347 int expected_result_; |
2344 bool reset_releasing_handle_; | 2348 bool reset_releasing_handle_; |
2345 ClientSocketHandle handle_; | 2349 ClientSocketHandle handle_; |
2346 ClientSocketHandle handle2_; | 2350 ClientSocketHandle handle2_; |
2347 TestOldCompletionCallback callback_; | 2351 CompletionCallback callback_; |
2348 TestOldCompletionCallback callback2_; | 2352 TestCompletionCallback callback2_; |
2349 }; | 2353 }; |
2350 | 2354 |
2351 | 2355 |
2352 TEST_F(ClientSocketPoolBaseTest, AdditionalErrorSocketsDontUseSlot) { | 2356 TEST_F(ClientSocketPoolBaseTest, AdditionalErrorSocketsDontUseSlot) { |
2353 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); | 2357 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); |
2354 | 2358 |
2355 EXPECT_EQ(OK, StartRequest("b", kDefaultPriority)); | 2359 EXPECT_EQ(OK, StartRequest("b", kDefaultPriority)); |
2356 EXPECT_EQ(OK, StartRequest("a", kDefaultPriority)); | 2360 EXPECT_EQ(OK, StartRequest("a", kDefaultPriority)); |
2357 EXPECT_EQ(OK, StartRequest("b", kDefaultPriority)); | 2361 EXPECT_EQ(OK, StartRequest("b", kDefaultPriority)); |
2358 | 2362 |
2359 EXPECT_EQ(static_cast<int>(requests_size()), | 2363 EXPECT_EQ(static_cast<int>(requests_size()), |
2360 client_socket_factory_.allocation_count()); | 2364 client_socket_factory_.allocation_count()); |
2361 | 2365 |
2362 connect_job_factory_->set_job_type( | 2366 connect_job_factory_->set_job_type( |
2363 TestConnectJob::kMockPendingAdditionalErrorStateJob); | 2367 TestConnectJob::kMockPendingAdditionalErrorStateJob); |
2364 TestReleasingSocketRequest req(pool_.get(), OK, false); | 2368 TestReleasingSocketRequest req(pool_.get(), OK, false); |
2365 EXPECT_EQ(ERR_IO_PENDING, | 2369 EXPECT_EQ(ERR_IO_PENDING, |
2366 req.handle()->Init("a", | 2370 req.handle()->Init("a", params_, kDefaultPriority, req.callback(), |
2367 params_, | 2371 pool_.get(), BoundNetLog())); |
2368 kDefaultPriority, | |
2369 &req, | |
2370 pool_.get(), | |
2371 BoundNetLog())); | |
2372 // The next job should complete synchronously | 2372 // The next job should complete synchronously |
2373 connect_job_factory_->set_job_type(TestConnectJob::kMockJob); | 2373 connect_job_factory_->set_job_type(TestConnectJob::kMockJob); |
2374 | 2374 |
2375 EXPECT_EQ(ERR_CONNECTION_FAILED, req.WaitForResult()); | 2375 EXPECT_EQ(ERR_CONNECTION_FAILED, req.WaitForResult()); |
2376 EXPECT_FALSE(req.handle()->is_initialized()); | 2376 EXPECT_FALSE(req.handle()->is_initialized()); |
2377 EXPECT_FALSE(req.handle()->socket()); | 2377 EXPECT_FALSE(req.handle()->socket()); |
2378 EXPECT_TRUE(req.handle()->is_ssl_error()); | 2378 EXPECT_TRUE(req.handle()->is_ssl_error()); |
2379 EXPECT_FALSE(req.handle()->ssl_error_response_info().headers.get() == NULL); | 2379 EXPECT_FALSE(req.handle()->ssl_error_response_info().headers.get() == NULL); |
2380 } | 2380 } |
2381 | 2381 |
2382 // http://crbug.com/44724 regression test. | 2382 // http://crbug.com/44724 regression test. |
2383 // We start releasing the pool when we flush on network change. When that | 2383 // We start releasing the pool when we flush on network change. When that |
2384 // happens, the only active references are in the ClientSocketHandles. When a | 2384 // happens, the only active references are in the ClientSocketHandles. When a |
2385 // ConnectJob completes and calls back into the last ClientSocketHandle, that | 2385 // ConnectJob completes and calls back into the last ClientSocketHandle, that |
2386 // callback can release the last reference and delete the pool. After the | 2386 // callback can release the last reference and delete the pool. After the |
2387 // callback finishes, we go back to the stack frame within the now-deleted pool. | 2387 // callback finishes, we go back to the stack frame within the now-deleted pool. |
2388 // Executing any code that refers to members of the now-deleted pool can cause | 2388 // Executing any code that refers to members of the now-deleted pool can cause |
2389 // crashes. | 2389 // crashes. |
2390 TEST_F(ClientSocketPoolBaseTest, CallbackThatReleasesPool) { | 2390 TEST_F(ClientSocketPoolBaseTest, CallbackThatReleasesPool) { |
2391 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); | 2391 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); |
2392 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingFailingJob); | 2392 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingFailingJob); |
2393 | 2393 |
2394 ClientSocketHandle handle; | 2394 ClientSocketHandle handle; |
2395 TestOldCompletionCallback callback; | 2395 TestCompletionCallback callback; |
2396 EXPECT_EQ(ERR_IO_PENDING, handle.Init("a", | 2396 EXPECT_EQ(ERR_IO_PENDING, handle.Init("a", |
2397 params_, | 2397 params_, |
2398 kDefaultPriority, | 2398 kDefaultPriority, |
2399 &callback, | 2399 callback.callback(), |
2400 pool_.get(), | 2400 pool_.get(), |
2401 BoundNetLog())); | 2401 BoundNetLog())); |
2402 | 2402 |
2403 pool_->Flush(); | 2403 pool_->Flush(); |
2404 | 2404 |
2405 // We'll call back into this now. | 2405 // We'll call back into this now. |
2406 callback.WaitForResult(); | 2406 callback.WaitForResult(); |
2407 } | 2407 } |
2408 | 2408 |
2409 TEST_F(ClientSocketPoolBaseTest, DoNotReuseSocketAfterFlush) { | 2409 TEST_F(ClientSocketPoolBaseTest, DoNotReuseSocketAfterFlush) { |
2410 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); | 2410 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); |
2411 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); | 2411 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); |
2412 | 2412 |
2413 ClientSocketHandle handle; | 2413 ClientSocketHandle handle; |
2414 TestOldCompletionCallback callback; | 2414 TestCompletionCallback callback; |
2415 EXPECT_EQ(ERR_IO_PENDING, handle.Init("a", | 2415 EXPECT_EQ(ERR_IO_PENDING, handle.Init("a", |
2416 params_, | 2416 params_, |
2417 kDefaultPriority, | 2417 kDefaultPriority, |
2418 &callback, | 2418 callback.callback(), |
2419 pool_.get(), | 2419 pool_.get(), |
2420 BoundNetLog())); | 2420 BoundNetLog())); |
2421 EXPECT_EQ(OK, callback.WaitForResult()); | 2421 EXPECT_EQ(OK, callback.WaitForResult()); |
2422 EXPECT_EQ(ClientSocketHandle::UNUSED, handle.reuse_type()); | 2422 EXPECT_EQ(ClientSocketHandle::UNUSED, handle.reuse_type()); |
2423 | 2423 |
2424 pool_->Flush(); | 2424 pool_->Flush(); |
2425 | 2425 |
2426 handle.Reset(); | 2426 handle.Reset(); |
2427 MessageLoop::current()->RunAllPending(); | 2427 MessageLoop::current()->RunAllPending(); |
2428 | 2428 |
2429 EXPECT_EQ(ERR_IO_PENDING, handle.Init("a", | 2429 EXPECT_EQ(ERR_IO_PENDING, handle.Init("a", |
2430 params_, | 2430 params_, |
2431 kDefaultPriority, | 2431 kDefaultPriority, |
2432 &callback, | 2432 callback.callback(), |
2433 pool_.get(), | 2433 pool_.get(), |
2434 BoundNetLog())); | 2434 BoundNetLog())); |
2435 EXPECT_EQ(OK, callback.WaitForResult()); | 2435 EXPECT_EQ(OK, callback.WaitForResult()); |
2436 EXPECT_EQ(ClientSocketHandle::UNUSED, handle.reuse_type()); | 2436 EXPECT_EQ(ClientSocketHandle::UNUSED, handle.reuse_type()); |
2437 } | 2437 } |
2438 | 2438 |
2439 class ConnectWithinCallback : public CallbackRunner< Tuple1<int> > { | 2439 class ConnectWithinCallback : public TestCompletionCallbackBase { |
2440 public: | 2440 public: |
2441 ConnectWithinCallback( | 2441 ConnectWithinCallback( |
2442 const std::string& group_name, | 2442 const std::string& group_name, |
2443 const scoped_refptr<TestSocketParams>& params, | 2443 const scoped_refptr<TestSocketParams>& params, |
2444 TestClientSocketPool* pool) | 2444 TestClientSocketPool* pool) |
2445 : group_name_(group_name), params_(params), pool_(pool) {} | 2445 : group_name_(group_name), |
2446 | 2446 params_(params), |
2447 ~ConnectWithinCallback() {} | 2447 pool_(pool), |
2448 | 2448 ALLOW_THIS_IN_INITIALIZER_LIST(callback_( |
2449 virtual void RunWithParams(const Tuple1<int>& params) { | 2449 base::Bind(&ConnectWithinCallback::OnComplete, |
2450 callback_.RunWithParams(params); | 2450 base::Unretained(this)))) { |
2451 EXPECT_EQ(ERR_IO_PENDING, | |
2452 handle_.Init(group_name_, | |
2453 params_, | |
2454 kDefaultPriority, | |
2455 &nested_callback_, | |
2456 pool_, | |
2457 BoundNetLog())); | |
2458 } | 2451 } |
2459 | 2452 |
2460 int WaitForResult() { | 2453 virtual ~ConnectWithinCallback() {} |
2461 return callback_.WaitForResult(); | |
2462 } | |
2463 | 2454 |
2464 int WaitForNestedResult() { | 2455 int WaitForNestedResult() { |
2465 return nested_callback_.WaitForResult(); | 2456 return nested_callback_.WaitForResult(); |
2466 } | 2457 } |
2467 | 2458 |
| 2459 const CompletionCallback& callback() const { return callback_; } |
| 2460 |
2468 private: | 2461 private: |
| 2462 void OnComplete(int result) { |
| 2463 SetResult(result); |
| 2464 EXPECT_EQ(ERR_IO_PENDING, |
| 2465 handle_.Init(group_name_, |
| 2466 params_, |
| 2467 kDefaultPriority, |
| 2468 nested_callback_.callback(), |
| 2469 pool_, |
| 2470 BoundNetLog())); |
| 2471 } |
| 2472 |
2469 const std::string group_name_; | 2473 const std::string group_name_; |
2470 const scoped_refptr<TestSocketParams> params_; | 2474 const scoped_refptr<TestSocketParams> params_; |
2471 TestClientSocketPool* const pool_; | 2475 TestClientSocketPool* const pool_; |
2472 ClientSocketHandle handle_; | 2476 ClientSocketHandle handle_; |
2473 TestOldCompletionCallback callback_; | 2477 CompletionCallback callback_; |
2474 TestOldCompletionCallback nested_callback_; | 2478 TestCompletionCallback nested_callback_; |
| 2479 |
| 2480 DISALLOW_COPY_AND_ASSIGN(ConnectWithinCallback); |
2475 }; | 2481 }; |
2476 | 2482 |
2477 TEST_F(ClientSocketPoolBaseTest, AbortAllRequestsOnFlush) { | 2483 TEST_F(ClientSocketPoolBaseTest, AbortAllRequestsOnFlush) { |
2478 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); | 2484 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); |
2479 | 2485 |
2480 // First job will be waiting until it gets aborted. | 2486 // First job will be waiting until it gets aborted. |
2481 connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob); | 2487 connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob); |
2482 | 2488 |
2483 ClientSocketHandle handle; | 2489 ClientSocketHandle handle; |
2484 ConnectWithinCallback callback("a", params_, pool_.get()); | 2490 ConnectWithinCallback callback("a", params_, pool_.get()); |
2485 EXPECT_EQ(ERR_IO_PENDING, handle.Init("a", | 2491 EXPECT_EQ(ERR_IO_PENDING, handle.Init("a", |
2486 params_, | 2492 params_, |
2487 kDefaultPriority, | 2493 kDefaultPriority, |
2488 &callback, | 2494 callback.callback(), |
2489 pool_.get(), | 2495 pool_.get(), |
2490 BoundNetLog())); | 2496 BoundNetLog())); |
2491 | 2497 |
2492 // Second job will be started during the first callback, and will | 2498 // Second job will be started during the first callback, and will |
2493 // asynchronously complete with OK. | 2499 // asynchronously complete with OK. |
2494 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); | 2500 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); |
2495 pool_->Flush(); | 2501 pool_->Flush(); |
2496 EXPECT_EQ(ERR_ABORTED, callback.WaitForResult()); | 2502 EXPECT_EQ(ERR_ABORTED, callback.WaitForResult()); |
2497 EXPECT_EQ(OK, callback.WaitForNestedResult()); | 2503 EXPECT_EQ(OK, callback.WaitForNestedResult()); |
2498 } | 2504 } |
2499 | 2505 |
2500 // Cancel a pending socket request while we're at max sockets, | 2506 // Cancel a pending socket request while we're at max sockets, |
2501 // and verify that the backup socket firing doesn't cause a crash. | 2507 // and verify that the backup socket firing doesn't cause a crash. |
2502 TEST_F(ClientSocketPoolBaseTest, BackupSocketCancelAtMaxSockets) { | 2508 TEST_F(ClientSocketPoolBaseTest, BackupSocketCancelAtMaxSockets) { |
2503 // Max 4 sockets globally, max 4 sockets per group. | 2509 // Max 4 sockets globally, max 4 sockets per group. |
2504 CreatePool(kDefaultMaxSockets, kDefaultMaxSockets); | 2510 CreatePool(kDefaultMaxSockets, kDefaultMaxSockets); |
2505 pool_->EnableConnectBackupJobs(); | 2511 pool_->EnableConnectBackupJobs(); |
2506 | 2512 |
2507 // Create the first socket and set to ERR_IO_PENDING. This starts the backup | 2513 // Create the first socket and set to ERR_IO_PENDING. This starts the backup |
2508 // timer. | 2514 // timer. |
2509 connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob); | 2515 connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob); |
2510 ClientSocketHandle handle; | 2516 ClientSocketHandle handle; |
2511 TestOldCompletionCallback callback; | 2517 TestCompletionCallback callback; |
2512 EXPECT_EQ(ERR_IO_PENDING, handle.Init("bar", | 2518 EXPECT_EQ(ERR_IO_PENDING, handle.Init("bar", |
2513 params_, | 2519 params_, |
2514 kDefaultPriority, | 2520 kDefaultPriority, |
2515 &callback, | 2521 callback.callback(), |
2516 pool_.get(), | 2522 pool_.get(), |
2517 BoundNetLog())); | 2523 BoundNetLog())); |
2518 | 2524 |
2519 // Start (MaxSockets - 1) connected sockets to reach max sockets. | 2525 // Start (MaxSockets - 1) connected sockets to reach max sockets. |
2520 connect_job_factory_->set_job_type(TestConnectJob::kMockJob); | 2526 connect_job_factory_->set_job_type(TestConnectJob::kMockJob); |
2521 ClientSocketHandle handles[kDefaultMaxSockets]; | 2527 ClientSocketHandle handles[kDefaultMaxSockets]; |
2522 for (int i = 1; i < kDefaultMaxSockets; ++i) { | 2528 for (int i = 1; i < kDefaultMaxSockets; ++i) { |
2523 TestOldCompletionCallback callback; | 2529 TestCompletionCallback callback; |
2524 EXPECT_EQ(OK, handles[i].Init("bar", | 2530 EXPECT_EQ(OK, handles[i].Init("bar", |
2525 params_, | 2531 params_, |
2526 kDefaultPriority, | 2532 kDefaultPriority, |
2527 &callback, | 2533 callback.callback(), |
2528 pool_.get(), | 2534 pool_.get(), |
2529 BoundNetLog())); | 2535 BoundNetLog())); |
2530 } | 2536 } |
2531 | 2537 |
2532 MessageLoop::current()->RunAllPending(); | 2538 MessageLoop::current()->RunAllPending(); |
2533 | 2539 |
2534 // Cancel the pending request. | 2540 // Cancel the pending request. |
2535 handle.Reset(); | 2541 handle.Reset(); |
2536 | 2542 |
2537 // Wait for the backup timer to fire (add some slop to ensure it fires) | 2543 // Wait for the backup timer to fire (add some slop to ensure it fires) |
2538 base::PlatformThread::Sleep( | 2544 base::PlatformThread::Sleep( |
2539 ClientSocketPool::kMaxConnectRetryIntervalMs / 2 * 3); | 2545 ClientSocketPool::kMaxConnectRetryIntervalMs / 2 * 3); |
2540 | 2546 |
2541 MessageLoop::current()->RunAllPending(); | 2547 MessageLoop::current()->RunAllPending(); |
2542 EXPECT_EQ(kDefaultMaxSockets, client_socket_factory_.allocation_count()); | 2548 EXPECT_EQ(kDefaultMaxSockets, client_socket_factory_.allocation_count()); |
2543 } | 2549 } |
2544 | 2550 |
2545 TEST_F(ClientSocketPoolBaseTest, CancelBackupSocketAfterCancelingAllRequests) { | 2551 TEST_F(ClientSocketPoolBaseTest, CancelBackupSocketAfterCancelingAllRequests) { |
2546 CreatePool(kDefaultMaxSockets, kDefaultMaxSockets); | 2552 CreatePool(kDefaultMaxSockets, kDefaultMaxSockets); |
2547 pool_->EnableConnectBackupJobs(); | 2553 pool_->EnableConnectBackupJobs(); |
2548 | 2554 |
2549 // Create the first socket and set to ERR_IO_PENDING. This starts the backup | 2555 // Create the first socket and set to ERR_IO_PENDING. This starts the backup |
2550 // timer. | 2556 // timer. |
2551 connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob); | 2557 connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob); |
2552 ClientSocketHandle handle; | 2558 ClientSocketHandle handle; |
2553 TestOldCompletionCallback callback; | 2559 TestCompletionCallback callback; |
2554 EXPECT_EQ(ERR_IO_PENDING, handle.Init("bar", | 2560 EXPECT_EQ(ERR_IO_PENDING, handle.Init("bar", |
2555 params_, | 2561 params_, |
2556 kDefaultPriority, | 2562 kDefaultPriority, |
2557 &callback, | 2563 callback.callback(), |
2558 pool_.get(), | 2564 pool_.get(), |
2559 BoundNetLog())); | 2565 BoundNetLog())); |
2560 ASSERT_TRUE(pool_->HasGroup("bar")); | 2566 ASSERT_TRUE(pool_->HasGroup("bar")); |
2561 EXPECT_EQ(1, pool_->NumConnectJobsInGroup("bar")); | 2567 EXPECT_EQ(1, pool_->NumConnectJobsInGroup("bar")); |
2562 | 2568 |
2563 // Cancel the socket request. This should cancel the backup timer. Wait for | 2569 // Cancel the socket request. This should cancel the backup timer. Wait for |
2564 // the backup time to see if it indeed got canceled. | 2570 // the backup time to see if it indeed got canceled. |
2565 handle.Reset(); | 2571 handle.Reset(); |
2566 // Wait for the backup timer to fire (add some slop to ensure it fires) | 2572 // Wait for the backup timer to fire (add some slop to ensure it fires) |
2567 base::PlatformThread::Sleep( | 2573 base::PlatformThread::Sleep( |
2568 ClientSocketPool::kMaxConnectRetryIntervalMs / 2 * 3); | 2574 ClientSocketPool::kMaxConnectRetryIntervalMs / 2 * 3); |
2569 MessageLoop::current()->RunAllPending(); | 2575 MessageLoop::current()->RunAllPending(); |
2570 ASSERT_TRUE(pool_->HasGroup("bar")); | 2576 ASSERT_TRUE(pool_->HasGroup("bar")); |
2571 EXPECT_EQ(1, pool_->NumConnectJobsInGroup("bar")); | 2577 EXPECT_EQ(1, pool_->NumConnectJobsInGroup("bar")); |
2572 } | 2578 } |
2573 | 2579 |
2574 TEST_F(ClientSocketPoolBaseTest, CancelBackupSocketAfterFinishingAllRequests) { | 2580 TEST_F(ClientSocketPoolBaseTest, CancelBackupSocketAfterFinishingAllRequests) { |
2575 CreatePool(kDefaultMaxSockets, kDefaultMaxSockets); | 2581 CreatePool(kDefaultMaxSockets, kDefaultMaxSockets); |
2576 pool_->EnableConnectBackupJobs(); | 2582 pool_->EnableConnectBackupJobs(); |
2577 | 2583 |
2578 // Create the first socket and set to ERR_IO_PENDING. This starts the backup | 2584 // Create the first socket and set to ERR_IO_PENDING. This starts the backup |
2579 // timer. | 2585 // timer. |
2580 connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob); | 2586 connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob); |
2581 ClientSocketHandle handle; | 2587 ClientSocketHandle handle; |
2582 TestOldCompletionCallback callback; | 2588 TestCompletionCallback callback; |
2583 EXPECT_EQ(ERR_IO_PENDING, handle.Init("bar", | 2589 EXPECT_EQ(ERR_IO_PENDING, handle.Init("bar", |
2584 params_, | 2590 params_, |
2585 kDefaultPriority, | 2591 kDefaultPriority, |
2586 &callback, | 2592 callback.callback(), |
2587 pool_.get(), | 2593 pool_.get(), |
2588 BoundNetLog())); | 2594 BoundNetLog())); |
2589 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); | 2595 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); |
2590 ClientSocketHandle handle2; | 2596 ClientSocketHandle handle2; |
2591 TestOldCompletionCallback callback2; | 2597 TestCompletionCallback callback2; |
2592 EXPECT_EQ(ERR_IO_PENDING, handle2.Init("bar", | 2598 EXPECT_EQ(ERR_IO_PENDING, handle2.Init("bar", |
2593 params_, | 2599 params_, |
2594 kDefaultPriority, | 2600 kDefaultPriority, |
2595 &callback2, | 2601 callback2.callback(), |
2596 pool_.get(), | 2602 pool_.get(), |
2597 BoundNetLog())); | 2603 BoundNetLog())); |
2598 ASSERT_TRUE(pool_->HasGroup("bar")); | 2604 ASSERT_TRUE(pool_->HasGroup("bar")); |
2599 EXPECT_EQ(2, pool_->NumConnectJobsInGroup("bar")); | 2605 EXPECT_EQ(2, pool_->NumConnectJobsInGroup("bar")); |
2600 | 2606 |
2601 // Cancel request 1 and then complete request 2. With the requests finished, | 2607 // Cancel request 1 and then complete request 2. With the requests finished, |
2602 // the backup timer should be cancelled. | 2608 // the backup timer should be cancelled. |
2603 handle.Reset(); | 2609 handle.Reset(); |
2604 EXPECT_EQ(OK, callback2.WaitForResult()); | 2610 EXPECT_EQ(OK, callback2.WaitForResult()); |
2605 // Wait for the backup timer to fire (add some slop to ensure it fires) | 2611 // Wait for the backup timer to fire (add some slop to ensure it fires) |
2606 base::PlatformThread::Sleep( | 2612 base::PlatformThread::Sleep( |
2607 ClientSocketPool::kMaxConnectRetryIntervalMs / 2 * 3); | 2613 ClientSocketPool::kMaxConnectRetryIntervalMs / 2 * 3); |
2608 MessageLoop::current()->RunAllPending(); | 2614 MessageLoop::current()->RunAllPending(); |
2609 } | 2615 } |
2610 | 2616 |
2611 // Test delayed socket binding for the case where we have two connects, | 2617 // Test delayed socket binding for the case where we have two connects, |
2612 // and while one is waiting on a connect, the other frees up. | 2618 // and while one is waiting on a connect, the other frees up. |
2613 // The socket waiting on a connect should switch immediately to the freed | 2619 // The socket waiting on a connect should switch immediately to the freed |
2614 // up socket. | 2620 // up socket. |
2615 TEST_F(ClientSocketPoolBaseTest, DelayedSocketBindingWaitingForConnect) { | 2621 TEST_F(ClientSocketPoolBaseTest, DelayedSocketBindingWaitingForConnect) { |
2616 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); | 2622 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); |
2617 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); | 2623 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); |
2618 | 2624 |
2619 ClientSocketHandle handle1; | 2625 ClientSocketHandle handle1; |
2620 TestOldCompletionCallback callback; | 2626 TestCompletionCallback callback; |
2621 EXPECT_EQ(ERR_IO_PENDING, | 2627 EXPECT_EQ(ERR_IO_PENDING, |
2622 handle1.Init("a", | 2628 handle1.Init("a", |
2623 params_, | 2629 params_, |
2624 kDefaultPriority, | 2630 kDefaultPriority, |
2625 &callback, | 2631 callback.callback(), |
2626 pool_.get(), | 2632 pool_.get(), |
2627 BoundNetLog())); | 2633 BoundNetLog())); |
2628 EXPECT_EQ(OK, callback.WaitForResult()); | 2634 EXPECT_EQ(OK, callback.WaitForResult()); |
2629 | 2635 |
2630 // No idle sockets, no pending jobs. | 2636 // No idle sockets, no pending jobs. |
2631 EXPECT_EQ(0, pool_->IdleSocketCount()); | 2637 EXPECT_EQ(0, pool_->IdleSocketCount()); |
2632 EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a")); | 2638 EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a")); |
2633 | 2639 |
2634 // Create a second socket to the same host, but this one will wait. | 2640 // Create a second socket to the same host, but this one will wait. |
2635 connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob); | 2641 connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob); |
2636 ClientSocketHandle handle2; | 2642 ClientSocketHandle handle2; |
2637 EXPECT_EQ(ERR_IO_PENDING, | 2643 EXPECT_EQ(ERR_IO_PENDING, |
2638 handle2.Init("a", | 2644 handle2.Init("a", |
2639 params_, | 2645 params_, |
2640 kDefaultPriority, | 2646 kDefaultPriority, |
2641 &callback, | 2647 callback.callback(), |
2642 pool_.get(), | 2648 pool_.get(), |
2643 BoundNetLog())); | 2649 BoundNetLog())); |
2644 // No idle sockets, and one connecting job. | 2650 // No idle sockets, and one connecting job. |
2645 EXPECT_EQ(0, pool_->IdleSocketCount()); | 2651 EXPECT_EQ(0, pool_->IdleSocketCount()); |
2646 EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a")); | 2652 EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a")); |
2647 | 2653 |
2648 // Return the first handle to the pool. This will initiate the delayed | 2654 // Return the first handle to the pool. This will initiate the delayed |
2649 // binding. | 2655 // binding. |
2650 handle1.Reset(); | 2656 handle1.Reset(); |
2651 | 2657 |
(...skipping 16 matching lines...) Expand all Loading... |
2668 MessageLoop::current()->RunAllPending(); | 2674 MessageLoop::current()->RunAllPending(); |
2669 } | 2675 } |
2670 | 2676 |
2671 // Test delayed socket binding when a group is at capacity and one | 2677 // Test delayed socket binding when a group is at capacity and one |
2672 // of the group's sockets frees up. | 2678 // of the group's sockets frees up. |
2673 TEST_F(ClientSocketPoolBaseTest, DelayedSocketBindingAtGroupCapacity) { | 2679 TEST_F(ClientSocketPoolBaseTest, DelayedSocketBindingAtGroupCapacity) { |
2674 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); | 2680 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); |
2675 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); | 2681 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); |
2676 | 2682 |
2677 ClientSocketHandle handle1; | 2683 ClientSocketHandle handle1; |
2678 TestOldCompletionCallback callback; | 2684 TestCompletionCallback callback; |
2679 EXPECT_EQ(ERR_IO_PENDING, | 2685 EXPECT_EQ(ERR_IO_PENDING, |
2680 handle1.Init("a", | 2686 handle1.Init("a", |
2681 params_, | 2687 params_, |
2682 kDefaultPriority, | 2688 kDefaultPriority, |
2683 &callback, | 2689 callback.callback(), |
2684 pool_.get(), | 2690 pool_.get(), |
2685 BoundNetLog())); | 2691 BoundNetLog())); |
2686 EXPECT_EQ(OK, callback.WaitForResult()); | 2692 EXPECT_EQ(OK, callback.WaitForResult()); |
2687 | 2693 |
2688 // No idle sockets, no pending jobs. | 2694 // No idle sockets, no pending jobs. |
2689 EXPECT_EQ(0, pool_->IdleSocketCount()); | 2695 EXPECT_EQ(0, pool_->IdleSocketCount()); |
2690 EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a")); | 2696 EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a")); |
2691 | 2697 |
2692 // Create a second socket to the same host, but this one will wait. | 2698 // Create a second socket to the same host, but this one will wait. |
2693 connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob); | 2699 connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob); |
2694 ClientSocketHandle handle2; | 2700 ClientSocketHandle handle2; |
2695 EXPECT_EQ(ERR_IO_PENDING, | 2701 EXPECT_EQ(ERR_IO_PENDING, |
2696 handle2.Init("a", | 2702 handle2.Init("a", |
2697 params_, | 2703 params_, |
2698 kDefaultPriority, | 2704 kDefaultPriority, |
2699 &callback, | 2705 callback.callback(), |
2700 pool_.get(), | 2706 pool_.get(), |
2701 BoundNetLog())); | 2707 BoundNetLog())); |
2702 // No idle sockets, and one connecting job. | 2708 // No idle sockets, and one connecting job. |
2703 EXPECT_EQ(0, pool_->IdleSocketCount()); | 2709 EXPECT_EQ(0, pool_->IdleSocketCount()); |
2704 EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a")); | 2710 EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a")); |
2705 | 2711 |
2706 // Return the first handle to the pool. This will initiate the delayed | 2712 // Return the first handle to the pool. This will initiate the delayed |
2707 // binding. | 2713 // binding. |
2708 handle1.Reset(); | 2714 handle1.Reset(); |
2709 | 2715 |
(...skipping 18 matching lines...) Expand all Loading... |
2728 | 2734 |
2729 // Test out the case where we have one socket connected, one | 2735 // Test out the case where we have one socket connected, one |
2730 // connecting, when the first socket finishes and goes idle. | 2736 // connecting, when the first socket finishes and goes idle. |
2731 // Although the second connection is pending, the second request | 2737 // Although the second connection is pending, the second request |
2732 // should complete, by taking the first socket's idle socket. | 2738 // should complete, by taking the first socket's idle socket. |
2733 TEST_F(ClientSocketPoolBaseTest, DelayedSocketBindingAtStall) { | 2739 TEST_F(ClientSocketPoolBaseTest, DelayedSocketBindingAtStall) { |
2734 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); | 2740 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); |
2735 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); | 2741 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); |
2736 | 2742 |
2737 ClientSocketHandle handle1; | 2743 ClientSocketHandle handle1; |
2738 TestOldCompletionCallback callback; | 2744 TestCompletionCallback callback; |
2739 EXPECT_EQ(ERR_IO_PENDING, | 2745 EXPECT_EQ(ERR_IO_PENDING, |
2740 handle1.Init("a", | 2746 handle1.Init("a", |
2741 params_, | 2747 params_, |
2742 kDefaultPriority, | 2748 kDefaultPriority, |
2743 &callback, | 2749 callback.callback(), |
2744 pool_.get(), | 2750 pool_.get(), |
2745 BoundNetLog())); | 2751 BoundNetLog())); |
2746 EXPECT_EQ(OK, callback.WaitForResult()); | 2752 EXPECT_EQ(OK, callback.WaitForResult()); |
2747 | 2753 |
2748 // No idle sockets, no pending jobs. | 2754 // No idle sockets, no pending jobs. |
2749 EXPECT_EQ(0, pool_->IdleSocketCount()); | 2755 EXPECT_EQ(0, pool_->IdleSocketCount()); |
2750 EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a")); | 2756 EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a")); |
2751 | 2757 |
2752 // Create a second socket to the same host, but this one will wait. | 2758 // Create a second socket to the same host, but this one will wait. |
2753 connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob); | 2759 connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob); |
2754 ClientSocketHandle handle2; | 2760 ClientSocketHandle handle2; |
2755 EXPECT_EQ(ERR_IO_PENDING, | 2761 EXPECT_EQ(ERR_IO_PENDING, |
2756 handle2.Init("a", | 2762 handle2.Init("a", |
2757 params_, | 2763 params_, |
2758 kDefaultPriority, | 2764 kDefaultPriority, |
2759 &callback, | 2765 callback.callback(), |
2760 pool_.get(), | 2766 pool_.get(), |
2761 BoundNetLog())); | 2767 BoundNetLog())); |
2762 // No idle sockets, and one connecting job. | 2768 // No idle sockets, and one connecting job. |
2763 EXPECT_EQ(0, pool_->IdleSocketCount()); | 2769 EXPECT_EQ(0, pool_->IdleSocketCount()); |
2764 EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a")); | 2770 EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a")); |
2765 | 2771 |
2766 // Return the first handle to the pool. This will initiate the delayed | 2772 // Return the first handle to the pool. This will initiate the delayed |
2767 // binding. | 2773 // binding. |
2768 handle1.Reset(); | 2774 handle1.Reset(); |
2769 | 2775 |
(...skipping 21 matching lines...) Expand all Loading... |
2791 TEST_F(ClientSocketPoolBaseTest, SynchronouslyProcessOnePendingRequest) { | 2797 TEST_F(ClientSocketPoolBaseTest, SynchronouslyProcessOnePendingRequest) { |
2792 const int kUnlimitedSockets = 100; | 2798 const int kUnlimitedSockets = 100; |
2793 const int kOneSocketPerGroup = 1; | 2799 const int kOneSocketPerGroup = 1; |
2794 CreatePool(kUnlimitedSockets, kOneSocketPerGroup); | 2800 CreatePool(kUnlimitedSockets, kOneSocketPerGroup); |
2795 | 2801 |
2796 // Make the first request asynchronous fail. | 2802 // Make the first request asynchronous fail. |
2797 // This will free up a socket slot later. | 2803 // This will free up a socket slot later. |
2798 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingFailingJob); | 2804 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingFailingJob); |
2799 | 2805 |
2800 ClientSocketHandle handle1; | 2806 ClientSocketHandle handle1; |
2801 TestOldCompletionCallback callback1; | 2807 TestCompletionCallback callback1; |
2802 EXPECT_EQ(ERR_IO_PENDING, | 2808 EXPECT_EQ(ERR_IO_PENDING, |
2803 handle1.Init("a", | 2809 handle1.Init("a", |
2804 params_, | 2810 params_, |
2805 kDefaultPriority, | 2811 kDefaultPriority, |
2806 &callback1, | 2812 callback1.callback(), |
2807 pool_.get(), | 2813 pool_.get(), |
2808 BoundNetLog())); | 2814 BoundNetLog())); |
2809 EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a")); | 2815 EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a")); |
2810 | 2816 |
2811 // Make the second request synchronously fail. This should make the Group | 2817 // Make the second request synchronously fail. This should make the Group |
2812 // empty. | 2818 // empty. |
2813 connect_job_factory_->set_job_type(TestConnectJob::kMockFailingJob); | 2819 connect_job_factory_->set_job_type(TestConnectJob::kMockFailingJob); |
2814 ClientSocketHandle handle2; | 2820 ClientSocketHandle handle2; |
2815 TestOldCompletionCallback callback2; | 2821 TestCompletionCallback callback2; |
2816 // It'll be ERR_IO_PENDING now, but the TestConnectJob will synchronously fail | 2822 // It'll be ERR_IO_PENDING now, but the TestConnectJob will synchronously fail |
2817 // when created. | 2823 // when created. |
2818 EXPECT_EQ(ERR_IO_PENDING, | 2824 EXPECT_EQ(ERR_IO_PENDING, |
2819 handle2.Init("a", | 2825 handle2.Init("a", |
2820 params_, | 2826 params_, |
2821 kDefaultPriority, | 2827 kDefaultPriority, |
2822 &callback2, | 2828 callback2.callback(), |
2823 pool_.get(), | 2829 pool_.get(), |
2824 BoundNetLog())); | 2830 BoundNetLog())); |
2825 | 2831 |
2826 EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a")); | 2832 EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a")); |
2827 | 2833 |
2828 EXPECT_EQ(ERR_CONNECTION_FAILED, callback1.WaitForResult()); | 2834 EXPECT_EQ(ERR_CONNECTION_FAILED, callback1.WaitForResult()); |
2829 EXPECT_EQ(ERR_CONNECTION_FAILED, callback2.WaitForResult()); | 2835 EXPECT_EQ(ERR_CONNECTION_FAILED, callback2.WaitForResult()); |
2830 EXPECT_FALSE(pool_->HasGroup("a")); | 2836 EXPECT_FALSE(pool_->HasGroup("a")); |
2831 } | 2837 } |
2832 | 2838 |
2833 TEST_F(ClientSocketPoolBaseTest, PreferUsedSocketToUnusedSocket) { | 2839 TEST_F(ClientSocketPoolBaseTest, PreferUsedSocketToUnusedSocket) { |
2834 CreatePool(kDefaultMaxSockets, kDefaultMaxSockets); | 2840 CreatePool(kDefaultMaxSockets, kDefaultMaxSockets); |
2835 | 2841 |
2836 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); | 2842 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); |
2837 | 2843 |
2838 ClientSocketHandle handle1; | 2844 ClientSocketHandle handle1; |
2839 TestOldCompletionCallback callback1; | 2845 TestCompletionCallback callback1; |
2840 EXPECT_EQ(ERR_IO_PENDING, handle1.Init("a", | 2846 EXPECT_EQ(ERR_IO_PENDING, handle1.Init("a", |
2841 params_, | 2847 params_, |
2842 kDefaultPriority, | 2848 kDefaultPriority, |
2843 &callback1, | 2849 callback1.callback(), |
2844 pool_.get(), | 2850 pool_.get(), |
2845 BoundNetLog())); | 2851 BoundNetLog())); |
2846 | 2852 |
2847 ClientSocketHandle handle2; | 2853 ClientSocketHandle handle2; |
2848 TestOldCompletionCallback callback2; | 2854 TestCompletionCallback callback2; |
2849 EXPECT_EQ(ERR_IO_PENDING, handle2.Init("a", | 2855 EXPECT_EQ(ERR_IO_PENDING, handle2.Init("a", |
2850 params_, | 2856 params_, |
2851 kDefaultPriority, | 2857 kDefaultPriority, |
2852 &callback2, | 2858 callback2.callback(), |
2853 pool_.get(), | 2859 pool_.get(), |
2854 BoundNetLog())); | 2860 BoundNetLog())); |
2855 ClientSocketHandle handle3; | 2861 ClientSocketHandle handle3; |
2856 TestOldCompletionCallback callback3; | 2862 TestCompletionCallback callback3; |
2857 EXPECT_EQ(ERR_IO_PENDING, handle3.Init("a", | 2863 EXPECT_EQ(ERR_IO_PENDING, handle3.Init("a", |
2858 params_, | 2864 params_, |
2859 kDefaultPriority, | 2865 kDefaultPriority, |
2860 &callback3, | 2866 callback3.callback(), |
2861 pool_.get(), | 2867 pool_.get(), |
2862 BoundNetLog())); | 2868 BoundNetLog())); |
2863 | 2869 |
2864 EXPECT_EQ(OK, callback1.WaitForResult()); | 2870 EXPECT_EQ(OK, callback1.WaitForResult()); |
2865 EXPECT_EQ(OK, callback2.WaitForResult()); | 2871 EXPECT_EQ(OK, callback2.WaitForResult()); |
2866 EXPECT_EQ(OK, callback3.WaitForResult()); | 2872 EXPECT_EQ(OK, callback3.WaitForResult()); |
2867 | 2873 |
2868 // Use the socket. | 2874 // Use the socket. |
2869 EXPECT_EQ(1, handle1.socket()->Write(NULL, 1, CompletionCallback())); | 2875 EXPECT_EQ(1, handle1.socket()->Write(NULL, 1, CompletionCallback())); |
2870 EXPECT_EQ(1, handle3.socket()->Write(NULL, 1, CompletionCallback())); | 2876 EXPECT_EQ(1, handle3.socket()->Write(NULL, 1, CompletionCallback())); |
2871 | 2877 |
2872 handle1.Reset(); | 2878 handle1.Reset(); |
2873 handle2.Reset(); | 2879 handle2.Reset(); |
2874 handle3.Reset(); | 2880 handle3.Reset(); |
2875 | 2881 |
2876 EXPECT_EQ(OK, handle1.Init("a", | 2882 EXPECT_EQ(OK, handle1.Init("a", |
2877 params_, | 2883 params_, |
2878 kDefaultPriority, | 2884 kDefaultPriority, |
2879 &callback1, | 2885 callback1.callback(), |
2880 pool_.get(), | 2886 pool_.get(), |
2881 BoundNetLog())); | 2887 BoundNetLog())); |
2882 EXPECT_EQ(OK, handle2.Init("a", | 2888 EXPECT_EQ(OK, handle2.Init("a", |
2883 params_, | 2889 params_, |
2884 kDefaultPriority, | 2890 kDefaultPriority, |
2885 &callback2, | 2891 callback2.callback(), |
2886 pool_.get(), | 2892 pool_.get(), |
2887 BoundNetLog())); | 2893 BoundNetLog())); |
2888 EXPECT_EQ(OK, handle3.Init("a", | 2894 EXPECT_EQ(OK, handle3.Init("a", |
2889 params_, | 2895 params_, |
2890 kDefaultPriority, | 2896 kDefaultPriority, |
2891 &callback3, | 2897 callback3.callback(), |
2892 pool_.get(), | 2898 pool_.get(), |
2893 BoundNetLog())); | 2899 BoundNetLog())); |
2894 | 2900 |
2895 EXPECT_TRUE(handle1.socket()->WasEverUsed()); | 2901 EXPECT_TRUE(handle1.socket()->WasEverUsed()); |
2896 EXPECT_TRUE(handle2.socket()->WasEverUsed()); | 2902 EXPECT_TRUE(handle2.socket()->WasEverUsed()); |
2897 EXPECT_FALSE(handle3.socket()->WasEverUsed()); | 2903 EXPECT_FALSE(handle3.socket()->WasEverUsed()); |
2898 } | 2904 } |
2899 | 2905 |
2900 TEST_F(ClientSocketPoolBaseTest, RequestSockets) { | 2906 TEST_F(ClientSocketPoolBaseTest, RequestSockets) { |
2901 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); | 2907 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); |
2902 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); | 2908 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); |
2903 | 2909 |
2904 pool_->RequestSockets("a", ¶ms_, 2, BoundNetLog()); | 2910 pool_->RequestSockets("a", ¶ms_, 2, BoundNetLog()); |
2905 | 2911 |
2906 ASSERT_TRUE(pool_->HasGroup("a")); | 2912 ASSERT_TRUE(pool_->HasGroup("a")); |
2907 EXPECT_EQ(2, pool_->NumConnectJobsInGroup("a")); | 2913 EXPECT_EQ(2, pool_->NumConnectJobsInGroup("a")); |
2908 EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a")); | 2914 EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a")); |
2909 | 2915 |
2910 ClientSocketHandle handle1; | 2916 ClientSocketHandle handle1; |
2911 TestOldCompletionCallback callback1; | 2917 TestCompletionCallback callback1; |
2912 EXPECT_EQ(ERR_IO_PENDING, handle1.Init("a", | 2918 EXPECT_EQ(ERR_IO_PENDING, handle1.Init("a", |
2913 params_, | 2919 params_, |
2914 kDefaultPriority, | 2920 kDefaultPriority, |
2915 &callback1, | 2921 callback1.callback(), |
2916 pool_.get(), | 2922 pool_.get(), |
2917 BoundNetLog())); | 2923 BoundNetLog())); |
2918 | 2924 |
2919 ClientSocketHandle handle2; | 2925 ClientSocketHandle handle2; |
2920 TestOldCompletionCallback callback2; | 2926 TestCompletionCallback callback2; |
2921 EXPECT_EQ(ERR_IO_PENDING, handle2.Init("a", | 2927 EXPECT_EQ(ERR_IO_PENDING, handle2.Init("a", |
2922 params_, | 2928 params_, |
2923 kDefaultPriority, | 2929 kDefaultPriority, |
2924 &callback2, | 2930 callback2.callback(), |
2925 pool_.get(), | 2931 pool_.get(), |
2926 BoundNetLog())); | 2932 BoundNetLog())); |
2927 | 2933 |
2928 EXPECT_EQ(2, pool_->NumConnectJobsInGroup("a")); | 2934 EXPECT_EQ(2, pool_->NumConnectJobsInGroup("a")); |
2929 EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a")); | 2935 EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a")); |
2930 | 2936 |
2931 EXPECT_EQ(OK, callback1.WaitForResult()); | 2937 EXPECT_EQ(OK, callback1.WaitForResult()); |
2932 EXPECT_EQ(OK, callback2.WaitForResult()); | 2938 EXPECT_EQ(OK, callback2.WaitForResult()); |
2933 handle1.Reset(); | 2939 handle1.Reset(); |
2934 handle2.Reset(); | 2940 handle2.Reset(); |
2935 | 2941 |
2936 EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a")); | 2942 EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a")); |
2937 EXPECT_EQ(2, pool_->IdleSocketCountInGroup("a")); | 2943 EXPECT_EQ(2, pool_->IdleSocketCountInGroup("a")); |
2938 } | 2944 } |
2939 | 2945 |
2940 TEST_F(ClientSocketPoolBaseTest, RequestSocketsWhenAlreadyHaveAConnectJob) { | 2946 TEST_F(ClientSocketPoolBaseTest, RequestSocketsWhenAlreadyHaveAConnectJob) { |
2941 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); | 2947 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); |
2942 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); | 2948 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); |
2943 | 2949 |
2944 ClientSocketHandle handle1; | 2950 ClientSocketHandle handle1; |
2945 TestOldCompletionCallback callback1; | 2951 TestCompletionCallback callback1; |
2946 EXPECT_EQ(ERR_IO_PENDING, handle1.Init("a", | 2952 EXPECT_EQ(ERR_IO_PENDING, handle1.Init("a", |
2947 params_, | 2953 params_, |
2948 kDefaultPriority, | 2954 kDefaultPriority, |
2949 &callback1, | 2955 callback1.callback(), |
2950 pool_.get(), | 2956 pool_.get(), |
2951 BoundNetLog())); | 2957 BoundNetLog())); |
2952 | 2958 |
2953 ASSERT_TRUE(pool_->HasGroup("a")); | 2959 ASSERT_TRUE(pool_->HasGroup("a")); |
2954 EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a")); | 2960 EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a")); |
2955 EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a")); | 2961 EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a")); |
2956 | 2962 |
2957 pool_->RequestSockets("a", ¶ms_, 2, BoundNetLog()); | 2963 pool_->RequestSockets("a", ¶ms_, 2, BoundNetLog()); |
2958 | 2964 |
2959 EXPECT_EQ(2, pool_->NumConnectJobsInGroup("a")); | 2965 EXPECT_EQ(2, pool_->NumConnectJobsInGroup("a")); |
2960 EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a")); | 2966 EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a")); |
2961 | 2967 |
2962 ClientSocketHandle handle2; | 2968 ClientSocketHandle handle2; |
2963 TestOldCompletionCallback callback2; | 2969 TestCompletionCallback callback2; |
2964 EXPECT_EQ(ERR_IO_PENDING, handle2.Init("a", | 2970 EXPECT_EQ(ERR_IO_PENDING, handle2.Init("a", |
2965 params_, | 2971 params_, |
2966 kDefaultPriority, | 2972 kDefaultPriority, |
2967 &callback2, | 2973 callback2.callback(), |
2968 pool_.get(), | 2974 pool_.get(), |
2969 BoundNetLog())); | 2975 BoundNetLog())); |
2970 | 2976 |
2971 EXPECT_EQ(2, pool_->NumConnectJobsInGroup("a")); | 2977 EXPECT_EQ(2, pool_->NumConnectJobsInGroup("a")); |
2972 EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a")); | 2978 EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a")); |
2973 | 2979 |
2974 EXPECT_EQ(OK, callback1.WaitForResult()); | 2980 EXPECT_EQ(OK, callback1.WaitForResult()); |
2975 EXPECT_EQ(OK, callback2.WaitForResult()); | 2981 EXPECT_EQ(OK, callback2.WaitForResult()); |
2976 handle1.Reset(); | 2982 handle1.Reset(); |
2977 handle2.Reset(); | 2983 handle2.Reset(); |
2978 | 2984 |
2979 EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a")); | 2985 EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a")); |
2980 EXPECT_EQ(2, pool_->IdleSocketCountInGroup("a")); | 2986 EXPECT_EQ(2, pool_->IdleSocketCountInGroup("a")); |
2981 } | 2987 } |
2982 | 2988 |
2983 TEST_F(ClientSocketPoolBaseTest, | 2989 TEST_F(ClientSocketPoolBaseTest, |
2984 RequestSocketsWhenAlreadyHaveMultipleConnectJob) { | 2990 RequestSocketsWhenAlreadyHaveMultipleConnectJob) { |
2985 CreatePool(4, 4); | 2991 CreatePool(4, 4); |
2986 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); | 2992 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); |
2987 | 2993 |
2988 ClientSocketHandle handle1; | 2994 ClientSocketHandle handle1; |
2989 TestOldCompletionCallback callback1; | 2995 TestCompletionCallback callback1; |
2990 EXPECT_EQ(ERR_IO_PENDING, handle1.Init("a", | 2996 EXPECT_EQ(ERR_IO_PENDING, handle1.Init("a", |
2991 params_, | 2997 params_, |
2992 kDefaultPriority, | 2998 kDefaultPriority, |
2993 &callback1, | 2999 callback1.callback(), |
2994 pool_.get(), | 3000 pool_.get(), |
2995 BoundNetLog())); | 3001 BoundNetLog())); |
2996 | 3002 |
2997 ClientSocketHandle handle2; | 3003 ClientSocketHandle handle2; |
2998 TestOldCompletionCallback callback2; | 3004 TestCompletionCallback callback2; |
2999 EXPECT_EQ(ERR_IO_PENDING, handle2.Init("a", | 3005 EXPECT_EQ(ERR_IO_PENDING, handle2.Init("a", |
3000 params_, | 3006 params_, |
3001 kDefaultPriority, | 3007 kDefaultPriority, |
3002 &callback2, | 3008 callback2.callback(), |
3003 pool_.get(), | 3009 pool_.get(), |
3004 BoundNetLog())); | 3010 BoundNetLog())); |
3005 | 3011 |
3006 ClientSocketHandle handle3; | 3012 ClientSocketHandle handle3; |
3007 TestOldCompletionCallback callback3; | 3013 TestCompletionCallback callback3; |
3008 EXPECT_EQ(ERR_IO_PENDING, handle3.Init("a", | 3014 EXPECT_EQ(ERR_IO_PENDING, handle3.Init("a", |
3009 params_, | 3015 params_, |
3010 kDefaultPriority, | 3016 kDefaultPriority, |
3011 &callback3, | 3017 callback3.callback(), |
3012 pool_.get(), | 3018 pool_.get(), |
3013 BoundNetLog())); | 3019 BoundNetLog())); |
3014 | 3020 |
3015 ASSERT_TRUE(pool_->HasGroup("a")); | 3021 ASSERT_TRUE(pool_->HasGroup("a")); |
3016 EXPECT_EQ(3, pool_->NumConnectJobsInGroup("a")); | 3022 EXPECT_EQ(3, pool_->NumConnectJobsInGroup("a")); |
3017 EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a")); | 3023 EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a")); |
3018 | 3024 |
3019 pool_->RequestSockets("a", ¶ms_, 2, BoundNetLog()); | 3025 pool_->RequestSockets("a", ¶ms_, 2, BoundNetLog()); |
3020 | 3026 |
3021 EXPECT_EQ(3, pool_->NumConnectJobsInGroup("a")); | 3027 EXPECT_EQ(3, pool_->NumConnectJobsInGroup("a")); |
(...skipping 51 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3073 ASSERT_TRUE(pool_->HasGroup("b")); | 3079 ASSERT_TRUE(pool_->HasGroup("b")); |
3074 EXPECT_EQ(1, pool_->NumConnectJobsInGroup("b")); | 3080 EXPECT_EQ(1, pool_->NumConnectJobsInGroup("b")); |
3075 EXPECT_FALSE(pool_->IsStalled()); | 3081 EXPECT_FALSE(pool_->IsStalled()); |
3076 } | 3082 } |
3077 | 3083 |
3078 TEST_F(ClientSocketPoolBaseTest, RequestSocketsCountIdleSockets) { | 3084 TEST_F(ClientSocketPoolBaseTest, RequestSocketsCountIdleSockets) { |
3079 CreatePool(4, 4); | 3085 CreatePool(4, 4); |
3080 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); | 3086 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); |
3081 | 3087 |
3082 ClientSocketHandle handle1; | 3088 ClientSocketHandle handle1; |
3083 TestOldCompletionCallback callback1; | 3089 TestCompletionCallback callback1; |
3084 EXPECT_EQ(ERR_IO_PENDING, handle1.Init("a", | 3090 EXPECT_EQ(ERR_IO_PENDING, handle1.Init("a", |
3085 params_, | 3091 params_, |
3086 kDefaultPriority, | 3092 kDefaultPriority, |
3087 &callback1, | 3093 callback1.callback(), |
3088 pool_.get(), | 3094 pool_.get(), |
3089 BoundNetLog())); | 3095 BoundNetLog())); |
3090 ASSERT_EQ(OK, callback1.WaitForResult()); | 3096 ASSERT_EQ(OK, callback1.WaitForResult()); |
3091 handle1.Reset(); | 3097 handle1.Reset(); |
3092 | 3098 |
3093 ASSERT_TRUE(pool_->HasGroup("a")); | 3099 ASSERT_TRUE(pool_->HasGroup("a")); |
3094 EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a")); | 3100 EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a")); |
3095 EXPECT_EQ(1, pool_->IdleSocketCountInGroup("a")); | 3101 EXPECT_EQ(1, pool_->IdleSocketCountInGroup("a")); |
3096 | 3102 |
3097 pool_->RequestSockets("a", ¶ms_, 2, BoundNetLog()); | 3103 pool_->RequestSockets("a", ¶ms_, 2, BoundNetLog()); |
3098 | 3104 |
3099 EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a")); | 3105 EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a")); |
3100 EXPECT_EQ(1, pool_->IdleSocketCountInGroup("a")); | 3106 EXPECT_EQ(1, pool_->IdleSocketCountInGroup("a")); |
3101 } | 3107 } |
3102 | 3108 |
3103 TEST_F(ClientSocketPoolBaseTest, RequestSocketsCountActiveSockets) { | 3109 TEST_F(ClientSocketPoolBaseTest, RequestSocketsCountActiveSockets) { |
3104 CreatePool(4, 4); | 3110 CreatePool(4, 4); |
3105 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); | 3111 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); |
3106 | 3112 |
3107 ClientSocketHandle handle1; | 3113 ClientSocketHandle handle1; |
3108 TestOldCompletionCallback callback1; | 3114 TestCompletionCallback callback1; |
3109 EXPECT_EQ(ERR_IO_PENDING, handle1.Init("a", | 3115 EXPECT_EQ(ERR_IO_PENDING, handle1.Init("a", |
3110 params_, | 3116 params_, |
3111 kDefaultPriority, | 3117 kDefaultPriority, |
3112 &callback1, | 3118 callback1.callback(), |
3113 pool_.get(), | 3119 pool_.get(), |
3114 BoundNetLog())); | 3120 BoundNetLog())); |
3115 ASSERT_EQ(OK, callback1.WaitForResult()); | 3121 ASSERT_EQ(OK, callback1.WaitForResult()); |
3116 | 3122 |
3117 ASSERT_TRUE(pool_->HasGroup("a")); | 3123 ASSERT_TRUE(pool_->HasGroup("a")); |
3118 EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a")); | 3124 EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a")); |
3119 EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a")); | 3125 EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a")); |
3120 EXPECT_EQ(1, pool_->NumActiveSocketsInGroup("a")); | 3126 EXPECT_EQ(1, pool_->NumActiveSocketsInGroup("a")); |
3121 | 3127 |
3122 pool_->RequestSockets("a", ¶ms_, 2, BoundNetLog()); | 3128 pool_->RequestSockets("a", ¶ms_, 2, BoundNetLog()); |
(...skipping 46 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3169 | 3175 |
3170 ASSERT_TRUE(pool_->HasGroup("a")); | 3176 ASSERT_TRUE(pool_->HasGroup("a")); |
3171 EXPECT_EQ(2, pool_->NumConnectJobsInGroup("a")); | 3177 EXPECT_EQ(2, pool_->NumConnectJobsInGroup("a")); |
3172 EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a")); | 3178 EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a")); |
3173 | 3179 |
3174 pool_->RequestSockets("a", ¶ms_, 2, BoundNetLog()); | 3180 pool_->RequestSockets("a", ¶ms_, 2, BoundNetLog()); |
3175 EXPECT_EQ(2, pool_->NumConnectJobsInGroup("a")); | 3181 EXPECT_EQ(2, pool_->NumConnectJobsInGroup("a")); |
3176 EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a")); | 3182 EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a")); |
3177 | 3183 |
3178 ClientSocketHandle handle1; | 3184 ClientSocketHandle handle1; |
3179 TestOldCompletionCallback callback1; | 3185 TestCompletionCallback callback1; |
3180 EXPECT_EQ(ERR_IO_PENDING, handle1.Init("a", | 3186 EXPECT_EQ(ERR_IO_PENDING, handle1.Init("a", |
3181 params_, | 3187 params_, |
3182 kDefaultPriority, | 3188 kDefaultPriority, |
3183 &callback1, | 3189 callback1.callback(), |
3184 pool_.get(), | 3190 pool_.get(), |
3185 BoundNetLog())); | 3191 BoundNetLog())); |
3186 ASSERT_EQ(OK, callback1.WaitForResult()); | 3192 ASSERT_EQ(OK, callback1.WaitForResult()); |
3187 | 3193 |
3188 ClientSocketHandle handle2; | 3194 ClientSocketHandle handle2; |
3189 TestOldCompletionCallback callback2; | 3195 TestCompletionCallback callback2; |
3190 int rv = handle2.Init("a", | 3196 int rv = handle2.Init("a", |
3191 params_, | 3197 params_, |
3192 kDefaultPriority, | 3198 kDefaultPriority, |
3193 &callback2, | 3199 callback2.callback(), |
3194 pool_.get(), | 3200 pool_.get(), |
3195 BoundNetLog()); | 3201 BoundNetLog()); |
3196 if (rv != OK) { | 3202 if (rv != OK) { |
3197 EXPECT_EQ(ERR_IO_PENDING, rv); | 3203 EXPECT_EQ(ERR_IO_PENDING, rv); |
3198 EXPECT_EQ(OK, callback2.WaitForResult()); | 3204 EXPECT_EQ(OK, callback2.WaitForResult()); |
3199 } | 3205 } |
3200 | 3206 |
3201 handle1.Reset(); | 3207 handle1.Reset(); |
3202 handle2.Reset(); | 3208 handle2.Reset(); |
3203 | 3209 |
(...skipping 31 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3235 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); | 3241 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); |
3236 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); | 3242 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); |
3237 | 3243 |
3238 pool_->RequestSockets("a", ¶ms_, 1, BoundNetLog()); | 3244 pool_->RequestSockets("a", ¶ms_, 1, BoundNetLog()); |
3239 | 3245 |
3240 ASSERT_TRUE(pool_->HasGroup("a")); | 3246 ASSERT_TRUE(pool_->HasGroup("a")); |
3241 EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a")); | 3247 EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a")); |
3242 EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a")); | 3248 EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a")); |
3243 | 3249 |
3244 ClientSocketHandle handle1; | 3250 ClientSocketHandle handle1; |
3245 TestOldCompletionCallback callback1; | 3251 TestCompletionCallback callback1; |
3246 EXPECT_EQ(ERR_IO_PENDING, handle1.Init("a", | 3252 EXPECT_EQ(ERR_IO_PENDING, handle1.Init("a", |
3247 params_, | 3253 params_, |
3248 kDefaultPriority, | 3254 kDefaultPriority, |
3249 &callback1, | 3255 callback1.callback(), |
3250 pool_.get(), | 3256 pool_.get(), |
3251 BoundNetLog())); | 3257 BoundNetLog())); |
3252 | 3258 |
3253 EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a")); | 3259 EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a")); |
3254 EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a")); | 3260 EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a")); |
3255 | 3261 |
3256 ASSERT_EQ(OK, callback1.WaitForResult()); | 3262 ASSERT_EQ(OK, callback1.WaitForResult()); |
3257 | 3263 |
3258 handle1.Reset(); | 3264 handle1.Reset(); |
3259 | 3265 |
3260 EXPECT_EQ(1, pool_->IdleSocketCountInGroup("a")); | 3266 EXPECT_EQ(1, pool_->IdleSocketCountInGroup("a")); |
3261 } | 3267 } |
3262 | 3268 |
3263 // http://crbug.com/64940 regression test. | 3269 // http://crbug.com/64940 regression test. |
3264 TEST_F(ClientSocketPoolBaseTest, PreconnectClosesIdleSocketRemovesGroup) { | 3270 TEST_F(ClientSocketPoolBaseTest, PreconnectClosesIdleSocketRemovesGroup) { |
3265 const int kMaxTotalSockets = 3; | 3271 const int kMaxTotalSockets = 3; |
3266 const int kMaxSocketsPerGroup = 2; | 3272 const int kMaxSocketsPerGroup = 2; |
3267 CreatePool(kMaxTotalSockets, kMaxSocketsPerGroup); | 3273 CreatePool(kMaxTotalSockets, kMaxSocketsPerGroup); |
3268 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); | 3274 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); |
3269 | 3275 |
3270 // Note that group name ordering matters here. "a" comes before "b", so | 3276 // Note that group name ordering matters here. "a" comes before "b", so |
3271 // CloseOneIdleSocket() will try to close "a"'s idle socket. | 3277 // CloseOneIdleSocket() will try to close "a"'s idle socket. |
3272 | 3278 |
3273 // Set up one idle socket in "a". | 3279 // Set up one idle socket in "a". |
3274 ClientSocketHandle handle1; | 3280 ClientSocketHandle handle1; |
3275 TestOldCompletionCallback callback1; | 3281 TestCompletionCallback callback1; |
3276 EXPECT_EQ(ERR_IO_PENDING, handle1.Init("a", | 3282 EXPECT_EQ(ERR_IO_PENDING, handle1.Init("a", |
3277 params_, | 3283 params_, |
3278 kDefaultPriority, | 3284 kDefaultPriority, |
3279 &callback1, | 3285 callback1.callback(), |
3280 pool_.get(), | 3286 pool_.get(), |
3281 BoundNetLog())); | 3287 BoundNetLog())); |
3282 | 3288 |
3283 ASSERT_EQ(OK, callback1.WaitForResult()); | 3289 ASSERT_EQ(OK, callback1.WaitForResult()); |
3284 handle1.Reset(); | 3290 handle1.Reset(); |
3285 EXPECT_EQ(1, pool_->IdleSocketCountInGroup("a")); | 3291 EXPECT_EQ(1, pool_->IdleSocketCountInGroup("a")); |
3286 | 3292 |
3287 // Set up two active sockets in "b". | 3293 // Set up two active sockets in "b". |
3288 ClientSocketHandle handle2; | 3294 ClientSocketHandle handle2; |
3289 TestOldCompletionCallback callback2; | 3295 TestCompletionCallback callback2; |
3290 EXPECT_EQ(ERR_IO_PENDING, handle1.Init("b", | 3296 EXPECT_EQ(ERR_IO_PENDING, handle1.Init("b", |
3291 params_, | 3297 params_, |
3292 kDefaultPriority, | 3298 kDefaultPriority, |
3293 &callback1, | 3299 callback1.callback(), |
3294 pool_.get(), | 3300 pool_.get(), |
3295 BoundNetLog())); | 3301 BoundNetLog())); |
3296 EXPECT_EQ(ERR_IO_PENDING, handle2.Init("b", | 3302 EXPECT_EQ(ERR_IO_PENDING, handle2.Init("b", |
3297 params_, | 3303 params_, |
3298 kDefaultPriority, | 3304 kDefaultPriority, |
3299 &callback2, | 3305 callback2.callback(), |
3300 pool_.get(), | 3306 pool_.get(), |
3301 BoundNetLog())); | 3307 BoundNetLog())); |
3302 | 3308 |
3303 ASSERT_EQ(OK, callback1.WaitForResult()); | 3309 ASSERT_EQ(OK, callback1.WaitForResult()); |
3304 ASSERT_EQ(OK, callback2.WaitForResult()); | 3310 ASSERT_EQ(OK, callback2.WaitForResult()); |
3305 EXPECT_EQ(0, pool_->IdleSocketCountInGroup("b")); | 3311 EXPECT_EQ(0, pool_->IdleSocketCountInGroup("b")); |
3306 EXPECT_EQ(2, pool_->NumActiveSocketsInGroup("b")); | 3312 EXPECT_EQ(2, pool_->NumActiveSocketsInGroup("b")); |
3307 | 3313 |
3308 // Now we have 1 idle socket in "a" and 2 active sockets in "b". This means | 3314 // Now we have 1 idle socket in "a" and 2 active sockets in "b". This means |
3309 // we've maxed out on sockets, since we set |kMaxTotalSockets| to 3. | 3315 // we've maxed out on sockets, since we set |kMaxTotalSockets| to 3. |
(...skipping 54 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3364 // Make the ConnectJob hang forever. | 3370 // Make the ConnectJob hang forever. |
3365 connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob); | 3371 connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob); |
3366 pool_->RequestSockets("a", ¶ms_, 1, BoundNetLog()); | 3372 pool_->RequestSockets("a", ¶ms_, 1, BoundNetLog()); |
3367 EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a")); | 3373 EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a")); |
3368 EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a")); | 3374 EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a")); |
3369 MessageLoop::current()->RunAllPending(); | 3375 MessageLoop::current()->RunAllPending(); |
3370 | 3376 |
3371 // Make the backup job be a pending job, so it completes normally. | 3377 // Make the backup job be a pending job, so it completes normally. |
3372 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); | 3378 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); |
3373 ClientSocketHandle handle; | 3379 ClientSocketHandle handle; |
3374 TestOldCompletionCallback callback; | 3380 TestCompletionCallback callback; |
3375 EXPECT_EQ(ERR_IO_PENDING, handle.Init("a", | 3381 EXPECT_EQ(ERR_IO_PENDING, handle.Init("a", |
3376 params_, | 3382 params_, |
3377 kDefaultPriority, | 3383 kDefaultPriority, |
3378 &callback, | 3384 callback.callback(), |
3379 pool_.get(), | 3385 pool_.get(), |
3380 BoundNetLog())); | 3386 BoundNetLog())); |
3381 // Timer has started, but the backup connect job shouldn't be created yet. | 3387 // Timer has started, but the backup connect job shouldn't be created yet. |
3382 EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a")); | 3388 EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a")); |
3383 EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a")); | 3389 EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a")); |
3384 EXPECT_EQ(0, pool_->NumActiveSocketsInGroup("a")); | 3390 EXPECT_EQ(0, pool_->NumActiveSocketsInGroup("a")); |
3385 ASSERT_EQ(OK, callback.WaitForResult()); | 3391 ASSERT_EQ(OK, callback.WaitForResult()); |
3386 | 3392 |
3387 // The hung connect job should still be there, but everything else should be | 3393 // The hung connect job should still be there, but everything else should be |
3388 // complete. | 3394 // complete. |
(...skipping 10 matching lines...) Expand all Loading... |
3399 params_(new TestSocketParams), | 3405 params_(new TestSocketParams), |
3400 group_name_(group_name) { | 3406 group_name_(group_name) { |
3401 pool_->AddLayeredPool(this); | 3407 pool_->AddLayeredPool(this); |
3402 } | 3408 } |
3403 | 3409 |
3404 ~MockLayeredPool() { | 3410 ~MockLayeredPool() { |
3405 pool_->RemoveLayeredPool(this); | 3411 pool_->RemoveLayeredPool(this); |
3406 } | 3412 } |
3407 | 3413 |
3408 int RequestSocket(TestClientSocketPool* pool) { | 3414 int RequestSocket(TestClientSocketPool* pool) { |
3409 return handle_.Init(group_name_, params_, kDefaultPriority, &callback_, | 3415 return handle_.Init(group_name_, params_, kDefaultPriority, |
3410 pool, BoundNetLog()); | 3416 callback_.callback(), pool, BoundNetLog()); |
3411 } | 3417 } |
3412 | 3418 |
3413 int RequestSocketWithoutLimits(TestClientSocketPool* pool) { | 3419 int RequestSocketWithoutLimits(TestClientSocketPool* pool) { |
3414 params_->set_ignore_limits(true); | 3420 params_->set_ignore_limits(true); |
3415 return handle_.Init(group_name_, params_, kDefaultPriority, &callback_, | 3421 return handle_.Init(group_name_, params_, kDefaultPriority, |
3416 pool, BoundNetLog()); | 3422 callback_.callback(), pool, BoundNetLog()); |
3417 } | 3423 } |
3418 | 3424 |
3419 bool ReleaseOneConnection() { | 3425 bool ReleaseOneConnection() { |
3420 if (!handle_.is_initialized()) { | 3426 if (!handle_.is_initialized()) { |
3421 return false; | 3427 return false; |
3422 } | 3428 } |
3423 handle_.socket()->Disconnect(); | 3429 handle_.socket()->Disconnect(); |
3424 handle_.Reset(); | 3430 handle_.Reset(); |
3425 return true; | 3431 return true; |
3426 } | 3432 } |
3427 | 3433 |
3428 MOCK_METHOD0(CloseOneIdleConnection, bool()); | 3434 MOCK_METHOD0(CloseOneIdleConnection, bool()); |
3429 | 3435 |
3430 private: | 3436 private: |
3431 TestClientSocketPool* const pool_; | 3437 TestClientSocketPool* const pool_; |
3432 scoped_refptr<TestSocketParams> params_; | 3438 scoped_refptr<TestSocketParams> params_; |
3433 ClientSocketHandle handle_; | 3439 ClientSocketHandle handle_; |
3434 TestOldCompletionCallback callback_; | 3440 TestCompletionCallback callback_; |
3435 const std::string group_name_; | 3441 const std::string group_name_; |
3436 }; | 3442 }; |
3437 | 3443 |
3438 TEST_F(ClientSocketPoolBaseTest, FailToCloseIdleSocketsNotHeldByLayeredPool) { | 3444 TEST_F(ClientSocketPoolBaseTest, FailToCloseIdleSocketsNotHeldByLayeredPool) { |
3439 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); | 3445 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); |
3440 connect_job_factory_->set_job_type(TestConnectJob::kMockJob); | 3446 connect_job_factory_->set_job_type(TestConnectJob::kMockJob); |
3441 | 3447 |
3442 MockLayeredPool mock_layered_pool(pool_.get(), "foo"); | 3448 MockLayeredPool mock_layered_pool(pool_.get(), "foo"); |
3443 EXPECT_CALL(mock_layered_pool, CloseOneIdleConnection()) | 3449 EXPECT_CALL(mock_layered_pool, CloseOneIdleConnection()) |
3444 .WillOnce(Return(false)); | 3450 .WillOnce(Return(false)); |
(...skipping 16 matching lines...) Expand all Loading... |
3461 TEST_F(ClientSocketPoolBaseTest, CloseIdleSocketsHeldByLayeredPoolWhenNeeded) { | 3467 TEST_F(ClientSocketPoolBaseTest, CloseIdleSocketsHeldByLayeredPoolWhenNeeded) { |
3462 CreatePool(1, 1); | 3468 CreatePool(1, 1); |
3463 connect_job_factory_->set_job_type(TestConnectJob::kMockJob); | 3469 connect_job_factory_->set_job_type(TestConnectJob::kMockJob); |
3464 | 3470 |
3465 MockLayeredPool mock_layered_pool(pool_.get(), "foo"); | 3471 MockLayeredPool mock_layered_pool(pool_.get(), "foo"); |
3466 EXPECT_EQ(OK, mock_layered_pool.RequestSocket(pool_.get())); | 3472 EXPECT_EQ(OK, mock_layered_pool.RequestSocket(pool_.get())); |
3467 EXPECT_CALL(mock_layered_pool, CloseOneIdleConnection()) | 3473 EXPECT_CALL(mock_layered_pool, CloseOneIdleConnection()) |
3468 .WillOnce(Invoke(&mock_layered_pool, | 3474 .WillOnce(Invoke(&mock_layered_pool, |
3469 &MockLayeredPool::ReleaseOneConnection)); | 3475 &MockLayeredPool::ReleaseOneConnection)); |
3470 ClientSocketHandle handle; | 3476 ClientSocketHandle handle; |
3471 TestOldCompletionCallback callback; | 3477 TestCompletionCallback callback; |
3472 EXPECT_EQ(OK, handle.Init("a", | 3478 EXPECT_EQ(OK, handle.Init("a", |
3473 params_, | 3479 params_, |
3474 kDefaultPriority, | 3480 kDefaultPriority, |
3475 &callback, | 3481 callback.callback(), |
3476 pool_.get(), | 3482 pool_.get(), |
3477 BoundNetLog())); | 3483 BoundNetLog())); |
3478 } | 3484 } |
3479 | 3485 |
3480 TEST_F(ClientSocketPoolBaseTest, | 3486 TEST_F(ClientSocketPoolBaseTest, |
3481 CloseMultipleIdleSocketsHeldByLayeredPoolWhenNeeded) { | 3487 CloseMultipleIdleSocketsHeldByLayeredPoolWhenNeeded) { |
3482 CreatePool(1, 1); | 3488 CreatePool(1, 1); |
3483 connect_job_factory_->set_job_type(TestConnectJob::kMockJob); | 3489 connect_job_factory_->set_job_type(TestConnectJob::kMockJob); |
3484 | 3490 |
3485 MockLayeredPool mock_layered_pool1(pool_.get(), "foo"); | 3491 MockLayeredPool mock_layered_pool1(pool_.get(), "foo"); |
3486 EXPECT_EQ(OK, mock_layered_pool1.RequestSocket(pool_.get())); | 3492 EXPECT_EQ(OK, mock_layered_pool1.RequestSocket(pool_.get())); |
3487 EXPECT_CALL(mock_layered_pool1, CloseOneIdleConnection()) | 3493 EXPECT_CALL(mock_layered_pool1, CloseOneIdleConnection()) |
3488 .WillRepeatedly(Invoke(&mock_layered_pool1, | 3494 .WillRepeatedly(Invoke(&mock_layered_pool1, |
3489 &MockLayeredPool::ReleaseOneConnection)); | 3495 &MockLayeredPool::ReleaseOneConnection)); |
3490 MockLayeredPool mock_layered_pool2(pool_.get(), "bar"); | 3496 MockLayeredPool mock_layered_pool2(pool_.get(), "bar"); |
3491 EXPECT_EQ(OK, mock_layered_pool2.RequestSocketWithoutLimits(pool_.get())); | 3497 EXPECT_EQ(OK, mock_layered_pool2.RequestSocketWithoutLimits(pool_.get())); |
3492 EXPECT_CALL(mock_layered_pool2, CloseOneIdleConnection()) | 3498 EXPECT_CALL(mock_layered_pool2, CloseOneIdleConnection()) |
3493 .WillRepeatedly(Invoke(&mock_layered_pool2, | 3499 .WillRepeatedly(Invoke(&mock_layered_pool2, |
3494 &MockLayeredPool::ReleaseOneConnection)); | 3500 &MockLayeredPool::ReleaseOneConnection)); |
3495 ClientSocketHandle handle; | 3501 ClientSocketHandle handle; |
3496 TestOldCompletionCallback callback; | 3502 TestCompletionCallback callback; |
3497 EXPECT_EQ(OK, handle.Init("a", | 3503 EXPECT_EQ(OK, handle.Init("a", |
3498 params_, | 3504 params_, |
3499 kDefaultPriority, | 3505 kDefaultPriority, |
3500 &callback, | 3506 callback.callback(), |
3501 pool_.get(), | 3507 pool_.get(), |
3502 BoundNetLog())); | 3508 BoundNetLog())); |
3503 } | 3509 } |
3504 | 3510 |
3505 } // namespace | 3511 } // namespace |
3506 | 3512 |
3507 } // namespace net | 3513 } // namespace net |
OLD | NEW |