Really connect to the same server in FTP network transaction.

net/socket/socket_test_util.cc

 // Copyright (c) 2009 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/socket_test_util.h"
 
 #include <algorithm>
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/message_loop.h"
+#include "net/base/address_family.h"
+#include "net/base/host_resolver_proc.h"
 #include "net/base/ssl_info.h"
 #include "net/socket/socket.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace net {
 
 MockClientSocket::MockClientSocket()
     : ALLOW_THIS_IN_INITIALIZER_LIST(method_factory_(this)),
       connected_(false) {
 }
@@ skipping 18 matching lines @@
 }
 
 bool MockClientSocket::IsConnected() const {
   return connected_;
 }
 
 bool MockClientSocket::IsConnectedAndIdle() const {
   return connected_;
 }
 
-int MockClientSocket::GetPeerName(struct sockaddr* name, socklen_t* namelen) {
-  memset(reinterpret_cast<char *>(name), 0, *namelen);
-  return net::OK;
+int MockClientSocket::GetPeerAddress(AddressList* address) const {
+  return net::SystemHostResolverProc("localhost", ADDRESS_FAMILY_UNSPECIFIED,
+                                     address);
 }
 
 void MockClientSocket::RunCallbackAsync(net::CompletionCallback* callback,
                                         int result) {
   MessageLoop::current()->PostTask(FROM_HERE,
       method_factory_.NewRunnableMethod(
           &MockClientSocket::RunCallback, callback, result));
 }
 
 void MockClientSocket::RunCallback(net::CompletionCallback* callback,
@@ skipping 300 matching lines @@
     SSLSocketDataProvider* data) {
   mock_ssl_data_.Add(data);
 }
 
 void MockClientSocketFactory::ResetNextMockIndexes() {
   mock_data_.ResetNextIndex();
   mock_ssl_data_.ResetNextIndex();
 }
 
 MockTCPClientSocket* MockClientSocketFactory::GetMockTCPClientSocket(
-    int index) const {
+    size_t index) const {
+  DCHECK_LT(index, tcp_client_sockets_.size());
   return tcp_client_sockets_[index];
 }
 
 MockSSLClientSocket* MockClientSocketFactory::GetMockSSLClientSocket(
-    int index) const {
+    size_t index) const {
+  DCHECK_LT(index, ssl_client_sockets_.size());
   return ssl_client_sockets_[index];
 }
 
 ClientSocket* MockClientSocketFactory::CreateTCPClientSocket(
     const AddressList& addresses) {
   SocketDataProvider* data_provider = mock_data_.GetNext();
   MockTCPClientSocket* socket =
       new MockTCPClientSocket(addresses, data_provider);
   data_provider->set_socket(socket);
   tcp_client_sockets_.push_back(socket);
@@ skipping 73 matching lines @@
 }
 
 void ClientSocketPoolTest::ReleaseAllConnections(KeepAlive keep_alive) {
   bool released_one;
   do {
     released_one = ReleaseOneConnection(keep_alive);
   } while (released_one);
 }
 
 }  // namespace net