Implement video frame acknowledgements in the chromoting protocol.

remoting/host/chromoting_host_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/bind.h"
 #include "base/bind_helpers.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "remoting/base/auto_thread_task_runner.h"
 #include "remoting/host/audio_capturer.h"
@@ skipping 10 matching lines @@
 #include "remoting/signaling/mock_signal_strategy.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gmock_mutant.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using ::remoting::protocol::MockClientStub;
 using ::remoting::protocol::MockConnectionToClient;
 using ::remoting::protocol::MockConnectionToClientEventHandler;
 using ::remoting::protocol::MockHostStub;
 using ::remoting::protocol::MockSession;
-using ::remoting::protocol::MockVideoStub;
+using ::remoting::protocol::MockVideoSender;
 using ::remoting::protocol::Session;
 using ::remoting::protocol::SessionConfig;
 
 using testing::_;
 using testing::AnyNumber;
 using testing::AtLeast;
 using testing::AtMost;
 using testing::CreateFunctor;
 using testing::DeleteArg;
 using testing::DoAll;
@@ skipping 94 matching lines @@
     EXPECT_CALL(*session2_, config())
         .WillRepeatedly(ReturnRef(session_config2_));
 
     owned_connection1_.reset(new MockConnectionToClient(session1_,
                                                         &host_stub1_));
     connection1_ = owned_connection1_.get();
     owned_connection2_.reset(new MockConnectionToClient(session2_,
                                                         &host_stub2_));
     connection2_ = owned_connection2_.get();
 
-    ON_CALL(video_stub1_, ProcessVideoPacketPtr(_, _))
+    ON_CALL(video_sender1_, ProcessVideoPacketPtr(_, _))
         .WillByDefault(DeleteArg<0>());
-    ON_CALL(video_stub2_, ProcessVideoPacketPtr(_, _))
+    ON_CALL(video_sender2_, ProcessVideoPacketPtr(_, _))
         .WillByDefault(DeleteArg<0>());
-    ON_CALL(*connection1_, video_stub())
-        .WillByDefault(Return(&video_stub1_));
+    ON_CALL(*connection1_, video_sender())
+        .WillByDefault(Return(&video_sender1_));
     ON_CALL(*connection1_, client_stub())
         .WillByDefault(Return(&client_stub1_));
     ON_CALL(*connection1_, session())
         .WillByDefault(Return(session1_));
-    ON_CALL(*connection2_, video_stub())
-        .WillByDefault(Return(&video_stub2_));
+    ON_CALL(*connection2_, video_sender())
+        .WillByDefault(Return(&video_sender2_));
     ON_CALL(*connection2_, client_stub())
         .WillByDefault(Return(&client_stub2_));
     ON_CALL(*connection2_, session())
         .WillByDefault(Return(session2_));
-    EXPECT_CALL(*connection1_, video_stub())
+    EXPECT_CALL(*connection1_, video_sender())
         .Times(AnyNumber());
     EXPECT_CALL(*connection1_, client_stub())
         .Times(AnyNumber());
     EXPECT_CALL(*connection1_, session())
         .Times(AnyNumber());
-    EXPECT_CALL(*connection2_, video_stub())
+    EXPECT_CALL(*connection2_, video_sender())
         .Times(AnyNumber());
     EXPECT_CALL(*connection2_, client_stub())
         .Times(AnyNumber());
     EXPECT_CALL(*connection2_, session())
         .Times(AnyNumber());
 
     empty_candidate_config_ =
         protocol::CandidateSessionConfig::CreateEmpty();
     default_candidate_config_ =
         protocol::CandidateSessionConfig::CreateDefault();
@@ skipping 158 matching lines @@
     return EXPECT_CALL(*session_manager_, Init(_, host_.get()));
   }
 
   // Expect a client to connect.
   // Return an expectation that a session has started, and that the first
   // video packet has been sent to the client.
   // Do |action| when that happens.
   template <class A>
   Expectation ExpectClientConnected(int connection_index, A action) {
     const std::string& session_jid = get_session_jid(connection_index);
-    MockVideoStub& video_stub = get_video_stub(connection_index);
+    MockVideoSender& video_sender = get_video_sender(connection_index);
 
     Expectation client_authenticated =
         EXPECT_CALL(host_status_observer_, OnClientAuthenticated(session_jid));
     EXPECT_CALL(host_status_observer_, OnClientConnected(session_jid))
         .After(client_authenticated);
     Expectation video_packet_sent =
-        EXPECT_CALL(video_stub, ProcessVideoPacketPtr(_, _))
+        EXPECT_CALL(video_sender, ProcessVideoPacketPtr(_, _))
         .After(client_authenticated)
         .WillOnce(DoAll(
             action,
             RunDoneTask()))
         .RetiresOnSaturation();
-    EXPECT_CALL(video_stub, ProcessVideoPacketPtr(_, _))
+    EXPECT_CALL(video_sender, ProcessVideoPacketPtr(_, _))
         .Times(AnyNumber())
         .After(video_packet_sent)
         .WillRepeatedly(RunDoneTask());
     return video_packet_sent;
   }
 
   // Return an expectation that a client will disconnect after a given
   // expectation. The given action will be done after the event executor is
   // notified that the session has finished.
   template <class A>
@@ skipping 44 matching lines @@
   scoped_ptr<ChromotingHost> host_;
   MockHostStatusObserver host_status_observer_;
   protocol::MockSessionManager* session_manager_;
   std::string xmpp_login_;
   MockConnectionToClient* connection1_;
   scoped_ptr<MockConnectionToClient> owned_connection1_;
   ClientSession* client1_;
   std::string session_jid1_;
   MockSession* session1_;  // Owned by |connection_|.
   SessionConfig session_config1_;
-  MockVideoStub video_stub1_;
+  MockVideoSender video_sender1_;
   MockClientStub client_stub1_;
   MockHostStub host_stub1_;
   MockConnectionToClient* connection2_;
   scoped_ptr<MockConnectionToClient> owned_connection2_;
   ClientSession* client2_;
   std::string session_jid2_;
   MockSession* session2_;  // Owned by |connection2_|.
   SessionConfig session_config2_;
-  MockVideoStub video_stub2_;
+  MockVideoSender video_sender2_;
   MockClientStub client_stub2_;
   MockHostStub host_stub2_;
   scoped_ptr<MockSession> session_unowned1_;  // Not owned by a connection.
   SessionConfig session_unowned_config1_;
   std::string session_unowned_jid1_;
   scoped_ptr<MockSession> session_unowned2_;  // Not owned by a connection.
   SessionConfig session_unowned_config2_;
   std::string session_unowned_jid2_;
   protocol::Session::EventHandler* session_unowned1_event_handler_;
   protocol::Session::EventHandler* session_unowned2_event_handler_;
@@ skipping 11 matching lines @@
 
   // Returns the list of clients of the host_.
   std::list<ClientSession*>& get_clients_from_host() {
     return host_->clients_;
   }
 
   const std::string& get_session_jid(int connection_index) {
     return (connection_index == 0) ? session_jid1_ : session_jid2_;
   }
 
-  MockVideoStub& get_video_stub(int connection_index) {
-    return (connection_index == 0) ? video_stub1_ : video_stub2_;
+  MockVideoSender& get_video_sender(int connection_index) {
+    return (connection_index == 0) ? video_sender1_ : video_sender2_;
   }
 };
 
 TEST_F(ChromotingHostTest, StartAndShutdown) {
   Expectation start = ExpectHostAndSessionManagerStart();
   EXPECT_CALL(host_status_observer_, OnShutdown()).After(start);
 
   host_->Start(xmpp_login_);
   ShutdownHost();
   message_loop_.Run();
@@ skipping 233 matching lines @@
   ExpectClientDisconnected(0, true, video_packet_sent,
       InvokeWithoutArgs(this, &ChromotingHostTest::ShutdownHost));
   EXPECT_CALL(host_status_observer_, OnShutdown());
 
   host_->Start(xmpp_login_);
   SimulateClientConnection(0, true, false);
   message_loop_.Run();
 }
 
 }  // namespace remoting