Implement SSLClientSocketPool.

net/socket/client_socket_pool_base.cc

 // Copyright (c) 2010 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/socket/client_socket_pool_base.h"
 
 #include "base/compiler_specific.h"
 #include "base/format_macros.h"
 #include "base/message_loop.h"
 #include "base/stats_counters.h"
@@ skipping 239 matching lines @@
                                                              this);
       StartBackupSocketTimer(group_name);
     }
 
     connecting_socket_count_++;
 
     ConnectJob* job = connect_job.release();
     group.jobs.insert(job);
   } else {
     LogBoundConnectJobToRequest(connect_job->net_log().source(), request);
+    connect_job->GetAdditionalErrorState(handle);
     ClientSocket* error_socket = connect_job->ReleaseSocket();
     if (error_socket) {
       HandOutSocket(error_socket, false /* not reused */, handle,
                     base::TimeDelta(), &group, request->net_log());
     }
     if (group.IsEmpty())
       group_map_.erase(group_name);
   }
 
   return rv;
@@ skipping 315 matching lines @@
 
   DCHECK_NE(ERR_IO_PENDING, result);
   const std::string group_name = job->group_name();
   GroupMap::iterator group_it = group_map_.find(group_name);
   CHECK(group_it != group_map_.end());
   Group& group = group_it->second;
 
   scoped_ptr<ClientSocket> socket(job->ReleaseSocket());
 
   BoundNetLog job_log = job->net_log();
-  RemoveConnectJob(job, &group);
 
   if (result == OK) {
     DCHECK(socket.get());
+    RemoveConnectJob(job, &group);
     if (!group.pending_requests.empty()) {
       scoped_ptr<const Request> r(RemoveRequestFromQueue(
           group.pending_requests.begin(), &group.pending_requests));
       LogBoundConnectJobToRequest(job_log.source(), r.get());
       HandOutSocket(
           socket.release(), false /* unused socket */, r->handle(),
           base::TimeDelta(), &group, r->net_log());
       r->net_log().EndEvent(NetLog::TYPE_SOCKET_POOL, NULL);
       r->callback()->Run(result);
     } else {
       AddIdleSocket(socket.release(), false /* unused socket */, &group);
       OnAvailableSocketSlot(group_name, MayHaveStalledGroups());
     }
   } else {
     // If we got a socket, it must contain error information so pass that
     // up so that the caller can retrieve it.
     bool handed_out_socket = false;
     if (!group.pending_requests.empty()) {
       scoped_ptr<const Request> r(RemoveRequestFromQueue(
           group.pending_requests.begin(), &group.pending_requests));
       LogBoundConnectJobToRequest(job_log.source(), r.get());
+      job->GetAdditionalErrorState(r->handle());
+      RemoveConnectJob(job, &group);
       if (socket.get()) {
         handed_out_socket = true;
         HandOutSocket(socket.release(), false /* unused socket */, r->handle(),
                       base::TimeDelta(), &group, r->net_log());
       }
       r->net_log().EndEvent(NetLog::TYPE_SOCKET_POOL,
                             new NetLogIntegerParameter("net_error", result));
+      if (socket.get()) {
+        handed_out_socket = true;
+        HandOutSocket(
+            socket.release(), false /* unused socket */, r->handle(),
+            base::TimeDelta(), &group, r->net_log());

[willchan no longer on Chromium, 2010/07/15 00:52:24]

Is this a bad merge?  Did this get copied twice?

+      }
       r->callback()->Run(result);
+    } else {
+      RemoveConnectJob(job, &group);
     }
     if (!handed_out_socket)
       OnAvailableSocketSlot(group_name, MayHaveStalledGroups());
   }
 }
 
 void ClientSocketPoolBaseHelper::OnIPAddressChanged() {
   Flush();
 }
 
@@ skipping 153 matching lines @@
       return;
     }
   }
 
   LOG(DFATAL) << "No idle socket found to close!.";
 }
 
 }  // namespace internal
 
 }  // namespace net