Allow input & clipboard filters to be disabled without NULLing target stub.

remoting/host/client_session.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/host/client_session.h"
 
 #include <algorithm>
 
 #include "base/message_loop_proxy.h"
 #include "remoting/host/video_frame_capturer.h"
 #include "remoting/proto/control.pb.h"
 #include "remoting/proto/event.pb.h"
 #include "remoting/protocol/client_stub.h"
 #include "remoting/protocol/clipboard_thread_proxy.h"
 
 namespace remoting {
 
 ClientSession::ClientSession(
     EventHandler* event_handler,
     scoped_ptr<protocol::ConnectionToClient> connection,
     protocol::ClipboardStub* host_clipboard_stub,
     protocol::InputStub* host_input_stub,
     VideoFrameCapturer* capturer,
     const base::TimeDelta& max_duration)
     : event_handler_(event_handler),
       connection_(connection.Pass()),
       client_jid_(connection_->session()->jid()),
-      is_authenticated_(false),
       host_clipboard_stub_(host_clipboard_stub),
       host_input_stub_(host_input_stub),
       input_tracker_(host_input_stub_),
       remote_input_filter_(&input_tracker_),
       mouse_input_filter_(&remote_input_filter_),
+      disable_input_filter_(&mouse_input_filter_),
+      disable_clipboard_filter_(clipboard_echo_filter_.host_filter()),
+      auth_input_filter_(&disable_input_filter_),
+      auth_clipboard_filter_(&disable_clipboard_filter_),
       client_clipboard_factory_(clipboard_echo_filter_.client_filter()),
       capturer_(capturer),
       max_duration_(max_duration) {
   connection_->SetEventHandler(this);
 
   // TODO(sergeyu): Currently ConnectionToClient expects stubs to be
   // set before channels are connected. Make it possible to set stubs
   // later and set them only when connection is authenticated.
   connection_->set_clipboard_stub(&auth_clipboard_filter_);
   connection_->set_host_stub(this);
   connection_->set_input_stub(this);
   clipboard_echo_filter_.set_host_stub(host_clipboard_stub_);
+
+  // |auth_*_filter_|'s states reflect whether the session is authenticated.
+  auth_input_filter_.set_enabled(false);
+  auth_clipboard_filter_.set_enabled(false);
 }
 
 ClientSession::~ClientSession() {
 }
 
 void ClientSession::InjectKeyEvent(const protocol::KeyEvent& event) {
   DCHECK(CalledOnValidThread());
   auth_input_filter_.InjectKeyEvent(event);
 }
 
@@ skipping 23 matching lines @@
     VLOG(1) << "Received VideoControl (enable="
             << video_control.enable() << ")";
   }
 }
 
 void ClientSession::OnConnectionAuthenticated(
     protocol::ConnectionToClient* connection) {
   DCHECK(CalledOnValidThread());
   DCHECK_EQ(connection_.get(), connection);
 
-  is_authenticated_ = true;
-  auth_input_filter_.set_input_stub(&disable_input_filter_);
-  auth_clipboard_filter_.set_clipboard_stub(&disable_clipboard_filter_);
+  auth_input_filter_.set_enabled(true);
+  auth_clipboard_filter_.set_enabled(true);
 
   clipboard_echo_filter_.set_client_stub(connection_->client_stub());
 
   if (max_duration_ > base::TimeDelta()) {
     // TODO(simonmorris): Let Disconnect() tell the client that the
     // disconnection was caused by the session exceeding its maximum duration.
     max_duration_timer_.Start(FROM_HERE, max_duration_,
                               this, &ClientSession::Disconnect);
   }
 
   event_handler_->OnSessionAuthenticated(this);
 }
 
 void ClientSession::OnConnectionChannelsConnected(
     protocol::ConnectionToClient* connection) {
   DCHECK(CalledOnValidThread());
   DCHECK_EQ(connection_.get(), connection);
   SetDisableInputs(false);
   event_handler_->OnSessionChannelsConnected(this);
 }
 
 void ClientSession::OnConnectionClosed(
     protocol::ConnectionToClient* connection,
     protocol::ErrorCode error) {
   DCHECK(CalledOnValidThread());
   DCHECK_EQ(connection_.get(), connection);
-  if (!is_authenticated_)
+
+  if (!auth_input_filter_.enabled())
     event_handler_->OnSessionAuthenticationFailed(this);
-  auth_input_filter_.set_input_stub(NULL);
-  auth_clipboard_filter_.set_clipboard_stub(NULL);
+
+  // Block any further input events from the client.
+  // TODO(wez): Fix ChromotingHost::OnSessionClosed not to check our
+  // is_authenticated(), so that we can disable |auth_*_filter_| here.
+  disable_input_filter_.set_enabled(false);
+  disable_clipboard_filter_.set_enabled(false);
 
   // Ensure that any pressed keys or buttons are released.
   input_tracker_.ReleaseAll();
 
   // TODO(sergeyu): Log failure reason?
   event_handler_->OnSessionClosed(this);
 }
 
 void ClientSession::OnSequenceNumberUpdated(
     protocol::ConnectionToClient* connection, int64 sequence_number) {
@@ skipping 22 matching lines @@
 }
 
 void ClientSession::LocalMouseMoved(const SkIPoint& mouse_pos) {
   DCHECK(CalledOnValidThread());
   remote_input_filter_.LocalMouseMoved(mouse_pos);
 }
 
 void ClientSession::SetDisableInputs(bool disable_inputs) {
   DCHECK(CalledOnValidThread());
 
-  if (disable_inputs) {
-    disable_input_filter_.set_input_stub(NULL);
-    disable_clipboard_filter_.set_clipboard_stub(NULL);
+  if (disable_inputs)
     input_tracker_.ReleaseAll();
-  } else {
-    disable_input_filter_.set_input_stub(&mouse_input_filter_);
-    disable_clipboard_filter_.set_clipboard_stub(
-        clipboard_echo_filter_.host_filter());
-  }
+
+  disable_input_filter_.set_enabled(!disable_inputs);
+  disable_clipboard_filter_.set_enabled(!disable_inputs);
 }
 
 scoped_ptr<protocol::ClipboardStub> ClientSession::CreateClipboardProxy() {
   DCHECK(CalledOnValidThread());
 
   return scoped_ptr<protocol::ClipboardStub>(
       new protocol::ClipboardThreadProxy(
           client_clipboard_factory_.GetWeakPtr(),
           base::MessageLoopProxy::current()));
 }
 
 }  // namespace remoting