Add DefaultListenSocket.

net/socket/transport_client_socket_unittest.cc

 // Copyright (c) 2012 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_client_socket.h"
 
 #include "base/basictypes.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "net/base/address_list.h"
@@ skipping 13 matching lines @@
 
 namespace {
 
 const char kServerReply[] = "HTTP/1.1 404 Not Found";
 
 enum ClientSocketTestTypes {
   TCP,
   SCTP
 };
 
+}  // namespace
+
 class TransportClientSocketTest
-    : public ListenSocket::ListenSocketDelegate,
+    : public StreamListenSocket::Delegate,
       public ::testing::TestWithParam<ClientSocketTestTypes> {
  public:
   TransportClientSocketTest()
       : listen_port_(0),
         net_log_(CapturingNetLog::kUnbounded),
         socket_factory_(ClientSocketFactory::GetDefaultFactory()),
         close_server_socket_on_next_send_(false) {
   }
 
   ~TransportClientSocketTest() {
   }
 
-  // Implement ListenSocketDelegate methods
-  virtual void DidAccept(ListenSocket* server, ListenSocket* connection) {
+  // Implement StreamListenSocket::Delegate methods
+  virtual void DidAccept(StreamListenSocket* server,
+                         StreamListenSocket* connection) {
     connected_sock_ = reinterpret_cast<TCPListenSocket*>(connection);
   }
-  virtual void DidRead(ListenSocket*, const char* str, int len) {
+  virtual void DidRead(StreamListenSocket*, const char* str, int len) {
     // TODO(dkegel): this might not be long enough to tickle some bugs.
     connected_sock_->Send(kServerReply, arraysize(kServerReply) - 1,
                           false /* Don't append line feed */);
     if (close_server_socket_on_next_send_)
       CloseServerSocket();
   }
-  virtual void DidClose(ListenSocket* sock) {}
+  virtual void DidClose(StreamListenSocket* sock) {}
 
   // Testcase hooks
   virtual void SetUp();
 
   void CloseServerSocket() {
     // delete the connected_sock_, which will close it.
     connected_sock_ = NULL;
   }
 
   void PauseServerReads() {
@@ skipping 24 matching lines @@
  private:
   scoped_refptr<TCPListenSocket> listen_sock_;
   scoped_refptr<TCPListenSocket> connected_sock_;
   bool close_server_socket_on_next_send_;
 };
 
 void TransportClientSocketTest::SetUp() {
   ::testing::TestWithParam<ClientSocketTestTypes>::SetUp();
 
   // Find a free port to listen on
-  TCPListenSocket *sock = NULL;
+  scoped_refptr<TCPListenSocket> sock = NULL;
   int port;
   // Range of ports to listen on.  Shouldn't need to try many.
   const int kMinPort = 10100;
   const int kMaxPort = 10200;
 #if defined(OS_WIN)
   EnsureWinsockInit();
 #endif
   for (port = kMinPort; port < kMaxPort; port++) {
     sock = TCPListenSocket::CreateAndListen("127.0.0.1", port, this);
-    if (sock)
+    if (sock.get())
       break;
   }
   ASSERT_TRUE(sock != NULL);
   listen_sock_ = sock;
   listen_port_ = port;
 
   AddressList addr;
   scoped_ptr<HostResolver> resolver(
       CreateSystemHostResolver(HostResolver::kDefaultParallelism,
                                HostResolver::kDefaultRetryAttempts,
@@ skipping 313 matching lines @@
   EXPECT_GE(rv, 0);
 
   // It's possible the read is blocked because it's already read all the data.
   // Close the server socket, so there will at least be a 0-byte read.
   CloseServerSocket();
 
   rv = callback.WaitForResult();
   EXPECT_GE(rv, 0);
 }
 
-}  // namespace
-
 }  // namespace net