Add audio support in WebrtcConnectionToHost, audio unittest

remoting/protocol/webrtc_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/webrtc_connection_to_host.h"
 
 #include <utility>
 
 #include "base/strings/string_util.h"
 #include "jingle/glue/thread_wrapper.h"
 #include "remoting/base/constants.h"
 #include "remoting/protocol/client_control_dispatcher.h"
 #include "remoting/protocol/client_event_dispatcher.h"
 #include "remoting/protocol/client_stub.h"
 #include "remoting/protocol/clipboard_stub.h"
 #include "remoting/protocol/message_pipe.h"
 #include "remoting/protocol/transport_context.h"
 #include "remoting/protocol/video_renderer.h"
+#include "remoting/protocol/webrtc_audio_module.h"
+#include "remoting/protocol/webrtc_audio_sink_adapter.h"
 #include "remoting/protocol/webrtc_transport.h"
 #include "remoting/protocol/webrtc_video_renderer_adapter.h"
 
 namespace remoting {
 namespace protocol {
 
 WebrtcConnectionToHost::WebrtcConnectionToHost() {}
 WebrtcConnectionToHost::~WebrtcConnectionToHost() {}
 
 void WebrtcConnectionToHost::Connect(
     std::unique_ptr<Session> session,
     scoped_refptr<TransportContext> transport_context,
     HostEventCallback* event_callback) {
   DCHECK(client_stub_);
   DCHECK(clipboard_stub_);
 
   transport_.reset(new WebrtcTransport(
       jingle_glue::JingleThreadWrapper::current(), transport_context, this));
 
+  transport_->audio_module()->SetAudioTaskRunner(audio_decode_task_runner_);
+
   session_ = std::move(session);
   session_->SetEventHandler(this);
   session_->SetTransport(transport_.get());
 
   event_callback_ = event_callback;
 
   SetState(CONNECTING, OK);
 }
 
 const SessionConfig& WebrtcConnectionToHost::config() {
@@ skipping 19 matching lines @@
 void WebrtcConnectionToHost::set_clipboard_stub(ClipboardStub* clipboard_stub) {
   clipboard_stub_ = clipboard_stub;
 }
 
 void WebrtcConnectionToHost::set_video_renderer(VideoRenderer* video_renderer) {
   video_renderer_ = video_renderer;
 }
 
 void WebrtcConnectionToHost::InitializeAudio(
     scoped_refptr<base::SingleThreadTaskRunner> audio_decode_task_runner,
-    base::WeakPtr<AudioStub> audio_stub) {
-  NOTIMPLEMENTED();
+    base::WeakPtr<AudioStub> audio_consumer) {
+  audio_decode_task_runner_ = audio_decode_task_runner;
+  audio_consumer_ = audio_consumer;
 }
 
 void WebrtcConnectionToHost::OnSessionStateChange(Session::State state) {
   DCHECK(event_callback_);
 
   switch (state) {
     case Session::INITIALIZING:
     case Session::CONNECTING:
     case Session::ACCEPTING:
     case Session::ACCEPTED:
@@ skipping 48 matching lines @@
         name.substr(strlen(kVideoStatsChannelNamePrefix));
     GetOrCreateVideoAdapter(video_stream_label)
         ->SetVideoStatsChannel(std::move(pipe));
   } else {
     LOG(WARNING) << "Received unknown incoming data channel " << name;
   }
 }
 
 void WebrtcConnectionToHost::OnWebrtcTransportMediaStreamAdded(
     scoped_refptr<webrtc::MediaStreamInterface> stream) {
-  GetOrCreateVideoAdapter(stream->label())->SetMediaStream(stream);
+  if (stream->GetVideoTracks().size() > 0) {
+    GetOrCreateVideoAdapter(stream->label())->SetMediaStream(stream);
+  } else if (stream->GetAudioTracks().size() > 0) {
+    audio_adapter_.reset(new WebrtcAudioSinkAdapter(stream, audio_consumer_));
+  } else {
+    LOG(ERROR) << "Received MediaStream with no video or audio tracks.";
+  }
 }
 
 void WebrtcConnectionToHost::OnWebrtcTransportMediaStreamRemoved(
     scoped_refptr<webrtc::MediaStreamInterface> stream) {
   if (video_adapter_ && video_adapter_->label() == stream->label())
     video_adapter_.reset();
 }
 
 void WebrtcConnectionToHost::OnChannelInitialized(
     ChannelDispatcherBase* channel_dispatcher) {
@@ skipping 49 matching lines @@
 
   if (state != state_) {
     state_ = state;
     error_ = error;
     event_callback_->OnConnectionState(state_, error_);
   }
 }
 
 }  // namespace protocol
 }  // namespace remoting