2 files changed, 43 insertions, 53 deletions

diff --git a/chrome/browser/sync/notifier/communicator/ssl_socket_adapter.cc b/chrome/browser/sync/notifier/communicator/ssl_socket_adapter.cc
index 28acf08..2b8b0cf 100755
--- a/chrome/browser/sync/notifier/communicator/ssl_socket_adapter.cc
+++ b/chrome/browser/sync/notifier/communicator/ssl_socket_adapter.cc
@@ -64,7 +64,7 @@ SSLSocketAdapter::SSLSocketAdapter(AsyncSocket* socket)
         io_callback_(this, &SSLSocketAdapter::OnIO)),
       ssl_connected_(false),
       state_(STATE_NONE) {
-  socket_.reset(new TransportSocket(socket, this));
+  socket_ = new TransportSocket(socket, this);
 }
 
 int SSLSocketAdapter::StartSSL(const char* hostname, bool restartable) {
@@ -77,7 +77,7 @@ int SSLSocketAdapter::StartSSL(const char* hostname, bool restartable) {
   socket_->set_addr(talk_base::SocketAddress(hostname));
   ssl_socket_.reset(
       net::ClientSocketFactory::GetDefaultFactory()->CreateSSLClientSocket(
-          socket_.release(), hostname, ssl_config));
+          socket_, hostname, ssl_config));
 
   int result = ssl_socket_->Connect(&connected_callback_);
 
@@ -91,38 +91,17 @@ int SSLSocketAdapter::StartSSL(const char* hostname, bool restartable) {
 int SSLSocketAdapter::Send(const void* buf, size_t len) {
   if (!ssl_connected_) {
     return AsyncSocketAdapter::Send(buf, len);
-  }
-
-  switch (state_) {
-    case STATE_NONE: {
-      transport_buf_ = new net::IOBuffer(len);
-      memcpy(transport_buf_->data(), buf, len);
-
-      int result = ssl_socket_->Write(transport_buf_, len, &io_callback_);
-      if (result == net::ERR_IO_PENDING) {
-        state_ = STATE_WRITE;
-        SetError(EWOULDBLOCK);
-      } else {
-        transport_buf_ = NULL;
-      }
-      return result;
-    }
-    case STATE_WRITE_COMPLETE:
-      transport_buf_ = NULL;
-      state_ = STATE_NONE;
-      return data_transferred_;
+  } else {
+    scoped_refptr<net::IOBuffer> transport_buf = new net::IOBuffer(len);
+    memcpy(transport_buf->data(), buf, len);
 
-    case STATE_READ:
-    case STATE_READ_COMPLETE:
-    case STATE_WRITE:
+    int result = ssl_socket_->Write(transport_buf, len, NULL);
+    if (result == net::ERR_IO_PENDING) {
       SetError(EWOULDBLOCK);
-      return -1;
-
-    default:
-      NOTREACHED();
-      break;
+    }
+    transport_buf = NULL;
+    return result;
   }
-  return -1;
 }
 
 int SSLSocketAdapter::Recv(void* buf, size_t len) {
@@ -142,6 +121,10 @@ int SSLSocketAdapter::Recv(void* buf, size_t len) {
         state_ = STATE_READ;
         SetError(EWOULDBLOCK);
       } else {
+        if (result < 0) {
+          SetError(result);
+          LOG(INFO) << "Socket error " << result;
+        }
         transport_buf_ = NULL;
       }
       return result;
@@ -177,10 +160,12 @@ void SSLSocketAdapter::OnIO(int result) {
     case STATE_READ:
       state_ = STATE_READ_COMPLETE;
       data_transferred_ = result;
+      AsyncSocketAdapter::OnReadEvent(this);
       break;
     case STATE_WRITE:
       state_ = STATE_WRITE_COMPLETE;
       data_transferred_ = result;
+      AsyncSocketAdapter::OnWriteEvent(this);
       break;
     case STATE_NONE:
     case STATE_READ_COMPLETE:
@@ -191,6 +176,16 @@ void SSLSocketAdapter::OnIO(int result) {
   }
 }
 
+void SSLSocketAdapter::OnReadEvent(talk_base::AsyncSocket* socket) {
+  if (!socket_->OnReadEvent(socket))
+    AsyncSocketAdapter::OnReadEvent(socket);
+}
+
+void SSLSocketAdapter::OnWriteEvent(talk_base::AsyncSocket* socket) {
+  if (!socket_->OnWriteEvent(socket))
+    AsyncSocketAdapter::OnWriteEvent(socket);
+}
+
 TransportSocket::TransportSocket(talk_base::AsyncSocket* socket,
                                  SSLSocketAdapter *ssl_adapter)
     : connect_callback_(NULL),
@@ -198,12 +193,8 @@ TransportSocket::TransportSocket(talk_base::AsyncSocket* socket,
       write_callback_(NULL),
       read_buffer_len_(0),
       write_buffer_len_(0),
-      socket_(socket),
-      ssl_adapter_(ssl_adapter) {
+      socket_(socket) {
     socket_->SignalConnectEvent.connect(this, &TransportSocket::OnConnectEvent);
-    socket_->SignalReadEvent.connect(this, &TransportSocket::OnReadEvent);
-    socket_->SignalWriteEvent.connect(this, &TransportSocket::OnWriteEvent);
-    socket_->SignalCloseEvent.connect(this, &TransportSocket::OnCloseEvent);
 }
 
 int TransportSocket::Connect(net::CompletionCallback* callback) {
@@ -282,12 +273,10 @@ void TransportSocket::OnConnectEvent(talk_base::AsyncSocket * socket) {
     net::CompletionCallback *callback = connect_callback_;
     connect_callback_ = NULL;
     callback->RunWithParams(Tuple1<int>(MapPosixError(socket_->GetError())));
-  } else {
-    ssl_adapter_->OnConnectEvent(socket);
   }
 }
 
-void TransportSocket::OnReadEvent(talk_base::AsyncSocket* socket) {
+bool TransportSocket::OnReadEvent(talk_base::AsyncSocket* socket) {
   if (read_callback_) {
     DCHECK(read_buffer_.get());
     net::CompletionCallback* callback = read_callback_;
@@ -305,16 +294,17 @@ void TransportSocket::OnReadEvent(talk_base::AsyncSocket* socket) {
         read_callback_ = callback;
         read_buffer_ = buffer;
         read_buffer_len_ = buffer_len;
-        return;
+        return true;
       }
     }
     callback->RunWithParams(Tuple1<int>(result));
+    return true;
   } else {
-    ssl_adapter_->OnReadEvent(socket);
+    return false;
   }
 }
 
-void TransportSocket::OnWriteEvent(talk_base::AsyncSocket* socket) {
+bool TransportSocket::OnWriteEvent(talk_base::AsyncSocket* socket) {
   if (write_callback_) {
     DCHECK(write_buffer_.get());
     net::CompletionCallback* callback = write_callback_;
@@ -332,17 +322,14 @@ void TransportSocket::OnWriteEvent(talk_base::AsyncSocket* socket) {
         write_callback_ = callback;
         write_buffer_ = buffer;
         write_buffer_len_ = buffer_len;
-        return;
+        return true;
       }
     }
     callback->RunWithParams(Tuple1<int>(result));
+    return true;
   } else {
-    ssl_adapter_->OnWriteEvent(socket);
+    return false;
   }
 }
 
-void TransportSocket::OnCloseEvent(talk_base::AsyncSocket* socket, int err) {
-  ssl_adapter_->OnCloseEvent(socket, err);
-}
-
 }  // namespace notifier
diff --git a/chrome/browser/sync/notifier/communicator/ssl_socket_adapter.h b/chrome/browser/sync/notifier/communicator/ssl_socket_adapter.h
index f121e1b..ab2fcf5 100755
--- a/chrome/browser/sync/notifier/communicator/ssl_socket_adapter.h
+++ b/chrome/browser/sync/notifier/communicator/ssl_socket_adapter.h
@@ -51,10 +51,11 @@ class TransportSocket : public net::ClientSocket, public sigslot::has_slots<> {
   virtual bool SetSendBufferSize(int32 size);
 
  private:
+  friend class SSLSocketAdapter;
+
   void OnConnectEvent(talk_base::AsyncSocket * socket);
-  void OnReadEvent(talk_base::AsyncSocket * socket);
-  void OnWriteEvent(talk_base::AsyncSocket * socket);
-  void OnCloseEvent(talk_base::AsyncSocket * socket, int err);
+  bool OnReadEvent(talk_base::AsyncSocket * socket);
+  bool OnWriteEvent(talk_base::AsyncSocket * socket);
 
   net::CompletionCallback* connect_callback_;
   net::CompletionCallback* read_callback_;
@@ -67,7 +68,6 @@ class TransportSocket : public net::ClientSocket, public sigslot::has_slots<> {
 
   talk_base::AsyncSocket *socket_;
   talk_base::SocketAddress addr_;
-  SSLSocketAdapter *ssl_adapter_;
 
   DISALLOW_COPY_AND_ASSIGN(TransportSocket);
 };
@@ -109,8 +109,11 @@ class SSLSocketAdapter : public talk_base::AsyncSocketAdapter {
   void OnConnected(int result);
   void OnIO(int result);
 
+  void OnReadEvent(talk_base::AsyncSocket * socket);
+  void OnWriteEvent(talk_base::AsyncSocket * socket);
+
   bool ignore_bad_cert_;
-  scoped_ptr<TransportSocket> socket_;
+  TransportSocket* socket_;
   scoped_ptr<net::SSLClientSocket> ssl_socket_;
   net::CompletionCallbackImpl<SSLSocketAdapter> connected_callback_;
   net::CompletionCallbackImpl<SSLSocketAdapter> io_callback_;