Allows chromoting host to be connected again after connection drops.

remoting/host/chromoting_host.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/chromoting_host.h"
 
 #include "base/stl_util-inl.h"
 #include "base/task.h"
 #include "build/build_config.h"
 #include "remoting/base/constants.h"
@@ skipping 52 matching lines @@
     // it should run on.
     DCHECK(capturer_.get());
     DCHECK(encoder_.get());
     session_ = new SessionManager(context_->capture_message_loop(),
                                   context_->encode_message_loop(),
                                   context_->main_message_loop(),
                                   capturer_.get(),
                                   encoder_.get());
 
     // Immediately add the client and start the session.
     session_->AddClient(client);

[Sergey Ulanov, 2010/09/02 01:20:24]

This code is duplicated below. Move this out of the if block?

     session_->Start();
     LOG(INFO) << "Session manager started";
   } else {
     // If a session manager already exists we simply add the new client.
     session_->AddClient(client);
+    session_->Start();
   }
 }
 
 void ChromotingHost::OnClientDisconnected(ClientConnection* client) {
   DCHECK_EQ(context_->main_message_loop(), MessageLoop::current());
 
   // Remove the client from the session manager and pause the session.
   // TODO(hclam): Pause only if the last client disconnected.
   if (session_.get()) {
     session_->RemoveClient(client);
     session_->Pause();
   }
 
+  // Close the connection to client just to be safe.
+  client->Disconnect();
+
   // Also remove reference to ClientConnection from this object.
   client_ = NULL;
 }
 
 ////////////////////////////////////////////////////////////////////////////
 // ClientConnection::EventHandler implementations
 void ChromotingHost::HandleMessages(ClientConnection* client,
                                     ClientMessageList* messages) {
   DCHECK_EQ(context_->main_message_loop(), MessageLoop::current());
 
   // Delegate the messages to EventExecutor and delete the unhandled
   // messages.
   DCHECK(executor_.get());
   executor_->HandleInputEvents(messages);
   STLDeleteElements<ClientMessageList>(messages);
 }
 
 void ChromotingHost::OnConnectionOpened(ClientConnection* client) {
   DCHECK_EQ(context_->main_message_loop(), MessageLoop::current());
 
   // Completes the client connection.
   LOG(INFO) << "Connection to client established.";
   OnClientConnected(client_.get());
 }
 
 void ChromotingHost::OnConnectionClosed(ClientConnection* client) {
   DCHECK_EQ(context_->main_message_loop(), MessageLoop::current());
 
-  // Completes the client connection.
   LOG(INFO) << "Connection to client closed.";
   OnClientDisconnected(client_.get());
 }
 
 void ChromotingHost::OnConnectionFailed(ClientConnection* client) {
   DCHECK_EQ(context_->main_message_loop(), MessageLoop::current());
 
-  // The client has disconnected.
   LOG(ERROR) << "Connection failed unexpectedly.";
   OnClientDisconnected(client_.get());
 }
 
 ////////////////////////////////////////////////////////////////////////////
 // JingleClient::Callback implementations
 void ChromotingHost::OnStateChange(JingleClient* jingle_client,
                                    JingleClient::State state) {
   if (state == JingleClient::CONNECTED) {
     DCHECK_EQ(jingle_client_.get(), jingle_client);
@@ skipping 121 matching lines @@
     heartbeat_sender_->Stop();
   }
 
   // Lastly call the shutdown task.
   if (shutdown_task_.get()) {
     shutdown_task_->Run();
   }
 }
 
 }  // namespace remoting