Revert 113699 - base::Bind: Convert Socket::Write.

BUG=none
TEST=none
R=csilv

Review URL: http://codereview.chromium.org/8831001

TBR=jhawkins@chromium.org
Review URL: http://codereview.chromium.org/8889036

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@113719 0039d316-1c4b-4281-b951-d872f2087c98

6 files changed, 15 insertions, 91 deletions

diff --git a/remoting/jingle_glue/ssl_socket_adapter.cc b/remoting/jingle_glue/ssl_socket_adapter.cc
index 3df508e..7414c4b 100644
--- a/remoting/jingle_glue/ssl_socket_adapter.cc
+++ b/remoting/jingle_glue/ssl_socket_adapter.cc
@@ -188,7 +188,7 @@ void SSLSocketAdapter::OnConnectEvent(talk_base::AsyncSocket* socket) {
 TransportSocket::TransportSocket(talk_base::AsyncSocket* socket,
                                  SSLSocketAdapter *ssl_adapter)
     : old_read_callback_(NULL),
-      old_write_callback_(NULL),
+      write_callback_(NULL),
       read_buffer_len_(0),
       write_buffer_len_(0),
       socket_(socket),
@@ -327,25 +327,7 @@ int TransportSocket::Read(net::IOBuffer* buf, int buf_len,
 int TransportSocket::Write(net::IOBuffer* buf, int buf_len,
                            net::OldCompletionCallback* callback) {
   DCHECK(buf);
-  DCHECK(!old_write_callback_ && write_callback_.is_null());
-  DCHECK(!write_buffer_.get());
-  int result = socket_->Send(buf->data(), buf_len);
-  if (result < 0) {
-    result = net::MapSystemError(socket_->GetError());
-    if (result == net::ERR_IO_PENDING) {
-      old_write_callback_ = callback;
-      write_buffer_ = buf;
-      write_buffer_len_ = buf_len;
-    }
-  }
-  if (result != net::ERR_IO_PENDING)
-    was_used_to_convey_data_ = true;
-  return result;
-}
-int TransportSocket::Write(net::IOBuffer* buf, int buf_len,
-                           const net::CompletionCallback& callback) {
-  DCHECK(buf);
-  DCHECK(!old_write_callback_ && write_callback_.is_null());
+  DCHECK(!write_callback_);
   DCHECK(!write_buffer_.get());
   int result = socket_->Send(buf->data(), buf_len);
   if (result < 0) {
@@ -404,15 +386,13 @@ void TransportSocket::OnReadEvent(talk_base::AsyncSocket* socket) {
 }
 
 void TransportSocket::OnWriteEvent(talk_base::AsyncSocket* socket) {
-  if (old_write_callback_ || !write_callback_.is_null()) {
+  if (write_callback_) {
     DCHECK(write_buffer_.get());
-    net::OldCompletionCallback* old_callback = old_write_callback_;
-    net::CompletionCallback callback = write_callback_;
+    net::OldCompletionCallback* callback = write_callback_;
     scoped_refptr<net::IOBuffer> buffer = write_buffer_;
     int buffer_len = write_buffer_len_;
 
-    old_write_callback_ = NULL;
-    write_callback_.Reset();
+    write_callback_ = NULL;
     write_buffer_ = NULL;
     write_buffer_len_ = 0;
 
@@ -420,7 +400,6 @@ void TransportSocket::OnWriteEvent(talk_base::AsyncSocket* socket) {
     if (result < 0) {
       result = net::MapSystemError(socket_->GetError());
       if (result == net::ERR_IO_PENDING) {
-        old_write_callback_ = old_callback;
         write_callback_ = callback;
         write_buffer_ = buffer;
         write_buffer_len_ = buffer_len;
@@ -428,10 +407,7 @@ void TransportSocket::OnWriteEvent(talk_base::AsyncSocket* socket) {
       }
     }
     was_used_to_convey_data_ = true;
-    if (old_callback)
-      old_callback->RunWithParams(Tuple1<int>(result));
-    else
-      callback.Run(result);
+    callback->RunWithParams(Tuple1<int>(result));
   }
 }
 
diff --git a/remoting/jingle_glue/ssl_socket_adapter.h b/remoting/jingle_glue/ssl_socket_adapter.h
index 3638ae1..f929bf8 100644
--- a/remoting/jingle_glue/ssl_socket_adapter.h
+++ b/remoting/jingle_glue/ssl_socket_adapter.h
@@ -62,8 +62,6 @@ class TransportSocket : public net::StreamSocket, public sigslot::has_slots<> {
                    const net::CompletionCallback& callback) OVERRIDE;
   virtual int Write(net::IOBuffer* buf, int buf_len,
                     net::OldCompletionCallback* callback) OVERRIDE;
-  virtual int Write(net::IOBuffer* buf, int buf_len,
-                    const net::CompletionCallback& callback) OVERRIDE;
   virtual bool SetReceiveBufferSize(int32 size) OVERRIDE;
   virtual bool SetSendBufferSize(int32 size) OVERRIDE;
 
@@ -75,8 +73,7 @@ class TransportSocket : public net::StreamSocket, public sigslot::has_slots<> {
 
   net::OldCompletionCallback* old_read_callback_;
   net::CompletionCallback read_callback_;
-  net::OldCompletionCallback* old_write_callback_;
-  net::CompletionCallback write_callback_;
+  net::OldCompletionCallback* write_callback_;
 
   scoped_refptr<net::IOBuffer> read_buffer_;
   int read_buffer_len_;
diff --git a/remoting/protocol/fake_session.cc b/remoting/protocol/fake_session.cc
index 18071fd..f1a890a 100644
--- a/remoting/protocol/fake_session.cc
+++ b/remoting/protocol/fake_session.cc
@@ -86,13 +86,6 @@ int FakeSocket::Write(net::IOBuffer* buf, int buf_len,
                        buf->data(), buf->data() + buf_len);
   return buf_len;
 }
-int FakeSocket::Write(net::IOBuffer* buf, int buf_len,
-                      const net::CompletionCallback& callback) {
-  EXPECT_EQ(message_loop_, MessageLoop::current());
-  written_data_.insert(written_data_.end(),
-                       buf->data(), buf->data() + buf_len);
-  return buf_len;
-}
 
 bool FakeSocket::SetReceiveBufferSize(int32 size) {
   NOTIMPLEMENTED();
@@ -243,13 +236,6 @@ int FakeUdpSocket::Write(net::IOBuffer* buf, int buf_len,
   written_packets_.back().assign(buf->data(), buf->data() + buf_len);
   return buf_len;
 }
-int FakeUdpSocket::Write(net::IOBuffer* buf, int buf_len,
-                         const net::CompletionCallback& callback) {
-  EXPECT_EQ(message_loop_, MessageLoop::current());
-  written_packets_.push_back(std::string());
-  written_packets_.back().assign(buf->data(), buf->data() + buf_len);
-  return buf_len;
-}
 
 bool FakeUdpSocket::SetReceiveBufferSize(int32 size) {
   NOTIMPLEMENTED();
diff --git a/remoting/protocol/fake_session.h b/remoting/protocol/fake_session.h
index c98d888..a8239f5 100644
--- a/remoting/protocol/fake_session.h
+++ b/remoting/protocol/fake_session.h
@@ -45,8 +45,6 @@ class FakeSocket : public net::StreamSocket {
                    const net::CompletionCallback& callback) OVERRIDE;
   virtual int Write(net::IOBuffer* buf, int buf_len,
                     net::OldCompletionCallback* callback) OVERRIDE;
-  virtual int Write(net::IOBuffer* buf, int buf_len,
-                    const net::CompletionCallback& callback) OVERRIDE;
 
   virtual bool SetReceiveBufferSize(int32 size) OVERRIDE;
   virtual bool SetSendBufferSize(int32 size) OVERRIDE;
@@ -107,8 +105,6 @@ class FakeUdpSocket : public net::Socket {
                    const net::CompletionCallback& callback) OVERRIDE;
   virtual int Write(net::IOBuffer* buf, int buf_len,
                     net::OldCompletionCallback* callback) OVERRIDE;
-  virtual int Write(net::IOBuffer* buf, int buf_len,
-                    const net::CompletionCallback& callback) OVERRIDE;
 
   virtual bool SetReceiveBufferSize(int32 size) OVERRIDE;
   virtual bool SetSendBufferSize(int32 size) OVERRIDE;
diff --git a/remoting/protocol/pepper_transport_socket_adapter.cc b/remoting/protocol/pepper_transport_socket_adapter.cc
index 4876088..0385b9b 100644
--- a/remoting/protocol/pepper_transport_socket_adapter.cc
+++ b/remoting/protocol/pepper_transport_socket_adapter.cc
@@ -50,7 +50,7 @@ PepperTransportSocketAdapter::PepperTransportSocketAdapter(
       connected_(false),
       get_address_pending_(false),
       old_read_callback_(NULL),
-      old_write_callback_(NULL) {
+      write_callback_(NULL) {
   callback_factory_.Initialize(this);
 }
 
@@ -112,28 +112,7 @@ int PepperTransportSocketAdapter::Read(
 int PepperTransportSocketAdapter::Write(net::IOBuffer* buf, int buf_len,
                                         net::OldCompletionCallback* callback) {
   DCHECK(CalledOnValidThread());
-  DCHECK(!old_write_callback_ && write_callback_.is_null());
-  DCHECK(!write_buffer_);
-
-  if (!transport_.get())
-    return net::ERR_SOCKET_NOT_CONNECTED;
-
-  int result = PPErrorToNetError(transport_->Send(
-      buf->data(), buf_len,
-      callback_factory_.NewOptionalCallback(
-          &PepperTransportSocketAdapter::OnWrite)));
-
-  if (result == net::ERR_IO_PENDING) {
-    old_write_callback_ = callback;
-    write_buffer_ = buf;
-  }
-
-  return result;
-}
-int PepperTransportSocketAdapter::Write(
-    net::IOBuffer* buf, int buf_len, const net::CompletionCallback& callback) {
-  DCHECK(CalledOnValidThread());
-  DCHECK(!old_write_callback_ && write_callback_.is_null());
+  DCHECK(!write_callback_);
   DCHECK(!write_buffer_);
 
   if (!transport_.get())
@@ -357,20 +336,13 @@ void PepperTransportSocketAdapter::OnRead(int32_t result) {
 
 void PepperTransportSocketAdapter::OnWrite(int32_t result) {
   DCHECK(CalledOnValidThread());
-  DCHECK(old_write_callback_ || !write_callback_.is_null());
+  DCHECK(write_callback_);
   DCHECK(write_buffer_);
 
-  if (old_write_callback_) {
-    net::OldCompletionCallback* callback = old_write_callback_;
-    old_write_callback_ = NULL;
-    write_buffer_ = NULL;
-    callback->Run(PPErrorToNetError(result));
-  } else {
-    net::CompletionCallback callback = write_callback_;
-    write_callback_.Reset();
-    write_buffer_ = NULL;
-    callback.Run(PPErrorToNetError(result));
-  }
+  net::OldCompletionCallback* callback = write_callback_;
+  write_callback_ = NULL;
+  write_buffer_ = NULL;
+  callback->Run(PPErrorToNetError(result));
 }
 
 }  // namespace protocol
diff --git a/remoting/protocol/pepper_transport_socket_adapter.h b/remoting/protocol/pepper_transport_socket_adapter.h
index 8453fc4..40b75ce 100644
--- a/remoting/protocol/pepper_transport_socket_adapter.h
+++ b/remoting/protocol/pepper_transport_socket_adapter.h
@@ -55,8 +55,6 @@ class PepperTransportSocketAdapter : public base::NonThreadSafe,
                    const net::CompletionCallback& callback) OVERRIDE;
   virtual int Write(net::IOBuffer* buf, int buf_len,
                     net::OldCompletionCallback* callback) OVERRIDE;
-  virtual int Write(net::IOBuffer* buf, int buf_len,
-                    const net::CompletionCallback& callback) OVERRIDE;
   virtual bool SetReceiveBufferSize(int32 size) OVERRIDE;
   virtual bool SetSendBufferSize(int32 size) OVERRIDE;
 
@@ -100,8 +98,7 @@ class PepperTransportSocketAdapter : public base::NonThreadSafe,
   net::CompletionCallback read_callback_;
   scoped_refptr<net::IOBuffer> read_buffer_;
 
-  net::OldCompletionCallback* old_write_callback_;
-  net::CompletionCallback write_callback_;
+  net::OldCompletionCallback* write_callback_;
   scoped_refptr<net::IOBuffer> write_buffer_;
 
   net::BoundNetLog net_log_;