Clang-tidy: additional checks (#107)

alan-george-lk · web-flow · commit 225e7d06986f · 2026-04-22T20:33:41.000-06:00
Added misc-const-correctness
diff --git a/.clang-tidy b/.clang-tidy
@@ -1,6 +1,7 @@
 Checks: >
   -*,
   bugprone-*,
+  misc-const-correctness,
   performance-*,
   modernize-*,
   readability-misleading-indentation,
diff --git a/src/audio_frame.cpp b/src/audio_frame.cpp
@@ -83,7 +83,7 @@ AudioFrame::fromOwnedInfo(const proto::OwnedAudioFrameBuffer &owned) {
   }
 
   {
-    FfiHandle guard(static_cast<uintptr_t>(owned.handle().id()));
+    const FfiHandle guard(static_cast<uintptr_t>(owned.handle().id()));
     // guard is destroyed at end of scope, which should call into the FFI to
     // drop the OwnedAudioFrameBuffer.
   }
diff --git a/src/audio_processing_module.cpp b/src/audio_processing_module.cpp
@@ -35,7 +35,7 @@ AudioProcessingModule::AudioProcessingModule(const Options &options) {
   msg->set_high_pass_filter_enabled(options.high_pass_filter);
   msg->set_gain_controller_enabled(options.auto_gain_control);
 
-  proto::FfiResponse resp = FfiClient::instance().sendRequest(req);
+  const proto::FfiResponse resp = FfiClient::instance().sendRequest(req);
 
   if (!resp.has_new_apm()) {
     throw std::runtime_error(
@@ -69,7 +69,7 @@ void AudioProcessingModule::processStream(AudioFrame &frame) {
   msg->set_sample_rate(static_cast<std::uint32_t>(frame.sample_rate()));
   msg->set_num_channels(static_cast<std::uint32_t>(frame.num_channels()));
 
-  proto::FfiResponse resp = FfiClient::instance().sendRequest(req);
+  const proto::FfiResponse resp = FfiClient::instance().sendRequest(req);
 
   if (!resp.has_apm_process_stream()) {
     throw std::runtime_error(
@@ -101,7 +101,7 @@ void AudioProcessingModule::processReverseStream(AudioFrame &frame) {
   msg->set_sample_rate(static_cast<std::uint32_t>(frame.sample_rate()));
   msg->set_num_channels(static_cast<std::uint32_t>(frame.num_channels()));
 
-  proto::FfiResponse resp = FfiClient::instance().sendRequest(req);
+  const proto::FfiResponse resp = FfiClient::instance().sendRequest(req);
 
   if (!resp.has_apm_process_reverse_stream()) {
     throw std::runtime_error(
@@ -125,7 +125,7 @@ void AudioProcessingModule::setStreamDelayMs(int delay_ms) {
   msg->set_apm_handle(static_cast<std::uint64_t>(handle_.get()));
   msg->set_delay_ms(delay_ms);
 
-  proto::FfiResponse resp = FfiClient::instance().sendRequest(req);
+  const proto::FfiResponse resp = FfiClient::instance().sendRequest(req);
 
   if (!resp.has_apm_set_stream_delay()) {
     throw std::runtime_error(
diff --git a/src/audio_source.cpp b/src/audio_source.cpp
@@ -50,7 +50,7 @@ AudioSource::AudioSource(int sample_rate, int num_channels, int queue_size_ms)
   msg->set_num_channels(static_cast<std::uint32_t>(num_channels_));
   msg->set_queue_size_ms(static_cast<std::uint32_t>(queue_size_ms_));
 
-  proto::FfiResponse resp = FfiClient::instance().sendRequest(req);
+  const proto::FfiResponse resp = FfiClient::instance().sendRequest(req);
 
   const auto &source_info = resp.new_audio_source().source();
   // Wrap FFI handle in RAII FfiHandle
@@ -62,9 +62,9 @@ double AudioSource::queuedDuration() const noexcept {
     return 0.0;
   }
 
-  double now = now_seconds();
-  double elapsed = now - last_capture_;
-  double remaining = q_size_ - elapsed;
+  const double now = now_seconds();
+  const double elapsed = now - last_capture_;
+  const double remaining = q_size_ - elapsed;
   return remaining > 0.0 ? remaining : 0.0;
 }
 
@@ -100,9 +100,9 @@ void AudioSource::captureFrame(const AudioFrame &frame, int timeout_ms) {
   }
 
   // Queue tracking, same logic as before
-  double now = now_seconds();
-  double elapsed = (last_capture_ == 0.0) ? 0.0 : (now - last_capture_);
-  double frame_duration = static_cast<double>(frame.samples_per_channel()) /
+  const double now = now_seconds();
+  const double elapsed = (last_capture_ == 0.0) ? 0.0 : (now - last_capture_);
+  const double frame_duration = static_cast<double>(frame.samples_per_channel()) /
                           static_cast<double>(sample_rate_);
   q_size_ += frame_duration - elapsed;
   if (q_size_ < 0.0) {
@@ -111,7 +111,7 @@ void AudioSource::captureFrame(const AudioFrame &frame, int timeout_ms) {
   last_capture_ = now;
 
   // Build AudioFrameBufferInfo from the wrapper
-  proto::AudioFrameBufferInfo buf = frame.toProto();
+  const proto::AudioFrameBufferInfo buf = frame.toProto();
   // Use async FFI API and block until the callback completes
   auto fut = FfiClient::instance().captureAudioFrameAsync(handle_.get(), buf);
   if (timeout_ms == 0) {
diff --git a/src/ffi_client.cpp b/src/ffi_client.cpp
@@ -200,7 +200,7 @@ FfiClient::sendRequest(const proto::FfiRequest &request) const {
   }
 
   // Ensure we drop the handle exactly once on all paths
-  FfiHandle handle_guard(static_cast<uintptr_t>(handle));
+  const FfiHandle handle_guard(static_cast<uintptr_t>(handle));
   if (!resp_ptr || resp_len == 0) {
     throw std::runtime_error("FFI returned empty response bytes");
   }
@@ -403,7 +403,7 @@ FfiClient::connectAsync(const std::string &url, const std::string &token,
   }
 
   try {
-    proto::FfiResponse resp = sendRequest(req);
+    const proto::FfiResponse resp = sendRequest(req);
     if (!resp.has_connect()) {
       logAndThrow("FfiResponse missing connect");
     }
@@ -501,7 +501,7 @@ FfiClient::publishTrackAsync(std::uint64_t local_participant_handle,
           return;
         }
 
-        proto::OwnedTrackPublication pub = cb.publication();
+        const proto::OwnedTrackPublication &pub = cb.publication();
         pr.set_value(std::move(pub));
       });
 
@@ -515,7 +515,7 @@ FfiClient::publishTrackAsync(std::uint64_t local_participant_handle,
   msg->mutable_options()->CopyFrom(optionProto);
 
   try {
-    proto::FfiResponse resp = sendRequest(req);
+    const proto::FfiResponse resp = sendRequest(req);
     if (!resp.has_publish_track()) {
       logAndThrow("FfiResponse missing publish_track");
     }
@@ -560,7 +560,7 @@ FfiClient::unpublishTrackAsync(std::uint64_t local_participant_handle,
   msg->set_request_async_id(async_id);
 
   try {
-    proto::FfiResponse resp = sendRequest(req);
+    const proto::FfiResponse resp = sendRequest(req);
     if (!resp.has_unpublish_track()) {
       logAndThrow("FfiResponse missing unpublish_track");
     }
@@ -611,7 +611,7 @@ std::future<void> FfiClient::publishDataAsync(
   }
 
   try {
-    proto::FfiResponse resp = sendRequest(req);
+    const proto::FfiResponse resp = sendRequest(req);
     if (!resp.has_publish_data()) {
       logAndThrow("FfiResponse missing publish_data");
     }
@@ -665,7 +665,7 @@ FfiClient::publishDataTrackAsync(std::uint64_t local_participant_handle,
   msg->set_request_async_id(async_id);
 
   try {
-    proto::FfiResponse resp = sendRequest(req);
+    const proto::FfiResponse resp = sendRequest(req);
     if (!resp.has_publish_data_track()) {
       cancelPendingByAsyncId(async_id);
       std::promise<Result<proto::OwnedLocalDataTrack, PublishDataTrackError>>
@@ -760,7 +760,7 @@ std::future<void> FfiClient::publishSipDtmfAsync(
   }
 
   try {
-    proto::FfiResponse resp = sendRequest(req);
+    const proto::FfiResponse resp = sendRequest(req);
     if (!resp.has_publish_sip_dtmf()) {
       logAndThrow("FfiResponse missing publish_sip_dtmf");
     }
@@ -803,7 +803,7 @@ FfiClient::setLocalMetadataAsync(std::uint64_t local_participant_handle,
   msg->set_request_async_id(async_id);
 
   try {
-    proto::FfiResponse resp = sendRequest(req);
+    const proto::FfiResponse resp = sendRequest(req);
     if (!resp.has_set_local_metadata()) {
       logAndThrow("FfiResponse missing set_local_metadata");
     }
@@ -848,7 +848,7 @@ FfiClient::captureAudioFrameAsync(std::uint64_t source_handle,
   msg->mutable_buffer()->CopyFrom(buffer);
 
   try {
-    proto::FfiResponse resp = sendRequest(req);
+    const proto::FfiResponse resp = sendRequest(req);
     if (!resp.has_capture_audio_frame()) {
       logAndThrow("FfiResponse missing capture_audio_frame");
     }
@@ -902,7 +902,7 @@ FfiClient::performRpcAsync(std::uint64_t local_participant_handle,
   }
 
   try {
-    proto::FfiResponse resp = sendRequest(req);
+    const proto::FfiResponse resp = sendRequest(req);
     if (!resp.has_perform_rpc()) {
       logAndThrow("FfiResponse missing perform_rpc");
     }
@@ -951,7 +951,7 @@ std::future<void> FfiClient::sendStreamHeaderAsync(
   }
 
   try {
-    proto::FfiResponse resp = sendRequest(req);
+    const proto::FfiResponse resp = sendRequest(req);
     if (!resp.has_send_stream_header()) {
       logAndThrow("FfiResponse missing send_stream_header");
     }
@@ -1000,7 +1000,7 @@ std::future<void> FfiClient::sendStreamChunkAsync(
   }
 
   try {
-    proto::FfiResponse resp = sendRequest(req);
+    const proto::FfiResponse resp = sendRequest(req);
     if (!resp.has_send_stream_chunk()) {
       logAndThrow("FfiResponse missing send_stream_chunk");
     }
@@ -1045,7 +1045,7 @@ FfiClient::sendStreamTrailerAsync(std::uint64_t local_participant_handle,
   msg->set_request_async_id(async_id);
 
   try {
-    proto::FfiResponse resp = sendRequest(req);
+    const proto::FfiResponse resp = sendRequest(req);
     if (!resp.has_send_stream_trailer()) {
       logAndThrow("FfiResponse missing send_stream_trailer");
     }
diff --git a/src/ffi_handle.cpp b/src/ffi_handle.cpp
@@ -40,7 +40,7 @@ void FfiHandle::reset(uintptr_t new_handle) noexcept {
 }
 
 uintptr_t FfiHandle::release() noexcept {
-  uintptr_t old = handle_;
+  const uintptr_t old = handle_;
   handle_ = 0;
   return old;
 }
diff --git a/src/local_audio_track.cpp b/src/local_audio_track.cpp
@@ -38,7 +38,7 @@ std::shared_ptr<LocalAudioTrack> LocalAudioTrack::createLocalAudioTrack(
   msg->set_name(name);
   msg->set_source_handle(static_cast<uint64_t>(source->ffi_handle_id()));
 
-  proto::FfiResponse resp = FfiClient::instance().sendRequest(req);
+  const proto::FfiResponse resp = FfiClient::instance().sendRequest(req);
   const proto::OwnedTrack &owned = resp.create_audio_track().track();
   FfiHandle handle(static_cast<uintptr_t>(owned.handle().id()));
   return std::shared_ptr<LocalAudioTrack>(
diff --git a/src/local_data_track.cpp b/src/local_data_track.cpp
@@ -52,7 +52,7 @@ LocalDataTrack::tryPush(const DataTrackFrame &frame) {
       pf->set_user_timestamp(frame.user_timestamp.value());
     }
 
-    proto::FfiResponse resp = FfiClient::instance().sendRequest(req);
+    const proto::FfiResponse resp = FfiClient::instance().sendRequest(req);
     const auto &r = resp.local_data_track_try_push();
     if (r.has_error()) {
       return Result<void, LocalDataTrackTryPushError>::failure(
@@ -84,7 +84,7 @@ bool LocalDataTrack::isPublished() const {
   auto *msg = req.mutable_local_data_track_is_published();
   msg->set_track_handle(static_cast<uint64_t>(handle_.get()));
 
-  proto::FfiResponse resp = FfiClient::instance().sendRequest(req);
+  const proto::FfiResponse resp = FfiClient::instance().sendRequest(req);
   return resp.local_data_track_is_published().is_published();
 }
 
diff --git a/src/local_video_track.cpp b/src/local_video_track.cpp
@@ -38,7 +38,7 @@ std::shared_ptr<LocalVideoTrack> LocalVideoTrack::createLocalVideoTrack(
   msg->set_name(name);
   msg->set_source_handle(static_cast<uint64_t>(source->ffi_handle_id()));
 
-  proto::FfiResponse resp = FfiClient::instance().sendRequest(req);
+  const proto::FfiResponse resp = FfiClient::instance().sendRequest(req);
   const proto::OwnedTrack &owned = resp.create_video_track().track();
   FfiHandle handle(static_cast<uintptr_t>(owned.handle().id()));
   return std::shared_ptr<LocalVideoTrack>(
diff --git a/src/remote_data_track.cpp b/src/remote_data_track.cpp
@@ -42,7 +42,7 @@ bool RemoteDataTrack::isPublished() const {
   auto *msg = req.mutable_remote_data_track_is_published();
   msg->set_track_handle(static_cast<uint64_t>(handle_.get()));
 
-  proto::FfiResponse resp = FfiClient::instance().sendRequest(req);
+  const proto::FfiResponse resp = FfiClient::instance().sendRequest(req);
   return resp.remote_data_track_is_published().is_published();
 }
 
@@ -63,7 +63,7 @@ RemoteDataTrack::subscribe(const DataTrackStream::Options &options) {
                   SubscribeDataTrackError>::failure(std::move(result).error());
   }
 
-  proto::OwnedDataTrackStream owned_sub = result.value();
+  const proto::OwnedDataTrackStream owned_sub = result.value();
 
   FfiHandle sub_handle(static_cast<uintptr_t>(owned_sub.handle().id()));
 
diff --git a/src/room.cpp b/src/room.cpp
@@ -1065,11 +1065,11 @@ void Room::OnEvent(const FfiEvent &event) {
       }
       const auto which_val = dp.value_case();
       if (which_val == proto::DataPacketReceived::kUser && delegate_snapshot) {
-        UserDataPacketEvent ev = userDataPacketFromProto(dp, rp);
+        const UserDataPacketEvent ev = userDataPacketFromProto(dp, rp);
         delegate_snapshot->onUserPacketReceived(*this, ev);
       } else if (which_val == proto::DataPacketReceived::kSipDtmf &&
                  delegate_snapshot) {
-        SipDtmfReceivedEvent ev = sipDtmfFromProto(dp, rp);
+        const SipDtmfReceivedEvent ev = sipDtmfFromProto(dp, rp);
         delegate_snapshot->onSipDtmfReceived(*this, ev);
       }
       break;
@@ -1140,14 +1140,14 @@ void Room::OnEvent(const FfiEvent &event) {
       break;
     }
     case proto::RoomEvent::kReconnecting: {
-      ReconnectingEvent ev;
+      const ReconnectingEvent ev;
       if (delegate_snapshot) {
         delegate_snapshot->onReconnecting(*this, ev);
       }
       break;
     }
     case proto::RoomEvent::kReconnected: {
-      ReconnectedEvent ev;
+      const ReconnectedEvent ev;
       if (delegate_snapshot) {
         delegate_snapshot->onReconnected(*this, ev);
       }
@@ -1196,7 +1196,7 @@ void Room::OnEvent(const FfiEvent &event) {
 
       // Old state will be destroyed here when going out of scope
 
-      RoomEosEvent ev;
+      const RoomEosEvent ev;
       if (delegate_snapshot) {
         delegate_snapshot->onRoomEos(*this, ev);
       }
@@ -1231,7 +1231,7 @@ void Room::OnEvent(const FfiEvent &event) {
           }
           text_cb = it->second;
 
-          TextStreamInfo info = makeTextInfo(header);
+          const TextStreamInfo info = makeTextInfo(header);
           text_reader = std::make_shared<TextStreamReader>(info);
           text_stream_readers_[header.stream_id()] = text_reader;
 
@@ -1241,7 +1241,7 @@ void Room::OnEvent(const FfiEvent &event) {
             break;
           }
           byte_cb = it->second;
-          ByteStreamInfo info = makeByteInfo(header);
+          const ByteStreamInfo info = makeByteInfo(header);
           byte_reader = std::make_shared<ByteStreamReader>(info);
           byte_stream_readers_[header.stream_id()] = byte_reader;
 
diff --git a/src/subscription_thread_dispatcher.cpp b/src/subscription_thread_dispatcher.cpp
diff --git a/src/track_proto_converter.cpp b/src/track_proto_converter.cpp
diff --git a/src/video_frame.cpp b/src/video_frame.cpp
diff --git a/src/video_source.cpp b/src/video_source.cpp
diff --git a/src/video_utils.cpp b/src/video_utils.cpp

Original file line number	Diff line number	Diff line change
`@@ -83,7 +83,7 @@ AudioFrame::fromOwnedInfo(const proto::OwnedAudioFrameBuffer &owned) {`
`83`	`83`	`}`
`84`	`84`
`85`	`85`	`{`
`86`		`- FfiHandle guard(static_cast<uintptr_t>(owned.handle().id()));`
	`86`	`+ const FfiHandle guard(static_cast<uintptr_t>(owned.handle().id()));`
`87`	`87`	`// guard is destroyed at end of scope, which should call into the FFI to`
`88`	`88`	`// drop the OwnedAudioFrameBuffer.`
`89`	`89`	`}`
Original file line number	Diff line number	Diff line change
`@@ -200,7 +200,7 @@ FfiClient::sendRequest(const proto::FfiRequest &request) const {`
`200`	`200`	`}`
`201`	`201`
`202`	`202`	`// Ensure we drop the handle exactly once on all paths`
`203`		`- FfiHandle handle_guard(static_cast<uintptr_t>(handle));`
	`203`	`+ const FfiHandle handle_guard(static_cast<uintptr_t>(handle));`
`204`	`204`	`if (!resp_ptr \|\| resp_len == 0) {`
`205`	`205`	`throw std::runtime_error("FFI returned empty response bytes");`
`206`	`206`	`}`
`@@ -403,7 +403,7 @@ FfiClient::connectAsync(const std::string &url, const std::string &token,`
`403`	`403`	`}`
`404`	`404`
`405`	`405`	`try {`
`406`		`- proto::FfiResponse resp = sendRequest(req);`
	`406`	`+ const proto::FfiResponse resp = sendRequest(req);`
`407`	`407`	`if (!resp.has_connect()) {`
`408`	`408`	`logAndThrow("FfiResponse missing connect");`
`409`	`409`	`}`
`@@ -501,7 +501,7 @@ FfiClient::publishTrackAsync(std::uint64_t local_participant_handle,`
`501`	`501`	`return;`
`502`	`502`	`}`
`503`	`503`
`504`		`- proto::OwnedTrackPublication pub = cb.publication();`
	`504`	`+ const proto::OwnedTrackPublication &pub = cb.publication();`
`505`	`505`	`pr.set_value(std::move(pub));`
`506`	`506`	`});`
`507`	`507`
`@@ -515,7 +515,7 @@ FfiClient::publishTrackAsync(std::uint64_t local_participant_handle,`
`515`	`515`	`msg->mutable_options()->CopyFrom(optionProto);`
`516`	`516`
`517`	`517`	`try {`
`518`		`- proto::FfiResponse resp = sendRequest(req);`
	`518`	`+ const proto::FfiResponse resp = sendRequest(req);`
`519`	`519`	`if (!resp.has_publish_track()) {`
`520`	`520`	`logAndThrow("FfiResponse missing publish_track");`
`521`	`521`	`}`
`@@ -560,7 +560,7 @@ FfiClient::unpublishTrackAsync(std::uint64_t local_participant_handle,`
`560`	`560`	`msg->set_request_async_id(async_id);`
`561`	`561`
`562`	`562`	`try {`
`563`		`- proto::FfiResponse resp = sendRequest(req);`
	`563`	`+ const proto::FfiResponse resp = sendRequest(req);`
`564`	`564`	`if (!resp.has_unpublish_track()) {`
`565`	`565`	`logAndThrow("FfiResponse missing unpublish_track");`
`566`	`566`	`}`
`@@ -611,7 +611,7 @@ std::future<void> FfiClient::publishDataAsync(`
`611`	`611`	`}`
`612`	`612`
`613`	`613`	`try {`
`614`		`- proto::FfiResponse resp = sendRequest(req);`
	`614`	`+ const proto::FfiResponse resp = sendRequest(req);`
`615`	`615`	`if (!resp.has_publish_data()) {`
`616`	`616`	`logAndThrow("FfiResponse missing publish_data");`
`617`	`617`	`}`
`@@ -665,7 +665,7 @@ FfiClient::publishDataTrackAsync(std::uint64_t local_participant_handle,`
`665`	`665`	`msg->set_request_async_id(async_id);`
`666`	`666`
`667`	`667`	`try {`
`668`		`- proto::FfiResponse resp = sendRequest(req);`
	`668`	`+ const proto::FfiResponse resp = sendRequest(req);`
`669`	`669`	`if (!resp.has_publish_data_track()) {`
`670`	`670`	`cancelPendingByAsyncId(async_id);`
`671`	`671`	`std::promise<Result<proto::OwnedLocalDataTrack, PublishDataTrackError>>`
`@@ -760,7 +760,7 @@ std::future<void> FfiClient::publishSipDtmfAsync(`
`760`	`760`	`}`
`761`	`761`
`762`	`762`	`try {`
`763`		`- proto::FfiResponse resp = sendRequest(req);`
	`763`	`+ const proto::FfiResponse resp = sendRequest(req);`
`764`	`764`	`if (!resp.has_publish_sip_dtmf()) {`
`765`	`765`	`logAndThrow("FfiResponse missing publish_sip_dtmf");`
`766`	`766`	`}`
`@@ -803,7 +803,7 @@ FfiClient::setLocalMetadataAsync(std::uint64_t local_participant_handle,`
`803`	`803`	`msg->set_request_async_id(async_id);`
`804`	`804`
`805`	`805`	`try {`
`806`		`- proto::FfiResponse resp = sendRequest(req);`
	`806`	`+ const proto::FfiResponse resp = sendRequest(req);`
`807`	`807`	`if (!resp.has_set_local_metadata()) {`
`808`	`808`	`logAndThrow("FfiResponse missing set_local_metadata");`
`809`	`809`	`}`
`@@ -848,7 +848,7 @@ FfiClient::captureAudioFrameAsync(std::uint64_t source_handle,`
`848`	`848`	`msg->mutable_buffer()->CopyFrom(buffer);`
`849`	`849`
`850`	`850`	`try {`
`851`		`- proto::FfiResponse resp = sendRequest(req);`
	`851`	`+ const proto::FfiResponse resp = sendRequest(req);`
`852`	`852`	`if (!resp.has_capture_audio_frame()) {`
`853`	`853`	`logAndThrow("FfiResponse missing capture_audio_frame");`
`854`	`854`	`}`
`@@ -902,7 +902,7 @@ FfiClient::performRpcAsync(std::uint64_t local_participant_handle,`
`902`	`902`	`}`
`903`	`903`
`904`	`904`	`try {`
`905`		`- proto::FfiResponse resp = sendRequest(req);`
	`905`	`+ const proto::FfiResponse resp = sendRequest(req);`
`906`	`906`	`if (!resp.has_perform_rpc()) {`
`907`	`907`	`logAndThrow("FfiResponse missing perform_rpc");`
`908`	`908`	`}`
`@@ -951,7 +951,7 @@ std::future<void> FfiClient::sendStreamHeaderAsync(`
`951`	`951`	`}`
`952`	`952`
`953`	`953`	`try {`
`954`		`- proto::FfiResponse resp = sendRequest(req);`
	`954`	`+ const proto::FfiResponse resp = sendRequest(req);`
`955`	`955`	`if (!resp.has_send_stream_header()) {`
`956`	`956`	`logAndThrow("FfiResponse missing send_stream_header");`
`957`	`957`	`}`
`@@ -1000,7 +1000,7 @@ std::future<void> FfiClient::sendStreamChunkAsync(`
`1000`	`1000`	`}`
`1001`	`1001`
`1002`	`1002`	`try {`
`1003`		`- proto::FfiResponse resp = sendRequest(req);`
	`1003`	`+ const proto::FfiResponse resp = sendRequest(req);`
`1004`	`1004`	`if (!resp.has_send_stream_chunk()) {`
`1005`	`1005`	`logAndThrow("FfiResponse missing send_stream_chunk");`
`1006`	`1006`	`}`
`@@ -1045,7 +1045,7 @@ FfiClient::sendStreamTrailerAsync(std::uint64_t local_participant_handle,`
`1045`	`1045`	`msg->set_request_async_id(async_id);`
`1046`	`1046`
`1047`	`1047`	`try {`
`1048`		`- proto::FfiResponse resp = sendRequest(req);`
	`1048`	`+ const proto::FfiResponse resp = sendRequest(req);`
`1049`	`1049`	`if (!resp.has_send_stream_trailer()) {`
`1050`	`1050`	`logAndThrow("FfiResponse missing send_stream_trailer");`
`1051`	`1051`	`}`
Original file line number	Diff line number	Diff line change
`@@ -40,7 +40,7 @@ void FfiHandle::reset(uintptr_t new_handle) noexcept {`
`40`	`40`	`}`
`41`	`41`
`42`	`42`	`uintptr_t FfiHandle::release() noexcept {`
`43`		`- uintptr_t old = handle_;`
	`43`	`+ const uintptr_t old = handle_;`
`44`	`44`	`handle_ = 0;`
`45`	`45`	`return old;`
`46`	`46`	`}`
Original file line number	Diff line number	Diff line change
`@@ -52,7 +52,7 @@ LocalDataTrack::tryPush(const DataTrackFrame &frame) {`
`52`	`52`	`pf->set_user_timestamp(frame.user_timestamp.value());`
`53`	`53`	`}`
`54`	`54`
`55`		`- proto::FfiResponse resp = FfiClient::instance().sendRequest(req);`
	`55`	`+ const proto::FfiResponse resp = FfiClient::instance().sendRequest(req);`
`56`	`56`	`const auto &r = resp.local_data_track_try_push();`
`57`	`57`	`if (r.has_error()) {`
`58`	`58`	`return Result<void, LocalDataTrackTryPushError>::failure(`
`@@ -84,7 +84,7 @@ bool LocalDataTrack::isPublished() const {`
`84`	`84`	`auto *msg = req.mutable_local_data_track_is_published();`
`85`	`85`	`msg->set_track_handle(static_cast<uint64_t>(handle_.get()));`
`86`	`86`
`87`		`- proto::FfiResponse resp = FfiClient::instance().sendRequest(req);`
	`87`	`+ const proto::FfiResponse resp = FfiClient::instance().sendRequest(req);`
`88`	`88`	`return resp.local_data_track_is_published().is_published();`
`89`	`89`	`}`
`90`	`90`
Original file line number	Diff line number	Diff line change
`@@ -42,7 +42,7 @@ bool RemoteDataTrack::isPublished() const {`
`42`	`42`	`auto *msg = req.mutable_remote_data_track_is_published();`
`43`	`43`	`msg->set_track_handle(static_cast<uint64_t>(handle_.get()));`
`44`	`44`
`45`		`- proto::FfiResponse resp = FfiClient::instance().sendRequest(req);`
	`45`	`+ const proto::FfiResponse resp = FfiClient::instance().sendRequest(req);`
`46`	`46`	`return resp.remote_data_track_is_published().is_published();`
`47`	`47`	`}`
`48`	`48`
`@@ -63,7 +63,7 @@ RemoteDataTrack::subscribe(const DataTrackStream::Options &options) {`
`63`	`63`	`SubscribeDataTrackError>::failure(std::move(result).error());`
`64`	`64`	`}`
`65`	`65`
`66`		`- proto::OwnedDataTrackStream owned_sub = result.value();`
	`66`	`+ const proto::OwnedDataTrackStream owned_sub = result.value();`
`67`	`67`
`68`	`68`	`FfiHandle sub_handle(static_cast<uintptr_t>(owned_sub.handle().id()));`
`69`	`69`