Move audio decoding to protocol layer

remoting/protocol/ice_connection_to_host.cc

 // 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/protocol/ice_connection_to_host.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/location.h"
 #include "remoting/base/constants.h"
+#include "remoting/protocol/audio_decode_scheduler.h"
 #include "remoting/protocol/audio_reader.h"
 #include "remoting/protocol/audio_stub.h"
 #include "remoting/protocol/auth_util.h"
 #include "remoting/protocol/client_control_dispatcher.h"
 #include "remoting/protocol/client_event_dispatcher.h"
 #include "remoting/protocol/client_stub.h"
 #include "remoting/protocol/client_video_dispatcher.h"
 #include "remoting/protocol/clipboard_stub.h"
 #include "remoting/protocol/errors.h"
 #include "remoting/protocol/ice_transport.h"
@@ skipping 49 matching lines @@
 void IceConnectionToHost::set_clipboard_stub(ClipboardStub* clipboard_stub) {
   clipboard_stub_ = clipboard_stub;
 }
 
 void IceConnectionToHost::set_video_renderer(VideoRenderer* video_renderer) {
   DCHECK(video_renderer);
   DCHECK(!monitored_video_stub_);
   video_renderer_ = video_renderer;
 }
 
-void IceConnectionToHost::set_audio_stub(AudioStub* audio_stub) {
-  audio_stub_ = audio_stub;
+void IceConnectionToHost::InitializeAudio(
+    scoped_refptr<base::SingleThreadTaskRunner> audio_decode_task_runner,
+    base::WeakPtr<AudioStub> audio_stub) {
+  audio_decode_scheduler_.reset(
+      new AudioDecodeScheduler(audio_decode_task_runner, audio_stub));
 }
 
 void IceConnectionToHost::OnSessionStateChange(Session::State state) {
   DCHECK(CalledOnValidThread());
   DCHECK(event_callback_);
 
   switch (state) {
     case Session::INITIALIZING:
     case Session::CONNECTING:
     case Session::ACCEPTING:
@@ skipping 23 matching lines @@
           base::TimeDelta::FromSeconds(
               MonitoredVideoStub::kConnectivityCheckDelaySeconds),
           base::Bind(&IceConnectionToHost::OnVideoChannelStatus,
                      base::Unretained(this))));
       video_dispatcher_.reset(
           new ClientVideoDispatcher(monitored_video_stub_.get(), client_stub_));
       video_dispatcher_->Init(transport_->GetChannelFactory(), this);
 
       // Configure audio pipeline if necessary.
       if (session_->config().is_audio_enabled()) {
-        audio_reader_.reset(new AudioReader(audio_stub_));
+        audio_reader_.reset(new AudioReader(audio_decode_scheduler_.get()));
         audio_reader_->Init(transport_->GetMultiplexedChannelFactory(), this);
+        audio_decode_scheduler_->Initialize(session_->config());
       }
       break;
 
     case Session::CLOSED:
       CloseChannels();
       SetState(CLOSED, OK);
       break;
 
     case Session::FAILED:
       // If we were connected then treat signaling timeout error as if
@@ skipping 79 matching lines @@
 
   if (state != state_) {
     state_ = state;
     error_ = error;
     event_callback_->OnConnectionState(state_, error_);
   }
 }
 
 }  // namespace protocol
 }  // namespace remoting