Added .clang-format + reformatted code

crates/livekit-webrtc/libwebrtc-sys/src/peer_connection.cpp

@@ -3,193 +3,234 @@
 //
 
 #include "livekit/peer_connection.h"
+
 #include "libwebrtc-sys/src/peer_connection.rs.h"
 #include "livekit/rtc_error.h"
 
 namespace livekit {
 
-    inline webrtc::PeerConnectionInterface::RTCOfferAnswerOptions toNativeOfferAnswerOptions(const RTCOfferAnswerOptions& options) {
-        webrtc::PeerConnectionInterface::RTCOfferAnswerOptions rtc_options;
-        rtc_options.offer_to_receive_video =  options.offer_to_receive_video;
-        rtc_options.offer_to_receive_audio =  options.offer_to_receive_audio;
-        rtc_options.voice_activity_detection = options.voice_activity_detection;
-        rtc_options.ice_restart = options.ice_restart;
-        rtc_options.use_rtp_mux = options.use_rtp_mux;
-        rtc_options.raw_packetization_for_video = options.raw_packetization_for_video;
-        rtc_options.num_simulcast_layers = options.num_simulcast_layers;
-        rtc_options.use_obsolete_sctp_sdp = options.use_obsolete_sctp_sdp;
-        return rtc_options;
-    }
+inline webrtc::PeerConnectionInterface::RTCOfferAnswerOptions
+toNativeOfferAnswerOptions(const RTCOfferAnswerOptions& options) {
+  webrtc::PeerConnectionInterface::RTCOfferAnswerOptions rtc_options;
+  rtc_options.offer_to_receive_video = options.offer_to_receive_video;
+  rtc_options.offer_to_receive_audio = options.offer_to_receive_audio;
+  rtc_options.voice_activity_detection = options.voice_activity_detection;
+  rtc_options.ice_restart = options.ice_restart;
+  rtc_options.use_rtp_mux = options.use_rtp_mux;
+  rtc_options.raw_packetization_for_video = options.raw_packetization_for_video;
+  rtc_options.num_simulcast_layers = options.num_simulcast_layers;
+  rtc_options.use_obsolete_sctp_sdp = options.use_obsolete_sctp_sdp;
+  return rtc_options;
+}
 
-    PeerConnection::PeerConnection(rtc::scoped_refptr<webrtc::PeerConnectionInterface> peer_connection) : peer_connection_(std::move(peer_connection)) {
+PeerConnection::PeerConnection(
+    rtc::scoped_refptr<webrtc::PeerConnectionInterface> peer_connection)
+    : peer_connection_(std::move(peer_connection)) {}
 
-    }
+void PeerConnection::create_offer(
+    NativeCreateSdpObserverHandle& observer_handle,
+    RTCOfferAnswerOptions options) {
+  peer_connection_->CreateOffer(observer_handle.observer.get(),
+                                toNativeOfferAnswerOptions(options));
+}
 
-    void PeerConnection::create_offer(NativeCreateSdpObserverHandle &observer_handle, RTCOfferAnswerOptions options) {
-        peer_connection_->CreateOffer(observer_handle.observer.get(), toNativeOfferAnswerOptions(options));
-    }
+void PeerConnection::create_answer(
+    NativeCreateSdpObserverHandle& observer_handle,
+    RTCOfferAnswerOptions options) {
+  peer_connection_->CreateAnswer(observer_handle.observer.get(),
+                                 toNativeOfferAnswerOptions(options));
+}
 
-    void PeerConnection::create_answer(NativeCreateSdpObserverHandle &observer_handle, RTCOfferAnswerOptions options) {
-        peer_connection_->CreateAnswer(observer_handle.observer.get(), toNativeOfferAnswerOptions(options));
-    }
+void PeerConnection::set_local_description(
+    std::unique_ptr<SessionDescription> desc,
+    NativeSetLocalSdpObserverHandle& observer) {
+  peer_connection_->SetLocalDescription(desc->clone()->release(),
+                                        observer.observer);
+}
 
-    void PeerConnection::set_local_description(std::unique_ptr<SessionDescription> desc, NativeSetLocalSdpObserverHandle &observer) {
-        peer_connection_->SetLocalDescription(desc->clone()->release(), observer.observer);
-    }
+void PeerConnection::set_remote_description(
+    std::unique_ptr<SessionDescription> desc,
+    NativeSetRemoteSdpObserverHandle& observer) {
+  peer_connection_->SetRemoteDescription(desc->clone()->release(),
+                                         observer.observer);
+}
 
-    void PeerConnection::set_remote_description(std::unique_ptr<SessionDescription> desc, NativeSetRemoteSdpObserverHandle &observer) {
-        peer_connection_->SetRemoteDescription(desc->clone()->release(), observer.observer);
-    }
+std::unique_ptr<DataChannel> PeerConnection::create_data_channel(
+    rust::String label,
+    std::unique_ptr<NativeDataChannelInit> init) {
+  auto result =
+      peer_connection_->CreateDataChannelOrError(label.c_str(), init.get());
 
-    std::unique_ptr<DataChannel> PeerConnection::create_data_channel(rust::String label, std::unique_ptr<NativeDataChannelInit> init) {
-        auto result = peer_connection_->CreateDataChannelOrError(label.c_str(), init.get());
+  if (!result.ok()) {
+    throw std::runtime_error(serialize_error(to_error(result.error())));
+  }
 
-        if(!result.ok()) {
-            throw std::runtime_error(serialize_error(to_error(result.error())));
-        }
+  return std::make_unique<DataChannel>(result.value());
+}
 
-        return std::make_unique<DataChannel>(result.value());
-    }
+void PeerConnection::add_ice_candidate(
+    std::unique_ptr<IceCandidate> candidate,
+    NativeAddIceCandidateObserver& observer) {
+  peer_connection_->AddIceCandidate(
+      candidate->release(),
+      [&](const webrtc::RTCError& err) { observer.OnComplete(to_error(err)); });
+}
 
-    void PeerConnection::add_ice_candidate(std::unique_ptr<IceCandidate> candidate, NativeAddIceCandidateObserver &observer){
-        peer_connection_->AddIceCandidate(candidate->release(), [&](const webrtc::RTCError& err){
-            observer.OnComplete(to_error(err));
-        });
-    }
+void PeerConnection::close() {
+  peer_connection_->Close();
+}
 
-    void PeerConnection::close() {
-        peer_connection_->Close();
-    }
+// AddIceCandidateObserver
 
-    // AddIceCandidateObserver
+NativeAddIceCandidateObserver::NativeAddIceCandidateObserver(
+    rust::Box<AddIceCandidateObserverWrapper> observer)
+    : observer_(std::move(observer)) {}
 
-    NativeAddIceCandidateObserver::NativeAddIceCandidateObserver(rust::Box<AddIceCandidateObserverWrapper> observer) : observer_(std::move(observer)) {
+void NativeAddIceCandidateObserver::OnComplete(const RTCError& error) {
+  observer_->on_complete(error);
+}
 
-    }
+std::unique_ptr<NativeAddIceCandidateObserver>
+create_native_add_ice_candidate_observer(
+    rust::Box<AddIceCandidateObserverWrapper> observer) {
+  return std::make_unique<NativeAddIceCandidateObserver>(std::move(observer));
+}
 
-    void NativeAddIceCandidateObserver::OnComplete(const RTCError &error) {
-        observer_->on_complete(error);
-    }
+// PeerConnectionObserver
 
-    std::unique_ptr<NativeAddIceCandidateObserver> create_native_add_ice_candidate_observer(rust::Box<AddIceCandidateObserverWrapper> observer) {
-        return std::make_unique<NativeAddIceCandidateObserver>(std::move(observer));
-    }
+NativePeerConnectionObserver::NativePeerConnectionObserver(
+    rust::Box<PeerConnectionObserverWrapper> observer)
+    : observer_(std::move(observer)) {}
 
-    // PeerConnectionObserver
+void NativePeerConnectionObserver::OnSignalingChange(
+    webrtc::PeerConnectionInterface::SignalingState new_state) {
+  observer_->on_signaling_change(static_cast<SignalingState>(new_state));
+}
 
-    NativePeerConnectionObserver::NativePeerConnectionObserver(rust::Box<PeerConnectionObserverWrapper> observer) : observer_(std::move(observer)) {
+void NativePeerConnectionObserver::OnAddStream(
+    rtc::scoped_refptr<webrtc::MediaStreamInterface> stream) {
+  observer_->on_add_stream(std::make_unique<MediaStreamInterface>(stream));
+}
 
-    }
+void NativePeerConnectionObserver::OnRemoveStream(
+    rtc::scoped_refptr<webrtc::MediaStreamInterface> stream) {
+  observer_->on_remove_stream(std::make_unique<MediaStreamInterface>(stream));
+}
 
-    void NativePeerConnectionObserver::OnSignalingChange(webrtc::PeerConnectionInterface::SignalingState new_state) {
-        observer_->on_signaling_change(static_cast<SignalingState>(new_state));
-    }
+void NativePeerConnectionObserver::OnDataChannel(
+    rtc::scoped_refptr<webrtc::DataChannelInterface> data_channel) {
+  observer_->on_data_channel(std::make_unique<DataChannel>(data_channel));
+}
 
-    void NativePeerConnectionObserver::OnAddStream(rtc::scoped_refptr<webrtc::MediaStreamInterface> stream) {
-        observer_->on_add_stream(std::make_unique<MediaStreamInterface>(stream));
-    }
+void NativePeerConnectionObserver::OnRenegotiationNeeded() {
+  observer_->on_renegotiation_needed();
+}
 
-    void NativePeerConnectionObserver::OnRemoveStream(rtc::scoped_refptr<webrtc::MediaStreamInterface> stream) {
-        observer_->on_remove_stream(std::make_unique<MediaStreamInterface>(stream));
-    }
+void NativePeerConnectionObserver::OnNegotiationNeededEvent(uint32_t event_id) {
+  observer_->on_negotiation_needed_event(event_id);
+}
 
-    void NativePeerConnectionObserver::OnDataChannel(rtc::scoped_refptr<webrtc::DataChannelInterface> data_channel) {
-        observer_->on_data_channel(std::make_unique<DataChannel>(data_channel));
-    }
+void NativePeerConnectionObserver::OnIceConnectionChange(
+    webrtc::PeerConnectionInterface::IceConnectionState new_state) {
+  observer_->on_ice_connection_change(
+      static_cast<IceConnectionState>(new_state));
+}
 
-    void NativePeerConnectionObserver::OnRenegotiationNeeded() {
-        observer_->on_renegotiation_needed();
-    }
+void NativePeerConnectionObserver::OnStandardizedIceConnectionChange(
+    webrtc::PeerConnectionInterface::IceConnectionState new_state) {
+  observer_->on_standardized_ice_connection_change(
+      static_cast<IceConnectionState>(new_state));
+}
 
-    void NativePeerConnectionObserver::OnNegotiationNeededEvent(uint32_t event_id) {
-        observer_->on_negotiation_needed_event(event_id);
-    }
+void NativePeerConnectionObserver::OnConnectionChange(
+    webrtc::PeerConnectionInterface::PeerConnectionState new_state) {
+  observer_->on_connection_change(static_cast<PeerConnectionState>(new_state));
+}
 
-    void
-    NativePeerConnectionObserver::OnIceConnectionChange(webrtc::PeerConnectionInterface::IceConnectionState new_state) {
-        observer_->on_ice_connection_change(static_cast<IceConnectionState>(new_state));
-    }
+void NativePeerConnectionObserver::OnIceGatheringChange(
+    webrtc::PeerConnectionInterface::IceGatheringState new_state) {
+  observer_->on_ice_gathering_change(static_cast<IceGatheringState>(new_state));
+}
 
-    void NativePeerConnectionObserver::OnStandardizedIceConnectionChange(
-            webrtc::PeerConnectionInterface::IceConnectionState new_state) {
-        observer_->on_standardized_ice_connection_change(static_cast<IceConnectionState>(new_state));
-    }
+void NativePeerConnectionObserver::OnIceCandidate(
+    const webrtc::IceCandidateInterface* candidate) {
+  auto new_candidate = webrtc::CreateIceCandidate(candidate->sdp_mid(),
+                                                  candidate->sdp_mline_index(),
+                                                  candidate->candidate());
+  observer_->on_ice_candidate(
+      std::make_unique<IceCandidate>(std::move(new_candidate)));
+}
 
-    void
-    NativePeerConnectionObserver::OnConnectionChange(webrtc::PeerConnectionInterface::PeerConnectionState new_state) {
-        observer_->on_connection_change(static_cast<PeerConnectionState>(new_state));
-    }
+void NativePeerConnectionObserver::OnIceCandidateError(
+    const std::string& address,
+    int port,
+    const std::string& url,
+    int error_code,
+    const std::string& error_text) {
+  observer_->on_ice_candidate_error(address, port, url, error_code, error_text);
+}
 
-    void
-    NativePeerConnectionObserver::OnIceGatheringChange(webrtc::PeerConnectionInterface::IceGatheringState new_state) {
-        observer_->on_ice_gathering_change(static_cast<IceGatheringState>(new_state));
-    }
+void NativePeerConnectionObserver::OnIceCandidatesRemoved(
+    const std::vector<cricket::Candidate>& candidates) {
+  rust::Vec<CandidatePtr> vec;
 
-    void NativePeerConnectionObserver::OnIceCandidate(const webrtc::IceCandidateInterface *candidate) {
-        auto new_candidate = webrtc::CreateIceCandidate(candidate->sdp_mid(), candidate->sdp_mline_index(),
-                                                        candidate->candidate());
-        observer_->on_ice_candidate(std::make_unique<IceCandidate>(std::move(new_candidate)));
-    }
+  for (const auto& item : candidates) {
+    vec.push_back(CandidatePtr{std::make_unique<Candidate>(item)});
+  }
 
-    void NativePeerConnectionObserver::OnIceCandidateError(const std::string &address, int port, const std::string &url,
-                                                           int error_code, const std::string &error_text) {
-        observer_->on_ice_candidate_error(address, port, url, error_code, error_text);
-    }
+  observer_->on_ice_candidates_removed(std::move(vec));
+}
 
-    void NativePeerConnectionObserver::OnIceCandidatesRemoved(const std::vector<cricket::Candidate> &candidates) {
-        rust::Vec<CandidatePtr> vec;
+void NativePeerConnectionObserver::OnIceConnectionReceivingChange(
+    bool receiving) {
+  observer_->on_ice_connection_receiving_change(receiving);
+}
 
-        for (const auto &item: candidates) {
-            vec.push_back(CandidatePtr{
-                    std::make_unique<Candidate>(item)
-            });
-        }
+void NativePeerConnectionObserver::OnIceSelectedCandidatePairChanged(
+    const cricket::CandidatePairChangeEvent& event) {
+  CandidatePairChangeEvent e;
+  e.selected_candidate_pair.local =
+      std::make_unique<Candidate>(event.selected_candidate_pair.local);
+  e.selected_candidate_pair.remote =
+      std::make_unique<Candidate>(event.selected_candidate_pair.remote);
+  e.last_data_received_ms = event.last_data_received_ms;
+  e.reason = event.reason;
+  e.estimated_disconnected_time_ms = event.estimated_disconnected_time_ms;
 
-        observer_->on_ice_candidates_removed(std::move(vec));
-    }
+  observer_->on_ice_selected_candidate_pair_changed(std::move(e));
+}
 
-    void NativePeerConnectionObserver::OnIceConnectionReceivingChange(bool receiving) {
-        observer_->on_ice_connection_receiving_change(receiving);
-    }
+void NativePeerConnectionObserver::OnAddTrack(
+    rtc::scoped_refptr<webrtc::RtpReceiverInterface> receiver,
+    const std::vector<rtc::scoped_refptr<webrtc::MediaStreamInterface>>&
+        streams) {
+  rust::Vec<MediaStreamPtr> vec;
 
-    void
-    NativePeerConnectionObserver::OnIceSelectedCandidatePairChanged(const cricket::CandidatePairChangeEvent &event) {
-        CandidatePairChangeEvent e;
-        e.selected_candidate_pair.local = std::make_unique<Candidate>(event.selected_candidate_pair.local);
-        e.selected_candidate_pair.remote = std::make_unique<Candidate>(event.selected_candidate_pair.remote);
-        e.last_data_received_ms = event.last_data_received_ms;
-        e.reason = event.reason;
-        e.estimated_disconnected_time_ms = event.estimated_disconnected_time_ms;
+  for (const auto& item : streams) {
+    vec.push_back(MediaStreamPtr{std::make_unique<MediaStreamInterface>(item)});
+  }
 
-        observer_->on_ice_selected_candidate_pair_changed(std::move(e));
-    }
+  observer_->on_add_track(std::make_unique<RtpReceiver>(receiver),
+                          std::move(vec));
+}
 
-    void NativePeerConnectionObserver::OnAddTrack(rtc::scoped_refptr<webrtc::RtpReceiverInterface> receiver,
-                                                  const std::vector<rtc::scoped_refptr<webrtc::MediaStreamInterface>> &streams) {
-        rust::Vec<MediaStreamPtr> vec;
+void NativePeerConnectionObserver::OnTrack(
+    rtc::scoped_refptr<webrtc::RtpTransceiverInterface> transceiver) {
+  observer_->on_track(std::make_unique<RtpTransceiver>(transceiver));
+}
 
-        for (const auto &item: streams) {
-            vec.push_back(MediaStreamPtr{
-                    std::make_unique<MediaStreamInterface>(item)
-            });
-        }
+void NativePeerConnectionObserver::OnRemoveTrack(
+    rtc::scoped_refptr<webrtc::RtpReceiverInterface> receiver) {
+  observer_->on_remove_track(std::make_unique<RtpReceiver>(receiver));
+}
 
-        observer_->on_add_track(std::make_unique<RtpReceiver>(receiver), std::move(vec));
-    }
+void NativePeerConnectionObserver::OnInterestingUsage(int usage_pattern) {
+  observer_->on_interesting_usage(usage_pattern);
+}
 
-    void NativePeerConnectionObserver::OnTrack(rtc::scoped_refptr<webrtc::RtpTransceiverInterface> transceiver) {
-        observer_->on_track(std::make_unique<RtpTransceiver>(transceiver));
-    }
-
-    void NativePeerConnectionObserver::OnRemoveTrack(rtc::scoped_refptr<webrtc::RtpReceiverInterface> receiver) {
-        observer_->on_remove_track(std::make_unique<RtpReceiver>(receiver));
-    }
-
-    void NativePeerConnectionObserver::OnInterestingUsage(int usage_pattern) {
-        observer_->on_interesting_usage(usage_pattern);
-    }
-
-    std::unique_ptr<NativePeerConnectionObserver> create_native_peer_connection_observer(rust::Box<PeerConnectionObserverWrapper> observer) {
-        return std::make_unique<NativePeerConnectionObserver>(std::move(observer));
-    }
-} // livekit
+std::unique_ptr<NativePeerConnectionObserver>
+create_native_peer_connection_observer(
+    rust::Box<PeerConnectionObserverWrapper> observer) {
+  return std::make_unique<NativePeerConnectionObserver>(std::move(observer));
+}
+}  // namespace livekit