Clean-up: Fix FrameInput::InsertAudio() interface, and remove ref-counting of AudioEncoder.

1. Rather than pass a done callback around, explicitly pass ownership of each AudioBus to the InsertAudio() calls.

2. AudioEncoder is no longer ref-counted.  Instead, its inner "impl class" is ref-counted since it can be referenced by two threads (MAIN and AUDIO_ENCODER).

BUG=344628

Review URL: https://codereview.chromium.org/198333002

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@256786 0039d316-1c4b-4281-b951-d872f2087c98

10 files changed, 73 insertions, 190 deletions

diff --git a/media/cast/audio_sender/audio_encoder.cc b/media/cast/audio_sender/audio_encoder.cc
index efe7a01..a1b0c95 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,
@@ -58,8 +61,6 @@ class AudioEncoder::ImplBase : public base::SupportsWeakPtr<ImplBase> {
     }
   }
 
-  virtual ~ImplBase() {}
-
   CastInitializationStatus InitializationResult() const {
     return cast_initialization_cb_;
   }
@@ -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,13 +138,16 @@ 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_;
@@ -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,
@@ -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,
@@ -318,17 +314,17 @@ AudioEncoder::AudioEncoder(
   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";
@@ -346,30 +342,20 @@ CastInitializationStatus AudioEncoder::InitializationResult() const {
   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 7c2b4f3..d4c9e0f 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 41ab572..37f5b49 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 d29e36a..a02ab21 100644
--- a/media/cast/audio_sender/audio_sender.cc
+++ b/media/cast/audio_sender/audio_sender.cc
@@ -117,11 +117,11 @@ AudioSender::AudioSender(scoped_refptr<CastEnvironment> cast_environment,
       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()));
+                                    weak_factory_.GetWeakPtr())));
     cast_initialization_cb_ = audio_encoder_->InitializationResult();
   }
 }
@@ -136,12 +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 6afa7cf..7673b82 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;
@@ -42,13 +39,8 @@ class AudioSender : public base::NonThreadSafe,
     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,7 +72,7 @@ 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_;
diff --git a/media/cast/audio_sender/audio_sender_unittest.cc b/media/cast/audio_sender/audio_sender_unittest.cc
index c7ce707..9b3a52e 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();
@@ -116,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,
@@ -126,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(),
@@ -137,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,
@@ -147,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.
diff --git a/media/cast/cast_sender.h b/media/cast/cast_sender.h
index 33b9393..64d07d4 100644
--- a/media/cast/cast_sender.h
+++ b/media/cast/cast_sender.h
@@ -13,15 +13,16 @@
 #include "base/basictypes.h"
 #include "base/callback.h"
 #include "base/memory/ref_counted.h"
+#include "base/memory/scoped_ptr.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/cast_environment.h"
 #include "media/cast/transport/cast_transport_sender.h"
 #include "media/filters/gpu_video_accelerator_factories.h"
 
 namespace media {
-class AudioBus;
 class GpuVideoAcceleratorFactories;
 class VideoFrame;
 
@@ -48,13 +49,8 @@ class AudioFrameInput : public base::RefCountedThreadSafe<AudioFrameInput> {
  public:
   // Insert audio frames into Cast sender. Frames will be encoded, packetized
   // and sent to the network.
-  // 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.
-  virtual void InsertAudio(const AudioBus* audio_bus,
-                           const base::TimeTicks& recorded_time,
-                           const base::Closure& done_callback) = 0;
+  virtual void InsertAudio(scoped_ptr<AudioBus> audio_bus,
+                           const base::TimeTicks& recorded_time) = 0;
 
  protected:
   virtual ~AudioFrameInput() {}
diff --git a/media/cast/cast_sender_impl.cc b/media/cast/cast_sender_impl.cc
index c461d35..3c90461 100644
--- a/media/cast/cast_sender_impl.cc
+++ b/media/cast/cast_sender_impl.cc
@@ -51,16 +51,14 @@ class LocalAudioFrameInput : public AudioFrameInput {
                        base::WeakPtr<AudioSender> audio_sender)
       : cast_environment_(cast_environment), audio_sender_(audio_sender) {}
 
-  virtual void InsertAudio(const AudioBus* audio_bus,
-                           const base::TimeTicks& recorded_time,
-                           const base::Closure& done_callback) OVERRIDE {
+  virtual void InsertAudio(scoped_ptr<AudioBus> audio_bus,
+                           const base::TimeTicks& recorded_time) OVERRIDE {
     cast_environment_->PostTask(CastEnvironment::MAIN,
                                 FROM_HERE,
                                 base::Bind(&AudioSender::InsertAudio,
                                            audio_sender_,
-                                           audio_bus,
-                                           recorded_time,
-                                           done_callback));
+                                           base::Passed(&audio_bus),
+                                           recorded_time));
   }
 
  protected:
diff --git a/media/cast/test/end2end_unittest.cc b/media/cast/test/end2end_unittest.cc
index df8e954..4c9fa2a 100644
--- a/media/cast/test/end2end_unittest.cc
+++ b/media/cast/test/end2end_unittest.cc
@@ -85,10 +85,6 @@ std::string ConvertFromBase16String(const std::string base_16) {
   return compressed;
 }
 
-// Dummy callback function that does nothing except to accept ownership of
-// |audio_bus| for destruction.
-void OwnThatAudioBus(scoped_ptr<AudioBus> audio_bus) {}
-
 void UpdateCastTransportStatus(transport::CastTransportStatus status) {
   bool result = (status == transport::TRANSPORT_AUDIO_INITIALIZED ||
                  status == transport::TRANSPORT_VIDEO_INITIALIZED);
@@ -662,11 +658,7 @@ TEST_F(End2EndTest, LoopNoLossPcm16) {
           send_time);
     }
 
-    AudioBus* const audio_bus_ptr = audio_bus.get();
-    audio_frame_input_->InsertAudio(
-        audio_bus_ptr,
-        send_time,
-        base::Bind(&OwnThatAudioBus, base::Passed(&audio_bus)));
+    audio_frame_input_->InsertAudio(audio_bus.Pass(), send_time);
 
     test_receiver_video_callback_->AddExpectedResult(
         video_start,
@@ -719,11 +711,7 @@ TEST_F(End2EndTest, LoopNoLossPcm16ExternalDecoder) {
         1,
         send_time);
 
-    AudioBus* const audio_bus_ptr = audio_bus.get();
-    audio_frame_input_->InsertAudio(
-        audio_bus_ptr,
-        send_time,
-        base::Bind(&OwnThatAudioBus, base::Passed(&audio_bus)));
+    audio_frame_input_->InsertAudio(audio_bus.Pass(), send_time);
 
     RunTasks(10);
     frame_receiver_->GetCodedAudioFrame(
@@ -754,11 +742,7 @@ TEST_F(End2EndTest, LoopNoLossOpus) {
           send_time);
     }
 
-    AudioBus* const audio_bus_ptr = audio_bus.get();
-    audio_frame_input_->InsertAudio(
-        audio_bus_ptr,
-        send_time,
-        base::Bind(&OwnThatAudioBus, base::Passed(&audio_bus)));
+    audio_frame_input_->InsertAudio(audio_bus.Pass(), send_time);
 
     RunTasks(30);
 
@@ -804,11 +788,7 @@ TEST_F(End2EndTest, StartSenderBeforeReceiver) {
     scoped_ptr<AudioBus> audio_bus(audio_bus_factory_->NextAudioBus(
         base::TimeDelta::FromMilliseconds(10) * num_10ms_blocks));
 
-    AudioBus* const audio_bus_ptr = audio_bus.get();
-    audio_frame_input_->InsertAudio(
-        audio_bus_ptr,
-        send_time,
-        base::Bind(&OwnThatAudioBus, base::Passed(&audio_bus)));
+    audio_frame_input_->InsertAudio(audio_bus.Pass(), send_time);
 
     // 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
@@ -846,11 +826,7 @@ TEST_F(End2EndTest, StartSenderBeforeReceiver) {
           send_time);
     }
 
-    AudioBus* const audio_bus_ptr = audio_bus.get();
-    audio_frame_input_->InsertAudio(
-        audio_bus_ptr,
-        send_time,
-        base::Bind(&OwnThatAudioBus, base::Passed(&audio_bus)));
+    audio_frame_input_->InsertAudio(audio_bus.Pass(), send_time);
 
     test_receiver_video_callback_->AddExpectedResult(
         video_start,
@@ -1082,11 +1058,7 @@ TEST_F(End2EndTest, CryptoAudio) {
           num_10ms_blocks,
           send_time);
     }
-    AudioBus* const audio_bus_ptr = audio_bus.get();
-    audio_frame_input_->InsertAudio(
-        audio_bus_ptr,
-        send_time,
-        base::Bind(&OwnThatAudioBus, base::Passed(&audio_bus)));
+    audio_frame_input_->InsertAudio(audio_bus.Pass(), send_time);
 
     RunTasks(num_10ms_blocks * 10);
 
@@ -1260,11 +1232,7 @@ TEST_F(End2EndTest, AudioLogging) {
           send_time);
     }
 
-    AudioBus* const audio_bus_ptr = audio_bus.get();
-    audio_frame_input_->InsertAudio(
-        audio_bus_ptr,
-        send_time,
-        base::Bind(&OwnThatAudioBus, base::Passed(&audio_bus)));
+    audio_frame_input_->InsertAudio(audio_bus.Pass(), send_time);
 
     RunTasks(kFrameTimerMs);
     audio_diff += kFrameTimerMs;
diff --git a/media/cast/test/sender.cc b/media/cast/test/sender.cc
index 5737ca6..b566101 100644
--- a/media/cast/test/sender.cc
+++ b/media/cast/test/sender.cc
@@ -60,11 +60,6 @@ static const int kFrameTimerMs = 33;
 
 // The max allowed size of serialized log.
 const int kMaxSerializedLogBytes = 10 * 1000 * 1000;
-
-// Dummy callback function that does nothing except to accept ownership of
-// |audio_bus| for destruction. This guarantees that the audio_bus is valid for
-// the entire duration of the encode/send process (not equivalent to DoNothing).
-void OwnThatAudioBus(scoped_ptr<AudioBus> audio_bus) {}
 }  // namespace
 
 void GetPort(int* port) {
@@ -267,13 +262,10 @@ class SendProcess {
     // Avoid drift.
     audio_diff_ += kFrameTimerMs - num_10ms_blocks * 10;
 
-    scoped_ptr<AudioBus> audio_bus(audio_bus_factory_->NextAudioBus(
-        base::TimeDelta::FromMilliseconds(10) * num_10ms_blocks));
-    AudioBus* const audio_bus_ptr = audio_bus.get();
     audio_frame_input_->InsertAudio(
-        audio_bus_ptr,
-        clock_->NowTicks(),
-        base::Bind(&OwnThatAudioBus, base::Passed(&audio_bus)));
+        audio_bus_factory_->NextAudioBus(
+            base::TimeDelta::FromMilliseconds(10) * num_10ms_blocks),
+        clock_->NowTicks());
 
     gfx::Size size(video_config_.width, video_config_.height);
     // TODO(mikhal): Use the provided timestamp.