Fix thread usage in chromoting host

remoting/host/client_connection.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/host/client_connection.h"
 
 #include "google/protobuf/message.h"
 #include "media/base/data_buffer.h"
 #include "remoting/base/protocol_decoder.h"
 #include "remoting/base/protocol_util.h"
@@ skipping 20 matching lines @@
 }
 
 ClientConnection::~ClientConnection() {
   // TODO(hclam): When we shut down the viewer we may have to close the
   // jingle channel.
 }
 
 void ClientConnection::SendInitClientMessage(int width, int height) {
   DCHECK_EQ(loop_, MessageLoop::current());
   DCHECK(!update_stream_size_);
-  DCHECK(channel_.get());
+
+  // If we are disconnected then return.
+  if (!channel_)
+    return;
 
   HostMessage msg;
   msg.mutable_init_client()->set_width(width);
   msg.mutable_init_client()->set_height(height);
   DCHECK(msg.IsInitialized());
   channel_->Write(SerializeAndFrameMessage(msg));
 }
 
 void ClientConnection::SendBeginUpdateStreamMessage() {
   DCHECK_EQ(loop_, MessageLoop::current());
-  DCHECK(channel_.get());
+
+  // If we are disconnected then return.
+  if (!channel_)
+    return;
 
   HostMessage msg;
   msg.mutable_begin_update_stream();
   DCHECK(msg.IsInitialized());
 
   scoped_refptr<DataBuffer> data = SerializeAndFrameMessage(msg);
   DCHECK(!update_stream_size_);
   update_stream_size_ += data->GetDataSize();
   channel_->Write(data);
 }
 
 void ClientConnection::SendUpdateStreamPacketMessage(
     const UpdateStreamPacketHeader* header,
     scoped_refptr<DataBuffer> data) {
   DCHECK_EQ(loop_, MessageLoop::current());
-  DCHECK(channel_.get());
+
+  // If we are disconnected then return.
+  if (!channel_)
+    return;
 
   HostMessage msg;
   msg.mutable_update_stream_packet()->mutable_header()->CopyFrom(*header);
   // TODO(hclam): This introduce one memory copy. Eliminate it.
   msg.mutable_update_stream_packet()->set_data(
       data->GetData(), data->GetDataSize());
   DCHECK(msg.IsInitialized());
 
   scoped_refptr<DataBuffer> encoded_data = SerializeAndFrameMessage(msg);
   update_stream_size_ += data->GetDataSize();
   channel_->Write(encoded_data);
 }
 
 void ClientConnection::SendEndUpdateStreamMessage() {
   DCHECK_EQ(loop_, MessageLoop::current());
-  DCHECK(channel_.get());
+
+  // If we are disconnected then return.
+  if (!channel_)
+    return;
 
   HostMessage msg;
   msg.mutable_end_update_stream();
   DCHECK(msg.IsInitialized());
 
   scoped_refptr<DataBuffer> data = SerializeAndFrameMessage(msg);
   update_stream_size_ += data->GetDataSize();
   channel_->Write(data);
 
   // Here's some logic to help finding the average update stream size.
@@ skipping 14 matching lines @@
     return 0;
   int average_size = size_in_queue_ / size_queue_.size();
   if (!average_size)
     return 0;
   return channel_->write_buffer_size() / average_size;
 }
 
 void ClientConnection::Disconnect() {
   DCHECK_EQ(loop_, MessageLoop::current());
 
-  DCHECK(channel_.get());
-  channel_->Close();
+  // If there is a channel then close it and release the reference.
+  if (channel_) {
+    channel_->Close();
+    channel_ = NULL;
+  }
 }
 
 void ClientConnection::OnStateChange(JingleChannel* channel,
                                      JingleChannel::State state) {
   DCHECK(channel);
   loop_->PostTask(FROM_HERE,
       NewRunnableMethod(this, &ClientConnection::StateChangeTask, state));
 }
 
 void ClientConnection::OnPacketReceived(JingleChannel* channel,
@@ skipping 33 matching lines @@
   DCHECK(decoder_.get());
   ClientMessageList list;
   decoder_->ParseClientMessages(data, &list);
 
   // Then submit the messages to the handler.
   DCHECK(handler_);
   handler_->HandleMessages(this, &list);
 }
 
 }  // namespace remoting