[sigslot] - Remove sigslot from MediaStreamObserver.

Bug: webrtc:11943
Change-Id: Icf91ce850913c26e45dbca1940cafd600c235ad4
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/227340
Reviewed-by: Harald Alvestrand <hta@webrtc.org>
Commit-Queue: Mirko Bonadei <mbonadei@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#34632}

pc/media_stream_observer.cc

@@ -10,17 +10,32 @@
 
 #include "pc/media_stream_observer.h"
 
+#include <functional>
 #include <string>
+#include <utility>
 #include <vector>
 
 #include "absl/algorithm/container.h"
 
 namespace webrtc {
 
-MediaStreamObserver::MediaStreamObserver(MediaStreamInterface* stream)
+MediaStreamObserver::MediaStreamObserver(
+    MediaStreamInterface* stream,
+    std::function<void(AudioTrackInterface*, MediaStreamInterface*)>
+        audio_track_added_callback,
+    std::function<void(AudioTrackInterface*, MediaStreamInterface*)>
+        audio_track_removed_callback,
+    std::function<void(VideoTrackInterface*, MediaStreamInterface*)>
+        video_track_added_callback,
+    std::function<void(VideoTrackInterface*, MediaStreamInterface*)>
+        video_track_removed_callback)
     : stream_(stream),
       cached_audio_tracks_(stream->GetAudioTracks()),
-      cached_video_tracks_(stream->GetVideoTracks()) {
+      cached_video_tracks_(stream->GetVideoTracks()),
+      audio_track_added_callback_(std::move(audio_track_added_callback)),
+      audio_track_removed_callback_(std::move(audio_track_removed_callback)),
+      video_track_added_callback_(std::move(video_track_added_callback)),
+      video_track_removed_callback_(std::move(video_track_removed_callback)) {
   stream_->RegisterObserver(this);
 }
 
@@ -39,7 +54,7 @@ void MediaStreamObserver::OnChanged() {
             [cached_track](const AudioTrackVector::value_type& new_track) {
               return new_track->id() == cached_track->id();
             })) {
-      SignalAudioTrackRemoved(cached_track.get(), stream_);
+      audio_track_removed_callback_(cached_track.get(), stream_);
     }
   }
 
@@ -50,7 +65,7 @@ void MediaStreamObserver::OnChanged() {
             [new_track](const AudioTrackVector::value_type& cached_track) {
               return new_track->id() == cached_track->id();
             })) {
-      SignalAudioTrackAdded(new_track.get(), stream_);
+      audio_track_added_callback_(new_track.get(), stream_);
     }
   }
 
@@ -61,7 +76,7 @@ void MediaStreamObserver::OnChanged() {
             [cached_track](const VideoTrackVector::value_type& new_track) {
               return new_track->id() == cached_track->id();
             })) {
-      SignalVideoTrackRemoved(cached_track.get(), stream_);
+      video_track_removed_callback_(cached_track.get(), stream_);
     }
   }
 
@@ -72,7 +87,7 @@ void MediaStreamObserver::OnChanged() {
             [new_track](const VideoTrackVector::value_type& cached_track) {
               return new_track->id() == cached_track->id();
             })) {
-      SignalVideoTrackAdded(new_track.get(), stream_);
+      video_track_added_callback_(new_track.get(), stream_);
     }
   }
 

pc/media_stream_observer.h

@@ -11,9 +11,10 @@
 #ifndef PC_MEDIA_STREAM_OBSERVER_H_
 #define PC_MEDIA_STREAM_OBSERVER_H_
 
+#include <functional>
+
 #include "api/media_stream_interface.h"
 #include "api/scoped_refptr.h"
-#include "rtc_base/third_party/sigslot/sigslot.h"
 
 namespace webrtc {
 
@@ -21,26 +22,34 @@ namespace webrtc {
 // corresponding signals.
 class MediaStreamObserver : public ObserverInterface {
  public:
-  explicit MediaStreamObserver(MediaStreamInterface* stream);
+  explicit MediaStreamObserver(
+      MediaStreamInterface* stream,
+      std::function<void(AudioTrackInterface*, MediaStreamInterface*)>
+          audio_track_added_callback,
+      std::function<void(AudioTrackInterface*, MediaStreamInterface*)>
+          audio_track_removed_callback,
+      std::function<void(VideoTrackInterface*, MediaStreamInterface*)>
+          video_track_added_callback,
+      std::function<void(VideoTrackInterface*, MediaStreamInterface*)>
+          video_track_removed_callback);
   ~MediaStreamObserver() override;
 
   const MediaStreamInterface* stream() const { return stream_; }
 
   void OnChanged() override;
 
-  sigslot::signal2<AudioTrackInterface*, MediaStreamInterface*>
-      SignalAudioTrackAdded;
-  sigslot::signal2<AudioTrackInterface*, MediaStreamInterface*>
-      SignalAudioTrackRemoved;
-  sigslot::signal2<VideoTrackInterface*, MediaStreamInterface*>
-      SignalVideoTrackAdded;
-  sigslot::signal2<VideoTrackInterface*, MediaStreamInterface*>
-      SignalVideoTrackRemoved;
-
  private:
   rtc::scoped_refptr<MediaStreamInterface> stream_;
   AudioTrackVector cached_audio_tracks_;
   VideoTrackVector cached_video_tracks_;
+  const std::function<void(AudioTrackInterface*, MediaStreamInterface*)>
+      audio_track_added_callback_;
+  const std::function<void(AudioTrackInterface*, MediaStreamInterface*)>
+      audio_track_removed_callback_;
+  const std::function<void(VideoTrackInterface*, MediaStreamInterface*)>
+      video_track_added_callback_;
+  const std::function<void(VideoTrackInterface*, MediaStreamInterface*)>
+      video_track_removed_callback_;
 };
 
 }  // namespace webrtc

pc/sdp_offer_answer.cc

@@ -13,6 +13,7 @@
 #include <algorithm>
 #include <iterator>
 #include <map>
+#include <memory>
 #include <queue>
 #include <type_traits>
 #include <utility>
@@ -2591,16 +2592,29 @@ bool SdpOfferAnswerHandler::AddStream(MediaStreamInterface* local_stream) {
   }
 
   local_streams_->AddStream(local_stream);
-  MediaStreamObserver* observer = new MediaStreamObserver(local_stream);
+  auto observer = std::make_unique<MediaStreamObserver>(
-  observer->SignalAudioTrackAdded.connect(
+      local_stream,
-      this, &SdpOfferAnswerHandler::OnAudioTrackAdded);
+      [this](AudioTrackInterface* audio_track,
-  observer->SignalAudioTrackRemoved.connect(
+             MediaStreamInterface* media_stream) {
-      this, &SdpOfferAnswerHandler::OnAudioTrackRemoved);
+        RTC_DCHECK_RUN_ON(signaling_thread());
-  observer->SignalVideoTrackAdded.connect(
+        OnAudioTrackAdded(audio_track, media_stream);
-      this, &SdpOfferAnswerHandler::OnVideoTrackAdded);
+      },
-  observer->SignalVideoTrackRemoved.connect(
+      [this](AudioTrackInterface* audio_track,
-      this, &SdpOfferAnswerHandler::OnVideoTrackRemoved);
+             MediaStreamInterface* media_stream) {
-  stream_observers_.push_back(std::unique_ptr<MediaStreamObserver>(observer));
+        RTC_DCHECK_RUN_ON(signaling_thread());
+        OnAudioTrackRemoved(audio_track, media_stream);
+      },
+      [this](VideoTrackInterface* video_track,
+             MediaStreamInterface* media_stream) {
+        RTC_DCHECK_RUN_ON(signaling_thread());
+        OnVideoTrackAdded(video_track, media_stream);
+      },
+      [this](VideoTrackInterface* video_track,
+             MediaStreamInterface* media_stream) {
+        RTC_DCHECK_RUN_ON(signaling_thread());
+        OnVideoTrackRemoved(video_track, media_stream);
+      });
+  stream_observers_.push_back(std::move(observer));
 
   for (const auto& track : local_stream->GetAudioTracks()) {
     rtp_manager()->AddAudioTrack(track.get(), local_stream);

sdk/android/src/jni/pc/media_stream.cc

@@ -25,8 +25,27 @@ JavaMediaStream::JavaMediaStream(
     : j_media_stream_(
           env,
           Java_MediaStream_Constructor(env,
-                                       jlongFromPointer(media_stream.get()))),
+                                       jlongFromPointer(media_stream.get()))) {
-      observer_(std::make_unique<MediaStreamObserver>(media_stream)) {
+  // Create an observer to update the Java stream when the native stream's set
+  // of tracks changes.
+  observer_.reset(new MediaStreamObserver(
+      media_stream,
+      [this](AudioTrackInterface* audio_track,
+             MediaStreamInterface* media_stream) {
+        OnAudioTrackAddedToStream(audio_track, media_stream);
+      },
+      [this](AudioTrackInterface* audio_track,
+             MediaStreamInterface* media_stream) {
+        OnAudioTrackRemovedFromStream(audio_track, media_stream);
+      },
+      [this](VideoTrackInterface* video_track,
+             MediaStreamInterface* media_stream) {
+        OnVideoTrackAddedToStream(video_track, media_stream);
+      },
+      [this](VideoTrackInterface* video_track,
+             MediaStreamInterface* media_stream) {
+        OnVideoTrackRemovedFromStream(video_track, media_stream);
+      }));
   for (rtc::scoped_refptr<AudioTrackInterface> track :
        media_stream->GetAudioTracks()) {
     Java_MediaStream_addNativeAudioTrack(env, j_media_stream_,
@@ -37,18 +56,6 @@ JavaMediaStream::JavaMediaStream(
     Java_MediaStream_addNativeVideoTrack(env, j_media_stream_,
                                          jlongFromPointer(track.release()));
   }
-
-  // Create an observer to update the Java stream when the native stream's set
-  // of tracks changes.
-  observer_->SignalAudioTrackRemoved.connect(
-      this, &JavaMediaStream::OnAudioTrackRemovedFromStream);
-  observer_->SignalVideoTrackRemoved.connect(
-      this, &JavaMediaStream::OnVideoTrackRemovedFromStream);
-  observer_->SignalAudioTrackAdded.connect(
-      this, &JavaMediaStream::OnAudioTrackAddedToStream);
-  observer_->SignalVideoTrackAdded.connect(
-      this, &JavaMediaStream::OnVideoTrackAddedToStream);
-
   // `j_media_stream` holds one reference. Corresponding Release() is in
   // MediaStream_free, triggered by MediaStream.dispose().
   media_stream.release();

sdk/android/src/jni/pc/media_stream.h

@@ -21,12 +21,12 @@
 namespace webrtc {
 namespace jni {
 
-class JavaMediaStream : public sigslot::has_slots<> {
+class JavaMediaStream {
  public:
   explicit JavaMediaStream(
       JNIEnv* env,
       rtc::scoped_refptr<MediaStreamInterface> media_stream);
-  ~JavaMediaStream() override;
+  ~JavaMediaStream();
 
   const ScopedJavaGlobalRef<jobject>& j_media_stream() {
     return j_media_stream_;