Add chromium support for MediaStreamAudioDestinationNode - part II

content/renderer/media/media_stream_dependency_factory.cc

 // Copyright (c) 2012 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/media_stream_dependency_factory.h"
 
 #include <vector>
 
 #include "base/synchronization/waitable_event.h"
 #include "base/utf_string_conversions.h"
@@ skipping 210 matching lines @@
         CreateVideoSource(source_data->device_info().session_id,
                           is_screencast,
                           &native_video_constraints));
     source_observer->AddSource(source_data->video_source());
   }
   source_observer->StartObservering();
 }
 
 void MediaStreamDependencyFactory::CreateNativeLocalMediaStream(
     WebKit::WebMediaStreamDescriptor* description) {
-  DCHECK(PeerConnectionFactoryCreated());
+  if (!EnsurePeerConnectionFactory()) {
+      DVLOG(1) << "EnsurePeerConnectionFactory() failed!";
+      return;
+  }
+
+  DVLOG(1) << "---MediaStreamDependencyFactory::CreateNativeLocalMediaStream()";
 
   std::string label = UTF16ToUTF8(description->label());
   scoped_refptr<webrtc::LocalMediaStreamInterface> native_stream =
       CreateLocalMediaStream(label);
 
+  WebRtcAudioCapturer* capturer = GetWebRtcAudioDevice()->capturer();
+  if (!capturer)
+      DVLOG(1) << "CreateNativeLocalMediaStream: missing WebRtcAudioCapturer.";
+
   // Add audio tracks.
   WebKit::WebVector<WebKit::WebMediaStreamComponent> audio_components;
   description->audioSources(audio_components);
+
   for (size_t i = 0; i < audio_components.size(); ++i) {
-    const WebKit::WebMediaStreamSource& source = audio_components[i].source();
-    MediaStreamSourceExtraData* source_data =
-        static_cast<MediaStreamSourceExtraData*>(source.extraData());
-    if (!source_data) {
-      // TODO(perkj): Implement support for sources from remote MediaStreams.
-      NOTIMPLEMENTED();
-      continue;
+    WebKit::WebMediaStreamSource source = audio_components[i].source();
+
+    // See if we're adding a WebAudio MediaStream.
+    if (source.requiresAudioConsumer()) {
+      if (!webaudio_capturer_source_.get() && capturer) {
+        DVLOG(1) << "CreateNativeLocalMediaStream: WebAudio MediaStream.";
+        DCHECK(GetWebRtcAudioDevice());
+
+        // TODO(crogers, xians): In reality we should be able to send a unique
+        // audio stream to each PeerConnection separately.  But currently WebRTC
+        // is only able to handle a global audio stream sent to ALL peers.
+
+        // TODO(henrika) - why store it here webaudio_capturer_source_?
+
+        webaudio_capturer_source_ = new WebAudioCapturerSource();
+        capturer->SetCapturerSource(webaudio_capturer_source_);
+        capturer->Start();
+
+        // For lifetime, we're relying on the fact that
+        // |webaudio_capturer_source_| will live longer than any
+        // MediaStreamSource, since we're never calling removeAudioConsumer().
+        source.addAudioConsumer(webaudio_capturer_source_.get());
+
+        scoped_refptr<webrtc::LocalAudioTrackInterface> audio_track(
+            CreateLocalAudioTrack(label + "a0", NULL));
+        native_stream->AddTrack(audio_track);
+        audio_track->set_enabled(audio_components[i].isEnabled());
+
+        // Do we need to set a sessionId???
+        // SetAudioDeviceSessionId(99);
+      } else {
+        // TODO(crogers): this is very likely to be less important, but
+        // in theory we should be able to "connect" multiple WebAudio
+        // MediaStreams to a single peer, mixing their results.
+        // Instead we just ignore additional ones after the first.
+        DVLOG(1)
+            << "Multiple MediaStreamAudioDestinationNodes not yet supported!";
+      }
+    } else {
+        MediaStreamSourceExtraData* source_data =
+            static_cast<MediaStreamSourceExtraData*>(source.extraData());
+
+        if (!source_data) {
+          // TODO(perkj): Implement support for sources from
+          // remote MediaStreams.
+          NOTIMPLEMENTED();
+          continue;
+        }
+
+        // TODO(perkj): Refactor the creation of audio tracks to use a proper
+        // interface for receiving audio input data. Currently NULL is passed
+        // since the |audio_device| is the wrong class and is unused.
+        scoped_refptr<webrtc::LocalAudioTrackInterface> audio_track(
+            CreateLocalAudioTrack(UTF16ToUTF8(source.id()), NULL));
+        native_stream->AddTrack(audio_track);
+        audio_track->set_enabled(audio_components[i].isEnabled());
+        // TODO(xians): This set the source of all audio tracks to the same
+        // microphone. Implement support for setting the source per audio track
+        // instead.
+        SetAudioDeviceSessionId(source_data->device_info().session_id);
     }
-    // TODO(perkj): Refactor the creation of audio tracks to use a proper
-    // interface for receiving audio input data. Currently NULL is passed since
-    // the |audio_device| is the wrong class and is unused.
-    scoped_refptr<webrtc::LocalAudioTrackInterface> audio_track(
-        CreateLocalAudioTrack(UTF16ToUTF8(source.id()), NULL));
-    native_stream->AddTrack(audio_track);
-    audio_track->set_enabled(audio_components[i].isEnabled());
-    // TODO(xians): This set the source of all audio tracks to the same
-    // microphone. Implement support for setting the source per audio track
-    // instead.
-    SetAudioDeviceSessionId(source_data->device_info().session_id);
   }
 
   // Add video tracks.
   WebKit::WebVector<WebKit::WebMediaStreamComponent> video_components;
   description->videoSources(video_components);
   for (size_t i = 0; i < video_components.size(); ++i) {
     const WebKit::WebMediaStreamSource& source = video_components[i].source();
     MediaStreamSourceExtraData* source_data =
         static_cast<MediaStreamSourceExtraData*>(source.extraData());
     if (!source_data || !source_data->video_source()) {
@@ skipping 58 matching lines @@
             network_manager_,
             socket_factory_.get(),
             web_frame);
   return pc_factory_->CreatePeerConnection(
       ice_servers, constraints, pa_factory, observer).get();
 }
 
 scoped_refptr<webrtc::LocalMediaStreamInterface>
 MediaStreamDependencyFactory::CreateLocalMediaStream(
     const std::string& label) {
+  DVLOG(1) << "---MediaStreamDependencyFactory::CreateLocalMediaStream()";
   return pc_factory_->CreateLocalMediaStream(label).get();
 }
 
 scoped_refptr<webrtc::VideoSourceInterface>
 MediaStreamDependencyFactory::CreateVideoSource(
     int video_session_id,
     bool is_screencast,
     const webrtc::MediaConstraintsInterface* constraints) {
+  DVLOG(1) << "---MediaStreamDependencyFactory::CreateVideoSource()";
   RtcVideoCapturer* capturer = new RtcVideoCapturer(
       video_session_id, vc_manager_.get(), is_screencast);
 
   // The video source takes ownership of |capturer|.
   scoped_refptr<webrtc::VideoSourceInterface> source =
       pc_factory_->CreateVideoSource(capturer, constraints).get();
   return source;
 }
 
 scoped_refptr<webrtc::VideoTrackInterface>
 MediaStreamDependencyFactory::CreateLocalVideoTrack(
     const std::string& label,
     webrtc::VideoSourceInterface* source) {
+  DVLOG(1) << "---MediaStreamDependencyFactory::CreateLocalVideoTrack()";
   return pc_factory_->CreateVideoTrack(label, source).get();
 }
 
 scoped_refptr<webrtc::LocalAudioTrackInterface>
 MediaStreamDependencyFactory::CreateLocalAudioTrack(
     const std::string& label,
     webrtc::AudioDeviceModule* audio_device) {
+  DVLOG(1) << "---MediaStreamDependencyFactory::CreateLocalAudioTrack()";
   return pc_factory_->CreateLocalAudioTrack(label, audio_device).get();
 }
 
 webrtc::SessionDescriptionInterface*
 MediaStreamDependencyFactory::CreateSessionDescription(const std::string& sdp) {
   return webrtc::CreateSessionDescription(sdp);
 }
 
 webrtc::SessionDescriptionInterface*
 MediaStreamDependencyFactory::CreateSessionDescription(const std::string& type,
                                                        const std::string& sdp) {
   return webrtc::CreateSessionDescription(type, sdp);
 }
 
 webrtc::IceCandidateInterface* MediaStreamDependencyFactory::CreateIceCandidate(
     const std::string& sdp_mid,
     int sdp_mline_index,
     const std::string& sdp) {
   return webrtc::CreateIceCandidate(sdp_mid, sdp_mline_index, sdp);
 }
 
 WebRtcAudioDeviceImpl*
 MediaStreamDependencyFactory::GetWebRtcAudioDevice() {
   return audio_device_;
 }
 
 void MediaStreamDependencyFactory::SetAudioDeviceSessionId(int session_id) {
+  DVLOG(1) << "--- MediaStreamDependencyFactory::SetAudioDeviceSessionId()";
+  DVLOG(1) << "--- session_id: " << session_id;
   audio_device_->SetSessionId(session_id);
 }
 
 void MediaStreamDependencyFactory::InitializeWorkerThread(
     talk_base::Thread** thread,
     base::WaitableEvent* event) {
   jingle_glue::JingleThreadWrapper::EnsureForCurrentMessageLoop();
   jingle_glue::JingleThreadWrapper::current()->set_send_allowed(true);
   *thread = jingle_glue::JingleThreadWrapper::current();
   event->Signal();
 }
 
 void MediaStreamDependencyFactory::CreateIpcNetworkManagerOnWorkerThread(
     base::WaitableEvent* event) {
   DCHECK_EQ(MessageLoop::current(), chrome_worker_thread_.message_loop());
   network_manager_ = new IpcNetworkManager(p2p_socket_dispatcher_);
   event->Signal();
 }
 
 void MediaStreamDependencyFactory::DeleteIpcNetworkManager() {
   DCHECK_EQ(MessageLoop::current(), chrome_worker_thread_.message_loop());
   delete network_manager_;
   network_manager_ = NULL;
 }
 
 bool MediaStreamDependencyFactory::EnsurePeerConnectionFactory() {
+  DVLOG(1) << "--- MediaStreamDependencyFactory::EnsurePeerConnectionFactory()";
   DCHECK(CalledOnValidThread());
   if (PeerConnectionFactoryCreated())
     return true;
 
   if (!signaling_thread_) {
     jingle_glue::JingleThreadWrapper::EnsureForCurrentMessageLoop();
     jingle_glue::JingleThreadWrapper::current()->set_send_allowed(true);
     signaling_thread_ = jingle_glue::JingleThreadWrapper::current();
     CHECK(signaling_thread_);
   }
@@ skipping 55 matching lines @@
       // processed before returning. We wait for the above task to finish before
       // letting the the function continue to avoid any potential race issues.
       chrome_worker_thread_.Stop();
     } else {
       NOTREACHED() << "Worker thread not running.";
     }
   }
 }
 
 }  // namespace content