Delete UDPClientSocket on same thread as creation. Also refactor.

chrome/browser/extensions/api/socket/socket_api_controller.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 "base/json/json_writer.h"
 #include "base/stl_util.h"
 #include "base/values.h"
 #include "chrome/browser/extensions/api/socket/socket_api_controller.h"
 #include "chrome/browser/profiles/profile.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/base/rand_callback.h"
 #include "net/udp/datagram_socket.h"
 #include "net/udp/udp_client_socket.h"
 #include "net/udp/udp_socket.h"
 
 using namespace net;
 
 namespace extensions {
 
 // A Socket wraps a low-level socket and includes housekeeping information that
 // we need to manage it in the context of an extension.
 class Socket {
  public:
-  explicit Socket(const Profile* profile, const std::string& src_extension_id,
-                  const GURL& src_url);
+  Socket(const Profile* profile, const std::string& src_extension_id,
+         const GURL& src_url);
   ~Socket();
 
   bool Connect(const net::IPEndPoint& ip_end_point);
   void Close();
   int Write(const std::string message);
 
  private:
   // TODO(miket): this metadata will enable us to pass events back to the
   // extension that created this Socket.
   const Profile* profile_;
   int id_;
   std::string src_extension_id_;
   GURL src_url_;
 
-  net::UDPClientSocket* udp_client_socket_;
+  scoped_ptr<net::UDPClientSocket> udp_client_socket_;
   bool is_connected_;
   net::OldCompletionCallbackImpl<Socket> io_callback_;
 
   // A callback required by UDPClientSocket::Write().
   void OnIOComplete(int result);
 };
 
 Socket::Socket(const Profile* profile, const std::string& src_extension_id,
                const GURL& src_url)
     : profile_(profile),
@@ skipping 42 matching lines @@
     if (rv <= 0) {
       // We pass all errors, including ERROR_IO_PENDING, back to the caller.
       return bytes_sent > 0 ? bytes_sent : rv;
     }
     bytes_sent += rv;
     buffer->DidConsume(rv);
   }
   return bytes_sent;
 }
 
-SocketController* SocketController::GetInstance() {
-  return Singleton<SocketController>::get();
+SocketController::SocketController() : next_socket_id_(1) {
 }
 
-SocketController::SocketController() : next_socket_id_(1) {}
-
-SocketController::~SocketController() {
-  STLDeleteValues(&socket_map_);
-}
+SocketController::~SocketController() {}
 
 Socket* SocketController::GetSocket(int socket_id) {
   // TODO(miket): we should verify that the extension asking for the
   // socket is the same one that created it.
   SocketMap::iterator i = socket_map_.find(socket_id);
   if (i != socket_map_.end())
-    return i->second;
+    return i->second.get();
   return NULL;
 }
 
 int SocketController::CreateUdp(const Profile* profile,
                                 const std::string& extension_id,
                                 const GURL& src_url) {
-  Socket* socket = new Socket(profile, extension_id, src_url);
-  CHECK(socket);
+  linked_ptr<Socket> socket(new Socket(profile, extension_id, src_url));
+  CHECK(socket.get());
   socket_map_[next_socket_id_] = socket;
   return next_socket_id_++;
 }
 
 bool SocketController::DestroyUdp(int socket_id) {
   Socket* socket = GetSocket(socket_id);
   if (!socket)
     return false;
   delete socket;
   socket_map_.erase(socket_id);
@@ skipping 34 matching lines @@
 
 int SocketController::WriteUdp(int socket_id, const std::string message) {
   Socket* socket = GetSocket(socket_id);
   if (!socket) {
     return -1;
   }
   return socket->Write(message);
 }
 
 }  // namespace extensions