Merge from Chromium at DEPS revision 257591

This commit was generated by merge_to_master.py.

Change-Id: I0010df2ec3fbb5d4947cd026de2feb150ce7a6b5

6 files changed, 89 insertions, 147 deletions

diff --git a/media/cast/audio_sender/audio_encoder.cc b/media/cast/audio_sender/audio_encoder.cc
index 2363619750..a1b0c95645 100644
--- a/media/cast/audio_sender/audio_encoder.cc
+++ b/media/cast/audio_sender/audio_encoder.cc
@@ -9,6 +9,7 @@
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/logging.h"
+#include "base/memory/ref_counted.h"
 #include "base/message_loop/message_loop.h"
 #include "base/sys_byteorder.h"
 #include "base/time/time.h"
@@ -26,9 +27,11 @@ namespace cast {
 //
 // Subclasses complete the implementation by handling the actual encoding
 // details.
-class AudioEncoder::ImplBase : public base::SupportsWeakPtr<ImplBase> {
+class AudioEncoder::ImplBase
+    : public base::RefCountedThreadSafe<AudioEncoder::ImplBase>,
+      public base::SupportsWeakPtr<ImplBase> {
  public:
-  ImplBase(CastEnvironment* cast_environment,
+  ImplBase(const scoped_refptr<CastEnvironment>& cast_environment,
            transport::AudioCodec codec,
            int num_channels,
            int sampling_rate,
@@ -52,16 +55,14 @@ class AudioEncoder::ImplBase : public base::SupportsWeakPtr<ImplBase> {
         sampling_rate % 100 != 0 ||
         samples_per_10ms_ * num_channels_ >
             transport::EncodedAudioFrame::kMaxNumberOfSamples) {
-      initialization_status_ = STATUS_INVALID_AUDIO_CONFIGURATION;
+      cast_initialization_cb_ = STATUS_INVALID_AUDIO_CONFIGURATION;
     } else {
-      initialization_status_ = STATUS_INITIALIZED;
+      cast_initialization_cb_ = STATUS_AUDIO_INITIALIZED;
     }
   }
 
-  virtual ~ImplBase() {}
-
   CastInitializationStatus InitializationResult() const {
-    return initialization_status_;
+    return cast_initialization_cb_;
   }
 
   void LogAudioFrameEvent(uint32 rtp_timestamp,
@@ -71,27 +72,19 @@ class AudioEncoder::ImplBase : public base::SupportsWeakPtr<ImplBase> {
         cast_environment_->Clock()->NowTicks(), type, rtp_timestamp, frame_id);
   }
 
-  void EncodeAudio(const AudioBus* audio_bus,
-                   const base::TimeTicks& recorded_time,
-                   const base::Closure& done_callback) {
+  void EncodeAudio(scoped_ptr<AudioBus> audio_bus,
+                   const base::TimeTicks& recorded_time) {
     int src_pos = 0;
     int packet_count = 0;
-    while (audio_bus && src_pos < audio_bus->frames()) {
+    while (src_pos < audio_bus->frames()) {
       const int num_samples_to_xfer = std::min(
           samples_per_10ms_ - buffer_fill_end_, audio_bus->frames() - src_pos);
       DCHECK_EQ(audio_bus->channels(), num_channels_);
       TransferSamplesIntoBuffer(
-          audio_bus, src_pos, buffer_fill_end_, num_samples_to_xfer);
+          audio_bus.get(), src_pos, buffer_fill_end_, num_samples_to_xfer);
       src_pos += num_samples_to_xfer;
       buffer_fill_end_ += num_samples_to_xfer;
 
-      if (src_pos == audio_bus->frames()) {
-        cast_environment_->PostTask(
-            CastEnvironment::MAIN, FROM_HERE, done_callback);
-        // Note: |audio_bus| is invalid once done_callback is invoked.
-        audio_bus = NULL;
-      }
-
       if (buffer_fill_end_ == samples_per_10ms_) {
         scoped_ptr<transport::EncodedAudioFrame> audio_frame(
             new transport::EncodedAudioFrame());
@@ -145,18 +138,21 @@ class AudioEncoder::ImplBase : public base::SupportsWeakPtr<ImplBase> {
   }
 
  protected:
+  friend class base::RefCountedThreadSafe<ImplBase>;
+  virtual ~ImplBase() {}
+
   virtual void TransferSamplesIntoBuffer(const AudioBus* audio_bus,
                                          int source_offset,
                                          int buffer_fill_offset,
                                          int num_samples) = 0;
   virtual bool EncodeFromFilledBuffer(std::string* out) = 0;
 
-  CastEnvironment* const cast_environment_;
+  const scoped_refptr<CastEnvironment> cast_environment_;
   const transport::AudioCodec codec_;
   const int num_channels_;
   const int samples_per_10ms_;
   const FrameEncodedCallback callback_;
-  CastInitializationStatus initialization_status_;
+  CastInitializationStatus cast_initialization_cb_;
 
  private:
   // In the case where a call to EncodeAudio() cannot completely fill the
@@ -179,7 +175,7 @@ class AudioEncoder::ImplBase : public base::SupportsWeakPtr<ImplBase> {
 
 class AudioEncoder::OpusImpl : public AudioEncoder::ImplBase {
  public:
-  OpusImpl(CastEnvironment* cast_environment,
+  OpusImpl(const scoped_refptr<CastEnvironment>& cast_environment,
            int num_channels,
            int sampling_rate,
            int bitrate,
@@ -192,7 +188,7 @@ class AudioEncoder::OpusImpl : public AudioEncoder::ImplBase {
         encoder_memory_(new uint8[opus_encoder_get_size(num_channels)]),
         opus_encoder_(reinterpret_cast<OpusEncoder*>(encoder_memory_.get())),
         buffer_(new float[num_channels * samples_per_10ms_]) {
-    if (ImplBase::initialization_status_ != STATUS_INITIALIZED) {
+    if (ImplBase::cast_initialization_cb_ != STATUS_AUDIO_INITIALIZED) {
       return;
     }
 
@@ -211,9 +207,9 @@ class AudioEncoder::OpusImpl : public AudioEncoder::ImplBase {
              OPUS_OK);
   }
 
+ private:
   virtual ~OpusImpl() {}
 
- private:
   virtual void TransferSamplesIntoBuffer(const AudioBus* audio_bus,
                                          int source_offset,
                                          int buffer_fill_offset,
@@ -266,7 +262,7 @@ class AudioEncoder::OpusImpl : public AudioEncoder::ImplBase {
 
 class AudioEncoder::Pcm16Impl : public AudioEncoder::ImplBase {
  public:
-  Pcm16Impl(CastEnvironment* cast_environment,
+  Pcm16Impl(const scoped_refptr<CastEnvironment>& cast_environment,
             int num_channels,
             int sampling_rate,
             const FrameEncodedCallback& callback)
@@ -277,9 +273,9 @@ class AudioEncoder::Pcm16Impl : public AudioEncoder::ImplBase {
                  callback),
         buffer_(new int16[num_channels * samples_per_10ms_]) {}
 
+ private:
   virtual ~Pcm16Impl() {}
 
- private:
   virtual void TransferSamplesIntoBuffer(const AudioBus* audio_bus,
                                          int source_offset,
                                          int buffer_fill_offset,
@@ -316,20 +312,19 @@ AudioEncoder::AudioEncoder(
   // Note: It doesn't matter which thread constructs AudioEncoder, just so long
   // as all calls to InsertAudio() are by the same thread.
   insert_thread_checker_.DetachFromThread();
-
   switch (audio_config.codec) {
     case transport::kOpus:
-      impl_.reset(new OpusImpl(cast_environment,
-                               audio_config.channels,
-                               audio_config.frequency,
-                               audio_config.bitrate,
-                               frame_encoded_callback));
+      impl_ = new OpusImpl(cast_environment,
+                           audio_config.channels,
+                           audio_config.frequency,
+                           audio_config.bitrate,
+                           frame_encoded_callback);
       break;
     case transport::kPcm16:
-      impl_.reset(new Pcm16Impl(cast_environment,
-                                audio_config.channels,
-                                audio_config.frequency,
-                                frame_encoded_callback));
+      impl_ = new Pcm16Impl(cast_environment,
+                            audio_config.channels,
+                            audio_config.frequency,
+                            frame_encoded_callback);
       break;
     default:
       NOTREACHED() << "Unsupported or unspecified codec for audio encoder";
@@ -340,36 +335,27 @@ AudioEncoder::AudioEncoder(
 AudioEncoder::~AudioEncoder() {}
 
 CastInitializationStatus AudioEncoder::InitializationResult() const {
+  DCHECK(insert_thread_checker_.CalledOnValidThread());
   if (impl_) {
     return impl_->InitializationResult();
   }
   return STATUS_UNSUPPORTED_AUDIO_CODEC;
 }
 
-void AudioEncoder::InsertAudio(const AudioBus* audio_bus,
-                               const base::TimeTicks& recorded_time,
-                               const base::Closure& done_callback) {
+void AudioEncoder::InsertAudio(scoped_ptr<AudioBus> audio_bus,
+                               const base::TimeTicks& recorded_time) {
   DCHECK(insert_thread_checker_.CalledOnValidThread());
+  DCHECK(audio_bus.get());
   if (!impl_) {
     NOTREACHED();
-    cast_environment_->PostTask(
-        CastEnvironment::MAIN, FROM_HERE, done_callback);
     return;
   }
   cast_environment_->PostTask(CastEnvironment::AUDIO_ENCODER,
                               FROM_HERE,
-                              base::Bind(&AudioEncoder::EncodeAudio,
-                                         this,
-                                         audio_bus,
-                                         recorded_time,
-                                         done_callback));
-}
-
-void AudioEncoder::EncodeAudio(const AudioBus* audio_bus,
-                               const base::TimeTicks& recorded_time,
-                               const base::Closure& done_callback) {
-  DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::AUDIO_ENCODER));
-  impl_->EncodeAudio(audio_bus, recorded_time, done_callback);
+                              base::Bind(&AudioEncoder::ImplBase::EncodeAudio,
+                                         impl_,
+                                         base::Passed(&audio_bus),
+                                         recorded_time));
 }
 
 }  // namespace cast
diff --git a/media/cast/audio_sender/audio_encoder.h b/media/cast/audio_sender/audio_encoder.h
index 7c2b4f3b09..d4c9e0f392 100644
--- a/media/cast/audio_sender/audio_encoder.h
+++ b/media/cast/audio_sender/audio_encoder.h
@@ -8,6 +8,7 @@
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/threading/thread_checker.h"
+#include "media/base/audio_bus.h"
 #include "media/cast/cast_config.h"
 #include "media/cast/cast_environment.h"
 
@@ -16,13 +17,9 @@ class TimeTicks;
 }
 
 namespace media {
-class AudioBus;
-}
-
-namespace media {
 namespace cast {
 
-class AudioEncoder : public base::RefCountedThreadSafe<AudioEncoder> {
+class AudioEncoder {
  public:
   typedef base::Callback<void(scoped_ptr<transport::EncodedAudioFrame>,
                               const base::TimeTicks&)> FrameEncodedCallback;
@@ -30,35 +27,20 @@ class AudioEncoder : public base::RefCountedThreadSafe<AudioEncoder> {
   AudioEncoder(const scoped_refptr<CastEnvironment>& cast_environment,
                const AudioSenderConfig& audio_config,
                const FrameEncodedCallback& frame_encoded_callback);
+  virtual ~AudioEncoder();
 
   CastInitializationStatus InitializationResult() const;
 
-  // The |audio_bus| must be valid until the |done_callback| is called.
-  // The callback is called from the main cast thread as soon as the encoder is
-  // done with |audio_bus|; it does not mean that the encoded data has been
-  // sent out.
-  void InsertAudio(const AudioBus* audio_bus,
-                   const base::TimeTicks& recorded_time,
-                   const base::Closure& done_callback);
-
- protected:
-  virtual ~AudioEncoder();
+  void InsertAudio(scoped_ptr<AudioBus> audio_bus,
+                   const base::TimeTicks& recorded_time);
 
  private:
-  friend class base::RefCountedThreadSafe<AudioEncoder>;
-
   class ImplBase;
   class OpusImpl;
   class Pcm16Impl;
 
-  // Invokes |impl_|'s encode method on the AUDIO_ENCODER thread while holding
-  // a ref-count on AudioEncoder.
-  void EncodeAudio(const AudioBus* audio_bus,
-                   const base::TimeTicks& recorded_time,
-                   const base::Closure& done_callback);
-
   const scoped_refptr<CastEnvironment> cast_environment_;
-  scoped_ptr<ImplBase> impl_;
+  scoped_refptr<ImplBase> impl_;
 
   // Used to ensure only one thread invokes InsertAudio().
   base::ThreadChecker insert_thread_checker_;
diff --git a/media/cast/audio_sender/audio_encoder_unittest.cc b/media/cast/audio_sender/audio_encoder_unittest.cc
index 41ab5727ce..37f5b49bd6 100644
--- a/media/cast/audio_sender/audio_encoder_unittest.cc
+++ b/media/cast/audio_sender/audio_encoder_unittest.cc
@@ -117,18 +117,9 @@ class AudioEncoderTest : public ::testing::TestWithParam<TestScenario> {
       receiver_->SetRecordedTimeUpperBound(testing_clock_->NowTicks() +
                                            duration);
 
-      const scoped_ptr<AudioBus> bus(
-          audio_bus_factory_->NextAudioBus(duration));
-
-      const int last_count = release_callback_count_;
-      audio_encoder_->InsertAudio(
-          bus.get(),
-          testing_clock_->NowTicks(),
-          base::Bind(&AudioEncoderTest::IncrementReleaseCallbackCounter,
-                     base::Unretained(this)));
+      audio_encoder_->InsertAudio(audio_bus_factory_->NextAudioBus(duration),
+                                  testing_clock_->NowTicks());
       task_runner_->RunTasks();
-      EXPECT_EQ(1, release_callback_count_ - last_count)
-          << "Release callback was not invoked once.";
 
       testing_clock_->Advance(duration);
     }
@@ -155,23 +146,19 @@ class AudioEncoderTest : public ::testing::TestWithParam<TestScenario> {
 
     receiver_.reset(new TestEncodedAudioFrameReceiver(codec));
 
-    audio_encoder_ = new AudioEncoder(
+    audio_encoder_.reset(new AudioEncoder(
         cast_environment_,
         audio_config,
         base::Bind(&TestEncodedAudioFrameReceiver::FrameEncoded,
-                   base::Unretained(receiver_.get())));
-    release_callback_count_ = 0;
+                   base::Unretained(receiver_.get()))));
   }
 
-  void IncrementReleaseCallbackCounter() { ++release_callback_count_; }
-
   base::SimpleTestTickClock* testing_clock_;  // Owned by CastEnvironment.
   scoped_refptr<test::FakeSingleThreadTaskRunner> task_runner_;
   scoped_ptr<TestAudioBusFactory> audio_bus_factory_;
   scoped_ptr<TestEncodedAudioFrameReceiver> receiver_;
-  scoped_refptr<AudioEncoder> audio_encoder_;
+  scoped_ptr<AudioEncoder> audio_encoder_;
   scoped_refptr<CastEnvironment> cast_environment_;
-  int release_callback_count_;
 
   DISALLOW_COPY_AND_ASSIGN(AudioEncoderTest);
 };
diff --git a/media/cast/audio_sender/audio_sender.cc b/media/cast/audio_sender/audio_sender.cc
index 8da20cbd22..a02ab2174c 100644
--- a/media/cast/audio_sender/audio_sender.cc
+++ b/media/cast/audio_sender/audio_sender.cc
@@ -25,7 +25,7 @@ class LocalRtcpAudioSenderFeedback : public RtcpSenderFeedback {
     if (!cast_feedback.missing_frames_and_packets_.empty()) {
       audio_sender_->ResendPackets(cast_feedback.missing_frames_and_packets_);
     }
-    VLOG(1) << "Received audio ACK "
+    VLOG(2) << "Received audio ACK "
             << static_cast<int>(cast_feedback.ack_frame_id_);
   }
 
@@ -43,9 +43,11 @@ class LocalRtpSenderStatistics : public RtpSenderStatistics {
       : transport_sender_(transport_sender),
         frequency_(0),
         sender_info_(),
-        rtp_timestamp_(0) {
-    transport_sender_->SubscribeAudioRtpStatsCallback(base::Bind(
-        &LocalRtpSenderStatistics::StoreStatistics, base::Unretained(this)));
+        rtp_timestamp_(0),
+        weak_factory_(this) {
+    transport_sender_->SubscribeAudioRtpStatsCallback(
+        base::Bind(&LocalRtpSenderStatistics::StoreStatistics,
+                   weak_factory_.GetWeakPtr()));
   }
 
   virtual void GetStatistics(const base::TimeTicks& now,
@@ -84,6 +86,8 @@ class LocalRtpSenderStatistics : public RtpSenderStatistics {
   base::TimeTicks time_sent_;
   uint32 rtp_timestamp_;
 
+  base::WeakPtrFactory<LocalRtpSenderStatistics> weak_factory_;
+
   DISALLOW_IMPLICIT_CONSTRUCTORS(LocalRtpSenderStatistics);
 };
 
@@ -109,15 +113,16 @@ AudioSender::AudioSender(scoped_refptr<CastEnvironment> cast_environment,
             audio_config.incoming_feedback_ssrc,
             audio_config.rtcp_c_name),
       timers_initialized_(false),
-      initialization_status_(STATUS_INITIALIZED),
+      cast_initialization_cb_(STATUS_AUDIO_UNINITIALIZED),
       weak_factory_(this) {
+  rtcp_.SetCastReceiverEventHistorySize(kReceiverRtcpEventHistorySize);
   if (!audio_config.use_external_encoder) {
-    audio_encoder_ =
+    audio_encoder_.reset(
         new AudioEncoder(cast_environment,
                          audio_config,
                          base::Bind(&AudioSender::SendEncodedAudioFrame,
-                                    weak_factory_.GetWeakPtr()));
-    initialization_status_ = audio_encoder_->InitializationResult();
+                                    weak_factory_.GetWeakPtr())));
+    cast_initialization_cb_ = audio_encoder_->InitializationResult();
   }
 }
 
@@ -131,13 +136,11 @@ void AudioSender::InitializeTimers() {
   }
 }
 
-void AudioSender::InsertAudio(const AudioBus* audio_bus,
-                              const base::TimeTicks& recorded_time,
-                              const base::Closure& done_callback) {
+void AudioSender::InsertAudio(scoped_ptr<AudioBus> audio_bus,
+                              const base::TimeTicks& recorded_time) {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   DCHECK(audio_encoder_.get()) << "Invalid internal state";
-
-  audio_encoder_->InsertAudio(audio_bus, recorded_time, done_callback);
+  audio_encoder_->InsertAudio(audio_bus.Pass(), recorded_time);
 }
 
 void AudioSender::SendEncodedAudioFrame(
diff --git a/media/cast/audio_sender/audio_sender.h b/media/cast/audio_sender/audio_sender.h
index 039983353d..7673b8250f 100644
--- a/media/cast/audio_sender/audio_sender.h
+++ b/media/cast/audio_sender/audio_sender.h
@@ -12,15 +12,12 @@
 #include "base/threading/non_thread_safe.h"
 #include "base/time/tick_clock.h"
 #include "base/time/time.h"
+#include "media/base/audio_bus.h"
 #include "media/cast/cast_config.h"
 #include "media/cast/rtcp/rtcp.h"
 #include "media/cast/transport/rtp_sender/rtp_sender.h"
 
 namespace media {
-class AudioBus;
-}
-
-namespace media {
 namespace cast {
 
 class AudioEncoder;
@@ -39,16 +36,11 @@ class AudioSender : public base::NonThreadSafe,
   virtual ~AudioSender();
 
   CastInitializationStatus InitializationResult() const {
-    return initialization_status_;
+    return cast_initialization_cb_;
   }
 
-  // The |audio_bus| must be valid until the |done_callback| is called.
-  // The callback is called from the main cast thread as soon as the encoder is
-  // done with |audio_bus|; it does not mean that the encoded data has been
-  // sent out.
-  void InsertAudio(const AudioBus* audio_bus,
-                   const base::TimeTicks& recorded_time,
-                   const base::Closure& done_callback);
+  void InsertAudio(scoped_ptr<AudioBus> audio_bus,
+                   const base::TimeTicks& recorded_time);
 
   // Only called from the main cast thread.
   void IncomingRtcpPacket(scoped_ptr<Packet> packet);
@@ -80,12 +72,12 @@ class AudioSender : public base::NonThreadSafe,
 
   scoped_refptr<CastEnvironment> cast_environment_;
   transport::CastTransportSender* const transport_sender_;
-  scoped_refptr<AudioEncoder> audio_encoder_;
+  scoped_ptr<AudioEncoder> audio_encoder_;
   scoped_ptr<LocalRtpSenderStatistics> rtp_audio_sender_statistics_;
   scoped_ptr<LocalRtcpAudioSenderFeedback> rtcp_feedback_;
   Rtcp rtcp_;
   bool timers_initialized_;
-  CastInitializationStatus initialization_status_;
+  CastInitializationStatus cast_initialization_cb_;
 
   DISALLOW_COPY_AND_ASSIGN(AudioSender);
 };
diff --git a/media/cast/audio_sender/audio_sender_unittest.cc b/media/cast/audio_sender/audio_sender_unittest.cc
index dc2c3bf8ec..9b3a52e1d8 100644
--- a/media/cast/audio_sender/audio_sender_unittest.cc
+++ b/media/cast/audio_sender/audio_sender_unittest.cc
@@ -15,7 +15,6 @@
 #include "media/cast/test/utility/audio_utility.h"
 #include "media/cast/transport/cast_transport_config.h"
 #include "media/cast/transport/cast_transport_sender_impl.h"
-#include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace media {
@@ -23,9 +22,6 @@ namespace cast {
 
 static const int64 kStartMillisecond = GG_INT64_C(12345678900000);
 
-using testing::_;
-using testing::Exactly;
-
 class TestPacketSender : public transport::PacketSender {
  public:
   TestPacketSender() : number_of_rtp_packets_(0), number_of_rtcp_packets_(0) {}
@@ -51,9 +47,6 @@ class TestPacketSender : public transport::PacketSender {
 };
 
 class AudioSenderTest : public ::testing::Test {
- public:
-  MOCK_METHOD0(InsertAudioCallback, void());
-
  protected:
   AudioSenderTest() {
     InitializeMediaLibraryForTesting();
@@ -61,6 +54,7 @@ class AudioSenderTest : public ::testing::Test {
     testing_clock_->Advance(
         base::TimeDelta::FromMilliseconds(kStartMillisecond));
     task_runner_ = new test::FakeSingleThreadTaskRunner(testing_clock_);
+    CastLoggingConfig logging_config = GetDefaultCastSenderLoggingConfig();
     cast_environment_ =
         new CastEnvironment(scoped_ptr<base::TickClock>(testing_clock_).Pass(),
                             task_runner_,
@@ -69,7 +63,7 @@ class AudioSenderTest : public ::testing::Test {
                             task_runner_,
                             task_runner_,
                             task_runner_,
-                            GetDefaultCastSenderLoggingConfig());
+                            logging_config);
     audio_config_.codec = transport::kOpus;
     audio_config_.use_external_encoder = false;
     audio_config_.frequency = kDefaultAudioSamplingRate;
@@ -77,15 +71,23 @@ class AudioSenderTest : public ::testing::Test {
     audio_config_.bitrate = kDefaultAudioEncoderBitrate;
     audio_config_.rtp_config.payload_type = 127;
 
-    transport::CastTransportConfig transport_config;
-    transport_config.audio_rtp_config.payload_type = 127;
-    transport_config.audio_channels = 2;
+    transport::CastTransportAudioConfig transport_config;
+    transport_config.base.rtp_config.payload_type = 127;
+    transport_config.channels = 2;
+    net::IPEndPoint dummy_endpoint;
+
     transport_sender_.reset(new transport::CastTransportSenderImpl(
+        NULL,
         testing_clock_,
-        transport_config,
+        dummy_endpoint,
+        dummy_endpoint,
+        logging_config,
         base::Bind(&UpdateCastTransportStatus),
+        transport::BulkRawEventsCallback(),
+        base::TimeDelta(),
         task_runner_,
         &transport_));
+    transport_sender_->InitializeAudio(transport_config);
     audio_sender_.reset(new AudioSender(
         cast_environment_, audio_config_, transport_sender_.get()));
     task_runner_->RunTasks();
@@ -94,7 +96,7 @@ class AudioSenderTest : public ::testing::Test {
   virtual ~AudioSenderTest() {}
 
   static void UpdateCastTransportStatus(transport::CastTransportStatus status) {
-    EXPECT_EQ(status, transport::TRANSPORT_INITIALIZED);
+    EXPECT_EQ(status, transport::TRANSPORT_AUDIO_INITIALIZED);
   }
 
   base::SimpleTestTickClock* testing_clock_;  // Owned by CastEnvironment.
@@ -107,8 +109,6 @@ class AudioSenderTest : public ::testing::Test {
 };
 
 TEST_F(AudioSenderTest, Encode20ms) {
-  EXPECT_CALL(*this, InsertAudioCallback()).Times(Exactly(1));
-
   const base::TimeDelta kDuration = base::TimeDelta::FromMilliseconds(20);
   scoped_ptr<AudioBus> bus(
       TestAudioBusFactory(audio_config_.channels,
@@ -117,10 +117,7 @@ TEST_F(AudioSenderTest, Encode20ms) {
                           0.5f).NextAudioBus(kDuration));
 
   base::TimeTicks recorded_time = base::TimeTicks::Now();
-  audio_sender_->InsertAudio(bus.get(),
-                             recorded_time,
-                             base::Bind(&AudioSenderTest::InsertAudioCallback,
-                                        base::Unretained(this)));
+  audio_sender_->InsertAudio(bus.Pass(), recorded_time);
   task_runner_->RunTasks();
   EXPECT_GE(
       transport_.number_of_rtp_packets() + transport_.number_of_rtcp_packets(),
@@ -128,8 +125,6 @@ TEST_F(AudioSenderTest, Encode20ms) {
 }
 
 TEST_F(AudioSenderTest, RtcpTimer) {
-  EXPECT_CALL(*this, InsertAudioCallback()).Times(Exactly(1));
-
   const base::TimeDelta kDuration = base::TimeDelta::FromMilliseconds(20);
   scoped_ptr<AudioBus> bus(
       TestAudioBusFactory(audio_config_.channels,
@@ -138,10 +133,7 @@ TEST_F(AudioSenderTest, RtcpTimer) {
                           0.5f).NextAudioBus(kDuration));
 
   base::TimeTicks recorded_time = base::TimeTicks::Now();
-  audio_sender_->InsertAudio(bus.get(),
-                             recorded_time,
-                             base::Bind(&AudioSenderTest::InsertAudioCallback,
-                                        base::Unretained(this)));
+  audio_sender_->InsertAudio(bus.Pass(), recorded_time);
   task_runner_->RunTasks();
 
   // Make sure that we send at least one RTCP packet.