[Cast] Remove AudioDecoder's dependency on WebRTC, and refactor/clean-up AudioReceiver.

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
 
 #include <math.h>
 
 #include <functional>
 #include <list>
 #include <map>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
+#include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
+#include "base/sys_byteorder.h"
 #include "base/test/simple_test_tick_clock.h"
 #include "base/time/tick_clock.h"
+#include "media/base/audio_bus.h"
 #include "media/base/video_frame.h"
 #include "media/cast/cast_config.h"
 #include "media/cast/cast_environment.h"
 #include "media/cast/cast_receiver.h"
 #include "media/cast/cast_sender.h"
 #include "media/cast/logging/simple_event_subscriber.h"
 #include "media/cast/test/fake_single_thread_task_runner.h"
 #include "media/cast/test/utility/audio_utility.h"
 #include "media/cast/test/utility/default_config.h"
 #include "media/cast/test/utility/video_utility.h"
@@ skipping 33 matching lines @@
 // retransmitted.
 // In addition, audio packets are sent in 10mS intervals in audio_encoder.cc,
 // although we send an audio frame every 33mS, which adds an extra delay.
 // A TODO was added in the code to resolve this.
 static const int kTimerErrorMs = 20;
 
 // Start the video synthetic start value to medium range value, to avoid edge
 // effects cause by encoding and quantization.
 static const int kVideoStart = 100;
 
+// The size of audio frames.  The encoder joins/breaks all inserted audio into
+// chunks of this size.
+static const int kAudioFrameDurationMs = 10;
+
 std::string ConvertFromBase16String(const std::string base_16) {
   std::string compressed;
   DCHECK_EQ(base_16.size() % 2, 0u) << "Must be a multiple of 2";
   compressed.reserve(base_16.size() / 2);
 
   std::vector<uint8> v;
   if (!base::HexStringToBytes(base_16, &v)) {
     NOTREACHED();
   }
   compressed.assign(reinterpret_cast<const char*>(&v[0]), v.size());
@@ skipping 116 matching lines @@
   bool drop_packets_belonging_to_odd_frames_;
   bool reset_reference_frame_id_;
   scoped_refptr<CastEnvironment> cast_environment_;
 };
 
 // Class that verifies the audio frames coming out of the receiver.
 class TestReceiverAudioCallback
     : public base::RefCountedThreadSafe<TestReceiverAudioCallback> {
  public:
   struct ExpectedAudioFrame {
-    PcmAudioFrame audio_frame;
-    int num_10ms_blocks;
+    scoped_ptr<AudioBus> audio_bus;
     base::TimeTicks record_time;
   };
 
   TestReceiverAudioCallback() : num_called_(0) {}
 
   void SetExpectedSamplingFrequency(int expected_sampling_frequency) {
     expected_sampling_frequency_ = expected_sampling_frequency;
   }
 
-  void AddExpectedResult(scoped_ptr<PcmAudioFrame> audio_frame,
-                         int expected_num_10ms_blocks,
+  void AddExpectedResult(const AudioBus& audio_bus,
                          const base::TimeTicks& record_time) {
-    ExpectedAudioFrame expected_audio_frame;
-    expected_audio_frame.audio_frame = *audio_frame;
-    expected_audio_frame.num_10ms_blocks = expected_num_10ms_blocks;
-    expected_audio_frame.record_time = record_time;
-    expected_frame_.push_back(expected_audio_frame);
+    scoped_ptr<ExpectedAudioFrame> expected_audio_frame(
+        new ExpectedAudioFrame());
+    expected_audio_frame->audio_bus =
+        AudioBus::Create(audio_bus.channels(), audio_bus.frames()).Pass();
+    audio_bus.CopyTo(expected_audio_frame->audio_bus.get());
+    expected_audio_frame->record_time = record_time;
+    expected_frames_.push_back(expected_audio_frame.release());
   }
 
-  void IgnoreAudioFrame(scoped_ptr<PcmAudioFrame> audio_frame,
-                        const base::TimeTicks& playout_time) {}
+  void IgnoreAudioFrame(scoped_ptr<AudioBus> audio_bus,
+                        const base::TimeTicks& playout_time,
+                        bool is_continuous) {
+    ++num_called_;
+  }
 
-  // Check the audio frame parameters but not the audio samples.
-  void CheckBasicAudioFrame(const scoped_ptr<PcmAudioFrame>& audio_frame,
-                            const base::TimeTicks& playout_time) {
-    EXPECT_FALSE(expected_frame_.empty());  // Test for bug in test code.
-    ExpectedAudioFrame expected_audio_frame = expected_frame_.front();
-    EXPECT_EQ(audio_frame->channels, kAudioChannels);
-    EXPECT_EQ(audio_frame->frequency, expected_sampling_frequency_);
-    EXPECT_EQ(static_cast<int>(audio_frame->samples.size()),
-              expected_audio_frame.num_10ms_blocks * kAudioChannels *
-                  expected_sampling_frequency_ / 100);
+  void CheckAudioFrame(scoped_ptr<AudioBus> audio_bus,
+                       const base::TimeTicks& playout_time,
+                       bool is_continuous) {
+    ++num_called_;
 
+    ASSERT_FALSE(expected_frames_.empty());
+    const scoped_ptr<ExpectedAudioFrame> expected_audio_frame(
+        expected_frames_.front());
+    expected_frames_.pop_front();
+
+    EXPECT_EQ(audio_bus->channels(), kAudioChannels);
+    EXPECT_EQ(audio_bus->frames(), expected_audio_frame->audio_bus->frames());
+    for (int ch = 0; ch < audio_bus->channels(); ++ch) {
+      EXPECT_NEAR(CountZeroCrossings(
+                      expected_audio_frame->audio_bus->channel(ch),
+                      expected_audio_frame->audio_bus->frames()),
+                  CountZeroCrossings(audio_bus->channel(ch),
+                                     audio_bus->frames()),
+                  1);
+    }
+
+    // TODO(miu): This is a "fuzzy" way to check the timestamps.  We should be
+    // able to compute exact offsets with "omnipotent" knowledge of the system.
     const base::TimeTicks upper_bound =
-        expected_audio_frame.record_time +
+        expected_audio_frame->record_time +
         base::TimeDelta::FromMilliseconds(kDefaultRtpMaxDelayMs +
                                           kTimerErrorMs);
     EXPECT_GE(upper_bound, playout_time)
         << "playout_time - upper_bound == "
         << (playout_time - upper_bound).InMicroseconds() << " usec";
-    EXPECT_LT(expected_audio_frame.record_time, playout_time)
-        << "playout_time - expected == "
-        << (playout_time - expected_audio_frame.record_time).InMilliseconds()
-        << " mS";
 
-    EXPECT_EQ(audio_frame->samples.size(),
-              expected_audio_frame.audio_frame.samples.size());
+    EXPECT_TRUE(is_continuous);
   }
 
-  void CheckPcmAudioFrame(scoped_ptr<PcmAudioFrame> audio_frame,
-                          const base::TimeTicks& playout_time) {
-    ++num_called_;
-
-    CheckBasicAudioFrame(audio_frame, playout_time);
-    ExpectedAudioFrame expected_audio_frame = expected_frame_.front();
-    expected_frame_.pop_front();
-    if (audio_frame->samples.size() == 0)
-      return;  // No more checks needed.
-
-    EXPECT_NEAR(CountZeroCrossings(expected_audio_frame.audio_frame.samples),
-                CountZeroCrossings(audio_frame->samples),
-                1);
-  }
-
-  void CheckCodedPcmAudioFrame(
+  void CheckCodedAudioFrame(
       scoped_ptr<transport::EncodedAudioFrame> audio_frame,
       const base::TimeTicks& playout_time) {
-    ++num_called_;
+    ASSERT_FALSE(expected_frames_.empty());
+    const ExpectedAudioFrame& expected_audio_frame =
+        *(expected_frames_.front());
+    // Note: Just peeking here.  Will delegate to CheckAudioFrame() to pop.
 
-    EXPECT_FALSE(expected_frame_.empty());  // Test for bug in test code.
-    ExpectedAudioFrame expected_audio_frame = expected_frame_.front();
-    expected_frame_.pop_front();
+    // We need to "decode" the encoded audio frame.  The codec is simply to
+    // swizzle the bytes of each int16 from host-->network-->host order to get
+    // interleaved int16 PCM.  Then, make an AudioBus out of that.
+    const int num_elements = audio_frame->data.size() / sizeof(int16);
+    ASSERT_EQ(expected_audio_frame.audio_bus->channels() *
+                  expected_audio_frame.audio_bus->frames(),
+              num_elements);
+    int16* const pcm_data =
+        reinterpret_cast<int16*>(string_as_array(&audio_frame->data));
+    for (int i = 0; i < num_elements; ++i)
+      pcm_data[i] = static_cast<int16>(base::NetToHost16(pcm_data[i]));
+    scoped_ptr<AudioBus> audio_bus(
+        AudioBus::Create(expected_audio_frame.audio_bus->channels(),
+                         expected_audio_frame.audio_bus->frames()));
+    audio_bus->FromInterleaved(pcm_data, audio_bus->frames(), sizeof(int16));
 
-    EXPECT_EQ(static_cast<int>(audio_frame->data.size()),
-              2 * kAudioChannels * expected_sampling_frequency_ / 100);
-
-    base::TimeDelta time_since_recording =
-        playout_time - expected_audio_frame.record_time;
-
-    EXPECT_LE(time_since_recording,
-              base::TimeDelta::FromMilliseconds(kDefaultRtpMaxDelayMs +
-                                                kTimerErrorMs));
-
-    EXPECT_LT(expected_audio_frame.record_time, playout_time);
-    if (audio_frame->data.size() == 0)
-      return;  // No more checks needed.
-
-    // We need to convert our "coded" audio frame to our raw format.
-    std::vector<int16> output_audio_samples;
-    size_t number_of_samples = audio_frame->data.size() / 2;
-
-    for (size_t i = 0; i < number_of_samples; ++i) {
-      uint16 sample =
-          static_cast<uint8>(audio_frame->data[1 + i * sizeof(uint16)]) +
-          (static_cast<uint16>(audio_frame->data[i * sizeof(uint16)]) << 8);
-      output_audio_samples.push_back(static_cast<int16>(sample));
-    }
-
-    EXPECT_NEAR(CountZeroCrossings(expected_audio_frame.audio_frame.samples),
-                CountZeroCrossings(output_audio_samples),
-                1);
+    // Delegate the checking from here...
+    CheckAudioFrame(audio_bus.Pass(), playout_time, true);
   }
 
   int number_times_called() const { return num_called_; }
 
  protected:
-  virtual ~TestReceiverAudioCallback() {}
+  virtual ~TestReceiverAudioCallback() {
+    STLDeleteElements(&expected_frames_);
+  }
 
  private:
   friend class base::RefCountedThreadSafe<TestReceiverAudioCallback>;
 
   int num_called_;
   int expected_sampling_frequency_;
-  std::list<ExpectedAudioFrame> expected_frame_;
+  std::list<ExpectedAudioFrame*> expected_frames_;
 };
 
 // Class that verifies the video frames coming out of the receiver.
 class TestReceiverVideoCallback
     : public base::RefCountedThreadSafe<TestReceiverVideoCallback> {
  public:
   struct ExpectedVideoFrame {
     int start_value;
     int width;
     int height;
@@ skipping 20 matching lines @@
 
     EXPECT_FALSE(expected_frame_.empty());  // Test for bug in test code.
     ExpectedVideoFrame expected_video_frame = expected_frame_.front();
     expected_frame_.pop_front();
 
     base::TimeDelta time_since_capture =
         render_time - expected_video_frame.capture_time;
     const base::TimeDelta upper_bound = base::TimeDelta::FromMilliseconds(
         kDefaultRtpMaxDelayMs + kTimerErrorMs);
 
+    // TODO(miu): This is a "fuzzy" way to check the timestamps.  We should be
+    // able to compute exact offsets with "omnipotent" knowledge of the system.
     EXPECT_GE(upper_bound, time_since_capture)
         << "time_since_capture - upper_bound == "
-        << (time_since_capture - upper_bound).InMilliseconds() << " mS";
+        << (time_since_capture - upper_bound).InMicroseconds() << " usec";
     EXPECT_LE(expected_video_frame.capture_time, render_time);
     EXPECT_EQ(expected_video_frame.width, video_frame->coded_size().width());
     EXPECT_EQ(expected_video_frame.height, video_frame->coded_size().height());
 
     gfx::Size size(expected_video_frame.width, expected_video_frame.height);
     scoped_refptr<media::VideoFrame> expected_I420_frame =
         media::VideoFrame::CreateFrame(
             VideoFrame::I420, size, gfx::Rect(size), size, base::TimeDelta());
     PopulateVideoFrame(expected_I420_frame, expected_video_frame.start_value);
 
@@ skipping 40 matching lines @@
         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_);
   }
 
-  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) {
+  void Configure(transport::AudioCodec audio_codec,
+                 int audio_sampling_frequency,
+                 bool external_audio_decoder,
+                 int max_number_of_video_buffers_used) {
     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 =
@@ skipping 37 matching lines @@
     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)
+        test_receiver_audio_callback_->AddExpectedResult(*audio_bus, send_time);
+      audio_frame_input_->InsertAudio(audio_bus.Pass(), send_time);
+    }
+  }
+
+  void FeedAudioFramesWithExpectedDelay(int count,
+                                        const base::TimeDelta& delay) {
+    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);
+      test_receiver_audio_callback_->AddExpectedResult(*audio_bus,
+                                                       send_time + delay);
+      audio_frame_input_->InsertAudio(audio_bus.Pass(), send_time);
+    }
+  }
+
+  void RequestAudioFrames(int count, bool with_check) {
+    for (int i = 0; i < count; ++i) {
+      frame_receiver_->GetRawAudioFrame(
+          base::Bind(with_check ? &TestReceiverAudioCallback::CheckAudioFrame :
+                                  &TestReceiverAudioCallback::IgnoreAudioFrame,
+                     test_receiver_audio_callback_));
+    }
+  }
+
   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 transport::CastTransportSenderImpl(
         NULL,
         testing_clock_sender_,
         dummy_endpoint,
@@ skipping 114 matching lines @@
 
   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);
+  Configure(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();
 
+  const int kNumIterations = 50;
   int video_start = kVideoStart;
   int audio_diff = kFrameTimerMs;
-  int i = 0;
+  int num_audio_frames_requested = 0;
+  for (int i = 0; i < kNumIterations; ++i) {
+    const int num_audio_frames = audio_diff / kAudioFrameDurationMs;
+    audio_diff -= num_audio_frames * kAudioFrameDurationMs;
 
-  for (; i < 300; ++i) {
-    int num_10ms_blocks = audio_diff / 10;
-    audio_diff -= num_10ms_blocks * 10;
-
-    scoped_ptr<AudioBus> audio_bus(audio_bus_factory_->NextAudioBus(
-        base::TimeDelta::FromMilliseconds(10) * num_10ms_blocks));
-
-    base::TimeTicks send_time = testing_clock_sender_->NowTicks();
-    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),
-          num_10ms_blocks,
-          send_time);
-    }
-
-    audio_frame_input_->InsertAudio(audio_bus.Pass(), send_time);
+    if (num_audio_frames > 0)
+      FeedAudioFrames(1, true);
 
     test_receiver_video_callback_->AddExpectedResult(
         video_start,
         video_sender_config_.width,
         video_sender_config_.height,
-        send_time);
-    SendVideoFrame(video_start, send_time);
+        testing_clock_sender_->NowTicks());
+    SendVideoFrame(video_start, testing_clock_sender_->NowTicks());
 
-    if (i == 0) {
-      frame_receiver_->GetRawAudioFrame(
-          num_10ms_blocks,
-          audio_sender_config_.frequency,
-          base::Bind(&TestReceiverAudioCallback::IgnoreAudioFrame,
-                     test_receiver_audio_callback_));
-    } else {
-      frame_receiver_->GetRawAudioFrame(
-          num_10ms_blocks,
-          audio_sender_config_.frequency,
-          base::Bind(&TestReceiverAudioCallback::CheckPcmAudioFrame,
-                     test_receiver_audio_callback_));
-    }
+    if (num_audio_frames > 0)
+      RunTasks(kAudioFrameDurationMs);  // Advance clock forward.
+    if (num_audio_frames > 1)
+      FeedAudioFrames(num_audio_frames - 1, true);
+
+    RequestAudioFrames(num_audio_frames, true);
+    num_audio_frames_requested += num_audio_frames;
 
     frame_receiver_->GetRawVideoFrame(
         base::Bind(&TestReceiverVideoCallback::CheckVideoFrame,
                    test_receiver_video_callback_));
 
-    RunTasks(kFrameTimerMs);
+    RunTasks(kFrameTimerMs - kAudioFrameDurationMs);
     audio_diff += kFrameTimerMs;
     video_start++;
   }
 
   RunTasks(2 * kFrameTimerMs + 1);  // Empty the receiver pipeline.
-  EXPECT_EQ(i - 1, test_receiver_audio_callback_->number_times_called());
-  EXPECT_EQ(i, test_receiver_video_callback_->number_times_called());
+  EXPECT_EQ(num_audio_frames_requested,
+            test_receiver_audio_callback_->number_times_called());
+  EXPECT_EQ(kNumIterations,
+            test_receiver_video_callback_->number_times_called());
 }
 
 // This tests our external decoder interface for Audio.
 // Audio test without packet loss using raw PCM 16 audio "codec";
 TEST_F(End2EndTest, LoopNoLossPcm16ExternalDecoder) {
-  SetupConfig(transport::kPcm16, 32000, true, 1);
+  Configure(transport::kPcm16, 32000, true, 1);
   Create();
 
-  int i = 0;
-  for (; i < 10; ++i) {
-    base::TimeTicks send_time = testing_clock_sender_->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);
-
-    audio_frame_input_->InsertAudio(audio_bus.Pass(), send_time);
-
-    RunTasks(10);
+  const int kNumIterations = 10;
+  for (int i = 0; i < kNumIterations; ++i) {
+    FeedAudioFrames(1, true);
+    RunTasks(kAudioFrameDurationMs);
     frame_receiver_->GetCodedAudioFrame(
-        base::Bind(&TestReceiverAudioCallback::CheckCodedPcmAudioFrame,
+        base::Bind(&TestReceiverAudioCallback::CheckCodedAudioFrame,
                    test_receiver_audio_callback_));
   }
   RunTasks(2 * kFrameTimerMs + 1);  // Empty the receiver pipeline.
-  EXPECT_EQ(10, test_receiver_audio_callback_->number_times_called());
+  EXPECT_EQ(kNumIterations,
+            test_receiver_audio_callback_->number_times_called());
 }
 
 // This tests our Opus audio codec without video.
 TEST_F(End2EndTest, LoopNoLossOpus) {
-  SetupConfig(transport::kOpus, kDefaultAudioSamplingRate, false, 1);
+  Configure(transport::kOpus, kDefaultAudioSamplingRate, false, 1);
   Create();
 
-  int i = 0;
-  for (; i < 10; ++i) {
-    int num_10ms_blocks = 3;
-    base::TimeTicks send_time = testing_clock_sender_->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);
-    }
-
-    audio_frame_input_->InsertAudio(audio_bus.Pass(), send_time);
-
-    RunTasks(30);
-
-    if (i == 0) {
-      frame_receiver_->GetRawAudioFrame(
-          num_10ms_blocks,
-          audio_sender_config_.frequency,
-          base::Bind(&TestReceiverAudioCallback::IgnoreAudioFrame,
-                     test_receiver_audio_callback_));
-    } else {
-      frame_receiver_->GetRawAudioFrame(
-          num_10ms_blocks,
-          audio_sender_config_.frequency,
-          base::Bind(&TestReceiverAudioCallback::CheckPcmAudioFrame,
-                     test_receiver_audio_callback_));
-    }
+  const int kNumIterations = 300;
+  for (int i = 0; i < kNumIterations; ++i) {
+    // Opus introduces a tiny delay before the sinewave starts; so don't examine
+    // the first frame.
+    const bool examine_audio_data = i > 0;
+    FeedAudioFrames(1, examine_audio_data);
+    RunTasks(kAudioFrameDurationMs);
+    RequestAudioFrames(1, examine_audio_data);
   }
   RunTasks(2 * kFrameTimerMs + 1);  // Empty the receiver pipeline.
-  EXPECT_EQ(i - 1, test_receiver_audio_callback_->number_times_called());
+  EXPECT_EQ(kNumIterations,
+            test_receiver_audio_callback_->number_times_called());
 }
 
 // This tests start sending audio and video at start-up time before the receiver
 // is ready; it sends 2 frames before the receiver comes online.
-TEST_F(End2EndTest, StartSenderBeforeReceiver) {
-  SetupConfig(transport::kOpus, kDefaultAudioSamplingRate, false, 1);
+//
+// Test disabled due to flakiness: It appears that the RTCP synchronization
+// sometimes kicks in, and sometimes doesn't.  When it does, there's a sharp
+// discontinuity in the timeline, throwing off the test expectations.  See TODOs
+// in audio_receiver.cc for likely cause(s) of this bug.
+// http://crbug.com/356942
+TEST_F(End2EndTest, DISABLED_StartSenderBeforeReceiver) {
+  Configure(transport::kPcm16, kDefaultAudioSamplingRate, false, 1);
   Create();
 
   int video_start = kVideoStart;
   int audio_diff = kFrameTimerMs;
 
   sender_to_receiver_.SetSendPackets(false);
 
   const int test_delay_ms = 100;
 
-  base::TimeTicks initial_send_time;
-  for (int i = 0; i < 2; ++i) {
-    int num_10ms_blocks = audio_diff / 10;
-    audio_diff -= num_10ms_blocks * 10;
+  const int kNumVideoFramesBeforeReceiverStarted = 2;
+  const base::TimeTicks initial_send_time = testing_clock_sender_->NowTicks();
+  const base::TimeDelta expected_delay =
+      base::TimeDelta::FromMilliseconds(test_delay_ms + kFrameTimerMs);
+  for (int i = 0; i < kNumVideoFramesBeforeReceiverStarted; ++i) {
+    const int num_audio_frames = audio_diff / kAudioFrameDurationMs;
+    audio_diff -= num_audio_frames * kAudioFrameDurationMs;
 
-    base::TimeTicks send_time = testing_clock_sender_->NowTicks();
-    if (initial_send_time.is_null())
-      initial_send_time = send_time;
-    scoped_ptr<AudioBus> audio_bus(audio_bus_factory_->NextAudioBus(
-        base::TimeDelta::FromMilliseconds(10) * num_10ms_blocks));
-
-    audio_frame_input_->InsertAudio(audio_bus.Pass(), send_time);
+    if (num_audio_frames > 0)
+      FeedAudioFramesWithExpectedDelay(1, expected_delay);
 
     // Frame will be rendered with 100mS delay, as the transmission is delayed.
     // The receiver at this point cannot be synced to the sender's clock, as no
     // packets, and specifically no RTCP packets were sent.
     test_receiver_video_callback_->AddExpectedResult(
         video_start,
         video_sender_config_.width,
         video_sender_config_.height,
-        initial_send_time +
-            base::TimeDelta::FromMilliseconds(test_delay_ms + kFrameTimerMs));
+        initial_send_time + expected_delay);
+    SendVideoFrame(video_start, testing_clock_sender_->NowTicks());
 
-    SendVideoFrame(video_start, send_time);
-    RunTasks(kFrameTimerMs);
+    if (num_audio_frames > 0)
+      RunTasks(kAudioFrameDurationMs);  // Advance clock forward.
+    if (num_audio_frames > 1)
+      FeedAudioFramesWithExpectedDelay(num_audio_frames - 1, expected_delay);
+
+    RunTasks(kFrameTimerMs - kAudioFrameDurationMs);
     audio_diff += kFrameTimerMs;
     video_start++;
   }
 
   RunTasks(test_delay_ms);
   sender_to_receiver_.SetSendPackets(true);
 
-  int j = 0;
-  const int number_of_audio_frames_to_ignore = 2;
-  for (; j < 10; ++j) {
-    int num_10ms_blocks = audio_diff / 10;
-    audio_diff -= num_10ms_blocks * 10;
-    base::TimeTicks send_time = testing_clock_sender_->NowTicks();
+  int num_audio_frames_requested = 0;
+  for (int j = 0; j < 10; ++j) {
+    const int num_audio_frames = audio_diff / kAudioFrameDurationMs;
+    audio_diff -= num_audio_frames * kAudioFrameDurationMs;
 
-    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);
-    }
-
-    audio_frame_input_->InsertAudio(audio_bus.Pass(), send_time);
+    if (num_audio_frames > 0)
+      FeedAudioFrames(1, true);
 
     test_receiver_video_callback_->AddExpectedResult(
         video_start,
         video_sender_config_.width,
         video_sender_config_.height,
-        send_time);
+        testing_clock_sender_->NowTicks());
+    SendVideoFrame(video_start, testing_clock_sender_->NowTicks());
 
-    SendVideoFrame(video_start, send_time);
-    RunTasks(kFrameTimerMs);
-    audio_diff += kFrameTimerMs;
+    if (num_audio_frames > 0)
+      RunTasks(kAudioFrameDurationMs);  // Advance clock forward.
+    if (num_audio_frames > 1)
+      FeedAudioFrames(num_audio_frames - 1, true);
 
-    if (j < number_of_audio_frames_to_ignore) {
-      frame_receiver_->GetRawAudioFrame(
-          num_10ms_blocks,
-          audio_sender_config_.frequency,
-          base::Bind(&TestReceiverAudioCallback::IgnoreAudioFrame,
-                     test_receiver_audio_callback_));
-    } else {
-      frame_receiver_->GetRawAudioFrame(
-          num_10ms_blocks,
-          audio_sender_config_.frequency,
-          base::Bind(&TestReceiverAudioCallback::CheckPcmAudioFrame,
-                     test_receiver_audio_callback_));
-    }
+    RequestAudioFrames(num_audio_frames, true);
+    num_audio_frames_requested += num_audio_frames;
+
     frame_receiver_->GetRawVideoFrame(
         base::Bind(&TestReceiverVideoCallback::CheckVideoFrame,
                    test_receiver_video_callback_));
+
+    RunTasks(kFrameTimerMs - kAudioFrameDurationMs);
+    audio_diff += kFrameTimerMs;
     video_start++;
   }
   RunTasks(2 * kFrameTimerMs + 1);  // Empty the receiver pipeline.
-  EXPECT_EQ(j - number_of_audio_frames_to_ignore,
+  EXPECT_EQ(num_audio_frames_requested,
             test_receiver_audio_callback_->number_times_called());
-  EXPECT_EQ(j, test_receiver_video_callback_->number_times_called());
+  EXPECT_EQ(10, test_receiver_video_callback_->number_times_called());
 }
 
 // This tests a network glitch lasting for 10 video frames.
 // Flaky. See crbug.com/351596.
 TEST_F(End2EndTest, DISABLED_GlitchWith3Buffers) {
-  SetupConfig(transport::kOpus, kDefaultAudioSamplingRate, false, 3);
+  Configure(transport::kOpus, kDefaultAudioSamplingRate, false, 3);
   video_sender_config_.rtp_config.max_delay_ms = 67;
   video_receiver_config_.rtp_max_delay_ms = 67;
   Create();
 
   int video_start = kVideoStart;
   base::TimeTicks send_time;
   // Frames will rendered on completion until the render time stabilizes, i.e.
   // we got enough data.
   const int frames_before_glitch = 20;
   for (int i = 0; i < frames_before_glitch; ++i) {
@@ skipping 38 matching lines @@
   frame_receiver_->GetRawVideoFrame(
       base::Bind(&TestReceiverVideoCallback::CheckVideoFrame,
                  test_receiver_video_callback_));
 
   RunTasks(2 * kFrameTimerMs + 1);  // Empty the receiver pipeline.
   EXPECT_EQ(frames_before_glitch + 1,
             test_receiver_video_callback_->number_times_called());
 }
 
 TEST_F(End2EndTest, DropEveryOtherFrame3Buffers) {
-  SetupConfig(transport::kOpus, kDefaultAudioSamplingRate, false, 3);
+  Configure(transport::kOpus, kDefaultAudioSamplingRate, false, 3);
   video_sender_config_.rtp_config.max_delay_ms = 67;
   video_receiver_config_.rtp_max_delay_ms = 67;
   Create();
   sender_to_receiver_.DropAllPacketsBelongingToOddFrames();
 
   int video_start = kVideoStart;
   base::TimeTicks send_time;
 
   int i = 0;
   for (; i < 20; ++i) {
@@ skipping 15 matching lines @@
     }
     RunTasks(kFrameTimerMs);
     video_start++;
   }
 
   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);
+  Configure(transport::kOpus, kDefaultAudioSamplingRate, false, 3);
   video_sender_config_.rtp_config.max_delay_ms = 67;
   video_receiver_config_.rtp_max_delay_ms = 67;
   Create();
   sender_to_receiver_.AlwaysResetReferenceFrameId();
 
   int frames_counter = 0;
   for (; frames_counter < 10; ++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);
 
     // 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_));
     RunTasks(kFrameTimerMs);
   }
   RunTasks(2 * kFrameTimerMs + 1);  // Empty the pipeline.
   EXPECT_EQ(frames_counter,
             test_receiver_video_callback_->number_times_called());
 }
 
 TEST_F(End2EndTest, CryptoVideo) {
-  SetupConfig(transport::kPcm16, 32000, false, 1);
+  Configure(transport::kPcm16, 32000, false, 1);
 
   transport_video_config_.base.aes_iv_mask =
       ConvertFromBase16String("1234567890abcdeffedcba0987654321");
   transport_video_config_.base.aes_key =
       ConvertFromBase16String("deadbeefcafeb0b0b0b0cafedeadbeef");
 
   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();
@@ skipping 16 matching lines @@
         base::Bind(&TestReceiverVideoCallback::CheckVideoFrame,
                    test_receiver_video_callback_));
     RunTasks(kFrameTimerMs);
   }
   RunTasks(2 * kFrameTimerMs + 1);  // Empty the pipeline.
   EXPECT_EQ(frames_counter,
             test_receiver_video_callback_->number_times_called());
 }
 
 TEST_F(End2EndTest, CryptoAudio) {
-  SetupConfig(transport::kPcm16, 32000, false, 1);
+  Configure(transport::kPcm16, 32000, false, 1);
 
   transport_audio_config_.base.aes_iv_mask =
       ConvertFromBase16String("abcdeffedcba12345678900987654321");
   transport_audio_config_.base.aes_key =
       ConvertFromBase16String("deadbeefcafecafedeadbeefb0b0b0b0");
 
   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();
 
-  int frames_counter = 0;
-  for (; frames_counter < 3; ++frames_counter) {
-    int num_10ms_blocks = 2;
-
-    const base::TimeTicks send_time = testing_clock_sender_->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),
-          num_10ms_blocks,
-          send_time);
-    }
-    audio_frame_input_->InsertAudio(audio_bus.Pass(), send_time);
-
-    RunTasks(num_10ms_blocks * 10);
-
-    if (frames_counter == 0) {
-      frame_receiver_->GetRawAudioFrame(
-          num_10ms_blocks,
-          32000,
-          base::Bind(&TestReceiverAudioCallback::IgnoreAudioFrame,
-                     test_receiver_audio_callback_));
-    } else {
-      frame_receiver_->GetRawAudioFrame(
-          num_10ms_blocks,
-          32000,
-          base::Bind(&TestReceiverAudioCallback::CheckPcmAudioFrame,
-                     test_receiver_audio_callback_));
-    }
+  const int kNumIterations = 3;
+  const int kNumAudioFramesPerIteration = 2;
+  for (int i = 0; i < kNumIterations; ++i) {
+    FeedAudioFrames(kNumAudioFramesPerIteration, true);
+    RunTasks(kNumAudioFramesPerIteration * kAudioFrameDurationMs);
+    RequestAudioFrames(kNumAudioFramesPerIteration, true);
   }
   RunTasks(2 * kFrameTimerMs + 1);  // Empty the pipeline.
-  EXPECT_EQ(frames_counter - 1,
+  EXPECT_EQ(kNumIterations * kNumAudioFramesPerIteration,
             test_receiver_audio_callback_->number_times_called());
 }
 
 // Video test without packet loss - tests the logging aspects of the end2end,
 // but is basically equivalent to LoopNoLossPcm16.
 TEST_F(End2EndTest, VideoLogging) {
-  SetupConfig(transport::kPcm16, 32000, false, 1);
+  Configure(transport::kPcm16, 32000, false, 1);
   Create();
 
   int video_start = kVideoStart;
   const int num_frames = 5;
   for (int i = 0; i < num_frames; ++i) {
     base::TimeTicks send_time = testing_clock_sender_->NowTicks();
     test_receiver_video_callback_->AddExpectedResult(
         video_start,
         video_sender_config_.width,
         video_sender_config_.height,
@@ skipping 100 matching lines @@
 
     // Verify that there were no other events logged with respect to this
     // packet. (i.e. Total event count = expected event count)
     EXPECT_EQ(total_event_count_for_packet, expected_event_count_for_packet);
   }
 }
 
 // Audio test without packet loss - tests the logging aspects of the end2end,
 // but is basically equivalent to LoopNoLossPcm16.
 TEST_F(End2EndTest, AudioLogging) {
-  SetupConfig(transport::kPcm16, 32000, false, 1);
+  Configure(transport::kPcm16, 32000, false, 1);
   Create();
 
   int audio_diff = kFrameTimerMs;
-  const int num_audio_buses = 10;
-  int num_frames = 0;
-  for (int i = 0; i < num_audio_buses; ++i) {
-    int num_10ms_blocks = audio_diff / 10;
-    audio_diff -= num_10ms_blocks * 10;
-    base::TimeTicks send_time = testing_clock_sender_->NowTicks();
+  const int kNumVideoFrames = 10;
+  int num_audio_frames_requested = 0;
+  for (int i = 0; i < kNumVideoFrames; ++i) {
+    const int num_audio_frames = audio_diff / kAudioFrameDurationMs;
+    audio_diff -= num_audio_frames * kAudioFrameDurationMs;
 
-    // Each audio bus can contain more than one frame.
-    scoped_ptr<AudioBus> audio_bus(audio_bus_factory_->NextAudioBus(
-        base::TimeDelta::FromMilliseconds(10) * num_10ms_blocks));
-    num_frames += 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),
-          num_10ms_blocks,
-          send_time);
-    }
-
-    audio_frame_input_->InsertAudio(audio_bus.Pass(), send_time);
+    FeedAudioFrames(num_audio_frames, true);
 
     RunTasks(kFrameTimerMs);
     audio_diff += kFrameTimerMs;
 
-    if (i == 0) {
-      frame_receiver_->GetRawAudioFrame(
-          num_10ms_blocks,
-          audio_sender_config_.frequency,
-          base::Bind(&TestReceiverAudioCallback::IgnoreAudioFrame,
-                     test_receiver_audio_callback_));
-    } else {
-      frame_receiver_->GetRawAudioFrame(
-          num_10ms_blocks,
-          audio_sender_config_.frequency,
-          base::Bind(&TestReceiverAudioCallback::CheckPcmAudioFrame,
-                     test_receiver_audio_callback_));
-    }
+    RequestAudioFrames(num_audio_frames, true);
+    num_audio_frames_requested += num_audio_frames;
   }
 
   // Basic tests.
   RunTasks(2 * kFrameTimerMs + 1);  // Empty the receiver pipeline.
 
-  int num_times_called = test_receiver_audio_callback_->number_times_called();
-  EXPECT_EQ(num_audio_buses - 1, num_times_called);
+  EXPECT_EQ(num_audio_frames_requested,
+            test_receiver_audio_callback_->number_times_called());
 
   // Logging tests.
   // Verify that all frames and all required events were logged.
   event_subscriber_sender_.GetFrameEventsAndReset(&frame_events_);
 
   // Construct a map from each frame (RTP timestamp) to a count of each event
   // type logged for that frame.
   std::map<RtpTimestamp, LoggingEventCounts> event_counter_for_frame =
       GetEventCountForFrameEvents(frame_events_);
 
   int received_count = 0;
   int encoded_count = 0;
 
   // Verify the right number of events were logged for each event type.
   for (std::map<RtpTimestamp, LoggingEventCounts>::iterator it =
            event_counter_for_frame.begin();
        it != event_counter_for_frame.end();
        ++it) {
     received_count += it->second.counter[kAudioFrameReceived];
     encoded_count += it->second.counter[kAudioFrameEncoded];
   }
 
-  EXPECT_EQ(num_frames, received_count);
-  EXPECT_EQ(num_frames, encoded_count);
+  EXPECT_EQ(num_audio_frames_requested, received_count);
+  EXPECT_EQ(num_audio_frames_requested, encoded_count);
 
   std::map<RtpTimestamp, LoggingEventCounts>::iterator map_it =
       event_counter_for_frame.begin();
 
   // Verify that each frame have the expected types of events logged.
   // TODO(imcheng): This only checks the first frame. This doesn't work
   // properly for all frames because:
   // 1. kAudioPlayoutDelay and kAudioFrameDecoded RTP timestamps aren't
   // exactly aligned with those of kAudioFrameReceived and kAudioFrameEncoded.
   // Note that these RTP timestamps are output from webrtc::AudioCodingModule
@@ skipping 30 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