Piping for audio encoding.

remoting/host/audio_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/host/audio_scheduler.h"
 
 #include "base/bind.h"
 #include "base/callback.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 {
 
 AudioScheduler::AudioScheduler(
     scoped_refptr<base::SingleThreadTaskRunner> capture_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> network_task_runner,
     AudioCapturer* audio_capturer,
+    scoped_ptr<AudioEncoder> audio_encoder,
     protocol::AudioStub* audio_stub)
     : capture_task_runner_(capture_task_runner),
       network_task_runner_(network_task_runner),
       audio_capturer_(audio_capturer),
+      audio_encoder_(audio_encoder.Pass()),
       audio_stub_(audio_stub),
       network_stopped_(false) {
   DCHECK(capture_task_runner_);
   DCHECK(network_task_runner_);
   DCHECK(audio_capturer_);
   DCHECK(audio_stub_);
   capture_task_runner_->PostTask(
       FROM_HERE, base::Bind(&AudioScheduler::DoStart, this));
 }
 
@@ skipping 14 matching lines @@
 
 void AudioScheduler::OnClientDisconnected() {
   DCHECK(network_task_runner_->BelongsToCurrentThread());
   DCHECK(audio_stub_);
   audio_stub_ = NULL;
 }
 
 AudioScheduler::~AudioScheduler() {
 }
 
-void AudioScheduler::NotifyAudioPacketCaptured(scoped_ptr<AudioPacket> packet) {
+void AudioScheduler::NotifyAudioPacketCaptured(
+    scoped_ptr<AudioPacket> packet) {
+  scoped_ptr<AudioPacket> encoded_packet =
+      audio_encoder_->Encode(packet.Pass());
   network_task_runner_->PostTask(
       FROM_HERE, base::Bind(&AudioScheduler::DoSendAudioPacket,
-                            this, base::Passed(packet.Pass())));
+                            this, base::Passed(encoded_packet.Pass())));
 }
 
 void AudioScheduler::DoStart() {
   DCHECK(capture_task_runner_->BelongsToCurrentThread());
 
   // TODO(kxing): Do something with the return value.
   audio_capturer_->Start(
       base::Bind(&AudioScheduler::NotifyAudioPacketCaptured, this));
 }
 
@@ skipping 13 matching lines @@
 
 void AudioScheduler::DoStopOnNetworkThread(const base::Closure& done_task) {
   DCHECK(network_task_runner_->BelongsToCurrentThread());
 
   network_stopped_ = true;
 
   done_task.Run();
 }
 
 }  // namespace remoting