Add audio support in WebrtcConnectionToHost, audio unittest

remoting/protocol/webrtc_transport.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_transport.h"
 
 #include <string>
 #include <utility>
 #include <vector>
 
@@ skipping 128 matching lines @@
 
 class WebrtcTransport::PeerConnectionWrapper
     : public webrtc::PeerConnectionObserver {
  public:
   PeerConnectionWrapper(
       rtc::Thread* worker_thread,
       std::unique_ptr<cricket::WebRtcVideoEncoderFactory> encoder_factory,
       std::unique_ptr<cricket::PortAllocator> port_allocator,
       base::WeakPtr<WebrtcTransport> transport)
       : transport_(transport) {
-    scoped_refptr<WebrtcAudioModule> audio_module =
-        new rtc::RefCountedObject<WebrtcAudioModule>();
+    audio_module_ = new rtc::RefCountedObject<WebrtcAudioModule>();
 
     peer_connection_factory_ = webrtc::CreatePeerConnectionFactory(
-        worker_thread, rtc::Thread::Current(), audio_module.get(),
+        worker_thread, rtc::Thread::Current(), audio_module_.get(),
         encoder_factory.release(), nullptr);
 
     webrtc::FakeConstraints constraints;
     constraints.AddMandatory(webrtc::MediaConstraintsInterface::kEnableDtlsSrtp,
                              webrtc::MediaConstraintsInterface::kValueTrue);
     peer_connection_ = peer_connection_factory_->CreatePeerConnection(
         webrtc::PeerConnectionInterface::RTCConfiguration(), &constraints,
         std::move(port_allocator), nullptr, this);
   }
   virtual ~PeerConnectionWrapper() { peer_connection_->Close(); }
 
+  WebrtcAudioModule* audio_module() {
+    return audio_module_.get();
+  }
+
   webrtc::PeerConnectionInterface* peer_connection() {
     return peer_connection_.get();
   }
 
   webrtc::PeerConnectionFactoryInterface* peer_connection_factory() {
     return peer_connection_factory_.get();
   }
 
   // webrtc::PeerConnectionObserver interface.
   void OnSignalingChange(
@@ skipping 43 matching lines @@
 
   base::WeakPtr<WebrtcTransport> transport_;
 
   DISALLOW_COPY_AND_ASSIGN(PeerConnectionWrapper);
 };
 
 WebrtcTransport::WebrtcTransport(
     rtc::Thread* worker_thread,
     scoped_refptr<TransportContext> transport_context,
     EventHandler* event_handler)
-    : worker_thread_(worker_thread),
-      transport_context_(transport_context),
+    : transport_context_(transport_context),
       event_handler_(event_handler),
       handshake_hmac_(crypto::HMAC::SHA256),
       weak_factory_(this) {
   transport_context_->set_relay_mode(TransportContext::RelayMode::TURN);
+
+  video_encoder_factory_ = new WebrtcDummyVideoEncoderFactory();
+  std::unique_ptr<cricket::PortAllocator> port_allocator =
+      transport_context_->port_allocator_factory()->CreatePortAllocator(
+          transport_context_);
+
+  // Takes ownership of video_encoder_factory_.
+  peer_connection_wrapper_.reset(new PeerConnectionWrapper(
+      worker_thread, base::WrapUnique(video_encoder_factory_),
+      std::move(port_allocator), weak_factory_.GetWeakPtr()));
 }
 
 WebrtcTransport::~WebrtcTransport() {
   Close(OK);
 }
 
 webrtc::PeerConnectionInterface* WebrtcTransport::peer_connection() {
   return peer_connection_wrapper_ ? peer_connection_wrapper_->peer_connection()
                                   : nullptr;
 }
 
 webrtc::PeerConnectionFactoryInterface*
 WebrtcTransport::peer_connection_factory() {
   return peer_connection_wrapper_
              ? peer_connection_wrapper_->peer_connection_factory()
              : nullptr;
 }
 
+WebrtcAudioModule* WebrtcTransport::audio_module() {
+  return peer_connection_wrapper_
+             ? peer_connection_wrapper_->audio_module()
+             : nullptr;
+}
+
 std::unique_ptr<MessagePipe> WebrtcTransport::CreateOutgoingChannel(
     const std::string& name) {
   webrtc::DataChannelInit config;
   config.reliable = true;
   return base::MakeUnique<WebrtcDataStreamAdapter>(
       peer_connection()->CreateDataChannel(name, &config));
 }
 
 void WebrtcTransport::Start(
     Authenticator* authenticator,
     SendTransportInfoCallback send_transport_info_callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(send_transport_info_callback_.is_null());
 
   jingle_glue::JingleThreadWrapper::EnsureForCurrentMessageLoop();
 
   // TODO(sergeyu): Investigate if it's possible to avoid Send().
   jingle_glue::JingleThreadWrapper::current()->set_send_allowed(true);
 
   send_transport_info_callback_ = std::move(send_transport_info_callback);
 
   if (!handshake_hmac_.Init(authenticator->GetAuthKey())) {
     LOG(FATAL) << "HMAC::Init() failed.";
   }
 
-  video_encoder_factory_ = new WebrtcDummyVideoEncoderFactory();
-  std::unique_ptr<cricket::PortAllocator> port_allocator =
-      transport_context_->port_allocator_factory()->CreatePortAllocator(
-          transport_context_);
-
-  // Takes ownership of video_encoder_factory_.
-  peer_connection_wrapper_.reset(new PeerConnectionWrapper(
-      worker_thread_, base::WrapUnique(video_encoder_factory_),
-      std::move(port_allocator), weak_factory_.GetWeakPtr()));
-
   event_handler_->OnWebrtcTransportConnecting();
 
   if (transport_context_->role() == TransportRole::SERVER)
     RequestNegotiation();
 }
 
 bool WebrtcTransport::ProcessTransportInfo(XmlElement* transport_info) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (transport_info->Name() != QName(kTransportNamespace, "transport"))
@@ skipping 130 matching lines @@
   }
 
   std::string description_sdp;
   if (!description->ToString(&description_sdp)) {
     LOG(ERROR) << "Failed to serialize description.";
     Close(CHANNEL_CONNECTION_ERROR);
     return;
   }
   description_sdp = NormalizeSessionDescription(description_sdp);
 
+  // Update SDP format to use stereo for opus codec.
+  std::string opus_line = "a=rtpmap:111 opus/48000/2\n";
+  std::string opus_line_with_bitrate =
+      opus_line + "a=fmtp:111 stereo=1; x-google-min-bitrate=160\n";
+  base::ReplaceSubstringsAfterOffset(&description_sdp, 0, opus_line,
+                                     opus_line_with_bitrate);
+
   // Format and send the session description to the peer.
   std::unique_ptr<XmlElement> transport_info(
       new XmlElement(QName(kTransportNamespace, "transport"), true));
   XmlElement* offer_tag =
       new XmlElement(QName(kTransportNamespace, "session-description"));
   transport_info->AddElement(offer_tag);
   offer_tag->SetAttr(QName(std::string(), "type"), description->type());
   offer_tag->SetBodyText(description_sdp);
 
   std::string digest;
@@ skipping 216 matching lines @@
   // the stack and so it must be destroyed later.
   base::ThreadTaskRunnerHandle::Get()->DeleteSoon(
       FROM_HERE, peer_connection_wrapper_.release());
 
   if (error != OK)
     event_handler_->OnWebrtcTransportError(error);
 }
 
 }  // namespace protocol
 }  // namespace remoting