Cast:Transport: Dividing A/V Initialization pipeline

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 72 matching lines @@
   }
   compressed.assign(reinterpret_cast<const char*>(&v[0]), v.size());
   return compressed;
 }
 
 // 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) {
-  EXPECT_EQ(status, transport::TRANSPORT_INITIALIZED);
+  bool result = (status == transport::TRANSPORT_AUDIO_INITIALIZED ||
+                 status == transport::TRANSPORT_VIDEO_INITIALIZED);
+  EXPECT_TRUE(result);
 }
 
 // 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(
@@ skipping 367 matching lines @@
     video_sender_config_.number_of_cores = 1;
 
     video_receiver_config_.feedback_ssrc =
         video_sender_config_.incoming_feedback_ssrc;
     video_receiver_config_.incoming_ssrc = video_sender_config_.sender_ssrc;
     video_receiver_config_.rtp_payload_type =
         video_sender_config_.rtp_config.payload_type;
     video_receiver_config_.use_external_decoder = false;
     video_receiver_config_.codec = video_sender_config_.codec;
 
-    transport_config_.audio_ssrc = audio_sender_config_.sender_ssrc;
-    transport_config_.video_ssrc = video_sender_config_.sender_ssrc;
-    transport_config_.video_codec = video_sender_config_.codec;
-    transport_config_.audio_codec = audio_sender_config_.codec;
-    transport_config_.video_rtp_config = video_sender_config_.rtp_config;
-    transport_config_.audio_rtp_config = audio_sender_config_.rtp_config;
-    transport_config_.audio_frequency = audio_sender_config_.frequency;
-    transport_config_.audio_channels = audio_sender_config_.channels;
+    transport_audio_config_.base.ssrc = audio_sender_config_.sender_ssrc;
+    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_));
+    net::IPEndPoint dummy_endpoint;
     transport_sender_.reset(new transport::CastTransportSenderImpl(
         NULL,
         testing_clock_sender_,
-        transport_config_,
+        dummy_endpoint,
+        dummy_endpoint,
         base::Bind(&UpdateCastTransportStatus),
         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()));
 
     receiver_to_sender_.SetPacketReceiver(cast_sender_->packet_receiver());
@@ skipping 44 matching lines @@
   }
 
   void InitializationResult(CastInitializationStatus result) {
     EXPECT_EQ(result, STATUS_INITIALIZED);
   }
 
   AudioReceiverConfig audio_receiver_config_;
   VideoReceiverConfig video_receiver_config_;
   AudioSenderConfig audio_sender_config_;
   VideoSenderConfig video_sender_config_;
-  transport::CastTransportConfig transport_config_;
+  transport::CastTransportAudioConfig transport_audio_config_;
+  transport::CastTransportVideoConfig transport_video_config_;
 
   base::TimeTicks start_time_;
   base::SimpleTestTickClock* testing_clock_sender_;
   base::SimpleTestTickClock* testing_clock_receiver_;
   scoped_refptr<test::FakeSingleThreadTaskRunner> task_runner_;
   scoped_refptr<CastEnvironment> cast_environment_sender_;
   scoped_refptr<CastEnvironment> cast_environment_receiver_;
 
   LoopBackTransport receiver_to_sender_;
   LoopBackTransport sender_to_receiver_;
@@ skipping 388 matching lines @@
     RunTasks(kFrameTimerMs);
   }
   RunTasks(2 * kFrameTimerMs + 1);  // Empty the pipeline.
   EXPECT_EQ(frames_counter,
             test_receiver_video_callback_->number_times_called());
 }
 
 TEST_F(End2EndTest, CryptoVideo) {
   SetupConfig(transport::kPcm16, 32000, false, 1);
 
-  transport_config_.aes_iv_mask =
+  transport_video_config_.base.aes_iv_mask =
       ConvertFromBase16String("1234567890abcdeffedcba0987654321");
-  transport_config_.aes_key =
+  transport_video_config_.base.aes_key =
       ConvertFromBase16String("deadbeefcafeb0b0b0b0cafedeadbeef");
 
-  video_receiver_config_.aes_iv_mask = transport_config_.aes_iv_mask;
-  video_receiver_config_.aes_key = transport_config_.aes_key;
+  video_receiver_config_.aes_iv_mask = transport_video_config_.base.aes_iv_mask;
+  video_receiver_config_.aes_key = transport_video_config_.base.aes_key;
 
   Create();
 
   int frames_counter = 0;
   for (; frames_counter < 3; ++frames_counter) {
     const base::TimeTicks send_time = testing_clock_sender_->NowTicks();
 
     SendVideoFrame(frames_counter, send_time);
 
     test_receiver_video_callback_->AddExpectedResult(
@@ skipping 10 matching lines @@
     RunTasks(kFrameTimerMs);
   }
   RunTasks(2 * kFrameTimerMs + 1);  // Empty the pipeline.
   EXPECT_EQ(frames_counter,
             test_receiver_video_callback_->number_times_called());
 }
 
 TEST_F(End2EndTest, CryptoAudio) {
   SetupConfig(transport::kPcm16, 32000, false, 1);
 
-  transport_config_.aes_iv_mask =
+  transport_audio_config_.base.aes_iv_mask =
       ConvertFromBase16String("abcdeffedcba12345678900987654321");
-  transport_config_.aes_key =
+  transport_audio_config_.base.aes_key =
       ConvertFromBase16String("deadbeefcafecafedeadbeefb0b0b0b0");
 
-  audio_receiver_config_.aes_iv_mask = transport_config_.aes_iv_mask;
-  audio_receiver_config_.aes_key = transport_config_.aes_key;
+  audio_receiver_config_.aes_iv_mask = transport_audio_config_.base.aes_iv_mask;
+  audio_receiver_config_.aes_key = transport_audio_config_.base.aes_key;
 
   Create();
 
   int frames_counter = 0;
   for (; frames_counter < 3; ++frames_counter) {
     int num_10ms_blocks = 2;
 
     const base::TimeTicks send_time = testing_clock_sender_->NowTicks();
 
     scoped_ptr<AudioBus> audio_bus(audio_bus_factory_->NextAudioBus(
@@ skipping 283 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