Redesign the copresence audio handlers.

components/copresence/mediums/audio/audio_recorder.cc

 // Copyright 2014 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 "components/copresence/mediums/audio/audio_recorder.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 20 matching lines @@
   const int channels = source->channels();
   for (int ch = 0; ch < channels; ++ch) {
     for (int si = 0, di = ch; si < source->frames(); ++si, di += channels)
       buffer_view[di] = source->channel(ch)[si];
   }
 }
 
 // Called every kProcessIntervalMs to process the recorded audio. This
 // converts our samples to the required sample rate, interleaves the samples
 // and sends them to the whispernet decoder to process.
-void ProcessSamples(scoped_ptr<media::AudioBus> bus,
-                    const AudioRecorder::DecodeSamplesCallback& callback) {
+void ProcessSamples(
+    scoped_ptr<media::AudioBus> bus,
+    const AudioRecorderImpl::RecordedSamplesCallback& callback) {
   std::string samples;
   AudioBusToString(bus.Pass(), &samples);
   content::BrowserThread::PostTask(
       content::BrowserThread::UI, FROM_HERE, base::Bind(callback, samples));
 }
 
 }  // namespace
 
 // Public methods.
 
-AudioRecorder::AudioRecorder(const DecodeSamplesCallback& decode_callback)
+AudioRecorderImpl::AudioRecorderImpl()
     : is_recording_(false),
       stream_(NULL),
-      decode_callback_(decode_callback),
+      temp_conversion_buffer_(NULL),
       total_buffer_frames_(0),
       buffer_frame_index_(0) {
 }
 
-void AudioRecorder::Initialize() {
+void AudioRecorderImpl::Initialize(
+    const RecordedSamplesCallback& decode_callback) {
+  decode_callback_ = decode_callback;
   media::AudioManager::Get()->GetTaskRunner()->PostTask(
       FROM_HERE,
-      base::Bind(&AudioRecorder::InitializeOnAudioThread,
+      base::Bind(&AudioRecorderImpl::InitializeOnAudioThread,
                  base::Unretained(this)));
 }
 
-AudioRecorder::~AudioRecorder() {
+AudioRecorderImpl::~AudioRecorderImpl() {
 }
 
-void AudioRecorder::Record() {
+void AudioRecorderImpl::Record() {
   media::AudioManager::Get()->GetTaskRunner()->PostTask(
       FROM_HERE,
-      base::Bind(&AudioRecorder::RecordOnAudioThread, base::Unretained(this)));
+      base::Bind(&AudioRecorderImpl::RecordOnAudioThread,
+                 base::Unretained(this)));
 }
 
-void AudioRecorder::Stop() {
+void AudioRecorderImpl::Stop() {
   media::AudioManager::Get()->GetTaskRunner()->PostTask(
       FROM_HERE,
-      base::Bind(&AudioRecorder::StopOnAudioThread, base::Unretained(this)));
+      base::Bind(&AudioRecorderImpl::StopOnAudioThread,
+                 base::Unretained(this)));
 }
 
-bool AudioRecorder::IsRecording() {
+bool AudioRecorderImpl::IsRecording() {
   return is_recording_;
 }
 
-void AudioRecorder::Finalize() {
+void AudioRecorderImpl::Finalize() {
   media::AudioManager::Get()->GetTaskRunner()->PostTask(
       FROM_HERE,
-      base::Bind(&AudioRecorder::FinalizeOnAudioThread,
+      base::Bind(&AudioRecorderImpl::FinalizeOnAudioThread,
                  base::Unretained(this)));
 }
 
 // Private methods.
 
-void AudioRecorder::InitializeOnAudioThread() {
+void AudioRecorderImpl::InitializeOnAudioThread() {
   DCHECK(media::AudioManager::Get()->GetTaskRunner()->BelongsToCurrentThread());
 
   media::AudioParameters params =
       params_for_testing_
           ? *params_for_testing_
           : media::AudioManager::Get()->GetInputStreamParameters(
                 media::AudioManagerBase::kDefaultDeviceId);
 
   const media::AudioParameters dest_params(params.format(),
                                            kDefaultChannelLayout,
@@ skipping 20 matching lines @@
     LOG(ERROR) << "Failed to open an input stream.";
     if (stream_) {
       stream_->Close();
       stream_ = NULL;
     }
     return;
   }
   stream_->SetVolume(stream_->GetMaxVolume());
 }
 
-void AudioRecorder::RecordOnAudioThread() {
+void AudioRecorderImpl::RecordOnAudioThread() {
   DCHECK(media::AudioManager::Get()->GetTaskRunner()->BelongsToCurrentThread());
   if (!stream_ || is_recording_)
     return;
 
   converter_->Reset();
   stream_->Start(this);
   is_recording_ = true;
 }
 
-void AudioRecorder::StopOnAudioThread() {
+void AudioRecorderImpl::StopOnAudioThread() {
   DCHECK(media::AudioManager::Get()->GetTaskRunner()->BelongsToCurrentThread());
   if (!stream_ || !is_recording_)
     return;
 
   stream_->Stop();
   is_recording_ = false;
 }
 
-void AudioRecorder::StopAndCloseOnAudioThread() {
+void AudioRecorderImpl::StopAndCloseOnAudioThread() {
   DCHECK(media::AudioManager::Get()->GetTaskRunner()->BelongsToCurrentThread());
   if (!stream_)
     return;
 
   StopOnAudioThread();
   stream_->Close();
   stream_ = NULL;
 }
 
-void AudioRecorder::FinalizeOnAudioThread() {
+void AudioRecorderImpl::FinalizeOnAudioThread() {
   DCHECK(media::AudioManager::Get()->GetTaskRunner()->BelongsToCurrentThread());
   StopAndCloseOnAudioThread();
   delete this;
 }
 
-void AudioRecorder::OnData(media::AudioInputStream* stream,
-                           const media::AudioBus* source,
-                           uint32 /* hardware_delay_bytes */,
-                           double /* volume */) {
+void AudioRecorderImpl::OnData(media::AudioInputStream* stream,
+                               const media::AudioBus* source,
+                               uint32 /* hardware_delay_bytes */,
+                               double /* volume */) {
   temp_conversion_buffer_ = source;
   while (temp_conversion_buffer_) {
     // source->frames() == source_params.frames_per_buffer(), so we only have
     // one chunk of data in the source; correspondingly set the destination
     // size to one chunk.
     // TODO(rkc): Optimize this to directly write into buffer_ so we can avoid
     // the copy into this buffer and then the copy back into buffer_.
     scoped_ptr<media::AudioBus> converted_source =
         media::AudioBus::Create(kDefaultChannels, converter_->ChunkSize());
 
@@ skipping 23 matching lines @@
       int remaining_source_frames = converted_source->frames() - frames_to_copy;
       converted_source->CopyPartialFramesTo(frames_to_copy,
                                             remaining_source_frames,
                                             buffer_frame_index_,
                                             buffer_.get());
       buffer_frame_index_ += remaining_source_frames;
     }
   }
 }
 
-void AudioRecorder::OnError(media::AudioInputStream* /* stream */) {
+void AudioRecorderImpl::OnError(media::AudioInputStream* /* stream */) {
   LOG(ERROR) << "Error during sound recording.";
   media::AudioManager::Get()->GetTaskRunner()->PostTask(
       FROM_HERE,
-      base::Bind(&AudioRecorder::StopAndCloseOnAudioThread,
+      base::Bind(&AudioRecorderImpl::StopAndCloseOnAudioThread,
                  base::Unretained(this)));
 }
 
-double AudioRecorder::ProvideInput(media::AudioBus* dest,
-                                   base::TimeDelta /* buffer_delay */) {
+double AudioRecorderImpl::ProvideInput(media::AudioBus* dest,
+                                       base::TimeDelta /* buffer_delay */) {
   DCHECK(temp_conversion_buffer_);
   DCHECK_LE(temp_conversion_buffer_->frames(), dest->frames());
   temp_conversion_buffer_->CopyTo(dest);
   temp_conversion_buffer_ = NULL;
   return 1.0;
 }
 
-void AudioRecorder::FlushAudioLoopForTesting() {
+void AudioRecorderImpl::FlushAudioLoopForTesting() {
   if (media::AudioManager::Get()->GetTaskRunner()->BelongsToCurrentThread())
     return;
 
   // Queue task on the audio thread, when it is executed, that means we've
   // successfully executed all the tasks before us.
   base::RunLoop rl;
   media::AudioManager::Get()->GetTaskRunner()->PostTaskAndReply(
       FROM_HERE,
-      base::Bind(base::IgnoreResult(&AudioRecorder::FlushAudioLoopForTesting),
-                 base::Unretained(this)),
+      base::Bind(
+          base::IgnoreResult(&AudioRecorderImpl::FlushAudioLoopForTesting),
+          base::Unretained(this)),
       rl.QuitClosure());
   rl.Run();
 }
 
 }  // namespace copresence