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.
Clarify what level of authentication you are talking about here.  By the time we
reach here we have already got the client GAIA Id, authenticated by Talk, and
we've authenticated the channel against the Access Code or PIN?

[Sergey Ulanov, 2011/11/09 19:26:13]

Removed this TODO for now. The intention is that ClientSession is created in
response to incoming session (session-initiate message) and then it would invoke
OnSessionAuthenticated after session is completely authenticated (e.g. using
EKE). But I'm not yet sure yet if it's better to handle auth in ClientSession or
ConnectionToHost, so I just removed this comment.

+  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();

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

Could OnSessionClosed() be dispatched from Disconnect()?

[Sergey Ulanov, 2011/11/09 19:26:13]

No. In any case I removed this line in one of the next CLs.

+}
+
+void ClientSession::OnConnectionFailed(
+    protocol::ConnectionToClient* connection) {

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

Fetch and log some reason for the "failure"?

[Sergey Ulanov, 2011/11/09 19:26:13]

Added TODO for this.

+  DCHECK_EQ(connection_.get(), connection);
+  scoped_refptr<ClientSession> self = this;
+  event_handler_->OnSessionClosed(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;

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

Rather than keeping a separate |authenticated_| flag and checking it here,
couldn't we just not set the input and host stubs on the connection when we're
not authenticated?

[Sergey Ulanov, 2011/11/09 19:26:13]

I agree it would be better, but currently ConnectionToClient expects stubs to be
set before channels are created. Added TODO in ClientSession::ClientSession() to
fix it.

   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