Fixes to support building in -std=c++20 mode.

* Structs with user-declared constructors are no longer considered
  aggregates, so remove the declarations when possible
* Types of both arguments to "==" must match to avoid "ambiguous
  function call" warning
* Various types of math involving enums are deprecated, so replace with
  constexprs where necessary
* ABSL_CONST_INIT must be used on definition as well as declaration
* volatile memory may no longer be read from and written to by the same
  operator, so replace e.g. "n++" with "n = n + 1"
* Replace an outdated check for no_unique_address support with
  __has_cpp_attribute
* std::result_of(f(x)) has been removed, replace with
  std::invoke_result(f, x)

Bug: chromium:1284275
Change-Id: I77b366ab1da7eb2c1e4c825b2714417c31ee5903
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/261221
Auto-Submit: Peter Kasting <pkasting@chromium.org>
Reviewed-by: Tomas Gunnarsson <tommi@google.com>
Reviewed-by: Tomas Gunnarsson <tommi@webrtc.org>
Commit-Queue: Tomas Gunnarsson <tommi@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#36786}

common_audio/wav_header.cc

@@ -80,8 +80,6 @@ const uint32_t kFmtIeeeFloatSubchunkSize =
 // read audio samples.
 #pragma pack(2)
 struct WavHeaderPcm {
-  WavHeaderPcm(const WavHeaderPcm&) = default;
-  WavHeaderPcm& operator=(const WavHeaderPcm&) = default;
   RiffHeader riff;
   FmtPcmSubchunk fmt;
   struct {
@@ -95,8 +93,6 @@ static_assert(sizeof(WavHeaderPcm) == kPcmWavHeaderSize,
 // WAV implementation.
 #pragma pack(2)
 struct WavHeaderIeeeFloat {
-  WavHeaderIeeeFloat(const WavHeaderIeeeFloat&) = default;
-  WavHeaderIeeeFloat& operator=(const WavHeaderIeeeFloat&) = default;
   RiffHeader riff;
   FmtIeeeFloatSubchunk fmt;
   struct {

modules/audio_processing/include/aec_dump.cc

@@ -17,7 +17,7 @@ InternalAPMConfig::InternalAPMConfig(InternalAPMConfig&&) = default;
 InternalAPMConfig& InternalAPMConfig::operator=(const InternalAPMConfig&) =
     default;
 
-bool InternalAPMConfig::operator==(const InternalAPMConfig& other) {
+bool InternalAPMConfig::operator==(const InternalAPMConfig& other) const {
   return aec_enabled == other.aec_enabled &&
          aec_delay_agnostic_enabled == other.aec_delay_agnostic_enabled &&
          aec_drift_compensation_enabled ==

modules/audio_processing/include/aec_dump.h

@@ -31,7 +31,7 @@ struct InternalAPMConfig {
   InternalAPMConfig& operator=(const InternalAPMConfig&);
   InternalAPMConfig& operator=(InternalAPMConfig&&) = delete;
 
-  bool operator==(const InternalAPMConfig& other);
+  bool operator==(const InternalAPMConfig& other) const;
 
   bool aec_enabled = false;
   bool aec_delay_agnostic_enabled = false;

modules/audio_processing/utility/delay_estimator_wrapper.cc

@@ -21,8 +21,8 @@ namespace webrtc {
 
 // Only bit `kBandFirst` through bit `kBandLast` are processed and
 // `kBandFirst` - `kBandLast` must be < 32.
-enum { kBandFirst = 12 };
+constexpr int kBandFirst = 12;
-enum { kBandLast = 43 };
+constexpr int kBandLast = 43;
 
 static __inline uint32_t SetBit(uint32_t in, int pos) {
   uint32_t mask = (1 << pos);

modules/audio_processing/vad/vad_audio_proc.h

@@ -35,7 +35,7 @@ class VadAudioProc {
                       size_t length,
                       AudioFeatures* audio_features);
 
-  static const size_t kDftSize = 512;
+  static constexpr size_t kDftSize = 512;
 
  private:
   void PitchAnalysis(double* pitch_gains, double* pitch_lags_hz, size_t length);
@@ -51,28 +51,24 @@ class VadAudioProc {
   // For every 30 ms we compute 3 spectral peak there for 3 LPC analysis.
   // LPC is computed over 15 ms of windowed audio. For every 10 ms sub-frame
   // we need 5 ms of past signal to create the input of LPC analysis.
-  enum : size_t {
+  static constexpr size_t kNumPastSignalSamples =
-    kNumPastSignalSamples = static_cast<size_t>(kSampleRateHz / 200)
+      static_cast<size_t>(kSampleRateHz / 200);
-  };
 
   // TODO(turajs): maybe defining this at a higher level (maybe enum) so that
   // all the code recognize it as "no-error."
-  enum : int { kNoError = 0 };
+  static constexpr int kNoError = 0;
 
-  enum : size_t { kNum10msSubframes = 3 };
+  static constexpr size_t kNum10msSubframes = 3;
-  enum : size_t {
+  static constexpr size_t kNumSubframeSamples =
-    kNumSubframeSamples = static_cast<size_t>(kSampleRateHz / 100)
+      static_cast<size_t>(kSampleRateHz / 100);
-  };
-  enum : size_t {
   // Samples in 30 ms @ given sampling rate.
-    kNumSamplesToProcess = kNum10msSubframes * kNumSubframeSamples
+  static constexpr size_t kNumSamplesToProcess =
-  };
+      size_t{kNum10msSubframes} * kNumSubframeSamples;
-  enum : size_t {
+  static constexpr size_t kBufferLength =
-    kBufferLength = kNumPastSignalSamples + kNumSamplesToProcess
+      size_t{kNumPastSignalSamples} + kNumSamplesToProcess;
-  };
+  static constexpr size_t kIpLength = kDftSize >> 1;
-  enum : size_t { kIpLength = kDftSize >> 1 };
+  static constexpr size_t kWLength = kDftSize >> 1;
-  enum : size_t { kWLength = kDftSize >> 1 };
+  static constexpr size_t kLpcOrder = 16;
-  enum : size_t { kLpcOrder = 16 };
 
   size_t ip_[kIpLength];
   float w_fft_[kWLength];

modules/video_coding/codecs/av1/libaom_av1_decoder.cc

@@ -191,7 +191,7 @@ const char* LibaomAv1Decoder::ImplementationName() const {
 
 }  // namespace
 
-const bool kIsLibaomAv1DecoderSupported = true;
+ABSL_CONST_INIT const bool kIsLibaomAv1DecoderSupported = true;
 
 std::unique_ptr<VideoDecoder> CreateLibaomAv1Decoder() {
   return std::make_unique<LibaomAv1Decoder>();

modules/video_coding/codecs/av1/libaom_av1_encoder_supported.cc

@@ -18,7 +18,7 @@
 
 namespace webrtc {
 #if defined(RTC_USE_LIBAOM_AV1_ENCODER)
-const bool kIsLibaomAv1EncoderSupported = true;
+ABSL_CONST_INIT const bool kIsLibaomAv1EncoderSupported = true;
 std::unique_ptr<VideoEncoder> CreateLibaomAv1EncoderIfSupported() {
   return CreateLibaomAv1Encoder();
 }

modules/video_coding/media_opt_util.h

@@ -26,10 +26,10 @@ namespace media_optimization {
 // Number of time periods used for (max) window filter for packet loss
 // TODO(marpan): set reasonable window size for filtered packet loss,
 // adjustment should be based on logged/real data of loss stats/correlation.
-enum { kLossPrHistorySize = 10 };
+constexpr int kLossPrHistorySize = 10;
 
 // 1000 ms, total filter length is (kLossPrHistorySize * 1000) ms
-enum { kLossPrShortFilterWinMs = 1000 };
+constexpr int kLossPrShortFilterWinMs = 1000;
 
 // The type of filter used on the received packet loss reports.
 enum FilterPacketLossMode {
@@ -41,11 +41,11 @@ enum FilterPacketLossMode {
 
 // Thresholds for hybrid NACK/FEC
 // common to media optimization and the jitter buffer.
-const int64_t kLowRttNackMs = 20;
+constexpr int64_t kLowRttNackMs = 20;
 
 // If the RTT is higher than this an extra RTT wont be added to to the jitter
 // buffer delay.
-const int kMaxRttDelayThreshold = 500;
+constexpr int kMaxRttDelayThreshold = 500;
 
 struct VCMProtectionParameters {
   VCMProtectionParameters();
@@ -175,15 +175,15 @@ class VCMFecMethod : public VCMProtectionMethod {
   int BitsPerFrame(const VCMProtectionParameters* parameters);
 
  protected:
-  enum { kUpperLimitFramesFec = 6 };
+  static constexpr int kUpperLimitFramesFec = 6;
   // Thresholds values for the bytes/frame and round trip time, below which we
   // may turn off FEC, depending on `_numLayers` and `_maxFramesFec`.
   // Max bytes/frame for VGA, corresponds to ~140k at 25fps.
-  enum { kMaxBytesPerFrameForFec = 700 };
+  static constexpr int kMaxBytesPerFrameForFec = 700;
   // Max bytes/frame for CIF and lower: corresponds to ~80k at 25fps.
-  enum { kMaxBytesPerFrameForFecLow = 400 };
+  static constexpr int kMaxBytesPerFrameForFecLow = 400;
   // Max bytes/frame for frame size larger than VGA, ~200k at 25fps.
-  enum { kMaxBytesPerFrameForFecHigh = 1000 };
+  static constexpr int kMaxBytesPerFrameForFecHigh = 1000;
 
   const RateControlSettings rate_control_settings_;
 };

rtc_base/race_checker.cc

@@ -25,7 +25,9 @@ RaceChecker::RaceChecker() {}
 bool RaceChecker::Acquire() const {
   const PlatformThreadRef current_thread = CurrentThreadRef();
   // Set new accessing thread if this is a new use.
-  if (access_count_++ == 0)
+  const int current_access_count = access_count_;
+  access_count_ = access_count_ + 1;
+  if (current_access_count == 0)
     accessing_thread_ = current_thread;
   // If this is being used concurrently this check will fail for the second
   // thread entering since it won't set the thread. Recursive use of checked
@@ -35,7 +37,7 @@ bool RaceChecker::Acquire() const {
 }
 
 void RaceChecker::Release() const {
-  --access_count_;
+  access_count_ = access_count_ - 1;
 }
 
 namespace internal {

rtc_base/system/no_unique_address.h

@@ -24,8 +24,10 @@
 // should add support for it starting from C++20. Among clang compilers,
 // clang-cl doesn't support it yet and support is unclear also when the target
 // platform is iOS.
-#if ((defined(__clang__) && !defined(_MSC_VER) && !defined(WEBRTC_IOS)) || \
+#ifndef __has_cpp_attribute
-     __cplusplus > 201703L)
+#define __has_cpp_attribute(__x) 0
+#endif
+#if __has_cpp_attribute(no_unique_address)
 // NOLINTNEXTLINE(whitespace/braces)
 #define RTC_NO_UNIQUE_ADDRESS [[no_unique_address]]
 #else

rtc_base/task_utils/repeating_task.h

@@ -75,8 +75,8 @@ class RepeatingTaskImpl final : public RepeatingTaskBase {
         closure_(std::forward<Closure>(closure)) {
     static_assert(
         std::is_same<TimeDelta,
-                     typename std::result_of<decltype (&Closure::operator())(
+                     typename std::invoke_result<decltype(&Closure::operator()),
-                         Closure)>::type>::value,
+                                                 Closure>::type>::value,
         "");
   }
 

rtc_base/units/unit_base.h

@@ -50,22 +50,22 @@ class UnitBase {
     return value_ == MinusInfinityVal();
   }
 
-  constexpr bool operator==(const Unit_T& other) const {
+  constexpr bool operator==(const UnitBase<Unit_T>& other) const {
     return value_ == other.value_;
   }
-  constexpr bool operator!=(const Unit_T& other) const {
+  constexpr bool operator!=(const UnitBase<Unit_T>& other) const {
     return value_ != other.value_;
   }
-  constexpr bool operator<=(const Unit_T& other) const {
+  constexpr bool operator<=(const UnitBase<Unit_T>& other) const {
     return value_ <= other.value_;
   }
-  constexpr bool operator>=(const Unit_T& other) const {
+  constexpr bool operator>=(const UnitBase<Unit_T>& other) const {
     return value_ >= other.value_;
   }
-  constexpr bool operator>(const Unit_T& other) const {
+  constexpr bool operator>(const UnitBase<Unit_T>& other) const {
     return value_ > other.value_;
   }
-  constexpr bool operator<(const Unit_T& other) const {
+  constexpr bool operator<(const UnitBase<Unit_T>& other) const {
     return value_ < other.value_;
   }
   constexpr Unit_T RoundTo(const Unit_T& resolution) const {

system_wrappers/include/metrics.h

@@ -363,7 +363,7 @@ namespace webrtc {
 namespace metrics {
 
 // Time that should have elapsed for stats that are gathered once per call.
-enum { kMinRunTimeInSeconds = 10 };
+constexpr int kMinRunTimeInSeconds = 10;
 
 class Histogram;
 

test/testsupport/file_utils.cc

@@ -63,9 +63,9 @@ namespace webrtc {
 namespace test {
 
 #if defined(WEBRTC_WIN)
-const absl::string_view kPathDelimiter = "\\";
+ABSL_CONST_INIT const absl::string_view kPathDelimiter = "\\";
 #else
-const absl::string_view kPathDelimiter = "/";
+ABSL_CONST_INIT const absl::string_view kPathDelimiter = "/";
 #endif
 
 std::string DirName(absl::string_view path) {