MediaStream audio object graph untangling and clean-ups.

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>
 
+#include "base/bind.h"
+#include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/metrics/field_trial.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/synchronization/waitable_event.h"
 #include "build/build_config.h"
 #include "content/common/media/media_stream_messages.h"
@@ skipping 158 matching lines @@
   // microphone or tab audio.
   RTCMediaConstraints native_audio_constraints(audio_constraints);
   MediaAudioConstraints::ApplyFixedAudioConstraints(&native_audio_constraints);
 
   StreamDeviceInfo device_info = source_data->device_info();
   RTCMediaConstraints constraints = native_audio_constraints;
   // May modify both |constraints| and |effects|.
   HarmonizeConstraintsAndEffects(&constraints,
                                  &device_info.device.input.effects);
 
-  scoped_refptr<WebRtcAudioCapturer> capturer(CreateAudioCapturer(
-      render_frame_id, device_info, audio_constraints, source_data));
+  scoped_ptr<WebRtcAudioCapturer> capturer = CreateAudioCapturer(
+      render_frame_id, device_info, audio_constraints, source_data);
   if (!capturer.get()) {
     const std::string log_string =
         "PCDF::InitializeMediaStreamAudioSource: fails to create capturer";
     WebRtcLogMessage(log_string);
     DVLOG(1) << log_string;
     // TODO(xians): Don't we need to check if source_observer is observing
     // something? If not, then it looks like we have a leak here.
     // OTOH, if it _is_ observing something, then the callback might
     // be called multiple times which is likely also a bug.
     return false;
   }
-  source_data->SetAudioCapturer(capturer.get());
+  source_data->SetAudioCapturer(std::move(capturer));
 
   // Creates a LocalAudioSource object which holds audio options.
   // TODO(xians): The option should apply to the track instead of the source.
   // TODO(perkj): Move audio constraints parsing to Chrome.
   // Currently there are a few constraints that are parsed by libjingle and
   // the state is set to ended if parsing fails.
   scoped_refptr<webrtc::AudioSourceInterface> rtc_source(
       CreateLocalAudioSource(&constraints).get());
   if (rtc_source->state() != webrtc::MediaSourceInterface::kLive) {
     DLOG(WARNING) << "Failed to create rtc LocalAudioSource.";
@@ skipping 316 matching lines @@
     const webrtc::MediaConstraintsInterface* constraints) {
   scoped_refptr<webrtc::AudioSourceInterface> source =
       GetPcFactory()->CreateAudioSource(constraints).get();
   return source;
 }
 
 void PeerConnectionDependencyFactory::CreateLocalAudioTrack(
     const blink::WebMediaStreamTrack& track) {
   blink::WebMediaStreamSource source = track.source();
   DCHECK_EQ(source.type(), blink::WebMediaStreamSource::TypeAudio);
-  DCHECK(!source.remote());
-  MediaStreamAudioSource* source_data =
-      static_cast<MediaStreamAudioSource*>(source.extraData());
+  MediaStreamAudioSource* source_data = MediaStreamAudioSource::From(source);
 
-  scoped_refptr<WebAudioCapturerSource> webaudio_source;
+  scoped_ptr<WebAudioCapturerSource> webaudio_source;
   if (!source_data) {
     if (source.requiresAudioConsumer()) {
       // We're adding a WebAudio MediaStream.
       // Create a specific capturer for each WebAudio consumer.
       webaudio_source = CreateWebAudioSource(&source);
-      source_data =
-          static_cast<MediaStreamAudioSource*>(source.extraData());
+      source_data = MediaStreamAudioSource::From(source);
     } else {
-      NOTREACHED() << "Local track missing source extra data.";
+      NOTREACHED() << "Local track missing MediaStreamAudioSource instance.";
       return;
     }
   }
 
   // Creates an adapter to hold all the libjingle objects.
   scoped_refptr<WebRtcLocalAudioTrackAdapter> adapter(
       WebRtcLocalAudioTrackAdapter::Create(track.id().utf8(),
                                            source_data->local_audio_source()));
   static_cast<webrtc::AudioTrackInterface*>(adapter.get())->set_enabled(
       track.isEnabled());
 
   // TODO(xians): Merge |source| to the capturer(). We can't do this today
   // because only one capturer() is supported while one |source| is created
   // for each audio track.
-  scoped_ptr<WebRtcLocalAudioTrack> audio_track(new WebRtcLocalAudioTrack(
-      adapter.get(), source_data->GetAudioCapturer(), webaudio_source.get()));
+  scoped_ptr<WebRtcLocalAudioTrack> audio_track(
+      new WebRtcLocalAudioTrack(adapter.get()));
 
-  StartLocalAudioTrack(audio_track.get());
+  // Start the source and connect the audio data flow to the track.
+  if (webaudio_source.get()) {
+    webaudio_source->Start(audio_track.get());
+    // The stop callback takes ownership of the |webaudio_source|, which will
+    // cause it to be auto-destroyed when the track is stopped.
+    //
+    // TODO(miu): In a future change, WebAudioCapturerSource will become a
+    // subclass of MediaStreamAudioSource, and this will allow it to be owned by
+    // the blink::WebMediaStreamSource so we don't need this hacky thing here.
+    audio_track->AddStopObserver(base::Bind(
+        &WebAudioCapturerSource::Stop, base::Owned(webaudio_source.release())));
+  } else if (WebRtcAudioCapturer* capturer = source_data->audio_capturer()) {
+    capturer->AddTrack(audio_track.get());
+  } else {
+    NOTREACHED();
+  }
 
   // Pass the ownership of the native local audio track to the blink track.
   blink::WebMediaStreamTrack writable_track = track;
   writable_track.setExtraData(audio_track.release());
 }
 
 void PeerConnectionDependencyFactory::CreateRemoteAudioTrack(
     const blink::WebMediaStreamTrack& track) {
   blink::WebMediaStreamSource source = track.source();
   DCHECK_EQ(source.type(), blink::WebMediaStreamSource::TypeAudio);
   DCHECK(source.remote());
-  DCHECK(source.extraData());
+  DCHECK(MediaStreamAudioSource::From(source));
 
   blink::WebMediaStreamTrack writable_track = track;
   writable_track.setExtraData(
       new MediaStreamRemoteAudioTrack(source, track.isEnabled()));
 }
 
-void PeerConnectionDependencyFactory::StartLocalAudioTrack(
-    WebRtcLocalAudioTrack* audio_track) {
-  // Start the audio track. This will hook the |audio_track| to the capturer
-  // as the sink of the audio, and only start the source of the capturer if
-  // it is the first audio track connecting to the capturer.
-  audio_track->Start();
-}
-
-scoped_refptr<WebAudioCapturerSource>
+scoped_ptr<WebAudioCapturerSource>
 PeerConnectionDependencyFactory::CreateWebAudioSource(
     blink::WebMediaStreamSource* source) {
   DVLOG(1) << "PeerConnectionDependencyFactory::CreateWebAudioSource()";
 
-  scoped_refptr<WebAudioCapturerSource>
-      webaudio_capturer_source(new WebAudioCapturerSource(*source));
   MediaStreamAudioSource* source_data = new MediaStreamAudioSource();
 
-  // Use the current default capturer for the WebAudio track so that the
-  // WebAudio track can pass a valid delay value and |need_audio_processing|
-  // flag to PeerConnection.
-  // TODO(xians): Remove this after moving APM to Chrome.
-  if (GetWebRtcAudioDevice()) {
-    source_data->SetAudioCapturer(
-        GetWebRtcAudioDevice()->GetDefaultCapturer());
-  }
-
   // Create a LocalAudioSource object which holds audio options.
   // SetLocalAudioSource() affects core audio parts in third_party/Libjingle.
   source_data->SetLocalAudioSource(CreateLocalAudioSource(NULL).get());
   source->setExtraData(source_data);
 
-  // Replace the default source with WebAudio as source instead.
-  source->addAudioConsumer(webaudio_capturer_source.get());
-
-  return webaudio_capturer_source;
+  return make_scoped_ptr(new WebAudioCapturerSource(source));
 }
 
 scoped_refptr<webrtc::VideoTrackInterface>
 PeerConnectionDependencyFactory::CreateLocalVideoTrack(
     const std::string& id,
     webrtc::VideoSourceInterface* source) {
   return GetPcFactory()->CreateVideoTrack(id, source).get();
 }
 
 scoped_refptr<webrtc::VideoTrackInterface>
@@ skipping 120 matching lines @@
       // Stopping the thread will wait until all tasks have been
       // 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.";
     }
   }
 }
 
-scoped_refptr<WebRtcAudioCapturer>
+scoped_ptr<WebRtcAudioCapturer>
 PeerConnectionDependencyFactory::CreateAudioCapturer(
     int render_frame_id,
     const StreamDeviceInfo& device_info,
     const blink::WebMediaConstraints& constraints,
     MediaStreamAudioSource* audio_source) {
   // TODO(xians): Handle the cases when gUM is called without a proper render
   // view, for example, by an extension.
   DCHECK_GE(render_frame_id, 0);
 
   EnsureWebRtcAudioDeviceImpl();
@@ skipping 24 matching lines @@
 }
 
 void PeerConnectionDependencyFactory::EnsureWebRtcAudioDeviceImpl() {
   if (audio_device_.get())
     return;
 
   audio_device_ = new WebRtcAudioDeviceImpl();
 }
 
 }  // namespace content