Replace AudioScheduler with AudioPump.

remoting/host/audio_pump.cc

Index: remoting/host/audio_pump.cc
diff --git a/remoting/host/audio_pump.cc b/remoting/host/audio_pump.cc
new file mode 100644
index 0000000000000000000000000000000000000000..619b04ebd1ef6a4c0241b7ab567778ff56abb3a6
--- /dev/null
+++ b/remoting/host/audio_pump.cc
@@ -0,0 +1,136 @@
+// Copyright 2015 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/host/audio_pump.h"
+
+#include "base/bind.h"
+#include "base/location.h"
+#include "base/logging.h"
+#include "base/single_thread_task_runner.h"
+#include "remoting/codec/audio_encoder.h"
+#include "remoting/host/audio_capturer.h"
+#include "remoting/proto/audio.pb.h"
+#include "remoting/protocol/audio_stub.h"
+
+namespace remoting {
+
+class AudioPump::Core {
+ public:
+  Core(base::WeakPtr<AudioPump> pump,
+       scoped_refptr<base::SingleThreadTaskRunner> audio_task_runner,
+       scoped_refptr<base::SingleThreadTaskRunner> network_task_runner,
+       scoped_ptr<AudioCapturer> audio_capturer,
+       scoped_ptr<AudioEncoder> audio_encoder);
+  ~Core();
+
+  void Start();
+  void Pause(bool pause);
+
+ private:
+  void EncodeAudioPacket(scoped_ptr<AudioPacket> packet);
+
+  base::WeakPtr<AudioPump> pump_;
+
+  scoped_refptr<base::SingleThreadTaskRunner> audio_task_runner_;
+  scoped_refptr<base::SingleThreadTaskRunner> network_task_runner_;

[Wez, 2015/02/11 01:41:12]

See elsewhere re "network" naming

[Sergey Ulanov, 2015/02/11 21:18:12]

Done.

+
+  scoped_ptr<AudioCapturer> audio_capturer_;
+
+  scoped_ptr<AudioEncoder> audio_encoder_;
+
+  bool enabled_;
+
+  DISALLOW_COPY_AND_ASSIGN(Core);
+};
+
+AudioPump::Core::Core(
+    base::WeakPtr<AudioPump> pump,
+    scoped_refptr<base::SingleThreadTaskRunner> audio_task_runner,
+    scoped_refptr<base::SingleThreadTaskRunner> network_task_runner,
+    scoped_ptr<AudioCapturer> audio_capturer,
+    scoped_ptr<AudioEncoder> audio_encoder)
+    : pump_(pump),
+      audio_task_runner_(audio_task_runner),
+      network_task_runner_(network_task_runner),
+      audio_capturer_(audio_capturer.Pass()),
+      audio_encoder_(audio_encoder.Pass()),
+      enabled_(true) {
+}
+
+AudioPump::Core::~Core() {
+  DCHECK(audio_task_runner_->BelongsToCurrentThread());
+}
+
+void AudioPump::Core::Start() {
+  DCHECK(audio_task_runner_->BelongsToCurrentThread());
+
+  audio_capturer_->Start(
+      base::Bind(&Core::EncodeAudioPacket, base::Unretained(this)));
+}
+
+void AudioPump::Core::Pause(bool pause) {
+  DCHECK(audio_task_runner_->BelongsToCurrentThread());
+
+  enabled_ = !pause;
+}
+
+void AudioPump::Core::EncodeAudioPacket(scoped_ptr<AudioPacket> packet) {
+  DCHECK(audio_task_runner_->BelongsToCurrentThread());
+  DCHECK(packet.get());

[Wez, 2015/02/11 01:41:13]

DCHECK(packet)

[Sergey Ulanov, 2015/02/11 21:18:12]

Done.

+
+  if (!enabled_)
+    return;
+
+  scoped_ptr<AudioPacket> encoded_packet =
+      audio_encoder_->Encode(packet.Pass());
+
+  // The audio encoder returns a null audio packet if there's no audio to send.
+  if (!encoded_packet)
+    return;
+
+  network_task_runner_->PostTask(FROM_HERE,
+                                 base::Bind(&AudioPump::SendAudioPacket, pump_,
+                                            base::Passed(&encoded_packet)));
+}
+
+AudioPump::AudioPump(
+    scoped_refptr<base::SingleThreadTaskRunner> audio_task_runner,
+    scoped_refptr<base::SingleThreadTaskRunner> network_task_runner,
+    scoped_ptr<AudioCapturer> audio_capturer,
+    scoped_ptr<AudioEncoder> audio_encoder,
+    protocol::AudioStub* audio_stub)
+    : audio_task_runner_(audio_task_runner),
+      audio_stub_(audio_stub),
+      weak_factory_(this) {
+  DCHECK(network_task_runner->BelongsToCurrentThread());
+  DCHECK(audio_stub_);
+
+  core_.reset(new Core(weak_factory_.GetWeakPtr(), audio_task_runner,
+                       network_task_runner, audio_capturer.Pass(),
+                       audio_encoder.Pass()));
+
+  audio_task_runner_->PostTask(
+      FROM_HERE, base::Bind(&Core::Start, base::Unretained(core_.get())));
+}
+
+AudioPump::~AudioPump() {

[Wez, 2015/02/11 01:41:13]

Thread check network_task_runner_?

[Sergey Ulanov, 2015/02/11 21:18:12]

Done.

+  audio_task_runner_->DeleteSoon(FROM_HERE, core_.release());
+}
+
+void AudioPump::Pause(bool pause) {
+  DCHECK(CalledOnValidThread());

[Wez, 2015/02/11 01:41:12]

Does this need to be both BaseNonThreadSafe and hold a pointer to its calling
TaskRunner (network_task_runner_)?

[Sergey Ulanov, 2015/02/11 21:18:12]

Done.

+
+  audio_task_runner_->PostTask(
+      FROM_HERE,
+      base::Bind(&Core::Pause, base::Unretained(core_.get()), pause));
+}
+
+void AudioPump::SendAudioPacket(scoped_ptr<AudioPacket> packet) {
+  DCHECK(CalledOnValidThread());
+  DCHECK(packet.get());

[Wez, 2015/02/11 01:41:12]

nit: DCHECK(packet)

[Sergey Ulanov, 2015/02/11 21:18:12]

Done.

+
+  audio_stub_->ProcessAudioPacket(packet.Pass(), base::Closure());

[Wez, 2015/02/11 01:41:12]

nit: Do we ever use the done callback in ProcessAudioPacket, or can we get rid
of that as well...?

[Sergey Ulanov, 2015/02/11 21:18:12]

Actually I think it's wrong that we are not using it here. The pump currently
pumps the data even when the network is blocked. I'll send you a separate CL to
fix it.

[Wez, 2015/02/12 02:26:18]

Acknowledged.

+}
+
+}  // namespace remoting