Piping for audio decoding.

remoting/client/audio_decode_scheduler.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 "remoting/client/audio_decode_scheduler.h"
+
+#include "base/bind.h"
+#include "base/location.h"
+#include "base/single_thread_task_runner.h"
+#include "remoting/client/audio_player.h"
+#include "remoting/codec/audio_decoder.h"
+#include "remoting/proto/audio.pb.h"
+
+namespace remoting {
+
+AudioDecodeScheduler::AudioDecodeScheduler(
+    scoped_refptr<base::SingleThreadTaskRunner> main_task_runner,
+    scoped_refptr<base::SingleThreadTaskRunner> audio_decode_task_runner,
+    scoped_ptr<AudioPlayer> audio_player)
+    : main_task_runner_(main_task_runner),
+      audio_decode_task_runner_(audio_decode_task_runner),
+      audio_player_(audio_player.Pass()) {
+}
+
+AudioDecodeScheduler::~AudioDecodeScheduler() {
+}
+
+void AudioDecodeScheduler::Initialize(const protocol::SessionConfig& config) {
+  DCHECK(main_task_runner_->BelongsToCurrentThread());
+  decoder_.reset(AudioDecoder::CreateAudioDecoder(config).release());

[Wez, 2012/08/07 18:29:05]

nit: decoder_ = AudioDecoder::CreateAudioDecoder(config); ?

+}
+
+void AudioDecodeScheduler::ProcessAudioPacket(scoped_ptr<AudioPacket> packet,
+                                              const base::Closure& done) {
+  DCHECK(main_task_runner_->BelongsToCurrentThread());
+  audio_decode_task_runner_->PostTask(FROM_HERE, base::Bind(
+      &AudioDecodeScheduler::DecodePacket, base::Unretained(this),

[Wez, 2012/08/07 18:29:05]

You can't use base::Unretained(this) unless you have some other way to guarantee
that all such tasks you posted to the thread will have been processed by the
time you delete the AudioDecodeScheduler, or will be ignored once it's gone.
You'll need to split AudioDecodeScheduler's DecodePacket handling into a
separate ref-counted class internal to the scheduler, and which posts back to
ProcessDecodedPacket via a WeakPtr to the main scheduler object.

+      base::Passed(&packet), done));
+}
+
+void AudioDecodeScheduler::DecodePacket(scoped_ptr<AudioPacket> packet,
+                                        const base::Closure& done) {
+  DCHECK(audio_decode_task_runner_->BelongsToCurrentThread());
+  scoped_ptr<AudioPacket> decoded_packet = decoder_->Decode(packet.Pass());
+
+  main_task_runner_->PostTask(FROM_HERE, base::Bind(
+      &AudioDecodeScheduler::ProcessDecodedPacket, base::Unretained(this),

[Wez, 2012/08/07 18:29:05]

base::Unretained(this) -> weak_ptr_, where weak_ptr_ is initialised in
Initialize() or the constructore, from a weak_factory_ member of the
AudioDecodeScheduler itself.

+      base::Passed(decoded_packet.Pass()), done));
+}
+
+void AudioDecodeScheduler::ProcessDecodedPacket(scoped_ptr<AudioPacket> packet,
+                                                const base::Closure& done) {
+  DCHECK(main_task_runner_->BelongsToCurrentThread());
+  audio_player_->ProcessAudioPacket(packet.Pass());

[Wez, 2012/08/07 18:29:05]

Presumably ProcessAudioPacket plays back asynchronously, so should the done task
be passed to that, so that the caller actually gets notified only when the audio
has actually been played?

+  done.Run();
+}
+
+}  // namespace remoting