Fixes for memory and threading issues in cast

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 322 matching lines @@
   config.enable_raw_data_collection = true;
   config.enable_stats_data_collection = true;
   return config;
 }
 // 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_(),
-        task_runner_(new test::FakeTaskRunner(&testing_clock_)),
-        transport_task_runner_(new test::FakeTaskRunner(&testing_clock_)),
-        cast_environment_sender_(new CastEnvironment(&testing_clock_,
+        testing_clock_(new base::SimpleTestTickClock()),
+        task_runner_(new test::FakeTaskRunner(testing_clock_)),
+        transport_task_runner_(new test::FakeTaskRunner(testing_clock_)),
+        cast_environment_(new CastEnvironment(
+            scoped_ptr<base::TickClock>(testing_clock_).Pass(),
             task_runner_, task_runner_, task_runner_, task_runner_,
             task_runner_, task_runner_, EnableCastLoggingConfig(true))),
-        cast_environment_receiver_(new CastEnvironment(&testing_clock_,
-            task_runner_, task_runner_, task_runner_, task_runner_,
-            task_runner_, task_runner_, EnableCastLoggingConfig(false))),
-        receiver_to_sender_(cast_environment_receiver_),
-        sender_to_receiver_(cast_environment_sender_),
+        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(
+    testing_clock_->Advance(
         base::TimeDelta::FromMilliseconds(kStartMillisecond));
   }
 
   void SetupConfig(transport::AudioCodec audio_codec,
                    int audio_sampling_frequency,
                    // TODO(miu): 3rd arg is meaningless?!?
                    bool external_audio_decoder,
                    int max_number_of_video_buffers_used) {
     audio_sender_config_.sender_ssrc = 1;
     audio_sender_config_.incoming_feedback_ssrc = 2;
@@ skipping 55 matching lines @@
     transport_config_.audio_frequency = audio_sender_config_.frequency;
     transport_config_.audio_channels = audio_sender_config_.channels;
     transport_config_.video_rtp_max_delay_ms =
         video_sender_config_.rtp_max_delay_ms;
     transport_config_.audio_rtp_max_delay_ms =
         audio_sender_config_.rtp_max_delay_ms;
   }
 
   void Create() {
     cast_receiver_.reset(CastReceiver::CreateCastReceiver(
-        cast_environment_receiver_,
+        cast_environment_,
         audio_receiver_config_,
         video_receiver_config_,
         &receiver_to_sender_));
     transport_sender_.reset(new transport::CastTransportSenderImpl(
-        &testing_clock_,
+        testing_clock_,
         transport_config_,
         base::Bind(&UpdateCastTransportStatus),
         transport_task_runner_));
     transport_sender_->InsertFakeTransportForTesting(&sender_to_receiver_);
 
-    cast_sender_.reset(CastSender::CreateCastSender(cast_environment_sender_,
+    cast_sender_.reset(CastSender::CreateCastSender(cast_environment_,
                                                     audio_sender_config_,
                                                     video_sender_config_,
                                                     NULL,
                                                     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() {}
 
   void SendVideoFrame(int start_value, const base::TimeTicks& capture_time) {
     if (start_time_.is_null())
-      start_time_ = testing_clock_.NowTicks();
-      start_time_ = testing_clock_.NowTicks();
-    base::TimeDelta time_diff = testing_clock_.NowTicks() - start_time_;
+      start_time_ = testing_clock_->NowTicks();
+      start_time_ = testing_clock_->NowTicks();
+    base::TimeDelta time_diff = testing_clock_->NowTicks() - start_time_;
     gfx::Size size(kVideoWidth, kVideoHeight);
     EXPECT_TRUE(VideoFrame::IsValidConfig(VideoFrame::I420,
                                           size, gfx::Rect(size), size));
     scoped_refptr<media::VideoFrame> video_frame =
         media::VideoFrame::CreateFrame(
         VideoFrame::I420, size, gfx::Rect(size), size, time_diff);
     PopulateVideoFrame(video_frame, start_value);
     frame_input_->InsertRawVideoFrame(video_frame, capture_time);
   }
 
   void RunTasks(int during_ms) {
     for (int i = 0; i < during_ms; ++i) {
       // Call process the timers every 1 ms.
-      testing_clock_.Advance(base::TimeDelta::FromMilliseconds(1));
+      testing_clock_->Advance(base::TimeDelta::FromMilliseconds(1));
       task_runner_->RunTasks();
       transport_task_runner_->RunTasks();
     }
   }
 
   AudioReceiverConfig audio_receiver_config_;
   VideoReceiverConfig video_receiver_config_;
   AudioSenderConfig audio_sender_config_;
   VideoSenderConfig video_sender_config_;
   transport::CastTransportConfig transport_config_;
 
-  base::SimpleTestTickClock testing_clock_;
   base::TimeTicks start_time_;
+  base::SimpleTestTickClock* testing_clock_;  // Owned by CastEnvironment.
   scoped_refptr<test::FakeTaskRunner> task_runner_;
   scoped_refptr<test::FakeTaskRunner> transport_task_runner_;
-  scoped_refptr<CastEnvironment> cast_environment_sender_;
-  scoped_refptr<CastEnvironment> cast_environment_receiver_;
+  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_;
 };
 
 // Audio and video test without packet loss using raw PCM 16 audio "codec";
 // This test is too slow. Disabled for now: crbug.com/329333.
 TEST_F(End2EndTest, DISABLED_LoopNoLossPcm16) {
   SetupConfig(transport::kPcm16, 32000, false, 1);
   Create();
 
   int video_start = 1;
   int audio_diff = kFrameTimerMs;
   int i = 0;
 
   for (; i < 10; ++i) {
     int num_10ms_blocks = audio_diff / 10;
     audio_diff -= num_10ms_blocks * 10;
-    base::TimeTicks send_time = testing_clock_.NowTicks();
+    base::TimeTicks send_time = testing_clock_->NowTicks();
 
     test_receiver_video_callback_->AddExpectedResult(video_start,
         video_sender_config_.width, video_sender_config_.height, send_time);
 
     scoped_ptr<AudioBus> audio_bus(audio_bus_factory_->NextAudioBus(
         base::TimeDelta::FromMilliseconds(10) * num_10ms_blocks));
 
     if (i != 0) {
       // Due to the re-sampler and NetEq in the webrtc AudioCodingModule the
       // first samples will be 0 and then slowly ramp up to its real amplitude;
@@ skipping 45 matching lines @@
 #define MAYBE_LoopNoLossPcm16ExternalDecoder LoopNoLossPcm16ExternalDecoder
 #endif
 // This tests our external decoder interface for Audio.
 // Audio test without packet loss using raw PCM 16 audio "codec";
 TEST_F(End2EndTest, MAYBE_LoopNoLossPcm16ExternalDecoder) {
   SetupConfig(transport::kPcm16, 32000, true, 1);
   Create();
 
   int i = 0;
   for (; i < 10; ++i) {
-    base::TimeTicks send_time = testing_clock_.NowTicks();
+    base::TimeTicks send_time = testing_clock_->NowTicks();
     scoped_ptr<AudioBus> audio_bus(audio_bus_factory_->NextAudioBus(
         base::TimeDelta::FromMilliseconds(10)));
     test_receiver_audio_callback_->AddExpectedResult(
         ToPcmAudioFrame(*audio_bus, audio_sender_config_.frequency),
         1, send_time);
 
     AudioBus* const audio_bus_ptr = audio_bus.get();
     frame_input_->InsertAudio(audio_bus_ptr, send_time,
         base::Bind(&OwnThatAudioBus, base::Passed(&audio_bus)));
 
@@ skipping 13 matching lines @@
 #define MAYBE_LoopNoLossOpus LoopNoLossOpus
 #endif
 // This tests our Opus audio codec without video.
 TEST_F(End2EndTest, MAYBE_LoopNoLossOpus) {
   SetupConfig(transport::kOpus, kDefaultAudioSamplingRate, false, 1);
   Create();
 
   int i = 0;
   for (; i < 10; ++i) {
     int num_10ms_blocks = 3;
-    base::TimeTicks send_time = testing_clock_.NowTicks();
+    base::TimeTicks send_time = testing_clock_->NowTicks();
 
     scoped_ptr<AudioBus> audio_bus(audio_bus_factory_->NextAudioBus(
         base::TimeDelta::FromMilliseconds(10) * num_10ms_blocks));
 
     if (i != 0) {
       test_receiver_audio_callback_->AddExpectedResult(
           ToPcmAudioFrame(*audio_bus, audio_sender_config_.frequency),
           num_10ms_blocks, send_time);
     }
 
@@ skipping 29 matching lines @@
 
   int video_start = 1;
   int audio_diff = kFrameTimerMs;
 
   sender_to_receiver_.SetSendPackets(false);
 
   for (int i = 0; i < 3; ++i) {
     int num_10ms_blocks = audio_diff / 10;
     audio_diff -= num_10ms_blocks * 10;
 
-    base::TimeTicks send_time = testing_clock_.NowTicks();
+    base::TimeTicks send_time = testing_clock_->NowTicks();
     scoped_ptr<AudioBus> audio_bus(audio_bus_factory_->NextAudioBus(
         base::TimeDelta::FromMilliseconds(10) * num_10ms_blocks));
 
     AudioBus* const audio_bus_ptr = audio_bus.get();
     frame_input_->InsertAudio(audio_bus_ptr, send_time,
         base::Bind(&OwnThatAudioBus, base::Passed(&audio_bus)));
 
     SendVideoFrame(video_start, send_time);
     RunTasks(kFrameTimerMs);
     audio_diff += kFrameTimerMs;
     video_start++;
   }
   RunTasks(100);
   sender_to_receiver_.SetSendPackets(true);
 
   int j = 0;
   const int number_of_audio_frames_to_ignore = 3;
   for (; j < 10; ++j) {
     int num_10ms_blocks = audio_diff / 10;
     audio_diff -= num_10ms_blocks * 10;
-    base::TimeTicks send_time = testing_clock_.NowTicks();
+    base::TimeTicks send_time = testing_clock_->NowTicks();
 
     scoped_ptr<AudioBus> audio_bus(audio_bus_factory_->NextAudioBus(
         base::TimeDelta::FromMilliseconds(10) * num_10ms_blocks));
 
     if (j >= number_of_audio_frames_to_ignore) {
       test_receiver_audio_callback_->AddExpectedResult(
           ToPcmAudioFrame(*audio_bus, audio_sender_config_.frequency),
           num_10ms_blocks, send_time);
     }
 
@@ skipping 31 matching lines @@
 }
 
 // This tests a network glitch lasting for 10 video frames.
 TEST_F(End2EndTest, GlitchWith3Buffers) {
   SetupConfig(transport::kOpus, kDefaultAudioSamplingRate, false, 3);
   video_sender_config_.rtp_max_delay_ms = 67;
   video_receiver_config_.rtp_max_delay_ms = 67;
   Create();
 
   int video_start = 50;
-  base::TimeTicks send_time = testing_clock_.NowTicks();
+  base::TimeTicks send_time = testing_clock_->NowTicks();
   SendVideoFrame(video_start, send_time);
   RunTasks(kFrameTimerMs);
 
   test_receiver_video_callback_->AddExpectedResult(video_start,
       video_sender_config_.width, video_sender_config_.height, send_time);
   frame_receiver_->GetRawVideoFrame(
       base::Bind(&TestReceiverVideoCallback::CheckVideoFrame,
           test_receiver_video_callback_));
 
   RunTasks(750);  // Make sure that we send a RTCP packet.
 
   video_start++;
 
   // Introduce a glitch lasting for 10 frames.
   sender_to_receiver_.SetSendPackets(false);
   for (int i = 0; i < 10; ++i) {
-    send_time = testing_clock_.NowTicks();
+    send_time = testing_clock_->NowTicks();
     // First 3 will be sent and lost.
     SendVideoFrame(video_start, send_time);
     RunTasks(kFrameTimerMs);
     video_start++;
   }
   sender_to_receiver_.SetSendPackets(true);
   RunTasks(100);
-  send_time = testing_clock_.NowTicks();
+  send_time = testing_clock_->NowTicks();
 
   // Frame 1 should be acked by now and we should have an opening to send 4.
   SendVideoFrame(video_start, send_time);
   RunTasks(kFrameTimerMs);
 
   test_receiver_video_callback_->AddExpectedResult(video_start,
       video_sender_config_.width, video_sender_config_.height, send_time);
 
   frame_receiver_->GetRawVideoFrame(
       base::Bind(&TestReceiverVideoCallback::CheckVideoFrame,
           test_receiver_video_callback_));
 
   RunTasks(2 * kFrameTimerMs + 1);  // Empty the receiver pipeline.
   EXPECT_EQ(2, test_receiver_video_callback_->number_times_called());
 }
 
 TEST_F(End2EndTest, DropEveryOtherFrame3Buffers) {
   SetupConfig(transport::kOpus, kDefaultAudioSamplingRate, false, 3);
   video_sender_config_.rtp_max_delay_ms = 67;
   video_receiver_config_.rtp_max_delay_ms = 67;
   Create();
   sender_to_receiver_.DropAllPacketsBelongingToOddFrames();
 
   int video_start = 50;
   base::TimeTicks send_time;
 
   int i = 0;
   for (; i < 20; ++i) {
-    send_time = testing_clock_.NowTicks();
+    send_time = testing_clock_->NowTicks();
     SendVideoFrame(video_start, send_time);
 
     if (i % 2 == 0) {
       test_receiver_video_callback_->AddExpectedResult(video_start,
           video_sender_config_.width, video_sender_config_.height, send_time);
 
       // GetRawVideoFrame will not return the frame until we are close in
       // time before we should render the frame.
       frame_receiver_->GetRawVideoFrame(
           base::Bind(&TestReceiverVideoCallback::CheckVideoFrame,
               test_receiver_video_callback_));
     }
     RunTasks(kFrameTimerMs);
     video_start++;
   }
   std::cout << std::endl;
   RunTasks(2 * kFrameTimerMs + 1);  // Empty the pipeline.
   EXPECT_EQ(i / 2, test_receiver_video_callback_->number_times_called());
 }
 
 TEST_F(End2EndTest, ResetReferenceFrameId) {
   SetupConfig(transport::kOpus, kDefaultAudioSamplingRate, false, 3);
   video_sender_config_.rtp_max_delay_ms = 67;
   video_receiver_config_.rtp_max_delay_ms = 67;
   Create();
   sender_to_receiver_.AlwaysResetReferenceFrameId();
 
   int frames_counter = 0;
   for (; frames_counter < 20; ++frames_counter) {
-    const base::TimeTicks send_time = testing_clock_.NowTicks();
+    const base::TimeTicks send_time = testing_clock_->NowTicks();
     SendVideoFrame(frames_counter, send_time);
 
     test_receiver_video_callback_->AddExpectedResult(frames_counter,
         video_sender_config_.width, video_sender_config_.height, send_time);
 
     // GetRawVideoFrame will not return the frame until we are close to the
     // time in which we should render the frame.
     frame_receiver_->GetRawVideoFrame(
         base::Bind(&TestReceiverVideoCallback::CheckVideoFrame,
                    test_receiver_video_callback_));
@@ skipping 12 matching lines @@
   transport_config_.aes_key =
       ConvertFromBase16String("deadbeefcafeb0b0b0b0cafedeadbeef");
 
   video_receiver_config_.aes_iv_mask = transport_config_.aes_iv_mask;
   video_receiver_config_.aes_key = transport_config_.aes_key;
 
   Create();
 
   int frames_counter = 0;
   for (; frames_counter < 3; ++frames_counter) {
-    const base::TimeTicks send_time = testing_clock_.NowTicks();
+    const base::TimeTicks send_time = testing_clock_->NowTicks();
 
     SendVideoFrame(frames_counter, send_time);
 
     test_receiver_video_callback_->AddExpectedResult(frames_counter,
         video_sender_config_.width, video_sender_config_.height, send_time);
 
     // GetRawVideoFrame will not return the frame until we are close to the
     // time in which we should render the frame.
     frame_receiver_->GetRawVideoFrame(
         base::Bind(&TestReceiverVideoCallback::CheckVideoFrame,
@@ skipping 21 matching lines @@
 
   audio_receiver_config_.aes_iv_mask = transport_config_.aes_iv_mask;
   audio_receiver_config_.aes_key = transport_config_.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_.NowTicks();
+    const base::TimeTicks send_time = testing_clock_->NowTicks();
 
     scoped_ptr<AudioBus> audio_bus(audio_bus_factory_->NextAudioBus(
         base::TimeDelta::FromMilliseconds(10) * num_10ms_blocks));
 
     if (frames_counter != 0) {
       // Due to the re-sampler and NetEq in the webrtc AudioCodingModule the
       // first samples will be 0 and then slowly ramp up to its real amplitude;
       // ignore the first frame.
       test_receiver_audio_callback_->AddExpectedResult(
           ToPcmAudioFrame(*audio_bus, audio_sender_config_.frequency),
@@ skipping 24 matching lines @@
 
 // Video test without packet loss; This test is targeted at testing the logging
 // aspects of the end2end, but is basically equivalent to LoopNoLossPcm16.
 TEST_F(End2EndTest, VideoLogging) {
   SetupConfig(transport::kPcm16, 32000, false, 1);
   Create();
 
   int video_start = 1;
   int i = 0;
   for (; i < 1; ++i) {
-    base::TimeTicks send_time = testing_clock_.NowTicks();
+    base::TimeTicks send_time = testing_clock_->NowTicks();
     test_receiver_video_callback_->AddExpectedResult(video_start,
         video_sender_config_.width, video_sender_config_.height, send_time);
 
     SendVideoFrame(video_start, send_time);
     RunTasks(kFrameTimerMs);
 
     frame_receiver_->GetRawVideoFrame(
         base::Bind(&TestReceiverVideoCallback::CheckVideoFrame,
             test_receiver_video_callback_));
 
     video_start++;
   }
 
   // Basic tests.
   RunTasks(2 * kFrameTimerMs + 1);  // Empty the receiver pipeline.
   EXPECT_EQ(i, test_receiver_video_callback_->number_times_called());
 
   // Sender logging tests.
-  LoggingImpl* sender_log = cast_environment_sender_->Logging();
+  LoggingImpl* sender_log = cast_environment_->Logging();
 
   // Verify that all frames and all required events were logged.
   FrameRawMap frame_raw_log = sender_log->GetFrameRawData();
 
   // Every frame should have only one entry.
   EXPECT_EQ(static_cast<unsigned int>(i), frame_raw_log.size());
   FrameRawMap::const_iterator frame_it = frame_raw_log.begin();
 
   // Choose a video frame, and verify that all events were logged.
   std::vector<CastLoggingEvent> event_log = frame_it->second.type;
@@ skipping 29 matching lines @@
   // Packet logging.
   // Verify that all packet related events were logged.
   PacketRawMap packet_raw_log = sender_log->GetPacketRawData();
   // Every rtp_timestamp should have only one entry.
   EXPECT_EQ(static_cast<unsigned int>(i), packet_raw_log.size());
   PacketRawMap::const_iterator packet_it = packet_raw_log.begin();
   // Choose a packet, and verify that all events were logged.
   event_log = (++(packet_it->second.packet_map.begin()))->second.type;
   EXPECT_TRUE((std::find(event_log.begin(), event_log.end(),
                kVideoPacketReceived)) != event_log.end());
-  // Verify that there were no other events logged with respect to this frame.
-  EXPECT_EQ(1u, event_log.size());
 
   RunTasks(750);  // Make sure that we send a RTCP message with the log.
 
   // Receiver logging tests.
-  LoggingImpl* receiver_log = cast_environment_receiver_->Logging();
+  LoggingImpl* receiver_log = cast_environment_->Logging();
 
   // Verify that all frames and all required events were logged.
   frame_raw_log = receiver_log->GetFrameRawData();
   EXPECT_EQ(static_cast<unsigned int>(i), frame_raw_log.size());
   frame_it = frame_raw_log.begin();
 
   // Choose a video frame, and verify that all events were logged.
   event_log = frame_it->second.type;
 
   event_it = std::find(event_log.begin(), event_log.end(),
                        kVideoFrameEncoded);
   EXPECT_TRUE(event_it != event_log.end());
 
   event_it = std::find(event_log.begin(), event_log.end(),
                        kVideoRenderDelay);
 
   EXPECT_TRUE(event_it != event_log.end());
-  EXPECT_EQ(2u, event_log.size());
 }
 
 // TODO(mikhal): Crashes on the bots. Re-enable. http://crbug.com/329563
 #if defined(OS_WIN)
 #define MAYBE_AudioLogging DISABLED_AudioLogging
 #else
 #define MAYBE_AudioLogging AudioLogging
 #endif
 // Audio test without packet loss; This test is targeted at testing the logging
 // aspects of the end2end, but is basically equivalent to LoopNoLossPcm16.
 TEST_F(End2EndTest, MAYBE_AudioLogging) {
   SetupConfig(transport::kPcm16, 32000, false, 1);
   Create();
 
   int audio_diff = kFrameTimerMs;
   int i = 0;
 
   for (; i < 10; ++i) {
     int num_10ms_blocks = audio_diff / 10;
     audio_diff -= num_10ms_blocks * 10;
-    base::TimeTicks send_time = testing_clock_.NowTicks();
+    base::TimeTicks send_time = testing_clock_->NowTicks();
 
     scoped_ptr<AudioBus> audio_bus(audio_bus_factory_->NextAudioBus(
         base::TimeDelta::FromMilliseconds(10) * num_10ms_blocks));
 
     if (i != 0) {
       // Due to the re-sampler and NetEq in the webrtc AudioCodingModule the
       // first samples will be 0 and then slowly ramp up to its real amplitude;
       // ignore the first frame.
       test_receiver_audio_callback_->AddExpectedResult(
           ToPcmAudioFrame(*audio_bus, audio_sender_config_.frequency),
@@ skipping 18 matching lines @@
           base::Bind(&TestReceiverAudioCallback::CheckPcmAudioFrame,
               test_receiver_audio_callback_));
     }
   }
 
   // Basic tests.
   RunTasks(2 * kFrameTimerMs + 1);  // Empty the receiver pipeline.
   //EXPECT_EQ(i - 1, test_receiver_audio_callback_->number_times_called());
   EXPECT_EQ(i - 1, test_receiver_audio_callback_->number_times_called());
   // Logging tests.
-  LoggingImpl* sender_log = cast_environment_sender_->Logging();
+  LoggingImpl* sender_log = cast_environment_->Logging();
   // Verify that all frames and all required events were logged.
   FrameRawMap frame_raw_log = sender_log->GetFrameRawData();
   // TODO(mikhal): Results are wrong. Need to resolve passing/calculation of
   // rtp_timestamp for audio for this to work.
   // Should have logged both audio and video. Every frame should have only one
   // entry.
   //EXPECT_EQ(static_cast<unsigned int>(i - 1), frame_raw_log.size());
   FrameRawMap::const_iterator frame_it = frame_raw_log.begin();
   // Choose a video frame, and verify that all events were logged.
   std::vector<CastLoggingEvent> event_log = frame_it->second.type;
@@ skipping 11 matching lines @@
 }
 
 
 // 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