Remove VLA and implicit value capture of this in lambdas

Those trigger new warnings when importing the Chromium roll

Bug: None
Change-Id: Ica71cc83f5bbfd8fec4736185d389b9e82f2276e
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/363740
Commit-Queue: Florent Castelli <orphis@webrtc.org>
Commit-Queue: Harald Alvestrand <hta@webrtc.org>
Auto-Submit: Florent Castelli <orphis@webrtc.org>
Reviewed-by: Harald Alvestrand <hta@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#43080}

modules/audio_device/linux/audio_device_alsa_linux.cc

@@ -1516,7 +1516,7 @@ bool AudioDeviceLinuxALSA::RecThreadProcess() {
   int err;
   snd_pcm_sframes_t frames;
   snd_pcm_sframes_t avail_frames;
-  int8_t buffer[_recordingBufferSizeIn10MS];
+  std::vector<int8_t> buffer(_recordingBufferSizeIn10MS);
 
   Lock();
 
@@ -1542,7 +1542,7 @@ bool AudioDeviceLinuxALSA::RecThreadProcess() {
   if (static_cast<uint32_t>(avail_frames) > _recordingFramesLeft)
     avail_frames = _recordingFramesLeft;
 
-  frames = LATE(snd_pcm_readi)(_handleRecord, buffer,
+  frames = LATE(snd_pcm_readi)(_handleRecord, buffer.data(),
                                avail_frames);  // frames to be written
   if (frames < 0) {
     RTC_LOG(LS_ERROR) << "capture snd_pcm_readi error: "
@@ -1557,8 +1557,8 @@ bool AudioDeviceLinuxALSA::RecThreadProcess() {
         LATE(snd_pcm_frames_to_bytes)(_handleRecord, _recordingFramesLeft);
     int size = LATE(snd_pcm_frames_to_bytes)(_handleRecord, frames);
 
-    memcpy(&_recordingBuffer[_recordingBufferSizeIn10MS - left_size], buffer,
+    memcpy(&_recordingBuffer[_recordingBufferSizeIn10MS - left_size],
-           size);
+           buffer.data(), size);
     _recordingFramesLeft -= frames;
 
     if (!_recordingFramesLeft) {  // buf is full

modules/congestion_controller/goog_cc/test/goog_cc_printer.cc

@@ -104,13 +104,13 @@ std::deque<FieldLogger*> GoogCcStatePrinter::CreateLoggers() {
                 ->loss_based_bandwidth_estimator_v1_;
   };
   std::deque<FieldLogger*> loggers({
-      Log("time", [=] { return target_.at_time; }),
+      Log("time", [this] { return target_.at_time; }),
-      Log("rtt", [=] { return target_.network_estimate.round_trip_time; }),
+      Log("rtt", [this] { return target_.network_estimate.round_trip_time; }),
-      Log("target", [=] { return target_.target_rate; }),
+      Log("target", [this] { return target_.target_rate; }),
-      Log("stable_target", [=] { return target_.stable_target_rate; }),
+      Log("stable_target", [this] { return target_.stable_target_rate; }),
-      Log("pacing", [=] { return pacing_.data_rate(); }),
+      Log("pacing", [this] { return pacing_.data_rate(); }),
-      Log("padding", [=] { return pacing_.pad_rate(); }),
+      Log("padding", [this] { return pacing_.pad_rate(); }),
-      Log("window", [=] { return congestion_window_; }),
+      Log("window", [this] { return congestion_window_; }),
       Log("rate_control_state", [=] { return rate_control_state(); }),
       Log("stable_estimate", [=] { return stable_estimate(); }),
       Log("trendline", [=] { return trend()->prev_trend_; }),
@@ -118,15 +118,15 @@ std::deque<FieldLogger*> GoogCcStatePrinter::CreateLoggers() {
           [=] { return trend()->prev_modified_trend_; }),
       Log("trendline_offset_threshold", [=] { return trend()->threshold_; }),
       Log("acknowledged_rate", [=] { return acknowledged_rate(); }),
-      Log("est_capacity", [=] { return est_.link_capacity; }),
+      Log("est_capacity", [this] { return est_.link_capacity; }),
-      Log("est_capacity_dev", [=] { return est_.link_capacity_std_dev; }),
+      Log("est_capacity_dev", [this] { return est_.link_capacity_std_dev; }),
-      Log("est_capacity_min", [=] { return est_.link_capacity_min; }),
+      Log("est_capacity_min", [this] { return est_.link_capacity_min; }),
-      Log("est_cross_traffic", [=] { return est_.cross_traffic_ratio; }),
+      Log("est_cross_traffic", [this] { return est_.cross_traffic_ratio; }),
-      Log("est_cross_delay", [=] { return est_.cross_delay_rate; }),
+      Log("est_cross_delay", [this] { return est_.cross_delay_rate; }),
-      Log("est_spike_delay", [=] { return est_.spike_delay_rate; }),
+      Log("est_spike_delay", [this] { return est_.spike_delay_rate; }),
-      Log("est_pre_buffer", [=] { return est_.pre_link_buffer_delay; }),
+      Log("est_pre_buffer", [this] { return est_.pre_link_buffer_delay; }),
-      Log("est_post_buffer", [=] { return est_.post_link_buffer_delay; }),
+      Log("est_post_buffer", [this] { return est_.post_link_buffer_delay; }),
-      Log("est_propagation", [=] { return est_.propagation_delay; }),
+      Log("est_propagation", [this] { return est_.propagation_delay; }),
       Log("loss_ratio", [=] { return loss_cont()->last_loss_ratio_; }),
       Log("loss_average", [=] { return loss_cont()->average_loss_; }),
       Log("loss_average_max", [=] { return loss_cont()->average_loss_max_; }),
@@ -138,9 +138,9 @@ std::deque<FieldLogger*> GoogCcStatePrinter::CreateLoggers() {
       Log("loss_based_rate", [=] { return loss_cont()->loss_based_bitrate_; }),
       Log("loss_ack_rate",
           [=] { return loss_cont()->acknowledged_bitrate_max_; }),
-      Log("data_window", [=] { return controller_->current_data_window_; }),
+      Log("data_window", [this] { return controller_->current_data_window_; }),
       Log("pushback_target",
-          [=] { return controller_->last_pushback_target_rate_; }),
+          [this] { return controller_->last_pushback_target_rate_; }),
   });
   return loggers;
 }

modules/video_coding/codecs/test/videoprocessor_unittest.cc

@@ -103,7 +103,8 @@ TEST_F(VideoProcessorTest, ProcessFrames_FixedFramerate) {
       SetRates(Field(&VideoEncoder::RateControlParameters::framerate_fps,
                      static_cast<double>(kFramerateFps))))
       .Times(1);
-  q_.SendTask([=] { video_processor_->SetRates(kBitrateKbps, kFramerateFps); });
+  q_.SendTask(
+      [this] { video_processor_->SetRates(kBitrateKbps, kFramerateFps); });
 
   EXPECT_CALL(frame_reader_mock_, PullFrame(_, _, _))
       .WillRepeatedly(Return(I420Buffer::Create(kWidth, kHeight)));
@@ -132,7 +133,7 @@ TEST_F(VideoProcessorTest, ProcessFrames_VariableFramerate) {
                      static_cast<double>(kStartFramerateFps))))
       .Times(1);
   q_.SendTask(
-      [=] { video_processor_->SetRates(kBitrateKbps, kStartFramerateFps); });
+      [this] { video_processor_->SetRates(kBitrateKbps, kStartFramerateFps); });
 
   EXPECT_CALL(frame_reader_mock_, PullFrame(_, _, _))
       .WillRepeatedly(Return(I420Buffer::Create(kWidth, kHeight)));
@@ -148,7 +149,7 @@ TEST_F(VideoProcessorTest, ProcessFrames_VariableFramerate) {
                      static_cast<double>(kNewFramerateFps))))
       .Times(1);
   q_.SendTask(
-      [=] { video_processor_->SetRates(kBitrateKbps, kNewFramerateFps); });
+      [this] { video_processor_->SetRates(kBitrateKbps, kNewFramerateFps); });
 
   EXPECT_CALL(encoder_mock_,
               Encode(Property(&VideoFrame::rtp_timestamp,
@@ -174,7 +175,8 @@ TEST_F(VideoProcessorTest, SetRates) {
                      Field(&VideoEncoder::RateControlParameters::framerate_fps,
                            static_cast<double>(kFramerateFps)))))
       .Times(1);
-  q_.SendTask([=] { video_processor_->SetRates(kBitrateKbps, kFramerateFps); });
+  q_.SendTask(
+      [this] { video_processor_->SetRates(kBitrateKbps, kFramerateFps); });
 
   const uint32_t kNewBitrateKbps = 456;
   const int kNewFramerateFps = 34;
@@ -188,8 +190,9 @@ TEST_F(VideoProcessorTest, SetRates) {
                      Field(&VideoEncoder::RateControlParameters::framerate_fps,
                            static_cast<double>(kNewFramerateFps)))))
       .Times(1);
-  q_.SendTask(
+  q_.SendTask([this] {
-      [=] { video_processor_->SetRates(kNewBitrateKbps, kNewFramerateFps); });
+    video_processor_->SetRates(kNewBitrateKbps, kNewFramerateFps);
+  });
 
   ExpectRelease();
 }

test/peer_scenario/peer_scenario_client.cc

@@ -348,7 +348,8 @@ void PeerScenarioClient::CreateAndSetSdp(
   RTC_DCHECK_RUN_ON(signaling_thread_);
   peer_connection_->CreateOffer(
       rtc::make_ref_counted<LambdaCreateSessionDescriptionObserver>(
-          [=](std::unique_ptr<SessionDescriptionInterface> offer) {
+          [this, munge_offer,
+           offer_handler](std::unique_ptr<SessionDescriptionInterface> offer) {
             RTC_DCHECK_RUN_ON(signaling_thread_);
             if (munge_offer) {
               munge_offer(offer.get());
@@ -371,7 +372,8 @@ void PeerScenarioClient::SetSdpOfferAndGetAnswer(
     std::function<void()> remote_description_set,
     std::function<void(std::string)> answer_handler) {
   if (!signaling_thread_->IsCurrent()) {
-    signaling_thread_->PostTask([=] {
+    signaling_thread_->PostTask([this, remote_offer, remote_description_set,
+                                 answer_handler] {
       SetSdpOfferAndGetAnswer(remote_offer, remote_description_set,
                               answer_handler);
     });
@@ -380,7 +382,9 @@ void PeerScenarioClient::SetSdpOfferAndGetAnswer(
   RTC_DCHECK_RUN_ON(signaling_thread_);
   peer_connection_->SetRemoteDescription(
       CreateSessionDescription(SdpType::kOffer, remote_offer),
-      rtc::make_ref_counted<LambdaSetRemoteDescriptionObserver>([=](RTCError) {
+      rtc::make_ref_counted<
+          LambdaSetRemoteDescriptionObserver>([this, remote_description_set,
+                                               answer_handler](RTCError) {
         RTC_DCHECK_RUN_ON(signaling_thread_);
         if (remote_description_set) {
           // Allow the caller to modify transceivers
@@ -389,7 +393,8 @@ void PeerScenarioClient::SetSdpOfferAndGetAnswer(
         }
         peer_connection_->CreateAnswer(
             rtc::make_ref_counted<LambdaCreateSessionDescriptionObserver>(
-                [=](std::unique_ptr<SessionDescriptionInterface> answer) {
+                [this, answer_handler](
+                    std::unique_ptr<SessionDescriptionInterface> answer) {
                   RTC_DCHECK_RUN_ON(signaling_thread_);
                   std::string sdp_answer;
                   answer->ToString(&sdp_answer);
@@ -410,8 +415,9 @@ void PeerScenarioClient::SetSdpAnswer(
     std::string remote_answer,
     std::function<void(const SessionDescriptionInterface&)> done_handler) {
   if (!signaling_thread_->IsCurrent()) {
-    signaling_thread_->PostTask(
+    signaling_thread_->PostTask([this, remote_answer, done_handler] {
-        [=] { SetSdpAnswer(remote_answer, done_handler); });
+      SetSdpAnswer(remote_answer, done_handler);
+    });
     return;
   }
   RTC_DCHECK_RUN_ON(signaling_thread_);

test/scenario/video_stream.cc

@@ -455,7 +455,7 @@ void SendVideoStream::UpdateConfig(
 }
 
 void SendVideoStream::UpdateActiveLayers(std::vector<bool> active_layers) {
-  sender_->task_queue_.PostTask([=] {
+  sender_->task_queue_.PostTask([this, active_layers] {
     MutexLock lock(&mutex_);
     VideoEncoderConfig encoder_config = CreateVideoEncoderConfig(config_);
     RTC_CHECK_EQ(encoder_config.simulcast_layers.size(), active_layers.size());