Delete Session and SessionManager object synchronously.

jingle/glue/pseudotcp_adapter.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 "jingle/glue/pseudotcp_adapter.h"
 
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/time.h"
 #include "net/base/address_list.h"
@@ skipping 35 matching lines @@
   virtual void OnTcpClosed(cricket::PseudoTcp* tcp, uint32 error) OVERRIDE;
   // This is triggered by NotifyClock, NotifyPacket, Recv and Send.
   virtual WriteResult TcpWritePacket(cricket::PseudoTcp* tcp,
                                      const char* buffer, size_t len) OVERRIDE;
 
   void SetAckDelay(int delay_ms);
   void SetNoDelay(bool no_delay);
   void SetReceiveBufferSize(int32 size);
   void SetSendBufferSize(int32 size);
 
+  void DeleteSocket();
+
  private:
   // These are invoked by the underlying Socket, and may trigger callbacks.
   // They hold a reference to |this| while running, to protect from deletion.
   void OnRead(int result);
   void OnWritten(int result);
 
   // These may trigger callbacks, so the holder must hold a reference on
   // the stack while calling them.
   void DoReadFromSocket();
   void HandleReadResults(int result);
@@ skipping 209 matching lines @@
 }
 
 void PseudoTcpAdapter::Core::SetReceiveBufferSize(int32 size) {
   pseudo_tcp_.SetOption(cricket::PseudoTcp::OPT_RCVBUF, size);
 }
 
 void PseudoTcpAdapter::Core::SetSendBufferSize(int32 size) {
   pseudo_tcp_.SetOption(cricket::PseudoTcp::OPT_SNDBUF, size);
 }
 
+void PseudoTcpAdapter::Core::DeleteSocket() {
+  socket_.reset();
+}
+
 cricket::IPseudoTcpNotify::WriteResult PseudoTcpAdapter::Core::TcpWritePacket(
     PseudoTcp* tcp,
     const char* buffer,
     size_t len) {
   DCHECK_EQ(tcp, &pseudo_tcp_);
 
   // If we already have a write pending, we behave like a congested network,
   // returning success for the write, but dropping the packet.  PseudoTcp will
   // back-off and retransmit, adjusting for the perceived congestion.
   if (socket_write_pending_)
     return IPseudoTcpNotify::WR_SUCCESS;
 
   scoped_refptr<net::IOBuffer> write_buffer = new net::IOBuffer(len);
   memcpy(write_buffer->data(), buffer, len);
 
   // Our underlying socket is datagram-oriented, which means it should either
   // send exactly as many bytes as we requested, or fail.
-  int result = socket_->Write(write_buffer, len,
-                              base::Bind(&PseudoTcpAdapter::Core::OnWritten,
-                                         base::Unretained(this)));
+  int result;
+  if (socket_.get()) {
+    result = socket_->Write(write_buffer, len,
+                            base::Bind(&PseudoTcpAdapter::Core::OnWritten,
+                                       base::Unretained(this)));
+  } else {
+    result = net::ERR_CONNECTION_CLOSED;
+  }
   if (result == net::ERR_IO_PENDING) {
     socket_write_pending_ = true;
     return IPseudoTcpNotify::WR_SUCCESS;
   } if (result == net::ERR_MSG_TOO_BIG) {
     return IPseudoTcpNotify::WR_TOO_LARGE;
   } else if (result < 0) {
     return IPseudoTcpNotify::WR_FAIL;
   } else {
     return IPseudoTcpNotify::WR_SUCCESS;
   }
 }
 
 void PseudoTcpAdapter::Core::DoReadFromSocket() {
   if (!socket_read_buffer_)
     socket_read_buffer_ = new net::IOBuffer(kReadBufferSize);
 
-  while (true) {
-    int result = socket_->Read(socket_read_buffer_, kReadBufferSize,
-                               base::Bind(&PseudoTcpAdapter::Core::OnRead,
-                                          base::Unretained(this)));
-    if (result == net::ERR_IO_PENDING)
-      break;
-
-    HandleReadResults(result);
+  int result = 1;
+  while (socket_.get() && result > 0) {
+    result = socket_->Read(socket_read_buffer_, kReadBufferSize,
+                           base::Bind(&PseudoTcpAdapter::Core::OnRead,
+                                      base::Unretained(this)));
+    if (result != net::ERR_IO_PENDING)
+      HandleReadResults(result);
   }
 }
 
 void PseudoTcpAdapter::Core::HandleReadResults(int result) {
   if (result <= 0) {
     LOG(ERROR) << "Read returned " << result;
     return;
   }
 
   // TODO(wez): Disconnect on failure of NotifyPacket?
@@ skipping 39 matching lines @@
 }
 
 // Public interface implemention.
 
 PseudoTcpAdapter::PseudoTcpAdapter(net::Socket* socket)
     : core_(new Core(socket)) {
 }
 
 PseudoTcpAdapter::~PseudoTcpAdapter() {
   Disconnect();
+
+  // Make sure that the underlying socket is destroyed before PseudoTcp.
+  core_->DeleteSocket();
 }
 
 int PseudoTcpAdapter::Read(net::IOBuffer* buffer, int buffer_size,
                            const net::CompletionCallback& callback) {
   DCHECK(CalledOnValidThread());
   return core_->Read(buffer, buffer_size, callback);
 }
 
 int PseudoTcpAdapter::Write(net::IOBuffer* buffer, int buffer_size,
                             const net::CompletionCallback& callback) {
@@ skipping 96 matching lines @@
   DCHECK(CalledOnValidThread());
   core_->SetAckDelay(delay_ms);
 }
 
 void PseudoTcpAdapter::SetNoDelay(bool no_delay) {
   DCHECK(CalledOnValidThread());
   core_->SetNoDelay(no_delay);
 }
 
 }  // namespace jingle_glue