Revert of Cast: Fix two video freezing problems

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 448 matching lines @@
         base::TimeDelta::FromMilliseconds(kStartMillisecond));
     cast_environment_sender_->Logging()->AddRawEventSubscriber(
         &event_subscriber_sender_);
   }
 
   void Configure(transport::VideoCodec video_codec,
                  transport::AudioCodec audio_codec,
                  int audio_sampling_frequency,
                  bool external_audio_decoder,
                  int max_number_of_video_buffers_used) {
-    audio_sender_config_.rtp_config.ssrc = 1;
+    audio_sender_config_.sender_ssrc = 1;
     audio_sender_config_.incoming_feedback_ssrc = 2;
     audio_sender_config_.rtp_config.payload_type = 96;
     audio_sender_config_.use_external_encoder = false;
     audio_sender_config_.frequency = audio_sampling_frequency;
     audio_sender_config_.channels = kAudioChannels;
     audio_sender_config_.bitrate = kDefaultAudioEncoderBitrate;
     audio_sender_config_.codec = audio_codec;
 
     audio_receiver_config_.feedback_ssrc =
         audio_sender_config_.incoming_feedback_ssrc;
-    audio_receiver_config_.incoming_ssrc = audio_sender_config_.rtp_config.ssrc;
+    audio_receiver_config_.incoming_ssrc = audio_sender_config_.sender_ssrc;
     audio_receiver_config_.rtp_payload_type =
         audio_sender_config_.rtp_config.payload_type;
     audio_receiver_config_.use_external_decoder = external_audio_decoder;
     audio_receiver_config_.frequency = audio_sender_config_.frequency;
     audio_receiver_config_.channels = kAudioChannels;
     audio_receiver_config_.codec = audio_sender_config_.codec;
 
     test_receiver_audio_callback_->SetExpectedSamplingFrequency(
         audio_receiver_config_.frequency);
 
-    video_sender_config_.rtp_config.ssrc = 3;
+    video_sender_config_.sender_ssrc = 3;
     video_sender_config_.incoming_feedback_ssrc = 4;
     video_sender_config_.rtp_config.payload_type = 97;
     video_sender_config_.use_external_encoder = false;
     video_sender_config_.width = kVideoHdWidth;
     video_sender_config_.height = kVideoHdHeight;
     video_sender_config_.max_bitrate = 5000000;
     video_sender_config_.min_bitrate = 1000000;
     video_sender_config_.start_bitrate = 5000000;
     video_sender_config_.max_qp = 30;
     video_sender_config_.min_qp = 4;
     video_sender_config_.max_frame_rate = 30;
     video_sender_config_.max_number_of_video_buffers_used =
         max_number_of_video_buffers_used;
     video_sender_config_.codec = video_codec;
 
     video_receiver_config_.feedback_ssrc =
         video_sender_config_.incoming_feedback_ssrc;
-    video_receiver_config_.incoming_ssrc = video_sender_config_.rtp_config.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_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 FeedAudioFrames(int count, bool will_be_checked) {
     for (int i = 0; i < count; ++i) {
       scoped_ptr<AudioBus> audio_bus(audio_bus_factory_->NextAudioBus(
           base::TimeDelta::FromMilliseconds(kAudioFrameDurationMs)));
       const base::TimeTicks send_time =
           testing_clock_sender_->NowTicks() +
               i * base::TimeDelta::FromMilliseconds(kAudioFrameDurationMs);
       if (will_be_checked)
@@ skipping 33 matching lines @@
     net::IPEndPoint dummy_endpoint;
     transport_sender_.reset(new transport::CastTransportSenderImpl(
         NULL,
         testing_clock_sender_,
         dummy_endpoint,
         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_ =
         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),
                                   CreateDefaultVideoEncodeAcceleratorCallback(),
@@ skipping 66 matching lines @@
                                                              it->packet_id,
                                                              it->max_packet_id,
                                                              it->size);
     }
   }
 
   AudioReceiverConfig audio_receiver_config_;
   VideoReceiverConfig video_receiver_config_;
   AudioSenderConfig audio_sender_config_;
   VideoSenderConfig video_sender_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 299 matching lines @@
     video_start++;
   }
 
   RunTasks(2 * kFrameTimerMs + 1);  // Empty the pipeline.
   EXPECT_EQ(i / 2, test_receiver_video_callback_->number_times_called());
 }
 
 TEST_F(End2EndTest, CryptoVideo) {
   Configure(transport::kVp8, transport::kPcm16, 32000, false, 1);
 
-  video_sender_config_.rtp_config.aes_iv_mask =
+  transport_video_config_.base.aes_iv_mask =
       ConvertFromBase16String("1234567890abcdeffedcba0987654321");
-  video_sender_config_.rtp_config.aes_key =
+  transport_video_config_.base.aes_key =
       ConvertFromBase16String("deadbeefcafeb0b0b0b0cafedeadbeef");
 
-  video_receiver_config_.aes_iv_mask =
-      video_sender_config_.rtp_config.aes_iv_mask;
-  video_receiver_config_.aes_key =
-      video_sender_config_.rtp_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(
         frames_counter,
         video_sender_config_.width,
         video_sender_config_.height,
         send_time,
         true);
 
     RunTasks(kFrameTimerMs);
 
     frame_receiver_->GetRawVideoFrame(
         base::Bind(&TestReceiverVideoCallback::CheckVideoFrame,
                    test_receiver_video_callback_));
   }
   RunTasks(2 * kFrameTimerMs + 1);  // Empty the pipeline.
   EXPECT_EQ(frames_counter,
             test_receiver_video_callback_->number_times_called());
 }
 
 TEST_F(End2EndTest, CryptoAudio) {
   Configure(transport::kVp8, transport::kPcm16, 32000, false, 1);
 
-  audio_sender_config_.rtp_config.aes_iv_mask =
+  transport_audio_config_.base.aes_iv_mask =
       ConvertFromBase16String("abcdeffedcba12345678900987654321");
-    audio_sender_config_.rtp_config.aes_key =
+  transport_audio_config_.base.aes_key =
       ConvertFromBase16String("deadbeefcafecafedeadbeefb0b0b0b0");
 
-  audio_receiver_config_.aes_iv_mask =
-      audio_sender_config_.rtp_config.aes_iv_mask;
-  audio_receiver_config_.aes_key =
-      audio_sender_config_.rtp_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();
 
   const int kNumIterations = 3;
   const int kNumAudioFramesPerIteration = 2;
   for (int i = 0; i < kNumIterations; ++i) {
     FeedAudioFrames(kNumAudioFramesPerIteration, true);
     RunTasks(kNumAudioFramesPerIteration * kAudioFrameDurationMs);
     RequestAudioFrames(kNumAudioFramesPerIteration, true);
   }
@@ skipping 231 matching lines @@
   EXPECT_EQ(1000, received_counter);
 }
 
 // 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