Simplify It2Me host shutdown

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 312 matching lines @@
       .WillOnce(Invoke(client_session_.get(), &ClientSession::SetCapabilities));
 }
 
 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));
+      EXPECT_CALL(session_event_handler_, OnSessionAuthenticated(_));
   EXPECT_CALL(session_event_handler_, OnSessionChannelsConnected(_))
       .After(authenticated)
       .WillOnce(DoAll(
           DeliverClientMessage(client_session_.get(), message),
           InvokeWithoutArgs(this, &ClientSessionTest::DisconnectClientSession),
           InvokeWithoutArgs(this, &ClientSessionTest::StopClientSession)));
 }
 
 TEST_F(ClientSessionTest, ClipboardStubFilter) {
   CreateClientSession();
 
-  EXPECT_CALL(session_event_handler_, OnSessionAuthenticated(_))
-      .WillOnce(Return(true));
+  EXPECT_CALL(session_event_handler_, OnSessionAuthenticated(_));
   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));
@@ skipping 84 matching lines @@
   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(session_event_handler_, OnSessionAuthenticated(_));
   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(_, _))
@@ skipping 35 matching lines @@
 
   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(session_event_handler_, OnSessionAuthenticated(_));
   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)
@@ skipping 19 matching lines @@
       .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(session_event_handler_, OnSessionAuthenticated(_));
   EXPECT_CALL(*input_injector_, StartPtr(_)).After(authenticated);
   EXPECT_CALL(session_event_handler_, OnSessionChannelsConnected(_))
       .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, protocol::FakeDesktopCapturer::kWidth - 1 };
   int input_y[3] = { -999, 50, 999 };
@@ skipping 40 matching lines @@
 }
 
 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(session_event_handler_, OnSessionAuthenticated(_));
   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();
 }
 
 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(session_event_handler_, OnSessionAuthenticated(_));
   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();
 }
 
 // Verifies that the client's video pipeline can be reset mid-session.
 TEST_F(ClientSessionTest, ResetVideoPipeline) {
   CreateClientSession();
 
-  EXPECT_CALL(session_event_handler_, OnSessionAuthenticated(_))
-      .WillOnce(Return(true));
+  EXPECT_CALL(session_event_handler_, OnSessionAuthenticated(_));
 
   EXPECT_CALL(video_stub_, ProcessVideoPacketPtr(_, _))
       .WillOnce(DoAll(
           InvokeWithoutArgs(this, &ClientSessionTest::DisconnectClientSession),
           InvokeWithoutArgs(this, &ClientSessionTest::StopClientSession)));
 
   ConnectClientSession();
 
   client_session_->ResetVideoPipeline();
 }
@@ skipping 10 matching lines @@
   extensions_.push_back(&extension2);
   FakeExtension extension3("ext3", "cap3");
   extensions_.push_back(&extension3);
 
   // Set the second extension to request to modify the video pipeline.
   extension2.set_steal_video_capturer(true);
 
   CreateClientSession();
 
   Expectation authenticated =
-      EXPECT_CALL(session_event_handler_, OnSessionAuthenticated(_))
-          .WillOnce(Return(true));
+      EXPECT_CALL(session_event_handler_, OnSessionAuthenticated(_));
 
   // Verify that the ClientSession reports the correct capabilities, and mimic
   // the client reporting an overlapping set of capabilities.
   EXPECT_CALL(client_stub_,
               SetCapabilities(EqCapabilities("cap1 cap3 default")))
       .After(authenticated)
       .WillOnce(SetCapabilities(client_session_.get(), "cap1 cap4 default"));
 
   // Verify that the correct extension messages are delivered, and dropped.
   protocol::ExtensionMessage message1;
@@ skipping 34 matching lines @@
 // Verifies that an extension can "steal" the video capture, in which case no
 // VideoFramePump is instantiated.
 TEST_F(ClientSessionTest, StealVideoCapturer) {
   FakeExtension extension("ext1", "cap1");
   extensions_.push_back(&extension);
 
   CreateClientSession();
 
   SetMatchCapabilitiesExpectation();
 
-  EXPECT_CALL(session_event_handler_, OnSessionAuthenticated(_))
-      .WillOnce(Return(true));
+  EXPECT_CALL(session_event_handler_, OnSessionAuthenticated(_));
 
   ConnectClientSession();
 
   base::RunLoop().RunUntilIdle();
 
   extension.set_steal_video_capturer(true);
   client_session_->ResetVideoPipeline();
 
   base::RunLoop().RunUntilIdle();
 
@@ skipping 10 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