Added .clang-format + reformatted code

crates/livekit-webrtc/libwebrtc-sys/.clang-format

@@ -0,0 +1,24 @@
+# Using the same .clang-format as libwebrtc
+# https://github.com/webrtc-sdk/webrtc/blob/m104_release/.clang-format
+BasedOnStyle: Chromium
+---
+Language: Java
+BasedOnStyle: Google
+---
+Language: ObjC
+BasedOnStyle: Google
+BinPackParameters: false
+BinPackArguments: false
+ColumnLimit: 100
+ObjCBlockIndentWidth: 2
+AllowAllParametersOfDeclarationOnNextLine: true
+AlignOperands: false
+AlwaysBreakBeforeMultilineStrings: false
+AllowShortFunctionsOnASingleLine: Inline
+BreakBeforeTernaryOperators: false
+IndentWrappedFunctionNames: true
+ContinuationIndentWidth: 4
+ObjCSpaceBeforeProtocolList: true
+---
+Language: Cpp
+IncludeBlocks: Regroup

crates/livekit-webrtc/libwebrtc-sys/include/livekit/candidate.h

@@ -6,6 +6,7 @@
 #define CLIENT_SDK_NATIVE_CANDIDATE_H
 
 #include <memory>
+
 #include "api/candidate.h"
 
 // cricket::Candidate
@@ -23,6 +24,6 @@ namespace livekit {
   return nullptr;
 }
 
-} // livekit
+}  // namespace livekit
 
 #endif  // CLIENT_SDK_NATIVE_CANDIDATE_H

crates/livekit-webrtc/libwebrtc-sys/include/livekit/data_channel.h

@@ -6,9 +6,10 @@
 #define CLIENT_SDK_NATIVE_DATA_CHANNEL_H
 
 #include <memory>
+
 #include "api/data_channel_interface.h"
-#include "rust_types.h"
 #include "rust/cxx.h"
+#include "rust_types.h"
 
 namespace livekit {
 using NativeDataChannelInit = webrtc::DataChannelInit;
@@ -16,18 +17,21 @@ namespace livekit {
 
 class DataChannel {
  public:
-        explicit DataChannel(rtc::scoped_refptr<webrtc::DataChannelInterface> data_channel);
+  explicit DataChannel(
+      rtc::scoped_refptr<webrtc::DataChannelInterface> data_channel);
 
   void register_observer(NativeDataChannelObserver& observer);
   void unregister_observer();
   bool send(const DataBuffer& buffer);
   rust::String label() const;
   void close();
+
  private:
   rtc::scoped_refptr<webrtc::DataChannelInterface> data_channel_;
 };
 
-    std::unique_ptr<NativeDataChannelInit> create_data_channel_init(DataChannelInit init);
+std::unique_ptr<NativeDataChannelInit> create_data_channel_init(
+    DataChannelInit init);
 
 static std::unique_ptr<DataChannel> _unique_data_channel() {
   return nullptr;  // Ignore
@@ -35,16 +39,19 @@ namespace livekit {
 
 class NativeDataChannelObserver : public webrtc::DataChannelObserver {
  public:
-        explicit NativeDataChannelObserver(rust::Box<DataChannelObserverWrapper> observer);
+  explicit NativeDataChannelObserver(
+      rust::Box<DataChannelObserverWrapper> observer);
 
   void OnStateChange() override;
   void OnMessage(const webrtc::DataBuffer& buffer) override;
   void OnBufferedAmountChange(uint64_t sent_data_size) override;
+
  private:
   rust::Box<DataChannelObserverWrapper> observer_;
 };
 
-    std::unique_ptr<NativeDataChannelObserver> create_native_data_channel_observer(rust::Box<DataChannelObserverWrapper> observer);
+std::unique_ptr<NativeDataChannelObserver> create_native_data_channel_observer(
-} // livekit
+    rust::Box<DataChannelObserverWrapper> observer);
+}  // namespace livekit
 
 #endif  // CLIENT_SDK_NATIVE_DATA_CHANNEL_H

crates/livekit-webrtc/libwebrtc-sys/include/livekit/jsep.h

@@ -6,18 +6,21 @@
 #define CLIENT_SDK_NATIVE_JSEP_H
 
 #include <memory>
+
 #include "api/jsep.h"
+#include "api/ref_counted_base.h"
 #include "rust/cxx.h"
 #include "rust_types.h"
-#include "api/ref_counted_base.h"
 
 namespace livekit {
 
 class IceCandidate {
  public:
-        explicit IceCandidate(std::unique_ptr<webrtc::IceCandidateInterface> ice_candidate);
+  explicit IceCandidate(
+      std::unique_ptr<webrtc::IceCandidateInterface> ice_candidate);
 
   std::unique_ptr<webrtc::IceCandidateInterface> release();
+
  private:
   std::unique_ptr<webrtc::IceCandidateInterface> ice_candidate_;
 };
@@ -28,7 +31,8 @@ namespace livekit {
 
 class SessionDescription {
  public:
-        explicit SessionDescription(std::unique_ptr<webrtc::SessionDescriptionInterface> session_description);
+  explicit SessionDescription(
+      std::unique_ptr<webrtc::SessionDescriptionInterface> session_description);
 
   rust::String stringify() const;
   std::unique_ptr<SessionDescription> clone() const;
@@ -44,12 +48,15 @@ namespace livekit {
 
 // SetCreateSdpObserver
 
-    class NativeCreateSdpObserver : public webrtc::CreateSessionDescriptionObserver {
+class NativeCreateSdpObserver
+    : public webrtc::CreateSessionDescriptionObserver {
  public:
-        explicit NativeCreateSdpObserver(rust::Box<CreateSdpObserverWrapper> observer);
+  explicit NativeCreateSdpObserver(
+      rust::Box<CreateSdpObserverWrapper> observer);
 
   void OnSuccess(webrtc::SessionDescriptionInterface* desc) override;
   void OnFailure(webrtc::RTCError error) override;
+
  private:
   rust::Box<CreateSdpObserverWrapper> observer_;
 };
@@ -58,15 +65,19 @@ namespace livekit {
   rtc::scoped_refptr<NativeCreateSdpObserver> observer;
 };
 
-    std::unique_ptr<NativeCreateSdpObserverHandle> create_native_create_sdp_observer(rust::Box<CreateSdpObserverWrapper> observer);
+std::unique_ptr<NativeCreateSdpObserverHandle>
+create_native_create_sdp_observer(rust::Box<CreateSdpObserverWrapper> observer);
 
 // SetLocalSdpObserver
 
-    class NativeSetLocalSdpObserver : public webrtc::SetLocalDescriptionObserverInterface{
+class NativeSetLocalSdpObserver
+    : public webrtc::SetLocalDescriptionObserverInterface {
  public:
-        explicit NativeSetLocalSdpObserver(rust::Box<SetLocalSdpObserverWrapper> observer);
+  explicit NativeSetLocalSdpObserver(
+      rust::Box<SetLocalSdpObserverWrapper> observer);
 
   void OnSetLocalDescriptionComplete(webrtc::RTCError error) override;
+
  private:
   rust::Box<SetLocalSdpObserverWrapper> observer_;
 };
@@ -75,15 +86,20 @@ namespace livekit {
   rtc::scoped_refptr<NativeSetLocalSdpObserver> observer;
 };
 
-    std::unique_ptr<NativeSetLocalSdpObserverHandle> create_native_set_local_sdp_observer(rust::Box<SetLocalSdpObserverWrapper> observer);
+std::unique_ptr<NativeSetLocalSdpObserverHandle>
+create_native_set_local_sdp_observer(
+    rust::Box<SetLocalSdpObserverWrapper> observer);
 
 // SetRemoteSdpObserver
 
-    class NativeSetRemoteSdpObserver : public webrtc::SetRemoteDescriptionObserverInterface{
+class NativeSetRemoteSdpObserver
+    : public webrtc::SetRemoteDescriptionObserverInterface {
  public:
-        explicit NativeSetRemoteSdpObserver(rust::Box<SetRemoteSdpObserverWrapper> observer);
+  explicit NativeSetRemoteSdpObserver(
+      rust::Box<SetRemoteSdpObserverWrapper> observer);
 
   void OnSetRemoteDescriptionComplete(webrtc::RTCError error) override;
+
  private:
   rust::Box<SetRemoteSdpObserverWrapper> observer_;
 };
@@ -92,7 +108,9 @@ namespace livekit {
   rtc::scoped_refptr<NativeSetRemoteSdpObserver> observer;
 };
 
-    std::unique_ptr<NativeSetRemoteSdpObserverHandle> create_native_set_remote_sdp_observer(rust::Box<SetRemoteSdpObserverWrapper> observer);
+std::unique_ptr<NativeSetRemoteSdpObserverHandle>
-} // livekit
+create_native_set_remote_sdp_observer(
+    rust::Box<SetRemoteSdpObserverWrapper> observer);
+}  // namespace livekit
 
 #endif  // CLIENT_SDK_NATIVE_JSEP_H

crates/livekit-webrtc/libwebrtc-sys/include/livekit/media_stream_interface.h

@@ -6,13 +6,15 @@
 #define CLIENT_SDK_NATIVE_MEDIA_STREAM_INTERFACE_H
 
 #include <memory>
+
 #include "api/media_stream_interface.h"
 
 namespace livekit {
 
 class MediaStreamInterface {
  public:
-        explicit MediaStreamInterface(rtc::scoped_refptr<webrtc::MediaStreamInterface> stream);
+  explicit MediaStreamInterface(
+      rtc::scoped_refptr<webrtc::MediaStreamInterface> stream);
 
  private:
   rtc::scoped_refptr<webrtc::MediaStreamInterface> media_stream_;
@@ -21,6 +23,6 @@ namespace livekit {
 static std::unique_ptr<MediaStreamInterface> _unique_media_stream() {
   return nullptr;  // Ignore
 }
-} // livekit
+}  // namespace livekit
 
 #endif  // CLIENT_SDK_NATIVE_MEDIA_STREAM_INTERFACE_H

crates/livekit-webrtc/libwebrtc-sys/include/livekit/peer_connection.h

@@ -6,10 +6,11 @@
 #define CLIENT_SDK_NATIVE_PEER_CONNECTION_H
 
 #include <memory>
+
 #include "api/peer_connection_interface.h"
-#include "rust/cxx.h"
 #include "data_channel.h"
 #include "jsep.h"
+#include "rust/cxx.h"
 #include "rust_types.h"
 
 namespace livekit {
@@ -17,14 +18,22 @@ namespace livekit {
 
 class PeerConnection {
  public:
-        explicit PeerConnection(rtc::scoped_refptr<webrtc::PeerConnectionInterface> peer_connection);
+  explicit PeerConnection(
+      rtc::scoped_refptr<webrtc::PeerConnectionInterface> peer_connection);
 
-        void create_offer(NativeCreateSdpObserverHandle &observer, RTCOfferAnswerOptions options);
+  void create_offer(NativeCreateSdpObserverHandle& observer,
-        void create_answer(NativeCreateSdpObserverHandle &observer, RTCOfferAnswerOptions options);
+                    RTCOfferAnswerOptions options);
-        void set_local_description(std::unique_ptr<SessionDescription> desc, NativeSetLocalSdpObserverHandle &observer);
+  void create_answer(NativeCreateSdpObserverHandle& observer,
-        void set_remote_description(std::unique_ptr<SessionDescription> desc, NativeSetRemoteSdpObserverHandle &observer);
+                     RTCOfferAnswerOptions options);
-        std::unique_ptr<DataChannel> create_data_channel(rust::String label, std::unique_ptr<NativeDataChannelInit> init);
+  void set_local_description(std::unique_ptr<SessionDescription> desc,
-        void add_ice_candidate(std::unique_ptr<IceCandidate> candidate, NativeAddIceCandidateObserver &observer);
+                             NativeSetLocalSdpObserverHandle& observer);
+  void set_remote_description(std::unique_ptr<SessionDescription> desc,
+                              NativeSetRemoteSdpObserverHandle& observer);
+  std::unique_ptr<DataChannel> create_data_channel(
+      rust::String label,
+      std::unique_ptr<NativeDataChannelInit> init);
+  void add_ice_candidate(std::unique_ptr<IceCandidate> candidate,
+                         NativeAddIceCandidateObserver& observer);
   void close();
 
  private:
@@ -37,45 +46,88 @@ namespace livekit {
 
 class NativeAddIceCandidateObserver {
  public:
-        explicit NativeAddIceCandidateObserver(rust::Box<AddIceCandidateObserverWrapper> observer);
+  explicit NativeAddIceCandidateObserver(
+      rust::Box<AddIceCandidateObserverWrapper> observer);
 
   void OnComplete(const RTCError& error);
+
  private:
   rust::Box<AddIceCandidateObserverWrapper> observer_;
 };
 
-    std::unique_ptr<NativeAddIceCandidateObserver> create_native_add_ice_candidate_observer(rust::Box<AddIceCandidateObserverWrapper> observer);
+std::unique_ptr<NativeAddIceCandidateObserver>
+create_native_add_ice_candidate_observer(
+    rust::Box<AddIceCandidateObserverWrapper> observer);
 
 class NativePeerConnectionObserver : public webrtc::PeerConnectionObserver {
  public:
-        explicit NativePeerConnectionObserver(rust::Box<PeerConnectionObserverWrapper> observer);
+  explicit NativePeerConnectionObserver(
+      rust::Box<PeerConnectionObserverWrapper> observer);
+
+  void OnSignalingChange(
+      webrtc::PeerConnectionInterface::SignalingState new_state) override;
+
+  void OnAddStream(
+      rtc::scoped_refptr<webrtc::MediaStreamInterface> stream) override;
+
+  void OnRemoveStream(
+      rtc::scoped_refptr<webrtc::MediaStreamInterface> stream) override;
+
+  void OnDataChannel(
+      rtc::scoped_refptr<webrtc::DataChannelInterface> data_channel) override;
 
-        void OnSignalingChange(webrtc::PeerConnectionInterface::SignalingState new_state) override;
-        void OnAddStream(rtc::scoped_refptr<webrtc::MediaStreamInterface> stream) override;
-        void OnRemoveStream(rtc::scoped_refptr<webrtc::MediaStreamInterface> stream) override;
-        void OnDataChannel(rtc::scoped_refptr<webrtc::DataChannelInterface> data_channel) override;
   void OnRenegotiationNeeded() override;
+
   void OnNegotiationNeededEvent(uint32_t event_id) override;
-        void OnIceConnectionChange(webrtc::PeerConnectionInterface::IceConnectionState new_state) override;
+
-        void OnStandardizedIceConnectionChange(webrtc::PeerConnectionInterface::IceConnectionState new_state) override;
+  void OnIceConnectionChange(
-        void OnConnectionChange(webrtc::PeerConnectionInterface::PeerConnectionState new_state) override;
+      webrtc::PeerConnectionInterface::IceConnectionState new_state) override;
-        void OnIceGatheringChange(webrtc::PeerConnectionInterface::IceGatheringState new_state) override;
+
+  void OnStandardizedIceConnectionChange(
+      webrtc::PeerConnectionInterface::IceConnectionState new_state) override;
+
+  void OnConnectionChange(
+      webrtc::PeerConnectionInterface::PeerConnectionState new_state) override;
+
+  void OnIceGatheringChange(
+      webrtc::PeerConnectionInterface::IceGatheringState new_state) override;
+
   void OnIceCandidate(const webrtc::IceCandidateInterface* candidate) override;
-        void OnIceCandidateError(const std::string &address, int port, const std::string &url, int error_code, const std::string &error_text) override;
+
-        void OnIceCandidatesRemoved(const std::vector<cricket::Candidate> &candidates) override;
+  void OnIceCandidateError(const std::string& address,
+                           int port,
+                           const std::string& url,
+                           int error_code,
+                           const std::string& error_text) override;
+
+  void OnIceCandidatesRemoved(
+      const std::vector<cricket::Candidate>& candidates) override;
+
   void OnIceConnectionReceivingChange(bool receiving) override;
-        void OnIceSelectedCandidatePairChanged(const cricket::CandidatePairChangeEvent &event) override;
+
-        void OnAddTrack(rtc::scoped_refptr<webrtc::RtpReceiverInterface> receiver, const std::vector<rtc::scoped_refptr<webrtc::MediaStreamInterface>> &streams) override;
+  void OnIceSelectedCandidatePairChanged(
-        void OnTrack(rtc::scoped_refptr<webrtc::RtpTransceiverInterface> transceiver) override;
+      const cricket::CandidatePairChangeEvent& event) override;
-        void OnRemoveTrack(rtc::scoped_refptr<webrtc::RtpReceiverInterface> receiver) override;
+
+  void OnAddTrack(
+      rtc::scoped_refptr<webrtc::RtpReceiverInterface> receiver,
+      const std::vector<rtc::scoped_refptr<webrtc::MediaStreamInterface>>&
+          streams) override;
+
+  void OnTrack(
+      rtc::scoped_refptr<webrtc::RtpTransceiverInterface> transceiver) override;
+
+  void OnRemoveTrack(
+      rtc::scoped_refptr<webrtc::RtpReceiverInterface> receiver) override;
+
   void OnInterestingUsage(int usage_pattern) override;
 
  private:
   rust::Box<PeerConnectionObserverWrapper> observer_;
 };
 
-    std::unique_ptr<NativePeerConnectionObserver> create_native_peer_connection_observer(rust::Box<PeerConnectionObserverWrapper> observer);
+std::unique_ptr<NativePeerConnectionObserver>
-} // livekit
+create_native_peer_connection_observer(
+    rust::Box<PeerConnectionObserverWrapper> observer);
+}  // namespace livekit
 
 #endif  // CLIENT_SDK_NATIVE_PEER_CONNECTION_H
-

crates/livekit-webrtc/libwebrtc-sys/include/livekit/peer_connection_factory.h

@@ -2,7 +2,6 @@
 // Created by Théo Monnom on 03/08/2022.
 //
 
-
 #ifndef PEER_CONNECTION_FACTORY_H
 #define PEER_CONNECTION_FACTORY_H
 
@@ -11,13 +10,16 @@
 #include "rust_types.h"
 
 namespace livekit {
-    using NativeRTCConfiguration = webrtc::PeerConnectionInterface::RTCConfiguration;
+using NativeRTCConfiguration =
+    webrtc::PeerConnectionInterface::RTCConfiguration;
 
 class PeerConnectionFactory {
  public:
   PeerConnectionFactory();
 
-        std::unique_ptr<PeerConnection> create_peer_connection(std::unique_ptr<NativeRTCConfiguration> config, NativePeerConnectionObserver &observer) const;
+  std::unique_ptr<PeerConnection> create_peer_connection(
+      std::unique_ptr<NativeRTCConfiguration> config,
+      NativePeerConnectionObserver& observer) const;
 
  private:
   std::unique_ptr<rtc::Thread> network_thread_;
@@ -28,8 +30,8 @@ namespace livekit {
 };
 
 std::unique_ptr<PeerConnectionFactory> create_peer_connection_factory();
-    std::unique_ptr<NativeRTCConfiguration> create_rtc_configuration(RTCConfiguration conf);
+std::unique_ptr<NativeRTCConfiguration> create_rtc_configuration(
-} // livekit
+    RTCConfiguration conf);
-
+}  // namespace livekit
 
 #endif  // PEER_CONNECTION_FACTORY_H

crates/livekit-webrtc/libwebrtc-sys/include/livekit/rtc_error.h

@@ -7,19 +7,20 @@
 
 #include "api/rtc_error.h"
 #include "libwebrtc-sys/src/rtc_error.rs.h"
-#include "rust_types.h"
 #include "rust/cxx.h"
+#include "rust_types.h"
 
 namespace livekit {
 
 RTCError to_error(const webrtc::RTCError& error);
-    std::string serialize_error(const RTCError &error); // to be used inside cxx::Exception msg
+std::string serialize_error(
+    const RTCError& error);  // to be used inside cxx::Exception msg
 
 #ifdef LIVEKIT_TEST
 rust::String serialize_deserialize();
 void throw_error();
 #endif
 
-} // livekit
+}  // namespace livekit
 
 #endif  // CLIENT_SDK_NATIVE_RTC_ERROR_H

crates/livekit-webrtc/libwebrtc-sys/include/livekit/rtp_receiver.h

@@ -6,13 +6,15 @@
 #define CLIENT_SDK_NATIVE_RTP_RECEIVER_H
 
 #include <memory>
+
 #include "api/rtp_receiver_interface.h"
 
 namespace livekit {
 
 class RtpReceiver {
  public:
-        explicit RtpReceiver(rtc::scoped_refptr<webrtc::RtpReceiverInterface> receiver);
+  explicit RtpReceiver(
+      rtc::scoped_refptr<webrtc::RtpReceiverInterface> receiver);
 
  private:
   rtc::scoped_refptr<webrtc::RtpReceiverInterface> receiver_;
@@ -21,6 +23,6 @@ namespace livekit {
 static std::unique_ptr<RtpReceiver> _unique_rtp_receiver() {
   return nullptr;  // Ignore
 }
-} // livekit
+}  // namespace livekit
 
 #endif  // CLIENT_SDK_NATIVE_RTP_RECEIVER_H

crates/livekit-webrtc/libwebrtc-sys/include/livekit/rtp_transceiver.h

@@ -6,13 +6,15 @@
 #define CLIENT_SDK_NATIVE_RTP_TRANSCEIVER_H
 
 #include <memory>
+
 #include "api/rtp_transceiver_interface.h"
 
 namespace livekit {
 
 class RtpTransceiver {
  public:
-        explicit RtpTransceiver(rtc::scoped_refptr<webrtc::RtpTransceiverInterface> transceiver);
+  explicit RtpTransceiver(
+      rtc::scoped_refptr<webrtc::RtpTransceiverInterface> transceiver);
 
  private:
   rtc::scoped_refptr<webrtc::RtpTransceiverInterface> transceiver_;
@@ -21,6 +23,6 @@ namespace livekit {
 static std::unique_ptr<RtpTransceiver> _unique_rtp_transceiver() {
   return nullptr;  // Ignore
 }
-} // livekit
+}  // namespace livekit
 
 #endif  // CLIENT_SDK_NATIVE_RTP_TRANSCEIVER_H

crates/livekit-webrtc/libwebrtc-sys/include/livekit/rust_types.h

@@ -2,7 +2,6 @@
 // Created by Théo Monnom on 30/08/2022.
 //
 
-
 #ifndef RUST_TYPES_H
 #define RUST_TYPES_H
 
@@ -22,6 +21,6 @@ namespace livekit {
 struct RTCError;
 struct DataChannelInit;
 struct DataBuffer;
-}
+}  // namespace livekit
 
 #endif  // RUST_TYPES_H

crates/livekit-webrtc/libwebrtc-sys/include/livekit/webrtc.h

@@ -5,8 +5,8 @@
 #ifndef LIVEKIT_WEBRTC_WEBRTC_H
 #define LIVEKIT_WEBRTC_WEBRTC_H
 
-#include "rtc_base/ssl_adapter.h"
 #include "rtc_base/physical_socket_server.h"
+#include "rtc_base/ssl_adapter.h"
 
 #ifdef WEBRTC_WIN
 #include "rtc_base/win32_socket_init.h"
@@ -21,6 +21,7 @@ namespace livekit {
 
   RTCRuntime(const RTCRuntime&) = delete;
   RTCRuntime& operator=(const RTCRuntime&) = delete;
+
  private:
 #ifdef WEBRTC_WIN
   rtc::WinsockInitializer winsock_;
@@ -29,6 +30,6 @@ namespace livekit {
 
 std::unique_ptr<RTCRuntime> create_rtc_runtime();
 
-} // livekit
+}  // namespace livekit
 
 #endif  // LIVEKIT_WEBRTC_WEBRTC_H

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

@@ -5,7 +5,6 @@
 #include "livekit/candidate.h"
 
 namespace livekit {
-    Candidate::Candidate(const cricket::Candidate &candidate) : candidate_(candidate) {
+Candidate::Candidate(const cricket::Candidate& candidate)
-
+    : candidate_(candidate) {}
-    }
+}  // namespace livekit
-} // livekit

crates/livekit-webrtc/libwebrtc-sys/src/candidate.rs

@@ -1,5 +1,3 @@
-use cxx::UniquePtr;
-
 #[cxx::bridge(namespace = "livekit")]
 pub mod ffi {
     unsafe extern "C++" {

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

@@ -2,16 +2,17 @@
 // Created by Théo Monnom on 01/09/2022.
 //
 
+#include "livekit/data_channel.h"
+
 #include <utility>
 
-#include "livekit/data_channel.h"
 #include "libwebrtc-sys/src/data_channel.rs.h"
 
 namespace livekit {
 
-    DataChannel::DataChannel(rtc::scoped_refptr<webrtc::DataChannelInterface> data_channel) : data_channel_(std::move(data_channel)) {
+DataChannel::DataChannel(
-
+    rtc::scoped_refptr<webrtc::DataChannelInterface> data_channel)
-    }
+    : data_channel_(std::move(data_channel)) {}
 
 void DataChannel::register_observer(NativeDataChannelObserver& observer) {
   data_channel_->RegisterObserver(&observer);
@@ -22,7 +23,8 @@ namespace livekit {
 }
 
 bool DataChannel::send(const DataBuffer& buffer) {
-        return data_channel_->Send(webrtc::DataBuffer{rtc::CopyOnWriteBuffer(buffer.ptr, buffer.len), buffer.binary });
+  return data_channel_->Send(webrtc::DataBuffer{
+      rtc::CopyOnWriteBuffer(buffer.ptr, buffer.len), buffer.binary});
 }
 
 rust::String DataChannel::label() const {
@@ -33,7 +35,8 @@ namespace livekit {
   return data_channel_->Close();
 }
 
-    std::unique_ptr<NativeDataChannelInit> create_data_channel_init(DataChannelInit init) {
+std::unique_ptr<NativeDataChannelInit> create_data_channel_init(
+    DataChannelInit init) {
   auto rtc_init = std::make_unique<webrtc::DataChannelInit>();
   rtc_init->id = init.id;
   rtc_init->negotiated = init.negotiated;
@@ -53,9 +56,9 @@ namespace livekit {
   return rtc_init;
 }
 
-    NativeDataChannelObserver::NativeDataChannelObserver(rust::Box<DataChannelObserverWrapper> observer) : observer_(std::move(observer)){
+NativeDataChannelObserver::NativeDataChannelObserver(
-
+    rust::Box<DataChannelObserverWrapper> observer)
-    }
+    : observer_(std::move(observer)) {}
 
 void NativeDataChannelObserver::OnStateChange() {
   observer_->on_state_change();
@@ -69,11 +72,13 @@ namespace livekit {
   observer_->on_message(data);
 }
 
-    void NativeDataChannelObserver::OnBufferedAmountChange(uint64_t sent_data_size) {
+void NativeDataChannelObserver::OnBufferedAmountChange(
+    uint64_t sent_data_size) {
   observer_->on_buffered_amount_change(sent_data_size);
 }
 
-    std::unique_ptr<NativeDataChannelObserver> create_native_data_channel_observer(rust::Box<DataChannelObserverWrapper> observer){
+std::unique_ptr<NativeDataChannelObserver> create_native_data_channel_observer(
+    rust::Box<DataChannelObserverWrapper> observer) {
   return std::make_unique<NativeDataChannelObserver>(std::move(observer));
 }
-} // livekit
+}  // namespace livekit

crates/livekit-webrtc/libwebrtc-sys/src/data_channel.rs

@@ -1,9 +1,7 @@
-use cxx::UniquePtr;
 use std::slice;
 
 #[cxx::bridge(namespace = "livekit")]
 pub mod ffi {
-
     #[derive(Debug)]
     #[repr(u32)]
     pub enum Priority {
@@ -83,6 +81,7 @@ pub mod ffi {
 }
 
 unsafe impl Send for ffi::DataChannel {}
+
 unsafe impl Send for ffi::NativeDataChannelObserver {}
 
 // DataChannelObserver

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

@@ -2,26 +2,27 @@
 // Created by Théo Monnom on 01/09/2022.
 //
 
+#include "livekit/jsep.h"
+
 #include <memory>
 
-#include "livekit/rtc_error.h"
-#include "livekit/jsep.h"
 #include "libwebrtc-sys/src/jsep.rs.h"
+#include "livekit/rtc_error.h"
 #include "rtc_base/ref_counted_object.h"
 
 namespace livekit {
 
-    IceCandidate::IceCandidate(std::unique_ptr<webrtc::IceCandidateInterface> ice_candidate) : ice_candidate_(std::move(ice_candidate)){
+IceCandidate::IceCandidate(
-
+    std::unique_ptr<webrtc::IceCandidateInterface> ice_candidate)
-    }
+    : ice_candidate_(std::move(ice_candidate)) {}
 
 std::unique_ptr<webrtc::IceCandidateInterface> IceCandidate::release() {
   return std::move(ice_candidate_);
 }
 
-    SessionDescription::SessionDescription(std::unique_ptr<webrtc::SessionDescriptionInterface> session_description) : session_description_(std::move(session_description)){
+SessionDescription::SessionDescription(
-
+    std::unique_ptr<webrtc::SessionDescriptionInterface> session_description)
-    }
+    : session_description_(std::move(session_description)) {}
 
 rust::String SessionDescription::stringify() const {
   std::string str;
@@ -33,62 +34,74 @@ namespace livekit {
   return std::make_unique<SessionDescription>(session_description_->Clone());
 }
 
-    std::unique_ptr<webrtc::SessionDescriptionInterface> SessionDescription::release() {
+std::unique_ptr<webrtc::SessionDescriptionInterface>
+SessionDescription::release() {
   return std::move(session_description_);
 }
 
 // CreateSdpObserver
 
 NativeCreateSdpObserver::NativeCreateSdpObserver(
-            rust::Box<CreateSdpObserverWrapper> observer) : observer_(std::move(observer)) {
+    rust::Box<CreateSdpObserverWrapper> observer)
+    : observer_(std::move(observer)) {}
 
-    }
+void NativeCreateSdpObserver::OnSuccess(
-
+    webrtc::SessionDescriptionInterface* desc) {
-    void NativeCreateSdpObserver::OnSuccess(webrtc::SessionDescriptionInterface *desc) {
   // We have ownership of desc
-        observer_->on_success(std::make_unique<SessionDescription>(std::unique_ptr<webrtc::SessionDescriptionInterface>(desc)));
+  observer_->on_success(std::make_unique<SessionDescription>(
+      std::unique_ptr<webrtc::SessionDescriptionInterface>(desc)));
 }
 
 void NativeCreateSdpObserver::OnFailure(webrtc::RTCError error) {
   observer_->on_failure(to_error(error));
 }
 
-    std::unique_ptr<NativeCreateSdpObserverHandle> create_native_create_sdp_observer(rust::Box<CreateSdpObserverWrapper> observer){
+std::unique_ptr<NativeCreateSdpObserverHandle>
-        return std::make_unique<NativeCreateSdpObserverHandle>(NativeCreateSdpObserverHandle {
+create_native_create_sdp_observer(
-            rtc::make_ref_counted<NativeCreateSdpObserver>(std::move(observer))
+    rust::Box<CreateSdpObserverWrapper> observer) {
-        });
+  return std::make_unique<NativeCreateSdpObserverHandle>(
+      NativeCreateSdpObserverHandle{
+          rtc::make_ref_counted<NativeCreateSdpObserver>(std::move(observer))});
 }
 
 // SetLocalSdpObserver
 
-    NativeSetLocalSdpObserver::NativeSetLocalSdpObserver(rust::Box<SetLocalSdpObserverWrapper> observer) : observer_(std::move(observer)) {
+NativeSetLocalSdpObserver::NativeSetLocalSdpObserver(
+    rust::Box<SetLocalSdpObserverWrapper> observer)
+    : observer_(std::move(observer)) {}
 
-    }
+void NativeSetLocalSdpObserver::OnSetLocalDescriptionComplete(
-
+    webrtc::RTCError error) {
-    void NativeSetLocalSdpObserver::OnSetLocalDescriptionComplete(webrtc::RTCError error) {
   observer_->on_set_local_description_complete(to_error(error));
 }
 
-    std::unique_ptr<NativeSetLocalSdpObserverHandle> create_native_set_local_sdp_observer(rust::Box<SetLocalSdpObserverWrapper> observer){
+std::unique_ptr<NativeSetLocalSdpObserverHandle>
-        return std::make_unique<NativeSetLocalSdpObserverHandle>(NativeSetLocalSdpObserverHandle {
+create_native_set_local_sdp_observer(
-                rtc::make_ref_counted<NativeSetLocalSdpObserver>(std::move(observer))
+    rust::Box<SetLocalSdpObserverWrapper> observer) {
-        });
+  return std::make_unique<NativeSetLocalSdpObserverHandle>(
+      NativeSetLocalSdpObserverHandle{
+          rtc::make_ref_counted<NativeSetLocalSdpObserver>(
+              std::move(observer))});
 }
 
 // SetRemoteSdpObserver
 
-    NativeSetRemoteSdpObserver::NativeSetRemoteSdpObserver(rust::Box<SetRemoteSdpObserverWrapper> observer) : observer_(std::move(observer)) {
+NativeSetRemoteSdpObserver::NativeSetRemoteSdpObserver(
+    rust::Box<SetRemoteSdpObserverWrapper> observer)
+    : observer_(std::move(observer)) {}
 
-    }
+void NativeSetRemoteSdpObserver::OnSetRemoteDescriptionComplete(
-
+    webrtc::RTCError error) {
-    void NativeSetRemoteSdpObserver::OnSetRemoteDescriptionComplete(webrtc::RTCError error) {
   observer_->on_set_remote_description_complete(to_error(error));
 }
 
-    std::unique_ptr<NativeSetRemoteSdpObserverHandle> create_native_set_remote_sdp_observer(rust::Box<SetRemoteSdpObserverWrapper> observer){
+std::unique_ptr<NativeSetRemoteSdpObserverHandle>
-        return std::make_unique<NativeSetRemoteSdpObserverHandle>(NativeSetRemoteSdpObserverHandle {
+create_native_set_remote_sdp_observer(
-                rtc::make_ref_counted<NativeSetRemoteSdpObserver>(std::move(observer))
+    rust::Box<SetRemoteSdpObserverWrapper> observer) {
-        });
+  return std::make_unique<NativeSetRemoteSdpObserverHandle>(
+      NativeSetRemoteSdpObserverHandle{
+          rtc::make_ref_counted<NativeSetRemoteSdpObserver>(
+              std::move(observer))});
 }
 
-} // livekit
+}  // namespace livekit

crates/livekit-webrtc/libwebrtc-sys/src/jsep.rs

@@ -1,11 +1,11 @@
-use cxx::UniquePtr;
 use std::fmt::{Debug, Formatter};
 
+use cxx::UniquePtr;
+
 use crate::rtc_error::ffi::RTCError;
 
 #[cxx::bridge(namespace = "livekit")]
 pub mod ffi {
-
     extern "Rust" {
         type CreateSdpObserverWrapper;
         fn on_success(

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

@@ -6,7 +6,7 @@
 
 namespace livekit {
 
-    MediaStreamInterface::MediaStreamInterface(rtc::scoped_refptr<webrtc::MediaStreamInterface> stream) : media_stream_(std::move(stream)) {
+MediaStreamInterface::MediaStreamInterface(
-
+    rtc::scoped_refptr<webrtc::MediaStreamInterface> stream)
-    }
+    : media_stream_(std::move(stream)) {}
-} // livekit
+}  // namespace livekit

crates/livekit-webrtc/libwebrtc-sys/src/media_stream_interface.rs

@@ -1,5 +1,3 @@
-use cxx::UniquePtr;
-
 #[cxx::bridge(namespace = "livekit")]
 pub mod ffi {
     unsafe extern "C++" {

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

@@ -3,12 +3,14 @@
 //
 
 #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) {
+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;
@@ -21,28 +23,43 @@ namespace livekit {
   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) {
+void PeerConnection::create_answer(
-        peer_connection_->CreateOffer(observer_handle.observer.get(), toNativeOfferAnswerOptions(options));
+    NativeCreateSdpObserverHandle& observer_handle,
+    RTCOfferAnswerOptions options) {
+  peer_connection_->CreateAnswer(observer_handle.observer.get(),
+                                 toNativeOfferAnswerOptions(options));
 }
 
-    void PeerConnection::create_answer(NativeCreateSdpObserverHandle &observer_handle, RTCOfferAnswerOptions options) {
+void PeerConnection::set_local_description(
-        peer_connection_->CreateAnswer(observer_handle.observer.get(), toNativeOfferAnswerOptions(options));
+    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) {
+void PeerConnection::set_remote_description(
-        peer_connection_->SetLocalDescription(desc->clone()->release(), observer.observer);
+    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) {
+std::unique_ptr<DataChannel> PeerConnection::create_data_channel(
-        peer_connection_->SetRemoteDescription(desc->clone()->release(), observer.observer);
+    rust::String label,
-    }
+    std::unique_ptr<NativeDataChannelInit> init) {
-
+  auto result =
-    std::unique_ptr<DataChannel> PeerConnection::create_data_channel(rust::String label, std::unique_ptr<NativeDataChannelInit> init) {
+      peer_connection_->CreateDataChannelOrError(label.c_str(), init.get());
-        auto result = peer_connection_->CreateDataChannelOrError(label.c_str(), init.get());
 
   if (!result.ok()) {
     throw std::runtime_error(serialize_error(to_error(result.error())));
@@ -51,10 +68,12 @@ namespace livekit {
   return std::make_unique<DataChannel>(result.value());
 }
 
-    void PeerConnection::add_ice_candidate(std::unique_ptr<IceCandidate> candidate, NativeAddIceCandidateObserver &observer){
+void PeerConnection::add_ice_candidate(
-        peer_connection_->AddIceCandidate(candidate->release(), [&](const webrtc::RTCError& err){
+    std::unique_ptr<IceCandidate> candidate,
-            observer.OnComplete(to_error(err));
+    NativeAddIceCandidateObserver& observer) {
-        });
+  peer_connection_->AddIceCandidate(
+      candidate->release(),
+      [&](const webrtc::RTCError& err) { observer.OnComplete(to_error(err)); });
 }
 
 void PeerConnection::close() {
@@ -63,37 +82,43 @@ namespace livekit {
 
 // 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) {
+std::unique_ptr<NativeAddIceCandidateObserver>
+create_native_add_ice_candidate_observer(
+    rust::Box<AddIceCandidateObserverWrapper> observer) {
   return std::make_unique<NativeAddIceCandidateObserver>(std::move(observer));
 }
 
 // PeerConnectionObserver
 
-    NativePeerConnectionObserver::NativePeerConnectionObserver(rust::Box<PeerConnectionObserverWrapper> observer) : observer_(std::move(observer)) {
+NativePeerConnectionObserver::NativePeerConnectionObserver(
+    rust::Box<PeerConnectionObserverWrapper> observer)
+    : observer_(std::move(observer)) {}
 
-    }
+void NativePeerConnectionObserver::OnSignalingChange(
-
+    webrtc::PeerConnectionInterface::SignalingState new_state) {
-    void NativePeerConnectionObserver::OnSignalingChange(webrtc::PeerConnectionInterface::SignalingState new_state) {
   observer_->on_signaling_change(static_cast<SignalingState>(new_state));
 }
 
-    void NativePeerConnectionObserver::OnAddStream(rtc::scoped_refptr<webrtc::MediaStreamInterface> stream) {
+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) {
+void NativePeerConnectionObserver::OnRemoveStream(
+    rtc::scoped_refptr<webrtc::MediaStreamInterface> stream) {
   observer_->on_remove_stream(std::make_unique<MediaStreamInterface>(stream));
 }
 
-    void NativePeerConnectionObserver::OnDataChannel(rtc::scoped_refptr<webrtc::DataChannelInterface> data_channel) {
+void NativePeerConnectionObserver::OnDataChannel(
+    rtc::scoped_refptr<webrtc::DataChannelInterface> data_channel) {
   observer_->on_data_channel(std::make_unique<DataChannel>(data_channel));
 }
 
@@ -105,58 +130,69 @@ namespace livekit {
   observer_->on_negotiation_needed_event(event_id);
 }
 
-    void
+void NativePeerConnectionObserver::OnIceConnectionChange(
-    NativePeerConnectionObserver::OnIceConnectionChange(webrtc::PeerConnectionInterface::IceConnectionState new_state) {
+    webrtc::PeerConnectionInterface::IceConnectionState new_state) {
-        observer_->on_ice_connection_change(static_cast<IceConnectionState>(new_state));
+  observer_->on_ice_connection_change(
+      static_cast<IceConnectionState>(new_state));
 }
 
 void NativePeerConnectionObserver::OnStandardizedIceConnectionChange(
     webrtc::PeerConnectionInterface::IceConnectionState new_state) {
-        observer_->on_standardized_ice_connection_change(static_cast<IceConnectionState>(new_state));
+  observer_->on_standardized_ice_connection_change(
+      static_cast<IceConnectionState>(new_state));
 }
 
-    void
+void NativePeerConnectionObserver::OnConnectionChange(
-    NativePeerConnectionObserver::OnConnectionChange(webrtc::PeerConnectionInterface::PeerConnectionState new_state) {
+    webrtc::PeerConnectionInterface::PeerConnectionState new_state) {
   observer_->on_connection_change(static_cast<PeerConnectionState>(new_state));
 }
 
-    void
+void NativePeerConnectionObserver::OnIceGatheringChange(
-    NativePeerConnectionObserver::OnIceGatheringChange(webrtc::PeerConnectionInterface::IceGatheringState new_state) {
+    webrtc::PeerConnectionInterface::IceGatheringState new_state) {
   observer_->on_ice_gathering_change(static_cast<IceGatheringState>(new_state));
 }
 
-    void NativePeerConnectionObserver::OnIceCandidate(const webrtc::IceCandidateInterface *candidate) {
+void NativePeerConnectionObserver::OnIceCandidate(
-        auto new_candidate = webrtc::CreateIceCandidate(candidate->sdp_mid(), candidate->sdp_mline_index(),
+    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)));
+  observer_->on_ice_candidate(
+      std::make_unique<IceCandidate>(std::move(new_candidate)));
 }
 
-    void NativePeerConnectionObserver::OnIceCandidateError(const std::string &address, int port, const std::string &url,
+void NativePeerConnectionObserver::OnIceCandidateError(
-                                                           int error_code, const std::string &error_text) {
+    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::OnIceCandidatesRemoved(const std::vector<cricket::Candidate> &candidates) {
+void NativePeerConnectionObserver::OnIceCandidatesRemoved(
+    const std::vector<cricket::Candidate>& candidates) {
   rust::Vec<CandidatePtr> vec;
 
   for (const auto& item : candidates) {
-            vec.push_back(CandidatePtr{
+    vec.push_back(CandidatePtr{std::make_unique<Candidate>(item)});
-                    std::make_unique<Candidate>(item)
-            });
   }
 
   observer_->on_ice_candidates_removed(std::move(vec));
 }
 
-    void NativePeerConnectionObserver::OnIceConnectionReceivingChange(bool receiving) {
+void NativePeerConnectionObserver::OnIceConnectionReceivingChange(
+    bool receiving) {
   observer_->on_ice_connection_receiving_change(receiving);
 }
 
-    void
+void NativePeerConnectionObserver::OnIceSelectedCandidatePairChanged(
-    NativePeerConnectionObserver::OnIceSelectedCandidatePairChanged(const cricket::CandidatePairChangeEvent &event) {
+    const cricket::CandidatePairChangeEvent& event) {
   CandidatePairChangeEvent e;
-        e.selected_candidate_pair.local = std::make_unique<Candidate>(event.selected_candidate_pair.local);
+  e.selected_candidate_pair.local =
-        e.selected_candidate_pair.remote = std::make_unique<Candidate>(event.selected_candidate_pair.remote);
+      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;
@@ -164,24 +200,27 @@ namespace livekit {
   observer_->on_ice_selected_candidate_pair_changed(std::move(e));
 }
 
-    void NativePeerConnectionObserver::OnAddTrack(rtc::scoped_refptr<webrtc::RtpReceiverInterface> receiver,
+void NativePeerConnectionObserver::OnAddTrack(
-                                                  const std::vector<rtc::scoped_refptr<webrtc::MediaStreamInterface>> &streams) {
+    rtc::scoped_refptr<webrtc::RtpReceiverInterface> receiver,
+    const std::vector<rtc::scoped_refptr<webrtc::MediaStreamInterface>>&
+        streams) {
   rust::Vec<MediaStreamPtr> vec;
 
   for (const auto& item : streams) {
-            vec.push_back(MediaStreamPtr{
+    vec.push_back(MediaStreamPtr{std::make_unique<MediaStreamInterface>(item)});
-                    std::make_unique<MediaStreamInterface>(item)
-            });
   }
 
-        observer_->on_add_track(std::make_unique<RtpReceiver>(receiver), std::move(vec));
+  observer_->on_add_track(std::make_unique<RtpReceiver>(receiver),
+                          std::move(vec));
 }
 
-    void NativePeerConnectionObserver::OnTrack(rtc::scoped_refptr<webrtc::RtpTransceiverInterface> transceiver) {
+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) {
+void NativePeerConnectionObserver::OnRemoveTrack(
+    rtc::scoped_refptr<webrtc::RtpReceiverInterface> receiver) {
   observer_->on_remove_track(std::make_unique<RtpReceiver>(receiver));
 }
 
@@ -189,7 +228,9 @@ namespace livekit {
   observer_->on_interesting_usage(usage_pattern);
 }
 
-    std::unique_ptr<NativePeerConnectionObserver> create_native_peer_connection_observer(rust::Box<PeerConnectionObserverWrapper> observer) {
+std::unique_ptr<NativePeerConnectionObserver>
+create_native_peer_connection_observer(
+    rust::Box<PeerConnectionObserverWrapper> observer) {
   return std::make_unique<NativePeerConnectionObserver>(std::move(observer));
 }
-} // livekit
+}  // namespace livekit

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

@@ -1,3 +1,5 @@
+use cxx::UniquePtr;
+
 use crate::candidate::ffi::Candidate;
 use crate::data_channel::ffi::DataChannel;
 use crate::jsep::ffi::IceCandidate;
@@ -5,11 +7,9 @@ use crate::media_stream_interface::ffi::MediaStreamInterface;
 use crate::rtc_error::ffi::RTCError;
 use crate::rtp_receiver::ffi::RtpReceiver;
 use crate::rtp_transceiver::ffi::RtpTransceiver;
-use cxx::UniquePtr;
 
 #[cxx::bridge(namespace = "livekit")]
 pub mod ffi {
-
     struct CandidatePair {
         local: UniquePtr<Candidate>,
         remote: UniquePtr<Candidate>,
@@ -246,6 +246,7 @@ pub mod ffi {
 
 // https://webrtc.github.io/webrtc-org/native-code/native-apis/
 unsafe impl Sync for ffi::PeerConnection {}
+
 unsafe impl Send for ffi::PeerConnection {}
 
 unsafe impl Send for ffi::NativePeerConnectionObserver {}

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

@@ -3,15 +3,16 @@
 //
 
 #include "livekit/peer_connection_factory.h"
-#include "api/video_codecs/builtin_video_decoder_factory.h"
+
 #include "api/audio_codecs/builtin_audio_decoder_factory.h"
 #include "api/audio_codecs/builtin_audio_encoder_factory.h"
-#include "api/video_codecs/builtin_video_encoder_factory.h"
-#include "media/engine/webrtc_media_engine.h"
-#include "api/task_queue/default_task_queue_factory.h"
 #include "api/rtc_event_log/rtc_event_log_factory.h"
+#include "api/task_queue/default_task_queue_factory.h"
+#include "api/video_codecs/builtin_video_decoder_factory.h"
+#include "api/video_codecs/builtin_video_encoder_factory.h"
 #include "libwebrtc-sys/src/peer_connection_factory.rs.h"
 #include "livekit/rtc_error.h"
+#include "media/engine/webrtc_media_engine.h"
 
 namespace livekit {
 
@@ -34,7 +35,8 @@ namespace livekit{
   dependencies.worker_thread = worker_thread_.get();
   dependencies.signaling_thread = signaling_thread_.get();
   dependencies.task_queue_factory = webrtc::CreateDefaultTaskQueueFactory();
-        dependencies.event_log_factory = std::make_unique<webrtc::RtcEventLogFactory>(dependencies.task_queue_factory.get());
+  dependencies.event_log_factory = std::make_unique<webrtc::RtcEventLogFactory>(
+      dependencies.task_queue_factory.get());
 
   cricket::MediaEngineDependencies media_deps;
   media_deps.task_queue_factory = dependencies.task_queue_factory.get();
@@ -45,7 +47,8 @@ namespace livekit{
 
   dependencies.media_engine = cricket::CreateMediaEngine(std::move(media_deps));
 
-        peer_factory_ = webrtc::CreateModularPeerConnectionFactory(std::move(dependencies));
+  peer_factory_ =
+      webrtc::CreateModularPeerConnectionFactory(std::move(dependencies));
 
   if (peer_factory_.get() == nullptr) {
     RTC_LOG_ERR(LS_ERROR) << "Failed to create PeerConnectionFactory";
@@ -53,9 +56,12 @@ namespace livekit{
   }
 }
 
-    std::unique_ptr<PeerConnection> PeerConnectionFactory::create_peer_connection(std::unique_ptr<webrtc::PeerConnectionInterface::RTCConfiguration> config, NativePeerConnectionObserver &observer) const {
+std::unique_ptr<PeerConnection> PeerConnectionFactory::create_peer_connection(
+    std::unique_ptr<webrtc::PeerConnectionInterface::RTCConfiguration> config,
+    NativePeerConnectionObserver& observer) const {
   webrtc::PeerConnectionDependencies deps{&observer};
-        auto result = peer_factory_->CreatePeerConnectionOrError(*config, std::move(deps));
+  auto result =
+      peer_factory_->CreatePeerConnectionOrError(*config, std::move(deps));
 
   if (!result.ok()) {
     throw std::runtime_error(serialize_error(to_error(result.error())));
@@ -68,8 +74,10 @@ namespace livekit{
   return std::make_unique<PeerConnectionFactory>();
 }
 
-    std::unique_ptr<NativeRTCConfiguration> create_rtc_configuration(RTCConfiguration conf){
+std::unique_ptr<NativeRTCConfiguration> create_rtc_configuration(
-        auto rtc = std::make_unique<webrtc::PeerConnectionInterface::RTCConfiguration>();
+    RTCConfiguration conf) {
+  auto rtc =
+      std::make_unique<webrtc::PeerConnectionInterface::RTCConfiguration>();
   for (auto& item : conf.ice_servers) {
     webrtc::PeerConnectionInterface::IceServer ice_server;
     ice_server.username = item.username.c_str();
@@ -84,4 +92,4 @@ namespace livekit{
 
   return rtc;
 }
-} // namespace lk
+}  // namespace livekit

crates/livekit-webrtc/libwebrtc-sys/src/peer_connection_factory.rs

@@ -1,25 +1,10 @@
-use crate::candidate::ffi::Candidate;
-use crate::data_channel::ffi::DataChannel;
-use crate::jsep::ffi::IceCandidate;
-use crate::jsep::CreateSdpObserver;
-use crate::media_stream_interface::ffi::MediaStreamInterface;
-use crate::peer_connection::ffi::{
-    CandidatePairChangeEvent, IceConnectionState, IceGatheringState, PeerConnectionState,
-    SignalingState,
-};
-use crate::peer_connection::PeerConnectionObserver;
-use crate::rtp_receiver::ffi::RtpReceiver;
-use crate::rtp_transceiver::ffi::RtpTransceiver;
-use crate::{jsep, peer_connection};
-use cxx::UniquePtr;
-use log::info;
 use std::any::Any;
-use std::thread::sleep;
+
-use std::time::Duration;
+use crate::jsep::CreateSdpObserver;
+use crate::peer_connection::PeerConnectionObserver;
 
 #[cxx::bridge(namespace = "livekit")]
 pub mod ffi {
-
     #[derive(Debug, Clone)]
     pub struct ICEServer {
         pub urls: Vec<String>,

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

@@ -3,6 +3,7 @@
 //
 
 #include "livekit/rtc_error.h"
+
 #include <iomanip>
 #include <sstream>
 #include <string>
@@ -52,4 +53,4 @@ namespace livekit {
 }
 #endif
 
-} // livekit
+}  // namespace livekit

crates/livekit-webrtc/libwebrtc-sys/src/rtc_error.rs

@@ -6,7 +6,6 @@ use std::fmt::{Display, Formatter};
 
 #[cxx::bridge(namespace = "livekit")]
 pub mod ffi {
-
     #[derive(Debug)]
     #[repr(u32)]
     pub enum RTCErrorType {
@@ -42,7 +41,8 @@ pub mod ffi {
         pub error_type: RTCErrorType,
         pub message: String,
         pub error_detail: RTCErrorDetailType,
-        pub has_sctp_cause_code: bool, // cxx doesn't support the Option trait
+        pub has_sctp_cause_code: bool,
+        // cxx doesn't support the Option trait
         pub sctp_cause_code: u16,
     }
 }

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

@@ -5,7 +5,7 @@
 #include "livekit/rtp_receiver.h"
 
 namespace livekit {
-    RtpReceiver::RtpReceiver(rtc::scoped_refptr<webrtc::RtpReceiverInterface> receiver) : receiver_(std::move(receiver)) {
+RtpReceiver::RtpReceiver(
-
+    rtc::scoped_refptr<webrtc::RtpReceiverInterface> receiver)
-    }
+    : receiver_(std::move(receiver)) {}
-} // livekit
+}  // namespace livekit

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

@@ -5,7 +5,7 @@
 #include "livekit/rtp_transceiver.h"
 
 namespace livekit {
-    RtpTransceiver::RtpTransceiver(rtc::scoped_refptr<webrtc::RtpTransceiverInterface> transceiver) : transceiver_(std::move(transceiver)) {
+RtpTransceiver::RtpTransceiver(
-
+    rtc::scoped_refptr<webrtc::RtpTransceiverInterface> transceiver)
-    }
+    : transceiver_(std::move(transceiver)) {}
-} // livekit
+}  // namespace livekit

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

@@ -3,6 +3,7 @@
 //
 
 #include "livekit/webrtc.h"
+
 #include "rtc_base/logging.h"
 
 namespace livekit {
@@ -19,4 +20,4 @@ namespace livekit {
 std::unique_ptr<RTCRuntime> create_rtc_runtime() {
   return std::make_unique<RTCRuntime>();
 }
-} // livekit
+}  // namespace livekit

crates/livekit-webrtc/src/data_channel.rs

@@ -1,9 +1,10 @@
-use cxx::UniquePtr;
-use libwebrtc_sys::data_channel as sys_dc;
-use log::trace;
 use std::fmt::{Debug, Formatter};
 use std::sync::{Arc, Mutex};
 
+use cxx::UniquePtr;
+use log::trace;
+
+use libwebrtc_sys::data_channel as sys_dc;
 pub use sys_dc::ffi::Priority;
 
 pub struct DataChannel {
@@ -78,7 +79,8 @@ impl DataChannel {
 }
 
 pub type OnStateChangeHandler = Box<dyn FnMut() + Send + Sync>;
-pub type OnMessageHandler = Box<dyn FnMut(&[u8], bool) + Send + Sync>; // data, is_binary
+pub type OnMessageHandler = Box<dyn FnMut(&[u8], bool) + Send + Sync>;
+// data, is_binary
 pub type OnBufferedAmountChangeHandler = Box<dyn FnMut(u64) + Send + Sync>;
 
 struct InternalDataChannelObserver {

crates/livekit-webrtc/src/jsep.rs

@@ -1,4 +1,5 @@
-use cxx::{SharedPtr, UniquePtr};
+use cxx::UniquePtr;
+
 use libwebrtc_sys::jsep as sys_jsep;
 
 #[derive(Debug)]

crates/livekit-webrtc/src/peer_connection.rs

@@ -1,12 +1,19 @@
+use std::fmt::Debug;
+use std::sync::{Arc, Mutex};
+
 use cxx::UniquePtr;
+use log::trace;
+use thiserror::Error;
+use tokio::sync::mpsc;
+
 use libwebrtc_sys::data_channel as sys_dc;
 use libwebrtc_sys::jsep as sys_jsep;
 use libwebrtc_sys::peer_connection as sys_pc;
-use log::trace;
+pub use libwebrtc_sys::peer_connection::ffi::IceConnectionState;
-use std::fmt::{Debug, Formatter};
+pub use libwebrtc_sys::peer_connection::ffi::IceGatheringState;
-use std::sync::{Arc, Mutex};
+pub use libwebrtc_sys::peer_connection::ffi::PeerConnectionState;
-use thiserror::Error;
+pub use libwebrtc_sys::peer_connection::ffi::RTCOfferAnswerOptions;
-use tokio::sync::{mpsc, oneshot};
+pub use libwebrtc_sys::peer_connection::ffi::SignalingState;
 
 use crate::data_channel::{DataChannel, DataChannelInit};
 use crate::jsep::{IceCandidate, SessionDescription};
@@ -15,12 +22,6 @@ use crate::rtc_error::RTCError;
 use crate::rtp_receiver::RtpReceiver;
 use crate::rtp_transceiver::RtpTransceiver;
 
-pub use libwebrtc_sys::peer_connection::ffi::IceConnectionState;
-pub use libwebrtc_sys::peer_connection::ffi::IceGatheringState;
-pub use libwebrtc_sys::peer_connection::ffi::PeerConnectionState;
-pub use libwebrtc_sys::peer_connection::ffi::RTCOfferAnswerOptions;
-pub use libwebrtc_sys::peer_connection::ffi::SignalingState;
-
 #[derive(Error, Debug)]
 pub enum SdpError {
     #[error("recv failure: {0}")]
@@ -604,12 +605,13 @@ impl sys_pc::PeerConnectionObserver for InternalObserver {
 
 #[cfg(test)]
 mod tests {
+    use log::trace;
+    use tokio::sync::mpsc;
+
     use crate::data_channel::{DataChannel, DataChannelInit};
     use crate::jsep::IceCandidate;
     use crate::peer_connection_factory::{ICEServer, PeerConnectionFactory, RTCConfiguration};
     use crate::webrtc::RTCRuntime;
-    use log::trace;
-    use tokio::sync::mpsc;
 
     fn init_log() {
         let _ = env_logger::builder().is_test(true).try_init();

crates/livekit-webrtc/src/peer_connection_factory.rs

@@ -1,12 +1,12 @@
 use cxx::UniquePtr;
+
 use libwebrtc_sys::peer_connection as sys_pc;
 use libwebrtc_sys::peer_connection_factory as sys_factory;
+pub use sys_factory::ffi::{ICEServer, RTCConfiguration};
 
 use crate::peer_connection::{InternalObserver, PeerConnection};
 use crate::rtc_error::RTCError;
 
-pub use sys_factory::ffi::{ICEServer, RTCConfiguration};
-
 pub struct PeerConnectionFactory {
     cxx_handle: UniquePtr<sys_factory::ffi::PeerConnectionFactory>,
 }

crates/livekit-webrtc/src/rtc_error.rs

@@ -1,4 +1,3 @@
-use std::fmt;
-
 // TODO(theomonnom) Wrap the RTCError ffi so we can use Option(u16)
 pub use libwebrtc_sys::rtc_error::ffi::RTCError;
+

crates/livekit-webrtc/src/webrtc.rs

@@ -1,4 +1,5 @@
 use cxx::UniquePtr;
+
 use libwebrtc_sys::webrtc as sys_rtc;
 
 pub struct RTCRuntime {