Fix ConnectionToClient to connect stubs only after authentication.

remoting/host/client_session_unittest.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 <algorithm>
 #include <string>
 #include <vector>
 
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
@@ skipping 292 matching lines @@
 
 webrtc::DesktopCapturer* ClientSessionTest::CreateVideoCapturer() {
   return new FakeDesktopCapturer();
 }
 
 webrtc::MouseCursorMonitor* ClientSessionTest::CreateMouseCursorMonitor() {
   return new FakeMouseCursorMonitor();
 }
 
 void ClientSessionTest::ConnectClientSession() {
+  // Stubs should be set only after connection is authenticated.
+  EXPECT_FALSE(connection_->clipboard_stub());
+  EXPECT_FALSE(connection_->input_stub());
+
   client_session_->OnConnectionAuthenticated(client_session_->connection());
+
+  EXPECT_TRUE(connection_->clipboard_stub());
+  EXPECT_TRUE(connection_->input_stub());
+
   client_session_->OnConnectionChannelsConnected(client_session_->connection());
 }
 
 void ClientSessionTest::SetMatchCapabilitiesExpectation() {
   // Set the client to report the same capabilities as the host.
   EXPECT_CALL(client_stub_, SetCapabilities(_))
       .Times(AtMost(1))
       .WillOnce(Invoke(client_session_.get(), &ClientSession::SetCapabilities));
 }
 
@@ skipping 12 matching lines @@
           DeliverClientMessage(client_session_.get(), message),
           InvokeWithoutArgs(this, &ClientSessionTest::DisconnectClientSession),
           InvokeWithoutArgs(this, &ClientSessionTest::StopClientSession)));
 }
 
 MATCHER_P2(EqualsClipboardEvent, m, d, "") {
   return (strcmp(arg.mime_type().c_str(), m) == 0 &&
       memcmp(arg.data().data(), d, arg.data().size()) == 0);
 }
 
-TEST_F(ClientSessionTest, ClipboardStubFilter) {

[Wez, 2015/02/07 00:40:43]

We should have some disable-inputs tests - perhaps just repurpose these?

[Sergey Ulanov, 2015/02/13 19:40:21]

Done.

-  CreateClientSession();
-
-  protocol::ClipboardEvent clipboard_event1;
-  clipboard_event1.set_mime_type(kMimeTypeTextUtf8);
-  clipboard_event1.set_data("a");
-
-  protocol::ClipboardEvent clipboard_event2;
-  clipboard_event2.set_mime_type(kMimeTypeTextUtf8);
-  clipboard_event2.set_data("b");
-
-  protocol::ClipboardEvent clipboard_event3;
-  clipboard_event3.set_mime_type(kMimeTypeTextUtf8);
-  clipboard_event3.set_data("c");
-
-  Expectation authenticated =
-      EXPECT_CALL(session_event_handler_, OnSessionAuthenticated(_))
-          .WillOnce(Return(true));
-  EXPECT_CALL(*input_injector_, StartPtr(_))
-      .After(authenticated);
-  EXPECT_CALL(session_event_handler_, OnSessionChannelsConnected(_))
-      .After(authenticated);
-
-  // Wait for the first video packet to be captured to make sure that
-  // the injected input will go though. Otherwise mouse events will be blocked
-  // by the mouse clamping filter.
-  Sequence s;
-  EXPECT_CALL(video_stub_, ProcessVideoPacketPtr(_, _))
-      .InSequence(s)
-      .After(authenticated)
-      .WillOnce(DoAll(
-          // This event should get through to the clipboard stub.
-          InjectClipboardEvent(connection_, clipboard_event2),
-          InvokeWithoutArgs(this, &ClientSessionTest::DisconnectClientSession),
-          // This event should not get through to the clipboard stub,
-          // because the client has disconnected.
-          InjectClipboardEvent(connection_, clipboard_event3),
-          InvokeWithoutArgs(this, &ClientSessionTest::StopClientSession)));
-  EXPECT_CALL(*input_injector_, InjectClipboardEvent(EqualsClipboardEvent(
-      kMimeTypeTextUtf8, "b")))
-      .InSequence(s);
-  EXPECT_CALL(session_event_handler_, OnSessionClosed(_))
-      .InSequence(s);
-
-  // This event should not get through to the clipboard stub,
-  // because the client isn't authenticated yet.
-  connection_->clipboard_stub()->InjectClipboardEvent(clipboard_event1);
-
-  ConnectClientSession();
-}
-
-TEST_F(ClientSessionTest, InputStubFilter) {
-  CreateClientSession();
-
-  protocol::KeyEvent key_event1;
-  key_event1.set_pressed(true);
-  key_event1.set_usb_keycode(1);
-
-  protocol::KeyEvent key_event2_down;
-  key_event2_down.set_pressed(true);
-  key_event2_down.set_usb_keycode(2);
-
-  protocol::KeyEvent key_event2_up;
-  key_event2_up.set_pressed(false);
-  key_event2_up.set_usb_keycode(2);
-
-  protocol::KeyEvent key_event3;
-  key_event3.set_pressed(true);
-  key_event3.set_usb_keycode(3);
-
-  protocol::MouseEvent mouse_event1;
-  mouse_event1.set_x(100);
-  mouse_event1.set_y(101);
-
-  protocol::MouseEvent mouse_event2;
-  mouse_event2.set_x(200);
-  mouse_event2.set_y(201);
-
-  protocol::MouseEvent mouse_event3;
-  mouse_event3.set_x(300);
-  mouse_event3.set_y(301);
-
-  Expectation authenticated =
-      EXPECT_CALL(session_event_handler_, OnSessionAuthenticated(_))
-          .WillOnce(Return(true));
-  EXPECT_CALL(*input_injector_, StartPtr(_))
-      .After(authenticated);
-  EXPECT_CALL(session_event_handler_, OnSessionChannelsConnected(_))
-      .After(authenticated);
-
-  // Wait for the first video packet to be captured to make sure that
-  // the injected input will go though. Otherwise mouse events will be blocked
-  // by the mouse clamping filter.
-  Sequence s;
-  EXPECT_CALL(video_stub_, ProcessVideoPacketPtr(_, _))
-      .InSequence(s)
-      .After(authenticated)
-      .WillOnce(DoAll(
-          // These events should get through to the input stub.
-          InjectKeyEvent(connection_, key_event2_down),
-          InjectKeyEvent(connection_, key_event2_up),
-          InjectMouseEvent(connection_, mouse_event2),
-          InvokeWithoutArgs(this, &ClientSessionTest::DisconnectClientSession),
-          // These events should not get through to the input stub,
-          // because the client has disconnected.
-          InjectKeyEvent(connection_, key_event3),
-          InjectMouseEvent(connection_, mouse_event3),
-          InvokeWithoutArgs(this, &ClientSessionTest::StopClientSession)));
-  EXPECT_CALL(*input_injector_, InjectKeyEvent(EqualsUsbEvent(2, true)))
-      .InSequence(s);
-  EXPECT_CALL(*input_injector_, InjectKeyEvent(EqualsUsbEvent(2, false)))
-      .InSequence(s);
-  EXPECT_CALL(*input_injector_, InjectMouseEvent(EqualsMouseEvent(200, 201)))
-      .InSequence(s);
-  EXPECT_CALL(session_event_handler_, OnSessionClosed(_))
-      .InSequence(s);
-
-  // These events should not get through to the input stub,
-  // because the client isn't authenticated yet.
-  connection_->input_stub()->InjectKeyEvent(key_event1);
-  connection_->input_stub()->InjectMouseEvent(mouse_event1);
-
-  ConnectClientSession();
-}
-
 TEST_F(ClientSessionTest, LocalInputTest) {
   CreateClientSession();
 
   protocol::MouseEvent mouse_event1;
   mouse_event1.set_x(100);
   mouse_event1.set_y(101);
   protocol::MouseEvent mouse_event2;
   mouse_event2.set_x(200);
   mouse_event2.set_y(201);
   protocol::MouseEvent mouse_event3;
@@ skipping 327 matching lines @@
 
   DisconnectClientSession();
   StopClientSession();
 
   // ext1 was instantiated and wrapped the video capturer.
   EXPECT_TRUE(extension.was_instantiated());
   EXPECT_TRUE(extension.has_wrapped_video_capturer());
 }
 
 }  // namespace remoting