1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
5 #include "net/socket/client_socket_pool_base.h"
7 #include "base/compiler_specific.h"
8 #include "base/format_macros.h"
9 #include "base/logging.h"
10 #include "base/message_loop/message_loop.h"
11 #include "base/profiler/scoped_tracker.h"
12 #include "base/stl_util.h"
13 #include "base/strings/string_util.h"
14 #include "base/time/time.h"
15 #include "base/values.h"
16 #include "net/base/net_errors.h"
17 #include "net/base/net_log.h"
19 using base::TimeDelta
;
25 // Indicate whether we should enable idle socket cleanup timer. When timer is
26 // disabled, sockets are closed next time a socket request is made.
27 bool g_cleanup_timer_enabled
= true;
29 // The timeout value, in seconds, used to clean up idle sockets that can't be
32 // Note: It's important to close idle sockets that have received data as soon
33 // as possible because the received data may cause BSOD on Windows XP under
34 // some conditions. See http://crbug.com/4606.
35 const int kCleanupInterval
= 10; // DO NOT INCREASE THIS TIMEOUT.
37 // Indicate whether or not we should establish a new transport layer connection
38 // after a certain timeout has passed without receiving an ACK.
39 bool g_connect_backup_jobs_enabled
= true;
43 ConnectJob::ConnectJob(const std::string
& group_name
,
44 base::TimeDelta timeout_duration
,
45 RequestPriority priority
,
47 const BoundNetLog
& net_log
)
48 : group_name_(group_name
),
49 timeout_duration_(timeout_duration
),
54 DCHECK(!group_name
.empty());
56 net_log
.BeginEvent(NetLog::TYPE_SOCKET_POOL_CONNECT_JOB
,
57 NetLog::StringCallback("group_name", &group_name_
));
60 ConnectJob::~ConnectJob() {
61 net_log().EndEvent(NetLog::TYPE_SOCKET_POOL_CONNECT_JOB
);
64 scoped_ptr
<StreamSocket
> ConnectJob::PassSocket() {
65 return socket_
.Pass();
68 int ConnectJob::Connect() {
69 if (timeout_duration_
!= base::TimeDelta())
70 timer_
.Start(FROM_HERE
, timeout_duration_
, this, &ConnectJob::OnTimeout
);
76 int rv
= ConnectInternal();
78 if (rv
!= ERR_IO_PENDING
) {
79 LogConnectCompletion(rv
);
86 void ConnectJob::SetSocket(scoped_ptr
<StreamSocket
> socket
) {
88 net_log().AddEvent(NetLog::TYPE_CONNECT_JOB_SET_SOCKET
,
89 socket
->NetLog().source().ToEventParametersCallback());
91 socket_
= socket
.Pass();
94 void ConnectJob::NotifyDelegateOfCompletion(int rv
) {
95 // The delegate will own |this|.
96 Delegate
* delegate
= delegate_
;
99 LogConnectCompletion(rv
);
100 delegate
->OnConnectJobComplete(rv
, this);
103 void ConnectJob::ResetTimer(base::TimeDelta remaining_time
) {
105 timer_
.Start(FROM_HERE
, remaining_time
, this, &ConnectJob::OnTimeout
);
108 void ConnectJob::LogConnectStart() {
109 connect_timing_
.connect_start
= base::TimeTicks::Now();
110 net_log().BeginEvent(NetLog::TYPE_SOCKET_POOL_CONNECT_JOB_CONNECT
);
113 void ConnectJob::LogConnectCompletion(int net_error
) {
114 connect_timing_
.connect_end
= base::TimeTicks::Now();
115 net_log().EndEventWithNetErrorCode(
116 NetLog::TYPE_SOCKET_POOL_CONNECT_JOB_CONNECT
, net_error
);
119 void ConnectJob::OnTimeout() {
120 // Make sure the socket is NULL before calling into |delegate|.
121 SetSocket(scoped_ptr
<StreamSocket
>());
123 net_log_
.AddEvent(NetLog::TYPE_SOCKET_POOL_CONNECT_JOB_TIMED_OUT
);
125 NotifyDelegateOfCompletion(ERR_TIMED_OUT
);
130 ClientSocketPoolBaseHelper::Request::Request(
131 ClientSocketHandle
* handle
,
132 const CompletionCallback
& callback
,
133 RequestPriority priority
,
136 const BoundNetLog
& net_log
)
140 ignore_limits_(ignore_limits
),
144 DCHECK_EQ(priority_
, MAXIMUM_PRIORITY
);
147 ClientSocketPoolBaseHelper::Request::~Request() {}
149 ClientSocketPoolBaseHelper::ClientSocketPoolBaseHelper(
150 HigherLayeredPool
* pool
,
152 int max_sockets_per_group
,
153 base::TimeDelta unused_idle_socket_timeout
,
154 base::TimeDelta used_idle_socket_timeout
,
155 ConnectJobFactory
* connect_job_factory
)
156 : idle_socket_count_(0),
157 connecting_socket_count_(0),
158 handed_out_socket_count_(0),
159 max_sockets_(max_sockets
),
160 max_sockets_per_group_(max_sockets_per_group
),
161 use_cleanup_timer_(g_cleanup_timer_enabled
),
162 unused_idle_socket_timeout_(unused_idle_socket_timeout
),
163 used_idle_socket_timeout_(used_idle_socket_timeout
),
164 connect_job_factory_(connect_job_factory
),
165 connect_backup_jobs_enabled_(false),
166 pool_generation_number_(0),
168 weak_factory_(this) {
169 DCHECK_LE(0, max_sockets_per_group
);
170 DCHECK_LE(max_sockets_per_group
, max_sockets
);
172 NetworkChangeNotifier::AddIPAddressObserver(this);
175 ClientSocketPoolBaseHelper::~ClientSocketPoolBaseHelper() {
176 // Clean up any idle sockets and pending connect jobs. Assert that we have no
177 // remaining active sockets or pending requests. They should have all been
178 // cleaned up prior to |this| being destroyed.
179 FlushWithError(ERR_ABORTED
);
180 DCHECK(group_map_
.empty());
181 DCHECK(pending_callback_map_
.empty());
182 DCHECK_EQ(0, connecting_socket_count_
);
183 CHECK(higher_pools_
.empty());
185 NetworkChangeNotifier::RemoveIPAddressObserver(this);
187 // Remove from lower layer pools.
188 for (std::set
<LowerLayeredPool
*>::iterator it
= lower_pools_
.begin();
189 it
!= lower_pools_
.end();
191 (*it
)->RemoveHigherLayeredPool(pool_
);
195 ClientSocketPoolBaseHelper::CallbackResultPair::CallbackResultPair()
199 ClientSocketPoolBaseHelper::CallbackResultPair::CallbackResultPair(
200 const CompletionCallback
& callback_in
, int result_in
)
201 : callback(callback_in
),
205 ClientSocketPoolBaseHelper::CallbackResultPair::~CallbackResultPair() {}
207 bool ClientSocketPoolBaseHelper::IsStalled() const {
208 // If a lower layer pool is stalled, consider |this| stalled as well.
209 for (std::set
<LowerLayeredPool
*>::const_iterator it
= lower_pools_
.begin();
210 it
!= lower_pools_
.end();
212 if ((*it
)->IsStalled())
216 // If fewer than |max_sockets_| are in use, then clearly |this| is not
218 if ((handed_out_socket_count_
+ connecting_socket_count_
) < max_sockets_
)
220 // So in order to be stalled, |this| must be using at least |max_sockets_| AND
221 // |this| must have a request that is actually stalled on the global socket
222 // limit. To find such a request, look for a group that has more requests
223 // than jobs AND where the number of sockets is less than
224 // |max_sockets_per_group_|. (If the number of sockets is equal to
225 // |max_sockets_per_group_|, then the request is stalled on the group limit,
226 // which does not count.)
227 for (GroupMap::const_iterator it
= group_map_
.begin();
228 it
!= group_map_
.end(); ++it
) {
229 if (it
->second
->CanUseAdditionalSocketSlot(max_sockets_per_group_
))
235 void ClientSocketPoolBaseHelper::AddLowerLayeredPool(
236 LowerLayeredPool
* lower_pool
) {
238 CHECK(!ContainsKey(lower_pools_
, lower_pool
));
239 lower_pools_
.insert(lower_pool
);
240 lower_pool
->AddHigherLayeredPool(pool_
);
243 void ClientSocketPoolBaseHelper::AddHigherLayeredPool(
244 HigherLayeredPool
* higher_pool
) {
246 CHECK(!ContainsKey(higher_pools_
, higher_pool
));
247 higher_pools_
.insert(higher_pool
);
250 void ClientSocketPoolBaseHelper::RemoveHigherLayeredPool(
251 HigherLayeredPool
* higher_pool
) {
253 CHECK(ContainsKey(higher_pools_
, higher_pool
));
254 higher_pools_
.erase(higher_pool
);
257 int ClientSocketPoolBaseHelper::RequestSocket(
258 const std::string
& group_name
,
259 scoped_ptr
<const Request
> request
) {
260 CHECK(!request
->callback().is_null());
261 CHECK(request
->handle());
263 // Cleanup any timed-out idle sockets if no timer is used.
264 if (!use_cleanup_timer_
)
265 CleanupIdleSockets(false);
267 request
->net_log().BeginEvent(NetLog::TYPE_SOCKET_POOL
);
268 Group
* group
= GetOrCreateGroup(group_name
);
270 int rv
= RequestSocketInternal(group_name
, *request
);
271 if (rv
!= ERR_IO_PENDING
) {
272 request
->net_log().EndEventWithNetErrorCode(NetLog::TYPE_SOCKET_POOL
, rv
);
273 CHECK(!request
->handle()->is_initialized());
276 group
->InsertPendingRequest(request
.Pass());
277 // Have to do this asynchronously, as closing sockets in higher level pools
278 // call back in to |this|, which will cause all sorts of fun and exciting
279 // re-entrancy issues if the socket pool is doing something else at the
281 if (group
->CanUseAdditionalSocketSlot(max_sockets_per_group_
)) {
282 base::MessageLoop::current()->PostTask(
285 &ClientSocketPoolBaseHelper::TryToCloseSocketsInLayeredPools
,
286 weak_factory_
.GetWeakPtr()));
292 void ClientSocketPoolBaseHelper::RequestSockets(
293 const std::string
& group_name
,
294 const Request
& request
,
296 DCHECK(request
.callback().is_null());
297 DCHECK(!request
.handle());
299 // Cleanup any timed out idle sockets if no timer is used.
300 if (!use_cleanup_timer_
)
301 CleanupIdleSockets(false);
303 if (num_sockets
> max_sockets_per_group_
) {
304 num_sockets
= max_sockets_per_group_
;
307 request
.net_log().BeginEvent(
308 NetLog::TYPE_SOCKET_POOL_CONNECTING_N_SOCKETS
,
309 NetLog::IntegerCallback("num_sockets", num_sockets
));
311 Group
* group
= GetOrCreateGroup(group_name
);
313 // RequestSocketsInternal() may delete the group.
314 bool deleted_group
= false;
317 for (int num_iterations_left
= num_sockets
;
318 group
->NumActiveSocketSlots() < num_sockets
&&
319 num_iterations_left
> 0 ; num_iterations_left
--) {
320 rv
= RequestSocketInternal(group_name
, request
);
321 if (rv
< 0 && rv
!= ERR_IO_PENDING
) {
322 // We're encountering a synchronous error. Give up.
323 if (!ContainsKey(group_map_
, group_name
))
324 deleted_group
= true;
327 if (!ContainsKey(group_map_
, group_name
)) {
328 // Unexpected. The group should only be getting deleted on synchronous
331 deleted_group
= true;
336 if (!deleted_group
&& group
->IsEmpty())
337 RemoveGroup(group_name
);
339 if (rv
== ERR_IO_PENDING
)
341 request
.net_log().EndEventWithNetErrorCode(
342 NetLog::TYPE_SOCKET_POOL_CONNECTING_N_SOCKETS
, rv
);
345 int ClientSocketPoolBaseHelper::RequestSocketInternal(
346 const std::string
& group_name
,
347 const Request
& request
) {
348 ClientSocketHandle
* const handle
= request
.handle();
349 const bool preconnecting
= !handle
;
350 Group
* group
= GetOrCreateGroup(group_name
);
352 if (!(request
.flags() & NO_IDLE_SOCKETS
)) {
353 // Try to reuse a socket.
354 if (AssignIdleSocketToRequest(request
, group
))
358 // If there are more ConnectJobs than pending requests, don't need to do
359 // anything. Can just wait for the extra job to connect, and then assign it
361 if (!preconnecting
&& group
->TryToUseUnassignedConnectJob())
362 return ERR_IO_PENDING
;
364 // Can we make another active socket now?
365 if (!group
->HasAvailableSocketSlot(max_sockets_per_group_
) &&
366 !request
.ignore_limits()) {
367 // TODO(willchan): Consider whether or not we need to close a socket in a
368 // higher layered group. I don't think this makes sense since we would just
369 // reuse that socket then if we needed one and wouldn't make it down to this
371 request
.net_log().AddEvent(
372 NetLog::TYPE_SOCKET_POOL_STALLED_MAX_SOCKETS_PER_GROUP
);
373 return ERR_IO_PENDING
;
376 if (ReachedMaxSocketsLimit() && !request
.ignore_limits()) {
377 // NOTE(mmenke): Wonder if we really need different code for each case
378 // here. Only reason for them now seems to be preconnects.
379 if (idle_socket_count() > 0) {
380 // There's an idle socket in this pool. Either that's because there's
381 // still one in this group, but we got here due to preconnecting bypassing
382 // idle sockets, or because there's an idle socket in another group.
383 bool closed
= CloseOneIdleSocketExceptInGroup(group
);
384 if (preconnecting
&& !closed
)
385 return ERR_PRECONNECT_MAX_SOCKET_LIMIT
;
387 // We could check if we really have a stalled group here, but it requires
388 // a scan of all groups, so just flip a flag here, and do the check later.
389 request
.net_log().AddEvent(NetLog::TYPE_SOCKET_POOL_STALLED_MAX_SOCKETS
);
390 return ERR_IO_PENDING
;
394 // We couldn't find a socket to reuse, and there's space to allocate one,
395 // so allocate and connect a new one.
396 scoped_ptr
<ConnectJob
> connect_job(
397 connect_job_factory_
->NewConnectJob(group_name
, request
, this));
399 int rv
= connect_job
->Connect();
401 LogBoundConnectJobToRequest(connect_job
->net_log().source(), request
);
402 if (!preconnecting
) {
403 HandOutSocket(connect_job
->PassSocket(), ClientSocketHandle::UNUSED
,
404 connect_job
->connect_timing(), handle
, base::TimeDelta(),
405 group
, request
.net_log());
407 AddIdleSocket(connect_job
->PassSocket(), group
);
409 } else if (rv
== ERR_IO_PENDING
) {
410 // If we don't have any sockets in this group, set a timer for potentially
411 // creating a new one. If the SYN is lost, this backup socket may complete
412 // before the slow socket, improving end user latency.
413 if (connect_backup_jobs_enabled_
&& group
->IsEmpty()) {
414 group
->StartBackupJobTimer(group_name
, this);
417 connecting_socket_count_
++;
419 group
->AddJob(connect_job
.Pass(), preconnecting
);
421 LogBoundConnectJobToRequest(connect_job
->net_log().source(), request
);
422 scoped_ptr
<StreamSocket
> error_socket
;
423 if (!preconnecting
) {
425 connect_job
->GetAdditionalErrorState(handle
);
426 error_socket
= connect_job
->PassSocket();
429 HandOutSocket(error_socket
.Pass(), ClientSocketHandle::UNUSED
,
430 connect_job
->connect_timing(), handle
, base::TimeDelta(),
431 group
, request
.net_log());
432 } else if (group
->IsEmpty()) {
433 RemoveGroup(group_name
);
440 bool ClientSocketPoolBaseHelper::AssignIdleSocketToRequest(
441 const Request
& request
, Group
* group
) {
442 std::list
<IdleSocket
>* idle_sockets
= group
->mutable_idle_sockets();
443 std::list
<IdleSocket
>::iterator idle_socket_it
= idle_sockets
->end();
445 // Iterate through the idle sockets forwards (oldest to newest)
446 // * Delete any disconnected ones.
447 // * If we find a used idle socket, assign to |idle_socket|. At the end,
448 // the |idle_socket_it| will be set to the newest used idle socket.
449 for (std::list
<IdleSocket
>::iterator it
= idle_sockets
->begin();
450 it
!= idle_sockets
->end();) {
451 if (!it
->IsUsable()) {
452 DecrementIdleCount();
454 it
= idle_sockets
->erase(it
);
458 if (it
->socket
->WasEverUsed()) {
459 // We found one we can reuse!
466 // If we haven't found an idle socket, that means there are no used idle
467 // sockets. Pick the oldest (first) idle socket (FIFO).
469 if (idle_socket_it
== idle_sockets
->end() && !idle_sockets
->empty())
470 idle_socket_it
= idle_sockets
->begin();
472 if (idle_socket_it
!= idle_sockets
->end()) {
473 DecrementIdleCount();
474 base::TimeDelta idle_time
=
475 base::TimeTicks::Now() - idle_socket_it
->start_time
;
476 IdleSocket idle_socket
= *idle_socket_it
;
477 idle_sockets
->erase(idle_socket_it
);
478 // TODO(davidben): If |idle_time| is under some low watermark, consider
479 // treating as UNUSED rather than UNUSED_IDLE. This will avoid
480 // HttpNetworkTransaction retrying on some errors.
481 ClientSocketHandle::SocketReuseType reuse_type
=
482 idle_socket
.socket
->WasEverUsed() ?
483 ClientSocketHandle::REUSED_IDLE
:
484 ClientSocketHandle::UNUSED_IDLE
;
486 scoped_ptr
<StreamSocket
>(idle_socket
.socket
),
488 LoadTimingInfo::ConnectTiming(),
500 void ClientSocketPoolBaseHelper::LogBoundConnectJobToRequest(
501 const NetLog::Source
& connect_job_source
, const Request
& request
) {
502 request
.net_log().AddEvent(NetLog::TYPE_SOCKET_POOL_BOUND_TO_CONNECT_JOB
,
503 connect_job_source
.ToEventParametersCallback());
506 void ClientSocketPoolBaseHelper::CancelRequest(
507 const std::string
& group_name
, ClientSocketHandle
* handle
) {
508 PendingCallbackMap::iterator callback_it
= pending_callback_map_
.find(handle
);
509 if (callback_it
!= pending_callback_map_
.end()) {
510 int result
= callback_it
->second
.result
;
511 pending_callback_map_
.erase(callback_it
);
512 scoped_ptr
<StreamSocket
> socket
= handle
->PassSocket();
515 socket
->Disconnect();
516 ReleaseSocket(handle
->group_name(), socket
.Pass(), handle
->id());
521 CHECK(ContainsKey(group_map_
, group_name
));
523 Group
* group
= GetOrCreateGroup(group_name
);
525 // Search pending_requests for matching handle.
526 scoped_ptr
<const Request
> request
=
527 group
->FindAndRemovePendingRequest(handle
);
529 request
->net_log().AddEvent(NetLog::TYPE_CANCELLED
);
530 request
->net_log().EndEvent(NetLog::TYPE_SOCKET_POOL
);
532 // We let the job run, unless we're at the socket limit and there is
533 // not another request waiting on the job.
534 if (group
->jobs().size() > group
->pending_request_count() &&
535 ReachedMaxSocketsLimit()) {
536 RemoveConnectJob(*group
->jobs().begin(), group
);
537 CheckForStalledSocketGroups();
542 bool ClientSocketPoolBaseHelper::HasGroup(const std::string
& group_name
) const {
543 return ContainsKey(group_map_
, group_name
);
546 void ClientSocketPoolBaseHelper::CloseIdleSockets() {
547 CleanupIdleSockets(true);
548 DCHECK_EQ(0, idle_socket_count_
);
551 int ClientSocketPoolBaseHelper::IdleSocketCountInGroup(
552 const std::string
& group_name
) const {
553 GroupMap::const_iterator i
= group_map_
.find(group_name
);
554 CHECK(i
!= group_map_
.end());
556 return i
->second
->idle_sockets().size();
559 LoadState
ClientSocketPoolBaseHelper::GetLoadState(
560 const std::string
& group_name
,
561 const ClientSocketHandle
* handle
) const {
562 if (ContainsKey(pending_callback_map_
, handle
))
563 return LOAD_STATE_CONNECTING
;
565 GroupMap::const_iterator group_it
= group_map_
.find(group_name
);
566 // TODO(mmenke): Switch to DCHECK once sure this doesn't break anything.
568 CHECK(group_it
!= group_map_
.end());
569 const Group
& group
= *group_it
->second
;
571 if (group
.HasConnectJobForHandle(handle
)) {
572 // Just return the state of the farthest along ConnectJob for the first
573 // group.jobs().size() pending requests.
574 LoadState max_state
= LOAD_STATE_IDLE
;
575 for (const auto& job
: group
.jobs()) {
576 max_state
= std::max(max_state
, job
->GetLoadState());
581 if (group
.CanUseAdditionalSocketSlot(max_sockets_per_group_
))
582 return LOAD_STATE_WAITING_FOR_STALLED_SOCKET_POOL
;
583 return LOAD_STATE_WAITING_FOR_AVAILABLE_SOCKET
;
586 base::DictionaryValue
* ClientSocketPoolBaseHelper::GetInfoAsValue(
587 const std::string
& name
, const std::string
& type
) const {
588 base::DictionaryValue
* dict
= new base::DictionaryValue();
589 dict
->SetString("name", name
);
590 dict
->SetString("type", type
);
591 dict
->SetInteger("handed_out_socket_count", handed_out_socket_count_
);
592 dict
->SetInteger("connecting_socket_count", connecting_socket_count_
);
593 dict
->SetInteger("idle_socket_count", idle_socket_count_
);
594 dict
->SetInteger("max_socket_count", max_sockets_
);
595 dict
->SetInteger("max_sockets_per_group", max_sockets_per_group_
);
596 dict
->SetInteger("pool_generation_number", pool_generation_number_
);
598 if (group_map_
.empty())
601 base::DictionaryValue
* all_groups_dict
= new base::DictionaryValue();
602 for (GroupMap::const_iterator it
= group_map_
.begin();
603 it
!= group_map_
.end(); it
++) {
604 const Group
* group
= it
->second
;
605 base::DictionaryValue
* group_dict
= new base::DictionaryValue();
607 group_dict
->SetInteger("pending_request_count",
608 group
->pending_request_count());
609 if (group
->has_pending_requests()) {
610 group_dict
->SetString(
611 "top_pending_priority",
612 RequestPriorityToString(group
->TopPendingPriority()));
615 group_dict
->SetInteger("active_socket_count", group
->active_socket_count());
617 base::ListValue
* idle_socket_list
= new base::ListValue();
618 std::list
<IdleSocket
>::const_iterator idle_socket
;
619 for (idle_socket
= group
->idle_sockets().begin();
620 idle_socket
!= group
->idle_sockets().end();
622 int source_id
= idle_socket
->socket
->NetLog().source().id
;
623 idle_socket_list
->Append(new base::FundamentalValue(source_id
));
625 group_dict
->Set("idle_sockets", idle_socket_list
);
627 base::ListValue
* connect_jobs_list
= new base::ListValue();
628 std::set
<ConnectJob
*>::const_iterator job
= group
->jobs().begin();
629 for (job
= group
->jobs().begin(); job
!= group
->jobs().end(); job
++) {
630 int source_id
= (*job
)->net_log().source().id
;
631 connect_jobs_list
->Append(new base::FundamentalValue(source_id
));
633 group_dict
->Set("connect_jobs", connect_jobs_list
);
635 group_dict
->SetBoolean("is_stalled", group
->CanUseAdditionalSocketSlot(
636 max_sockets_per_group_
));
637 group_dict
->SetBoolean("backup_job_timer_is_running",
638 group
->BackupJobTimerIsRunning());
640 all_groups_dict
->SetWithoutPathExpansion(it
->first
, group_dict
);
642 dict
->Set("groups", all_groups_dict
);
646 bool ClientSocketPoolBaseHelper::IdleSocket::IsUsable() const {
647 if (socket
->WasEverUsed())
648 return socket
->IsConnectedAndIdle();
649 return socket
->IsConnected();
652 bool ClientSocketPoolBaseHelper::IdleSocket::ShouldCleanup(
654 base::TimeDelta timeout
) const {
655 bool timed_out
= (now
- start_time
) >= timeout
;
661 void ClientSocketPoolBaseHelper::CleanupIdleSockets(bool force
) {
662 if (idle_socket_count_
== 0)
665 // Current time value. Retrieving it once at the function start rather than
666 // inside the inner loop, since it shouldn't change by any meaningful amount.
667 base::TimeTicks now
= base::TimeTicks::Now();
669 GroupMap::iterator i
= group_map_
.begin();
670 while (i
!= group_map_
.end()) {
671 Group
* group
= i
->second
;
673 std::list
<IdleSocket
>::iterator j
= group
->mutable_idle_sockets()->begin();
674 while (j
!= group
->idle_sockets().end()) {
675 base::TimeDelta timeout
=
676 j
->socket
->WasEverUsed() ?
677 used_idle_socket_timeout_
: unused_idle_socket_timeout_
;
678 if (force
|| j
->ShouldCleanup(now
, timeout
)) {
680 j
= group
->mutable_idle_sockets()->erase(j
);
681 DecrementIdleCount();
687 // Delete group if no longer needed.
688 if (group
->IsEmpty()) {
696 ClientSocketPoolBaseHelper::Group
* ClientSocketPoolBaseHelper::GetOrCreateGroup(
697 const std::string
& group_name
) {
698 GroupMap::iterator it
= group_map_
.find(group_name
);
699 if (it
!= group_map_
.end())
701 Group
* group
= new Group
;
702 group_map_
[group_name
] = group
;
706 void ClientSocketPoolBaseHelper::RemoveGroup(const std::string
& group_name
) {
707 GroupMap::iterator it
= group_map_
.find(group_name
);
708 CHECK(it
!= group_map_
.end());
713 void ClientSocketPoolBaseHelper::RemoveGroup(GroupMap::iterator it
) {
715 group_map_
.erase(it
);
719 bool ClientSocketPoolBaseHelper::connect_backup_jobs_enabled() {
720 return g_connect_backup_jobs_enabled
;
724 bool ClientSocketPoolBaseHelper::set_connect_backup_jobs_enabled(bool enabled
) {
725 bool old_value
= g_connect_backup_jobs_enabled
;
726 g_connect_backup_jobs_enabled
= enabled
;
730 void ClientSocketPoolBaseHelper::EnableConnectBackupJobs() {
731 connect_backup_jobs_enabled_
= g_connect_backup_jobs_enabled
;
734 void ClientSocketPoolBaseHelper::IncrementIdleCount() {
735 if (++idle_socket_count_
== 1 && use_cleanup_timer_
)
736 StartIdleSocketTimer();
739 void ClientSocketPoolBaseHelper::DecrementIdleCount() {
740 if (--idle_socket_count_
== 0)
745 bool ClientSocketPoolBaseHelper::cleanup_timer_enabled() {
746 return g_cleanup_timer_enabled
;
750 bool ClientSocketPoolBaseHelper::set_cleanup_timer_enabled(bool enabled
) {
751 bool old_value
= g_cleanup_timer_enabled
;
752 g_cleanup_timer_enabled
= enabled
;
756 void ClientSocketPoolBaseHelper::StartIdleSocketTimer() {
757 timer_
.Start(FROM_HERE
, TimeDelta::FromSeconds(kCleanupInterval
), this,
758 &ClientSocketPoolBaseHelper::OnCleanupTimerFired
);
761 void ClientSocketPoolBaseHelper::ReleaseSocket(const std::string
& group_name
,
762 scoped_ptr
<StreamSocket
> socket
,
764 GroupMap::iterator i
= group_map_
.find(group_name
);
765 CHECK(i
!= group_map_
.end());
767 Group
* group
= i
->second
;
769 CHECK_GT(handed_out_socket_count_
, 0);
770 handed_out_socket_count_
--;
772 CHECK_GT(group
->active_socket_count(), 0);
773 group
->DecrementActiveSocketCount();
775 const bool can_reuse
= socket
->IsConnectedAndIdle() &&
776 id
== pool_generation_number_
;
778 // Add it to the idle list.
779 AddIdleSocket(socket
.Pass(), group
);
780 OnAvailableSocketSlot(group_name
, group
);
785 CheckForStalledSocketGroups();
788 void ClientSocketPoolBaseHelper::CheckForStalledSocketGroups() {
789 // If we have idle sockets, see if we can give one to the top-stalled group.
790 std::string top_group_name
;
791 Group
* top_group
= NULL
;
792 if (!FindTopStalledGroup(&top_group
, &top_group_name
)) {
793 // There may still be a stalled group in a lower level pool.
794 for (std::set
<LowerLayeredPool
*>::iterator it
= lower_pools_
.begin();
795 it
!= lower_pools_
.end();
797 if ((*it
)->IsStalled()) {
798 CloseOneIdleSocket();
805 if (ReachedMaxSocketsLimit()) {
806 if (idle_socket_count() > 0) {
807 CloseOneIdleSocket();
809 // We can't activate more sockets since we're already at our global
815 // Note: we don't loop on waking stalled groups. If the stalled group is at
816 // its limit, may be left with other stalled groups that could be
817 // woken. This isn't optimal, but there is no starvation, so to avoid
818 // the looping we leave it at this.
819 OnAvailableSocketSlot(top_group_name
, top_group
);
822 // Search for the highest priority pending request, amongst the groups that
823 // are not at the |max_sockets_per_group_| limit. Note: for requests with
824 // the same priority, the winner is based on group hash ordering (and not
826 bool ClientSocketPoolBaseHelper::FindTopStalledGroup(
828 std::string
* group_name
) const {
829 CHECK((group
&& group_name
) || (!group
&& !group_name
));
830 Group
* top_group
= NULL
;
831 const std::string
* top_group_name
= NULL
;
832 bool has_stalled_group
= false;
833 for (GroupMap::const_iterator i
= group_map_
.begin();
834 i
!= group_map_
.end(); ++i
) {
835 Group
* curr_group
= i
->second
;
836 if (!curr_group
->has_pending_requests())
838 if (curr_group
->CanUseAdditionalSocketSlot(max_sockets_per_group_
)) {
841 has_stalled_group
= true;
842 bool has_higher_priority
= !top_group
||
843 curr_group
->TopPendingPriority() > top_group
->TopPendingPriority();
844 if (has_higher_priority
) {
845 top_group
= curr_group
;
846 top_group_name
= &i
->first
;
854 *group_name
= *top_group_name
;
856 CHECK(!has_stalled_group
);
858 return has_stalled_group
;
861 void ClientSocketPoolBaseHelper::OnConnectJobComplete(
862 int result
, ConnectJob
* job
) {
863 // TODO(vadimt): Remove ScopedTracker below once crbug.com/436634 is fixed.
864 tracked_objects::ScopedTracker
tracking_profile(
865 FROM_HERE_WITH_EXPLICIT_FUNCTION(
866 "436634 ClientSocketPoolBaseHelper::OnConnectJobComplete"));
868 DCHECK_NE(ERR_IO_PENDING
, result
);
869 const std::string group_name
= job
->group_name();
870 GroupMap::iterator group_it
= group_map_
.find(group_name
);
871 CHECK(group_it
!= group_map_
.end());
872 Group
* group
= group_it
->second
;
874 scoped_ptr
<StreamSocket
> socket
= job
->PassSocket();
876 // Copies of these are needed because |job| may be deleted before they are
878 BoundNetLog job_log
= job
->net_log();
879 LoadTimingInfo::ConnectTiming connect_timing
= job
->connect_timing();
881 // RemoveConnectJob(job, _) must be called by all branches below;
882 // otherwise, |job| will be leaked.
885 DCHECK(socket
.get());
886 RemoveConnectJob(job
, group
);
887 scoped_ptr
<const Request
> request
= group
->PopNextPendingRequest();
889 LogBoundConnectJobToRequest(job_log
.source(), *request
);
891 socket
.Pass(), ClientSocketHandle::UNUSED
, connect_timing
,
892 request
->handle(), base::TimeDelta(), group
, request
->net_log());
893 request
->net_log().EndEvent(NetLog::TYPE_SOCKET_POOL
);
894 InvokeUserCallbackLater(request
->handle(), request
->callback(), result
);
896 AddIdleSocket(socket
.Pass(), group
);
897 OnAvailableSocketSlot(group_name
, group
);
898 CheckForStalledSocketGroups();
901 // If we got a socket, it must contain error information so pass that
902 // up so that the caller can retrieve it.
903 bool handed_out_socket
= false;
904 scoped_ptr
<const Request
> request
= group
->PopNextPendingRequest();
906 LogBoundConnectJobToRequest(job_log
.source(), *request
);
907 job
->GetAdditionalErrorState(request
->handle());
908 RemoveConnectJob(job
, group
);
910 handed_out_socket
= true;
911 HandOutSocket(socket
.Pass(), ClientSocketHandle::UNUSED
,
912 connect_timing
, request
->handle(), base::TimeDelta(),
913 group
, request
->net_log());
915 request
->net_log().EndEventWithNetErrorCode(
916 NetLog::TYPE_SOCKET_POOL
, result
);
917 InvokeUserCallbackLater(request
->handle(), request
->callback(), result
);
919 RemoveConnectJob(job
, group
);
921 if (!handed_out_socket
) {
922 OnAvailableSocketSlot(group_name
, group
);
923 CheckForStalledSocketGroups();
928 void ClientSocketPoolBaseHelper::OnIPAddressChanged() {
929 FlushWithError(ERR_NETWORK_CHANGED
);
932 void ClientSocketPoolBaseHelper::FlushWithError(int error
) {
933 pool_generation_number_
++;
934 CancelAllConnectJobs();
936 CancelAllRequestsWithError(error
);
939 void ClientSocketPoolBaseHelper::RemoveConnectJob(ConnectJob
* job
,
941 CHECK_GT(connecting_socket_count_
, 0);
942 connecting_socket_count_
--;
945 group
->RemoveJob(job
);
948 void ClientSocketPoolBaseHelper::OnAvailableSocketSlot(
949 const std::string
& group_name
, Group
* group
) {
950 DCHECK(ContainsKey(group_map_
, group_name
));
951 if (group
->IsEmpty()) {
952 RemoveGroup(group_name
);
953 } else if (group
->has_pending_requests()) {
954 ProcessPendingRequest(group_name
, group
);
958 void ClientSocketPoolBaseHelper::ProcessPendingRequest(
959 const std::string
& group_name
, Group
* group
) {
960 const Request
* next_request
= group
->GetNextPendingRequest();
961 DCHECK(next_request
);
963 // If the group has no idle sockets, and can't make use of an additional slot,
964 // either because it's at the limit or because it's at the socket per group
965 // limit, then there's nothing to do.
966 if (group
->idle_sockets().empty() &&
967 !group
->CanUseAdditionalSocketSlot(max_sockets_per_group_
)) {
971 int rv
= RequestSocketInternal(group_name
, *next_request
);
972 if (rv
!= ERR_IO_PENDING
) {
973 scoped_ptr
<const Request
> request
= group
->PopNextPendingRequest();
975 if (group
->IsEmpty())
976 RemoveGroup(group_name
);
978 request
->net_log().EndEventWithNetErrorCode(NetLog::TYPE_SOCKET_POOL
, rv
);
979 InvokeUserCallbackLater(request
->handle(), request
->callback(), rv
);
983 void ClientSocketPoolBaseHelper::HandOutSocket(
984 scoped_ptr
<StreamSocket
> socket
,
985 ClientSocketHandle::SocketReuseType reuse_type
,
986 const LoadTimingInfo::ConnectTiming
& connect_timing
,
987 ClientSocketHandle
* handle
,
988 base::TimeDelta idle_time
,
990 const BoundNetLog
& net_log
) {
992 handle
->SetSocket(socket
.Pass());
993 handle
->set_reuse_type(reuse_type
);
994 handle
->set_idle_time(idle_time
);
995 handle
->set_pool_id(pool_generation_number_
);
996 handle
->set_connect_timing(connect_timing
);
998 if (handle
->is_reused()) {
1000 NetLog::TYPE_SOCKET_POOL_REUSED_AN_EXISTING_SOCKET
,
1001 NetLog::IntegerCallback(
1002 "idle_ms", static_cast<int>(idle_time
.InMilliseconds())));
1006 NetLog::TYPE_SOCKET_POOL_BOUND_TO_SOCKET
,
1007 handle
->socket()->NetLog().source().ToEventParametersCallback());
1009 handed_out_socket_count_
++;
1010 group
->IncrementActiveSocketCount();
1013 void ClientSocketPoolBaseHelper::AddIdleSocket(
1014 scoped_ptr
<StreamSocket
> socket
,
1017 IdleSocket idle_socket
;
1018 idle_socket
.socket
= socket
.release();
1019 idle_socket
.start_time
= base::TimeTicks::Now();
1021 group
->mutable_idle_sockets()->push_back(idle_socket
);
1022 IncrementIdleCount();
1025 void ClientSocketPoolBaseHelper::CancelAllConnectJobs() {
1026 for (GroupMap::iterator i
= group_map_
.begin(); i
!= group_map_
.end();) {
1027 Group
* group
= i
->second
;
1028 connecting_socket_count_
-= group
->jobs().size();
1029 group
->RemoveAllJobs();
1031 // Delete group if no longer needed.
1032 if (group
->IsEmpty()) {
1033 // RemoveGroup() will call .erase() which will invalidate the iterator,
1034 // but i will already have been incremented to a valid iterator before
1035 // RemoveGroup() is called.
1041 DCHECK_EQ(0, connecting_socket_count_
);
1044 void ClientSocketPoolBaseHelper::CancelAllRequestsWithError(int error
) {
1045 for (GroupMap::iterator i
= group_map_
.begin(); i
!= group_map_
.end();) {
1046 Group
* group
= i
->second
;
1049 scoped_ptr
<const Request
> request
= group
->PopNextPendingRequest();
1052 InvokeUserCallbackLater(request
->handle(), request
->callback(), error
);
1055 // Delete group if no longer needed.
1056 if (group
->IsEmpty()) {
1057 // RemoveGroup() will call .erase() which will invalidate the iterator,
1058 // but i will already have been incremented to a valid iterator before
1059 // RemoveGroup() is called.
1067 bool ClientSocketPoolBaseHelper::ReachedMaxSocketsLimit() const {
1068 // Each connecting socket will eventually connect and be handed out.
1069 int total
= handed_out_socket_count_
+ connecting_socket_count_
+
1070 idle_socket_count();
1071 // There can be more sockets than the limit since some requests can ignore
1073 if (total
< max_sockets_
)
1078 bool ClientSocketPoolBaseHelper::CloseOneIdleSocket() {
1079 if (idle_socket_count() == 0)
1081 return CloseOneIdleSocketExceptInGroup(NULL
);
1084 bool ClientSocketPoolBaseHelper::CloseOneIdleSocketExceptInGroup(
1085 const Group
* exception_group
) {
1086 CHECK_GT(idle_socket_count(), 0);
1088 for (GroupMap::iterator i
= group_map_
.begin(); i
!= group_map_
.end(); ++i
) {
1089 Group
* group
= i
->second
;
1090 if (exception_group
== group
)
1092 std::list
<IdleSocket
>* idle_sockets
= group
->mutable_idle_sockets();
1094 if (!idle_sockets
->empty()) {
1095 delete idle_sockets
->front().socket
;
1096 idle_sockets
->pop_front();
1097 DecrementIdleCount();
1098 if (group
->IsEmpty())
1108 bool ClientSocketPoolBaseHelper::CloseOneIdleConnectionInHigherLayeredPool() {
1109 // This pool doesn't have any idle sockets. It's possible that a pool at a
1110 // higher layer is holding one of this sockets active, but it's actually idle.
1111 // Query the higher layers.
1112 for (std::set
<HigherLayeredPool
*>::const_iterator it
= higher_pools_
.begin();
1113 it
!= higher_pools_
.end(); ++it
) {
1114 if ((*it
)->CloseOneIdleConnection())
1120 void ClientSocketPoolBaseHelper::InvokeUserCallbackLater(
1121 ClientSocketHandle
* handle
, const CompletionCallback
& callback
, int rv
) {
1122 CHECK(!ContainsKey(pending_callback_map_
, handle
));
1123 pending_callback_map_
[handle
] = CallbackResultPair(callback
, rv
);
1124 base::MessageLoop::current()->PostTask(
1126 base::Bind(&ClientSocketPoolBaseHelper::InvokeUserCallback
,
1127 weak_factory_
.GetWeakPtr(), handle
));
1130 void ClientSocketPoolBaseHelper::InvokeUserCallback(
1131 ClientSocketHandle
* handle
) {
1132 PendingCallbackMap::iterator it
= pending_callback_map_
.find(handle
);
1134 // Exit if the request has already been cancelled.
1135 if (it
== pending_callback_map_
.end())
1138 CHECK(!handle
->is_initialized());
1139 CompletionCallback callback
= it
->second
.callback
;
1140 int result
= it
->second
.result
;
1141 pending_callback_map_
.erase(it
);
1142 callback
.Run(result
);
1145 void ClientSocketPoolBaseHelper::TryToCloseSocketsInLayeredPools() {
1146 while (IsStalled()) {
1147 // Closing a socket will result in calling back into |this| to use the freed
1148 // socket slot, so nothing else is needed.
1149 if (!CloseOneIdleConnectionInHigherLayeredPool())
1154 ClientSocketPoolBaseHelper::Group::Group()
1155 : unassigned_job_count_(0),
1156 pending_requests_(NUM_PRIORITIES
),
1157 active_socket_count_(0) {}
1159 ClientSocketPoolBaseHelper::Group::~Group() {
1160 DCHECK_EQ(0u, unassigned_job_count_
);
1163 void ClientSocketPoolBaseHelper::Group::StartBackupJobTimer(
1164 const std::string
& group_name
,
1165 ClientSocketPoolBaseHelper
* pool
) {
1166 // Only allow one timer to run at a time.
1167 if (BackupJobTimerIsRunning())
1170 // Unretained here is okay because |backup_job_timer_| is
1171 // automatically cancelled when it's destroyed.
1172 backup_job_timer_
.Start(
1173 FROM_HERE
, pool
->ConnectRetryInterval(),
1174 base::Bind(&Group::OnBackupJobTimerFired
, base::Unretained(this),
1178 bool ClientSocketPoolBaseHelper::Group::BackupJobTimerIsRunning() const {
1179 return backup_job_timer_
.IsRunning();
1182 bool ClientSocketPoolBaseHelper::Group::TryToUseUnassignedConnectJob() {
1185 if (unassigned_job_count_
== 0)
1187 --unassigned_job_count_
;
1191 void ClientSocketPoolBaseHelper::Group::AddJob(scoped_ptr
<ConnectJob
> job
,
1192 bool is_preconnect
) {
1196 ++unassigned_job_count_
;
1197 jobs_
.insert(job
.release());
1200 void ClientSocketPoolBaseHelper::Group::RemoveJob(ConnectJob
* job
) {
1201 scoped_ptr
<ConnectJob
> owned_job(job
);
1204 std::set
<ConnectJob
*>::iterator it
= jobs_
.find(job
);
1205 if (it
!= jobs_
.end()) {
1210 size_t job_count
= jobs_
.size();
1211 if (job_count
< unassigned_job_count_
)
1212 unassigned_job_count_
= job_count
;
1214 // If we've got no more jobs for this group, then we no longer need a
1215 // backup job either.
1217 backup_job_timer_
.Stop();
1220 void ClientSocketPoolBaseHelper::Group::OnBackupJobTimerFired(
1221 std::string group_name
,
1222 ClientSocketPoolBaseHelper
* pool
) {
1223 // If there are no more jobs pending, there is no work to do.
1224 // If we've done our cleanups correctly, this should not happen.
1225 if (jobs_
.empty()) {
1230 // If our old job is waiting on DNS, or if we can't create any sockets
1231 // right now due to limits, just reset the timer.
1232 if (pool
->ReachedMaxSocketsLimit() ||
1233 !HasAvailableSocketSlot(pool
->max_sockets_per_group_
) ||
1234 (*jobs_
.begin())->GetLoadState() == LOAD_STATE_RESOLVING_HOST
) {
1235 StartBackupJobTimer(group_name
, pool
);
1239 if (pending_requests_
.empty())
1242 scoped_ptr
<ConnectJob
> backup_job
=
1243 pool
->connect_job_factory_
->NewConnectJob(
1244 group_name
, *pending_requests_
.FirstMax().value(), pool
);
1245 backup_job
->net_log().AddEvent(NetLog::TYPE_BACKUP_CONNECT_JOB_CREATED
);
1246 int rv
= backup_job
->Connect();
1247 pool
->connecting_socket_count_
++;
1248 ConnectJob
* raw_backup_job
= backup_job
.get();
1249 AddJob(backup_job
.Pass(), false);
1250 if (rv
!= ERR_IO_PENDING
)
1251 pool
->OnConnectJobComplete(rv
, raw_backup_job
);
1254 void ClientSocketPoolBaseHelper::Group::SanityCheck() {
1255 DCHECK_LE(unassigned_job_count_
, jobs_
.size());
1258 void ClientSocketPoolBaseHelper::Group::RemoveAllJobs() {
1261 // Delete active jobs.
1262 STLDeleteElements(&jobs_
);
1263 unassigned_job_count_
= 0;
1265 // Stop backup job timer.
1266 backup_job_timer_
.Stop();
1269 const ClientSocketPoolBaseHelper::Request
*
1270 ClientSocketPoolBaseHelper::Group::GetNextPendingRequest() const {
1272 pending_requests_
.empty() ? NULL
: pending_requests_
.FirstMax().value();
1275 bool ClientSocketPoolBaseHelper::Group::HasConnectJobForHandle(
1276 const ClientSocketHandle
* handle
) const {
1277 // Search the first |jobs_.size()| pending requests for |handle|.
1278 // If it's farther back in the deque than that, it doesn't have a
1279 // corresponding ConnectJob.
1281 for (RequestQueue::Pointer pointer
= pending_requests_
.FirstMax();
1282 !pointer
.is_null() && i
< jobs_
.size();
1283 pointer
= pending_requests_
.GetNextTowardsLastMin(pointer
), ++i
) {
1284 if (pointer
.value()->handle() == handle
)
1290 void ClientSocketPoolBaseHelper::Group::InsertPendingRequest(
1291 scoped_ptr
<const Request
> request
) {
1292 // This value must be cached before we release |request|.
1293 RequestPriority priority
= request
->priority();
1294 if (request
->ignore_limits()) {
1295 // Put requests with ignore_limits == true (which should have
1296 // priority == MAXIMUM_PRIORITY) ahead of other requests with
1297 // MAXIMUM_PRIORITY.
1298 DCHECK_EQ(priority
, MAXIMUM_PRIORITY
);
1299 pending_requests_
.InsertAtFront(request
.release(), priority
);
1301 pending_requests_
.Insert(request
.release(), priority
);
1305 scoped_ptr
<const ClientSocketPoolBaseHelper::Request
>
1306 ClientSocketPoolBaseHelper::Group::PopNextPendingRequest() {
1307 if (pending_requests_
.empty())
1308 return scoped_ptr
<const ClientSocketPoolBaseHelper::Request
>();
1309 return RemovePendingRequest(pending_requests_
.FirstMax());
1312 scoped_ptr
<const ClientSocketPoolBaseHelper::Request
>
1313 ClientSocketPoolBaseHelper::Group::FindAndRemovePendingRequest(
1314 ClientSocketHandle
* handle
) {
1315 for (RequestQueue::Pointer pointer
= pending_requests_
.FirstMax();
1317 pointer
= pending_requests_
.GetNextTowardsLastMin(pointer
)) {
1318 if (pointer
.value()->handle() == handle
) {
1319 scoped_ptr
<const Request
> request
= RemovePendingRequest(pointer
);
1320 return request
.Pass();
1323 return scoped_ptr
<const ClientSocketPoolBaseHelper::Request
>();
1326 scoped_ptr
<const ClientSocketPoolBaseHelper::Request
>
1327 ClientSocketPoolBaseHelper::Group::RemovePendingRequest(
1328 const RequestQueue::Pointer
& pointer
) {
1329 scoped_ptr
<const Request
> request(pointer
.value());
1330 pending_requests_
.Erase(pointer
);
1331 // If there are no more requests, kill the backup timer.
1332 if (pending_requests_
.empty())
1333 backup_job_timer_
.Stop();
1334 return request
.Pass();
1337 } // namespace internal