Rename ClientSocket to StreamSocket.

net/socket/tcp_server_socket_unittest.cc

 // Copyright (c) 2011 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/tcp_server_socket.h"
 
 #include "base/compiler_specific.h"
 #include "base/scoped_ptr.h"
 #include "net/base/address_list.h"
 #include "net/base/ip_endpoint.h"
@@ skipping 23 matching lines @@
   }
 
   void ParseAddress(std::string ip_str, int port, IPEndPoint* address) {
     IPAddressNumber ip_number;
     bool rv = ParseIPLiteralToNumber(ip_str, &ip_number);
     if (!rv)
       return;
     *address = IPEndPoint(ip_number, port);
   }
 
-  static IPEndPoint GetPeerAddress(ClientSocket* socket) {
+  static IPEndPoint GetPeerAddress(StreamSocket* socket) {
     AddressList address;
     EXPECT_EQ(OK, socket->GetPeerAddress(&address));
     IPEndPoint endpoint;
     EXPECT_TRUE(endpoint.FromSockAddr(
         address.head()->ai_addr, address.head()->ai_addrlen));
     return endpoint;
   }
 
   TCPServerSocket socket_;
   IPEndPoint local_address_;
 };
 
 TEST_F(TCPServerSocketTest, Accept) {
   TestCompletionCallback connect_callback;
   TCPClientSocket connecting_socket(AddressList(local_address_.address(),
                                                 local_address_.port(), false),
                                     NULL, NetLog::Source());
   connecting_socket.Connect(&connect_callback);
 
   TestCompletionCallback accept_callback;
-  scoped_ptr<ClientSocket> accepted_socket;
+  scoped_ptr<StreamSocket> accepted_socket;
   int result = socket_.Accept(&accepted_socket, &accept_callback);
   if (result == ERR_IO_PENDING)
     result = accept_callback.WaitForResult();
   ASSERT_EQ(OK, result);
 
   ASSERT_TRUE(accepted_socket.get() != NULL);
 
   // Both sockets should be on the loopback network interface.
   EXPECT_EQ(GetPeerAddress(accepted_socket.get()).address(),
             local_address_.address());
 
   EXPECT_EQ(OK, connect_callback.WaitForResult());
 }
 
 // Test Accept() callback.
 TEST_F(TCPServerSocketTest, AcceptAsync) {
   TestCompletionCallback accept_callback;
-  scoped_ptr<ClientSocket> accepted_socket;
+  scoped_ptr<StreamSocket> accepted_socket;
 
   ASSERT_EQ(ERR_IO_PENDING, socket_.Accept(&accepted_socket, &accept_callback));
 
   TestCompletionCallback connect_callback;
   TCPClientSocket connecting_socket(AddressList(local_address_.address(),
                                                 local_address_.port(), false),
                                     NULL, NetLog::Source());
   connecting_socket.Connect(&connect_callback);
 
   EXPECT_EQ(OK, connect_callback.WaitForResult());
   EXPECT_EQ(OK, accept_callback.WaitForResult());
 
   EXPECT_TRUE(accepted_socket != NULL);
 
   // Both sockets should be on the loopback network interface.
   EXPECT_EQ(GetPeerAddress(accepted_socket.get()).address(),
             local_address_.address());
 }
 
 // Accept two connections simultaneously.
 TEST_F(TCPServerSocketTest, Accept2Connections) {
   TestCompletionCallback accept_callback;
-  scoped_ptr<ClientSocket> accepted_socket;
+  scoped_ptr<StreamSocket> accepted_socket;
 
   ASSERT_EQ(ERR_IO_PENDING,
             socket_.Accept(&accepted_socket, &accept_callback));
 
   TestCompletionCallback connect_callback;
   TCPClientSocket connecting_socket(AddressList(local_address_.address(),
                                                 local_address_.port(), false),
                                     NULL, NetLog::Source());
   connecting_socket.Connect(&connect_callback);
 
   TestCompletionCallback connect_callback2;
   TCPClientSocket connecting_socket2(AddressList(local_address_.address(),
                                                  local_address_.port(), false),
                                      NULL, NetLog::Source());
   connecting_socket2.Connect(&connect_callback2);
 
   EXPECT_EQ(OK, accept_callback.WaitForResult());
 
   TestCompletionCallback accept_callback2;
-  scoped_ptr<ClientSocket> accepted_socket2;
+  scoped_ptr<StreamSocket> accepted_socket2;
   int result = socket_.Accept(&accepted_socket2, &accept_callback2);
   if (result == ERR_IO_PENDING)
     result = accept_callback2.WaitForResult();
   ASSERT_EQ(OK, result);
 
   EXPECT_EQ(OK, connect_callback.WaitForResult());
 
   EXPECT_TRUE(accepted_socket != NULL);
   EXPECT_TRUE(accepted_socket2 != NULL);
   EXPECT_NE(accepted_socket.get(), accepted_socket2.get());
 
   EXPECT_EQ(GetPeerAddress(accepted_socket.get()).address(),
             local_address_.address());
   EXPECT_EQ(GetPeerAddress(accepted_socket2.get()).address(),
             local_address_.address());
 }
 
 }  // namespace
 
 }  // namespace net