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 378 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_,
-            GetLoggingConfigWithRawEventsAndStatsEnabled())),
+            logging_config_)),
         cast_environment_receiver_(new CastEnvironment(
             scoped_ptr<base::TickClock>(testing_clock_receiver_).Pass(),
             task_runner_,
             task_runner_,
             task_runner_,
             task_runner_,
             task_runner_,
             task_runner_,
-            GetLoggingConfigWithRawEventsAndStatsEnabled())),
+            logging_config_)),
         receiver_to_sender_(cast_environment_receiver_),
         sender_to_receiver_(cast_environment_sender_),
         test_receiver_audio_callback_(new TestReceiverAudioCallback()),
         test_receiver_video_callback_(new TestReceiverVideoCallback()) {
     testing_clock_sender_->Advance(
         base::TimeDelta::FromMilliseconds(kStartMillisecond));
     testing_clock_receiver_->Advance(
         base::TimeDelta::FromMilliseconds(kStartMillisecond));
     cast_environment_sender_->Logging()->AddRawEventSubscriber(
         &event_subscriber_sender_);
@@ skipping 66 matching lines @@
         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_,
         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,
@@ skipping 44 matching lines @@
       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,
+                                                             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_;
+  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<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;
   Create();
 
@@ skipping 709 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