Implement video frame acknowledgements in the chromoting protocol.

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 18 matching lines @@
 #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::MockVideoSender;
 using protocol::SessionConfig;
 
 using testing::_;
 using testing::AnyNumber;
 using testing::AtMost;
 using testing::CreateFunctor;
 using testing::DeleteArg;
 using testing::DoAll;
 using testing::Expectation;
 using testing::Invoke;
@@ skipping 133 matching lines @@
 
   // ClientSession::EventHandler mock for use in tests.
   MockClientSessionEventHandler session_event_handler_;
 
   // Storage for values to be returned by the protocol::Session mock.
   SessionConfig session_config_;
   const std::string client_jid_;
 
   // Stubs returned to |client_session_| components by |connection_|.
   MockClientStub client_stub_;
-  MockVideoStub video_stub_;
+  MockVideoSender video_sender_;
 
   // DesktopEnvironment owns |input_injector_|, but input injection tests need
   // to express expectations on it.
   scoped_ptr<MockInputInjector> input_injector_;
 
   // ClientSession owns |connection_| but tests need it to inject fake events.
   MockConnectionToClient* connection_;
 
   scoped_ptr<MockDesktopEnvironmentFactory> desktop_environment_factory_;
 };
@@ skipping 31 matching lines @@
   EXPECT_CALL(*session, jid()).WillRepeatedly(ReturnRef(client_jid_));
   EXPECT_CALL(*session, SetEventHandler(_));
 
   // Mock protocol::ConnectionToClient APIs called directly by ClientSession.
   // HostStub is not touched by ClientSession, so we can safely pass nullptr.
   scoped_ptr<MockConnectionToClient> connection(
       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, video_sender())
+      .WillRepeatedly(Return(&video_sender_));
   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.
@@ skipping 107 matching lines @@
           .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(_, _))
+  EXPECT_CALL(video_sender_, 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)));
@@ skipping 46 matching lines @@
           .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(_, _))
+  EXPECT_CALL(video_sender_, 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.
@@ skipping 35 matching lines @@
           .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(_, _))
+  EXPECT_CALL(video_sender_, ProcessVideoPacketPtr(_, _))
       .InSequence(s)
       .After(authenticated)
       .WillOnce(DoAll(
           // This event should get through to the input stub.
           InjectMouseEvent(connection_, mouse_event1),
 #if !defined(OS_WIN)
           // The OS echoes the injected event back.
           LocalMouseMoved(client_session_.get(), mouse_event1),
 #endif  // !defined(OS_WIN)
           // This one should get throught as well.
@@ skipping 37 matching lines @@
           .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(_, _))
+  EXPECT_CALL(video_sender_, ProcessVideoPacketPtr(_, _))
       .InSequence(s)
       .After(authenticated)
       .WillOnce(DoAll(
           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)))
       .InSequence(s);
@@ skipping 38 matching lines @@
   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(_, _))
+            EXPECT_CALL(video_sender_, 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())))
                 .After(connected)
@@ skipping 67 matching lines @@
   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(video_stub_, ProcessVideoPacketPtr(_, _))
+  EXPECT_CALL(video_sender_, ProcessVideoPacketPtr(_, _))
       .WillOnce(DoAll(
           InvokeWithoutArgs(this, &ClientSessionTest::DisconnectClientSession),
           InvokeWithoutArgs(this, &ClientSessionTest::StopClientSession)));
 
   ConnectClientSession();
 
   client_session_->ResetVideoPipeline();
 }
 
 // Verifies that clients can have extensions registered, resulting in the
@@ skipping 96 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