Jingle_glue bugfixes.

remoting/jingle_glue/jingle_channel.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/jingle_glue/jingle_channel.h"
 
 #include "base/lock.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/waitable_event.h"
 #include "media/base/data_buffer.h"
 #include "remoting/jingle_glue/jingle_thread.h"
 #include "third_party/libjingle/source/talk/base/stream.h"
 
 using media::DataBuffer;
 
 namespace remoting {
 
 // Size of a read buffer chunk in bytes.
 const size_t kReadBufferSize = 4096;
 
 JingleChannel::JingleChannel(Callback* callback)
     : state_(INITIALIZING),
       callback_(callback),
+      closed_(false),
       event_handler_(this),
       write_buffer_size_(0),
       current_write_buf_pos_(0) {
   DCHECK(callback_ != NULL);
 }
 
 // This constructor is only used in unit test.
 JingleChannel::JingleChannel()
     : state_(CLOSED),
+      closed_(false),
       write_buffer_size_(0),
       current_write_buf_pos_(0) {
 }
 
 JingleChannel::~JingleChannel() {
-  DCHECK_EQ(CLOSED, state_);
+  DCHECK(closed_ || stream_ == NULL);
 }
 
 void JingleChannel::Init(JingleThread* thread,
                          talk_base::StreamInterface* stream,
                          const std::string& jid) {
   thread_ = thread;
   stream_.reset(stream);
   stream_->SignalEvent.connect(&event_handler_, &EventHandler::OnStreamEvent);
   jid_ = jid;
 
@@ skipping 44 matching lines @@
     scoped_refptr<DataBuffer> buffer(
         new DataBuffer(new uint8[bytes_to_read], kReadBufferSize));
     size_t bytes_read;
     int error;
     talk_base::StreamResult result = stream_->Read(
         buffer->GetWritableData(), bytes_to_read, &bytes_read, &error);
     switch (result) {
       case talk_base::SR_SUCCESS: {
         DCHECK_GT(bytes_read, 0U);
         buffer->SetDataSize(bytes_read);
-        callback_->OnPacketReceived(this, buffer);
+        {
+          AutoLock auto_lock(state_lock_);
+          // Drop received data if the channel is already closed.
+          if (!closed_)
+            callback_->OnPacketReceived(this, buffer);
+        }
         break;
       }
       case talk_base::SR_BLOCK: {
         return;
       }
       case talk_base::SR_EOS: {
         SetState(CLOSED);
         return;
       }
       case talk_base::SR_ERROR: {
@@ skipping 55 matching lines @@
   if (state_ == OPEN && (events & talk_base::SE_WRITE))
     DoWrite();
 
   if (state_ == OPEN && (events & talk_base::SE_READ))
     DoRead();
 
   if (events & talk_base::SE_CLOSE)
     SetState(CLOSED);
 }
 
-void JingleChannel::SetState(State state) {
-  if (state == state_)
-    return;
-  state_ = state;
-  callback_->OnStateChange(this, state);
+void JingleChannel::SetState(State new_state) {
+  if (new_state != state_) {
+    state_ = new_state;
+    {
+      AutoLock auto_lock(state_lock_);
+      if (!closed_)
+        callback_->OnStateChange(this, new_state);
+    }
+  }
 }
 
 void JingleChannel::Close() {
-  base::WaitableEvent event(true, false);
-  thread_->message_loop()->PostTask(
-      FROM_HERE, NewRunnableMethod(this, &JingleChannel::DoClose, &event));
-  event.Wait();
+  Close(NULL);
 }
 
-void JingleChannel::DoClose(base::WaitableEvent* done_event) {
-  if (stream_.get())
-    stream_->Close();
-  SetState(CLOSED);
-  done_event->Signal();
+void JingleChannel::Close(Task* closed_task) {
+  {
+    AutoLock auto_lock(state_lock_);
+    if (closed_) {
+      // We are already closed.
+      if (closed_task)
+        thread_->message_loop()->PostTask(FROM_HERE, closed_task);
+      return;
+    }
+    closed_ = true;
+    if (closed_task)
+      closed_task_.reset(closed_task);
+  }
+
+  thread_->message_loop()->PostTask(
+      FROM_HERE, NewRunnableMethod(this, &JingleChannel::DoClose));
+}
+
+
+void JingleChannel::DoClose() {
+  DCHECK(closed_);
+  stream_->Close();
+  stream_.reset();
+
+  // TODO(sergeyu): Even though we have called Close() for the stream, it
+  // doesn't mean that the p2p sessions has been closed. I.e. |closed_task_|
+  // is called too early. If the client is closed right after that the other
+  // side will not receive notification that the channel was closed.
+  if (closed_task_.get()) {
+    closed_task_->Run();
+    closed_task_.reset();
+  }
 }
 
 size_t JingleChannel::write_buffer_size() {
   AutoLock auto_lock(write_lock_);
   return write_buffer_size_;
 }
 
 }  // namespace remoting