Cast: IPC from browser to renderer to send packet events from transport to cast library.

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 376 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_(new base::SimpleTestTickClock()),
         task_runner_(new test::FakeSingleThreadTaskRunner(testing_clock_)),
+        logging_config_(GetLoggingConfigWithRawEventsAndStatsEnabled()),
         cast_environment_(new CastEnvironment(
             scoped_ptr<base::TickClock>(testing_clock_).Pass(),
             task_runner_,
             task_runner_,
             task_runner_,
             task_runner_,
             task_runner_,
             task_runner_,
-            GetLoggingConfigWithRawEventsAndStatsEnabled())),
+            logging_config_)),
         receiver_to_sender_(cast_environment_),
         sender_to_receiver_(cast_environment_),
         test_receiver_audio_callback_(new TestReceiverAudioCallback()),
         test_receiver_video_callback_(new TestReceiverVideoCallback()) {
     testing_clock_->Advance(
         base::TimeDelta::FromMilliseconds(kStartMillisecond));
     cast_environment_->Logging()->AddRawEventSubscriber(&event_subscriber_);
   }
 
   void SetupConfig(transport::AudioCodec audio_codec,
@@ skipping 61 matching lines @@
   void Create() {
     cast_receiver_.reset(
         CastReceiver::CreateCastReceiver(cast_environment_,
                                          audio_receiver_config_,
                                          video_receiver_config_,
                                          &receiver_to_sender_));
     transport_sender_.reset(new transport::CastTransportSenderImpl(
         NULL,
         testing_clock_,
         transport_config_,
+        logging_config_,
         base::Bind(&UpdateCastTransportStatus),
+        base::Bind(&End2EndTest::LogRawEvents, base::Unretained(this)),
+        base::TimeDelta::FromSeconds(1),
         task_runner_,
         &sender_to_receiver_));
 
     cast_sender_.reset(CastSender::CreateCastSender(
         cast_environment_,
         &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());
     sender_to_receiver_.SetPacketReceiver(cast_receiver_->packet_receiver());
 
     frame_input_ = cast_sender_->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() {
     cast_environment_->Logging()->RemoveRawEventSubscriber(&event_subscriber_);
   }
 
   virtual void TearDown() OVERRIDE {
-
     cast_sender_.reset();
     cast_receiver_.reset();
     task_runner_->RunTasks();
   }
 
   void SendVideoFrame(int start_value, const base::TimeTicks& capture_time) {
     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);
@@ skipping 11 matching lines @@
       // Call process the timers every 1 ms.
       testing_clock_->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_->Logging()->InsertPacketEvent(it->timestamp,
+                                                      it->type,
+                                                      it->rtp_timestamp,
+                                                      it->frame_id,
+                                                      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::CastTransportConfig transport_config_;
 
   base::TimeTicks start_time_;
   base::SimpleTestTickClock* testing_clock_;
   scoped_refptr<test::FakeSingleThreadTaskRunner> task_runner_;
+  CastLoggingConfig logging_config_;
   scoped_refptr<CastEnvironment> cast_environment_;
 
   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<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_;
   std::vector<FrameEvent> frame_events_;
   std::vector<PacketEvent> packet_events_;
   std::vector<GenericEvent> generic_events_;
+
+  // For transport_sender_.
+  base::MessageLoopForIO message_loop_;

[dcheng, 2014/02/27 22:27:20]

Where is this used?

[imcheng, 2014/02/28 00:15:06]

CastTransportSenderImpl creates a RepeatingTimer which relies on having a
SingleThreadTaskRunner in the current thread. This is kind of ugly but I am not
sure what options we have if we are keeping that RepeatingTimer. Or we can
choose not to use RepeatingTimer and just pass in a FakeSingleThreadTaskRunner
and implement the repeating logic there, but then we would have to make it
SupportsWeakPtr<>, which doesn't sound appealing either.

[dcheng, 2014/02/28 19:46:11]

OK, perhaps add a reference to the fact that CastTransportSenderImpl uses a
RepeatingTimer to the comment:
// transport_sender_ has a RepeatingTimer which needs a message loop.
Otherwise, a clueless reader like me doesn't see the connection =)

Also, why can't it be just MessageLoop?

[imcheng, 2014/03/03 19:00:09]

Changed comments. I also changed it to a MessageLoop.

 };
 
 #if defined(OS_WIN)
 #define MAYBE_LoopNoLossPcm16 DISABLED_LoopNoLossPcm16
 #else
 #define MAYBE_LoopNoLossPcm16 LoopNoLossPcm16
 #endif
 // TODO(mikhal): Crashes in win bots (http://crbug.com/329563)
 TEST_F(End2EndTest, MAYBE_LoopNoLossPcm16) {
   SetupConfig(transport::kPcm16, 32000, false, 1);
@@ skipping 697 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