[Cast] Repurpose CastInitializationStatus for variable frame size support.

media/cast/sender/video_sender_unittest.cc

 // Copyright 2014 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 34 matching lines @@
 void CreateSharedMemory(
     size_t size, const ReceiveVideoEncodeMemoryCallback& callback) {
   scoped_ptr<base::SharedMemory> shm(new base::SharedMemory());
   if (!shm->CreateAndMapAnonymous(size)) {
     NOTREACHED();
     return;
   }
   callback.Run(shm.Pass());
 }
 
-void SaveInitializationStatus(CastInitializationStatus* out_status,
-                              CastInitializationStatus in_status) {
+void SaveOperationalStatus(OperationalStatus* out_status,
+                           OperationalStatus in_status) {
+  DVLOG(1) << "OperationalStatus transitioning from " << *out_status << " to "
+           << in_status;
   *out_status = in_status;
 }
 
 class TestPacketSender : public PacketSender {
  public:
   TestPacketSender()
       : number_of_rtp_packets_(0),
         number_of_rtcp_packets_(0),
         paused_(false) {}
 
@@ skipping 37 matching lines @@
   int number_of_rtcp_packets_;
   bool paused_;
   base::Closure callback_;
   PacketRef stored_packet_;
 
   DISALLOW_COPY_AND_ASSIGN(TestPacketSender);
 };
 
 void IgnorePlayoutDelayChanges(base::TimeDelta unused_playout_delay) {
 }
+
 class PeerVideoSender : public VideoSender {
  public:
   PeerVideoSender(
       scoped_refptr<CastEnvironment> cast_environment,
       const VideoSenderConfig& video_config,
-      const CastInitializationCallback& initialization_cb,
+      const StatusChangeCallback& status_change_cb,
       const CreateVideoEncodeAcceleratorCallback& create_vea_cb,
       const CreateVideoEncodeMemoryCallback& create_video_encode_mem_cb,
       CastTransportSender* const transport_sender)
       : VideoSender(cast_environment,
                     video_config,
-                    initialization_cb,
+                    status_change_cb,
                     create_vea_cb,
                     create_video_encode_mem_cb,
                     transport_sender,
                     base::Bind(&IgnorePlayoutDelayChanges)) {}
   using VideoSender::OnReceivedCastFeedback;
 };
 }  // namespace
 
 class VideoSenderTest : public ::testing::Test {
  protected:
   VideoSenderTest()
-      : stored_bitrates_(NULL) {
-    testing_clock_ = new base::SimpleTestTickClock();
+      : testing_clock_(new base::SimpleTestTickClock()),
+        task_runner_(new test::FakeSingleThreadTaskRunner(testing_clock_)),
+        cast_environment_(new CastEnvironment(
+            scoped_ptr<base::TickClock>(testing_clock_).Pass(),
+            task_runner_,
+            task_runner_,
+            task_runner_)),
+        operational_status_(STATUS_UNINITIALIZED),
+        stored_bitrates_(NULL) {
     testing_clock_->Advance(base::TimeTicks::Now() - base::TimeTicks());
-    task_runner_ = new test::FakeSingleThreadTaskRunner(testing_clock_);
-    cast_environment_ =
-        new CastEnvironment(scoped_ptr<base::TickClock>(testing_clock_).Pass(),
-                            task_runner_,
-                            task_runner_,
-                            task_runner_);
     last_pixel_value_ = kPixelValue;
     net::IPEndPoint dummy_endpoint;
     transport_sender_.reset(new CastTransportSenderImpl(
         NULL,
         testing_clock_,
         dummy_endpoint,
         dummy_endpoint,
         make_scoped_ptr(new base::DictionaryValue),
         base::Bind(&UpdateCastTransportStatus),
         BulkRawEventsCallback(),
         base::TimeDelta(),
         task_runner_,
         PacketReceiverCallback(),
         &transport_));
   }
 
   ~VideoSenderTest() override {}
 
   void TearDown() override {
     video_sender_.reset();
     task_runner_->RunTasks();
   }
 
   static void UpdateCastTransportStatus(CastTransportStatus status) {
     EXPECT_EQ(TRANSPORT_VIDEO_INITIALIZED, status);
   }
 
   // If |external| is true then external video encoder (VEA) is used.
   // |expect_init_sucess| is true if initialization is expected to succeed.
-  CastInitializationStatus InitEncoder(bool external,
-                                       bool expect_init_success) {
+  void InitEncoder(bool external, bool expect_init_success) {
     VideoSenderConfig video_config;
     video_config.ssrc = 1;
     video_config.receiver_ssrc = 2;
     video_config.rtp_payload_type = 127;
     video_config.use_external_encoder = external;
     video_config.width = kWidth;
     video_config.height = kHeight;
     video_config.max_bitrate = 5000000;
     video_config.min_bitrate = 1000000;
     video_config.start_bitrate = 1000000;
     video_config.max_qp = 56;
     video_config.min_qp = 0;
     video_config.max_frame_rate = 30;
     video_config.max_number_of_video_buffers_used = 1;
     video_config.codec = CODEC_VIDEO_VP8;
-    CastInitializationStatus status = STATUS_VIDEO_UNINITIALIZED;
+
+    ASSERT_EQ(operational_status_, STATUS_UNINITIALIZED);
 
     if (external) {
       media::FakeVideoEncodeAccelerator* fake_vea =
           new media::FakeVideoEncodeAccelerator(task_runner_);
       stored_bitrates_ = &fake_vea->stored_bitrates();
       fake_vea->SetWillInitializationSucceed(expect_init_success);
       scoped_ptr<VideoEncodeAccelerator> fake_vea_owner(fake_vea);
       video_sender_.reset(
           new PeerVideoSender(cast_environment_,
                               video_config,
-                              base::Bind(&SaveInitializationStatus,
-                                         &status),
+                              base::Bind(&SaveOperationalStatus,
+                                         &operational_status_),
                               base::Bind(&CreateVideoEncodeAccelerator,
                                          task_runner_,
                                          base::Passed(&fake_vea_owner)),
                               base::Bind(&CreateSharedMemory),
                               transport_sender_.get()));
     } else {
       video_sender_.reset(
           new PeerVideoSender(cast_environment_,
                               video_config,
-                              base::Bind(&SaveInitializationStatus,
-                                         &status),
+                              base::Bind(&SaveOperationalStatus,
+                                         &operational_status_),
                               CreateDefaultVideoEncodeAcceleratorCallback(),
                               CreateDefaultVideoEncodeMemoryCallback(),
                               transport_sender_.get()));
     }
     task_runner_->RunTasks();
-    return status;
   }
 
   scoped_refptr<media::VideoFrame> GetNewVideoFrame() {
     if (first_frame_timestamp_.is_null())
       first_frame_timestamp_ = testing_clock_->NowTicks();
     gfx::Size size(kWidth, kHeight);
     scoped_refptr<media::VideoFrame> video_frame =
         media::VideoFrame::CreateFrame(
             VideoFrame::I420, size, gfx::Rect(size), size,
             testing_clock_->NowTicks() - first_frame_timestamp_);
@@ skipping 10 matching lines @@
             VideoFrame::I420, size, gfx::Rect(size), size,
             testing_clock_->NowTicks() - first_frame_timestamp_);
     PopulateVideoFrameWithNoise(video_frame.get());
     return video_frame;
   }
 
   void RunTasks(int during_ms) {
     task_runner_->Sleep(base::TimeDelta::FromMilliseconds(during_ms));
   }
 
-  base::SimpleTestTickClock* testing_clock_;  // Owned by CastEnvironment.
+  base::SimpleTestTickClock* const testing_clock_;  // Owned by CastEnvironment.
+  const scoped_refptr<test::FakeSingleThreadTaskRunner> task_runner_;
+  const scoped_refptr<CastEnvironment> cast_environment_;
+  OperationalStatus operational_status_;
   TestPacketSender transport_;
   scoped_ptr<CastTransportSenderImpl> transport_sender_;
-  scoped_refptr<test::FakeSingleThreadTaskRunner> task_runner_;
   scoped_ptr<PeerVideoSender> video_sender_;
   const std::vector<uint32>* stored_bitrates_;  // Owned by |video_sender_|.
-  scoped_refptr<CastEnvironment> cast_environment_;
   int last_pixel_value_;
   base::TimeTicks first_frame_timestamp_;
 
   DISALLOW_COPY_AND_ASSIGN(VideoSenderTest);
 };
 
 TEST_F(VideoSenderTest, BuiltInEncoder) {
-  EXPECT_EQ(STATUS_VIDEO_INITIALIZED, InitEncoder(false, true));
+  InitEncoder(false, true);
+  ASSERT_EQ(STATUS_INITIALIZED, operational_status_);
+
   scoped_refptr<media::VideoFrame> video_frame = GetNewVideoFrame();
 
   const base::TimeTicks reference_time = testing_clock_->NowTicks();
   video_sender_->InsertRawVideoFrame(video_frame, reference_time);
 
   task_runner_->RunTasks();
   EXPECT_LE(1, transport_.number_of_rtp_packets());
   EXPECT_LE(1, transport_.number_of_rtcp_packets());
 }
 
 TEST_F(VideoSenderTest, ExternalEncoder) {
-  EXPECT_EQ(STATUS_VIDEO_INITIALIZED, InitEncoder(true, true));
+  InitEncoder(true, true);
+  ASSERT_EQ(STATUS_INITIALIZED, operational_status_);
 
   scoped_refptr<media::VideoFrame> video_frame = GetNewVideoFrame();
 
   const base::TimeTicks reference_time = testing_clock_->NowTicks();
   video_sender_->InsertRawVideoFrame(video_frame, reference_time);
   task_runner_->RunTasks();
   video_sender_->InsertRawVideoFrame(video_frame, reference_time);
   task_runner_->RunTasks();
   video_sender_->InsertRawVideoFrame(video_frame, reference_time);
   task_runner_->RunTasks();
 
   // Fixed bitrate is used for external encoder. Bitrate is only once
   // to the encoder.
   EXPECT_EQ(1u, stored_bitrates_->size());
   video_sender_.reset(NULL);
   task_runner_->RunTasks();
 }
 
 TEST_F(VideoSenderTest, ExternalEncoderInitFails) {
-  EXPECT_EQ(STATUS_HW_VIDEO_ENCODER_NOT_SUPPORTED,
-            InitEncoder(true, false));
+  InitEncoder(true, false);
+  EXPECT_EQ(STATUS_CODEC_INIT_FAILED, operational_status_);
+
   video_sender_.reset(NULL);
   task_runner_->RunTasks();
 }
 
 TEST_F(VideoSenderTest, RtcpTimer) {
-  EXPECT_EQ(STATUS_VIDEO_INITIALIZED, InitEncoder(false, true));
+  InitEncoder(false, true);
+  ASSERT_EQ(STATUS_INITIALIZED, operational_status_);
 
   scoped_refptr<media::VideoFrame> video_frame = GetNewVideoFrame();
 
   const base::TimeTicks reference_time = testing_clock_->NowTicks();
   video_sender_->InsertRawVideoFrame(video_frame, reference_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_LE(1, transport_.number_of_rtp_packets());
   EXPECT_LE(1, transport_.number_of_rtcp_packets());
   // 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_LE(1, transport_.number_of_rtcp_packets());
 }
 
 TEST_F(VideoSenderTest, ResendTimer) {
-  EXPECT_EQ(STATUS_VIDEO_INITIALIZED, InitEncoder(false, true));
+  InitEncoder(false, true);
+  ASSERT_EQ(STATUS_INITIALIZED, operational_status_);
 
   scoped_refptr<media::VideoFrame> video_frame = GetNewVideoFrame();
 
   const base::TimeTicks reference_time = testing_clock_->NowTicks();
   video_sender_->InsertRawVideoFrame(video_frame, reference_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, reference_time);
 
   base::TimeDelta max_resend_timeout =
       base::TimeDelta::FromMilliseconds(1 + kDefaultRtpMaxDelayMs);
 
   // Make sure that we do a re-send.
   RunTasks(max_resend_timeout.InMilliseconds());
   // Should have sent at least 3 packets.
   EXPECT_LE(
       3,
       transport_.number_of_rtp_packets() + transport_.number_of_rtcp_packets());
 }
 
 TEST_F(VideoSenderTest, LogAckReceivedEvent) {
-  EXPECT_EQ(STATUS_VIDEO_INITIALIZED, InitEncoder(false, true));
+  InitEncoder(false, true);
+  ASSERT_EQ(STATUS_INITIALIZED, operational_status_);
+
   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();
 
     const base::TimeTicks reference_time = testing_clock_->NowTicks();
     video_sender_->InsertRawVideoFrame(video_frame, reference_time);
     RunTasks(33);
@@ skipping 11 matching lines @@
 
   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) {
-  EXPECT_EQ(STATUS_VIDEO_INITIALIZED, InitEncoder(false, true));
+  InitEncoder(false, true);
+  ASSERT_EQ(STATUS_INITIALIZED, operational_status_);
+
   // Send a stream of frames and don't ACK; by default we shouldn't have more
   // than 4 frames in flight.
   scoped_refptr<media::VideoFrame> video_frame = GetNewVideoFrame();
   video_sender_->InsertRawVideoFrame(video_frame, testing_clock_->NowTicks());
   RunTasks(33);
 
   // Send 3 more frames and record the number of packets sent.
   for (int i = 0; i < 3; ++i) {
     scoped_refptr<media::VideoFrame> video_frame = GetNewVideoFrame();
     video_sender_->InsertRawVideoFrame(video_frame, testing_clock_->NowTicks());
@@ skipping 25 matching lines @@
 
   // Empty the pipeline.
   RunTasks(100);
   // Should have sent at least 7 packets.
   EXPECT_LE(
       7,
       transport_.number_of_rtp_packets() + transport_.number_of_rtcp_packets());
 }
 
 TEST_F(VideoSenderTest, DuplicateAckRetransmit) {
-  EXPECT_EQ(STATUS_VIDEO_INITIALIZED, InitEncoder(false, true));
+  InitEncoder(false, true);
+  ASSERT_EQ(STATUS_INITIALIZED, operational_status_);
+
   scoped_refptr<media::VideoFrame> video_frame = GetNewVideoFrame();
   video_sender_->InsertRawVideoFrame(video_frame, testing_clock_->NowTicks());
   RunTasks(33);
   RtcpCastMessage cast_feedback(1);
   cast_feedback.media_ssrc = 2;
   cast_feedback.ack_frame_id = 0;
 
   // Send 3 more frames but don't ACK.
   for (int i = 0; i < 3; ++i) {
     scoped_refptr<media::VideoFrame> video_frame = GetNewVideoFrame();
@@ skipping 19 matching lines @@
   for (int i = 0; i < 3; ++i) {
     RtcpCastMessage ack_feedback(1);
     ack_feedback.media_ssrc = 2;
     ack_feedback.ack_frame_id = 0;
     video_sender_->OnReceivedCastFeedback(ack_feedback);
   }
   EXPECT_EQ(number_of_packets_sent + 1, transport_.number_of_rtp_packets());
 }
 
 TEST_F(VideoSenderTest, DuplicateAckRetransmitDoesNotCancelRetransmits) {
-  EXPECT_EQ(STATUS_VIDEO_INITIALIZED, InitEncoder(false, true));
+  InitEncoder(false, true);
+  ASSERT_EQ(STATUS_INITIALIZED, operational_status_);
+
   scoped_refptr<media::VideoFrame> video_frame = GetNewVideoFrame();
   video_sender_->InsertRawVideoFrame(video_frame, testing_clock_->NowTicks());
   RunTasks(33);
   RtcpCastMessage cast_feedback(1);
   cast_feedback.media_ssrc = 2;
   cast_feedback.ack_frame_id = 0;
 
   // Send 2 more frames but don't ACK.
   for (int i = 0; i < 2; ++i) {
     scoped_refptr<media::VideoFrame> video_frame = GetNewVideoFrame();
@@ skipping 30 matching lines @@
     ack_feedback.ack_frame_id = 0;
     video_sender_->OnReceivedCastFeedback(ack_feedback);
   }
 
   transport_.SetPause(false);
   RunTasks(100);
   EXPECT_LT(number_of_packets_sent + 1, transport_.number_of_rtp_packets());
 }
 
 TEST_F(VideoSenderTest, AcksCancelRetransmits) {
-  EXPECT_EQ(STATUS_VIDEO_INITIALIZED, InitEncoder(false, true));
+  InitEncoder(false, true);
+  ASSERT_EQ(STATUS_INITIALIZED, operational_status_);
+
   transport_.SetPause(true);
   scoped_refptr<media::VideoFrame> video_frame = GetLargeNewVideoFrame();
   video_sender_->InsertRawVideoFrame(video_frame, testing_clock_->NowTicks());
   RunTasks(33);
 
   // Frame should be in buffer, waiting. Now let's ack it.
   RtcpCastMessage cast_feedback(1);
   cast_feedback.media_ssrc = 2;
   cast_feedback.ack_frame_id = 0;
   video_sender_->OnReceivedCastFeedback(cast_feedback);
 
   transport_.SetPause(false);
   RunTasks(33);
   EXPECT_EQ(0, transport_.number_of_rtp_packets());
 }
 
 TEST_F(VideoSenderTest, CheckVideoFrameFactoryIsNull) {
-  EXPECT_EQ(STATUS_VIDEO_INITIALIZED, InitEncoder(false, true));
+  InitEncoder(false, true);
+  ASSERT_EQ(STATUS_INITIALIZED, operational_status_);
+
   EXPECT_EQ(nullptr, video_sender_->CreateVideoFrameFactory().get());
 }
 
 }  // namespace cast
 }  // namespace media