Revert "Replace sigslot usages with robocaller library."

This reverts commit 40261c3.

Reason for revert: Breaks downstream project

Original change's description:
> Replace sigslot usages with robocaller library.
>
> - Replace all the top level signals from jsep_transport_controller.
> - There are still sigslot usages in this file so keep the inheritance
>   and that is the reason for not having a binary size gain in this CL.
>
> Bug: webrtc:11943
> Change-Id: I249d3b9710783aef70ba273e082ceeafe3056898
> Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/185540
> Commit-Queue: Lahiru Ginnaliya Gamathige <[email protected]>
> Reviewed-by: Mirko Bonadei <[email protected]>
> Reviewed-by: Karl Wiberg <[email protected]>
> Cr-Commit-Position: refs/heads/master@{#32321}

[email protected],[email protected],[email protected]

Change-Id: Icf438f87c3d95940d858db3cc5848b23abb82fc4
No-Presubmit: true
No-Tree-Checks: true
No-Try: true
Bug: webrtc:11943
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/186844
Reviewed-by: Sam Zackrisson <[email protected]>
Commit-Queue: Sam Zackrisson <[email protected]>
Cr-Commit-Position: refs/heads/master@{#32324}

Author: Sam Zackrisson

p2p/BUILD.gn

@@ -97,7 +97,6 @@ rtc_library("rtc_p2p") {
     "../logging:ice_log",
     "../rtc_base",
     "../rtc_base:checks",
-    "../rtc_base:robo_caller",
     "../rtc_base:rtc_numerics",
     "../rtc_base/experiments:field_trial_parser",
     "../rtc_base/synchronization:sequence_checker",

p2p/base/dtls_transport.cc

@@ -23,7 +23,6 @@
 #include "rtc_base/checks.h"
 #include "rtc_base/dscp.h"
 #include "rtc_base/logging.h"
-#include "rtc_base/robo_caller.h"
 #include "rtc_base/rtc_certificate.h"
 #include "rtc_base/ssl_stream_adapter.h"
 #include "rtc_base/stream.h"
@@ -359,8 +358,8 @@ bool DtlsTransport::SetupDtls() {
   dtls_->SetMaxProtocolVersion(ssl_max_version_);
   dtls_->SetServerRole(*dtls_role_);
   dtls_->SignalEvent.connect(this, &DtlsTransport::OnDtlsEvent);
-  dtls_->SignalSSLHandshakeError.AddReceiver(
-      [this](rtc::SSLHandshakeError e) { OnDtlsHandshakeError(e); });
+  dtls_->SignalSSLHandshakeError.connect(this,
+                                         &DtlsTransport::OnDtlsHandshakeError);
   if (remote_fingerprint_value_.size() &&
       !dtls_->SetPeerCertificateDigest(
           remote_fingerprint_algorithm_,
@@ -821,7 +820,7 @@ void DtlsTransport::set_dtls_state(DtlsTransportState state) {
 }
 
 void DtlsTransport::OnDtlsHandshakeError(rtc::SSLHandshakeError error) {
-  SignalDtlsHandshakeError.Send(error);
+  SignalDtlsHandshakeError(error);
 }
 
 void DtlsTransport::ConfigureHandshakeTimeout() {

p2p/base/dtls_transport_internal.h

@@ -23,7 +23,6 @@
 #include "p2p/base/ice_transport_internal.h"
 #include "p2p/base/packet_transport_internal.h"
 #include "rtc_base/constructor_magic.h"
-#include "rtc_base/robo_caller.h"
 #include "rtc_base/ssl_certificate.h"
 #include "rtc_base/ssl_fingerprint.h"
 #include "rtc_base/ssl_stream_adapter.h"
@@ -116,7 +115,7 @@ class DtlsTransportInternal : public rtc::PacketTransportInternal {
   sigslot::signal2<DtlsTransportInternal*, DtlsTransportState> SignalDtlsState;
 
   // Emitted whenever the Dtls handshake failed on some transport channel.
-  webrtc::RoboCaller<rtc::SSLHandshakeError> SignalDtlsHandshakeError;
+  sigslot::signal1<rtc::SSLHandshakeError> SignalDtlsHandshakeError;
 
  protected:
   DtlsTransportInternal();

pc/jsep_transport_controller.cc

@@ -462,8 +462,8 @@ JsepTransportController::CreateDtlsTransport(
       this, &JsepTransportController::OnTransportWritableState_n);
   dtls->SignalReceivingState.connect(
       this, &JsepTransportController::OnTransportReceivingState_n);
-  dtls->SignalDtlsHandshakeError.AddReceiver(
-      [this](rtc::SSLHandshakeError error) { OnDtlsHandshakeError(error); });
+  dtls->SignalDtlsHandshakeError.connect(
+      this, &JsepTransportController::OnDtlsHandshakeError);
   dtls->ice_transport()->SignalGatheringState.connect(
       this, &JsepTransportController::OnTransportGatheringState_n);
   dtls->ice_transport()->SignalCandidateGathered.connect(
@@ -1154,8 +1154,7 @@ void JsepTransportController::OnTransportCandidateGathered_n(
   std::string transport_name = transport->transport_name();
   invoker_.AsyncInvoke<void>(
       RTC_FROM_HERE, signaling_thread_, [this, transport_name, candidate] {
-        SignalIceCandidatesGathered.Send(
-            transport_name, std::vector<cricket::Candidate>{candidate});
+        SignalIceCandidatesGathered(transport_name, {candidate});
       });
 }
 
@@ -1164,21 +1163,20 @@ void JsepTransportController::OnTransportCandidateError_n(
     const cricket::IceCandidateErrorEvent& event) {
   RTC_DCHECK(network_thread_->IsCurrent());
 
-  invoker_.AsyncInvoke<void>(RTC_FROM_HERE, signaling_thread_, [this, event] {
-    SignalIceCandidateError.Send(event);
-  });
+  invoker_.AsyncInvoke<void>(RTC_FROM_HERE, signaling_thread_,
+                             [this, event] { SignalIceCandidateError(event); });
 }
 void JsepTransportController::OnTransportCandidatesRemoved_n(
     cricket::IceTransportInternal* transport,
     const cricket::Candidates& candidates) {
   invoker_.AsyncInvoke<void>(
       RTC_FROM_HERE, signaling_thread_,
-      [this, candidates] { SignalIceCandidatesRemoved.Send(candidates); });
+      [this, candidates] { SignalIceCandidatesRemoved(candidates); });
 }
 void JsepTransportController::OnTransportCandidatePairChanged_n(
     const cricket::CandidatePairChangeEvent& event) {
   invoker_.AsyncInvoke<void>(RTC_FROM_HERE, signaling_thread_, [this, event] {
-    SignalIceCandidatePairChanged.Send(event);
+    SignalIceCandidatePairChanged(event);
   });
 }
 
@@ -1319,14 +1317,14 @@ void JsepTransportController::UpdateAggregateStates_n() {
             PeerConnectionInterface::kIceConnectionCompleted) {
       // Ensure that we never skip over the "connected" state.
       invoker_.AsyncInvoke<void>(RTC_FROM_HERE, signaling_thread_, [this] {
-        SignalStandardizedIceConnectionState.Send(
+        SignalStandardizedIceConnectionState(
             PeerConnectionInterface::kIceConnectionConnected);
       });
     }
     standardized_ice_connection_state_ = new_ice_connection_state;
     invoker_.AsyncInvoke<void>(
         RTC_FROM_HERE, signaling_thread_, [this, new_ice_connection_state] {
-          SignalStandardizedIceConnectionState.Send(new_ice_connection_state);
+          SignalStandardizedIceConnectionState(new_ice_connection_state);
         });
   }
 
@@ -1380,7 +1378,7 @@ void JsepTransportController::UpdateAggregateStates_n() {
     combined_connection_state_ = new_combined_state;
     invoker_.AsyncInvoke<void>(RTC_FROM_HERE, signaling_thread_,
                                [this, new_combined_state] {
-                                 SignalConnectionState.Send(new_combined_state);
+                                 SignalConnectionState(new_combined_state);
                                });
   }
 
@@ -1394,10 +1392,10 @@ void JsepTransportController::UpdateAggregateStates_n() {
   }
   if (ice_gathering_state_ != new_gathering_state) {
     ice_gathering_state_ = new_gathering_state;
-    invoker_.AsyncInvoke<void>(
-        RTC_FROM_HERE, signaling_thread_, [this, new_gathering_state] {
-          SignalIceGatheringState.Send(new_gathering_state);
-        });
+    invoker_.AsyncInvoke<void>(RTC_FROM_HERE, signaling_thread_,
+                               [this, new_gathering_state] {
+                                 SignalIceGatheringState(new_gathering_state);
+                               });
   }
 }
 
@@ -1410,7 +1408,7 @@ void JsepTransportController::OnRtcpPacketReceived_n(
 
 void JsepTransportController::OnDtlsHandshakeError(
     rtc::SSLHandshakeError error) {
-  SignalDtlsHandshakeError.Send(error);
+  SignalDtlsHandshakeError(error);
 }
 
 }  // namespace webrtc

pc/jsep_transport_controller.h

@@ -200,29 +200,31 @@ class JsepTransportController : public sigslot::has_slots<> {
   // Else => connecting
   RoboCaller<cricket::IceConnectionState> SignalIceConnectionState;
 
-  RoboCaller<PeerConnectionInterface::PeerConnectionState>
+  sigslot::signal1<PeerConnectionInterface::PeerConnectionState>
       SignalConnectionState;
 
-  RoboCaller<PeerConnectionInterface::IceConnectionState>
+  sigslot::signal1<PeerConnectionInterface::IceConnectionState>
       SignalStandardizedIceConnectionState;
 
   // If all transports done gathering => complete,
   // Else if any are gathering => gathering,
   // Else => new
-  RoboCaller<cricket::IceGatheringState> SignalIceGatheringState;
+  sigslot::signal1<cricket::IceGatheringState> SignalIceGatheringState;
 
-  // [mid, candidates]
-  RoboCaller<const std::string&, const std::vector<cricket::Candidate>&>
+  // (mid, candidates)
+  sigslot::signal2<const std::string&, const std::vector<cricket::Candidate>&>
       SignalIceCandidatesGathered;
 
-  RoboCaller<const cricket::IceCandidateErrorEvent&> SignalIceCandidateError;
+  sigslot::signal1<const cricket::IceCandidateErrorEvent&>
+      SignalIceCandidateError;
 
-  RoboCaller<const std::vector<cricket::Candidate>&> SignalIceCandidatesRemoved;
+  sigslot::signal1<const std::vector<cricket::Candidate>&>
+      SignalIceCandidatesRemoved;
 
-  RoboCaller<const cricket::CandidatePairChangeEvent&>
+  sigslot::signal1<const cricket::CandidatePairChangeEvent&>
       SignalIceCandidatePairChanged;
 
-  RoboCaller<rtc::SSLHandshakeError> SignalDtlsHandshakeError;
+  sigslot::signal1<rtc::SSLHandshakeError> SignalDtlsHandshakeError;
 
  private:
   RTCError ApplyDescription_n(bool local,

pc/jsep_transport_controller_unittest.cc

@@ -93,24 +93,14 @@ class JsepTransportControllerTest : public JsepTransportController::Observer,
         [this](cricket::IceConnectionState s) {
           JsepTransportControllerTest::OnConnectionState(s);
         });
-    transport_controller_->SignalConnectionState.AddReceiver(
-        [this](PeerConnectionInterface::PeerConnectionState s) {
-          JsepTransportControllerTest::OnCombinedConnectionState(s);
-        });
-    transport_controller_->SignalStandardizedIceConnectionState.AddReceiver(
-        [this](PeerConnectionInterface::IceConnectionState s) {
-          JsepTransportControllerTest::OnStandardizedIceConnectionState(s);
-        });
-    transport_controller_->SignalIceGatheringState.AddReceiver(
-        [this](cricket::IceGatheringState s) {
-          JsepTransportControllerTest::OnGatheringState(s);
-        });
-    transport_controller_->SignalIceCandidatesGathered.AddReceiver(
-        [this](const std::string& transport,
-               const std::vector<cricket::Candidate>& candidates) {
-          JsepTransportControllerTest::OnCandidatesGathered(transport,
-                                                            candidates);
-        });
+    transport_controller_->SignalStandardizedIceConnectionState.connect(
+        this, &JsepTransportControllerTest::OnStandardizedIceConnectionState);
+    transport_controller_->SignalConnectionState.connect(
+        this, &JsepTransportControllerTest::OnCombinedConnectionState);
+    transport_controller_->SignalIceGatheringState.connect(
+        this, &JsepTransportControllerTest::OnGatheringState);
+    transport_controller_->SignalIceCandidatesGathered.connect(
+        this, &JsepTransportControllerTest::OnCandidatesGathered);
   }
 
   std::unique_ptr<cricket::SessionDescription>

pc/peer_connection.cc

@@ -545,52 +545,28 @@ bool PeerConnection::Initialize(
   transport_controller_.reset(new JsepTransportController(
       signaling_thread(), network_thread(), port_allocator_.get(),
       async_resolver_factory_.get(), config));
+  transport_controller_->SignalStandardizedIceConnectionState.connect(
+      this, &PeerConnection::SetStandardizedIceConnectionState);
+  transport_controller_->SignalConnectionState.connect(
+      this, &PeerConnection::SetConnectionState);
+  transport_controller_->SignalIceGatheringState.connect(
+      this, &PeerConnection::OnTransportControllerGatheringState);
+  transport_controller_->SignalIceCandidatesGathered.connect(
+      this, &PeerConnection::OnTransportControllerCandidatesGathered);
+  transport_controller_->SignalIceCandidateError.connect(
+      this, &PeerConnection::OnTransportControllerCandidateError);
+  transport_controller_->SignalIceCandidatesRemoved.connect(
+      this, &PeerConnection::OnTransportControllerCandidatesRemoved);
+  transport_controller_->SignalDtlsHandshakeError.connect(
+      this, &PeerConnection::OnTransportControllerDtlsHandshakeError);
+  transport_controller_->SignalIceCandidatePairChanged.connect(
+      this, &PeerConnection::OnTransportControllerCandidateChanged);
+
   transport_controller_->SignalIceConnectionState.AddReceiver(
       [this](cricket::IceConnectionState s) {
         RTC_DCHECK_RUN_ON(signaling_thread());
         OnTransportControllerConnectionState(s);
       });
-  transport_controller_->SignalConnectionState.AddReceiver(
-      [this](PeerConnectionInterface::PeerConnectionState s) {
-        RTC_DCHECK_RUN_ON(signaling_thread());
-        SetConnectionState(s);
-      });
-  transport_controller_->SignalStandardizedIceConnectionState.AddReceiver(
-      [this](PeerConnectionInterface::IceConnectionState s) {
-        RTC_DCHECK_RUN_ON(signaling_thread());
-        SetStandardizedIceConnectionState(s);
-      });
-  transport_controller_->SignalIceGatheringState.AddReceiver(
-      [this](cricket::IceGatheringState s) {
-        RTC_DCHECK_RUN_ON(signaling_thread());
-        OnTransportControllerGatheringState(s);
-      });
-  transport_controller_->SignalIceCandidatesGathered.AddReceiver(
-      [this](const std::string& transport,
-             const std::vector<cricket::Candidate>& candidates) {
-        RTC_DCHECK_RUN_ON(signaling_thread());
-        OnTransportControllerCandidatesGathered(transport, candidates);
-      });
-  transport_controller_->SignalIceCandidateError.AddReceiver(
-      [this](const cricket::IceCandidateErrorEvent& event) {
-        RTC_DCHECK_RUN_ON(signaling_thread());
-        OnTransportControllerCandidateError(event);
-      });
-  transport_controller_->SignalIceCandidatesRemoved.AddReceiver(
-      [this](const std::vector<cricket::Candidate>& c) {
-        RTC_DCHECK_RUN_ON(signaling_thread());
-        OnTransportControllerCandidatesRemoved(c);
-      });
-  transport_controller_->SignalIceCandidatePairChanged.AddReceiver(
-      [this](const cricket::CandidatePairChangeEvent& event) {
-        RTC_DCHECK_RUN_ON(signaling_thread());
-        OnTransportControllerCandidateChanged(event);
-      });
-  transport_controller_->SignalDtlsHandshakeError.AddReceiver(
-      [this](rtc::SSLHandshakeError event) {
-        RTC_DCHECK_RUN_ON(signaling_thread());
-        OnTransportControllerDtlsHandshakeError(event);
-      });
 
   stats_.reset(new StatsCollector(this));
   stats_collector_ = RTCStatsCollector::Create(this);

rtc_base/BUILD.gn

@@ -819,7 +819,6 @@ rtc_library("rtc_base") {
   deps = [
     ":checks",
     ":deprecation",
-    ":robo_caller",
     ":rtc_task_queue",
     ":stringutils",
     "../api:array_view",

rtc_base/openssl_stream_adapter.cc

@@ -33,7 +33,6 @@
 #include "rtc_base/openssl_adapter.h"
 #include "rtc_base/openssl_digest.h"
 #include "rtc_base/openssl_identity.h"
-#include "rtc_base/robo_caller.h"
 #include "rtc_base/ssl_certificate.h"
 #include "rtc_base/stream.h"
 #include "rtc_base/task_utils/to_queued_task.h"
@@ -931,7 +930,7 @@ int OpenSSLStreamAdapter::ContinueSSL() {
       }
       RTC_DLOG(LS_VERBOSE) << " -- error " << code << ", " << err_code << ", "
                            << ERR_GET_REASON(err_code);
-      SignalSSLHandshakeError.Send(ssl_handshake_err);
+      SignalSSLHandshakeError(ssl_handshake_err);
       return (ssl_error != 0) ? ssl_error : -1;
   }
 

rtc_base/ssl_stream_adapter.h

@@ -19,10 +19,10 @@
 
 #include "absl/memory/memory.h"
 #include "rtc_base/deprecation.h"
-#include "rtc_base/robo_caller.h"
 #include "rtc_base/ssl_certificate.h"
 #include "rtc_base/ssl_identity.h"
 #include "rtc_base/stream.h"
+#include "rtc_base/third_party/sigslot/sigslot.h"
 
 namespace rtc {
 
@@ -268,7 +268,7 @@ class SSLStreamAdapter : public StreamAdapterInterface {
   // authentication.
   bool GetClientAuthEnabled() const { return client_auth_enabled_; }
 
-  webrtc::RoboCaller<SSLHandshakeError> SignalSSLHandshakeError;
+  sigslot::signal1<SSLHandshakeError> SignalSSLHandshakeError;
 
  private:
   // If true (default), the client is required to provide a certificate during