diff --git a/api/candidate.cc b/api/candidate.cc
index 62cd1bd..d51fb84 100644
--- a/api/candidate.cc
+++ b/api/candidate.cc
@@ -73,8 +73,9 @@
       sensitive ? address_.ToSensitiveString() : address_.ToString();
   ost << "Cand[" << transport_name_ << ":" << foundation_ << ":" << component_
       << ":" << protocol_ << ":" << priority_ << ":" << address << ":" << type_
-      << ":" << related_address_ << ":" << username_ << ":" << password_ << ":"
-      << network_id_ << ":" << network_cost_ << ":" << generation_ << "]";
+      << ":" << related_address_.ToString() << ":" << username_ << ":"
+      << password_ << ":" << network_id_ << ":" << network_cost_ << ":"
+      << generation_ << "]";
   return ost.str();
 }
 
diff --git a/api/rtcerror.h b/api/rtcerror.h
index 760bad8..d7dec29 100644
--- a/api/rtcerror.h
+++ b/api/rtcerror.h
@@ -150,11 +150,11 @@
 // Helper macro that can be used by implementations to create an error with a
 // message and log it. |message| should be a string literal or movable
 // std::string.
-#define LOG_AND_RETURN_ERROR_EX(type, message, severity) \
-  {                                                      \
-    RTC_DCHECK(type != RTCErrorType::NONE);              \
-    RTC_LOG(severity) << message << " (" << type << ")"; \
-    return webrtc::RTCError(type, message);              \
+#define LOG_AND_RETURN_ERROR_EX(type, message, severity)           \
+  {                                                                \
+    RTC_DCHECK(type != RTCErrorType::NONE);                        \
+    RTC_LOG(severity) << message << " (" << ToString(type) << ")"; \
+    return webrtc::RTCError(type, message);                        \
   }
 
 #define LOG_AND_RETURN_ERROR(type, message) \
diff --git a/api/rtcerror_unittest.cc b/api/rtcerror_unittest.cc
index d8f7ca6..90593cf 100644
--- a/api/rtcerror_unittest.cc
+++ b/api/rtcerror_unittest.cc
@@ -58,15 +58,6 @@
 
 namespace webrtc {
 
-// Simple test for ostream operator for RTCErrorType.
-TEST(RTCErrorTypeTest, OstreamOperator) {
-  std::ostringstream oss;
-  oss << webrtc::RTCErrorType::NONE << ' '
-      << webrtc::RTCErrorType::INVALID_PARAMETER << ' '
-      << webrtc::RTCErrorType::INTERNAL_ERROR;
-  EXPECT_EQ("NONE INVALID_PARAMETER INTERNAL_ERROR", oss.str());
-}
-
 // Test that the default constructor creates a "no error" error.
 TEST(RTCErrorTest, DefaultConstructor) {
   RTCError e;
diff --git a/audio/BUILD.gn b/audio/BUILD.gn
index 451708a..3880eab 100644
--- a/audio/BUILD.gn
+++ b/audio/BUILD.gn
@@ -75,6 +75,7 @@
     "../modules/rtp_rtcp",
     "../modules/rtp_rtcp:rtp_rtcp_format",
     "../modules/utility",
+    "../rtc_base:audio_format_to_string",
     "../rtc_base:checks",
     "../rtc_base:rate_limiter",
     "../rtc_base:rtc_base",
diff --git a/audio/audio_send_stream.cc b/audio/audio_send_stream.cc
index cf02388..b8c88e8 100644
--- a/audio/audio_send_stream.cc
+++ b/audio/audio_send_stream.cc
@@ -23,6 +23,7 @@
 #include "rtc_base/event.h"
 #include "rtc_base/function_view.h"
 #include "rtc_base/logging.h"
+#include "rtc_base/strings/audio_format_to_string.h"
 #include "rtc_base/task_queue.h"
 #include "rtc_base/timeutils.h"
 #include "system_wrappers/include/field_trial.h"
@@ -509,7 +510,8 @@
           spec.payload_type, spec.format, new_config.codec_pair_id);
 
   if (!encoder) {
-    RTC_DLOG(LS_ERROR) << "Unable to create encoder for " << spec.format;
+    RTC_DLOG(LS_ERROR) << "Unable to create encoder for "
+                       << rtc::ToString(spec.format);
     return false;
   }
   // If a bitrate has been specified for the codec, use it over the
diff --git a/call/BUILD.gn b/call/BUILD.gn
index 2a0e38a..58238af 100644
--- a/call/BUILD.gn
+++ b/call/BUILD.gn
@@ -33,6 +33,7 @@
     "../api/audio:audio_mixer_api",
     "../api/audio_codecs:audio_codecs_api",
     "../modules/audio_processing:audio_processing_statistics",
+    "../rtc_base:audio_format_to_string",
     "../rtc_base:rtc_base",
     "../rtc_base:rtc_base_approved",
   ]
diff --git a/call/audio_send_stream.cc b/call/audio_send_stream.cc
index 3458e73..1c08c2e 100644
--- a/call/audio_send_stream.cc
+++ b/call/audio_send_stream.cc
@@ -10,6 +10,7 @@
 
 #include "call/audio_send_stream.h"
 #include "rtc_base/stringencode.h"
+#include "rtc_base/strings/audio_format_to_string.h"
 
 namespace webrtc {
 
@@ -67,7 +68,7 @@
   ss << ", cng_payload_type: "
      << (cng_payload_type ? rtc::ToString(*cng_payload_type) : "<unset>");
   ss << ", payload_type: " << payload_type;
-  ss << ", format: " << format;
+  ss << ", format: " << rtc::ToString(format);
   ss << '}';
   return ss.str();
 }
diff --git a/media/BUILD.gn b/media/BUILD.gn
index 69e47c1..ffc4883 100644
--- a/media/BUILD.gn
+++ b/media/BUILD.gn
@@ -258,6 +258,7 @@
     "../modules/audio_processing/aec_dump:aec_dump",
     "../modules/video_coding:video_codec_interface",
     "../modules/video_coding:video_coding",
+    "../rtc_base:audio_format_to_string",
     "../rtc_base:checks",
   ]
 
diff --git a/media/engine/webrtcvoiceengine.cc b/media/engine/webrtcvoiceengine.cc
index d6ec44b..df50642 100644
--- a/media/engine/webrtcvoiceengine.cc
+++ b/media/engine/webrtcvoiceengine.cc
@@ -40,6 +40,7 @@
 #include "rtc_base/logging.h"
 #include "rtc_base/race_checker.h"
 #include "rtc_base/stringencode.h"
+#include "rtc_base/strings/audio_format_to_string.h"
 #include "rtc_base/stringutils.h"
 #include "rtc_base/trace_event.h"
 #include "system_wrappers/include/field_trial.h"
@@ -689,7 +690,7 @@
       }
     } else {
       RTC_LOG(LS_ERROR) << "Unable to assign payload type to format: "
-                        << format;
+                        << rtc::ToString(format);
     }
 
     return opt_codec;
@@ -1529,7 +1530,7 @@
     auto format = AudioCodecToSdpAudioFormat(codec);
     if (!IsCodec(codec, "cn") && !IsCodec(codec, "telephone-event") &&
         !engine()->decoder_factory_->IsSupportedDecoder(format)) {
-      RTC_LOG(LS_ERROR) << "Unsupported codec: " << format;
+      RTC_LOG(LS_ERROR) << "Unsupported codec: " << rtc::ToString(format);
       return false;
     }
     // We allow adding new codecs but don't allow changing the payload type of
diff --git a/modules/audio_coding/BUILD.gn b/modules/audio_coding/BUILD.gn
index ea69666..1fb13e5 100644
--- a/modules/audio_coding/BUILD.gn
+++ b/modules/audio_coding/BUILD.gn
@@ -148,6 +148,7 @@
            ":audio_coding_module_typedefs",
            ":neteq",
            ":rent_a_codec",
+           "../../rtc_base:audio_format_to_string",
            "../../rtc_base:rtc_base_approved",
            "../../api:optional",
            "../../logging:rtc_event_log_api",
@@ -1087,6 +1088,7 @@
     "../../api/audio_codecs:audio_codecs_api",
     "../../common_audio",
     "../../common_audio:common_audio_c",
+    "../../rtc_base:audio_format_to_string",
     "../../rtc_base:checks",
     "../../rtc_base:gtest_prod",
     "../../rtc_base:rtc_base_approved",
diff --git a/modules/audio_coding/acm2/acm_receiver.cc b/modules/audio_coding/acm2/acm_receiver.cc
index 0d5dcae..4d0209b 100644
--- a/modules/audio_coding/acm2/acm_receiver.cc
+++ b/modules/audio_coding/acm2/acm_receiver.cc
@@ -26,6 +26,7 @@
 #include "rtc_base/format_macros.h"
 #include "rtc_base/logging.h"
 #include "rtc_base/numerics/safe_conversions.h"
+#include "rtc_base/strings/audio_format_to_string.h"
 #include "system_wrappers/include/clock.h"
 
 namespace webrtc {
@@ -260,7 +261,8 @@
       neteq_->RegisterPayloadType(rtp_payload_type, audio_format);
   if (!success) {
     RTC_LOG(LERROR) << "AcmReceiver::AddCodec failed for payload type "
-                    << rtp_payload_type << ", decoder format " << audio_format;
+                    << rtp_payload_type << ", decoder format "
+                    << rtc::ToString(audio_format);
   }
   return success;
 }
diff --git a/modules/audio_coding/neteq/decoder_database.cc b/modules/audio_coding/neteq/decoder_database.cc
index 7244c8d..40b0dc7 100644
--- a/modules/audio_coding/neteq/decoder_database.cc
+++ b/modules/audio_coding/neteq/decoder_database.cc
@@ -15,6 +15,7 @@
 #include "api/audio_codecs/audio_decoder.h"
 #include "rtc_base/checks.h"
 #include "rtc_base/logging.h"
+#include "rtc_base/strings/audio_format_to_string.h"
 
 namespace webrtc {
 
@@ -95,7 +96,7 @@
     RTC_DCHECK(factory_);
     decoder_ = factory_->MakeAudioDecoder(audio_format_, codec_pair_id_);
   }
-  RTC_DCHECK(decoder_) << "Failed to create: " << audio_format_;
+  RTC_DCHECK(decoder_) << "Failed to create: " << rtc::ToString(audio_format_);
   return decoder_.get();
 }
 
diff --git a/modules/audio_coding/neteq/neteq_impl.cc b/modules/audio_coding/neteq/neteq_impl.cc
index 78015d9..4e780c3 100644
--- a/modules/audio_coding/neteq/neteq_impl.cc
+++ b/modules/audio_coding/neteq/neteq_impl.cc
@@ -46,6 +46,7 @@
 #include "rtc_base/logging.h"
 #include "rtc_base/numerics/safe_conversions.h"
 #include "rtc_base/sanitizer.h"
+#include "rtc_base/strings/audio_format_to_string.h"
 #include "rtc_base/system/fallthrough.h"
 #include "rtc_base/trace_event.h"
 #include "system_wrappers/include/field_trial.h"
@@ -262,7 +263,8 @@
 bool NetEqImpl::RegisterPayloadType(int rtp_payload_type,
                                     const SdpAudioFormat& audio_format) {
   RTC_LOG(LS_VERBOSE) << "NetEqImpl::RegisterPayloadType: payload type "
-                      << rtp_payload_type << ", codec " << audio_format;
+                      << rtp_payload_type << ", codec "
+                      << rtc::ToString(audio_format);
   rtc::CritScope lock(&crit_sect_);
   return decoder_database_->RegisterPayload(rtp_payload_type, audio_format) ==
          DecoderDatabase::kOK;
diff --git a/modules/rtp_rtcp/source/rtp_format_h264.cc b/modules/rtp_rtcp/source/rtp_format_h264.cc
index 46f726b..3eda5be 100644
--- a/modules/rtp_rtcp/source/rtp_format_h264.cc
+++ b/modules/rtp_rtcp/source/rtp_format_h264.cc
@@ -337,11 +337,11 @@
     packets_.pop();
     input_fragments_.pop_front();
   } else if (packet.aggregated) {
-    RTC_CHECK_EQ(H264PacketizationMode::NonInterleaved, packetization_mode_);
+    RTC_CHECK(H264PacketizationMode::NonInterleaved == packetization_mode_);
     bool is_last_packet = num_packets_left_ == 1;
     NextAggregatePacket(rtp_packet, is_last_packet);
   } else {
-    RTC_CHECK_EQ(H264PacketizationMode::NonInterleaved, packetization_mode_);
+    RTC_CHECK(H264PacketizationMode::NonInterleaved == packetization_mode_);
     NextFragmentPacket(rtp_packet);
   }
   RTC_DCHECK_LE(rtp_packet->payload_size(), max_payload_len_);
diff --git a/p2p/base/relayport.cc b/p2p/base/relayport.cc
index 52416ca..d1c5ac6 100644
--- a/p2p/base/relayport.cc
+++ b/p2p/base/relayport.cc
@@ -443,7 +443,8 @@
   rtc::PacketOptions options;  // Default dscp set to NO_CHANGE.
   int sent = socket_->SendTo(data, size, GetAddress(), options);
   if (sent <= 0) {
-    RTC_LOG(LS_VERBOSE) << "OnSendPacket: failed sending to " << GetAddress()
+    RTC_LOG(LS_VERBOSE) << "OnSendPacket: failed sending to "
+                        << GetAddress().ToString()
                         << strerror(socket_->GetError());
     RTC_DCHECK(sent < 0);
   }
@@ -652,7 +653,7 @@
   if (current_connection_) {
     const ProtocolAddress* ra = current_connection_->protocol_address();
     RTC_LOG(LS_WARNING) << "Relay " << ra->proto << " connection to "
-                        << ra->address << " timed out";
+                        << ra->address.ToString() << " timed out";
 
     // Currently we connect to each server address in sequence. If we
     // have more addresses to try, treat this is an error and move on to
diff --git a/p2p/base/stunserver_unittest.cc b/p2p/base/stunserver_unittest.cc
index d1b65b2..6b44360 100644
--- a/p2p/base/stunserver_unittest.cc
+++ b/p2p/base/stunserver_unittest.cc
@@ -89,8 +89,9 @@
   EXPECT_EQ(1, mapped_addr->family());
   EXPECT_EQ(client_addr.port(), mapped_addr->port());
   if (mapped_addr->ipaddr() != client_addr.ipaddr()) {
-    RTC_LOG(LS_WARNING) << "Warning: mapped IP (" << mapped_addr->ipaddr()
-                        << ") != local IP (" << client_addr.ipaddr() << ")";
+    RTC_LOG(LS_WARNING) << "Warning: mapped IP ("
+                        << mapped_addr->ipaddr().ToString() << ") != local IP ("
+                        << client_addr.ipaddr().ToString() << ")";
   }
 
   delete msg;
diff --git a/p2p/base/turnport.cc b/p2p/base/turnport.cc
index fa3bc17..bf858be 100644
--- a/p2p/base/turnport.cc
+++ b/p2p/base/turnport.cc
@@ -467,8 +467,8 @@
     server_address_.address = socket_->GetRemoteAddress();
   }
 
-  RTC_LOG(LS_INFO) << "TurnPort connected to " << socket->GetRemoteAddress()
-                   << " using tcp.";
+  RTC_LOG(LS_INFO) << "TurnPort connected to "
+                   << socket->GetRemoteAddress().ToString() << " using tcp.";
   SendRequest(new TurnAllocateRequest(this), 0);
 }
 
@@ -584,7 +584,8 @@
   // Try to find an entry for this specific address; we should have one.
   TurnEntry* entry = FindEntry(addr);
   if (!entry) {
-    RTC_LOG(LS_ERROR) << "Did not find the TurnEntry for address: " << addr;
+    RTC_LOG(LS_ERROR) << "Did not find the TurnEntry for address "
+                      << addr.ToString();
     return 0;
   }
 
diff --git a/p2p/base/turnserver.cc b/p2p/base/turnserver.cc
index aa5b5ed..2a154aa 100644
--- a/p2p/base/turnserver.cc
+++ b/p2p/base/turnserver.cc
@@ -715,7 +715,7 @@
     RTC_LOG(LS_WARNING) << ToString()
                         << ": Received send indication without permission"
                            " peer="
-                        << peer_attr->GetAddress();
+                        << peer_attr->GetAddress().ToString();
   }
 }
 
@@ -739,7 +739,8 @@
   AddPermission(peer_attr->GetAddress().ipaddr());
 
   RTC_LOG(LS_INFO) << ToString()
-                   << ": Created permission, peer=" << peer_attr->GetAddress();
+                   << ": Created permission, peer="
+                   << peer_attr->GetAddress().ToString();
 
   // Send a success response.
   TurnMessage response;
@@ -789,7 +790,7 @@
 
   RTC_LOG(LS_INFO) << ToString()
                    << ": Bound channel, id=" << channel_id
-                   << ", peer=" << peer_attr->GetAddress();
+                   << ", peer=" << peer_attr->GetAddress().ToString();
 
   // Send a success response.
   TurnMessage response;
@@ -841,7 +842,8 @@
   } else {
     RTC_LOG(LS_WARNING)
         << ToString()
-        << ": Received external packet without permission, peer=" << addr;
+        << ": Received external packet without permission, peer="
+        << addr.ToString();
   }
 }
 
diff --git a/p2p/client/basicportallocator_unittest.cc b/p2p/client/basicportallocator_unittest.cc
index df6eb4c..f39e61e 100644
--- a/p2p/client/basicportallocator_unittest.cc
+++ b/p2p/client/basicportallocator_unittest.cc
@@ -540,8 +540,8 @@
 
     uint32_t total_candidates = 0;
     if (!host_candidate_addr.IsNil()) {
-      EXPECT_PRED4(HasCandidate, candidates_, "local", "udp",
-                   rtc::SocketAddress(kPrivateAddr.ipaddr(), 0));
+      EXPECT_TRUE(HasCandidate(candidates_, "local", "udp",
+                               rtc::SocketAddress(kPrivateAddr.ipaddr(), 0)));
       ++total_candidates;
     }
     if (!stun_candidate_addr.IsNil()) {
@@ -549,20 +549,23 @@
       if (host_candidate_addr.IsNil()) {
         related_address.SetIP(rtc::GetAnyIP(stun_candidate_addr.family()));
       }
-      EXPECT_PRED5(HasCandidateWithRelatedAddr, candidates_, "stun", "udp",
-                   rtc::SocketAddress(stun_candidate_addr, 0), related_address);
+      EXPECT_TRUE(HasCandidateWithRelatedAddr(
+          candidates_, "stun", "udp",
+          rtc::SocketAddress(stun_candidate_addr, 0), related_address));
       ++total_candidates;
     }
     if (!relay_candidate_udp_transport_addr.IsNil()) {
-      EXPECT_PRED5(HasCandidateWithRelatedAddr, candidates_, "relay", "udp",
-                   rtc::SocketAddress(relay_candidate_udp_transport_addr, 0),
-                   rtc::SocketAddress(stun_candidate_addr, 0));
+      EXPECT_TRUE(HasCandidateWithRelatedAddr(
+          candidates_, "relay", "udp",
+          rtc::SocketAddress(relay_candidate_udp_transport_addr, 0),
+          rtc::SocketAddress(stun_candidate_addr, 0)));
       ++total_candidates;
     }
     if (!relay_candidate_tcp_transport_addr.IsNil()) {
-      EXPECT_PRED5(HasCandidateWithRelatedAddr, candidates_, "relay", "udp",
-                   rtc::SocketAddress(relay_candidate_tcp_transport_addr, 0),
-                   rtc::SocketAddress(stun_candidate_addr, 0));
+      EXPECT_TRUE(HasCandidateWithRelatedAddr(
+          candidates_, "relay", "udp",
+          rtc::SocketAddress(relay_candidate_tcp_transport_addr, 0),
+          rtc::SocketAddress(stun_candidate_addr, 0)));
       ++total_candidates;
     }
 
@@ -604,9 +607,9 @@
     const std::vector<Candidate>& ready_candidates =
         session_->ReadyCandidates();
     EXPECT_EQ(3U, ready_candidates.size());
-    EXPECT_PRED4(HasCandidate, ready_candidates, "local", "udp", kClientAddr);
-    EXPECT_PRED4(HasCandidate, ready_candidates, "relay", "udp",
-                 rtc::SocketAddress(kTurnUdpExtAddr.ipaddr(), 0));
+    EXPECT_TRUE(HasCandidate(ready_candidates, "local", "udp", kClientAddr));
+    EXPECT_TRUE(HasCandidate(ready_candidates, "relay", "udp",
+                             rtc::SocketAddress(kTurnUdpExtAddr.ipaddr(), 0)));
   }
 
   void TestUdpTurnPortPrunesTcpTurnPort() {
@@ -644,9 +647,9 @@
     const std::vector<Candidate>& ready_candidates =
         session_->ReadyCandidates();
     EXPECT_EQ(2U, ready_candidates.size());
-    EXPECT_PRED4(HasCandidate, ready_candidates, "local", "udp", kClientAddr);
-    EXPECT_PRED4(HasCandidate, ready_candidates, "relay", "udp",
-                 rtc::SocketAddress(kTurnUdpExtAddr.ipaddr(), 0));
+    EXPECT_TRUE(HasCandidate(ready_candidates, "local", "udp", kClientAddr));
+    EXPECT_TRUE(HasCandidate(ready_candidates, "relay", "udp",
+                             rtc::SocketAddress(kTurnUdpExtAddr.ipaddr(), 0)));
   }
 
   void TestEachInterfaceHasItsOwnTurnPorts() {
@@ -694,20 +697,20 @@
     const std::vector<Candidate>& ready_candidates =
         session_->ReadyCandidates();
     EXPECT_EQ(10U, ready_candidates.size());
-    EXPECT_PRED4(HasCandidate, ready_candidates, "local", "udp", kClientAddr);
-    EXPECT_PRED4(HasCandidate, ready_candidates, "local", "udp", kClientAddr2);
-    EXPECT_PRED4(HasCandidate, ready_candidates, "local", "udp",
-                 kClientIPv6Addr);
-    EXPECT_PRED4(HasCandidate, ready_candidates, "local", "udp",
-                 kClientIPv6Addr2);
-    EXPECT_PRED4(HasCandidate, ready_candidates, "local", "tcp", kClientAddr);
-    EXPECT_PRED4(HasCandidate, ready_candidates, "local", "tcp", kClientAddr2);
-    EXPECT_PRED4(HasCandidate, ready_candidates, "local", "tcp",
-                 kClientIPv6Addr);
-    EXPECT_PRED4(HasCandidate, ready_candidates, "local", "tcp",
-                 kClientIPv6Addr2);
-    EXPECT_PRED4(HasCandidate, ready_candidates, "relay", "udp",
-                 rtc::SocketAddress(kTurnUdpExtAddr.ipaddr(), 0));
+    EXPECT_TRUE(HasCandidate(ready_candidates, "local", "udp", kClientAddr));
+    EXPECT_TRUE(HasCandidate(ready_candidates, "local", "udp", kClientAddr2));
+    EXPECT_TRUE(
+        HasCandidate(ready_candidates, "local", "udp", kClientIPv6Addr));
+    EXPECT_TRUE(
+        HasCandidate(ready_candidates, "local", "udp", kClientIPv6Addr2));
+    EXPECT_TRUE(HasCandidate(ready_candidates, "local", "tcp", kClientAddr));
+    EXPECT_TRUE(HasCandidate(ready_candidates, "local", "tcp", kClientAddr2));
+    EXPECT_TRUE(
+        HasCandidate(ready_candidates, "local", "tcp", kClientIPv6Addr));
+    EXPECT_TRUE(
+        HasCandidate(ready_candidates, "local", "tcp", kClientIPv6Addr2));
+    EXPECT_TRUE(HasCandidate(ready_candidates, "relay", "udp",
+                             rtc::SocketAddress(kTurnUdpExtAddr.ipaddr(), 0)));
   }
 };
 
@@ -791,7 +794,7 @@
                              kDefaultAllocationTimeout, fake_clock);
   // Should only get one Wi-Fi candidate.
   EXPECT_EQ(1U, candidates_.size());
-  EXPECT_PRED4(HasCandidate, candidates_, "local", "udp", wifi);
+  EXPECT_TRUE(HasCandidate(candidates_, "local", "udp", wifi));
 }
 
 // Test that when the PORTALLOCATOR_DISABLE_COSTLY_NETWORKS flag is set and
@@ -817,8 +820,8 @@
                              kDefaultAllocationTimeout, fake_clock);
   // Should only get two candidates, none of which is cell.
   EXPECT_EQ(2U, candidates_.size());
-  EXPECT_PRED4(HasCandidate, candidates_, "local", "udp", unknown1);
-  EXPECT_PRED4(HasCandidate, candidates_, "local", "udp", unknown2);
+  EXPECT_TRUE(HasCandidate(candidates_, "local", "udp", unknown1));
+  EXPECT_TRUE(HasCandidate(candidates_, "local", "udp", unknown2));
 }
 
 // Test that when the PORTALLOCATOR_DISABLE_COSTLY_NETWORKS flag is set and
@@ -845,7 +848,7 @@
                              kDefaultAllocationTimeout, fake_clock);
   // Should only get one Wi-Fi candidate.
   EXPECT_EQ(1U, candidates_.size());
-  EXPECT_PRED4(HasCandidate, candidates_, "local", "udp", wifi);
+  EXPECT_TRUE(HasCandidate(candidates_, "local", "udp", wifi));
 }
 
 // Test that if the PORTALLOCATOR_DISABLE_COSTLY_NETWORKS flag is set, but the
@@ -866,7 +869,7 @@
                              kDefaultAllocationTimeout, fake_clock);
   // Make sure we got the cell candidate.
   EXPECT_EQ(1U, candidates_.size());
-  EXPECT_PRED4(HasCandidate, candidates_, "local", "udp", cellular);
+  EXPECT_TRUE(HasCandidate(candidates_, "local", "udp", cellular));
 }
 
 // Test that if both PORTALLOCATOR_DISABLE_COSTLY_NETWORKS is set, and there is
@@ -889,8 +892,8 @@
                              kDefaultAllocationTimeout, fake_clock);
   // Make sure we got both wifi and cell candidates.
   EXPECT_EQ(2U, candidates_.size());
-  EXPECT_PRED4(HasCandidate, candidates_, "local", "udp", wifi_link_local);
-  EXPECT_PRED4(HasCandidate, candidates_, "local", "udp", cellular);
+  EXPECT_TRUE(HasCandidate(candidates_, "local", "udp", wifi_link_local));
+  EXPECT_TRUE(HasCandidate(candidates_, "local", "udp", cellular));
 }
 
 // Test that if both PORTALLOCATOR_DISABLE_COSTLY_NETWORKS is set, and there is
@@ -916,8 +919,8 @@
                              kDefaultAllocationTimeout, fake_clock);
   // Make sure we got only wifi candidates.
   EXPECT_EQ(2U, candidates_.size());
-  EXPECT_PRED4(HasCandidate, candidates_, "local", "udp", wifi);
-  EXPECT_PRED4(HasCandidate, candidates_, "local", "udp", wifi_link_local);
+  EXPECT_TRUE(HasCandidate(candidates_, "local", "udp", wifi));
+  EXPECT_TRUE(HasCandidate(candidates_, "local", "udp", wifi_link_local));
 }
 
 // Test that no more than allocator.max_ipv6_networks() IPv6 networks are used
@@ -940,8 +943,8 @@
                              kDefaultAllocationTimeout, fake_clock);
   EXPECT_EQ(2U, candidates_.size());
   // Ensure the expected two interfaces (eth0 and eth1) were used.
-  EXPECT_PRED4(HasCandidate, candidates_, "local", "udp", kClientIPv6Addr);
-  EXPECT_PRED4(HasCandidate, candidates_, "local", "udp", kClientIPv6Addr2);
+  EXPECT_TRUE(HasCandidate(candidates_, "local", "udp", kClientIPv6Addr));
+  EXPECT_TRUE(HasCandidate(candidates_, "local", "udp", kClientIPv6Addr2));
 }
 
 // Ensure that allocator.max_ipv6_networks() doesn't prevent IPv4 networks from
@@ -966,9 +969,9 @@
   EXPECT_EQ(3U, candidates_.size());
   // Ensure that only one IPv6 interface was used, but both IPv4 interfaces
   // were used.
-  EXPECT_PRED4(HasCandidate, candidates_, "local", "udp", kClientIPv6Addr);
-  EXPECT_PRED4(HasCandidate, candidates_, "local", "udp", kClientAddr);
-  EXPECT_PRED4(HasCandidate, candidates_, "local", "udp", kClientAddr2);
+  EXPECT_TRUE(HasCandidate(candidates_, "local", "udp", kClientIPv6Addr));
+  EXPECT_TRUE(HasCandidate(candidates_, "local", "udp", kClientAddr));
+  EXPECT_TRUE(HasCandidate(candidates_, "local", "udp", kClientAddr2));
 }
 
 // Test that we could use loopback interface as host candidate.
@@ -993,14 +996,14 @@
                              kDefaultAllocationTimeout, fake_clock);
   EXPECT_EQ(7U, candidates_.size());
   EXPECT_EQ(4U, ports_.size());
-  EXPECT_PRED4(HasCandidate, candidates_, "local", "udp", kClientAddr);
-  EXPECT_PRED4(HasCandidate, candidates_, "stun", "udp", kClientAddr);
-  EXPECT_PRED4(HasCandidate, candidates_, "relay", "udp", kRelayUdpIntAddr);
-  EXPECT_PRED4(HasCandidate, candidates_, "relay", "udp", kRelayUdpExtAddr);
-  EXPECT_PRED4(HasCandidate, candidates_, "relay", "tcp", kRelayTcpIntAddr);
-  EXPECT_PRED4(HasCandidate, candidates_, "local", "tcp", kClientAddr);
-  EXPECT_PRED4(HasCandidate, candidates_, "relay", "ssltcp",
-               kRelaySslTcpIntAddr);
+  EXPECT_TRUE(HasCandidate(candidates_, "local", "udp", kClientAddr));
+  EXPECT_TRUE(HasCandidate(candidates_, "stun", "udp", kClientAddr));
+  EXPECT_TRUE(HasCandidate(candidates_, "relay", "udp", kRelayUdpIntAddr));
+  EXPECT_TRUE(HasCandidate(candidates_, "relay", "udp", kRelayUdpExtAddr));
+  EXPECT_TRUE(HasCandidate(candidates_, "relay", "tcp", kRelayTcpIntAddr));
+  EXPECT_TRUE(HasCandidate(candidates_, "local", "tcp", kClientAddr));
+  EXPECT_TRUE(
+      HasCandidate(candidates_, "relay", "ssltcp", kRelaySslTcpIntAddr));
 }
 
 // Test that when the same network interface is brought down and up, the
@@ -1092,7 +1095,7 @@
   // a single TCP active candidate, since that doesn't require creating a
   // socket).
   ASSERT_EQ(1U, candidates_.size());
-  EXPECT_PRED4(HasCandidate, candidates_, "local", "tcp", kClientAddr);
+  EXPECT_TRUE(HasCandidate(candidates_, "local", "tcp", kClientAddr));
   candidate_allocation_done_ = false;
 
   // Now simulate the interface coming up, with the newfound ability to bind
@@ -1104,11 +1107,11 @@
                              kDefaultAllocationTimeout, fake_clock);
   // Should get UDP and TCP candidate.
   ASSERT_EQ(2U, candidates_.size());
-  EXPECT_PRED4(HasCandidate, candidates_, "local", "udp", kClientAddr);
+  EXPECT_TRUE(HasCandidate(candidates_, "local", "udp", kClientAddr));
   // TODO(deadbeef): This is actually the same active TCP candidate as before.
   // We should extend this test to also verify that a server candidate is
   // gathered.
-  EXPECT_PRED4(HasCandidate, candidates_, "local", "tcp", kClientAddr);
+  EXPECT_TRUE(HasCandidate(candidates_, "local", "tcp", kClientAddr));
 }
 
 // Verify candidates with default step delay of 1sec.
@@ -1121,13 +1124,13 @@
   EXPECT_EQ(2U, ports_.size());
   ASSERT_EQ_SIMULATED_WAIT(6U, candidates_.size(), 2000, fake_clock);
   EXPECT_EQ(3U, ports_.size());
-  EXPECT_PRED4(HasCandidate, candidates_, "relay", "udp", kRelayUdpIntAddr);
-  EXPECT_PRED4(HasCandidate, candidates_, "relay", "udp", kRelayUdpExtAddr);
-  EXPECT_PRED4(HasCandidate, candidates_, "relay", "tcp", kRelayTcpIntAddr);
-  EXPECT_PRED4(HasCandidate, candidates_, "relay", "ssltcp",
-               kRelaySslTcpIntAddr);
+  EXPECT_TRUE(HasCandidate(candidates_, "relay", "udp", kRelayUdpIntAddr));
+  EXPECT_TRUE(HasCandidate(candidates_, "relay", "udp", kRelayUdpExtAddr));
+  EXPECT_TRUE(HasCandidate(candidates_, "relay", "tcp", kRelayTcpIntAddr));
+  EXPECT_TRUE(
+      HasCandidate(candidates_, "relay", "ssltcp", kRelaySslTcpIntAddr));
   ASSERT_EQ_SIMULATED_WAIT(7U, candidates_.size(), 1500, fake_clock);
-  EXPECT_PRED4(HasCandidate, candidates_, "local", "tcp", kClientAddr);
+  EXPECT_TRUE(HasCandidate(candidates_, "local", "tcp", kClientAddr));
   EXPECT_EQ(4U, ports_.size());
   EXPECT_TRUE(candidate_allocation_done_);
   // If we Stop gathering now, we shouldn't get a second "done" callback.
@@ -1184,14 +1187,14 @@
   for (const Candidate& candidate : candidates_) {
     // Check the port number for the UDP/STUN/TCP port objects.
     if (candidate.type() != RELAY_PORT_TYPE) {
-      EXPECT_PRED3(CheckPort, candidate.address(), kMinPort, kMaxPort);
+      EXPECT_TRUE(CheckPort(candidate.address(), kMinPort, kMaxPort));
       ++num_nonrelay_candidates;
     }
   }
   EXPECT_EQ(3, num_nonrelay_candidates);
   // Check the port number used to connect to the relay server.
-  EXPECT_PRED3(CheckPort, relay_server_.GetConnection(0).source(), kMinPort,
-               kMaxPort);
+  EXPECT_TRUE(
+      CheckPort(relay_server_.GetConnection(0).source(), kMinPort, kMaxPort));
 }
 
 // Test that if we have no network adapters, we bind to the ANY address and
@@ -1221,8 +1224,8 @@
   // candidate for it is useless and shouldn't be signaled. So we only have
   // STUN/TURN candidates.
   EXPECT_EQ(3U, candidates_.size());
-  EXPECT_PRED4(HasCandidate, candidates_, "stun", "udp",
-               rtc::SocketAddress(kNatUdpAddr.ipaddr(), 0));
+  EXPECT_TRUE(HasCandidate(candidates_, "stun", "udp",
+                           rtc::SocketAddress(kNatUdpAddr.ipaddr(), 0)));
   // Again, two TURN candidates, using UDP/TCP for the first hop to the TURN
   // server.
   EXPECT_EQ(2,
@@ -1355,11 +1358,11 @@
   EXPECT_EQ(2U, ports_.size());
   EXPECT_EQ(2U, candidates_.size());
   Candidate turn_candidate;
-  EXPECT_PRED5(FindCandidate, candidates_, "relay", "udp", kTurnUdpExtAddr,
-               &turn_candidate);
+  EXPECT_TRUE(FindCandidate(candidates_, "relay", "udp", kTurnUdpExtAddr,
+                            &turn_candidate));
   // The TURN candidate should use TCP to contact the TURN server.
   EXPECT_EQ(TCP_PROTOCOL_NAME, turn_candidate.relay_protocol());
-  EXPECT_PRED4(HasCandidate, candidates_, "local", "tcp", kClientAddr);
+  EXPECT_TRUE(HasCandidate(candidates_, "local", "tcp", kClientAddr));
 }
 
 // Disable for asan, see
@@ -1388,12 +1391,12 @@
                              kDefaultAllocationTimeout, fake_clock);
   EXPECT_EQ(5U, candidates_.size());
   EXPECT_EQ(2U, ports_.size());
-  EXPECT_PRED4(HasCandidate, candidates_, "relay", "udp", kRelayUdpIntAddr);
-  EXPECT_PRED4(HasCandidate, candidates_, "relay", "udp", kRelayUdpExtAddr);
-  EXPECT_PRED4(HasCandidate, candidates_, "relay", "tcp", kRelayTcpIntAddr);
-  EXPECT_PRED4(HasCandidate, candidates_, "local", "tcp", kClientAddr);
-  EXPECT_PRED4(HasCandidate, candidates_, "relay", "ssltcp",
-               kRelaySslTcpIntAddr);
+  EXPECT_TRUE(HasCandidate(candidates_, "relay", "udp", kRelayUdpIntAddr));
+  EXPECT_TRUE(HasCandidate(candidates_, "relay", "udp", kRelayUdpExtAddr));
+  EXPECT_TRUE(HasCandidate(candidates_, "relay", "tcp", kRelayTcpIntAddr));
+  EXPECT_TRUE(HasCandidate(candidates_, "local", "tcp", kClientAddr));
+  EXPECT_TRUE(
+      HasCandidate(candidates_, "relay", "ssltcp", kRelaySslTcpIntAddr));
 }
 
 #endif  // if !defined(ADDRESS_SANITIZER)
@@ -1411,12 +1414,12 @@
                              kDefaultAllocationTimeout, fake_clock);
   EXPECT_EQ(5U, candidates_.size());
   EXPECT_EQ(2U, ports_.size());
-  EXPECT_PRED4(HasCandidate, candidates_, "relay", "udp", kRelayUdpIntAddr);
-  EXPECT_PRED4(HasCandidate, candidates_, "relay", "udp", kRelayUdpExtAddr);
-  EXPECT_PRED4(HasCandidate, candidates_, "relay", "tcp", kRelayTcpIntAddr);
-  EXPECT_PRED4(HasCandidate, candidates_, "local", "tcp", kClientAddr);
-  EXPECT_PRED4(HasCandidate, candidates_, "relay", "ssltcp",
-               kRelaySslTcpIntAddr);
+  EXPECT_TRUE(HasCandidate(candidates_, "relay", "udp", kRelayUdpIntAddr));
+  EXPECT_TRUE(HasCandidate(candidates_, "relay", "udp", kRelayUdpExtAddr));
+  EXPECT_TRUE(HasCandidate(candidates_, "relay", "tcp", kRelayTcpIntAddr));
+  EXPECT_TRUE(HasCandidate(candidates_, "local", "tcp", kClientAddr));
+  EXPECT_TRUE(
+      HasCandidate(candidates_, "relay", "ssltcp", kRelaySslTcpIntAddr));
 }
 
 // Test that we don't crash or malfunction if we can't create any sockets.
@@ -1442,17 +1445,17 @@
   EXPECT_EQ_SIMULATED_WAIT(2U, candidates_.size(), kDefaultAllocationTimeout,
                            fake_clock);
   EXPECT_EQ(2U, ports_.size());
-  EXPECT_PRED4(HasCandidate, candidates_, "local", "udp", kClientAddr);
-  EXPECT_PRED4(HasCandidate, candidates_, "local", "tcp", kClientAddr);
+  EXPECT_TRUE(HasCandidate(candidates_, "local", "udp", kClientAddr));
+  EXPECT_TRUE(HasCandidate(candidates_, "local", "tcp", kClientAddr));
   // RelayPort connection timeout is 3sec. TCP connection with RelayServer
   // will be tried after about 3 seconds.
   EXPECT_EQ_SIMULATED_WAIT(6U, candidates_.size(), 3500, fake_clock);
   EXPECT_EQ(3U, ports_.size());
-  EXPECT_PRED4(HasCandidate, candidates_, "relay", "udp", kRelayUdpIntAddr);
-  EXPECT_PRED4(HasCandidate, candidates_, "relay", "tcp", kRelayTcpIntAddr);
-  EXPECT_PRED4(HasCandidate, candidates_, "relay", "ssltcp",
-               kRelaySslTcpIntAddr);
-  EXPECT_PRED4(HasCandidate, candidates_, "relay", "udp", kRelayUdpExtAddr);
+  EXPECT_TRUE(HasCandidate(candidates_, "relay", "udp", kRelayUdpIntAddr));
+  EXPECT_TRUE(HasCandidate(candidates_, "relay", "tcp", kRelayTcpIntAddr));
+  EXPECT_TRUE(
+      HasCandidate(candidates_, "relay", "ssltcp", kRelaySslTcpIntAddr));
+  EXPECT_TRUE(HasCandidate(candidates_, "relay", "udp", kRelayUdpExtAddr));
   // We wait at least for a full STUN timeout, which
   // cricket::STUN_TOTAL_TIMEOUT seconds.  But since 3-3.5 seconds
   // already passed (see above), we wait 3 seconds less than that.
@@ -1521,8 +1524,8 @@
   session_->StartGettingPorts();
   EXPECT_TRUE_SIMULATED_WAIT(candidate_allocation_done_,
                              kDefaultAllocationTimeout, fake_clock);
-  EXPECT_PRED4(HasCandidate, candidates_, "relay", "udp",
-               rtc::SocketAddress(kTurnUdpExtAddr.ipaddr(), 0));
+  EXPECT_TRUE(HasCandidate(candidates_, "relay", "udp",
+                           rtc::SocketAddress(kTurnUdpExtAddr.ipaddr(), 0)));
 
   EXPECT_EQ(1U, candidates_.size());
   EXPECT_EQ(1U, ports_.size());  // Only Relay port will be in ready state.
@@ -1593,9 +1596,9 @@
   ASSERT_TRUE_SIMULATED_WAIT(candidate_allocation_done_,
                              kDefaultAllocationTimeout, fake_clock);
   EXPECT_EQ(7U, candidates_.size());
-  EXPECT_PRED4(HasCandidate, candidates_, "local", "udp", kClientAddr);
-  EXPECT_PRED4(HasCandidate, candidates_, "stun", "udp", kClientAddr);
-  EXPECT_PRED4(HasCandidate, candidates_, "local", "tcp", kClientAddr);
+  EXPECT_TRUE(HasCandidate(candidates_, "local", "udp", kClientAddr));
+  EXPECT_TRUE(HasCandidate(candidates_, "stun", "udp", kClientAddr));
+  EXPECT_TRUE(HasCandidate(candidates_, "local", "tcp", kClientAddr));
   EXPECT_EQ(4U, ports_.size());
   for (const Candidate& candidate : candidates_) {
     EXPECT_EQ(kIceUfrag0, candidate.username());
@@ -1616,7 +1619,7 @@
   ASSERT_EQ_SIMULATED_WAIT(6U, candidates_.size(), kDefaultAllocationTimeout,
                            fake_clock);
   EXPECT_EQ(3U, ports_.size());
-  EXPECT_PRED4(HasCandidate, candidates_, "local", "udp", kClientAddr);
+  EXPECT_TRUE(HasCandidate(candidates_, "local", "udp", kClientAddr));
   EXPECT_TRUE_SIMULATED_WAIT(candidate_allocation_done_,
                              kDefaultAllocationTimeout, fake_clock);
 }
@@ -1635,9 +1638,9 @@
   ASSERT_EQ_SIMULATED_WAIT(3U, candidates_.size(), kDefaultAllocationTimeout,
                            fake_clock);
   ASSERT_EQ(2U, ports_.size());
-  EXPECT_PRED4(HasCandidate, candidates_, "local", "udp", kClientAddr);
-  EXPECT_PRED4(HasCandidate, candidates_, "stun", "udp",
-               rtc::SocketAddress(kNatUdpAddr.ipaddr(), 0));
+  EXPECT_TRUE(HasCandidate(candidates_, "local", "udp", kClientAddr));
+  EXPECT_TRUE(HasCandidate(candidates_, "stun", "udp",
+                           rtc::SocketAddress(kNatUdpAddr.ipaddr(), 0)));
   EXPECT_TRUE_SIMULATED_WAIT(candidate_allocation_done_,
                              kDefaultAllocationTimeout, fake_clock);
   EXPECT_EQ(3U, candidates_.size());
@@ -1663,11 +1666,11 @@
                              kDefaultAllocationTimeout, fake_clock);
   ASSERT_EQ(3U, candidates_.size());
   ASSERT_EQ(3U, ports_.size());
-  EXPECT_PRED4(HasCandidate, candidates_, "local", "udp", kClientAddr);
-  EXPECT_PRED4(HasCandidate, candidates_, "relay", "udp",
-               rtc::SocketAddress(kTurnUdpExtAddr.ipaddr(), 0));
-  EXPECT_PRED4(HasCandidate, candidates_, "relay", "udp",
-               rtc::SocketAddress(kTurnUdpExtAddr.ipaddr(), 0));
+  EXPECT_TRUE(HasCandidate(candidates_, "local", "udp", kClientAddr));
+  EXPECT_TRUE(HasCandidate(candidates_, "relay", "udp",
+                           rtc::SocketAddress(kTurnUdpExtAddr.ipaddr(), 0)));
+  EXPECT_TRUE(HasCandidate(candidates_, "relay", "udp",
+                           rtc::SocketAddress(kTurnUdpExtAddr.ipaddr(), 0)));
 }
 
 // Test that if prune_turn_ports is set, TCP TURN port will not be used
@@ -1790,11 +1793,11 @@
                              kDefaultAllocationTimeout, fake_clock);
   EXPECT_EQ(3U, candidates_.size());
   ASSERT_EQ(2U, ports_.size());
-  EXPECT_PRED4(HasCandidate, candidates_, "local", "udp", kClientAddr);
-  EXPECT_PRED4(HasCandidate, candidates_, "stun", "udp",
-               rtc::SocketAddress(kNatUdpAddr.ipaddr(), 0));
-  EXPECT_PRED4(HasCandidate, candidates_, "relay", "udp",
-               rtc::SocketAddress(kTurnUdpExtAddr.ipaddr(), 0));
+  EXPECT_TRUE(HasCandidate(candidates_, "local", "udp", kClientAddr));
+  EXPECT_TRUE(HasCandidate(candidates_, "stun", "udp",
+                           rtc::SocketAddress(kNatUdpAddr.ipaddr(), 0)));
+  EXPECT_TRUE(HasCandidate(candidates_, "relay", "udp",
+                           rtc::SocketAddress(kTurnUdpExtAddr.ipaddr(), 0)));
   EXPECT_TRUE_SIMULATED_WAIT(candidate_allocation_done_,
                              kDefaultAllocationTimeout, fake_clock);
   // Local port will be created first and then TURN port.
@@ -1828,13 +1831,15 @@
   ASSERT_TRUE_SIMULATED_WAIT(candidate_allocation_done_,
                              kDefaultAllocationTimeout, fake_clock);
   EXPECT_EQ(3U, candidates_.size());
-  EXPECT_PRED4(HasCandidate, candidates_, "local", "udp", kClientAddr);
+  EXPECT_TRUE(HasCandidate(candidates_, "local", "udp", kClientAddr));
   Candidate stun_candidate;
-  EXPECT_PRED5(FindCandidate, candidates_, "stun", "udp",
-               rtc::SocketAddress(kNatUdpAddr.ipaddr(), 0), &stun_candidate);
-  EXPECT_PRED5(HasCandidateWithRelatedAddr, candidates_, "relay", "udp",
-               rtc::SocketAddress(kTurnUdpExtAddr.ipaddr(), 0),
-               stun_candidate.address());
+  EXPECT_TRUE(FindCandidate(candidates_, "stun", "udp",
+                            rtc::SocketAddress(kNatUdpAddr.ipaddr(), 0),
+                            &stun_candidate));
+  EXPECT_TRUE(HasCandidateWithRelatedAddr(
+      candidates_, "relay", "udp",
+      rtc::SocketAddress(kTurnUdpExtAddr.ipaddr(), 0),
+      stun_candidate.address()));
 
   // Local port will be created first and then TURN port.
   // TODO(deadbeef): This isn't something the BasicPortAllocator API contract
@@ -1863,9 +1868,9 @@
                              kDefaultAllocationTimeout, fake_clock);
   EXPECT_EQ(2U, candidates_.size());
   ASSERT_EQ(2U, ports_.size());
-  EXPECT_PRED4(HasCandidate, candidates_, "local", "udp", kClientAddr);
-  EXPECT_PRED4(HasCandidate, candidates_, "relay", "udp",
-               rtc::SocketAddress(kTurnUdpExtAddr.ipaddr(), 0));
+  EXPECT_TRUE(HasCandidate(candidates_, "local", "udp", kClientAddr));
+  EXPECT_TRUE(HasCandidate(candidates_, "relay", "udp",
+                           rtc::SocketAddress(kTurnUdpExtAddr.ipaddr(), 0)));
   EXPECT_EQ(1U, ports_[0]->Candidates().size());
   EXPECT_EQ(1U, ports_[1]->Candidates().size());
 }
@@ -1890,14 +1895,15 @@
                              kDefaultAllocationTimeout, fake_clock);
   EXPECT_EQ(3U, candidates_.size());
   ASSERT_EQ(3U, ports_.size());
-  EXPECT_PRED4(HasCandidate, candidates_, "local", "udp", kClientAddr);
+  EXPECT_TRUE(HasCandidate(candidates_, "local", "udp", kClientAddr));
   Candidate stun_candidate;
-  EXPECT_PRED5(FindCandidate, candidates_, "stun", "udp",
-               rtc::SocketAddress(kNatUdpAddr.ipaddr(), 0), &stun_candidate);
+  EXPECT_TRUE(FindCandidate(candidates_, "stun", "udp",
+                            rtc::SocketAddress(kNatUdpAddr.ipaddr(), 0),
+                            &stun_candidate));
   Candidate turn_candidate;
-  EXPECT_PRED5(FindCandidate, candidates_, "relay", "udp",
-               rtc::SocketAddress(kTurnUdpExtAddr.ipaddr(), 0),
-               &turn_candidate);
+  EXPECT_TRUE(FindCandidate(candidates_, "relay", "udp",
+                            rtc::SocketAddress(kTurnUdpExtAddr.ipaddr(), 0),
+                            &turn_candidate));
   // Not using shared socket, so the STUN request's server reflexive address
   // should be different than the TURN request's server reflexive address.
   EXPECT_NE(turn_candidate.related_address(), stun_candidate.address());
@@ -1926,13 +1932,15 @@
 
   ASSERT_EQ_SIMULATED_WAIT(3U, candidates_.size(), kDefaultAllocationTimeout,
                            fake_clock);
-  EXPECT_PRED4(HasCandidate, candidates_, "local", "udp", kClientAddr);
+  EXPECT_TRUE(HasCandidate(candidates_, "local", "udp", kClientAddr));
   Candidate stun_candidate;
-  EXPECT_PRED5(FindCandidate, candidates_, "stun", "udp",
-               rtc::SocketAddress(kNatUdpAddr.ipaddr(), 0), &stun_candidate);
-  EXPECT_PRED5(HasCandidateWithRelatedAddr, candidates_, "relay", "udp",
-               rtc::SocketAddress(kTurnUdpExtAddr.ipaddr(), 0),
-               stun_candidate.address());
+  EXPECT_TRUE(FindCandidate(candidates_, "stun", "udp",
+                            rtc::SocketAddress(kNatUdpAddr.ipaddr(), 0),
+                            &stun_candidate));
+  EXPECT_TRUE(HasCandidateWithRelatedAddr(
+      candidates_, "relay", "udp",
+      rtc::SocketAddress(kTurnUdpExtAddr.ipaddr(), 0),
+      stun_candidate.address()));
 
   // Don't bother waiting for STUN timeout, since we already verified
   // that we got a STUN candidate from the TURN server.
@@ -1952,7 +1960,7 @@
   ASSERT_EQ_SIMULATED_WAIT(1U, ports_.size(), kDefaultAllocationTimeout,
                            fake_clock);
   EXPECT_EQ(1U, candidates_.size());
-  EXPECT_PRED4(HasCandidate, candidates_, "local", "udp", kClientAddr);
+  EXPECT_TRUE(HasCandidate(candidates_, "local", "udp", kClientAddr));
   // STUN timeout is 9.5sec. We need to wait to get candidate done signal.
   EXPECT_TRUE_SIMULATED_WAIT(candidate_allocation_done_, kStunTimeoutMs,
                              fake_clock);
@@ -1978,7 +1986,7 @@
   EXPECT_EQ_SIMULATED_WAIT(1U, ports_.size(), kDefaultAllocationTimeout,
                            fake_clock);
   EXPECT_EQ(1U, candidates_.size());
-  EXPECT_PRED4(HasCandidate, candidates_, "local", "udp", kPrivateAddr);
+  EXPECT_TRUE(HasCandidate(candidates_, "local", "udp", kPrivateAddr));
   EXPECT_NE(0U, session_->flags() & PORTALLOCATOR_DISABLE_ADAPTER_ENUMERATION);
 }
 
@@ -1996,10 +2004,10 @@
                              kDefaultAllocationTimeout, fake_clock);
   EXPECT_EQ(4U, ports_.size());
   EXPECT_EQ(4U, candidates_.size());
-  EXPECT_PRED4(HasCandidate, candidates_, "local", "udp", kClientIPv6Addr);
-  EXPECT_PRED4(HasCandidate, candidates_, "local", "udp", kClientAddr);
-  EXPECT_PRED4(HasCandidate, candidates_, "local", "tcp", kClientIPv6Addr);
-  EXPECT_PRED4(HasCandidate, candidates_, "local", "tcp", kClientAddr);
+  EXPECT_TRUE(HasCandidate(candidates_, "local", "udp", kClientIPv6Addr));
+  EXPECT_TRUE(HasCandidate(candidates_, "local", "udp", kClientAddr));
+  EXPECT_TRUE(HasCandidate(candidates_, "local", "tcp", kClientIPv6Addr));
+  EXPECT_TRUE(HasCandidate(candidates_, "local", "tcp", kClientAddr));
 }
 
 TEST_F(BasicPortAllocatorTest, TestStopGettingPorts) {
diff --git a/pc/peerconnection_ice_unittest.cc b/pc/peerconnection_ice_unittest.cc
index edf2bf8..e8f450f 100644
--- a/pc/peerconnection_ice_unittest.cc
+++ b/pc/peerconnection_ice_unittest.cc
@@ -527,7 +527,7 @@
     if (candidate_ip == address.ipaddr()) {
       return ::testing::AssertionSuccess();
     }
-    candidate_hosts << "\n" << candidate_ip;
+    candidate_hosts << "\n" << candidate_ip.ToString();
   }
   return ::testing::AssertionFailure()
          << address_expr << " (host " << address.HostAsURIString()
diff --git a/rtc_base/ipaddress_unittest.cc b/rtc_base/ipaddress_unittest.cc
index 90c9559..3698d3f 100644
--- a/rtc_base/ipaddress_unittest.cc
+++ b/rtc_base/ipaddress_unittest.cc
@@ -288,39 +288,39 @@
   IPAddress addr(v4addr);
   IPAddress addr2(addr);
 
-  EXPECT_PRED2(AreEqual, addr, addr2);
+  EXPECT_TRUE(AreEqual(addr, addr2));
 
   addr = IPAddress(INADDR_ANY);
   addr2 = IPAddress(addr);
-  EXPECT_PRED2(AreEqual, addr, addr2);
+  EXPECT_TRUE(AreEqual(addr, addr2));
 
   addr = IPAddress(INADDR_LOOPBACK);
   addr2 = IPAddress(addr);
-  EXPECT_PRED2(AreEqual, addr, addr2);
+  EXPECT_TRUE(AreEqual(addr, addr2));
 
   addr = IPAddress(kIPv4PublicAddr);
   addr2 = IPAddress(addr);
-  EXPECT_PRED2(AreEqual, addr, addr2);
+  EXPECT_TRUE(AreEqual(addr, addr2));
 
   addr = IPAddress(kIPv4RFC1918Addr);
   addr2 = IPAddress(addr);
-  EXPECT_PRED2(AreEqual, addr, addr2);
+  EXPECT_TRUE(AreEqual(addr, addr2));
 
   addr = IPAddress(in6addr_any);
   addr2 = IPAddress(addr);
-  EXPECT_PRED2(AreEqual, addr, addr2);
+  EXPECT_TRUE(AreEqual(addr, addr2));
 
   addr = IPAddress(in6addr_loopback);
   addr2 = IPAddress(addr);
-  EXPECT_PRED2(AreEqual, addr, addr2);
+  EXPECT_TRUE(AreEqual(addr, addr2));
 
   addr = IPAddress(kIPv6LinkLocalAddr);
   addr2 = IPAddress(addr);
-  EXPECT_PRED2(AreEqual, addr, addr2);
+  EXPECT_TRUE(AreEqual(addr, addr2));
 
   addr = IPAddress(kIPv6PublicAddr);
   addr2 = IPAddress(addr);
-  EXPECT_PRED2(AreEqual, addr, addr2);
+  EXPECT_TRUE(AreEqual(addr, addr2));
 }
 
 TEST(IPAddressTest, TestEquality) {
@@ -446,46 +446,46 @@
 
   EXPECT_TRUE(IPFromString(kIPv4AnyAddrString, &addr));
   EXPECT_EQ(addr.ToString(), kIPv4AnyAddrString);
-  EXPECT_PRED2(AreEqual, addr, addr2);
+  EXPECT_TRUE(AreEqual(addr, addr2));
 
   addr2 = IPAddress(INADDR_LOOPBACK);
   EXPECT_TRUE(IPFromString(kIPv4LoopbackAddrString, &addr));
   EXPECT_EQ(addr.ToString(), kIPv4LoopbackAddrString);
-  EXPECT_PRED2(AreEqual, addr, addr2);
+  EXPECT_TRUE(AreEqual(addr, addr2));
 
   addr2 = IPAddress(kIPv4RFC1918Addr);
   EXPECT_TRUE(IPFromString(kIPv4RFC1918AddrString, &addr));
   EXPECT_EQ(addr.ToString(), kIPv4RFC1918AddrString);
-  EXPECT_PRED2(AreEqual, addr, addr2);
+  EXPECT_TRUE(AreEqual(addr, addr2));
 
   addr2 = IPAddress(kIPv4PublicAddr);
   EXPECT_TRUE(IPFromString(kIPv4PublicAddrString, &addr));
   EXPECT_EQ(addr.ToString(), kIPv4PublicAddrString);
-  EXPECT_PRED2(AreEqual, addr, addr2);
+  EXPECT_TRUE(AreEqual(addr, addr2));
 
   addr2 = IPAddress(in6addr_any);
   EXPECT_TRUE(IPFromString(kIPv6AnyAddrString, &addr));
   EXPECT_EQ(addr.ToString(), kIPv6AnyAddrString);
-  EXPECT_PRED2(AreEqual, addr, addr2);
+  EXPECT_TRUE(AreEqual(addr, addr2));
 
   addr2 = IPAddress(in6addr_loopback);
   EXPECT_TRUE(IPFromString(kIPv6LoopbackAddrString, &addr));
   EXPECT_EQ(addr.ToString(), kIPv6LoopbackAddrString);
-  EXPECT_PRED2(AreEqual, addr, addr2);
+  EXPECT_TRUE(AreEqual(addr, addr2));
 
   addr2 = IPAddress(kIPv6LinkLocalAddr);
   EXPECT_TRUE(IPFromString(kIPv6LinkLocalAddrString, &addr));
   EXPECT_EQ(addr.ToString(), kIPv6LinkLocalAddrString);
-  EXPECT_PRED2(AreEqual, addr, addr2);
+  EXPECT_TRUE(AreEqual(addr, addr2));
 
   addr2 = IPAddress(kIPv6PublicAddr);
   EXPECT_TRUE(IPFromString(kIPv6PublicAddrString, &addr));
   EXPECT_EQ(addr.ToString(), kIPv6PublicAddrString);
-  EXPECT_PRED2(AreEqual, addr, addr2);
+  EXPECT_TRUE(AreEqual(addr, addr2));
 
   addr2 = IPAddress(kIPv4MappedRFC1918Addr);
   EXPECT_TRUE(IPFromString(kIPv4MappedV4StyleAddrString, &addr));
-  EXPECT_PRED2(AreEqual, addr, addr2);
+  EXPECT_TRUE(AreEqual(addr, addr2));
 
   // Broken cases, should set addr to AF_UNSPEC.
   EXPECT_PRED1(BrokenIPStringFails, kIPv4BrokenString1);
diff --git a/rtc_base/nat_unittest.cc b/rtc_base/nat_unittest.cc
index d68df1d..68f0f1c 100644
--- a/rtc_base/nat_unittest.cc
+++ b/rtc_base/nat_unittest.cc
@@ -232,11 +232,12 @@
     }
   }
   if (ext_addr2.IsNil()) {
-    RTC_LOG(LS_WARNING) << "No available IP of same family as " << int_addr;
+    RTC_LOG(LS_WARNING) << "No available IP of same family as "
+                        << int_addr.ToString();
     return;
   }
 
-  RTC_LOG(LS_INFO) << "selected ip " << ext_addr2.ipaddr();
+  RTC_LOG(LS_INFO) << "selected ip " << ext_addr2.ipaddr().ToString();
 
   SocketAddress ext_addrs[4] = {
       SocketAddress(ext_addr1),
diff --git a/rtc_base/physicalsocketserver_unittest.cc b/rtc_base/physicalsocketserver_unittest.cc
index d09385bb..81f1c9d 100644
--- a/rtc_base/physicalsocketserver_unittest.cc
+++ b/rtc_base/physicalsocketserver_unittest.cc
@@ -201,13 +201,13 @@
       server_->CreateAsyncSocket(loopback.family(), SOCK_STREAM));
   sink.Monitor(client1.get());
   EXPECT_EQ(AsyncSocket::CS_CLOSED, client1->GetState());
-  EXPECT_PRED1(IsUnspecOrEmptyIP, client1->GetLocalAddress().ipaddr());
+  EXPECT_TRUE(IsUnspecOrEmptyIP(client1->GetLocalAddress().ipaddr()));
 
   std::unique_ptr<AsyncSocket> client2(
       server_->CreateAsyncSocket(loopback.family(), SOCK_STREAM));
   sink.Monitor(client2.get());
   EXPECT_EQ(AsyncSocket::CS_CLOSED, client2->GetState());
-  EXPECT_PRED1(IsUnspecOrEmptyIP, client2->GetLocalAddress().ipaddr());
+  EXPECT_TRUE(IsUnspecOrEmptyIP(client2->GetLocalAddress().ipaddr()));
 
   // Create server and listen.
   std::unique_ptr<AsyncSocket> server(
diff --git a/rtc_base/socket_unittest.cc b/rtc_base/socket_unittest.cc
index a31cc02..be958d3 100644
--- a/rtc_base/socket_unittest.cc
+++ b/rtc_base/socket_unittest.cc
@@ -224,7 +224,7 @@
       ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM));
   sink.Monitor(client.get());
   EXPECT_EQ(AsyncSocket::CS_CLOSED, client->GetState());
-  EXPECT_PRED1(IsUnspecOrEmptyIP, client->GetLocalAddress().ipaddr());
+  EXPECT_TRUE(IsUnspecOrEmptyIP(client->GetLocalAddress().ipaddr()));
 
   // Create server and listen.
   std::unique_ptr<AsyncSocket> server(
diff --git a/rtc_base/socketaddress.cc b/rtc_base/socketaddress.cc
index 54a41d4..bddb7bc 100644
--- a/rtc_base/socketaddress.cc
+++ b/rtc_base/socketaddress.cc
@@ -26,12 +26,11 @@
 #include <unistd.h>
 #endif
 
-#include <sstream>
-
 #include "rtc_base/byteorder.h"
 #include "rtc_base/checks.h"
 #include "rtc_base/logging.h"
 #include "rtc_base/nethelpers.h"
+#include "rtc_base/strings/string_builder.h"
 
 #if defined(WEBRTC_WIN)
 #include "rtc_base/win32.h"
@@ -161,21 +160,21 @@
 }
 
 std::string SocketAddress::PortAsString() const {
-  std::ostringstream ost;
-  ost << port_;
-  return ost.str();
+  return std::to_string(port_);
 }
 
 std::string SocketAddress::ToString() const {
-  std::ostringstream ost;
-  ost << *this;
-  return ost.str();
+  char buf[1024];
+  rtc::SimpleStringBuilder sb(buf);
+  sb << HostAsURIString() << ":" << port();
+  return sb.str();
 }
 
 std::string SocketAddress::ToSensitiveString() const {
-  std::ostringstream ost;
-  ost << HostAsSensitiveURIString() << ":" << port();
-  return ost.str();
+  char buf[1024];
+  rtc::SimpleStringBuilder sb(buf);
+  sb << HostAsSensitiveURIString() << ":" << port();
+  return sb.str();
 }
 
 bool SocketAddress::FromString(const std::string& str) {
diff --git a/rtc_base/socketaddress_unittest.cc b/rtc_base/socketaddress_unittest.cc
index 0d168df..fb195b6 100644
--- a/rtc_base/socketaddress_unittest.cc
+++ b/rtc_base/socketaddress_unittest.cc
@@ -255,34 +255,34 @@
 TEST(SocketAddressTest, TestEqualityOperators) {
   SocketAddress addr1("1.2.3.4", 5678);
   SocketAddress addr2("1.2.3.4", 5678);
-  EXPECT_PRED2(AreEqual, addr1, addr2);
+  EXPECT_TRUE(AreEqual(addr1, addr2));
 
   addr2 = SocketAddress("0.0.0.1", 5678);
-  EXPECT_PRED2(AreUnequal, addr1, addr2);
+  EXPECT_TRUE(AreUnequal(addr1, addr2));
 
   addr2 = SocketAddress("1.2.3.4", 1234);
-  EXPECT_PRED2(AreUnequal, addr1, addr2);
+  EXPECT_TRUE(AreUnequal(addr1, addr2));
 
   addr2 = SocketAddress(kTestV6AddrString, 5678);
-  EXPECT_PRED2(AreUnequal, addr1, addr2);
+  EXPECT_TRUE(AreUnequal(addr1, addr2));
 
   addr1 = SocketAddress(kTestV6AddrString, 5678);
-  EXPECT_PRED2(AreEqual, addr1, addr2);
+  EXPECT_TRUE(AreEqual(addr1, addr2));
 
   addr2 = SocketAddress(kTestV6AddrString, 1234);
-  EXPECT_PRED2(AreUnequal, addr1, addr2);
+  EXPECT_TRUE(AreUnequal(addr1, addr2));
 
   addr2 = SocketAddress("fe80::1", 5678);
-  EXPECT_PRED2(AreUnequal, addr1, addr2);
+  EXPECT_TRUE(AreUnequal(addr1, addr2));
 
   SocketAddress addr3("a.b.c.d", 1);
   SocketAddress addr4("b.b.c.d", 1);
-  EXPECT_PRED2(AreUnequal, addr3, addr4);
-  EXPECT_PRED2(AreEqual, addr3, addr3);
+  EXPECT_TRUE(AreUnequal(addr3, addr4));
+  EXPECT_TRUE(AreEqual(addr3, addr3));
 
   addr3.SetIP(addr1.ip());
   addr4.SetIP(addr1.ip());
-  EXPECT_PRED2(AreEqual,addr3, addr4);
+  EXPECT_TRUE(AreEqual(addr3, addr4));
 }
 
 bool IsLessThan(const SocketAddress& addr1, const SocketAddress& addr2) {
@@ -299,19 +299,19 @@
   EXPECT_FALSE(addr2 < addr1);
 
   addr2 = SocketAddress("1.2.3.4", 5679);
-  EXPECT_PRED2(IsLessThan, addr1, addr2);
+  EXPECT_TRUE(IsLessThan(addr1, addr2));
 
   addr2 = SocketAddress("2.2.3.4", 49152);
-  EXPECT_PRED2(IsLessThan, addr1, addr2);
+  EXPECT_TRUE(IsLessThan(addr1, addr2));
 
   addr2 = SocketAddress(kTestV6AddrString, 5678);
-  EXPECT_PRED2(IsLessThan, addr1, addr2);
+  EXPECT_TRUE(IsLessThan(addr1, addr2));
 
   addr1 = SocketAddress("fe80::1", 5678);
-  EXPECT_PRED2(IsLessThan, addr2, addr1);
+  EXPECT_TRUE(IsLessThan(addr2, addr1));
 
   addr2 = SocketAddress("fe80::1", 5679);
-  EXPECT_PRED2(IsLessThan, addr1, addr2);
+  EXPECT_TRUE(IsLessThan(addr1, addr2));
 
   addr2 = SocketAddress("fe80::1", 5678);
   EXPECT_FALSE(addr1 < addr2);
@@ -319,7 +319,7 @@
 
   SocketAddress addr3("a.b.c.d", 1);
   SocketAddress addr4("b.b.c.d", 1);
-  EXPECT_PRED2(IsLessThan, addr3, addr4);
+  EXPECT_TRUE(IsLessThan(addr3, addr4));
 }
 
 TEST(SocketAddressTest, TestToSensitiveString) {
diff --git a/rtc_base/ssladapter_unittest.cc b/rtc_base/ssladapter_unittest.cc
index 0996b01..c15ecfe 100644
--- a/rtc_base/ssladapter_unittest.cc
+++ b/rtc_base/ssladapter_unittest.cc
@@ -81,7 +81,7 @@
   }
 
   int Connect(const std::string& hostname, const rtc::SocketAddress& address) {
-    RTC_LOG(LS_INFO) << "Initiating connection with " << address;
+    RTC_LOG(LS_INFO) << "Initiating connection with " << address.ToString();
 
     int rv = ssl_adapter_->Connect(address);
 
@@ -157,7 +157,7 @@
 
     RTC_LOG(LS_INFO) << ((ssl_mode_ == rtc::SSL_MODE_DTLS) ? "UDP" : "TCP")
                      << " server listening on "
-                     << server_socket_->GetLocalAddress();
+                     << server_socket_->GetLocalAddress().ToString();
   }
 
   rtc::SocketAddress GetAddress() const {
diff --git a/rtc_base/stringutils.h b/rtc_base/stringutils.h
index 386ca9e..b42cfa5 100644
--- a/rtc_base/stringutils.h
+++ b/rtc_base/stringutils.h
@@ -312,6 +312,7 @@
 // Remove leading and trailing whitespaces.
 std::string string_trim(const std::string& s);
 
+// TODO(jonasolsson): replace with absl::Hex when that becomes available.
 std::string ToHex(const int i);
 }  // namespace rtc
 
diff --git a/rtc_base/virtualsocketserver.cc b/rtc_base/virtualsocketserver.cc
index d8771e7..fab5900 100644
--- a/rtc_base/virtualsocketserver.cc
+++ b/rtc_base/virtualsocketserver.cc
@@ -409,7 +409,8 @@
     } else if ((SOCK_STREAM == type_) && (CS_CONNECTING == state_)) {
       CompleteConnect(data->addr, true);
     } else {
-      RTC_LOG(LS_VERBOSE) << "Socket at " << local_addr_ << " is not listening";
+      RTC_LOG(LS_VERBOSE) << "Socket at " << local_addr_.ToString()
+                          << " is not listening";
       server_->Disconnect(server_->LookupBinding(data->addr));
     }
     delete data;
@@ -805,7 +806,8 @@
   VirtualSocket* remote = LookupBinding(remote_addr);
   if (!CanInteractWith(socket, remote)) {
     RTC_LOG(LS_INFO) << "Address family mismatch between "
-                     << socket->GetLocalAddress() << " and " << remote_addr;
+                     << socket->GetLocalAddress().ToString() << " and "
+                     << remote_addr.ToString();
     return -1;
   }
   if (remote != nullptr) {
@@ -813,7 +815,7 @@
     msg_queue_->PostDelayed(RTC_FROM_HERE, delay, remote, MSG_ID_CONNECT,
                             new MessageAddress(addr));
   } else {
-    RTC_LOG(LS_INFO) << "No one listening at " << remote_addr;
+    RTC_LOG(LS_INFO) << "No one listening at " << remote_addr.ToString();
     msg_queue_->PostDelayed(RTC_FROM_HERE, delay, socket, MSG_ID_DISCONNECT);
   }
   return 0;
@@ -856,17 +858,18 @@
     dummy_socket->SetLocalAddress(remote_addr);
     if (!CanInteractWith(socket, dummy_socket.get())) {
       RTC_LOG(LS_VERBOSE) << "Incompatible address families: "
-                          << socket->GetLocalAddress() << " and "
-                          << remote_addr;
+                          << socket->GetLocalAddress().ToString() << " and "
+                          << remote_addr.ToString();
       return -1;
     }
-    RTC_LOG(LS_VERBOSE) << "No one listening at " << remote_addr;
+    RTC_LOG(LS_VERBOSE) << "No one listening at " << remote_addr.ToString();
     return static_cast<int>(data_size);
   }
 
   if (!CanInteractWith(socket, recipient)) {
     RTC_LOG(LS_VERBOSE) << "Incompatible address families: "
-                        << socket->GetLocalAddress() << " and " << remote_addr;
+                        << socket->GetLocalAddress().ToString() << " and "
+                        << remote_addr.ToString();
     return -1;
   }