Migrate net/socket/socket.h, net/socket/stream_socket.h to base::Bind().

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"
@@ skipping 22 matching lines @@
  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_;
 
   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),
       src_extension_id_(src_extension_id),
       src_url_(src_url),
       udp_client_socket_(new UDPClientSocket(
           DatagramSocket::DEFAULT_BIND,
           RandIntCallback(),
           NULL,
           NetLog::Source())),
-      is_connected_(false),
-      ALLOW_THIS_IN_INITIALIZER_LIST(
-          io_callback_(this, &Socket::OnIOComplete)) {}
+      is_connected_(false) {}
 
 Socket::~Socket() {
   if (is_connected_) {
     Close();
   }
 }
 
 void Socket::OnIOComplete(int result) {
   // We don't need to do anything.
 }
 
 bool Socket::Connect(const net::IPEndPoint& ip_end_point) {
   is_connected_ = udp_client_socket_->Connect(ip_end_point) == net::OK;
   return is_connected_;
 }
 
 void Socket::Close() {
   is_connected_ = false;
   udp_client_socket_->Close();
 }
 
 int Socket::Write(const std::string message) {
   int length = message.length();
   scoped_refptr<StringIOBuffer> io_buffer(new StringIOBuffer(message));
   scoped_refptr<DrainableIOBuffer> buffer(
       new DrainableIOBuffer(io_buffer, length));
 
   int bytes_sent = 0;
   while (buffer->BytesRemaining()) {
-    int rv = udp_client_socket_->Write(buffer,
-                                       buffer->BytesRemaining(),
-                                       &io_callback_);
+    int rv = udp_client_socket_->Write(
+        buffer, buffer->BytesRemaining(),
+        base::Bind(&Socket::OnIOComplete, base::Unretained(this)));
     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;
 }
 
@@ skipping 63 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