Piping for audio decoding.

remoting/client/chromoting_client.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/chromoting_client.h"
 
 #include "base/bind.h"
+#include "remoting/client/audio_decode_scheduler.h"
 #include "remoting/client/audio_player.h"
 #include "remoting/client/client_context.h"
 #include "remoting/client/client_user_interface.h"
 #include "remoting/client/rectangle_update_decoder.h"
 #include "remoting/proto/audio.pb.h"
 #include "remoting/proto/video.pb.h"
 #include "remoting/protocol/authentication_method.h"
 #include "remoting/protocol/connection_to_host.h"
 #include "remoting/protocol/negotiating_authenticator.h"
 #include "remoting/protocol/session_config.h"
 #include "remoting/protocol/transport.h"
 
 namespace remoting {
 
 using protocol::AuthenticationMethod;
 
 ChromotingClient::QueuedVideoPacket::QueuedVideoPacket(
     scoped_ptr<VideoPacket> packet, const base::Closure& done)
     : packet(packet.release()), done(done) {
 }
 
 ChromotingClient::QueuedVideoPacket::~QueuedVideoPacket() {
 }
 
 ChromotingClient::ChromotingClient(
     const ClientConfig& config,
-    scoped_refptr<base::SingleThreadTaskRunner> task_runner,
+    const ClientContext& client_context,
     protocol::ConnectionToHost* connection,
     ClientUserInterface* user_interface,
     RectangleUpdateDecoder* rectangle_decoder,
-    AudioPlayer* audio_player)
+    scoped_ptr<AudioPlayer> audio_player)
     : config_(config),
-      task_runner_(task_runner),
+      task_runner_(client_context.main_task_runner()),
       connection_(connection),
       user_interface_(user_interface),
       rectangle_decoder_(rectangle_decoder),
-      audio_player_(audio_player),
       packet_being_processed_(false),
       last_sequence_number_(0),
       weak_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
+  audio_decode_scheduler_.reset(new AudioDecodeScheduler(
+      client_context.main_task_runner(),
+      client_context.audio_decode_task_runner(),
+      audio_player.Pass()));
 }
 
 ChromotingClient::~ChromotingClient() {
 }
 
 void ChromotingClient::Start(
     scoped_refptr<XmppProxy> xmpp_proxy,
     scoped_ptr<protocol::TransportFactory> transport_factory) {
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   scoped_ptr<protocol::Authenticator> authenticator(
       protocol::NegotiatingAuthenticator::CreateForClient(
           config_.authentication_tag,
           config_.shared_secret, config_.authentication_methods));
 
   // Create a WeakPtr to ourself for to use for all posted tasks.
   weak_ptr_ = weak_factory_.GetWeakPtr();
 
   connection_->Connect(xmpp_proxy, config_.local_jid, config_.host_jid,
                        config_.host_public_key, transport_factory.Pass(),
-                       authenticator.Pass(), this, this, this, this, this);
+                       authenticator.Pass(), this, this, this, this,
+                       audio_decode_scheduler_.get());
 }
 
 void ChromotingClient::Stop(const base::Closure& shutdown_task) {
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   // Drop all pending packets.
   while(!received_packets_.empty()) {
     delete received_packets_.front().packet;
     received_packets_.front().done.Run();
     received_packets_.pop_front();
@@ skipping 55 matching lines @@
   received_packets_.push_back(QueuedVideoPacket(packet.Pass(), done));
   if (!packet_being_processed_)
     DispatchPacket();
 }
 
 int ChromotingClient::GetPendingVideoPackets() {
   DCHECK(task_runner_->BelongsToCurrentThread());
   return received_packets_.size();
 }
 
-void ChromotingClient::ProcessAudioPacket(scoped_ptr<AudioPacket> packet,
-                                          const base::Closure& done) {
-  audio_player_->ProcessAudioPacket(packet.Pass());
-  done.Run();
-}
-
 void ChromotingClient::DispatchPacket() {
   DCHECK(task_runner_->BelongsToCurrentThread());
   CHECK(!packet_being_processed_);
 
   if (received_packets_.empty()) {
     // Nothing to do!
     return;
   }
 
   scoped_ptr<VideoPacket> packet(received_packets_.front().packet);
@@ skipping 50 matching lines @@
 
   // Process the next video packet.
   DispatchPacket();
 }
 
 void ChromotingClient::Initialize() {
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   // Initialize the decoder.
   rectangle_decoder_->Initialize(connection_->config());
+  if (connection_->config().is_audio_enabled()) {

[Sergey Ulanov, 2012/08/03 17:59:55]

remove brackets for consistency with other one-line ifs in this file.

[kxing, 2012/08/03 20:55:13]

Done.

+    audio_decode_scheduler_->Initialize(connection_->config());
+  }
 }
 
 }  // namespace remoting