Add generic interfaces for the sinks of the media stream audio track

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/command_line.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 408 matching lines @@
   scoped_refptr<WebRtcAudioCapturer> capturer;
   if (GetWebRtcAudioDevice())
     capturer = GetWebRtcAudioDevice()->GetDefaultCapturer();
 
   scoped_refptr<webrtc::AudioTrackInterface> audio_track(
       CreateLocalAudioTrack(track_id,
                             capturer,
                             webaudio_source.get(),
                             source_data->local_audio_source(),
                             &track_constraints));
-  AddNativeTrackToBlinkTrack(audio_track.get(), track);
+  AddNativeTrackToBlinkTrack(audio_track.get(), track, true);
 
   audio_track->set_enabled(track.isEnabled());
 
   // Pass the pointer of the source provider to the blink audio track.
   blink::WebMediaStreamTrack writable_track = track;
   writable_track.setSourceProvider(static_cast<WebRtcLocalAudioTrack*>(
       audio_track.get())->audio_source_provider());
 
   return audio_track;
 }
 
 scoped_refptr<webrtc::VideoTrackInterface>
 MediaStreamDependencyFactory::CreateNativeVideoMediaStreamTrack(
     const blink::WebMediaStreamTrack& track) {
   blink::WebMediaStreamSource source = track.source();
   DCHECK_EQ(source.type(), blink::WebMediaStreamSource::TypeVideo);
   MediaStreamSourceExtraData* source_data =
       static_cast<MediaStreamSourceExtraData*>(source.extraData());
 
   if (!source_data) {
     // TODO(perkj): Implement support for sources from
     // remote MediaStreams.
     NOTIMPLEMENTED();
     return NULL;
   }
 
   std::string track_id = UTF16ToUTF8(track.id());
   scoped_refptr<webrtc::VideoTrackInterface> video_track(
       CreateLocalVideoTrack(track_id, source_data->video_source()));
-  AddNativeTrackToBlinkTrack(video_track.get(), track);
+  AddNativeTrackToBlinkTrack(video_track.get(), track, true);
 
   video_track->set_enabled(track.isEnabled());
 
   return video_track;
 }
 
 void MediaStreamDependencyFactory::CreateNativeMediaStreamTrack(
     const blink::WebMediaStreamTrack& track) {
   DCHECK(!track.isNull() && !track.extraData());
   DCHECK(!track.source().isNull());
@@ skipping 64 matching lines @@
 
   // Create a new webkit video track.
   blink::WebMediaStreamTrack webkit_track;
   blink::WebMediaStreamSource webkit_source;
   blink::WebString webkit_track_id(UTF8ToUTF16(track_id));
   blink::WebMediaStreamSource::Type type =
       blink::WebMediaStreamSource::TypeVideo;
   webkit_source.initialize(webkit_track_id, type, webkit_track_id);
 
   webkit_track.initialize(webkit_track_id, webkit_source);
-  AddNativeTrackToBlinkTrack(native_track.get(), webkit_track);
+  AddNativeTrackToBlinkTrack(native_track.get(), webkit_track, true);
 
   // Add the track to WebMediaStream.
   stream->addTrack(webkit_track);
   return true;
 }
 
 bool MediaStreamDependencyFactory::RemoveNativeMediaStreamTrack(
     const blink::WebMediaStream& stream,
     const blink::WebMediaStreamTrack& track) {
   MediaStreamExtraData* extra_data =
@@ skipping 349 matching lines @@
 
   // Add the capturer to the WebRtcAudioDeviceImpl if it is a new capturer.
   if (is_new_capturer)
     GetWebRtcAudioDevice()->AddAudioCapturer(capturer);
 
   return capturer;
 }
 
 void MediaStreamDependencyFactory::AddNativeTrackToBlinkTrack(
     webrtc::MediaStreamTrackInterface* native_track,
-    const blink::WebMediaStreamTrack& webkit_track) {
+    const blink::WebMediaStreamTrack& webkit_track,
+    bool is_local_track) {
   DCHECK(!webkit_track.isNull() && !webkit_track.extraData());
   blink::WebMediaStreamTrack track = webkit_track;
-  track.setExtraData(new MediaStreamTrackExtraData(native_track));
+  track.setExtraData(new MediaStreamTrackExtraData(native_track,
+                                                   is_local_track));
 }
 
 webrtc::MediaStreamInterface*
 MediaStreamDependencyFactory::GetNativeMediaStream(
     const blink::WebMediaStream& stream) {
   if (stream.isNull())
     return NULL;
   MediaStreamExtraData* extra_data =
       static_cast<MediaStreamExtraData*>(stream.extraData());
   return extra_data ? extra_data->stream().get() : NULL;
 }
 
 webrtc::MediaStreamTrackInterface*
 MediaStreamDependencyFactory::GetNativeMediaStreamTrack(
       const blink::WebMediaStreamTrack& track) {
   if (track.isNull())
     return NULL;
   MediaStreamTrackExtraData* extra_data =
       static_cast<MediaStreamTrackExtraData*>(track.extraData());
   return extra_data ? extra_data->track().get() : NULL;
 }
 
 }  // namespace content