Check whether the client is connected before trying to write to channels.

remoting/client/plugin/chromoting_instance.cc

 // Copyright (c) 2012 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/client/plugin/chromoting_instance.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 312 matching lines @@
   view_->SetView(new_size, new_clip);
 
   if (mouse_input_filter_.get()) {
     mouse_input_filter_->set_input_size(view_->get_view_size());
   }
 }
 
 bool ChromotingInstance::HandleInputEvent(const pp::InputEvent& event) {
   DCHECK(plugin_message_loop_->BelongsToCurrentThread());
 
-  if (!input_handler_.get())
+  if (!IsConnected())
     return false;
 
   // TODO(wez): When we have a good hook into Host dimensions changes, move
   // this there.
   // If |input_handler_| is valid, then |mouse_input_filter_| must also be
   // since they are constructed together as part of the input pipeline
   mouse_input_filter_->set_output_size(view_->get_screen_size());
 
   return input_handler_->HandleInputEvent(event);
 }
@@ skipping 101 matching lines @@
   host_connection_.reset();
 
   SetConnectionState(STATE_CLOSED, ERROR_NONE);
 }
 
 void ChromotingInstance::OnIncomingIq(const std::string& iq) {
   xmpp_proxy_->OnIq(iq);
 }
 
 void ChromotingInstance::ReleaseAllKeys() {
-  if (input_tracker_.get())
+  if (IsConnected())
     input_tracker_->ReleaseAll();
 }
 
 void ChromotingInstance::InjectKeyEvent(const protocol::KeyEvent& event) {
   // Inject after the KeyEventMapper, so the event won't get mapped or trapped.
-  if (input_tracker_.get())
+  if (IsConnected())
     input_tracker_->InjectKeyEvent(event);
 }
 
 void ChromotingInstance::RemapKey(uint32 in_usb_keycode,
                                   uint32 out_usb_keycode) {
   key_mapper_.RemapKey(in_usb_keycode, out_usb_keycode);
 }
 
 void ChromotingInstance::TrapKey(uint32 usb_keycode, bool trap) {
   key_mapper_.TrapKey(usb_keycode, trap);
 }
 
 void ChromotingInstance::SendClipboardItem(const std::string& mime_type,
                                            const std::string& item) {
-  if (!host_connection_.get()) {
+  if (!IsConnected()) {
     return;
   }
   protocol::ClipboardEvent event;
   event.set_mime_type(mime_type);
   event.set_data(item);
   host_connection_->clipboard_stub()->InjectClipboardEvent(event);
 }
 
 void ChromotingInstance::NotifyClientDimensions(int width, int height) {
-  if (!host_connection_.get()) {
+  if (!IsConnected()) {
     return;
   }
   protocol::ClientDimensions client_dimensions;
   client_dimensions.set_width(width);
   client_dimensions.set_height(height);
   host_connection_->host_stub()->NotifyClientDimensions(client_dimensions);
 }
 
 ChromotingStats* ChromotingInstance::GetStats() {
   if (!client_.get())
@@ skipping 150 matching lines @@
   if (scriptable_object) {
     scoped_ptr<base::DictionaryValue> data(new base::DictionaryValue());
     data->SetString("message", message);
     PostChromotingMessage("logDebugMessage", data.Pass());
 
     scriptable_object->LogDebugInfo(message);
   }
   g_logging_to_plugin = false;
 }
 
+bool ChromotingInstance::IsConnected() {
+  return host_connection_.get() &&
+    (host_connection_->state() == protocol::ConnectionToHost::CONNECTED);
+}
+
 }  // namespace remoting