Close all writers before JingleSession is destroyed.

remoting/protocol/buffered_socket_writer.cc

 // Copyright (c) 2010 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 "remoting/protocol/buffered_socket_writer.h"
 
 #include "base/message_loop.h"
 #include "base/stl_util-inl.h"
 #include "net/base/net_errors.h"
 
@@ skipping 38 matching lines @@
                                     WriteFailedCallback* callback) {
   // TODO(garykac) Save copy of WriteFailedCallback.
   base::AutoLock auto_lock(lock_);
   message_loop_ = MessageLoop::current();
   socket_ = socket;
   DCHECK(socket_);
 }
 
 bool BufferedSocketWriterBase::Write(
     scoped_refptr<net::IOBufferWithSize> data, Task* done_task) {
-  base::AutoLock auto_lock(lock_);
-  if (!socket_)
-    return false;
-  queue_.push_back(new PendingPacket(data, done_task));
-  buffer_size_ += data->size();
+  {
+    base::AutoLock auto_lock(lock_);
+    queue_.push_back(new PendingPacket(data, done_task));
+    buffer_size_ += data->size();
+  }
   message_loop_->PostTask(
       FROM_HERE, NewRunnableMethod(this, &BufferedSocketWriterBase::DoWrite));
   return true;
 }
 
 void BufferedSocketWriterBase::DoWrite() {
   DCHECK_EQ(message_loop_, MessageLoop::current());
   DCHECK(socket_);
 
   // Don't try to write if there is another write pending.
   if (write_pending_)
     return;
 
   // Don't write after Close().
-  {
-    base::AutoLock auto_lock(lock_);
-    if (closed_)
-      return;
-  }
+  if (closed_)
+    return;
 
   while (true) {
     net::IOBuffer* current_packet;
     int current_packet_size;
     {
       base::AutoLock auto_lock(lock_);
       GetNextPacket_Locked(&current_packet, &current_packet_size);
     }
 
     // Return if the queue is empty.
@@ skipping 33 matching lines @@
     base::AutoLock auto_lock(lock_);
     AdvanceBufferPosition_Locked(result);
   }
 
   // Schedule next write.
   message_loop_->PostTask(
       FROM_HERE, NewRunnableMethod(this, &BufferedSocketWriterBase::DoWrite));
 }
 
 void BufferedSocketWriterBase::HandleError(int result) {
+  DCHECK_EQ(message_loop_, MessageLoop::current());
+
+  closed_ = true;
+
   base::AutoLock auto_lock(lock_);
-  closed_ = true;
   STLDeleteElements(&queue_);
 
   // Notify subclass that an error is received.
   OnError_Locked(result);
 }
 
 int BufferedSocketWriterBase::GetBufferSize() {
   base::AutoLock auto_lock(lock_);
   return buffer_size_;
 }
 
 int BufferedSocketWriterBase::GetBufferChunks() {
   base::AutoLock auto_lock(lock_);
   return queue_.size();
 }
 
 void BufferedSocketWriterBase::Close() {
-  base::AutoLock auto_lock(lock_);
+  DCHECK_EQ(message_loop_, MessageLoop::current());
   closed_ = true;
 }
 
 void BufferedSocketWriterBase::PopQueue() {
   // This also calls |done_task|.
   delete queue_.front();
   queue_.pop_front();
 }
 
 BufferedSocketWriter::BufferedSocketWriter() { }
@@ skipping 49 matching lines @@
   buffer_size_ -= queue_.front()->data()->size();
   PopQueue();
 }
 
 void BufferedDatagramWriter::OnError_Locked(int result) {
   // Nothing to do here.
 }
 
 }  // namespace protocol
 }  // namespace remoting