Remove ref-counting from StreamListenSocket

chrome_frame/test/test_server.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 "chrome_frame/test/test_server.h"
 
 #include <windows.h>
 #include <objbase.h>
 #include <urlmon.h>
 
@@ skipping 180 matching lines @@
     const net::StreamListenSocket* socket) const {
   ConnectionList::const_iterator it;
   for (it = connections_.begin(); it != connections_.end(); it++) {
     if ((*it)->IsSame(socket)) {
       return (*it);
     }
   }
   return NULL;
 }
 
-void SimpleWebServer::DidAccept(net::StreamListenSocket* server,
-                                net::StreamListenSocket* connection) {
-  connections_.push_back(new Connection(connection));
+void SimpleWebServer::DidAccept(
+    net::StreamListenSocket* server,
+    scoped_ptr<net::StreamListenSocket> connection) {
+  connections_.push_back(new Connection(connection.Pass()));
 }
 
 void SimpleWebServer::DidRead(net::StreamListenSocket* connection,
                               const char* data,
                               int len) {
   Connection* c = FindConnection(connection);
   DCHECK(c);
   Request& r = c->request();
   std::string str(data, len);
   r.OnDataReceived(str);
@@ skipping 41 matching lines @@
 
 HTTPTestServer::HTTPTestServer(int port, const std::wstring& address,
                                base::FilePath root_dir)
     : port_(port), address_(address), root_dir_(root_dir) {
   net::EnsureWinsockInit();
   server_ =
       net::TCPListenSocket::CreateAndListen(WideToUTF8(address), port, this);
 }
 
 HTTPTestServer::~HTTPTestServer() {
-  server_ = NULL;
 }
 
 std::list<scoped_refptr<ConfigurableConnection>>::iterator
 HTTPTestServer::FindConnection(const net::StreamListenSocket* socket) {
   ConnectionList::iterator it;
   // Scan through the list searching for the desired socket. Along the way,
   // erase any connections for which the corresponding socket has already been
   // forgotten about as a result of all data having been sent.
   for (it = connection_list_.begin(); it != connection_list_.end(); ) {
     ConfigurableConnection* connection = it->get();
@@ skipping 11 matching lines @@
 
 scoped_refptr<ConfigurableConnection> HTTPTestServer::ConnectionFromSocket(
     const net::StreamListenSocket* socket) {
   ConnectionList::iterator it = FindConnection(socket);
   if (it != connection_list_.end())
     return *it;
   return NULL;
 }
 
 void HTTPTestServer::DidAccept(net::StreamListenSocket* server,
-                               net::StreamListenSocket* socket) {
-  connection_list_.push_back(new ConfigurableConnection(socket));
+                               scoped_ptr<net::StreamListenSocket> socket) {
+  connection_list_.push_back(new ConfigurableConnection(socket.Pass()));
 }
 
 void HTTPTestServer::DidRead(net::StreamListenSocket* socket,
                              const char* data,
                              int len) {
   scoped_refptr<ConfigurableConnection> connection =
       ConnectionFromSocket(socket);
   if (connection) {
     std::string str(data, len);
     connection->r_.OnDataReceived(str);
@@ skipping 46 matching lines @@
   socket_->Send(chunk_ptr, bytes_to_send);
   VLOG(1) << "Sent(" << cur_pos_ << "," << bytes_to_send << "): "
           << base::StringPiece(chunk_ptr, bytes_to_send);
 
   cur_pos_ += bytes_to_send;
   if (cur_pos_ < size) {
     base::MessageLoop::current()->PostDelayedTask(
         FROM_HERE, base::Bind(&ConfigurableConnection::SendChunk, this),
         base::TimeDelta::FromMilliseconds(options_.timeout_));
   } else {
-    socket_ = 0;  // close the connection.
+    Close();
   }
 }
 
 void ConfigurableConnection::Close() {
-  socket_ = NULL;
+  socket_.reset();
 }
 
 void ConfigurableConnection::Send(const std::string& headers,
                                   const std::string& content) {
   SendOptions options(SendOptions::IMMEDIATE, 0, 0);
   SendWithOptions(headers, content, options);
 }
 
 void ConfigurableConnection::SendWithOptions(const std::string& headers,
                                              const std::string& content,
@@ skipping 32 matching lines @@
     data_.append(content_length_header);
     data_.append("\r\n");
   }
 
   base::MessageLoop::current()->PostDelayedTask(
       FROM_HERE, base::Bind(&ConfigurableConnection::SendChunk, this),
       base::TimeDelta::FromMilliseconds(options.timeout_));
 }
 
 }  // namespace test_server