Add WebrtcAudioModule

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>
 
 #include "base/base64.h"
 #include "base/callback_helpers.h"
 #include "base/command_line.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/task_runner_util.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "jingle/glue/thread_wrapper.h"
 #include "remoting/protocol/authenticator.h"
 #include "remoting/protocol/port_allocator_factory.h"
 #include "remoting/protocol/stream_message_pipe_adapter.h"
 #include "remoting/protocol/transport_context.h"
+#include "remoting/protocol/webrtc_audio_module.h"
 #include "remoting/protocol/webrtc_dummy_video_encoder.h"
 #include "third_party/webrtc/api/test/fakeconstraints.h"
 #include "third_party/webrtc/libjingle/xmllite/xmlelement.h"
-#include "third_party/webrtc/modules/audio_device/include/fake_audio_device.h"
 
 using buzz::QName;
 using buzz::XmlElement;
 
 namespace remoting {
 namespace protocol {
 
 namespace {
 
 // Delay after candidate creation before sending transport-info message to
@@ skipping 98 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>();
+
     peer_connection_factory_ = webrtc::CreatePeerConnectionFactory(
-        worker_thread, rtc::Thread::Current(), &fake_audio_device_module_,
+        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(); }
@@ skipping 40 matching lines @@
       webrtc::PeerConnectionInterface::IceGatheringState new_state) override {
     if (transport_)
       transport_->OnIceGatheringChange(new_state);
   }
   void OnIceCandidate(const webrtc::IceCandidateInterface* candidate) override {
     if (transport_)
       transport_->OnIceCandidate(candidate);
   }
 
  private:
-  webrtc::FakeAudioDeviceModule fake_audio_device_module_;
+  scoped_refptr<WebrtcAudioModule> audio_module_;
   scoped_refptr<webrtc::PeerConnectionFactoryInterface>
       peer_connection_factory_;
   scoped_refptr<webrtc::PeerConnectionInterface> peer_connection_;
 
   base::WeakPtr<WebrtcTransport> transport_;
 
   DISALLOW_COPY_AND_ASSIGN(PeerConnectionWrapper);
 };
 
 WebrtcTransport::WebrtcTransport(
@@ skipping 438 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