Stop using Googletest legacy APIs.

Googletest recently started replacing the term Test Case by Test Suite.
From now on, the preferred API is TestSuite*; the older TestCase* API
will be slowly deprecated.

This CL moves WebRTC to the new set of APIs.

More info in [1].

This CL has been generated with this script:

declare -A items
items[TYPED_TEST_CASE]=TYPED_TEST_SUITE
items[TYPED_TEST_CASE_P]=TYPED_TEST_SUITE_P
items[REGISTER_TYPED_TEST_CASE_P]=REGISTER_TYPED_TEST_SUITE_P
items[INSTANTIATE_TYPED_TEST_CASE_P]=INSTANTIATE_TYPED_TEST_SUITE_P
items[INSTANTIATE_TEST_CASE_P]=INSTANTIATE_TEST_SUITE_P
for i in "${!items[@]}"
do
  git ls-files | xargs sed -i "s/\b$i\b/${items[$i]}/g"
done
git cl format

[1] - https://github.com/google/googletest/blob/master/googletest/docs/primer.md#beware-of-the-nomenclature

Bug: None
Change-Id: I5ae191e3046caf347aeee01554d5743548ab0e3f
Reviewed-on: https://webrtc-review.googlesource.com/c/118701
Commit-Queue: Mirko Bonadei <mbonadei@webrtc.org>
Reviewed-by: Karl Wiberg <kwiberg@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#26494}

77 files changed, 356 insertions, 349 deletions

diff --git a/audio/transport_feedback_packet_loss_tracker_unittest.cc b/audio/transport_feedback_packet_loss_tracker_unittest.cc
index f522635300..cc9065109c 100644
--- a/audio/transport_feedback_packet_loss_tracker_unittest.cc
+++ b/audio/transport_feedback_packet_loss_tracker_unittest.cc
@@ -561,8 +561,8 @@ TEST(TransportFeedbackPacketLossTrackerTest, TimeCantFlowBackwards) {
 // to weed out potential bugs with wrap-around handling.
 constexpr uint16_t kBases[] = {0x0000, 0x3456, 0xc032, 0xfffe};
 
-INSTANTIATE_TEST_CASE_P(_,
-                        TransportFeedbackPacketLossTrackerTest,
-                        testing::ValuesIn(kBases));
+INSTANTIATE_TEST_SUITE_P(_,
+                         TransportFeedbackPacketLossTrackerTest,
+                         testing::ValuesIn(kBases));
 
 }  // namespace webrtc
diff --git a/call/rtp_video_sender_unittest.cc b/call/rtp_video_sender_unittest.cc
index 568b313957..9f98c9d0e1 100644
--- a/call/rtp_video_sender_unittest.cc
+++ b/call/rtp_video_sender_unittest.cc
@@ -141,9 +141,9 @@ class RtpVideoSenderTest : public ::testing::Test,
   test::ScopedFieldTrials field_trial_;
 };
 
-INSTANTIATE_TEST_CASE_P(Default, RtpVideoSenderTest, ::testing::Values(""));
+INSTANTIATE_TEST_SUITE_P(Default, RtpVideoSenderTest, ::testing::Values(""));
 
-INSTANTIATE_TEST_CASE_P(
+INSTANTIATE_TEST_SUITE_P(
     TaskQueueTrial,
     RtpVideoSenderTest,
     ::testing::Values("WebRTC-TaskQueueCongestionControl/Enabled/"));
diff --git a/common_audio/real_fourier_unittest.cc b/common_audio/real_fourier_unittest.cc
index 132488747a..eac4fce42e 100644
--- a/common_audio/real_fourier_unittest.cc
+++ b/common_audio/real_fourier_unittest.cc
@@ -68,7 +68,7 @@ class RealFourierTest : public ::testing::Test {
 };
 
 using FftTypes = ::testing::Types<RealFourierOoura>;
-TYPED_TEST_CASE(RealFourierTest, FftTypes);
+TYPED_TEST_SUITE(RealFourierTest, FftTypes);
 
 TYPED_TEST(RealFourierTest, SimpleForwardTransform) {
   this->real_buffer_[0] = 1.0f;
diff --git a/common_audio/resampler/push_sinc_resampler_unittest.cc b/common_audio/resampler/push_sinc_resampler_unittest.cc
index 6d15a40495..ee111c4c6a 100644
--- a/common_audio/resampler/push_sinc_resampler_unittest.cc
+++ b/common_audio/resampler/push_sinc_resampler_unittest.cc
@@ -255,7 +255,7 @@ TEST_P(PushSincResamplerTest, ResampleFloat) {
 
 // Thresholds chosen arbitrarily based on what each resampling reported during
 // testing.  All thresholds are in dbFS, http://en.wikipedia.org/wiki/DBFS.
-INSTANTIATE_TEST_CASE_P(
+INSTANTIATE_TEST_SUITE_P(
     PushSincResamplerTest,
     PushSincResamplerTest,
     ::testing::Values(
diff --git a/common_audio/resampler/sinc_resampler_unittest.cc b/common_audio/resampler/sinc_resampler_unittest.cc
index 3e0b84b091..3aedaccd56 100644
--- a/common_audio/resampler/sinc_resampler_unittest.cc
+++ b/common_audio/resampler/sinc_resampler_unittest.cc
@@ -340,7 +340,7 @@ static const double kResamplingRMSError = -14.58;
 
 // Thresholds chosen arbitrarily based on what each resampling reported during
 // testing.  All thresholds are in dbFS, http://en.wikipedia.org/wiki/DBFS.
-INSTANTIATE_TEST_CASE_P(
+INSTANTIATE_TEST_SUITE_P(
     SincResamplerTest,
     SincResamplerTest,
     testing::Values(
diff --git a/common_video/video_frame_unittest.cc b/common_video/video_frame_unittest.cc
index d65dd483fe..b7d8c300c3 100644
--- a/common_video/video_frame_unittest.cc
+++ b/common_video/video_frame_unittest.cc
@@ -489,10 +489,10 @@ TEST_P(TestPlanarYuvBuffer, PastesIntoBuffer) {
   }
 }
 
-INSTANTIATE_TEST_CASE_P(,
-                        TestPlanarYuvBuffer,
-                        ::testing::Values(VideoFrameBuffer::Type::kI420,
-                                          VideoFrameBuffer::Type::kI010));
+INSTANTIATE_TEST_SUITE_P(,
+                         TestPlanarYuvBuffer,
+                         ::testing::Values(VideoFrameBuffer::Type::kI420,
+                                           VideoFrameBuffer::Type::kI010));
 
 class TestPlanarYuvBufferRotate
     : public ::testing::TestWithParam<
@@ -507,7 +507,7 @@ TEST_P(TestPlanarYuvBufferRotate, Rotates) {
   CheckRotate(640, 480, rotation, *rotated_buffer->ToI420());
 }
 
-INSTANTIATE_TEST_CASE_P(
+INSTANTIATE_TEST_SUITE_P(
     Rotate,
     TestPlanarYuvBufferRotate,
     ::testing::Combine(::testing::Values(kVideoRotation_0,
diff --git a/logging/rtc_event_log/encoder/delta_encoding_unittest.cc b/logging/rtc_event_log/encoder/delta_encoding_unittest.cc
index ca44010eda..b385b8998a 100644
--- a/logging/rtc_event_log/encoder/delta_encoding_unittest.cc
+++ b/logging/rtc_event_log/encoder/delta_encoding_unittest.cc
@@ -443,7 +443,7 @@ TEST_P(DeltaEncodingTest, ZeroDelta) {
   TestEncodingAndDecoding(base, values);
 }
 
-INSTANTIATE_TEST_CASE_P(
+INSTANTIATE_TEST_SUITE_P(
     SignednessOverrideAndNumberOfValuesInSequence,
     DeltaEncodingTest,
     ::testing::Combine(::testing::Values(DeltaSignedness::kNoOverride,
@@ -555,7 +555,7 @@ TEST_P(DeltaEncodingCompressionQualityTest,
   }
 }
 
-INSTANTIATE_TEST_CASE_P(
+INSTANTIATE_TEST_SUITE_P(
     SignednessOverrideAndDeltaMaxBitWidthAndNumberOfValuesInSequence,
     DeltaEncodingCompressionQualityTest,
     ::testing::Combine(
@@ -616,7 +616,7 @@ TEST_P(DeltaEncodingFuzzerLikeTest, Test) {
   TestEncodingAndDecoding(base, values);
 }
 
-INSTANTIATE_TEST_CASE_P(
+INSTANTIATE_TEST_SUITE_P(
     SignednessOverrideAndDeltaMaxBitWidthAndNumberOfValuesInSequence,
     DeltaEncodingFuzzerLikeTest,
     ::testing::Combine(
@@ -679,7 +679,7 @@ TEST_P(DeltaEncodingSpecificEdgeCasesTest, ReverseSequence) {
   TestEncodingAndDecoding(base, values);
 }
 
-INSTANTIATE_TEST_CASE_P(
+INSTANTIATE_TEST_SUITE_P(
     _,
     DeltaEncodingSpecificEdgeCasesTest,
     ::testing::Combine(
diff --git a/logging/rtc_event_log/encoder/rtc_event_log_encoder_common_unittest.cc b/logging/rtc_event_log/encoder/rtc_event_log_encoder_common_unittest.cc
index 54735d8e2c..8a44a6dc2b 100644
--- a/logging/rtc_event_log/encoder/rtc_event_log_encoder_common_unittest.cc
+++ b/logging/rtc_event_log/encoder/rtc_event_log_encoder_common_unittest.cc
@@ -27,7 +27,7 @@ class SignednessConversionTest : public testing::Test {
   static_assert(std::is_signed<T>::value, "");
 };
 
-TYPED_TEST_CASE_P(SignednessConversionTest);
+TYPED_TEST_SUITE_P(SignednessConversionTest);
 
 TYPED_TEST_P(SignednessConversionTest, CorrectlyConvertsLegalValues) {
   using T = TypeParam;
@@ -72,13 +72,13 @@ TYPED_TEST_P(SignednessConversionTest, FailsOnConvertingIllegalValues) {
   }
 }
 
-REGISTER_TYPED_TEST_CASE_P(SignednessConversionTest,
-                           CorrectlyConvertsLegalValues,
-                           FailsOnConvertingIllegalValues);
+REGISTER_TYPED_TEST_SUITE_P(SignednessConversionTest,
+                            CorrectlyConvertsLegalValues,
+                            FailsOnConvertingIllegalValues);
 
 using Types = ::testing::Types<int8_t, int16_t, int32_t, int64_t>;
 
-INSTANTIATE_TYPED_TEST_CASE_P(_, SignednessConversionTest, Types);
+INSTANTIATE_TYPED_TEST_SUITE_P(_, SignednessConversionTest, Types);
 
 }  // namespace
 }  // namespace webrtc_event_logging
diff --git a/logging/rtc_event_log/encoder/rtc_event_log_encoder_unittest.cc b/logging/rtc_event_log/encoder/rtc_event_log_encoder_unittest.cc
index 210fa6a6c4..79bf04582f 100644
--- a/logging/rtc_event_log/encoder/rtc_event_log_encoder_unittest.cc
+++ b/logging/rtc_event_log/encoder/rtc_event_log_encoder_unittest.cc
@@ -939,7 +939,7 @@ TEST_P(RtcEventLogEncoderTest, RtcEventVideoSendStreamConfig) {
   verifier_.VerifyLoggedVideoSendConfig(*event, video_send_configs[0]);
 }
 
-INSTANTIATE_TEST_CASE_P(
+INSTANTIATE_TEST_SUITE_P(
     RandomSeeds,
     RtcEventLogEncoderTest,
     ::testing::Combine(/* Random seed*: */ ::testing::Values(1, 2, 3, 4, 5),
diff --git a/logging/rtc_event_log/rtc_event_log_unittest.cc b/logging/rtc_event_log/rtc_event_log_unittest.cc
index ec68ad2461..f44f53e83c 100644
--- a/logging/rtc_event_log/rtc_event_log_unittest.cc
+++ b/logging/rtc_event_log/rtc_event_log_unittest.cc
@@ -725,7 +725,7 @@ TEST_P(RtcEventLogSession, StartLoggingInTheMiddle) {
   ReadAndVerifyLog();
 }
 
-INSTANTIATE_TEST_CASE_P(
+INSTANTIATE_TEST_SUITE_P(
     RtcEventLogTest,
     RtcEventLogSession,
     ::testing::Combine(
@@ -822,7 +822,7 @@ TEST_P(RtcEventLogCircularBufferTest, KeepsMostRecentEvents) {
   }
 }
 
-INSTANTIATE_TEST_CASE_P(
+INSTANTIATE_TEST_SUITE_P(
     RtcEventLogTest,
     RtcEventLogCircularBufferTest,
     ::testing::Values(RtcEventLog::EncodingType::Legacy,
diff --git a/media/base/video_adapter_unittest.cc b/media/base/video_adapter_unittest.cc
index f50e13b11c..c156264ce9 100644
--- a/media/base/video_adapter_unittest.cc
+++ b/media/base/video_adapter_unittest.cc
@@ -125,9 +125,9 @@ class VideoAdapterTest : public testing::Test,
   const bool use_new_format_request_;
 };
 
-INSTANTIATE_TEST_CASE_P(OnOutputFormatRequests,
-                        VideoAdapterTest,
-                        ::testing::Values(true, false));
+INSTANTIATE_TEST_SUITE_P(OnOutputFormatRequests,
+                         VideoAdapterTest,
+                         ::testing::Values(true, false));
 
 // Do not adapt the frame rate or the resolution. Expect no frame drop, no
 // cropping, and no resolution change.
diff --git a/modules/audio_coding/codecs/builtin_audio_encoder_factory_unittest.cc b/modules/audio_coding/codecs/builtin_audio_encoder_factory_unittest.cc
index 6d1cbc6514..a548be8086 100644
--- a/modules/audio_coding/codecs/builtin_audio_encoder_factory_unittest.cc
+++ b/modules/audio_coding/codecs/builtin_audio_encoder_factory_unittest.cc
@@ -103,9 +103,9 @@ TEST_P(AudioEncoderFactoryTest, CanRunAllSupportedEncoders) {
   }
 }
 
-INSTANTIATE_TEST_CASE_P(BuiltinAudioEncoderFactoryTest,
-                        AudioEncoderFactoryTest,
-                        ::testing::Values(CreateBuiltinAudioEncoderFactory()));
+INSTANTIATE_TEST_SUITE_P(BuiltinAudioEncoderFactoryTest,
+                         AudioEncoderFactoryTest,
+                         ::testing::Values(CreateBuiltinAudioEncoderFactory()));
 
 TEST(BuiltinAudioEncoderFactoryTest, SupportsTheExpectedFormats) {
   using ::testing::ElementsAreArray;
diff --git a/modules/audio_coding/codecs/ilbc/ilbc_unittest.cc b/modules/audio_coding/codecs/ilbc/ilbc_unittest.cc
index 5ec1219b3b..689292f131 100644
--- a/modules/audio_coding/codecs/ilbc/ilbc_unittest.cc
+++ b/modules/audio_coding/codecs/ilbc/ilbc_unittest.cc
@@ -103,7 +103,7 @@ TEST_P(SplitIlbcTest, NumFrames) {
 // Also test the maximum number of frames in one packet for 20 and 30 ms.
 // The maximum is defined by the largest payload length that can be uniquely
 // resolved to a frame size of either 38 bytes (20 ms) or 50 bytes (30 ms).
-INSTANTIATE_TEST_CASE_P(
+INSTANTIATE_TEST_SUITE_P(
     IlbcTest,
     SplitIlbcTest,
     ::testing::Values(std::pair<int, int>(1, 20),  // 1 frame, 20 ms.
diff --git a/modules/audio_coding/codecs/isac/fix/test/isac_speed_test.cc b/modules/audio_coding/codecs/isac/fix/test/isac_speed_test.cc
index aeca2e8e31..20752639fc 100644
--- a/modules/audio_coding/codecs/isac/fix/test/isac_speed_test.cc
+++ b/modules/audio_coding/codecs/isac/fix/test/isac_speed_test.cc
@@ -112,6 +112,8 @@ const coding_param param_set[] = {
                     string("pcm"),
                     true)};
 
-INSTANTIATE_TEST_CASE_P(AllTest, IsacSpeedTest, ::testing::ValuesIn(param_set));
+INSTANTIATE_TEST_SUITE_P(AllTest,
+                         IsacSpeedTest,
+                         ::testing::ValuesIn(param_set));
 
 }  // namespace webrtc
diff --git a/modules/audio_coding/codecs/isac/unittest.cc b/modules/audio_coding/codecs/isac/unittest.cc
index 6791745eaf..076510be2a 100644
--- a/modules/audio_coding/codecs/isac/unittest.cc
+++ b/modules/audio_coding/codecs/isac/unittest.cc
@@ -252,6 +252,6 @@ std::vector<IsacTestParam> TestCases() {
   return cases;
 }
 
-INSTANTIATE_TEST_CASE_P(, IsacCommonTest, testing::ValuesIn(TestCases()));
+INSTANTIATE_TEST_SUITE_P(, IsacCommonTest, testing::ValuesIn(TestCases()));
 
 }  // namespace webrtc
diff --git a/modules/audio_coding/codecs/legacy_encoded_audio_frame_unittest.cc b/modules/audio_coding/codecs/legacy_encoded_audio_frame_unittest.cc
index 54a362d59e..2ca1d4ca98 100644
--- a/modules/audio_coding/codecs/legacy_encoded_audio_frame_unittest.cc
+++ b/modules/audio_coding/codecs/legacy_encoded_audio_frame_unittest.cc
@@ -160,7 +160,7 @@ TEST_P(SplitBySamplesTest, PayloadSizes) {
   }
 }
 
-INSTANTIATE_TEST_CASE_P(
+INSTANTIATE_TEST_SUITE_P(
     LegacyEncodedAudioFrame,
     SplitBySamplesTest,
     ::testing::Values(NetEqDecoder::kDecoderPCMu,
diff --git a/modules/audio_coding/codecs/opus/opus_fec_test.cc b/modules/audio_coding/codecs/opus/opus_fec_test.cc
index cd70821daf..7552c20f55 100644
--- a/modules/audio_coding/codecs/opus/opus_fec_test.cc
+++ b/modules/audio_coding/codecs/opus/opus_fec_test.cc
@@ -238,6 +238,6 @@ const coding_param param_set[] = {
                     string("pcm"))};
 
 // 64 kbps, stereo
-INSTANTIATE_TEST_CASE_P(AllTest, OpusFecTest, ::testing::ValuesIn(param_set));
+INSTANTIATE_TEST_SUITE_P(AllTest, OpusFecTest, ::testing::ValuesIn(param_set));
 
 }  // namespace webrtc
diff --git a/modules/audio_coding/codecs/opus/opus_speed_test.cc b/modules/audio_coding/codecs/opus/opus_speed_test.cc
index 03b59ed32e..bf757f6433 100644
--- a/modules/audio_coding/codecs/opus/opus_speed_test.cc
+++ b/modules/audio_coding/codecs/opus/opus_speed_test.cc
@@ -140,6 +140,8 @@ const coding_param param_set[] = {
                     string("pcm"),
                     true)};
 
-INSTANTIATE_TEST_CASE_P(AllTest, OpusSpeedTest, ::testing::ValuesIn(param_set));
+INSTANTIATE_TEST_SUITE_P(AllTest,
+                         OpusSpeedTest,
+                         ::testing::ValuesIn(param_set));
 
 }  // namespace webrtc
diff --git a/modules/audio_coding/codecs/opus/opus_unittest.cc b/modules/audio_coding/codecs/opus/opus_unittest.cc
index de088271b3..56dfd6a257 100644
--- a/modules/audio_coding/codecs/opus/opus_unittest.cc
+++ b/modules/audio_coding/codecs/opus/opus_unittest.cc
@@ -810,8 +810,8 @@ TEST_P(OpusTest, OpusDecodeRepacketized) {
   EXPECT_EQ(0, WebRtcOpus_DecoderFree(opus_decoder_));
 }
 
-INSTANTIATE_TEST_CASE_P(VariousMode,
-                        OpusTest,
-                        Combine(Values(1, 2, 4), Values(0, 1)));
+INSTANTIATE_TEST_SUITE_P(VariousMode,
+                         OpusTest,
+                         Combine(Values(1, 2, 4), Values(0, 1)));
 
 }  // namespace webrtc
diff --git a/modules/audio_coding/codecs/opus/test/audio_ring_buffer_unittest.cc b/modules/audio_coding/codecs/opus/test/audio_ring_buffer_unittest.cc
index e26df3a83c..5c44bc563f 100644
--- a/modules/audio_coding/codecs/opus/test/audio_ring_buffer_unittest.cc
+++ b/modules/audio_coding/codecs/opus/test/audio_ring_buffer_unittest.cc
@@ -82,7 +82,7 @@ TEST_P(AudioRingBufferTest, ReadDataMatchesWrittenData) {
       EXPECT_EQ(input.channels()[i][j], output.channels()[i][j]);
 }
 
-INSTANTIATE_TEST_CASE_P(
+INSTANTIATE_TEST_SUITE_P(
     AudioRingBufferTest,
     AudioRingBufferTest,
     ::testing::Combine(::testing::Values(10, 20, 42),  // num_write_chunk_frames
diff --git a/modules/audio_coding/neteq/audio_multi_vector_unittest.cc b/modules/audio_coding/neteq/audio_multi_vector_unittest.cc
index 5b2ec20ec8..d1351d8210 100644
--- a/modules/audio_coding/neteq/audio_multi_vector_unittest.cc
+++ b/modules/audio_coding/neteq/audio_multi_vector_unittest.cc
@@ -309,9 +309,9 @@ TEST_P(AudioMultiVectorTest, CopyChannel) {
   }
 }
 
-INSTANTIATE_TEST_CASE_P(TestNumChannels,
-                        AudioMultiVectorTest,
-                        ::testing::Values(static_cast<size_t>(1),
-                                          static_cast<size_t>(2),
-                                          static_cast<size_t>(5)));
+INSTANTIATE_TEST_SUITE_P(TestNumChannels,
+                         AudioMultiVectorTest,
+                         ::testing::Values(static_cast<size_t>(1),
+                                           static_cast<size_t>(2),
+                                           static_cast<size_t>(5)));
 }  // namespace webrtc
diff --git a/modules/audio_coding/neteq/neteq_stereo_unittest.cc b/modules/audio_coding/neteq/neteq_stereo_unittest.cc
index 289a38d9d2..d25e8d6824 100644
--- a/modules/audio_coding/neteq/neteq_stereo_unittest.cc
+++ b/modules/audio_coding/neteq/neteq_stereo_unittest.cc
@@ -364,24 +364,24 @@ void PrintTo(const TestParameters& p, ::std::ostream* os) {
 
 // Instantiate the tests. Each test is instantiated using the function above,
 // so that all different parameter combinations are tested.
-INSTANTIATE_TEST_CASE_P(MultiChannel,
-                        NetEqStereoTestNoJitter,
-                        ::testing::ValuesIn(GetTestParameters()));
+INSTANTIATE_TEST_SUITE_P(MultiChannel,
+                         NetEqStereoTestNoJitter,
+                         ::testing::ValuesIn(GetTestParameters()));
 
-INSTANTIATE_TEST_CASE_P(MultiChannel,
-                        NetEqStereoTestPositiveDrift,
-                        ::testing::ValuesIn(GetTestParameters()));
+INSTANTIATE_TEST_SUITE_P(MultiChannel,
+                         NetEqStereoTestPositiveDrift,
+                         ::testing::ValuesIn(GetTestParameters()));
 
-INSTANTIATE_TEST_CASE_P(MultiChannel,
-                        NetEqStereoTestNegativeDrift,
-                        ::testing::ValuesIn(GetTestParameters()));
+INSTANTIATE_TEST_SUITE_P(MultiChannel,
+                         NetEqStereoTestNegativeDrift,
+                         ::testing::ValuesIn(GetTestParameters()));
 
-INSTANTIATE_TEST_CASE_P(MultiChannel,
-                        NetEqStereoTestDelays,
-                        ::testing::ValuesIn(GetTestParameters()));
+INSTANTIATE_TEST_SUITE_P(MultiChannel,
+                         NetEqStereoTestDelays,
+                         ::testing::ValuesIn(GetTestParameters()));
 
-INSTANTIATE_TEST_CASE_P(MultiChannel,
-                        NetEqStereoTestLosses,
-                        ::testing::ValuesIn(GetTestParameters()));
+INSTANTIATE_TEST_SUITE_P(MultiChannel,
+                         NetEqStereoTestLosses,
+                         ::testing::ValuesIn(GetTestParameters()));
 
 }  // namespace webrtc
diff --git a/modules/audio_device/audio_device_unittest.cc b/modules/audio_device/audio_device_unittest.cc
index 9fcc4d8f5b..846f75745f 100644
--- a/modules/audio_device/audio_device_unittest.cc
+++ b/modules/audio_device/audio_device_unittest.cc
@@ -1112,14 +1112,14 @@ TEST_P(AudioDeviceTest, DISABLED_MeasureLoopbackLatency) {
 #ifdef WEBRTC_WIN
 // Test two different audio layers (or rather two different Core Audio
 // implementations) for Windows.
-INSTANTIATE_TEST_CASE_P(
+INSTANTIATE_TEST_SUITE_P(
     AudioLayerWin,
     AudioDeviceTest,
     ::testing::Values(AudioDeviceModule::kPlatformDefaultAudio,
                       AudioDeviceModule::kWindowsCoreAudio2));
 #else
 // For all platforms but Windows, only test the default audio layer.
-INSTANTIATE_TEST_CASE_P(
+INSTANTIATE_TEST_SUITE_P(
     AudioLayer,
     AudioDeviceTest,
     ::testing::Values(AudioDeviceModule::kPlatformDefaultAudio));
diff --git a/modules/audio_processing/agc2/rnn_vad/pitch_search_internal_unittest.cc b/modules/audio_processing/agc2/rnn_vad/pitch_search_internal_unittest.cc
index 033ea3e77f..8ff6ac1c12 100644
--- a/modules/audio_processing/agc2/rnn_vad/pitch_search_internal_unittest.cc
+++ b/modules/audio_processing/agc2/rnn_vad/pitch_search_internal_unittest.cc
@@ -88,7 +88,7 @@ TEST_P(ComputePitchGainThresholdTest, BitExactness) {
   }
 }
 
-INSTANTIATE_TEST_CASE_P(
+INSTANTIATE_TEST_SUITE_P(
     RnnVadTest,
     ComputePitchGainThresholdTest,
     ::testing::Values(
@@ -219,48 +219,48 @@ TEST_P(CheckLowerPitchPeriodsAndComputePitchGainTest, BitExactness) {
   }
 }
 
-INSTANTIATE_TEST_CASE_P(RnnVadTest,
-                        CheckLowerPitchPeriodsAndComputePitchGainTest,
-                        ::testing::Values(std::make_tuple(kTestPitchPeriods[0],
-                                                          kTestPitchPeriods[0],
-                                                          kTestPitchGains[0],
-                                                          91,
-                                                          -0.0188608f),
-                                          std::make_tuple(kTestPitchPeriods[0],
-                                                          kTestPitchPeriods[0],
-                                                          kTestPitchGains[1],
-                                                          91,
-                                                          -0.0188608f),
-                                          std::make_tuple(kTestPitchPeriods[0],
-                                                          kTestPitchPeriods[1],
-                                                          kTestPitchGains[0],
-                                                          91,
-                                                          -0.0188608f),
-                                          std::make_tuple(kTestPitchPeriods[0],
-                                                          kTestPitchPeriods[1],
-                                                          kTestPitchGains[1],
-                                                          91,
-                                                          -0.0188608f),
-                                          std::make_tuple(kTestPitchPeriods[1],
-                                                          kTestPitchPeriods[0],
-                                                          kTestPitchGains[0],
-                                                          475,
-                                                          -0.0904344f),
-                                          std::make_tuple(kTestPitchPeriods[1],
-                                                          kTestPitchPeriods[0],
-                                                          kTestPitchGains[1],
-                                                          475,
-                                                          -0.0904344f),
-                                          std::make_tuple(kTestPitchPeriods[1],
-                                                          kTestPitchPeriods[1],
-                                                          kTestPitchGains[0],
-                                                          475,
-                                                          -0.0904344f),
-                                          std::make_tuple(kTestPitchPeriods[1],
-                                                          kTestPitchPeriods[1],
-                                                          kTestPitchGains[1],
-                                                          475,
-                                                          -0.0904344f)));
+INSTANTIATE_TEST_SUITE_P(RnnVadTest,
+                         CheckLowerPitchPeriodsAndComputePitchGainTest,
+                         ::testing::Values(std::make_tuple(kTestPitchPeriods[0],
+                                                           kTestPitchPeriods[0],
+                                                           kTestPitchGains[0],
+                                                           91,
+                                                           -0.0188608f),
+                                           std::make_tuple(kTestPitchPeriods[0],
+                                                           kTestPitchPeriods[0],
+                                                           kTestPitchGains[1],
+                                                           91,
+                                                           -0.0188608f),
+                                           std::make_tuple(kTestPitchPeriods[0],
+                                                           kTestPitchPeriods[1],
+                                                           kTestPitchGains[0],
+                                                           91,
+                                                           -0.0188608f),
+                                           std::make_tuple(kTestPitchPeriods[0],
+                                                           kTestPitchPeriods[1],
+                                                           kTestPitchGains[1],
+                                                           91,
+                                                           -0.0188608f),
+                                           std::make_tuple(kTestPitchPeriods[1],
+                                                           kTestPitchPeriods[0],
+                                                           kTestPitchGains[0],
+                                                           475,
+                                                           -0.0904344f),
+                                           std::make_tuple(kTestPitchPeriods[1],
+                                                           kTestPitchPeriods[0],
+                                                           kTestPitchGains[1],
+                                                           475,
+                                                           -0.0904344f),
+                                           std::make_tuple(kTestPitchPeriods[1],
+                                                           kTestPitchPeriods[1],
+                                                           kTestPitchGains[0],
+                                                           475,
+                                                           -0.0904344f),
+                                           std::make_tuple(kTestPitchPeriods[1],
+                                                           kTestPitchPeriods[1],
+                                                           kTestPitchGains[1],
+                                                           475,
+                                                           -0.0904344f)));
 
 }  // namespace test
 }  // namespace rnn_vad
diff --git a/modules/audio_processing/audio_processing_impl_locking_unittest.cc b/modules/audio_processing/audio_processing_impl_locking_unittest.cc
index 6d1de620c0..828e2e7721 100644
--- a/modules/audio_processing/audio_processing_impl_locking_unittest.cc
+++ b/modules/audio_processing/audio_processing_impl_locking_unittest.cc
@@ -1109,12 +1109,12 @@ TEST_P(AudioProcessingImplLockTest, LockTest) {
 }
 
 // Instantiate tests from the extreme test configuration set.
-INSTANTIATE_TEST_CASE_P(
+INSTANTIATE_TEST_SUITE_P(
     DISABLED_AudioProcessingImplLockExtensive,
     AudioProcessingImplLockTest,
     ::testing::ValuesIn(TestConfig::GenerateExtensiveTestConfigs()));
 
-INSTANTIATE_TEST_CASE_P(
+INSTANTIATE_TEST_SUITE_P(
     AudioProcessingImplLockBrief,
     AudioProcessingImplLockTest,
     ::testing::ValuesIn(TestConfig::GenerateBriefTestConfigs()));
diff --git a/modules/audio_processing/audio_processing_performance_unittest.cc b/modules/audio_processing/audio_processing_performance_unittest.cc
index fa0f1da71e..70c91c4147 100644
--- a/modules/audio_processing/audio_processing_performance_unittest.cc
+++ b/modules/audio_processing/audio_processing_performance_unittest.cc
@@ -621,7 +621,7 @@ TEST_P(CallSimulator, DISABLED_ApiCallDurationTest) {
   EXPECT_TRUE(Run());
 }
 
-INSTANTIATE_TEST_CASE_P(
+INSTANTIATE_TEST_SUITE_P(
     AudioProcessingPerformanceTest,
     CallSimulator,
     ::testing::ValuesIn(SimulationConfig::GenerateSimulationConfigs()));
diff --git a/modules/audio_processing/audio_processing_unittest.cc b/modules/audio_processing/audio_processing_unittest.cc
index 6ae6765378..5ca0f74ebb 100644
--- a/modules/audio_processing/audio_processing_unittest.cc
+++ b/modules/audio_processing/audio_processing_unittest.cc
@@ -2413,7 +2413,7 @@ TEST_P(AudioProcessingTest, Formats) {
 }
 
 #if defined(WEBRTC_AUDIOPROC_FLOAT_PROFILE)
-INSTANTIATE_TEST_CASE_P(
+INSTANTIATE_TEST_SUITE_P(
     CommonFormats,
     AudioProcessingTest,
     testing::Values(std::make_tuple(48000, 48000, 48000, 48000, 0, 0),
@@ -2469,7 +2469,7 @@ INSTANTIATE_TEST_CASE_P(
                     std::make_tuple(16000, 16000, 16000, 16000, 0, 0)));
 
 #elif defined(WEBRTC_AUDIOPROC_FIXED_PROFILE)
-INSTANTIATE_TEST_CASE_P(
+INSTANTIATE_TEST_SUITE_P(
     CommonFormats,
     AudioProcessingTest,
     testing::Values(std::make_tuple(48000, 48000, 48000, 48000, 20, 0),
diff --git a/modules/audio_processing/gain_controller2_unittest.cc b/modules/audio_processing/gain_controller2_unittest.cc
index 27d540a198..258832acf5 100644
--- a/modules/audio_processing/gain_controller2_unittest.cc
+++ b/modules/audio_processing/gain_controller2_unittest.cc
@@ -227,7 +227,7 @@ TEST_P(FixedDigitalTest, CheckSaturationBehaviorWithLimiter) {
 }
 
 static_assert(test::kLimiterMaxInputLevelDbFs < 10, "");
-INSTANTIATE_TEST_CASE_P(
+INSTANTIATE_TEST_SUITE_P(
     GainController2,
     FixedDigitalTest,
     ::testing::Values(
diff --git a/modules/remote_bitrate_estimator/bwe_simulations.cc b/modules/remote_bitrate_estimator/bwe_simulations.cc
index 3beaf20ab6..68ba01cb42 100644
--- a/modules/remote_bitrate_estimator/bwe_simulations.cc
+++ b/modules/remote_bitrate_estimator/bwe_simulations.cc
@@ -50,12 +50,12 @@ class BweSimulation : public BweTest,
   RTC_DISALLOW_COPY_AND_ASSIGN(BweSimulation);
 };
 
-INSTANTIATE_TEST_CASE_P(VideoSendersTest,
-                        BweSimulation,
-                        ::testing::Values(kRembEstimator,
-                                          kSendSideEstimator,
-                                          kNadaEstimator,
-                                          kBbrEstimator));
+INSTANTIATE_TEST_SUITE_P(VideoSendersTest,
+                         BweSimulation,
+                         ::testing::Values(kRembEstimator,
+                                           kSendSideEstimator,
+                                           kNadaEstimator,
+                                           kBbrEstimator));
 
 TEST_P(BweSimulation, SprintUplinkTest) {
   AdaptiveVideoSource source(0, 30, 300, 0, 0);
diff --git a/modules/remote_bitrate_estimator/remote_bitrate_estimators_test.cc b/modules/remote_bitrate_estimator/remote_bitrate_estimators_test.cc
index 1d03038b0d..f58e9d3995 100644
--- a/modules/remote_bitrate_estimator/remote_bitrate_estimators_test.cc
+++ b/modules/remote_bitrate_estimator/remote_bitrate_estimators_test.cc
@@ -56,9 +56,9 @@ class BweFeedbackTest
   RTC_DISALLOW_COPY_AND_ASSIGN(BweFeedbackTest);
 };
 
-INSTANTIATE_TEST_CASE_P(VideoSendersTest,
-                        BweFeedbackTest,
-                        ::testing::Values(kRembEstimator, kSendSideEstimator));
+INSTANTIATE_TEST_SUITE_P(VideoSendersTest,
+                         BweFeedbackTest,
+                         ::testing::Values(kRembEstimator, kSendSideEstimator));
 
 TEST_P(BweFeedbackTest, ConstantCapacity) {
   AdaptiveVideoSource source(0, 30, 300, 0, 0);
diff --git a/modules/rtp_rtcp/source/rtp_fec_unittest.cc b/modules/rtp_rtcp/source/rtp_fec_unittest.cc
index cbad0aed4a..d260db4166 100644
--- a/modules/rtp_rtcp/source/rtp_fec_unittest.cc
+++ b/modules/rtp_rtcp/source/rtp_fec_unittest.cc
@@ -216,7 +216,7 @@ class UlpfecForwardErrorCorrection : public ForwardErrorCorrection {
 
 using FecTypes =
     Types<FlexfecForwardErrorCorrection, UlpfecForwardErrorCorrection>;
-TYPED_TEST_CASE(RtpFecTest, FecTypes);
+TYPED_TEST_SUITE(RtpFecTest, FecTypes);
 
 TYPED_TEST(RtpFecTest, WillProtectMediaPacketsWithLargeSequenceNumberGap) {
   constexpr int kNumImportantPackets = 0;
diff --git a/modules/rtp_rtcp/source/rtp_format_h264_unittest.cc b/modules/rtp_rtcp/source/rtp_format_h264_unittest.cc
index 0419159dd8..7608de3e4c 100644
--- a/modules/rtp_rtcp/source/rtp_format_h264_unittest.cc
+++ b/modules/rtp_rtcp/source/rtp_format_h264_unittest.cc
@@ -202,7 +202,7 @@ TEST_P(RtpPacketizerH264ModeTest,
   EXPECT_THAT(packets, SizeIs(1));
 }
 
-INSTANTIATE_TEST_CASE_P(
+INSTANTIATE_TEST_SUITE_P(
     PacketMode,
     RtpPacketizerH264ModeTest,
     ::testing::Values(H264PacketizationMode::SingleNalUnit,
diff --git a/modules/rtp_rtcp/source/rtp_sender_unittest.cc b/modules/rtp_rtcp/source/rtp_sender_unittest.cc
index 9eafd0a4dc..0effd016b6 100644
--- a/modules/rtp_rtcp/source/rtp_sender_unittest.cc
+++ b/modules/rtp_rtcp/source/rtp_sender_unittest.cc
@@ -2286,16 +2286,16 @@ TEST_P(RtpSenderTest, SendsKeepAlive) {
   EXPECT_EQ(kSeqNum + 1, rtp_sender_->SequenceNumber());
 }
 
-INSTANTIATE_TEST_CASE_P(WithAndWithoutOverhead,
-                        RtpSenderTest,
-                        ::testing::Bool());
-INSTANTIATE_TEST_CASE_P(WithAndWithoutOverhead,
-                        RtpSenderTestWithoutPacer,
-                        ::testing::Bool());
-INSTANTIATE_TEST_CASE_P(WithAndWithoutOverhead,
-                        RtpSenderVideoTest,
-                        ::testing::Bool());
-INSTANTIATE_TEST_CASE_P(WithAndWithoutOverhead,
-                        RtpSenderAudioTest,
-                        ::testing::Bool());
+INSTANTIATE_TEST_SUITE_P(WithAndWithoutOverhead,
+                         RtpSenderTest,
+                         ::testing::Bool());
+INSTANTIATE_TEST_SUITE_P(WithAndWithoutOverhead,
+                         RtpSenderTestWithoutPacer,
+                         ::testing::Bool());
+INSTANTIATE_TEST_SUITE_P(WithAndWithoutOverhead,
+                         RtpSenderVideoTest,
+                         ::testing::Bool());
+INSTANTIATE_TEST_SUITE_P(WithAndWithoutOverhead,
+                         RtpSenderAudioTest,
+                         ::testing::Bool());
 }  // namespace webrtc
diff --git a/modules/video_coding/codecs/multiplex/test/multiplex_adapter_unittest.cc b/modules/video_coding/codecs/multiplex/test/multiplex_adapter_unittest.cc
index 4225a59314..d3757004a7 100644
--- a/modules/video_coding/codecs/multiplex/test/multiplex_adapter_unittest.cc
+++ b/modules/video_coding/codecs/multiplex/test/multiplex_adapter_unittest.cc
@@ -323,8 +323,8 @@ TEST_P(TestMultiplexAdapter, ImageIndexIncreases) {
   }
 }
 
-INSTANTIATE_TEST_CASE_P(TestMultiplexAdapter,
-                        TestMultiplexAdapter,
-                        ::testing::Bool());
+INSTANTIATE_TEST_SUITE_P(TestMultiplexAdapter,
+                         TestMultiplexAdapter,
+                         ::testing::Bool());
 
 }  // namespace webrtc
diff --git a/modules/video_coding/codecs/test/video_encoder_decoder_instantiation_tests.cc b/modules/video_coding/codecs/test/video_encoder_decoder_instantiation_tests.cc
index b4fa6a1087..71627514ae 100644
--- a/modules/video_coding/codecs/test/video_encoder_decoder_instantiation_tests.cc
+++ b/modules/video_coding/codecs/test/video_encoder_decoder_instantiation_tests.cc
@@ -96,20 +96,20 @@ class VideoEncoderDecoderInstantiationTest
   std::vector<std::unique_ptr<VideoDecoder>> decoders_;
 };
 
-INSTANTIATE_TEST_CASE_P(MultipleEncoders,
-                        VideoEncoderDecoderInstantiationTest,
-                        ::testing::Combine(::testing::Range(1, 4),
-                                           ::testing::Range(1, 2)));
-
-INSTANTIATE_TEST_CASE_P(MultipleDecoders,
-                        VideoEncoderDecoderInstantiationTest,
-                        ::testing::Combine(::testing::Range(1, 2),
-                                           ::testing::Range(1, 9)));
-
-INSTANTIATE_TEST_CASE_P(MultipleEncodersDecoders,
-                        VideoEncoderDecoderInstantiationTest,
-                        ::testing::Combine(::testing::Range(1, 4),
-                                           ::testing::Range(1, 9)));
+INSTANTIATE_TEST_SUITE_P(MultipleEncoders,
+                         VideoEncoderDecoderInstantiationTest,
+                         ::testing::Combine(::testing::Range(1, 4),
+                                            ::testing::Range(1, 2)));
+
+INSTANTIATE_TEST_SUITE_P(MultipleDecoders,
+                         VideoEncoderDecoderInstantiationTest,
+                         ::testing::Combine(::testing::Range(1, 2),
+                                            ::testing::Range(1, 9)));
+
+INSTANTIATE_TEST_SUITE_P(MultipleEncodersDecoders,
+                         VideoEncoderDecoderInstantiationTest,
+                         ::testing::Combine(::testing::Range(1, 4),
+                                            ::testing::Range(1, 9)));
 
 // TODO(brandtr): Check that the factories actually support the codecs before
 // trying to instantiate. Currently, we will just crash with a Java exception
diff --git a/modules/video_coding/codecs/test/videocodec_test_parameterized.cc b/modules/video_coding/codecs/test/videocodec_test_parameterized.cc
index 099d06cb1d..c96b132485 100644
--- a/modules/video_coding/codecs/test/videocodec_test_parameterized.cc
+++ b/modules/video_coding/codecs/test/videocodec_test_parameterized.cc
@@ -77,7 +77,7 @@ class VideoCodecTestParameterized
   const VideoCodecType codec_type_;
 };
 
-INSTANTIATE_TEST_CASE_P(
+INSTANTIATE_TEST_SUITE_P(
     CodecSettings,
     VideoCodecTestParameterized,
     ::testing::Combine(::testing::ValuesIn(kBitrates),
diff --git a/modules/video_coding/codecs/vp8/default_temporal_layers_unittest.cc b/modules/video_coding/codecs/vp8/default_temporal_layers_unittest.cc
index d2ddac3e40..e408ee170c 100644
--- a/modules/video_coding/codecs/vp8/default_temporal_layers_unittest.cc
+++ b/modules/video_coding/codecs/vp8/default_temporal_layers_unittest.cc
@@ -713,9 +713,9 @@ class TemporalLayersReferenceTest : public TemporalLayersTest,
   BufferState altref_state;
 };
 
-INSTANTIATE_TEST_CASE_P(DefaultTemporalLayersTest,
-                        TemporalLayersReferenceTest,
-                        ::testing::Range(1, kMaxTemporalStreams + 1));
+INSTANTIATE_TEST_SUITE_P(DefaultTemporalLayersTest,
+                         TemporalLayersReferenceTest,
+                         ::testing::Range(1, kMaxTemporalStreams + 1));
 
 TEST_P(TemporalLayersReferenceTest, ValidFrameConfigs) {
   const int num_layers = GetParam();
diff --git a/modules/video_coding/codecs/vp9/svc_rate_allocator_unittest.cc b/modules/video_coding/codecs/vp9/svc_rate_allocator_unittest.cc
index dd40057ff9..e1e1df7aeb 100644
--- a/modules/video_coding/codecs/vp9/svc_rate_allocator_unittest.cc
+++ b/modules/video_coding/codecs/vp9/svc_rate_allocator_unittest.cc
@@ -254,8 +254,8 @@ TEST_P(SvcRateAllocatorTestParametrizedContentType, PaddingBitrate) {
   EXPECT_EQ(allocation.GetSpatialLayerSum(2), 0UL);
 }
 
-INSTANTIATE_TEST_CASE_P(_,
-                        SvcRateAllocatorTestParametrizedContentType,
-                        ::testing::Bool());
+INSTANTIATE_TEST_SUITE_P(_,
+                         SvcRateAllocatorTestParametrizedContentType,
+                         ::testing::Bool());
 
 }  // namespace webrtc
diff --git a/modules/video_coding/codecs/vp9/test/vp9_impl_unittest.cc b/modules/video_coding/codecs/vp9/test/vp9_impl_unittest.cc
index 48f81b83e1..d03e196894 100644
--- a/modules/video_coding/codecs/vp9/test/vp9_impl_unittest.cc
+++ b/modules/video_coding/codecs/vp9/test/vp9_impl_unittest.cc
@@ -1238,10 +1238,10 @@ TEST_P(TestVp9ImplWithLayering, ExternalRefControl) {
   }
 }
 
-INSTANTIATE_TEST_CASE_P(,
-                        TestVp9ImplWithLayering,
-                        ::testing::Combine(::testing::Values(1, 2, 3),
-                                           ::testing::Values(1, 2, 3)));
+INSTANTIATE_TEST_SUITE_P(,
+                         TestVp9ImplWithLayering,
+                         ::testing::Combine(::testing::Values(1, 2, 3),
+                                            ::testing::Values(1, 2, 3)));
 
 class TestVp9ImplFrameDropping : public TestVp9Impl {
  protected:
diff --git a/modules/video_coding/utility/quality_scaler_unittest.cc b/modules/video_coding/utility/quality_scaler_unittest.cc
index 9fc0290149..c9789eaae7 100644
--- a/modules/video_coding/utility/quality_scaler_unittest.cc
+++ b/modules/video_coding/utility/quality_scaler_unittest.cc
@@ -117,7 +117,7 @@ class QualityScalerTest : public ::testing::Test,
   std::unique_ptr<MockAdaptationObserver> observer_;
 };
 
-INSTANTIATE_TEST_CASE_P(
+INSTANTIATE_TEST_SUITE_P(
     FieldTrials,
     QualityScalerTest,
     ::testing::Values(
diff --git a/modules/video_coding/utility/simulcast_rate_allocator_unittest.cc b/modules/video_coding/utility/simulcast_rate_allocator_unittest.cc
index 46098f4ad3..690c3faaab 100644
--- a/modules/video_coding/utility/simulcast_rate_allocator_unittest.cc
+++ b/modules/video_coding/utility/simulcast_rate_allocator_unittest.cc
@@ -538,9 +538,9 @@ class ScreenshareRateAllocationTest : public SimulcastRateAllocatorTest {
   }
 };
 
-INSTANTIATE_TEST_CASE_P(ScreenshareTest,
-                        ScreenshareRateAllocationTest,
-                        ::testing::Bool());
+INSTANTIATE_TEST_SUITE_P(ScreenshareTest,
+                         ScreenshareRateAllocationTest,
+                         ::testing::Bool());
 
 TEST_P(ScreenshareRateAllocationTest, BitrateBelowTl0) {
   SetupConferenceScreenshare(GetParam());
diff --git a/modules/video_coding/video_packet_buffer_unittest.cc b/modules/video_coding/video_packet_buffer_unittest.cc
index 190e0e78eb..b8d6a6b543 100644
--- a/modules/video_coding/video_packet_buffer_unittest.cc
+++ b/modules/video_coding/video_packet_buffer_unittest.cc
@@ -583,9 +583,9 @@ class TestPacketBufferH264Parameterized
   TestPacketBufferH264Parameterized() : TestPacketBufferH264(GetParam()) {}
 };
 
-INSTANTIATE_TEST_CASE_P(SpsPpsIdrIsKeyframe,
-                        TestPacketBufferH264Parameterized,
-                        ::testing::Values(false, true));
+INSTANTIATE_TEST_SUITE_P(SpsPpsIdrIsKeyframe,
+                         TestPacketBufferH264Parameterized,
+                         ::testing::Values(false, true));
 
 TEST_P(TestPacketBufferH264Parameterized, DontRemoveMissingPacketOnClearTo) {
   EXPECT_TRUE(InsertH264(0, kKeyFrame, kFirst, kLast, 0));
diff --git a/p2p/base/dtls_transport_unittest.cc b/p2p/base/dtls_transport_unittest.cc
index f1ee1e00ea..f85965d365 100644
--- a/p2p/base/dtls_transport_unittest.cc
+++ b/p2p/base/dtls_transport_unittest.cc
@@ -455,7 +455,7 @@ TEST_P(DtlsTransportVersionTest, TestCipherSuiteNegotiation) {
 }
 
 // Will test every combination of 1.0/1.2 on the client and server.
-INSTANTIATE_TEST_CASE_P(
+INSTANTIATE_TEST_SUITE_P(
     TestCipherSuiteNegotiation,
     DtlsTransportVersionTest,
     ::testing::Combine(::testing::Values(rtc::SSL_PROTOCOL_DTLS_10,
@@ -707,7 +707,7 @@ TEST_P(DtlsEventOrderingTest, TestEventOrdering) {
                     ::testing::get<1>(GetParam()));
 }
 
-INSTANTIATE_TEST_CASE_P(
+INSTANTIATE_TEST_SUITE_P(
     TestEventOrdering,
     DtlsEventOrderingTest,
     ::testing::Combine(
diff --git a/pc/jsep_session_description_unittest.cc b/pc/jsep_session_description_unittest.cc
index 2eb1db0528..4dc0788fb7 100644
--- a/pc/jsep_session_description_unittest.cc
+++ b/pc/jsep_session_description_unittest.cc
@@ -425,8 +425,8 @@ TEST_P(EnumerateAllSdpTypesTest, TestIdentity) {
   EXPECT_EQ(type, webrtc::SdpTypeFromString(str));
 }
 
-INSTANTIATE_TEST_CASE_P(JsepSessionDescriptionTest,
-                        EnumerateAllSdpTypesTest,
-                        Values(SdpType::kOffer,
-                               SdpType::kPrAnswer,
-                               SdpType::kAnswer));
+INSTANTIATE_TEST_SUITE_P(JsepSessionDescriptionTest,
+                         EnumerateAllSdpTypesTest,
+                         Values(SdpType::kOffer,
+                                SdpType::kPrAnswer,
+                                SdpType::kAnswer));
diff --git a/pc/jsep_transport_unittest.cc b/pc/jsep_transport_unittest.cc
index efb2394eee..9ed079ba5d 100644
--- a/pc/jsep_transport_unittest.cc
+++ b/pc/jsep_transport_unittest.cc
@@ -638,9 +638,9 @@ TEST_P(JsepTransport2WithRtcpMux, InvalidDtlsRoleNegotiation) {
   }
 }
 
-INSTANTIATE_TEST_CASE_P(JsepTransport2Test,
-                        JsepTransport2WithRtcpMux,
-                        testing::Bool());
+INSTANTIATE_TEST_SUITE_P(JsepTransport2Test,
+                         JsepTransport2WithRtcpMux,
+                         testing::Bool());
 
 // Test that a reoffer in the opposite direction is successful as long as the
 // role isn't changing. Doesn't test every possible combination like the test
@@ -1231,7 +1231,7 @@ TEST_P(JsepTransport2HeaderExtensionTest, EncryptedHeaderExtensionNegotiation) {
   TestSendRecvPacketWithEncryptedHeaderExtension();
 }
 
-INSTANTIATE_TEST_CASE_P(
+INSTANTIATE_TEST_SUITE_P(
     JsepTransport2Test,
     JsepTransport2HeaderExtensionTest,
     ::testing::Values(
diff --git a/pc/media_session_unittest.cc b/pc/media_session_unittest.cc
index fc1cafbcb8..b0409eab11 100644
--- a/pc/media_session_unittest.cc
+++ b/pc/media_session_unittest.cc
@@ -4044,12 +4044,12 @@ TEST_P(MediaProtocolTest, TestAudioVideoAcceptance) {
   EXPECT_EQ(GetParam(), vcd->protocol());
 }
 
-INSTANTIATE_TEST_CASE_P(MediaProtocolPatternTest,
-                        MediaProtocolTest,
-                        ::testing::ValuesIn(kMediaProtocols));
-INSTANTIATE_TEST_CASE_P(MediaProtocolDtlsPatternTest,
-                        MediaProtocolTest,
-                        ::testing::ValuesIn(kMediaProtocolsDtls));
+INSTANTIATE_TEST_SUITE_P(MediaProtocolPatternTest,
+                         MediaProtocolTest,
+                         ::testing::ValuesIn(kMediaProtocols));
+INSTANTIATE_TEST_SUITE_P(MediaProtocolDtlsPatternTest,
+                         MediaProtocolTest,
+                         ::testing::ValuesIn(kMediaProtocolsDtls));
 
 TEST_F(MediaSessionDescriptionFactoryTest, TestSetAudioCodecs) {
   TransportDescriptionFactory tdf;
@@ -4372,12 +4372,12 @@ TEST_P(AudioCodecsOfferTest, TestCodecsInOffer) {
   TestAudioCodecsOffer(GetParam());
 }
 
-INSTANTIATE_TEST_CASE_P(MediaSessionDescriptionFactoryTest,
-                        AudioCodecsOfferTest,
-                        ::testing::Values(RtpTransceiverDirection::kSendOnly,
-                                          RtpTransceiverDirection::kRecvOnly,
-                                          RtpTransceiverDirection::kSendRecv,
-                                          RtpTransceiverDirection::kInactive));
+INSTANTIATE_TEST_SUITE_P(MediaSessionDescriptionFactoryTest,
+                         AudioCodecsOfferTest,
+                         ::testing::Values(RtpTransceiverDirection::kSendOnly,
+                                           RtpTransceiverDirection::kRecvOnly,
+                                           RtpTransceiverDirection::kSendRecv,
+                                           RtpTransceiverDirection::kInactive));
 
 class AudioCodecsAnswerTest
     : public ::testing::TestWithParam<::testing::tuple<RtpTransceiverDirection,
@@ -4390,7 +4390,7 @@ TEST_P(AudioCodecsAnswerTest, TestCodecsInAnswer) {
                         ::testing::get<2>(GetParam()));
 }
 
-INSTANTIATE_TEST_CASE_P(
+INSTANTIATE_TEST_SUITE_P(
     MediaSessionDescriptionFactoryTest,
     AudioCodecsAnswerTest,
     ::testing::Combine(::testing::Values(RtpTransceiverDirection::kSendOnly,
diff --git a/pc/peer_connection_bundle_unittest.cc b/pc/peer_connection_bundle_unittest.cc
index 67401a31a3..b369db23da 100644
--- a/pc/peer_connection_bundle_unittest.cc
+++ b/pc/peer_connection_bundle_unittest.cc
@@ -458,7 +458,7 @@ TEST_P(PeerConnectionBundleMatrixTest,
 // and multiplex audio/video from the start.
 // For all other policies, bundling should only be enabled if negotiated by the
 // answer.
-INSTANTIATE_TEST_CASE_P(
+INSTANTIATE_TEST_SUITE_P(
     PeerConnectionBundleTest,
     PeerConnectionBundleMatrixTest,
     Combine(Values(SdpSemantics::kPlanB, SdpSemantics::kUnifiedPlan),
@@ -861,10 +861,10 @@ TEST_P(PeerConnectionBundleTest, RemoveContentFromBundleGroup) {
       callee->SetLocalDescription(CloneSessionDescription(answer.get())));
 }
 
-INSTANTIATE_TEST_CASE_P(PeerConnectionBundleTest,
-                        PeerConnectionBundleTest,
-                        Values(SdpSemantics::kPlanB,
-                               SdpSemantics::kUnifiedPlan));
+INSTANTIATE_TEST_SUITE_P(PeerConnectionBundleTest,
+                         PeerConnectionBundleTest,
+                         Values(SdpSemantics::kPlanB,
+                                SdpSemantics::kUnifiedPlan));
 
 // According to RFC5888, if an endpoint understands the semantics of an
 // "a=group", it MUST return an answer with that group. So, an empty BUNDLE
diff --git a/pc/peer_connection_crypto_unittest.cc b/pc/peer_connection_crypto_unittest.cc
index b25aedad65..cb5c0e583f 100644
--- a/pc/peer_connection_crypto_unittest.cc
+++ b/pc/peer_connection_crypto_unittest.cc
@@ -640,7 +640,7 @@ TEST_P(PeerConnectionCryptoDtlsCertGenTest, TestCertificateGeneration) {
   }
 }
 
-INSTANTIATE_TEST_CASE_P(
+INSTANTIATE_TEST_SUITE_P(
     PeerConnectionCryptoTest,
     PeerConnectionCryptoDtlsCertGenTest,
     Combine(Values(SdpSemantics::kPlanB, SdpSemantics::kUnifiedPlan),
@@ -746,9 +746,9 @@ TEST_P(PeerConnectionCryptoTest, SessionErrorIfFingerprintInvalid) {
                       "Session error code: ERROR_CONTENT.");
 }
 
-INSTANTIATE_TEST_CASE_P(PeerConnectionCryptoTest,
-                        PeerConnectionCryptoTest,
-                        Values(SdpSemantics::kPlanB,
-                               SdpSemantics::kUnifiedPlan));
+INSTANTIATE_TEST_SUITE_P(PeerConnectionCryptoTest,
+                         PeerConnectionCryptoTest,
+                         Values(SdpSemantics::kPlanB,
+                                SdpSemantics::kUnifiedPlan));
 
 }  // namespace webrtc
diff --git a/pc/peer_connection_data_channel_unittest.cc b/pc/peer_connection_data_channel_unittest.cc
index 754ee0a92e..e0ceb72560 100644
--- a/pc/peer_connection_data_channel_unittest.cc
+++ b/pc/peer_connection_data_channel_unittest.cc
@@ -416,9 +416,9 @@ TEST_P(PeerConnectionDataChannelTest,
             "Failed to set local offer sdp: Failed to create data channel.");
 }
 
-INSTANTIATE_TEST_CASE_P(PeerConnectionDataChannelTest,
-                        PeerConnectionDataChannelTest,
-                        Values(SdpSemantics::kPlanB,
-                               SdpSemantics::kUnifiedPlan));
+INSTANTIATE_TEST_SUITE_P(PeerConnectionDataChannelTest,
+                         PeerConnectionDataChannelTest,
+                         Values(SdpSemantics::kPlanB,
+                                SdpSemantics::kUnifiedPlan));
 
 }  // namespace webrtc
diff --git a/pc/peer_connection_end_to_end_unittest.cc b/pc/peer_connection_end_to_end_unittest.cc
index dd56b26692..b01a69b0a8 100644
--- a/pc/peer_connection_end_to_end_unittest.cc
+++ b/pc/peer_connection_end_to_end_unittest.cc
@@ -726,7 +726,7 @@ TEST_P(PeerConnectionEndToEndTest, CloseDataChannelRemotelyWhileNotReferenced) {
 }
 #endif  // HAVE_SCTP
 
-INSTANTIATE_TEST_CASE_P(PeerConnectionEndToEndTest,
-                        PeerConnectionEndToEndTest,
-                        Values(SdpSemantics::kPlanB,
-                               SdpSemantics::kUnifiedPlan));
+INSTANTIATE_TEST_SUITE_P(PeerConnectionEndToEndTest,
+                         PeerConnectionEndToEndTest,
+                         Values(SdpSemantics::kPlanB,
+                                SdpSemantics::kUnifiedPlan));
diff --git a/pc/peer_connection_ice_unittest.cc b/pc/peer_connection_ice_unittest.cc
index aa7cc7f686..1d525e3642 100644
--- a/pc/peer_connection_ice_unittest.cc
+++ b/pc/peer_connection_ice_unittest.cc
@@ -872,7 +872,7 @@ TEST_P(PeerConnectionIceUfragPwdAnswerTest, TestIncludedInAnswer) {
   EXPECT_NE(answer_transport_desc->ice_pwd, local_transport_desc->ice_pwd);
 }
 
-INSTANTIATE_TEST_CASE_P(
+INSTANTIATE_TEST_SUITE_P(
     PeerConnectionIceTest,
     PeerConnectionIceUfragPwdAnswerTest,
     Combine(Values(SdpSemantics::kPlanB, SdpSemantics::kUnifiedPlan),
@@ -970,10 +970,10 @@ TEST_P(PeerConnectionIceTest,
   EXPECT_EQ(cricket::ICEROLE_CONTROLLED, GetIceRole(callee));
 }
 
-INSTANTIATE_TEST_CASE_P(PeerConnectionIceTest,
-                        PeerConnectionIceTest,
-                        Values(SdpSemantics::kPlanB,
-                               SdpSemantics::kUnifiedPlan));
+INSTANTIATE_TEST_SUITE_P(PeerConnectionIceTest,
+                         PeerConnectionIceTest,
+                         Values(SdpSemantics::kPlanB,
+                                SdpSemantics::kUnifiedPlan));
 
 class PeerConnectionIceConfigTest : public testing::Test {
  protected:
diff --git a/pc/peer_connection_integrationtest.cc b/pc/peer_connection_integrationtest.cc
index 54af495a34..2d7b33106c 100644
--- a/pc/peer_connection_integrationtest.cc
+++ b/pc/peer_connection_integrationtest.cc
@@ -3943,7 +3943,7 @@ constexpr uint32_t kFlagsIPv6NoStun =
 constexpr uint32_t kFlagsIPv4Stun =
     cricket::PORTALLOCATOR_DISABLE_TCP | cricket::PORTALLOCATOR_DISABLE_RELAY;
 
-INSTANTIATE_TEST_CASE_P(
+INSTANTIATE_TEST_SUITE_P(
     PeerConnectionIntegrationTest,
     PeerConnectionIntegrationIceStatesTest,
     Combine(Values(SdpSemantics::kPlanB, SdpSemantics::kUnifiedPlan),
@@ -4915,10 +4915,10 @@ TEST_P(PeerConnectionIntegrationTest,
   EXPECT_LT(0, callee_ice_event_count);
 }
 
-INSTANTIATE_TEST_CASE_P(PeerConnectionIntegrationTest,
-                        PeerConnectionIntegrationTest,
-                        Values(SdpSemantics::kPlanB,
-                               SdpSemantics::kUnifiedPlan));
+INSTANTIATE_TEST_SUITE_P(PeerConnectionIntegrationTest,
+                         PeerConnectionIntegrationTest,
+                         Values(SdpSemantics::kPlanB,
+                                SdpSemantics::kUnifiedPlan));
 
 // Tests that verify interoperability between Plan B and Unified Plan
 // PeerConnections.
@@ -5036,7 +5036,7 @@ TEST_P(PeerConnectionIntegrationInteropTest,
   ASSERT_TRUE(ExpectNewFrames(media_expectations));
 }
 
-INSTANTIATE_TEST_CASE_P(
+INSTANTIATE_TEST_SUITE_P(
     PeerConnectionIntegrationTest,
     PeerConnectionIntegrationInteropTest,
     Values(std::make_tuple(SdpSemantics::kPlanB, SdpSemantics::kUnifiedPlan),
diff --git a/pc/peer_connection_interface_unittest.cc b/pc/peer_connection_interface_unittest.cc
index 038e42c9b3..8e2226103b 100644
--- a/pc/peer_connection_interface_unittest.cc
+++ b/pc/peer_connection_interface_unittest.cc
@@ -3948,10 +3948,10 @@ TEST_P(PeerConnectionInterfaceTest, ExtmapAllowMixedIsConfigurable) {
   EXPECT_TRUE(offer->description()->extmap_allow_mixed());
 }
 
-INSTANTIATE_TEST_CASE_P(PeerConnectionInterfaceTest,
-                        PeerConnectionInterfaceTest,
-                        Values(SdpSemantics::kPlanB,
-                               SdpSemantics::kUnifiedPlan));
+INSTANTIATE_TEST_SUITE_P(PeerConnectionInterfaceTest,
+                         PeerConnectionInterfaceTest,
+                         Values(SdpSemantics::kPlanB,
+                                SdpSemantics::kUnifiedPlan));
 
 class PeerConnectionMediaConfigTest : public testing::Test {
  protected:
diff --git a/pc/peer_connection_jsep_unittest.cc b/pc/peer_connection_jsep_unittest.cc
index 3acf11e1a0..86d26fb9aa 100644
--- a/pc/peer_connection_jsep_unittest.cc
+++ b/pc/peer_connection_jsep_unittest.cc
@@ -1065,7 +1065,7 @@ TEST_P(RecycleMediaSectionTest, PendingRemoteRejectedAndNotRejectedLocal) {
 // for the media section. This is needed for full test coverage because
 // MediaSession has separate functions for processing audio and video media
 // sections.
-INSTANTIATE_TEST_CASE_P(
+INSTANTIATE_TEST_SUITE_P(
     PeerConnectionJsepTest,
     RecycleMediaSectionTest,
     Combine(Values(cricket::MEDIA_TYPE_AUDIO, cricket::MEDIA_TYPE_VIDEO),
diff --git a/pc/peer_connection_media_unittest.cc b/pc/peer_connection_media_unittest.cc
index 60bea4c8f4..c81d5111b7 100644
--- a/pc/peer_connection_media_unittest.cc
+++ b/pc/peer_connection_media_unittest.cc
@@ -536,7 +536,7 @@ TEST_P(PeerConnectionMediaOfferDirectionTest, VerifyDirection) {
 
 // Note that in these tests, MD_INACTIVE indicates that no media section is
 // included in the offer, not that the media direction is inactive.
-INSTANTIATE_TEST_CASE_P(
+INSTANTIATE_TEST_SUITE_P(
     PeerConnectionMediaTest,
     PeerConnectionMediaOfferDirectionTest,
     Combine(
@@ -652,16 +652,16 @@ TEST_P(PeerConnectionMediaAnswerDirectionTest, VerifyRejected) {
   EXPECT_EQ((offer_to_receive_ == 0 && !send_media_), audio_content->rejected);
 }
 
-INSTANTIATE_TEST_CASE_P(PeerConnectionMediaTest,
-                        PeerConnectionMediaAnswerDirectionTest,
-                        Combine(Values(SdpSemantics::kPlanB,
-                                       SdpSemantics::kUnifiedPlan),
-                                Values(RtpTransceiverDirection::kInactive,
-                                       RtpTransceiverDirection::kSendOnly,
-                                       RtpTransceiverDirection::kRecvOnly,
-                                       RtpTransceiverDirection::kSendRecv),
-                                Bool(),
-                                Values(-1, 0, 1)));
+INSTANTIATE_TEST_SUITE_P(PeerConnectionMediaTest,
+                         PeerConnectionMediaAnswerDirectionTest,
+                         Combine(Values(SdpSemantics::kPlanB,
+                                        SdpSemantics::kUnifiedPlan),
+                                 Values(RtpTransceiverDirection::kInactive,
+                                        RtpTransceiverDirection::kSendOnly,
+                                        RtpTransceiverDirection::kRecvOnly,
+                                        RtpTransceiverDirection::kSendRecv),
+                                 Bool(),
+                                 Values(-1, 0, 1)));
 
 TEST_P(PeerConnectionMediaTest, OfferHasDifferentDirectionForAudioVideo) {
   auto caller = CreatePeerConnection();
@@ -830,7 +830,7 @@ constexpr char kMLinesOutOfOrder[] =
     "The order of m-lines in answer doesn't match order in offer. Rejecting "
     "answer.";
 
-INSTANTIATE_TEST_CASE_P(
+INSTANTIATE_TEST_SUITE_P(
     PeerConnectionMediaTest,
     PeerConnectionMediaInvalidMediaTest,
     Combine(Values(SdpSemantics::kPlanB, SdpSemantics::kUnifiedPlan),
@@ -1239,9 +1239,9 @@ TEST_P(PeerConnectionMediaTest, MediaTransportNotPropagatedToVoiceEngine) {
   ASSERT_EQ(nullptr, callee_video->media_transport());
 }
 
-INSTANTIATE_TEST_CASE_P(PeerConnectionMediaTest,
-                        PeerConnectionMediaTest,
-                        Values(SdpSemantics::kPlanB,
-                               SdpSemantics::kUnifiedPlan));
+INSTANTIATE_TEST_SUITE_P(PeerConnectionMediaTest,
+                         PeerConnectionMediaTest,
+                         Values(SdpSemantics::kPlanB,
+                                SdpSemantics::kUnifiedPlan));
 
 }  // namespace webrtc
diff --git a/pc/peer_connection_rtp_unittest.cc b/pc/peer_connection_rtp_unittest.cc
index e80c95c7e8..e41791fe30 100644
--- a/pc/peer_connection_rtp_unittest.cc
+++ b/pc/peer_connection_rtp_unittest.cc
@@ -1814,9 +1814,9 @@ TEST_P(PeerConnectionRtpTest, CreateTwoSendersWithSameTrack) {
   }
 }
 
-INSTANTIATE_TEST_CASE_P(PeerConnectionRtpTest,
-                        PeerConnectionRtpTest,
-                        Values(SdpSemantics::kPlanB,
-                               SdpSemantics::kUnifiedPlan));
+INSTANTIATE_TEST_SUITE_P(PeerConnectionRtpTest,
+                         PeerConnectionRtpTest,
+                         Values(SdpSemantics::kPlanB,
+                                SdpSemantics::kUnifiedPlan));
 
 }  // namespace webrtc
diff --git a/pc/peer_connection_signaling_unittest.cc b/pc/peer_connection_signaling_unittest.cc
index 340d472bc8..db65de4b76 100644
--- a/pc/peer_connection_signaling_unittest.cc
+++ b/pc/peer_connection_signaling_unittest.cc
@@ -402,16 +402,16 @@ TEST_P(PeerConnectionSignalingStateTest, SetRemoteAnswer) {
   }
 }
 
-INSTANTIATE_TEST_CASE_P(PeerConnectionSignalingTest,
-                        PeerConnectionSignalingStateTest,
-                        Combine(Values(SdpSemantics::kPlanB,
-                                       SdpSemantics::kUnifiedPlan),
-                                Values(SignalingState::kStable,
-                                       SignalingState::kHaveLocalOffer,
-                                       SignalingState::kHaveLocalPrAnswer,
-                                       SignalingState::kHaveRemoteOffer,
-                                       SignalingState::kHaveRemotePrAnswer),
-                                Bool()));
+INSTANTIATE_TEST_SUITE_P(PeerConnectionSignalingTest,
+                         PeerConnectionSignalingStateTest,
+                         Combine(Values(SdpSemantics::kPlanB,
+                                        SdpSemantics::kUnifiedPlan),
+                                 Values(SignalingState::kStable,
+                                        SignalingState::kHaveLocalOffer,
+                                        SignalingState::kHaveLocalPrAnswer,
+                                        SignalingState::kHaveRemoteOffer,
+                                        SignalingState::kHaveRemotePrAnswer),
+                                 Bool()));
 
 // Test that CreateAnswer fails if a round of offer/answer has been done and
 // the PeerConnection is in the stable state.
@@ -522,10 +522,10 @@ TEST_P(PeerConnectionSignalingTest, CreateOffersAndShutdown) {
   }
 }
 
-INSTANTIATE_TEST_CASE_P(PeerConnectionSignalingTest,
-                        PeerConnectionSignalingTest,
-                        Values(SdpSemantics::kPlanB,
-                               SdpSemantics::kUnifiedPlan));
+INSTANTIATE_TEST_SUITE_P(PeerConnectionSignalingTest,
+                         PeerConnectionSignalingTest,
+                         Values(SdpSemantics::kPlanB,
+                                SdpSemantics::kUnifiedPlan));
 
 class PeerConnectionSignalingUnifiedPlanTest
     : public PeerConnectionSignalingBaseTest {
diff --git a/pc/rtp_media_utils_unittest.cc b/pc/rtp_media_utils_unittest.cc
index fbaa7a3802..f200c28ffb 100644
--- a/pc/rtp_media_utils_unittest.cc
+++ b/pc/rtp_media_utils_unittest.cc
@@ -57,9 +57,9 @@ TEST_P(EnumerateAllDirectionsTest, TestReversedIdentity) {
                            RtpTransceiverDirectionReversed(direction)));
 }
 
-INSTANTIATE_TEST_CASE_P(RtpTransceiverDirectionTest,
-                        EnumerateAllDirectionsTest,
-                        ValuesIn(kAllDirections));
+INSTANTIATE_TEST_SUITE_P(RtpTransceiverDirectionTest,
+                         EnumerateAllDirectionsTest,
+                         ValuesIn(kAllDirections));
 
 class EnumerateAllDirectionsAndBool
     : public ::testing::TestWithParam<
@@ -89,8 +89,8 @@ TEST_P(EnumerateAllDirectionsAndBool, TestWithRecvSet) {
   EXPECT_EQ(recv, RtpTransceiverDirectionHasRecv(result));
 }
 
-INSTANTIATE_TEST_CASE_P(RtpTransceiverDirectionTest,
-                        EnumerateAllDirectionsAndBool,
-                        Combine(ValuesIn(kAllDirections), Bool()));
+INSTANTIATE_TEST_SUITE_P(RtpTransceiverDirectionTest,
+                         EnumerateAllDirectionsAndBool,
+                         Combine(ValuesIn(kAllDirections), Bool()));
 
 }  // namespace webrtc
diff --git a/pc/sdp_serializer_unittest.cc b/pc/sdp_serializer_unittest.cc
index 76fa8baa93..e655f229ca 100644
--- a/pc/sdp_serializer_unittest.cc
+++ b/pc/sdp_serializer_unittest.cc
@@ -231,9 +231,9 @@ const char* kSimulcastMalformedStrings[] = {
     "",
 };
 
-INSTANTIATE_TEST_CASE_P(SimulcastDeserializationErrors,
-                        SimulcastSdpSerializerTest,
-                        ValuesIn(kSimulcastMalformedStrings));
+INSTANTIATE_TEST_SUITE_P(SimulcastDeserializationErrors,
+                         SimulcastSdpSerializerTest,
+                         ValuesIn(kSimulcastMalformedStrings));
 
 // Test a simple serialization scenario.
 TEST_F(SimulcastSdpSerializerTest, Serialize_SimpleCase) {
@@ -471,8 +471,8 @@ const char* kRidDescriptionMalformedStrings[] = {
     "1 recv ;;",
 };
 
-INSTANTIATE_TEST_CASE_P(RidDescriptionDeserializationErrors,
-                        RidDescriptionSdpSerializerTest,
-                        ValuesIn(kRidDescriptionMalformedStrings));
+INSTANTIATE_TEST_SUITE_P(RidDescriptionDeserializationErrors,
+                         RidDescriptionSdpSerializerTest,
+                         ValuesIn(kRidDescriptionMalformedStrings));
 
 }  // namespace webrtc
diff --git a/pc/srtp_transport_unittest.cc b/pc/srtp_transport_unittest.cc
index d429283fb2..f3fab89a21 100644
--- a/pc/srtp_transport_unittest.cc
+++ b/pc/srtp_transport_unittest.cc
@@ -399,9 +399,9 @@ TEST_F(SrtpTransportTest,
 }
 
 // Run all tests both with and without external auth enabled.
-INSTANTIATE_TEST_CASE_P(ExternalAuth,
-                        SrtpTransportTestWithExternalAuth,
-                        ::testing::Values(true, false));
+INSTANTIATE_TEST_SUITE_P(ExternalAuth,
+                         SrtpTransportTestWithExternalAuth,
+                         ::testing::Values(true, false));
 
 // Test directly setting the params with bogus keys.
 TEST_F(SrtpTransportTest, TestSetParamsKeyTooShort) {
diff --git a/pc/stats_collector_unittest.cc b/pc/stats_collector_unittest.cc
index 3fe6a9e287..eed30ef1d1 100644
--- a/pc/stats_collector_unittest.cc
+++ b/pc/stats_collector_unittest.cc
@@ -1750,6 +1750,6 @@ TEST_P(StatsCollectorTrackTest, VerifyVideoReceiveSsrcStatsNew) {
             ExtractSsrcStatsValue(reports, StatsReport::kStatsValueNameQpSum));
 }
 
-INSTANTIATE_TEST_CASE_P(HasStream, StatsCollectorTrackTest, ::testing::Bool());
+INSTANTIATE_TEST_SUITE_P(HasStream, StatsCollectorTrackTest, ::testing::Bool());
 
 }  // namespace webrtc
diff --git a/pc/webrtc_sdp_unittest.cc b/pc/webrtc_sdp_unittest.cc
index b1ecf7eb79..c04a1d9990 100644
--- a/pc/webrtc_sdp_unittest.cc
+++ b/pc/webrtc_sdp_unittest.cc
@@ -3020,9 +3020,9 @@ TEST_P(WebRtcSdpExtmapTest, DeserializeSessionDescriptionWithInvalidExtmap) {
   TestDeserializeExtmap(true, true, encrypted);
 }
 
-INSTANTIATE_TEST_CASE_P(Encrypted,
-                        WebRtcSdpExtmapTest,
-                        ::testing::Values(false, true));
+INSTANTIATE_TEST_SUITE_P(Encrypted,
+                         WebRtcSdpExtmapTest,
+                         ::testing::Values(false, true));
 
 TEST_F(WebRtcSdpTest, DeserializeSessionDescriptionWithoutEndLineBreak) {
   JsepSessionDescription jdesc(kDummyType);
diff --git a/rtc_base/numerics/percentile_filter_unittest.cc b/rtc_base/numerics/percentile_filter_unittest.cc
index a4cb31772e..8ed6d67960 100644
--- a/rtc_base/numerics/percentile_filter_unittest.cc
+++ b/rtc_base/numerics/percentile_filter_unittest.cc
@@ -34,9 +34,9 @@ class PercentileFilterTest : public ::testing::TestWithParam<float> {
   RTC_DISALLOW_COPY_AND_ASSIGN(PercentileFilterTest);
 };
 
-INSTANTIATE_TEST_CASE_P(PercentileFilterTests,
-                        PercentileFilterTest,
-                        ::testing::Values(0.0f, 0.1f, 0.5f, 0.9f, 1.0f));
+INSTANTIATE_TEST_SUITE_P(PercentileFilterTests,
+                         PercentileFilterTest,
+                         ::testing::Values(0.0f, 0.1f, 0.5f, 0.9f, 1.0f));
 
 TEST(PercentileFilterTest, MinFilter) {
   PercentileFilter<int64_t> filter(0.0f);
diff --git a/rtc_base/ssl_adapter_unittest.cc b/rtc_base/ssl_adapter_unittest.cc
index 9774c0a5d9..b459496b58 100644
--- a/rtc_base/ssl_adapter_unittest.cc
+++ b/rtc_base/ssl_adapter_unittest.cc
@@ -53,7 +53,7 @@ class MockCertVerifier : public rtc::SSLCertificateVerifier {
   MOCK_METHOD1(Verify, bool(const rtc::SSLCertificate&));
 };
 
-// TODO(benwright) - Move to using INSTANTIATE_TEST_CASE_P instead of using
+// TODO(benwright) - Move to using INSTANTIATE_TEST_SUITE_P instead of using
 // duplicate test cases for simple parameter changes.
 class SSLAdapterTestDummyClient : public sigslot::has_slots<> {
  public:
diff --git a/rtc_base/ssl_stream_adapter_unittest.cc b/rtc_base/ssl_stream_adapter_unittest.cc
index e866266530..82fa435908 100644
--- a/rtc_base/ssl_stream_adapter_unittest.cc
+++ b/rtc_base/ssl_stream_adapter_unittest.cc
@@ -1456,7 +1456,7 @@ TEST_P(SSLStreamAdapterTestDTLS, TestGetSslCipherSuiteDtls12Server) {
 // The RSA keysizes here might look strange, why not include the RFC's size
 // 2048?. The reason is test case slowness; testing two sizes to exercise
 // parametrization is sufficient.
-INSTANTIATE_TEST_CASE_P(
+INSTANTIATE_TEST_SUITE_P(
     SSLStreamAdapterTestsTLS,
     SSLStreamAdapterTestTLS,
     Combine(Values(rtc::KeyParams::RSA(1024, 65537),
@@ -1465,7 +1465,7 @@ INSTANTIATE_TEST_CASE_P(
             Values(rtc::KeyParams::RSA(1024, 65537),
                    rtc::KeyParams::RSA(1152, 65537),
                    rtc::KeyParams::ECDSA(rtc::EC_NIST_P256))));
-INSTANTIATE_TEST_CASE_P(
+INSTANTIATE_TEST_SUITE_P(
     SSLStreamAdapterTestsDTLS,
     SSLStreamAdapterTestDTLS,
     Combine(Values(rtc::KeyParams::RSA(1024, 65537),
diff --git a/rtc_base/string_to_number_unittest.cc b/rtc_base/string_to_number_unittest.cc
index fe5f88e7e7..2c2dfcc2b4 100644
--- a/rtc_base/string_to_number_unittest.cc
+++ b/rtc_base/string_to_number_unittest.cc
@@ -36,7 +36,7 @@ using IntegerTypes =
 template <typename T>
 class BasicNumberTest : public ::testing::Test {};
 
-TYPED_TEST_CASE_P(BasicNumberTest);
+TYPED_TEST_SUITE_P(BasicNumberTest);
 
 TYPED_TEST_P(BasicNumberTest, TestValidNumbers) {
   using T = TypeParam;
@@ -93,16 +93,16 @@ TYPED_TEST_P(BasicNumberTest, TestInvalidInputs) {
   EXPECT_EQ(absl::nullopt, StringToNumber<T>("5 "));
 }
 
-REGISTER_TYPED_TEST_CASE_P(BasicNumberTest,
-                           TestValidNumbers,
-                           TestInvalidNumbers,
-                           TestInvalidInputs);
+REGISTER_TYPED_TEST_SUITE_P(BasicNumberTest,
+                            TestValidNumbers,
+                            TestInvalidNumbers,
+                            TestInvalidInputs);
 
 }  // namespace
 
-INSTANTIATE_TYPED_TEST_CASE_P(StringToNumberTest_Integers,
-                              BasicNumberTest,
-                              IntegerTypes);
+INSTANTIATE_TYPED_TEST_SUITE_P(StringToNumberTest_Integers,
+                               BasicNumberTest,
+                               IntegerTypes);
 
 TEST(StringToNumberTest, TestSpecificValues) {
   EXPECT_EQ(absl::nullopt, StringToNumber<uint8_t>("256"));
diff --git a/rtc_base/unique_id_generator_unittest.cc b/rtc_base/unique_id_generator_unittest.cc
index d0e8d9827c..1634d56148 100644
--- a/rtc_base/unique_id_generator_unittest.cc
+++ b/rtc_base/unique_id_generator_unittest.cc
@@ -32,7 +32,7 @@ using test_types = ::testing::Types<UniqueNumberGenerator<uint8_t>,
                                     UniqueRandomIdGenerator,
                                     UniqueStringGenerator>;
 
-TYPED_TEST_CASE(UniqueIdGeneratorTest, test_types);
+TYPED_TEST_SUITE(UniqueIdGeneratorTest, test_types);
 
 TYPED_TEST(UniqueIdGeneratorTest, ElementsDoNotRepeat) {
   typedef TypeParam Generator;
diff --git a/test/scenario/scenario_tests/bbr_performance.cc b/test/scenario/scenario_tests/bbr_performance.cc
index 5841024940..b6d6a44e01 100644
--- a/test/scenario/scenario_tests/bbr_performance.cc
+++ b/test/scenario/scenario_tests/bbr_performance.cc
@@ -211,11 +211,12 @@ TEST_P(BbrScenarioTest, ReceivesVideo) {
   s.RunFor(TimeDelta::ms(kRunTimeMs));
 }
 
-INSTANTIATE_TEST_CASE_P(Selected,
-                        BbrScenarioTest,
-                        Values(make_tuple("rs:1,bw:150,dl:100,ct:100", "bbr")));
+INSTANTIATE_TEST_SUITE_P(Selected,
+                         BbrScenarioTest,
+                         Values(make_tuple("rs:1,bw:150,dl:100,ct:100",
+                                           "bbr")));
 
-INSTANTIATE_TEST_CASE_P(
+INSTANTIATE_TEST_SUITE_P(
     OneWayTuning,
     BbrScenarioTest,
     Values(make_tuple("bw:150,dl:100", "bbr,iw:,eg:100%,notr"),
@@ -223,34 +224,34 @@ INSTANTIATE_TEST_CASE_P(
            make_tuple("bw:150,dl:100", "bbr,iw:8000,eg:100%"),
            make_tuple("bw:150,dl:100", "bbr,iw:8000,eg:80%")));
 
-INSTANTIATE_TEST_CASE_P(OneWayTuned,
-                        BbrScenarioTest,
-                        Values(make_tuple("bw:150,dl:100", "bbr"),
-                               make_tuple("bw:150,dl:100", ""),
-                               make_tuple("bw:800,dl:100", "bbr"),
-                               make_tuple("bw:800,dl:100", "")));
+INSTANTIATE_TEST_SUITE_P(OneWayTuned,
+                         BbrScenarioTest,
+                         Values(make_tuple("bw:150,dl:100", "bbr"),
+                                make_tuple("bw:150,dl:100", ""),
+                                make_tuple("bw:800,dl:100", "bbr"),
+                                make_tuple("bw:800,dl:100", "")));
 
-INSTANTIATE_TEST_CASE_P(OneWayDegraded,
-                        BbrScenarioTest,
-                        Values(make_tuple("bw:150,dl:100,dn:30,pl:5%", "bbr"),
-                               make_tuple("bw:150,dl:100,dn:30,pl:5%", ""),
+INSTANTIATE_TEST_SUITE_P(OneWayDegraded,
+                         BbrScenarioTest,
+                         Values(make_tuple("bw:150,dl:100,dn:30,pl:5%", "bbr"),
+                                make_tuple("bw:150,dl:100,dn:30,pl:5%", ""),
 
-                               make_tuple("bw:150,ct:100,dl:100", "bbr"),
-                               make_tuple("bw:150,ct:100,dl:100", ""),
+                                make_tuple("bw:150,ct:100,dl:100", "bbr"),
+                                make_tuple("bw:150,ct:100,dl:100", ""),
 
-                               make_tuple("bw:800,dl:100,dn:30,pl:5%", "bbr"),
-                               make_tuple("bw:800,dl:100,dn:30,pl:5%", ""),
+                                make_tuple("bw:800,dl:100,dn:30,pl:5%", "bbr"),
+                                make_tuple("bw:800,dl:100,dn:30,pl:5%", ""),
 
-                               make_tuple("bw:800,ct:600,dl:100", "bbr"),
-                               make_tuple("bw:800,ct:600,dl:100", "")));
+                                make_tuple("bw:800,ct:600,dl:100", "bbr"),
+                                make_tuple("bw:800,ct:600,dl:100", "")));
 
-INSTANTIATE_TEST_CASE_P(TwoWay,
-                        BbrScenarioTest,
-                        Values(make_tuple("ret,bw:150,dl:100", "bbr"),
-                               make_tuple("ret,bw:150,dl:100", ""),
-                               make_tuple("ret,bw:800,dl:100", "bbr"),
-                               make_tuple("ret,bw:800,dl:100", ""),
-                               make_tuple("ret,bw:150,dl:50", "bbr"),
-                               make_tuple("ret,bw:150,dl:50", "")));
+INSTANTIATE_TEST_SUITE_P(TwoWay,
+                         BbrScenarioTest,
+                         Values(make_tuple("ret,bw:150,dl:100", "bbr"),
+                                make_tuple("ret,bw:150,dl:100", ""),
+                                make_tuple("ret,bw:800,dl:100", "bbr"),
+                                make_tuple("ret,bw:800,dl:100", ""),
+                                make_tuple("ret,bw:150,dl:50", "bbr"),
+                                make_tuple("ret,bw:150,dl:50", "")));
 }  // namespace test
 }  // namespace webrtc
diff --git a/video/end_to_end_tests/call_operation_tests.cc b/video/end_to_end_tests/call_operation_tests.cc
index df89eea29a..af76f350aa 100644
--- a/video/end_to_end_tests/call_operation_tests.cc
+++ b/video/end_to_end_tests/call_operation_tests.cc
@@ -31,7 +31,7 @@ class CallOperationEndToEndTest
   test::ScopedFieldTrials field_trial_;
 };
 
-INSTANTIATE_TEST_CASE_P(
+INSTANTIATE_TEST_SUITE_P(
     FieldTrials,
     CallOperationEndToEndTest,
     ::testing::Values("WebRTC-TaskQueueCongestionControl/Enabled/",
diff --git a/video/end_to_end_tests/codec_tests.cc b/video/end_to_end_tests/codec_tests.cc
index 3c9b39cdc8..ed303ec12f 100644
--- a/video/end_to_end_tests/codec_tests.cc
+++ b/video/end_to_end_tests/codec_tests.cc
@@ -110,10 +110,11 @@ class CodecObserver : public test::EndToEndTest,
   int frame_counter_;
 };
 
-INSTANTIATE_TEST_CASE_P(GenericDescriptor,
-                        CodecEndToEndTest,
-                        ::testing::Values("WebRTC-GenericDescriptor/Disabled/",
-                                          "WebRTC-GenericDescriptor/Enabled/"));
+INSTANTIATE_TEST_SUITE_P(
+    GenericDescriptor,
+    CodecEndToEndTest,
+    ::testing::Values("WebRTC-GenericDescriptor/Disabled/",
+                      "WebRTC-GenericDescriptor/Enabled/"));
 
 TEST_P(CodecEndToEndTest, SendsAndReceivesVP8) {
   test::FunctionVideoEncoderFactory encoder_factory(
@@ -229,7 +230,7 @@ class EndToEndTestH264 : public test::CallTest,
   test::ScopedFieldTrials field_trial_;
 };
 
-INSTANTIATE_TEST_CASE_P(
+INSTANTIATE_TEST_SUITE_P(
     SpsPpsIdrIsKeyframe,
     EndToEndTestH264,
     ::testing::Values("WebRTC-SpsPpsIdrIsH264Keyframe/Disabled/",
diff --git a/video/end_to_end_tests/probing_tests.cc b/video/end_to_end_tests/probing_tests.cc
index 9dee8c979c..026f333fd4 100644
--- a/video/end_to_end_tests/probing_tests.cc
+++ b/video/end_to_end_tests/probing_tests.cc
@@ -28,7 +28,7 @@ class ProbingEndToEndTest : public test::CallTest,
  private:
   test::ScopedFieldTrials field_trial_;
 };
-INSTANTIATE_TEST_CASE_P(
+INSTANTIATE_TEST_SUITE_P(
     FieldTrials,
     ProbingEndToEndTest,
     ::testing::Values("WebRTC-TaskQueueCongestionControl/Enabled/",
diff --git a/video/end_to_end_tests/transport_feedback_tests.cc b/video/end_to_end_tests/transport_feedback_tests.cc
index 5a9b1cc05b..7588e02c35 100644
--- a/video/end_to_end_tests/transport_feedback_tests.cc
+++ b/video/end_to_end_tests/transport_feedback_tests.cc
@@ -35,7 +35,7 @@ class TransportFeedbackEndToEndTest
   test::ScopedFieldTrials field_trial_;
 };
 
-INSTANTIATE_TEST_CASE_P(
+INSTANTIATE_TEST_SUITE_P(
     FieldTrials,
     TransportFeedbackEndToEndTest,
     ::testing::Values("WebRTC-TaskQueueCongestionControl/Enabled/",
diff --git a/video/full_stack_tests.cc b/video/full_stack_tests.cc
index 05be0ef017..5e08fcff86 100644
--- a/video/full_stack_tests.cc
+++ b/video/full_stack_tests.cc
@@ -1220,10 +1220,11 @@ TEST(FullStackTest, MAYBE_LargeRoomVP8_50thumb) {
   fixture->RunWithAnalyzer(large_room);
 }
 
-INSTANTIATE_TEST_CASE_P(FullStackTest,
-                        GenericDescriptorTest,
-                        ::testing::Values("WebRTC-GenericDescriptor/Disabled/",
-                                          "WebRTC-GenericDescriptor/Enabled/"));
+INSTANTIATE_TEST_SUITE_P(
+    FullStackTest,
+    GenericDescriptorTest,
+    ::testing::Values("WebRTC-GenericDescriptor/Disabled/",
+                      "WebRTC-GenericDescriptor/Enabled/"));
 
 class DualStreamsTest : public ::testing::TestWithParam<int> {};
 
@@ -1329,8 +1330,8 @@ TEST_P(DualStreamsTest, Conference_Restricted) {
   fixture->RunWithAnalyzer(dual_streams);
 }
 
-INSTANTIATE_TEST_CASE_P(FullStackTest,
-                        DualStreamsTest,
-                        ::testing::Values(0, 1));
+INSTANTIATE_TEST_SUITE_P(FullStackTest,
+                         DualStreamsTest,
+                         ::testing::Values(0, 1));
 
 }  // namespace webrtc
diff --git a/video/picture_id_tests.cc b/video/picture_id_tests.cc
index f74cebc237..3188786e9f 100644
--- a/video/picture_id_tests.cc
+++ b/video/picture_id_tests.cc
@@ -240,9 +240,9 @@ class PictureIdTest : public test::CallTest,
   std::unique_ptr<PictureIdObserver> observer_;
 };
 
-INSTANTIATE_TEST_CASE_P(TemporalLayers,
-                        PictureIdTest,
-                        ::testing::ValuesIn(kNumTemporalLayers));
+INSTANTIATE_TEST_SUITE_P(TemporalLayers,
+                         PictureIdTest,
+                         ::testing::ValuesIn(kNumTemporalLayers));
 
 // Use a special stream factory to ensure that all simulcast streams are being
 // sent.
diff --git a/video/receive_statistics_proxy_unittest.cc b/video/receive_statistics_proxy_unittest.cc
index 43ee08032f..ac75aad42e 100644
--- a/video/receive_statistics_proxy_unittest.cc
+++ b/video/receive_statistics_proxy_unittest.cc
@@ -928,10 +928,10 @@ TEST_F(ReceiveStatisticsProxyTest, RtcpHistogramsAreUpdated) {
                             kNackPackets * 60 / metrics::kMinRunTimeInSeconds));
 }
 
-INSTANTIATE_TEST_CASE_P(ContentTypes,
-                        ReceiveStatisticsProxyTest,
-                        ::testing::Values(VideoContentType::UNSPECIFIED,
-                                          VideoContentType::SCREENSHARE));
+INSTANTIATE_TEST_SUITE_P(ContentTypes,
+                         ReceiveStatisticsProxyTest,
+                         ::testing::Values(VideoContentType::UNSPECIFIED,
+                                           VideoContentType::SCREENSHARE));
 
 TEST_P(ReceiveStatisticsProxyTest, InterFrameDelaysAreReported) {
   const VideoContentType content_type = GetParam();
diff --git a/video/rtp_video_stream_receiver_unittest.cc b/video/rtp_video_stream_receiver_unittest.cc
index d54d977331..d80e55147c 100644
--- a/video/rtp_video_stream_receiver_unittest.cc
+++ b/video/rtp_video_stream_receiver_unittest.cc
@@ -284,7 +284,7 @@ class RtpVideoStreamReceiverTestH264
   RtpVideoStreamReceiverTestH264() : RtpVideoStreamReceiverTest(GetParam()) {}
 };
 
-INSTANTIATE_TEST_CASE_P(
+INSTANTIATE_TEST_SUITE_P(
     SpsPpsIdrIsKeyframe,
     RtpVideoStreamReceiverTestH264,
     ::testing::Values("", "WebRTC-SpsPpsIdrIsH264Keyframe/Enabled/"));
diff --git a/video/video_send_stream_tests.cc b/video/video_send_stream_tests.cc
index 4b7550b374..47542867a8 100644
--- a/video/video_send_stream_tests.cc
+++ b/video/video_send_stream_tests.cc
@@ -101,9 +101,9 @@ class VideoSendStreamTest : public test::CallTest,
   test::ScopedFieldTrials field_trial_;
 };
 
-INSTANTIATE_TEST_CASE_P(Default, VideoSendStreamTest, ::testing::Values(""));
+INSTANTIATE_TEST_SUITE_P(Default, VideoSendStreamTest, ::testing::Values(""));
 
-INSTANTIATE_TEST_CASE_P(
+INSTANTIATE_TEST_SUITE_P(
     TaskQueueTrial,
     VideoSendStreamTest,
     ::testing::Values("WebRTC-TaskQueueCongestionControl/Enabled/"));