Cast: Make receiver use cast_transport

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 564 matching lines @@
 
   void RequestAudioFrames(int count, bool with_check) {
     for (int i = 0; i < count; ++i) {
       cast_receiver_->RequestDecodedAudioFrame(
           base::Bind(with_check ? &TestReceiverAudioCallback::CheckAudioFrame :
                                   &TestReceiverAudioCallback::IgnoreAudioFrame,
                      test_receiver_audio_callback_));
     }
   }
 
+  void ReceivePacket(scoped_ptr<Packet> packet) {
+    cast_receiver_->ReceivePacket(packet.Pass());
+  }
+
   void Create() {
-    cast_receiver_ = CastReceiver::Create(cast_environment_receiver_,
-                                          audio_receiver_config_,
-                                          video_receiver_config_,
-                                          &receiver_to_sender_);
-
     net::IPEndPoint dummy_endpoint;
     transport_sender_.reset(new CastTransportSenderImpl(
         NULL,
         testing_clock_sender_,
         dummy_endpoint,
+        dummy_endpoint,
         make_scoped_ptr(new base::DictionaryValue),
         base::Bind(&UpdateCastTransportStatus),
         base::Bind(&End2EndTest::LogRawEvents, base::Unretained(this)),
         base::TimeDelta::FromMilliseconds(1),
         task_runner_sender_,
+        PacketReceiverCallback(),
         &sender_to_receiver_));
 
+    transport_receiver_.reset(new CastTransportSenderImpl(
+        NULL,
+        testing_clock_sender_,
+        dummy_endpoint,
+        dummy_endpoint,
+        make_scoped_ptr(new base::DictionaryValue),
+        base::Bind(&UpdateCastTransportStatus),
+        base::Bind(&End2EndTest::LogRawEvents, base::Unretained(this)),
+        base::TimeDelta::FromMilliseconds(1),
+        task_runner_sender_,
+        base::Bind(&End2EndTest::ReceivePacket, base::Unretained(this)),
+        &receiver_to_sender_));
+
+    cast_receiver_ = CastReceiver::Create(cast_environment_receiver_,
+                                          audio_receiver_config_,
+                                          video_receiver_config_,
+                                          transport_receiver_.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),
                                   CreateDefaultVideoEncodeAcceleratorCallback(),
                                   CreateDefaultVideoEncodeMemoryCallback());
     task_runner_->RunTasks();
 
     receiver_to_sender_.SetPacketReceiver(
         transport_sender_->PacketReceiverForTesting(),
         task_runner_,
         &testing_clock_);
-    sender_to_receiver_.SetPacketReceiver(cast_receiver_->packet_receiver(),
-                                          task_runner_,
-                                          &testing_clock_);
+    sender_to_receiver_.SetPacketReceiver(
+        transport_receiver_->PacketReceiverForTesting(),
+        task_runner_,
+        &testing_clock_);
 
     audio_frame_input_ = cast_sender_->audio_frame_input();
     video_frame_input_ = cast_sender_->video_frame_input();
 
     audio_bus_factory_.reset(
         new TestAudioBusFactory(audio_sender_config_.channels,
                                 audio_sender_config_.frequency,
                                 kSoundFrequency,
                                 kSoundVolume));
   }
@@ skipping 153 matching lines @@
   base::TimeTicks last_video_playout_time_;
   base::TimeDelta last_video_playout_delta_;
   base::TimeTicks last_audio_playout_time_;
 
   scoped_refptr<CastEnvironment> cast_environment_sender_;
   scoped_refptr<CastEnvironment> cast_environment_receiver_;
 
   LoopBackTransport receiver_to_sender_;
   LoopBackTransport sender_to_receiver_;
   scoped_ptr<CastTransportSenderImpl> transport_sender_;
+  scoped_ptr<CastTransportSenderImpl> transport_receiver_;
 
   scoped_ptr<CastReceiver> cast_receiver_;
   scoped_ptr<CastSender> cast_sender_;
   scoped_refptr<AudioFrameInput> audio_frame_input_;
   scoped_refptr<VideoFrameInput> video_frame_input_;
 
   scoped_refptr<TestReceiverAudioCallback> test_receiver_audio_callback_;
   scoped_refptr<TestReceiverVideoCallback> test_receiver_video_callback_;
 
   scoped_ptr<TestAudioBusFactory> audio_bus_factory_;
@@ skipping 700 matching lines @@
   EXPECT_LT(jump, 220u);
 }
 
 // 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