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

net/socket/web_socket_server_socket.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 "net/socket/web_socket_server_socket.h"
 
 #include <algorithm>
 #include <deque>
 #include <limits>
 #include <map>
@@ skipping 100 matching lines @@
   WebSocketServerSocketImpl(net::Socket* transport_socket, Delegate* delegate)
       : phase_(PHASE_NYMPH),
         frame_bytes_remaining_(0),
         transport_socket_(transport_socket),
         delegate_(delegate),
         handshake_buf_(new net::IOBuffer(kHandshakeLimitBytes)),
         fill_handshake_buf_(new net::DrainableIOBuffer(
             handshake_buf_, kHandshakeLimitBytes)),
         process_handshake_buf_(new net::DrainableIOBuffer(
             handshake_buf_, kHandshakeLimitBytes)),
-        transport_read_callback_(NewCallback(
-            this, &WebSocketServerSocketImpl::OnRead)),
-        transport_write_callback_(NewCallback(
-            this, &WebSocketServerSocketImpl::OnWrite)),
         is_transport_read_pending_(false),
         is_transport_write_pending_(false),
         method_factory_(this) {
     DCHECK(transport_socket);
     DCHECK(delegate);
   }
 
   virtual ~WebSocketServerSocketImpl() {
     std::deque<PendingReq>::iterator it = GetPendingReq(PendingReq::TYPE_READ);
     if (it != pending_reqs_.end() &&
         it->type == PendingReq::TYPE_READ &&
         it->io_buf != NULL &&
         it->io_buf->data() != NULL &&
-        (it->old_callback || !it->callback.is_null())) {
-      if (it->old_callback)
-        it->old_callback->Run(0);  // Report EOF.
-      else
-        it->callback.Run(0);
+        !it->callback.is_null()) {
+      it->callback.Run(0);  // Report EOF.
     }
   }
 
  private:
   enum Phase {
     // Before Accept() is called.
     PHASE_NYMPH,
 
     // After Accept() is called and until handshake success/fail.
     PHASE_HANDSHAKE,
@@ skipping 15 matching lines @@
       // Read request.
       TYPE_READ           = 1 << 1,
       // Write request.
       TYPE_WRITE          = 1 << 2,
 
       TYPE_READ_METADATA  = TYPE_READ | TYPE_METADATA,
       TYPE_WRITE_METADATA = TYPE_WRITE | TYPE_METADATA
     };
 
     PendingReq(Type type, net::DrainableIOBuffer* io_buf,
-               net::OldCompletionCallback* callback)
-        : type(type),
-          io_buf(io_buf),
-          old_callback(callback) {
-      switch (type) {
-        case PendingReq::TYPE_READ:
-        case PendingReq::TYPE_WRITE:
-        case PendingReq::TYPE_READ_METADATA:
-        case PendingReq::TYPE_WRITE_METADATA: {
-          DCHECK(io_buf);
-          break;
-        }
-        default: {
-          NOTREACHED();
-          break;
-        }
-      }
-    }
-    PendingReq(Type type, net::DrainableIOBuffer* io_buf,
                const net::CompletionCallback& callback)
         : type(type),
           io_buf(io_buf),
-          old_callback(NULL),
           callback(callback) {
       switch (type) {
         case PendingReq::TYPE_READ:
         case PendingReq::TYPE_WRITE:
         case PendingReq::TYPE_READ_METADATA:
         case PendingReq::TYPE_WRITE_METADATA: {
           DCHECK(io_buf);
           break;
         }
         default: {
           NOTREACHED();
           break;
         }
       }
     }
 
     Type type;
     scoped_refptr<net::DrainableIOBuffer> io_buf;
-    net::OldCompletionCallback* old_callback;
     net::CompletionCallback callback;
   };
 
   // Socket implementation.
   virtual int Read(net::IOBuffer* buf, int buf_len,
-                   net::OldCompletionCallback* callback) OVERRIDE {
-    if (buf_len == 0)
-      return 0;
-    if (buf == NULL || buf_len < 0) {
-      NOTREACHED();
-      return net::ERR_INVALID_ARGUMENT;
-    }
-    while (int bytes_remaining = fill_handshake_buf_->BytesConsumed() -
-        process_handshake_buf_->BytesConsumed()) {
-      DCHECK(!is_transport_read_pending_);
-      DCHECK(GetPendingReq(PendingReq::TYPE_READ) == pending_reqs_.end());
-      switch (phase_) {
-        case PHASE_FRAME_OUTSIDE:
-        case PHASE_FRAME_INSIDE:
-        case PHASE_FRAME_LENGTH:
-        case PHASE_FRAME_SKIP: {
-          int n = std::min(bytes_remaining, buf_len);
-          int rv = ProcessDataFrames(
-              process_handshake_buf_->data(), n, buf->data(), buf_len);
-          process_handshake_buf_->DidConsume(n);
-          if (rv == 0) {
-            // ProcessDataFrames may return zero for non-empty buffer if it
-            // contains only frame delimiters without real data.  In this case:
-            // try again and do not just return zero (zero stands for EOF).
-            continue;
-          }
-          return rv;
-        }
-        case PHASE_SHUT: {
-          return 0;
-        }
-        case PHASE_NYMPH:
-        case PHASE_HANDSHAKE:
-        default: {
-          NOTREACHED();
-          return net::ERR_UNEXPECTED;
-        }
-      }
-    }
-    switch (phase_) {
-      case PHASE_FRAME_OUTSIDE:
-      case PHASE_FRAME_INSIDE:
-      case PHASE_FRAME_LENGTH:
-      case PHASE_FRAME_SKIP: {
-        pending_reqs_.push_back(PendingReq(
-            PendingReq::TYPE_READ,
-            new net::DrainableIOBuffer(buf, buf_len),
-            callback));
-        ConsiderTransportRead();
-        break;
-      }
-      case PHASE_SHUT: {
-        return 0;
-      }
-      case PHASE_NYMPH:
-      case PHASE_HANDSHAKE:
-      default: {
-        NOTREACHED();
-        return net::ERR_UNEXPECTED;
-      }
-    }
-    return net::ERR_IO_PENDING;
-  }
-  virtual int Read(net::IOBuffer* buf, int buf_len,
                    const net::CompletionCallback& callback) OVERRIDE {
     if (buf_len == 0)
       return 0;
     if (buf == NULL || buf_len < 0) {
       NOTREACHED();
       return net::ERR_INVALID_ARGUMENT;
     }
     while (int bytes_remaining = fill_handshake_buf_->BytesConsumed() -
         process_handshake_buf_->BytesConsumed()) {
       DCHECK(!is_transport_read_pending_);
@@ skipping 45 matching lines @@
       case PHASE_HANDSHAKE:
       default: {
         NOTREACHED();
         return net::ERR_UNEXPECTED;
       }
     }
     return net::ERR_IO_PENDING;
   }
 
   virtual int Write(net::IOBuffer* buf, int buf_len,
-                    net::OldCompletionCallback* callback) OVERRIDE {
+                    const net::CompletionCallback& callback) OVERRIDE {
     if (buf_len == 0)
       return 0;
     if (buf == NULL || buf_len < 0) {
       NOTREACHED();
       return net::ERR_INVALID_ARGUMENT;
     }
     DCHECK_EQ(std::find(buf->data(), buf->data() + buf_len, '\xff'),
               buf->data() + buf_len);
     switch (phase_) {
       case PHASE_FRAME_OUTSIDE:
@@ skipping 10 matching lines @@
       default: {
         NOTREACHED();
         return net::ERR_UNEXPECTED;
       }
     }
 
     net::IOBuffer* frame_start = new net::IOBuffer(1);
     frame_start->data()[0] = '\x00';
     pending_reqs_.push_back(PendingReq(PendingReq::TYPE_WRITE_METADATA,
                             new net::DrainableIOBuffer(frame_start, 1),
-                            NULL));
+                            net::CompletionCallback()));
 
     pending_reqs_.push_back(PendingReq(PendingReq::TYPE_WRITE,
                             new net::DrainableIOBuffer(buf, buf_len),
                             callback));
 
     net::IOBuffer* frame_end = new net::IOBuffer(1);
     frame_end->data()[0] = '\xff';
     pending_reqs_.push_back(PendingReq(PendingReq::TYPE_WRITE_METADATA,
                             new net::DrainableIOBuffer(frame_end, 1),
-                            NULL));
+                            net::CompletionCallback()));
 
     ConsiderTransportWrite();
     return net::ERR_IO_PENDING;
   }
 
   virtual bool SetReceiveBufferSize(int32 size) OVERRIDE {
     return transport_socket_->SetReceiveBufferSize(size);
   }
 
   virtual bool SetSendBufferSize(int32 size) OVERRIDE {
     return transport_socket_->SetSendBufferSize(size);
   }
 
   // WebSocketServerSocket implementation.
   virtual int Accept(net::OldCompletionCallback* callback) {
     if (phase_ != PHASE_NYMPH)
       return net::ERR_UNEXPECTED;
     phase_ = PHASE_HANDSHAKE;
+    net::CompletionCallback cb;
+    if (callback) {
+      cb = base::Bind(&net::OldCompletionCallback::Run<int>,
+                      base::Unretained(callback));
+    }
     pending_reqs_.push_front(PendingReq(
-        PendingReq::TYPE_READ_METADATA, fill_handshake_buf_.get(), callback));
+        PendingReq::TYPE_READ_METADATA, fill_handshake_buf_.get(),
+        cb));
     ConsiderTransportRead();
     return net::ERR_IO_PENDING;
   }
 
   std::deque<PendingReq>::iterator GetPendingReq(PendingReq::Type type) {
     for (std::deque<PendingReq>::iterator it = pending_reqs_.begin();
          it != pending_reqs_.end(); ++it) {
       if (it->type & type)
         return it;
     }
     return pending_reqs_.end();
   }
 
   void ConsiderTransportRead() {
     if (pending_reqs_.empty())
       return;
     if (is_transport_read_pending_)
       return;
     std::deque<PendingReq>::iterator it = GetPendingReq(PendingReq::TYPE_READ);
     if (it == pending_reqs_.end())
       return;
     if (it->io_buf == NULL || it->io_buf->BytesRemaining() == 0) {
       NOTREACHED();
       return;
     }
     is_transport_read_pending_ = true;
     int rv = transport_socket_->Read(
         it->io_buf.get(), it->io_buf->BytesRemaining(),
-        transport_read_callback_.get());
+        base::Bind(&WebSocketServerSocketImpl::OnRead,
+                   base::Unretained(this)));
     if (rv != net::ERR_IO_PENDING) {
       // PostTask rather than direct call in order to:
       // (1) guarantee calling callback after returning from Read();
       // (2) avoid potential stack overflow;
       MessageLoop::current()->PostTask(FROM_HERE,
           method_factory_.NewRunnableMethod(
               &WebSocketServerSocketImpl::OnRead, rv));
     }
   }
 
   void ConsiderTransportWrite() {
     if (is_transport_write_pending_)
       return;
     if (pending_reqs_.empty())
       return;
     std::deque<PendingReq>::iterator it = GetPendingReq(PendingReq::TYPE_WRITE);
     if (it == pending_reqs_.end())
       return;
     if (it->io_buf == NULL || it->io_buf->BytesRemaining() == 0) {
       NOTREACHED();
       Shut(net::ERR_UNEXPECTED);
       return;
     }
     is_transport_write_pending_ = true;
     int rv = transport_socket_->Write(
         it->io_buf.get(), it->io_buf->BytesRemaining(),
-        transport_write_callback_.get());
+        base::Bind(&WebSocketServerSocketImpl::OnWrite,
+                   base::Unretained(this)));
     if (rv != net::ERR_IO_PENDING) {
       // PostTask rather than direct call in order to:
       // (1) guarantee calling callback after returning from Read();
       // (2) avoid potential stack overflow;
       MessageLoop::current()->PostTask(FROM_HERE,
           method_factory_.NewRunnableMethod(
               &WebSocketServerSocketImpl::OnWrite, rv));
     }
   }
 
   void Shut(int result) {
     if (result > 0 || result == net::ERR_IO_PENDING)
       result = net::ERR_UNEXPECTED;
     if (result != 0) {
       while (!pending_reqs_.empty()) {
         PendingReq& req = pending_reqs_.front();
-        if (req.old_callback)
-          req.old_callback->Run(result);
-        else if (!req.callback.is_null())
+        if (!req.callback.is_null())
           req.callback.Run(result);
         pending_reqs_.pop_front();
       }
       transport_socket_.reset();  // terminate underlying connection.
     }
     phase_ = PHASE_SHUT;
   }
 
   // Callbacks for transport socket.
   void OnRead(int result) {
@@ skipping 29 matching lines @@
           NOTREACHED();
           Shut(net::ERR_UNEXPECTED);
           return;
         }
         fill_handshake_buf_->DidConsume(result);
         // ProcessHandshake invalidates iterators for |pending_reqs_|
         int rv = ProcessHandshake();
         if (rv > 0) {
           process_handshake_buf_->DidConsume(rv);
           phase_ = PHASE_FRAME_OUTSIDE;
-          net::OldCompletionCallback* old_cb =
-              pending_reqs_.front().old_callback;
           net::CompletionCallback cb = pending_reqs_.front().callback;
           pending_reqs_.pop_front();
           ConsiderTransportWrite();  // Schedule answer handshake.
-          if (old_cb)
-            old_cb->Run(0);
-          else if (!cb.is_null())
+          if (!cb.is_null())
             cb.Run(0);
         } else if (rv == net::ERR_IO_PENDING) {
           if (fill_handshake_buf_->BytesRemaining() < 1)
             Shut(net::ERR_LIMIT_VIOLATION);
         } else if (rv < 0) {
           Shut(rv);
         } else {
           Shut(net::ERR_UNEXPECTED);
         }
         break;
       }
       case PHASE_FRAME_OUTSIDE:
       case PHASE_FRAME_INSIDE:
       case PHASE_FRAME_LENGTH:
       case PHASE_FRAME_SKIP: {
         int rv = ProcessDataFrames(
             it->io_buf->data(), result,
             it->io_buf->data(), it->io_buf->BytesRemaining());
         if (rv < 0) {
           Shut(rv);
           return;
         }
         if (rv > 0 || phase_ == PHASE_SHUT) {
-          net::OldCompletionCallback* old_cb = it->old_callback;
           net::CompletionCallback cb = it->callback;
           pending_reqs_.erase(it);
-          if (old_cb)
-            old_cb->Run(rv);
-          else if (!cb.is_null())
+          if (!cb.is_null())
             cb.Run(rv);
         }
         break;
       }
       case PHASE_NYMPH:
       default: {
         NOTREACHED();
         Shut(net::ERR_UNEXPECTED);
         break;
       }
@@ skipping 18 matching lines @@
     if (it == pending_reqs_.end() ||
         it->io_buf == NULL ||
         it->io_buf->data() == NULL) {
       NOTREACHED();
       Shut(net::ERR_UNEXPECTED);
       return;
     }
     DCHECK_LE(result, it->io_buf->BytesRemaining());
     it->io_buf->DidConsume(result);
     if (it->io_buf->BytesRemaining() == 0) {
-      net::OldCompletionCallback* old_cb = it->old_callback;
       net::CompletionCallback cb = it->callback;
       int bytes_written = it->io_buf->BytesConsumed();
       DCHECK_GT(bytes_written, 0);
       pending_reqs_.erase(it);
-      if (old_cb)
-        old_cb->Run(bytes_written);
-      else if (!cb.is_null())
+      if (!cb.is_null())
         cb.Run(bytes_written);
     }
     ConsiderTransportWrite();
   }
 
   // Returns (positive) number of consumed bytes on success.
   // Returns ERR_IO_PENDING in case of incomplete input.
   // Returns ERR_WS_PROTOCOL_ERROR or ERR_LIMIT_VIOLATION in case of failure to
   // reasonably parse input.
   int ProcessHandshake() {
@@ skipping 245 matching lines @@
         return net::ERR_LIMIT_VIOLATION;
       buffer.WriteLine(tmp);
     }
     buffer.WriteLine("");
     buffer.Write(&challenge_response, sizeof(challenge_response));
 
     if (!buffer.is_ok())
       return net::ERR_LIMIT_VIOLATION;
 
     pending_reqs_.push_back(PendingReq(
-        PendingReq::TYPE_WRITE_METADATA, buffer, NULL));
+        PendingReq::TYPE_WRITE_METADATA, buffer, net::CompletionCallback()));
     DCHECK_GT(term_pos - buf, 0);
     return term_pos - buf;
   }
 
   // Removes frame delimiters and returns net number of data bytes (or error).
   // |out| may be equal to |buf|, in that case it is in-place operation.
   int ProcessDataFrames(char* buf, int buf_len, char* out, int out_len) {
     if (out_len < buf_len) {
       NOTREACHED();
       return net::ERR_UNEXPECTED;
@@ skipping 71 matching lines @@
   Delegate* delegate_;
 
   // IOBuffer used to communicate with transport at initial stage.
   scoped_refptr<net::IOBuffer> handshake_buf_;
   scoped_refptr<net::DrainableIOBuffer> fill_handshake_buf_;
   scoped_refptr<net::DrainableIOBuffer> process_handshake_buf_;
 
   // Pending io requests we need to complete.
   std::deque<PendingReq> pending_reqs_;
 
-  // Callbacks from transport to us.
-  scoped_ptr<net::OldCompletionCallback> transport_read_callback_;
-  scoped_ptr<net::OldCompletionCallback> transport_write_callback_;
-
   // Whether transport requests are pending.
   bool is_transport_read_pending_;
   bool is_transport_write_pending_;
 
   ScopedRunnableMethodFactory<WebSocketServerSocketImpl> method_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(WebSocketServerSocketImpl);
 };
 
 }  // namespace
 
 namespace net {
 
 WebSocketServerSocket* CreateWebSocketServerSocket(
     Socket* transport_socket, WebSocketServerSocket::Delegate* delegate) {
   return new WebSocketServerSocketImpl(transport_socket, delegate);
 }
 
 WebSocketServerSocket::~WebSocketServerSocket() {
 }
 
 }  // namespace net;