Move ConnectionToClient::EventHandler from ChromotingHost to ClientSession

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/message_loop_proxy.h"
 #include "base/task.h"
 #include "remoting/host/capturer.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;
 
@@ skipping 12 matching lines @@
     protocol::InputStub* input_stub,
     Capturer* capturer)
     : event_handler_(event_handler),
       connection_(connection),
       client_jid_(connection->session()->jid()),
       input_stub_(input_stub),
       capturer_(capturer),
       authenticated_(false),
       awaiting_continue_approval_(false),
       remote_mouse_button_state_(0) {
+  connection_->SetEventHandler(this);
+  connection_->set_host_stub(this);
+  connection_->set_input_stub(this);
 }
 
 ClientSession::~ClientSession() {
 }
 
-void ClientSession::OnAuthenticationComplete() {
-  authenticated_ = true;
-  event_handler_->OnAuthenticationComplete(connection_.get());
-}
-
 void ClientSession::InjectKeyEvent(const KeyEvent& event) {
   if (authenticated_ && !ShouldIgnoreRemoteKeyboardInput(event)) {
     RecordKeyEvent(event);
     input_stub_->InjectKeyEvent(event);
   }
 }
 
 void ClientSession::InjectMouseEvent(const MouseEvent& event) {
   if (authenticated_ && !ShouldIgnoreRemoteMouseInput(event)) {
     RecordMouseButtonState(event);
@@ skipping 18 matching lines @@
       injected_mouse_positions_.push_back(pos);
       if (injected_mouse_positions_.size() > kNumRemoteMousePositions) {
         VLOG(1) << "Injected mouse positions queue full.";
         injected_mouse_positions_.pop_front();
       }
     }
     input_stub_->InjectMouseEvent(event_to_inject);
   }
 }
 
-void ClientSession::OnDisconnected() {
+void ClientSession::OnConnectionOpened(
+    protocol::ConnectionToClient* connection) {
+  DCHECK_EQ(connection_.get(), connection);
+  // TODO(sergeyu): Acutally authenticate the session.

[Wez, 2011/11/09 01:35:07]

typo: Acutally

The session has already been authenticated by Talk, and then by the
session-initiation handshake.  Are you intending that OnConnectionOpened() be
called _before_ the EKE handshake has completed, in future, or is this what you
mean by "actually authenticate" here?

+  authenticated_ = true;
+  event_handler_->OnSessionAuthenticated(this);
+}
+
+void ClientSession::OnConnectionClosed(
+    protocol::ConnectionToClient* connection) {
+  DCHECK_EQ(connection_.get(), connection);
+  scoped_refptr<ClientSession> self = this;
+  event_handler_->OnSessionClosed(this);
+  Disconnect();
+}
+
+void ClientSession::OnConnectionFailed(
+    protocol::ConnectionToClient* connection) {
+  DCHECK_EQ(connection_.get(), connection);
+  scoped_refptr<ClientSession> self = this;
+  event_handler_->OnSessionFailed(this);
+  Disconnect();
+}
+
+void ClientSession::OnSequenceNumberUpdated(
+    protocol::ConnectionToClient* connection, int64 sequence_number) {
+  DCHECK_EQ(connection_.get(), connection);
+  event_handler_->OnSessionSequenceNumber(this, sequence_number);
+}
+
+void ClientSession::Disconnect() {
+  connection_->Disconnect();
+  authenticated_ = false;
   RestoreEventState();
-  authenticated_ = false;
 }
 
 void ClientSession::LocalMouseMoved(const SkIPoint& mouse_pos) {
   // If this is a genuine local input event (rather than an echo of a remote
   // input event that we've just injected), then ignore remote inputs for a
   // short time.
   std::list<SkIPoint>::iterator found_position =
       std::find(injected_mouse_positions_.begin(),
                 injected_mouse_positions_.end(), mouse_pos);
   if (found_position != injected_mouse_positions_.end()) {
@@ skipping 84 matching lines @@
       mouse.set_y(remote_mouse_pos_.y());
       mouse.set_button((MouseEvent::MouseButton)i);
       mouse.set_button_down(false);
       input_stub_->InjectMouseEvent(mouse);
     }
   }
   remote_mouse_button_state_ = 0;
 }
 
 }  // namespace remoting