Move all protocol event matchers to test_event_matchers.h

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"
 #include "base/strings/string_util.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/fake_desktop_capturer.h"
 #include "remoting/host/fake_host_extension.h"
 #include "remoting/host/fake_mouse_cursor_monitor.h"
 #include "remoting/host/host_extension.h"
 #include "remoting/host/host_extension_session.h"
 #include "remoting/host/host_mock_objects.h"
 #include "remoting/protocol/protocol_mock_objects.h"
+#include "remoting/protocol/test_event_matchers.h"
 #include "testing/gmock/include/gmock/gmock-matchers.h"
 #include "testing/gmock_mutant.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::MockClientStub;
 using protocol::MockConnectionToClient;
-using protocol::MockClientStub;
 using protocol::MockHostStub;
 using protocol::MockInputStub;
 using protocol::MockSession;
 using protocol::MockVideoStub;
 using protocol::SessionConfig;
+using protocol::test::EqualsClipboardEvent;
+using protocol::test::EqualsMouseButtonEvent;
+using protocol::test::EqualsMouseMoveEvent;
+using protocol::test::EqualsKeyEvent;
 
 using testing::_;
 using testing::AnyNumber;
 using testing::AtMost;
 using testing::AtLeast;
 using testing::CreateFunctor;
 using testing::DeleteArg;
 using testing::DoAll;
 using testing::Expectation;
 using testing::Invoke;
@@ skipping 31 matching lines @@
 ACTION_P2(DeliverClientMessage, client_session, message) {
   client_session->DeliverClientMessage(message);
 }
 
 ACTION_P2(SetCapabilities, client_session, capabilities) {
   protocol::Capabilities capabilities_message;
   capabilities_message.set_capabilities(capabilities);
   client_session->SetCapabilities(capabilities_message);
 }
 
-MATCHER_P2(EqualsUsbEvent, usb_keycode, pressed, "") {
-  return arg.usb_keycode() == (unsigned int)usb_keycode &&
-         arg.pressed() == pressed;
-}
-
-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;
-}
-
 // Matches a |protocol::Capabilities| argument against a list of capabilities
 // formatted as a space-separated string.
 MATCHER_P(EqCapabilities, expected_capabilities, "") {
   if (!arg.has_capabilities())
     return false;
 
   std::vector<std::string> words_args;
   std::vector<std::string> words_expected;
   Tokenize(arg.capabilities(), " ", &words_args);
   Tokenize(expected_capabilities, " ", &words_expected);
@@ skipping 127 matching lines @@
       new MockConnectionToClient(session, nullptr));
   EXPECT_CALL(*connection, session()).WillRepeatedly(Return(session));
   EXPECT_CALL(*connection, client_stub())
       .WillRepeatedly(Return(&client_stub_));
   EXPECT_CALL(*connection, video_stub()).WillRepeatedly(Return(&video_stub_));
   EXPECT_CALL(*connection, Disconnect());
   connection_ = connection.get();
 
   client_session_.reset(new ClientSession(
       &session_event_handler_,
-      task_runner_, // Audio thread.
-      task_runner_, // Input thread.
-      task_runner_, // Capture thread.
-      task_runner_, // Encode thread.
-      task_runner_, // Network thread.
-      task_runner_, // UI thread.
+      task_runner_,  // Audio thread.
+      task_runner_,  // Input thread.
+      task_runner_,  // Capture thread.
+      task_runner_,  // Encode thread.
+      task_runner_,  // Network thread.
+      task_runner_,  // UI thread.
       connection.Pass(),
       desktop_environment_factory_.get(),
       base::TimeDelta(),
       nullptr,
       extensions_));
 }
 
 void ClientSessionTest::DisconnectClientSession() {
   client_session_->DisconnectSession();
   // MockSession won't trigger OnConnectionClosed, so fake it.
@@ skipping 15 matching lines @@
       .WillOnce(Invoke(this, &ClientSessionTest::CreateInputInjector));
   EXPECT_CALL(*desktop_environment, CreateScreenControlsPtr())
       .Times(AtMost(1));
   EXPECT_CALL(*desktop_environment, CreateVideoCapturerPtr())
       .WillRepeatedly(Invoke(this, &ClientSessionTest::CreateVideoCapturer));
   EXPECT_CALL(*desktop_environment, CreateMouseCursorMonitorPtr())
       .WillRepeatedly(
           Invoke(this, &ClientSessionTest::CreateMouseCursorMonitor));
   EXPECT_CALL(*desktop_environment, GetCapabilities())
       .Times(AtMost(1))
-       .WillOnce(Return(kDefaultTestCapability));
+      .WillOnce(Return(kDefaultTestCapability));
   EXPECT_CALL(*desktop_environment, SetCapabilities(_))
       .Times(AtMost(1));
 
   return desktop_environment;
 }
 
 InputInjector* ClientSessionTest::CreateInputInjector() {
   EXPECT_TRUE(input_injector_);
   return input_injector_.release();
 }
@@ skipping 27 matching lines @@
 }
 
 void ClientSessionTest::SetSendMessageAndDisconnectExpectation(
     const std::string& message_type) {
   protocol::ExtensionMessage message;
   message.set_type(message_type);
   message.set_data("data");
 
   Expectation authenticated =
       EXPECT_CALL(session_event_handler_, OnSessionAuthenticated(_))
-      .WillOnce(Return(true));
+          .WillOnce(Return(true));
   EXPECT_CALL(session_event_handler_, OnSessionChannelsConnected(_))
       .After(authenticated)
       .WillOnce(DoAll(
           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) {
   CreateClientSession();
 
   EXPECT_CALL(session_event_handler_, OnSessionAuthenticated(_))
       .WillOnce(Return(true));
   EXPECT_CALL(*input_injector_, StartPtr(_));
   EXPECT_CALL(session_event_handler_, OnSessionChannelsConnected(_));
 
   // 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.
   base::RunLoop run_loop;
   EXPECT_CALL(video_stub_, ProcessVideoPacketPtr(_, _))
       .Times(AtLeast(1))
       .WillOnce(testing::InvokeWithoutArgs(&run_loop, &base::RunLoop::Quit));
 
   {
     EXPECT_CALL(*input_injector_, InjectClipboardEvent(EqualsClipboardEvent(
                                       kMimeTypeTextUtf8, "a")));
-    EXPECT_CALL(*input_injector_, InjectKeyEvent(EqualsUsbEvent(1, true)));
-    EXPECT_CALL(*input_injector_, InjectKeyEvent(EqualsUsbEvent(1, false)));
-    EXPECT_CALL(*input_injector_, InjectMouseEvent(EqualsMouseEvent(100, 101)));
+    EXPECT_CALL(*input_injector_, InjectKeyEvent(EqualsKeyEvent(1, true)));
+    EXPECT_CALL(*input_injector_, InjectKeyEvent(EqualsKeyEvent(1, false)));
+    EXPECT_CALL(*input_injector_,
+                InjectMouseEvent(EqualsMouseMoveEvent(100, 101)));
 
     EXPECT_CALL(*input_injector_, InjectClipboardEvent(EqualsClipboardEvent(
                                       kMimeTypeTextUtf8, "c")));
-    EXPECT_CALL(*input_injector_, InjectKeyEvent(EqualsUsbEvent(3, true)));
-    EXPECT_CALL(*input_injector_, InjectMouseEvent(EqualsMouseEvent(300, 301)));
-    EXPECT_CALL(*input_injector_, InjectKeyEvent(EqualsUsbEvent(3, false)));
+    EXPECT_CALL(*input_injector_, InjectKeyEvent(EqualsKeyEvent(3, true)));
+    EXPECT_CALL(*input_injector_,
+                InjectMouseEvent(EqualsMouseMoveEvent(300, 301)));
+    EXPECT_CALL(*input_injector_, InjectKeyEvent(EqualsKeyEvent(3, false)));
   }
 
   ConnectClientSession();
 
   // Wait for the first frame.
   run_loop.Run();
 
   // Inject test events that are expected to be injected.
   protocol::ClipboardEvent clipboard_event;
   clipboard_event.set_mime_type(kMimeTypeTextUtf8);
@@ skipping 91 matching lines @@
           InjectMouseEvent(connection_, mouse_event2),
           // Now this is a genuine local event.
           LocalMouseMoved(client_session_.get(), mouse_event1),
           // This one should be blocked because of the previous  local input
           // event.
           InjectMouseEvent(connection_, mouse_event3),
           // TODO(jamiewalch): Verify that remote inputs are re-enabled
           // eventually (via dependency injection, not sleep!)
           InvokeWithoutArgs(this, &ClientSessionTest::DisconnectClientSession),
           InvokeWithoutArgs(this, &ClientSessionTest::StopClientSession)));
-  EXPECT_CALL(*input_injector_, InjectMouseEvent(EqualsMouseEvent(100, 101)))
-      .InSequence(s);
-  EXPECT_CALL(*input_injector_, InjectMouseEvent(EqualsMouseEvent(200, 201)))
-      .InSequence(s);
-  EXPECT_CALL(session_event_handler_, OnSessionClosed(_))
-      .InSequence(s);
+  EXPECT_CALL(*input_injector_,
+              InjectMouseEvent(EqualsMouseMoveEvent(100, 101))).InSequence(s);
+  EXPECT_CALL(*input_injector_,
+              InjectMouseEvent(EqualsMouseMoveEvent(200, 201))).InSequence(s);
+  EXPECT_CALL(session_event_handler_, OnSessionClosed(_)).InSequence(s);
 
   ConnectClientSession();
 }
 
 TEST_F(ClientSessionTest, RestoreEventState) {
   CreateClientSession();
 
   protocol::KeyEvent key1;
   key1.set_pressed(true);
   key1.set_usb_keycode(1);
 
   protocol::KeyEvent key2;
   key2.set_pressed(true);
   key2.set_usb_keycode(2);
 
   protocol::MouseEvent mousedown;
   mousedown.set_button(protocol::MouseEvent::BUTTON_LEFT);
   mousedown.set_button_down(true);
 
   Expectation authenticated =
       EXPECT_CALL(session_event_handler_, OnSessionAuthenticated(_))
           .WillOnce(Return(true));
-  EXPECT_CALL(*input_injector_, StartPtr(_))
-      .After(authenticated);
+  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(
-          InjectKeyEvent(connection_, key1),
-          InjectKeyEvent(connection_, key2),
+          InjectKeyEvent(connection_, key1), InjectKeyEvent(connection_, key2),
           InjectMouseEvent(connection_, mousedown),
           InvokeWithoutArgs(this, &ClientSessionTest::DisconnectClientSession),
           InvokeWithoutArgs(this, &ClientSessionTest::StopClientSession)));
-  EXPECT_CALL(*input_injector_, InjectKeyEvent(EqualsUsbEvent(1, true)))
+  EXPECT_CALL(*input_injector_, InjectKeyEvent(EqualsKeyEvent(1, true)))
       .InSequence(s);
-  EXPECT_CALL(*input_injector_, InjectKeyEvent(EqualsUsbEvent(2, true)))
+  EXPECT_CALL(*input_injector_, InjectKeyEvent(EqualsKeyEvent(2, true)))
       .InSequence(s);
   EXPECT_CALL(*input_injector_, InjectMouseEvent(EqualsMouseButtonEvent(
       protocol::MouseEvent::BUTTON_LEFT, true)))
       .InSequence(s);
-  EXPECT_CALL(*input_injector_, InjectKeyEvent(EqualsUsbEvent(1, false)))
+  EXPECT_CALL(*input_injector_, InjectKeyEvent(EqualsKeyEvent(1, false)))
       .InSequence(s);
-  EXPECT_CALL(*input_injector_, InjectKeyEvent(EqualsUsbEvent(2, false)))
+  EXPECT_CALL(*input_injector_, InjectKeyEvent(EqualsKeyEvent(2, false)))
       .InSequence(s);
   EXPECT_CALL(*input_injector_, InjectMouseEvent(EqualsMouseButtonEvent(
       protocol::MouseEvent::BUTTON_LEFT, false)))
       .InSequence(s);
-  EXPECT_CALL(session_event_handler_, OnSessionClosed(_))
-      .InSequence(s);
+  EXPECT_CALL(session_event_handler_, OnSessionClosed(_)).InSequence(s);
 
   ConnectClientSession();
 }
 
 TEST_F(ClientSessionTest, ClampMouseEvents) {
   CreateClientSession();
 
   Expectation authenticated =
       EXPECT_CALL(session_event_handler_, OnSessionAuthenticated(_))
           .WillOnce(Return(true));
-  EXPECT_CALL(*input_injector_, StartPtr(_))
-      .After(authenticated);
+  EXPECT_CALL(*input_injector_, StartPtr(_)).After(authenticated);
   EXPECT_CALL(session_event_handler_, OnSessionChannelsConnected(_))
       .After(authenticated);
-  EXPECT_CALL(session_event_handler_, OnSessionClosed(_))
-      .After(authenticated);
+  EXPECT_CALL(session_event_handler_, OnSessionClosed(_)).After(authenticated);
 
   Expectation connected = authenticated;
 
   int input_x[3] = { -999, 100, 999 };
   int expected_x[3] = { 0, 100, FakeDesktopCapturer::kWidth - 1 };
   int input_y[3] = { -999, 50, 999 };
   int expected_y[3] = { 0, 50, FakeDesktopCapturer::kHeight - 1 };
 
   protocol::MouseEvent expected_event;
   for (int j = 0; j < 3; j++) {
     for (int i = 0; i < 3; i++) {
       protocol::MouseEvent injected_event;
       injected_event.set_x(input_x[i]);
       injected_event.set_y(input_y[j]);
 
       if (i == 0 && j == 0) {
         // Inject the 1st event once a video packet has been received.
         connected =
             EXPECT_CALL(video_stub_, ProcessVideoPacketPtr(_, _))
                 .After(connected)
                 .WillOnce(InjectMouseEvent(connection_, injected_event));
       } else {
         // Every next event is injected once the previous event has been
         // received.
         connected =
             EXPECT_CALL(*input_injector_,
-                        InjectMouseEvent(EqualsMouseEvent(expected_event.x(),
-                                                          expected_event.y())))
+                        InjectMouseEvent(EqualsMouseMoveEvent(
+                            expected_event.x(), expected_event.y())))
                 .After(connected)
                 .WillOnce(InjectMouseEvent(connection_, injected_event));
       }
 
       expected_event.set_x(expected_x[i]);
       expected_event.set_y(expected_y[j]);
     }
   }
 
   // Shutdown the connection once the last event has been received.
-  EXPECT_CALL(*input_injector_,
-              InjectMouseEvent(EqualsMouseEvent(expected_event.x(),
-                                                expected_event.y())))
+  EXPECT_CALL(*input_injector_, InjectMouseEvent(EqualsMouseMoveEvent(
+                                    expected_event.x(), expected_event.y())))
       .After(connected)
       .WillOnce(DoAll(
           InvokeWithoutArgs(this, &ClientSessionTest::DisconnectClientSession),
           InvokeWithoutArgs(this, &ClientSessionTest::StopClientSession)));
 
   ConnectClientSession();
 }
 
 TEST_F(ClientSessionTest, NoGnubbyAuth) {
   CreateClientSession();
 
   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)));
+          DeliverClientMessage(client_session_.get(), message),
+          InvokeWithoutArgs(this, &ClientSessionTest::DisconnectClientSession),
+          InvokeWithoutArgs(this, &ClientSessionTest::StopClientSession)));
   EXPECT_CALL(session_event_handler_, OnSessionClosed(_));
 
   ConnectClientSession();
 }
 
 TEST_F(ClientSessionTest, EnableGnubbyAuth) {
   CreateClientSession();
 
   // Lifetime controlled by object under test.
   MockGnubbyAuthHandler* gnubby_auth_handler = new MockGnubbyAuthHandler();
 
   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)));
+          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();
 }
 
 // Verifies that the client's video pipeline can be reset mid-session.
 TEST_F(ClientSessionTest, ResetVideoPipeline) {
   CreateClientSession();
 
@@ skipping 110 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