Add gnubby authentication to remoting host

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 "base/message_loop/message_loop.h"
+#include "base/test/test_simple_task_runner.h"
 #include "remoting/base/auto_thread_task_runner.h"
 #include "remoting/base/constants.h"
 #include "remoting/host/audio_capturer.h"
 #include "remoting/host/client_session.h"
 #include "remoting/host/desktop_environment.h"
 #include "remoting/host/host_mock_objects.h"
 #include "remoting/host/screen_capturer_fake.h"
 #include "remoting/protocol/protocol_mock_objects.h"
+#include "testing/gmock/include/gmock/gmock-matchers.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/webrtc/modules/desktop_capture/desktop_geometry.h"
 #include "third_party/webrtc/modules/desktop_capture/desktop_region.h"
 #include "third_party/webrtc/modules/desktop_capture/screen_capturer_mock_objects.h"
 
 namespace remoting {
 
 using protocol::MockConnectionToClient;
 using protocol::MockClientStub;
 using protocol::MockHostStub;
 using protocol::MockInputStub;
 using protocol::MockSession;
 using protocol::MockVideoStub;
 using protocol::SessionConfig;
 
 using testing::_;
 using testing::AnyNumber;
 using testing::AtMost;
 using testing::DeleteArg;
 using testing::DoAll;
 using testing::Expectation;
 using testing::Return;
 using testing::ReturnRef;
 using testing::Sequence;
+using testing::StrEq;
+using testing::StrictMock;
 
 namespace {
 
 ACTION_P2(InjectClipboardEvent, connection, event) {
   connection->clipboard_stub()->InjectClipboardEvent(event);
 }
 
 ACTION_P2(InjectKeyEvent, connection, event) {
   connection->input_stub()->InjectKeyEvent(event);
 }
 
 ACTION_P2(InjectMouseEvent, connection, event) {
   connection->input_stub()->InjectMouseEvent(event);
 }
 
 ACTION_P2(LocalMouseMoved, client_session, event) {
   client_session->OnLocalMouseMoved(
       webrtc::DesktopVector(event.x(), event.y()));
 }
 
-}  // namespace
+ACTION_P2(SetGnubbyAuthHandlerForTesting, client_session, gnubby_auth_handler) {
+  client_session->SetGnubbyAuthHandlerForTesting(gnubby_auth_handler);
+}
+
+ACTION_P2(DeliverClientMessage, client_session, message) {
+  client_session->DeliverClientMessage(message);
+}
+
+}
 
 class ClientSessionTest : public testing::Test {
  public:
   ClientSessionTest() : client_jid_("user@domain/rest-of-jid") {}
 
   virtual void SetUp() OVERRIDE;
   virtual void TearDown() OVERRIDE;
 
   // Disconnects the client session.
   void DisconnectClientSession();
@@ skipping 91 matching lines @@
       &session_event_handler_,
       ui_task_runner, // Audio thread.
       ui_task_runner, // Input thread.
       ui_task_runner, // Capture thread.
       ui_task_runner, // Encode thread.
       ui_task_runner, // Network thread.
       ui_task_runner, // UI thread.
       connection.PassAs<protocol::ConnectionToClient>(),
       desktop_environment_factory_.get(),
       base::TimeDelta(),
-      NULL));
+      NULL,
+      false));
 }
 
 void ClientSessionTest::TearDown() {
   // Verify that the client session has been stopped.
   EXPECT_TRUE(!client_session_);
 }
 
 void ClientSessionTest::DisconnectClientSession() {
   client_session_->DisconnectSession();
   // MockSession won't trigger OnConnectionClosed, so fake it.
@@ skipping 106 matching lines @@
 }
 
 MATCHER_P2(EqualsMouseEvent, x, y, "") {
   return arg.x() == x && arg.y() == y;
 }
 
 MATCHER_P2(EqualsMouseButtonEvent, button, down, "") {
   return arg.button() == button && arg.button_down() == down;
 }
 
-}
+}  // namespace
 
 TEST_F(ClientSessionTest, InputStubFilter) {
   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);
 
@@ skipping 224 matching lines @@
                                                 expected_event.y())))
       .After(connected)
       .WillOnce(DoAll(
           InvokeWithoutArgs(this, &ClientSessionTest::DisconnectClientSession),
           InvokeWithoutArgs(this, &ClientSessionTest::StopClientSession)));
 
   ConnectClientSession();
   message_loop_.Run();
 }
 
+TEST_F(ClientSessionTest, NoGnubbyAuth) {
+  protocol::ExtensionMessage message;
+  message.set_type("gnubby-auth");
+  message.set_data("test");
+
+  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)
+      .WillOnce(DoAll(
+           DeliverClientMessage(client_session_.get(), message),
+           InvokeWithoutArgs(this, &ClientSessionTest::DisconnectClientSession),
+           InvokeWithoutArgs(this, &ClientSessionTest::StopClientSession)));
+  EXPECT_CALL(session_event_handler_, OnSessionClosed(_));
+
+  ConnectClientSession();
+  message_loop_.Run();
+}
+
+TEST_F(ClientSessionTest, EnableGnubbyAuth) {
+  // Lifetime controlled by object under test.
+  MockGnubbyAuthHandler* gnubby_auth_handler = new MockGnubbyAuthHandler(
+      &client_stub_);
+
+  protocol::ExtensionMessage message;
+  message.set_type("gnubby-auth");
+  message.set_data("test");
+
+  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)
+      .WillOnce(DoAll(
+           SetGnubbyAuthHandlerForTesting(client_session_.get(),
+                                          gnubby_auth_handler),
+           DeliverClientMessage(client_session_.get(), message),
+           InvokeWithoutArgs(this, &ClientSessionTest::DisconnectClientSession),
+           InvokeWithoutArgs(this, &ClientSessionTest::StopClientSession)));
+  EXPECT_CALL(*gnubby_auth_handler, DeliverClientMessage(_));
+  EXPECT_CALL(session_event_handler_, OnSessionClosed(_));
+
+  ConnectClientSession();
+  message_loop_.Run();
+}
+
 }  // namespace remoting