Implement video frame acknowledgements in the chromoting protocol.

remoting/host/video_scheduler_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 "remoting/host/video_scheduler.h"
 
 #include "base/bind.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "remoting/base/auto_thread.h"
 #include "remoting/base/auto_thread_task_runner.h"
 #include "remoting/codec/video_encoder.h"
 #include "remoting/codec/video_encoder_verbatim.h"
 #include "remoting/host/fake_desktop_capturer.h"
 #include "remoting/host/fake_mouse_cursor_monitor.h"
 #include "remoting/host/host_mock_objects.h"
 #include "remoting/proto/control.pb.h"
 #include "remoting/proto/video.pb.h"
 #include "remoting/protocol/protocol_mock_objects.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/webrtc/modules/desktop_capture/desktop_frame.h"
 #include "third_party/webrtc/modules/desktop_capture/mouse_cursor.h"
 #include "third_party/webrtc/modules/desktop_capture/screen_capturer_mock_objects.h"
 
 using ::remoting::protocol::MockClientStub;
-using ::remoting::protocol::MockVideoStub;
+using ::remoting::protocol::MockVideoSender;
 
 using ::testing::_;
 using ::testing::AtLeast;
 using ::testing::AnyNumber;
 using ::testing::DeleteArg;
 using ::testing::DoAll;
 using ::testing::Expectation;
 using ::testing::InSequence;
 using ::testing::InvokeWithoutArgs;
 using ::testing::Return;
@@ skipping 110 matching lines @@
 
  protected:
   base::MessageLoop message_loop_;
   base::RunLoop run_loop_;
   scoped_refptr<AutoThreadTaskRunner> capture_task_runner_;
   scoped_refptr<AutoThreadTaskRunner> encode_task_runner_;
   scoped_refptr<AutoThreadTaskRunner> main_task_runner_;
   scoped_refptr<VideoScheduler> scheduler_;
 
   MockClientStub client_stub_;
-  MockVideoStub video_stub_;
+  MockVideoSender video_sender_;
 
   // Points to the callback passed to webrtc::DesktopCapturer::Start().
   webrtc::DesktopCapturer::Callback* capturer_callback_;
 
   // Points to the callback passed to webrtc::MouseCursor::Init().
   webrtc::MouseCursorMonitor::Callback* mouse_monitor_callback_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(VideoSchedulerTest);
 };
@@ skipping 25 matching lines @@
     scoped_ptr<VideoEncoder> encoder,
     scoped_ptr<webrtc::MouseCursorMonitor> mouse_monitor) {
   scheduler_ = new VideoScheduler(
       capture_task_runner_,
       encode_task_runner_,
       main_task_runner_,
       capturer.Pass(),
       mouse_monitor.Pass(),
       encoder.Pass(),
       &client_stub_,
-      &video_stub_);
+      &video_sender_);
   scheduler_->Start();
 }
 
 void VideoSchedulerTest::StopVideoScheduler() {
   scheduler_->Stop();
   scheduler_ = nullptr;
 }
 
 void VideoSchedulerTest::OnCapturerStart(
     webrtc::DesktopCapturer::Callback* callback) {
@@ skipping 77 matching lines @@
       .After(capturer_start)
       .WillRepeatedly(Invoke(this, &VideoSchedulerTest::OnCaptureFrame));
 
   scoped_ptr<MockVideoEncoder> encoder(new MockVideoEncoder());
 
   // Expect the encoder be called.
   EXPECT_CALL(*encoder, EncodePtr(_))
       .WillRepeatedly(FinishEncode());
 
   // By default delete the arguments when ProcessVideoPacket is received.
-  EXPECT_CALL(video_stub_, ProcessVideoPacketPtr(_, _))
+  EXPECT_CALL(video_sender_, ProcessVideoPacketPtr(_, _))
       .WillRepeatedly(FinishSend());
 
   // When the first ProcessVideoPacket is received we stop the VideoScheduler.
-  EXPECT_CALL(video_stub_, ProcessVideoPacketPtr(_, _))
+  EXPECT_CALL(video_sender_, ProcessVideoPacketPtr(_, _))
       .WillOnce(DoAll(
           FinishSend(),
           InvokeWithoutArgs(this, &VideoSchedulerTest::StopVideoScheduler)))
       .RetiresOnSaturation();
 
   EXPECT_CALL(client_stub_, SetCursorShape(_))
       .WillOnce(Invoke(this, &VideoSchedulerTest::SetCursorShape));
 
   // Start video frame capture.
   scoped_ptr<webrtc::MouseCursorMonitor> mouse_cursor_monitor(
@@ skipping 20 matching lines @@
       new ThreadCheckMouseCursorMonitor(capture_task_runner_));
 
   // Start and stop the scheduler, so it will tear down the screen capturer,
   // video encoder and mouse monitor.
   StartVideoScheduler(capturer.Pass(), encoder.Pass(),
                       mouse_cursor_monitor.Pass());
   StopVideoScheduler();
 }
 
 }  // namespace remoting