Clean up net unit testing code.

net/base/listen_socket_unittest.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/base/listen_socket_unittest.h"
 
 #include <fcntl.h>
 #include <sys/types.h>
 
 #include "base/eintr_wrapper.h"
 #include "net/base/net_util.h"
 #include "testing/platform_test.h"
 
 const int ListenSocketTester::kTestPort = 9999;
 
 static const int kReadBufSize = 1024;
 static const char kHelloWorld[] = "HELLO, WORLD";
 static const int kMaxQueueSize = 20;
 static const char kLoopback[] = "127.0.0.1";
 static const int kDefaultTimeoutMs = 5000;
 
-ListenSocket* ListenSocketTester::DoListen() {
-  return ListenSocket::Listen(kLoopback, kTestPort, this);
+ListenSocketTester::ListenSocketTester()
+    : thread_(NULL),
+      loop_(NULL),
+      server_(NULL),
+      connection_(NULL),
+      cv_(&lock_) {
 }
 
 void ListenSocketTester::SetUp() {
   base::Thread::Options options;
   options.message_loop_type = MessageLoop::TYPE_IO;
   thread_.reset(new base::Thread("socketio_test"));
   thread_->StartWithOptions(options);
   loop_ = reinterpret_cast<MessageLoopForIO*>(thread_->message_loop());
 
   loop_->PostTask(FROM_HERE, NewRunnableMethod(
@@ skipping 80 matching lines @@
     server_->AddRef();
     ReportAction(ListenSocketTestAction(ACTION_LISTEN));
   }
 }
 
 void ListenSocketTester::SendFromTester() {
   connection_->Send(kHelloWorld);
   ReportAction(ListenSocketTestAction(ACTION_SEND));
 }
 
-void ListenSocketTester::DidAccept(ListenSocket *server,
-                                   ListenSocket *connection) {
-  connection_ = connection;
-  connection_->AddRef();
-  ReportAction(ListenSocketTestAction(ACTION_ACCEPT));
-}
-
-void ListenSocketTester::DidRead(ListenSocket *connection,
-                                 const char* data,
-                                 int len) {
-  std::string str(data, len);
-  ReportAction(ListenSocketTestAction(ACTION_READ, str));
-}
-
-void ListenSocketTester::DidClose(ListenSocket *sock) {
-  ReportAction(ListenSocketTestAction(ACTION_CLOSE));
-}
-
-bool ListenSocketTester::Send(SOCKET sock, const std::string& str) {
-  int len = static_cast<int>(str.length());
-  int send_len = HANDLE_EINTR(send(sock, str.data(), len, 0));
-  if (send_len == SOCKET_ERROR) {
-    LOG(ERROR) << "send failed: " << errno;
-    return false;
-  } else if (send_len != len) {
-    return false;
-  }
-  return true;
-}
-
 void ListenSocketTester::TestClientSend() {
   ASSERT_TRUE(Send(test_socket_, kHelloWorld));
   NextAction();
   ASSERT_EQ(ACTION_READ, last_action_.type());
   ASSERT_EQ(last_action_.data(), kHelloWorld);
 }
 
 void ListenSocketTester::TestClientSendLong() {
   size_t hello_len = strlen(kHelloWorld);
   std::string long_string;
@@ skipping 29 matching lines @@
     int r = HANDLE_EINTR(recv(test_socket_, buf, buf_len, 0));
     ASSERT_GE(r, 0);
     recv_len += static_cast<unsigned>(r);
     if (!r)
       break;
   }
   buf[recv_len] = 0;
   ASSERT_STREQ(buf, kHelloWorld);
 }
 
+bool ListenSocketTester::Send(SOCKET sock, const std::string& str) {
+  int len = static_cast<int>(str.length());
+  int send_len = HANDLE_EINTR(send(sock, str.data(), len, 0));
+  if (send_len == SOCKET_ERROR) {
+    LOG(ERROR) << "send failed: " << errno;
+    return false;
+  } else if (send_len != len) {
+    return false;
+  }
+  return true;
+}
+
+void ListenSocketTester::DidAccept(ListenSocket *server,
+                                   ListenSocket *connection) {
+  connection_ = connection;
+  connection_->AddRef();
+  ReportAction(ListenSocketTestAction(ACTION_ACCEPT));
+}
+
+void ListenSocketTester::DidRead(ListenSocket *connection,
+                                 const char* data,
+                                 int len) {
+  std::string str(data, len);
+  ReportAction(ListenSocketTestAction(ACTION_READ, str));
+}
+
+void ListenSocketTester::DidClose(ListenSocket *sock) {
+  ReportAction(ListenSocketTestAction(ACTION_CLOSE));
+}
+
+ListenSocketTester::~ListenSocketTester() {}
+
+ListenSocket* ListenSocketTester::DoListen() {
+  return ListenSocket::Listen(kLoopback, kTestPort, this);
+}
+
 
 class ListenSocketTest: public PlatformTest {
  public:
   ListenSocketTest() {
     tester_ = NULL;
   }
 
   virtual void SetUp() {
     PlatformTest::SetUp();
     tester_ = new ListenSocketTester();
@@ skipping 13 matching lines @@
   tester_->TestClientSend();
 }
 
 TEST_F(ListenSocketTest, ClientSendLong) {
   tester_->TestClientSendLong();
 }
 
 TEST_F(ListenSocketTest, ServerSend) {
   tester_->TestServerSend();
 }