Modifies AudioInputCallback::OnData and use media::AudioBus instead of plain byte vector

media/audio/pulse/pulse_output.cc

 // Copyright (c) 2012 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.
 
 #include "media/audio/pulse/pulse_output.h"
 
 #include <pulse/pulseaudio.h>
 
 #include "base/single_thread_task_runner.h"
 #include "media/audio/audio_manager_base.h"
@@ skipping 31 matching lines @@
                                                const std::string& device_id,
                                                AudioManagerBase* manager)
     : params_(params),
       device_id_(device_id),
       manager_(manager),
       pa_context_(NULL),
       pa_mainloop_(NULL),
       pa_stream_(NULL),
       volume_(1.0f),
       source_callback_(NULL) {
-  DCHECK(manager_->GetTaskRunner()->BelongsToCurrentThread());
-
   CHECK(params_.IsValid());
   audio_bus_ = AudioBus::Create(params_);
 }
 
 PulseAudioOutputStream::~PulseAudioOutputStream() {
   // All internal structures should already have been freed in Close(), which
   // calls AudioManagerBase::ReleaseOutputStream() which deletes this object.
   DCHECK(!pa_stream_);
   DCHECK(!pa_context_);
   DCHECK(!pa_mainloop_);
 }
 
 bool PulseAudioOutputStream::Open() {
-  DCHECK(manager_->GetTaskRunner()->BelongsToCurrentThread());
+  DCHECK(thread_checker_.CalledOnValidThread());
   return pulse::CreateOutputStream(&pa_mainloop_, &pa_context_, &pa_stream_,
                                    params_, device_id_, &StreamNotifyCallback,
                                    &StreamRequestCallback, this);
 }
 
 void PulseAudioOutputStream::Reset() {
   if (!pa_mainloop_) {
     DCHECK(!pa_stream_);
     DCHECK(!pa_context_);
     return;
@@ skipping 24 matching lines @@
       pa_context_ = NULL;
     }
   }
 
   pa_threaded_mainloop_stop(pa_mainloop_);
   pa_threaded_mainloop_free(pa_mainloop_);
   pa_mainloop_ = NULL;
 }
 
 void PulseAudioOutputStream::Close() {
-  DCHECK(manager_->GetTaskRunner()->BelongsToCurrentThread());
+  DCHECK(thread_checker_.CalledOnValidThread());
 
   Reset();
 
   // Signal to the manager that we're closed and can be removed.
   // This should be the last call in the function as it deletes "this".
   manager_->ReleaseOutputStream(this);
 }
 
 void PulseAudioOutputStream::FulfillWriteRequest(size_t requested_bytes) {
   int bytes_remaining = requested_bytes;
@@ skipping 29 matching lines @@
       if (source_callback_) {
         source_callback_->OnError(this);
       }
     }
 
     bytes_remaining -= bytes_to_fill;
   }
 }
 
 void PulseAudioOutputStream::Start(AudioSourceCallback* callback) {
-  DCHECK(manager_->GetTaskRunner()->BelongsToCurrentThread());
+  DCHECK(thread_checker_.CalledOnValidThread());
   CHECK(callback);
   CHECK(pa_stream_);
 
   AutoPulseLock auto_lock(pa_mainloop_);
 
   // Ensure the context and stream are ready.
   if (pa_context_get_state(pa_context_) != PA_CONTEXT_READY &&
       pa_stream_get_state(pa_stream_) != PA_STREAM_READY) {
     callback->OnError(this);
     return;
   }
 
   source_callback_ = callback;
 
   // Uncork (resume) the stream.
   pa_operation* operation = pa_stream_cork(
       pa_stream_, 0, &pulse::StreamSuccessCallback, pa_mainloop_);
   WaitForOperationCompletion(pa_mainloop_, operation);
 }
 
 void PulseAudioOutputStream::Stop() {
-  DCHECK(manager_->GetTaskRunner()->BelongsToCurrentThread());
+  DCHECK(thread_checker_.CalledOnValidThread());
 
   // Cork (pause) the stream.  Waiting for the main loop lock will ensure
   // outstanding callbacks have completed.
   AutoPulseLock auto_lock(pa_mainloop_);
 
   // Set |source_callback_| to NULL so all FulfillWriteRequest() calls which may
   // occur while waiting on the flush and cork exit immediately.
   source_callback_ = NULL;
 
   // Flush the stream prior to cork, doing so after will cause hangs.  Write
   // callbacks are suspended while inside pa_threaded_mainloop_lock() so this
   // is all thread safe.
   pa_operation* operation = pa_stream_flush(
       pa_stream_, &pulse::StreamSuccessCallback, pa_mainloop_);
   WaitForOperationCompletion(pa_mainloop_, operation);
 
   operation = pa_stream_cork(pa_stream_, 1, &pulse::StreamSuccessCallback,
                              pa_mainloop_);
   WaitForOperationCompletion(pa_mainloop_, operation);
 }
 
 void PulseAudioOutputStream::SetVolume(double volume) {
-  DCHECK(manager_->GetTaskRunner()->BelongsToCurrentThread());
+  DCHECK(thread_checker_.CalledOnValidThread());
 
   volume_ = static_cast<float>(volume);
 }
 
 void PulseAudioOutputStream::GetVolume(double* volume) {
-  DCHECK(manager_->GetTaskRunner()->BelongsToCurrentThread());
+  DCHECK(thread_checker_.CalledOnValidThread());
 
   *volume = volume_;
 }
 
 }  // namespace media