Remove WebRtc audio source references for local audio tracks.

content/renderer/media/webrtc/peer_connection_dependency_factory.cc

 // Copyright 2014 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 "content/renderer/media/webrtc/peer_connection_dependency_factory.h"
 
 #include <stddef.h>
 
 #include <utility>
 #include <vector>
@@ skipping 163 matching lines @@
     // Feature is to be disabled, no need to make sure FFmpeg is initialized.
     webrtc::DisableRtcUseH264();
   }
 #endif
 
   base::MessageLoop::current()->AddDestructionObserver(this);
   // To allow sending to the signaling/worker threads.
   jingle_glue::JingleThreadWrapper::EnsureForCurrentMessageLoop();
   jingle_glue::JingleThreadWrapper::current()->set_send_allowed(true);
 
+  EnsureWebRtcAudioDeviceImpl();
+
   CHECK(chrome_signaling_thread_.Start());
   CHECK(chrome_worker_thread_.Start());
 
   base::WaitableEvent start_worker_event(true, false);
   chrome_worker_thread_.task_runner()->PostTask(
       FROM_HERE,
       base::Bind(&PeerConnectionDependencyFactory::InitializeWorkerThread,
                  base::Unretained(this), &worker_thread_, &start_worker_event));
 
   base::WaitableEvent create_network_manager_event(true, false);
@@ skipping 31 matching lines @@
     media::GpuVideoAcceleratorFactories* gpu_factories,
     base::WaitableEvent* event) {
   DCHECK(chrome_signaling_thread_.task_runner()->BelongsToCurrentThread());
   DCHECK(worker_thread_);
   DCHECK(p2p_socket_dispatcher_.get());
 
   jingle_glue::JingleThreadWrapper::EnsureForCurrentMessageLoop();
   jingle_glue::JingleThreadWrapper::current()->set_send_allowed(true);
   signaling_thread_ = jingle_glue::JingleThreadWrapper::current();
 
-  EnsureWebRtcAudioDeviceImpl();
-
   socket_factory_.reset(
       new IpcPacketSocketFactory(p2p_socket_dispatcher_.get()));
 
   std::unique_ptr<cricket::WebRtcVideoDecoderFactory> decoder_factory;
   std::unique_ptr<cricket::WebRtcVideoEncoderFactory> encoder_factory;
 
   const base::CommandLine* cmd_line = base::CommandLine::ForCurrentProcess();
   if (gpu_factories && gpu_factories->IsGpuVideoAcceleratorEnabled()) {
     if (!cmd_line->HasSwitch(switches::kDisableWebRtcHWDecoding))
       decoder_factory.reset(new RTCVideoDecoderFactory(gpu_factories));
@@ skipping 169 matching lines @@
       webrtc::kIdentityName, rtc::KeyParams::ECDSA(rtc::EC_NIST_P256)));
   return rtc::RTCCertificate::Create(std::move(identity));
 }
 
 scoped_refptr<webrtc::MediaStreamInterface>
 PeerConnectionDependencyFactory::CreateLocalMediaStream(
     const std::string& label) {
   return GetPcFactory()->CreateLocalMediaStream(label).get();
 }
 
-scoped_refptr<webrtc::AudioSourceInterface>
-PeerConnectionDependencyFactory::CreateLocalAudioSource(
-    const cricket::AudioOptions& options) {
-  scoped_refptr<webrtc::AudioSourceInterface> source =
-      GetPcFactory()->CreateAudioSource(options).get();
-  return source;
-}
-
 scoped_refptr<webrtc::VideoTrackInterface>
 PeerConnectionDependencyFactory::CreateLocalVideoTrack(
     const std::string& id,
     webrtc::VideoTrackSourceInterface* source) {
   return GetPcFactory()->CreateVideoTrack(id, source).get();
 }
 
 scoped_refptr<webrtc::VideoTrackInterface>
 PeerConnectionDependencyFactory::CreateLocalVideoTrack(
     const std::string& id, cricket::VideoCapturer* capturer) {
@@ skipping 30 matching lines @@
     base::PlatformFile file) {
   return GetPcFactory()->StartRtcEventLog(file);
 }
 
 void PeerConnectionDependencyFactory::StopRtcEventLog() {
   GetPcFactory()->StopRtcEventLog();
 }
 
 WebRtcAudioDeviceImpl*
 PeerConnectionDependencyFactory::GetWebRtcAudioDevice() {
+  DCHECK(CalledOnValidThread());
+  EnsureWebRtcAudioDeviceImpl();
   return audio_device_.get();
 }
 
 void PeerConnectionDependencyFactory::InitializeWorkerThread(
     rtc::Thread** thread,
     base::WaitableEvent* event) {
   jingle_glue::JingleThreadWrapper::EnsureForCurrentMessageLoop();
   jingle_glue::JingleThreadWrapper::current()->set_send_allowed(true);
   *thread = jingle_glue::JingleThreadWrapper::current();
   event->Signal();
@@ skipping 89 matching lines @@
 
 scoped_refptr<base::SingleThreadTaskRunner>
 PeerConnectionDependencyFactory::GetWebRtcSignalingThread() const {
   DCHECK(CalledOnValidThread());
   return chrome_signaling_thread_.IsRunning()
              ? chrome_signaling_thread_.task_runner()
              : nullptr;
 }
 
 void PeerConnectionDependencyFactory::EnsureWebRtcAudioDeviceImpl() {
+  DCHECK(CalledOnValidThread());
   if (audio_device_.get())
     return;
 
   audio_device_ = new WebRtcAudioDeviceImpl();
 }
 
 }  // namespace content