Close all writers before JingleSession is destroyed.

remoting/protocol/connection_to_host.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 "remoting/protocol/connection_to_host.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/message_loop.h"
 #include "remoting/base/constants.h"
@@ skipping 26 matching lines @@
       event_callback_(NULL),
       dispatcher_(new ClientMessageDispatcher()),
       client_stub_(NULL),
       video_stub_(NULL) {
 }
 
 ConnectionToHost::~ConnectionToHost() {
 }
 
 InputStub* ConnectionToHost::input_stub() {
-  return input_stub_.get();
+  return input_sender_.get();
 }
 
 HostStub* ConnectionToHost::host_stub() {
-  return host_stub_.get();
+  return host_control_sender_.get();
 }
 
 void ConnectionToHost::Connect(scoped_refptr<XmppProxy> xmpp_proxy,
                                const std::string& your_jid,
                                const std::string& host_jid,
                                const std::string& host_public_key,
                                const std::string& access_code,
                                HostEventCallback* event_callback,
                                ClientStub* client_stub,
                                VideoStub* video_stub) {
@@ skipping 15 matching lines @@
 }
 
 void ConnectionToHost::Disconnect(const base::Closure& shutdown_task) {
   if (MessageLoop::current() != message_loop_) {
     message_loop_->PostTask(
         FROM_HERE, base::Bind(&ConnectionToHost::Disconnect,
                               base::Unretained(this), shutdown_task));
     return;
   }
 
+  CloseChannels();
+
   if (session_) {
     session_->Close(
         NewRunnableMethod(this, &ConnectionToHost::OnDisconnected,
                           shutdown_task));
   } else {
     OnDisconnected(shutdown_task);
   }
 }
 
 void ConnectionToHost::InitSession() {
@@ skipping 83 matching lines @@
 }
 
 void ConnectionToHost::OnSessionStateChange(
     Session::State state) {
   DCHECK_EQ(message_loop_, MessageLoop::current());
   DCHECK(event_callback_);
 
   switch (state) {
     case Session::FAILED:
       state_ = STATE_FAILED;
+      CloseChannels();
       event_callback_->OnConnectionFailed(this);
       break;
 
     case Session::CLOSED:
       state_ = STATE_CLOSED;
+      CloseChannels();
       event_callback_->OnConnectionClosed(this);
       break;
 
     case Session::CONNECTED:
       state_ = STATE_CONNECTED;
       // Initialize reader and writer.
       video_reader_.reset(VideoReader::Create(session_->config()));
       video_reader_->Init(session_, video_stub_);
-      host_stub_.reset(new HostControlSender(session_->control_channel()));
+      host_control_sender_.reset(
+          new HostControlSender(session_->control_channel()));
       dispatcher_->Initialize(session_.get(), client_stub_);
       event_callback_->OnConnectionOpened(this);
       break;
 
     default:
       // Ignore the other states by default.
       break;
   }
 }
 
+void ConnectionToHost::CloseChannels() {
+  if (input_sender_.get())
+    input_sender_->Close();
+
+  if (host_control_sender_.get())
+    host_control_sender_->Close();
+}
+
 void ConnectionToHost::OnClientAuthenticated() {
   // TODO(hclam): Don't send anything except authentication request if it is
   // not authenticated.
   state_ = STATE_AUTHENTICATED;
 
   // Create and enable the input stub now that we're authenticated.
-  input_stub_.reset(new InputSender(session_->event_channel()));
+  input_sender_.reset(new InputSender(session_->event_channel()));
 }
 
 ConnectionToHost::State ConnectionToHost::state() const {
   return state_;
 }
 
 }  // namespace protocol
 }  // namespace remoting