Automated g4 rollback of changelist 802848539.

*** Reason for rollback ***

Broke external QUICHE builds which use an earlier version of absl.

*** Original change description ***

Fix 14 ClangInliner findings:
* The use of this symbol has been deprecated and marked for inlining. The function being deprecated is absl::WriterMutexLock::WriterMutexLock. (8 times)
* The use of this symbol has been deprecated and marked for inlining. The function being deprecated is absl::ReaderMutexLock::ReaderMutexLock. (6 times)

See go/inliner-lsc for more information on why you've received this change and why it is important.

This CL looks good? Just LGTM and Approve it!
This CL doesn’...

***

PiperOrigin-RevId: 804949888

quiche/quic/test_tools/packet_dropping_test_writer.cc

diff --git a/quiche/quic/test_tools/packet_dropping_test_writer.cc b/quiche/quic/test_tools/packet_dropping_test_writer.cc
index c7b0a3d..5912910 100644
--- a/quiche/quic/test_tools/packet_dropping_test_writer.cc
+++ b/quiche/quic/test_tools/packet_dropping_test_writer.cc
@@ -97,7 +97,7 @@
   ++num_calls_to_write_;
   ReleaseOldPackets();
 
-  absl::WriterMutexLock lock(config_mutex_);
+  absl::WriterMutexLock lock(&config_mutex_);
   if (passthrough_for_next_n_packets_ > 0) {
     --passthrough_for_next_n_packets_;
     return QuicPacketWriterWrapper::WritePacket(buffer, buf_len, self_address,
@@ -201,7 +201,7 @@
   if (delayed_packets_.empty()) {
     return QuicTime::Zero();
   }
-  absl::ReaderMutexLock lock(config_mutex_);
+  absl::ReaderMutexLock lock(&config_mutex_);
   auto iter = delayed_packets_.begin();
   // Determine if we should re-order.
   if (delayed_packets_.size() > 1 && fake_packet_reorder_percentage_ > 0 &&

quiche/quic/test_tools/quic_crypto_server_config_peer.cc

diff --git a/quiche/quic/test_tools/quic_crypto_server_config_peer.cc b/quiche/quic/test_tools/quic_crypto_server_config_peer.cc
index 07c95d7..7179ca4 100644
--- a/quiche/quic/test_tools/quic_crypto_server_config_peer.cc
+++ b/quiche/quic/test_tools/quic_crypto_server_config_peer.cc
@@ -19,14 +19,14 @@
 
 quiche::QuicheReferenceCountedPointer<QuicCryptoServerConfig::Config>
 QuicCryptoServerConfigPeer::GetPrimaryConfig() {
-  absl::ReaderMutexLock locked(server_config_->configs_lock_);
+  absl::ReaderMutexLock locked(&server_config_->configs_lock_);
   return quiche::QuicheReferenceCountedPointer<QuicCryptoServerConfig::Config>(
       server_config_->primary_config_);
 }
 
 quiche::QuicheReferenceCountedPointer<QuicCryptoServerConfig::Config>
 QuicCryptoServerConfigPeer::GetConfig(std::string config_id) {
-  absl::ReaderMutexLock locked(server_config_->configs_lock_);
+  absl::ReaderMutexLock locked(&server_config_->configs_lock_);
   if (config_id == "<primary>") {
     return quiche::QuicheReferenceCountedPointer<
         QuicCryptoServerConfig::Config>(server_config_->primary_config_);
@@ -83,7 +83,7 @@
 
 void QuicCryptoServerConfigPeer::CheckConfigs(
     std::vector<std::pair<std::string, bool>> expected_ids_and_status) {
-  absl::ReaderMutexLock locked(server_config_->configs_lock_);
+  absl::ReaderMutexLock locked(&server_config_->configs_lock_);
 
   ASSERT_EQ(expected_ids_and_status.size(), server_config_->configs_.size())
       << ConfigsDebug();
@@ -132,7 +132,7 @@
 }
 
 void QuicCryptoServerConfigPeer::SelectNewPrimaryConfig(int seconds) {
-  absl::WriterMutexLock locked(server_config_->configs_lock_);
+  absl::WriterMutexLock locked(&server_config_->configs_lock_);
   server_config_->SelectNewPrimaryConfig(
       QuicWallTime::FromUNIXSeconds(seconds));
 }

quiche/quic/test_tools/quic_test_server.cc

diff --git a/quiche/quic/test_tools/quic_test_server.cc b/quiche/quic/test_tools/quic_test_server.cc
index fccaa0b..d5c364d 100644
--- a/quiche/quic/test_tools/quic_test_server.cc
+++ b/quiche/quic/test_tools/quic_test_server.cc
@@ -95,7 +95,7 @@
       const ParsedQuicVersion& version,
       const ParsedClientHello& /*parsed_chlo*/,
       ConnectionIdGeneratorInterface& connection_id_generator) override {
-    absl::ReaderMutexLock lock(factory_lock_);
+    absl::ReaderMutexLock lock(&factory_lock_);
     // The QuicServerSessionBase takes ownership of |connection| below.
     QuicConnection* connection = new QuicConnection(
         id, self_address, peer_address, helper(), alarm_factory(), writer(),
@@ -131,7 +131,7 @@
   }
 
   void SetSessionFactory(QuicTestServer::SessionFactory* factory) {
-    absl::WriterMutexLock lock(factory_lock_);
+    absl::WriterMutexLock lock(&factory_lock_);
     QUICHE_DCHECK(session_factory_ == nullptr);
     QUICHE_DCHECK(stream_factory_ == nullptr);
     QUICHE_DCHECK(crypto_stream_factory_ == nullptr);
@@ -139,14 +139,14 @@
   }
 
   void SetStreamFactory(QuicTestServer::StreamFactory* factory) {
-    absl::WriterMutexLock lock(factory_lock_);
+    absl::WriterMutexLock lock(&factory_lock_);
     QUICHE_DCHECK(session_factory_ == nullptr);
     QUICHE_DCHECK(stream_factory_ == nullptr);
     stream_factory_ = factory;
   }
 
   void SetCryptoStreamFactory(QuicTestServer::CryptoStreamFactory* factory) {
-    absl::WriterMutexLock lock(factory_lock_);
+    absl::WriterMutexLock lock(&factory_lock_);
     QUICHE_DCHECK(session_factory_ == nullptr);
     QUICHE_DCHECK(crypto_stream_factory_ == nullptr);
     crypto_stream_factory_ = factory;

quiche/quic/test_tools/server_thread.cc

diff --git a/quiche/quic/test_tools/server_thread.cc b/quiche/quic/test_tools/server_thread.cc
index 9cfab72..c80bff8 100644
--- a/quiche/quic/test_tools/server_thread.cc
+++ b/quiche/quic/test_tools/server_thread.cc
@@ -38,7 +38,7 @@
     return;
   }
 
-  absl::WriterMutexLock lock(port_lock_);
+  absl::WriterMutexLock lock(&port_lock_);
   port_ = server_->port();
 
   initialized_ = true;
@@ -63,14 +63,14 @@
 }
 
 int ServerThread::GetPort() {
-  absl::ReaderMutexLock lock(port_lock_);
+  absl::ReaderMutexLock lock(&port_lock_);
   int rc = port_;
   return rc;
 }
 
 void ServerThread::Schedule(quiche::SingleUseCallback<void()> action) {
   QUICHE_DCHECK(!quit_.HasBeenNotified());
-  absl::WriterMutexLock lock(scheduled_actions_lock_);
+  absl::WriterMutexLock lock(&scheduled_actions_lock_);
   scheduled_actions_.push_back(std::move(action));
 }
 
@@ -147,7 +147,7 @@
 void ServerThread::ExecuteScheduledActions() {
   quiche::QuicheCircularDeque<quiche::SingleUseCallback<void()>> actions;
   {
-    absl::WriterMutexLock lock(scheduled_actions_lock_);
+    absl::WriterMutexLock lock(&scheduled_actions_lock_);
     actions.swap(scheduled_actions_);
   }
   while (!actions.empty()) {