Cast: Refactoring Cast API's

media/cast/test/end2end_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.
 //
 // This test generate synthetic data. For audio it's a sinusoid waveform with
 // frequency kSoundFrequency and different amplitudes. For video it's a pattern
 // that is shifting by one pixel per frame, each pixels neighbors right and down
 // is this pixels value +1, since the pixel value is 8 bit it will wrap
 // frequently within the image. Visually this will create diagonally color bands
 // that moves across the screen
@@ skipping 77 matching lines @@
 // Dummy callback function that does nothing except to accept ownership of
 // |audio_bus| for destruction.
 void OwnThatAudioBus(scoped_ptr<AudioBus> audio_bus) {}
 
 void UpdateCastTransportStatus(transport::CastTransportStatus status) {
   bool result = (status == transport::TRANSPORT_AUDIO_INITIALIZED ||
                  status == transport::TRANSPORT_VIDEO_INITIALIZED);
   EXPECT_TRUE(result);
 }
 
+void AudioInitializationStatus(CastInitializationStatus status) {
+  EXPECT_EQ(STATUS_AUDIO_INITIALIZED, status);
+}
+
+void VideoInitializationStatus(CastInitializationStatus status) {
+  EXPECT_EQ(STATUS_VIDEO_INITIALIZED, status);
+}
+
 // This is wrapped in a struct because it needs to be put into a std::map.
 typedef struct {
   int counter[kNumOfLoggingEvents];
 } LoggingEventCounts;
 
 // Constructs a map from each frame (RTP timestamp) to counts of each event
 // type logged for that frame.
 std::map<RtpTimestamp, LoggingEventCounts> GetEventCountForFrameEvents(
     const std::vector<FrameEvent>& frame_events) {
   std::map<RtpTimestamp, LoggingEventCounts> event_counter_for_frame;
@@ skipping 281 matching lines @@
 };
 
 // The actual test class, generate synthetic data for both audio and video and
 // send those through the sender and receiver and analyzes the result.
 class End2EndTest : public ::testing::Test {
  protected:
   End2EndTest()
       : start_time_(),
         testing_clock_sender_(new base::SimpleTestTickClock()),
         testing_clock_receiver_(new base::SimpleTestTickClock()),
-        task_runner_(new test::FakeSingleThreadTaskRunner(
-            testing_clock_sender_)),
+        task_runner_(
+            new test::FakeSingleThreadTaskRunner(testing_clock_sender_)),
         logging_config_(GetLoggingConfigWithRawEventsAndStatsEnabled()),
         cast_environment_sender_(new CastEnvironment(
             scoped_ptr<base::TickClock>(testing_clock_sender_).Pass(),
             task_runner_,
             task_runner_,
             task_runner_,
             task_runner_,
             task_runner_,
             task_runner_,
             logging_config_)),
@@ skipping 74 matching lines @@
     transport_audio_config_.codec = audio_sender_config_.codec;
     transport_audio_config_.base.rtp_config = audio_sender_config_.rtp_config;
     transport_audio_config_.frequency = audio_sender_config_.frequency;
     transport_audio_config_.channels = audio_sender_config_.channels;
     transport_video_config_.base.ssrc = video_sender_config_.sender_ssrc;
     transport_video_config_.codec = video_sender_config_.codec;
     transport_video_config_.base.rtp_config = video_sender_config_.rtp_config;
   }
 
   void Create() {
-    cast_receiver_.reset(
-        CastReceiver::CreateCastReceiver(cast_environment_receiver_,
-                                         audio_receiver_config_,
-                                         video_receiver_config_,
-                                         &receiver_to_sender_));
+    cast_receiver_ = CastReceiver::Create(cast_environment_receiver_,
+                                          audio_receiver_config_,
+                                          video_receiver_config_,
+                                          &receiver_to_sender_);
     net::IPEndPoint dummy_endpoint;
     transport_sender_.reset(new transport::CastTransportSenderImpl(
         NULL,
         testing_clock_sender_,
         dummy_endpoint,
         dummy_endpoint,
         logging_config_,
         base::Bind(&UpdateCastTransportStatus),
         base::Bind(&End2EndTest::LogRawEvents, base::Unretained(this)),
         base::TimeDelta::FromSeconds(1),
         task_runner_,
         &sender_to_receiver_));
     transport_sender_->InitializeAudio(transport_audio_config_);
     transport_sender_->InitializeVideo(transport_video_config_);
 
-    cast_sender_.reset(CastSender::CreateCastSender(
-        cast_environment_sender_,
-        &audio_sender_config_,
-        &video_sender_config_,
-        NULL,
-        base::Bind(&End2EndTest::InitializationResult, base::Unretained(this)),
-        transport_sender_.get()));
+    cast_sender_ =
+        CastSender::Create(cast_environment_sender_, transport_sender_.get());
+
+    // Initializing audio and video senders.
+    cast_sender_->InitializeAudio(audio_sender_config_,
+                                  base::Bind(&AudioInitializationStatus));
+    cast_sender_->InitializeVideo(
+        video_sender_config_, base::Bind(&VideoInitializationStatus), NULL);
 
     receiver_to_sender_.SetPacketReceiver(cast_sender_->packet_receiver());
     sender_to_receiver_.SetPacketReceiver(cast_receiver_->packet_receiver());
 
-    frame_input_ = cast_sender_->frame_input();
+    audio_frame_input_ = cast_sender_->audio_frame_input();
+    video_frame_input_ = cast_sender_->video_frame_input();
+
     frame_receiver_ = cast_receiver_->frame_receiver();
 
     audio_bus_factory_.reset(
         new TestAudioBusFactory(audio_sender_config_.channels,
                                 audio_sender_config_.frequency,
                                 kSoundFrequency,
                                 kSoundVolume));
   }
 
   virtual ~End2EndTest() {
@@ skipping 11 matching lines @@
     if (start_time_.is_null())
       start_time_ = capture_time;
     base::TimeDelta time_diff = capture_time - start_time_;
     gfx::Size size(video_sender_config_.width, video_sender_config_.height);
     EXPECT_TRUE(VideoFrame::IsValidConfig(
         VideoFrame::I420, size, gfx::Rect(size), size));
     scoped_refptr<media::VideoFrame> video_frame =
         media::VideoFrame::CreateFrame(
             VideoFrame::I420, size, gfx::Rect(size), size, time_diff);
     PopulateVideoFrame(video_frame, start_value);
-    frame_input_->InsertRawVideoFrame(video_frame, capture_time);
+    video_frame_input_->InsertRawVideoFrame(video_frame, capture_time);
   }
 
   void RunTasks(int during_ms) {
     for (int i = 0; i < during_ms; ++i) {
       // Call process the timers every 1 ms.
       testing_clock_sender_->Advance(base::TimeDelta::FromMilliseconds(1));
       testing_clock_receiver_->Advance(base::TimeDelta::FromMilliseconds(1));
       task_runner_->RunTasks();
     }
   }
 
-  void InitializationResult(CastInitializationStatus result) {
-    EXPECT_EQ(result, STATUS_INITIALIZED);
-  }
-
   void LogRawEvents(const std::vector<PacketEvent>& packet_events) {
     EXPECT_FALSE(packet_events.empty());
     for (std::vector<media::cast::PacketEvent>::const_iterator it =
              packet_events.begin();
          it != packet_events.end();
          ++it) {
       cast_environment_sender_->Logging()->InsertPacketEvent(it->timestamp,
                                                              it->type,
                                                              it->rtp_timestamp,
                                                              it->frame_id,
@@ skipping 17 matching lines @@
   CastLoggingConfig logging_config_;
   scoped_refptr<CastEnvironment> cast_environment_sender_;
   scoped_refptr<CastEnvironment> cast_environment_receiver_;
 
   LoopBackTransport receiver_to_sender_;
   LoopBackTransport sender_to_receiver_;
   scoped_ptr<transport::CastTransportSenderImpl> transport_sender_;
 
   scoped_ptr<CastReceiver> cast_receiver_;
   scoped_ptr<CastSender> cast_sender_;
-  scoped_refptr<FrameInput> frame_input_;
+  scoped_refptr<AudioFrameInput> audio_frame_input_;
+  scoped_refptr<VideoFrameInput> video_frame_input_;
   scoped_refptr<FrameReceiver> frame_receiver_;
 
   scoped_refptr<TestReceiverAudioCallback> test_receiver_audio_callback_;
   scoped_refptr<TestReceiverVideoCallback> test_receiver_video_callback_;
 
   scoped_ptr<TestAudioBusFactory> audio_bus_factory_;
 
   SimpleEventSubscriber event_subscriber_sender_;
   std::vector<FrameEvent> frame_events_;
   std::vector<PacketEvent> packet_events_;
   std::vector<GenericEvent> generic_events_;
-
   // |transport_sender_| has a RepeatingTimer which needs a MessageLoop.
   base::MessageLoop message_loop_;
 };
 
 TEST_F(End2EndTest, LoopNoLossPcm16) {
   SetupConfig(transport::kPcm16, 32000, false, 1);
   // Reduce video resolution to allow processing multiple frames within a
   // reasonable time frame.
   video_sender_config_.width = kVideoQcifWidth;
   video_sender_config_.height = kVideoQcifHeight;
@@ skipping 16 matching lines @@
       // first samples will be 0 and then slowly ramp up to its real
       // amplitude;
       // ignore the first frame.
       test_receiver_audio_callback_->AddExpectedResult(
           ToPcmAudioFrame(*audio_bus, audio_sender_config_.frequency),
           num_10ms_blocks,
           send_time);
     }
 
     AudioBus* const audio_bus_ptr = audio_bus.get();
-    frame_input_->InsertAudio(
+    audio_frame_input_->InsertAudio(
         audio_bus_ptr,
         send_time,
         base::Bind(&OwnThatAudioBus, base::Passed(&audio_bus)));
 
     test_receiver_video_callback_->AddExpectedResult(
         video_start,
         video_sender_config_.width,
         video_sender_config_.height,
         send_time);
     SendVideoFrame(video_start, send_time);
@@ skipping 36 matching lines @@
   for (; i < 10; ++i) {
     base::TimeTicks send_time = testing_clock_sender_->NowTicks();
     scoped_ptr<AudioBus> audio_bus(audio_bus_factory_->NextAudioBus(
         base::TimeDelta::FromMilliseconds(10)));
     test_receiver_audio_callback_->AddExpectedResult(
         ToPcmAudioFrame(*audio_bus, audio_sender_config_.frequency),
         1,
         send_time);
 
     AudioBus* const audio_bus_ptr = audio_bus.get();
-    frame_input_->InsertAudio(
+    audio_frame_input_->InsertAudio(
         audio_bus_ptr,
         send_time,
         base::Bind(&OwnThatAudioBus, base::Passed(&audio_bus)));
 
     RunTasks(10);
     frame_receiver_->GetCodedAudioFrame(
         base::Bind(&TestReceiverAudioCallback::CheckCodedPcmAudioFrame,
                    test_receiver_audio_callback_));
   }
   RunTasks(2 * kFrameTimerMs + 1);  // Empty the receiver pipeline.
@@ skipping 14 matching lines @@
         base::TimeDelta::FromMilliseconds(10) * num_10ms_blocks));
 
     if (i != 0) {
       test_receiver_audio_callback_->AddExpectedResult(
           ToPcmAudioFrame(*audio_bus, audio_sender_config_.frequency),
           num_10ms_blocks,
           send_time);
     }
 
     AudioBus* const audio_bus_ptr = audio_bus.get();
-    frame_input_->InsertAudio(
+    audio_frame_input_->InsertAudio(
         audio_bus_ptr,
         send_time,
         base::Bind(&OwnThatAudioBus, base::Passed(&audio_bus)));
 
     RunTasks(30);
 
     if (i == 0) {
       frame_receiver_->GetRawAudioFrame(
           num_10ms_blocks,
           audio_sender_config_.frequency,
@@ skipping 29 matching lines @@
     int num_10ms_blocks = audio_diff / 10;
     audio_diff -= num_10ms_blocks * 10;
 
     base::TimeTicks send_time = testing_clock_sender_->NowTicks();
     if (initial_send_time.is_null())
       initial_send_time = send_time;
     scoped_ptr<AudioBus> audio_bus(audio_bus_factory_->NextAudioBus(
         base::TimeDelta::FromMilliseconds(10) * num_10ms_blocks));
 
     AudioBus* const audio_bus_ptr = audio_bus.get();
-    frame_input_->InsertAudio(
+    audio_frame_input_->InsertAudio(
         audio_bus_ptr,
         send_time,
         base::Bind(&OwnThatAudioBus, base::Passed(&audio_bus)));
 
     // Frame will be rendered with 100mS delay, as the transmission is delayed.
     // The receiver at this point cannot be synced to the sender's clock, as no
     // packets, and specifically no RTCP packets were sent.
     test_receiver_video_callback_->AddExpectedResult(
         video_start,
         video_sender_config_.width,
@@ skipping 21 matching lines @@
         base::TimeDelta::FromMilliseconds(10) * num_10ms_blocks));
 
     if (j >= number_of_audio_frames_to_ignore) {
       test_receiver_audio_callback_->AddExpectedResult(
           ToPcmAudioFrame(*audio_bus, audio_sender_config_.frequency),
           num_10ms_blocks,
           send_time);
     }
 
     AudioBus* const audio_bus_ptr = audio_bus.get();
-    frame_input_->InsertAudio(
+    audio_frame_input_->InsertAudio(
         audio_bus_ptr,
         send_time,
         base::Bind(&OwnThatAudioBus, base::Passed(&audio_bus)));
 
     test_receiver_video_callback_->AddExpectedResult(
         video_start,
         video_sender_config_.width,
         video_sender_config_.height,
         send_time);
 
@@ skipping 210 matching lines @@
       // Due to the re-sampler and NetEq in the webrtc AudioCodingModule the
       // first samples will be 0 and then slowly ramp up to its real
       // amplitude;
       // ignore the first frame.
       test_receiver_audio_callback_->AddExpectedResult(
           ToPcmAudioFrame(*audio_bus, audio_sender_config_.frequency),
           num_10ms_blocks,
           send_time);
     }
     AudioBus* const audio_bus_ptr = audio_bus.get();
-    frame_input_->InsertAudio(
+    audio_frame_input_->InsertAudio(
         audio_bus_ptr,
         send_time,
         base::Bind(&OwnThatAudioBus, base::Passed(&audio_bus)));
 
     RunTasks(num_10ms_blocks * 10);
 
     if (frames_counter == 0) {
       frame_receiver_->GetRawAudioFrame(
           num_10ms_blocks,
           32000,
@@ skipping 157 matching lines @@
       // first samples will be 0 and then slowly ramp up to its real
       // amplitude;
       // ignore the first frame.
       test_receiver_audio_callback_->AddExpectedResult(
           ToPcmAudioFrame(*audio_bus, audio_sender_config_.frequency),
           num_10ms_blocks,
           send_time);
     }
 
     AudioBus* const audio_bus_ptr = audio_bus.get();
-    frame_input_->InsertAudio(
+    audio_frame_input_->InsertAudio(
         audio_bus_ptr,
         send_time,
         base::Bind(&OwnThatAudioBus, base::Passed(&audio_bus)));
 
     RunTasks(kFrameTimerMs);
     audio_diff += kFrameTimerMs;
 
     if (i == 0) {
       frame_receiver_->GetRawAudioFrame(
           num_10ms_blocks,
@@ skipping 81 matching lines @@
   EXPECT_EQ(total_event_count_for_frame, expected_event_count_for_frame);
 }
 
 // TODO(pwestin): Add repeatable packet loss test.
 // TODO(pwestin): Add test for misaligned send get calls.
 // TODO(pwestin): Add more tests that does not resample.
 // TODO(pwestin): Add test when we have starvation for our RunTask.
 
 }  // namespace cast
 }  // namespace media