Fix stuck keys problem with Chromoting when host disconnects while keys are

remoting/host/client_session.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/host/client_session.h"
 
 #include <algorithm>
 
 #include "base/task.h"
 #include "remoting/host/user_authenticator.h"
 #include "remoting/proto/auth.pb.h"
 #include "remoting/proto/event.pb.h"
 
 // The number of remote mouse events to record for the purpose of eliminating
 // "echoes" detected by the local input detector. The value should be large
 // enough to cope with the fact that multiple events might be injected before
 // any echoes are detected.
 static const unsigned int kNumRemoteMousePositions = 50;
 
 // The number of milliseconds for which to block remote input when local input
 // is received.
 static const int64 kRemoteBlockTimeoutMillis = 2000;
 
 namespace remoting {
 
+using protocol::KeyEvent;
+
 ClientSession::ClientSession(
     EventHandler* event_handler,
     UserAuthenticator* user_authenticator,
     scoped_refptr<protocol::ConnectionToClient> connection,
     protocol::InputStub* input_stub)
     : event_handler_(event_handler),
       user_authenticator_(user_authenticator),
       connection_(connection),
       input_stub_(input_stub),
       authenticated_(false),
@@ skipping 28 matching lines @@
 void ClientSession::OnAuthorizationComplete(bool success) {
   if (success) {
     authenticated_ = true;
     event_handler_->LocalLoginSucceeded(connection_.get());
   } else {
     LOG(WARNING) << "Login failed";
     event_handler_->LocalLoginFailed(connection_.get());
   }
 }
 
-void ClientSession::InjectKeyEvent(const protocol::KeyEvent* event,
-                                   Task* done) {
+void ClientSession::InjectKeyEvent(const KeyEvent* event, Task* done) {
   base::ScopedTaskRunner done_runner(done);
   if (authenticated_ && !ShouldIgnoreRemoteKeyboardInput(event)) {
     RecordKeyEvent(event);
     input_stub_->InjectKeyEvent(event, done_runner.Release());
   }
 }
 
 void ClientSession::InjectMouseEvent(const protocol::MouseEvent* event,
                                      Task* done) {
   base::ScopedTaskRunner done_runner(done);
@@ skipping 62 matching lines @@
     return true;
   // Otherwise, ignore remote mouse events if the local mouse moved recently.
   int64 millis = (base::Time::Now() - latest_local_input_time_)
                  .InMilliseconds();
   if (millis < kRemoteBlockTimeoutMillis)
     return true;
   return false;
 }
 
 bool ClientSession::ShouldIgnoreRemoteKeyboardInput(
-    const protocol::KeyEvent* event) const {
+    const KeyEvent* event) const {
   // If the host user has not yet approved the continuation of the connection,
   // then all remote keyboard input is ignored, except to release keys that
   // were already pressed.
   if (awaiting_continue_approval_) {
     return event->pressed() ||
         (pressed_keys_.find(event->keycode()) == pressed_keys_.end());
   }
   return false;
 }
 
-void ClientSession::RecordKeyEvent(const protocol::KeyEvent* event) {
+void ClientSession::RecordKeyEvent(const KeyEvent* event) {
   if (event->pressed()) {
     pressed_keys_.insert(event->keycode());
   } else {
     pressed_keys_.erase(event->keycode());
   }
 }
 
 void ClientSession::UnpressKeys() {
   std::set<int>::iterator i;
   for (i = pressed_keys_.begin(); i != pressed_keys_.end(); ++i) {
-    protocol::KeyEvent key;
-    key.set_keycode(*i);
-    key.set_pressed(false);
-    input_stub_->InjectKeyEvent(&key, NULL);
+    KeyEvent* key = new KeyEvent();
+    key->set_keycode(*i);
+    key->set_pressed(false);
+    input_stub_->InjectKeyEvent(key, new DeleteTask<KeyEvent>(key));
   }
   pressed_keys_.clear();
 }
 
 }  // namespace remoting