[Cast] EncodedAudioFrame+EncodedVideoFrame+reference_time --> EncodedFrame

media/cast/video_sender/video_sender_unittest.cc

 // Copyright 2013 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 <stdint.h>
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 192 matching lines @@
   scoped_ptr<PeerVideoSender> video_sender_;
   scoped_refptr<CastEnvironment> cast_environment_;
 
   DISALLOW_COPY_AND_ASSIGN(VideoSenderTest);
 };
 
 TEST_F(VideoSenderTest, BuiltInEncoder) {
   InitEncoder(false);
   scoped_refptr<media::VideoFrame> video_frame = GetNewVideoFrame();
 
-  base::TimeTicks capture_time;
+  const base::TimeTicks capture_time = testing_clock_->NowTicks();
   video_sender_->InsertRawVideoFrame(video_frame, capture_time);
 
   task_runner_->RunTasks();
   EXPECT_GE(
       transport_.number_of_rtp_packets() + transport_.number_of_rtcp_packets(),
       1);
 }
 
 TEST_F(VideoSenderTest, ExternalEncoder) {
   InitEncoder(true);
   task_runner_->RunTasks();
 
   scoped_refptr<media::VideoFrame> video_frame = GetNewVideoFrame();
 
-  base::TimeTicks capture_time;
+  const base::TimeTicks capture_time = testing_clock_->NowTicks();
   video_sender_->InsertRawVideoFrame(video_frame, capture_time);
 
   task_runner_->RunTasks();
 
   // We need to run the task to cleanup the GPU instance.
   video_sender_.reset(NULL);
   task_runner_->RunTasks();
 }
 
 TEST_F(VideoSenderTest, RtcpTimer) {
   InitEncoder(false);
 
   scoped_refptr<media::VideoFrame> video_frame = GetNewVideoFrame();
 
-  base::TimeTicks capture_time = testing_clock_->NowTicks();
+  const base::TimeTicks capture_time = testing_clock_->NowTicks();
   video_sender_->InsertRawVideoFrame(video_frame, capture_time);
 
   // Make sure that we send at least one RTCP packet.
   base::TimeDelta max_rtcp_timeout =
       base::TimeDelta::FromMilliseconds(1 + kDefaultRtcpIntervalMs * 3 / 2);
 
   RunTasks(max_rtcp_timeout.InMilliseconds());
   EXPECT_GE(transport_.number_of_rtp_packets(), 1);
   // Don't send RTCP prior to receiving an ACK.
   EXPECT_GE(transport_.number_of_rtcp_packets(), 0);
   // Build Cast msg and expect RTCP packet.
   RtcpCastMessage cast_feedback(1);
   cast_feedback.media_ssrc_ = 2;
   cast_feedback.ack_frame_id_ = 0;
   video_sender_->OnReceivedCastFeedback(cast_feedback);
   RunTasks(max_rtcp_timeout.InMilliseconds());
   EXPECT_GE(transport_.number_of_rtcp_packets(), 1);
 }
 
 TEST_F(VideoSenderTest, ResendTimer) {
   InitEncoder(false);
 
   scoped_refptr<media::VideoFrame> video_frame = GetNewVideoFrame();
 
-  base::TimeTicks capture_time;
+  const base::TimeTicks capture_time = testing_clock_->NowTicks();
   video_sender_->InsertRawVideoFrame(video_frame, capture_time);
 
   // ACK the key frame.
   RtcpCastMessage cast_feedback(1);
   cast_feedback.media_ssrc_ = 2;
   cast_feedback.ack_frame_id_ = 0;
   video_sender_->OnReceivedCastFeedback(cast_feedback);
 
   video_frame = GetNewVideoFrame();
   video_sender_->InsertRawVideoFrame(video_frame, capture_time);
@@ skipping 11 matching lines @@
 
 TEST_F(VideoSenderTest, LogAckReceivedEvent) {
   InitEncoder(false);
   SimpleEventSubscriber event_subscriber;
   cast_environment_->Logging()->AddRawEventSubscriber(&event_subscriber);
 
   int num_frames = 10;
   for (int i = 0; i < num_frames; i++) {
     scoped_refptr<media::VideoFrame> video_frame = GetNewVideoFrame();
 
-    base::TimeTicks capture_time;
+    const base::TimeTicks capture_time = testing_clock_->NowTicks();
     video_sender_->InsertRawVideoFrame(video_frame, capture_time);
     RunTasks(33);
   }
 
   task_runner_->RunTasks();
 
   RtcpCastMessage cast_feedback(1);
   cast_feedback.ack_frame_id_ = num_frames - 1;
 
   video_sender_->OnReceivedCastFeedback(cast_feedback);
 
   std::vector<FrameEvent> frame_events;
   event_subscriber.GetFrameEventsAndReset(&frame_events);
 
   ASSERT_TRUE(!frame_events.empty());
   EXPECT_EQ(FRAME_ACK_RECEIVED, frame_events.rbegin()->type);
   EXPECT_EQ(VIDEO_EVENT, frame_events.rbegin()->media_type);
   EXPECT_EQ(num_frames - 1u, frame_events.rbegin()->frame_id);
 
   cast_environment_->Logging()->RemoveRawEventSubscriber(&event_subscriber);
 }
 
 TEST_F(VideoSenderTest, StopSendingIntheAbsenceOfAck) {
   InitEncoder(false);
   // Send a stream of frames and don't ACK; by default we shouldn't have more
   // than 4 frames in flight.
   // Store size in packets of frame 0, as it should be resent sue to timeout.
   scoped_refptr<media::VideoFrame> video_frame = GetNewVideoFrame();
-  base::TimeTicks capture_time;
-  video_sender_->InsertRawVideoFrame(video_frame, capture_time);
+  video_sender_->InsertRawVideoFrame(video_frame, testing_clock_->NowTicks());
   RunTasks(33);
   const int size_of_frame0 = transport_.number_of_rtp_packets();
 
   for (int i = 1; i < 4; ++i) {
     scoped_refptr<media::VideoFrame> video_frame = GetNewVideoFrame();
-    base::TimeTicks capture_time;
-    video_sender_->InsertRawVideoFrame(video_frame, capture_time);
+    video_sender_->InsertRawVideoFrame(video_frame, testing_clock_->NowTicks());
     RunTasks(33);
   }
 
   const int number_of_packets_sent = transport_.number_of_rtp_packets();
   // Send 4 more frames - they should not be sent to the transport, as we have
   // received any acks.
   for (int i = 0; i < 3; ++i) {
     scoped_refptr<media::VideoFrame> video_frame = GetNewVideoFrame();
-    base::TimeTicks capture_time;
-    video_sender_->InsertRawVideoFrame(video_frame, capture_time);
+    video_sender_->InsertRawVideoFrame(video_frame, testing_clock_->NowTicks());
     RunTasks(33);
   }
 
   EXPECT_EQ(number_of_packets_sent + size_of_frame0,
             transport_.number_of_rtp_packets());
 
   // Start acking and make sure we're back to steady-state.
   RtcpCastMessage cast_feedback(1);
   cast_feedback.media_ssrc_ = 2;
   cast_feedback.ack_frame_id_ = 0;
   video_sender_->OnReceivedCastFeedback(cast_feedback);
   EXPECT_GE(
       transport_.number_of_rtp_packets() + transport_.number_of_rtcp_packets(),
       4);
 
   // Empty the pipeline.
   RunTasks(100);
   // Should have sent at least 7 packets.
   EXPECT_GE(
       transport_.number_of_rtp_packets() + transport_.number_of_rtcp_packets(),
       7);
 }
 
 }  // namespace cast
 }  // namespace media