diff --git a/build/source_list.bzl b/build/source_list.bzl
index 1db4c11..9c9ed2b 100644
--- a/build/source_list.bzl
+++ b/build/source_list.bzl
@@ -29,7 +29,6 @@
     "common/platform/api/quiche_logging.h",
     "common/platform/api/quiche_lower_case_string.h",
     "common/platform/api/quiche_mem_slice.h",
-    "common/platform/api/quiche_mutex.h",
     "common/platform/api/quiche_prefetch.h",
     "common/platform/api/quiche_reference_counted.h",
     "common/platform/api/quiche_server_stats.h",
@@ -394,7 +393,6 @@
     "quic/platform/api/quic_ip_address.h",
     "quic/platform/api/quic_ip_address_family.h",
     "quic/platform/api/quic_logging.h",
-    "quic/platform/api/quic_mutex.h",
     "quic/platform/api/quic_server_stats.h",
     "quic/platform/api/quic_socket_address.h",
     "quic/platform/api/quic_stack_trace.h",
@@ -413,7 +411,6 @@
     "common/masque/connect_ip_datagram_payload.cc",
     "common/masque/connect_udp_datagram_payload.cc",
     "common/platform/api/quiche_hostname_utils.cc",
-    "common/platform/api/quiche_mutex.cc",
     "common/quiche_buffer_allocator.cc",
     "common/quiche_crypto_logging.cc",
     "common/quiche_data_reader.cc",
@@ -1452,7 +1449,6 @@
     "common/platform/default/quiche_platform_impl/quiche_logging_impl.h",
     "common/platform/default/quiche_platform_impl/quiche_lower_case_string_impl.h",
     "common/platform/default/quiche_platform_impl/quiche_mem_slice_impl.h",
-    "common/platform/default/quiche_platform_impl/quiche_mutex_impl.h",
     "common/platform/default/quiche_platform_impl/quiche_prefetch_impl.h",
     "common/platform/default/quiche_platform_impl/quiche_reference_counted_impl.h",
     "common/platform/default/quiche_platform_impl/quiche_server_stats_impl.h",
@@ -1466,7 +1462,6 @@
 default_platform_impl_srcs = [
     "common/platform/default/quiche_platform_impl/quiche_flags_impl.cc",
     "common/platform/default/quiche_platform_impl/quiche_logging_impl.cc",
-    "common/platform/default/quiche_platform_impl/quiche_mutex_impl.cc",
     "common/platform/default/quiche_platform_impl/quiche_stack_trace_impl.cc",
     "common/platform/default/quiche_platform_impl/quiche_time_utils_impl.cc",
     "common/platform/default/quiche_platform_impl/quiche_url_utils_impl.cc",
diff --git a/build/source_list.gni b/build/source_list.gni
index 1a4a39c..4d0b463 100644
--- a/build/source_list.gni
+++ b/build/source_list.gni
@@ -29,7 +29,6 @@
     "src/quiche/common/platform/api/quiche_logging.h",
     "src/quiche/common/platform/api/quiche_lower_case_string.h",
     "src/quiche/common/platform/api/quiche_mem_slice.h",
-    "src/quiche/common/platform/api/quiche_mutex.h",
     "src/quiche/common/platform/api/quiche_prefetch.h",
     "src/quiche/common/platform/api/quiche_reference_counted.h",
     "src/quiche/common/platform/api/quiche_server_stats.h",
@@ -394,7 +393,6 @@
     "src/quiche/quic/platform/api/quic_ip_address.h",
     "src/quiche/quic/platform/api/quic_ip_address_family.h",
     "src/quiche/quic/platform/api/quic_logging.h",
-    "src/quiche/quic/platform/api/quic_mutex.h",
     "src/quiche/quic/platform/api/quic_server_stats.h",
     "src/quiche/quic/platform/api/quic_socket_address.h",
     "src/quiche/quic/platform/api/quic_stack_trace.h",
@@ -413,7 +411,6 @@
     "src/quiche/common/masque/connect_ip_datagram_payload.cc",
     "src/quiche/common/masque/connect_udp_datagram_payload.cc",
     "src/quiche/common/platform/api/quiche_hostname_utils.cc",
-    "src/quiche/common/platform/api/quiche_mutex.cc",
     "src/quiche/common/quiche_buffer_allocator.cc",
     "src/quiche/common/quiche_crypto_logging.cc",
     "src/quiche/common/quiche_data_reader.cc",
@@ -1456,7 +1453,6 @@
     "src/quiche/common/platform/default/quiche_platform_impl/quiche_logging_impl.h",
     "src/quiche/common/platform/default/quiche_platform_impl/quiche_lower_case_string_impl.h",
     "src/quiche/common/platform/default/quiche_platform_impl/quiche_mem_slice_impl.h",
-    "src/quiche/common/platform/default/quiche_platform_impl/quiche_mutex_impl.h",
     "src/quiche/common/platform/default/quiche_platform_impl/quiche_prefetch_impl.h",
     "src/quiche/common/platform/default/quiche_platform_impl/quiche_reference_counted_impl.h",
     "src/quiche/common/platform/default/quiche_platform_impl/quiche_server_stats_impl.h",
@@ -1470,7 +1466,6 @@
 default_platform_impl_srcs = [
     "src/quiche/common/platform/default/quiche_platform_impl/quiche_flags_impl.cc",
     "src/quiche/common/platform/default/quiche_platform_impl/quiche_logging_impl.cc",
-    "src/quiche/common/platform/default/quiche_platform_impl/quiche_mutex_impl.cc",
     "src/quiche/common/platform/default/quiche_platform_impl/quiche_stack_trace_impl.cc",
     "src/quiche/common/platform/default/quiche_platform_impl/quiche_time_utils_impl.cc",
     "src/quiche/common/platform/default/quiche_platform_impl/quiche_url_utils_impl.cc",
diff --git a/build/source_list.json b/build/source_list.json
index 5db7d3a..abb2a45 100644
--- a/build/source_list.json
+++ b/build/source_list.json
@@ -28,7 +28,6 @@
     "quiche/common/platform/api/quiche_logging.h",
     "quiche/common/platform/api/quiche_lower_case_string.h",
     "quiche/common/platform/api/quiche_mem_slice.h",
-    "quiche/common/platform/api/quiche_mutex.h",
     "quiche/common/platform/api/quiche_prefetch.h",
     "quiche/common/platform/api/quiche_reference_counted.h",
     "quiche/common/platform/api/quiche_server_stats.h",
@@ -393,7 +392,6 @@
     "quiche/quic/platform/api/quic_ip_address.h",
     "quiche/quic/platform/api/quic_ip_address_family.h",
     "quiche/quic/platform/api/quic_logging.h",
-    "quiche/quic/platform/api/quic_mutex.h",
     "quiche/quic/platform/api/quic_server_stats.h",
     "quiche/quic/platform/api/quic_socket_address.h",
     "quiche/quic/platform/api/quic_stack_trace.h",
@@ -412,7 +410,6 @@
     "quiche/common/masque/connect_ip_datagram_payload.cc",
     "quiche/common/masque/connect_udp_datagram_payload.cc",
     "quiche/common/platform/api/quiche_hostname_utils.cc",
-    "quiche/common/platform/api/quiche_mutex.cc",
     "quiche/common/quiche_buffer_allocator.cc",
     "quiche/common/quiche_crypto_logging.cc",
     "quiche/common/quiche_data_reader.cc",
@@ -1455,7 +1452,6 @@
     "quiche/common/platform/default/quiche_platform_impl/quiche_logging_impl.h",
     "quiche/common/platform/default/quiche_platform_impl/quiche_lower_case_string_impl.h",
     "quiche/common/platform/default/quiche_platform_impl/quiche_mem_slice_impl.h",
-    "quiche/common/platform/default/quiche_platform_impl/quiche_mutex_impl.h",
     "quiche/common/platform/default/quiche_platform_impl/quiche_prefetch_impl.h",
     "quiche/common/platform/default/quiche_platform_impl/quiche_reference_counted_impl.h",
     "quiche/common/platform/default/quiche_platform_impl/quiche_server_stats_impl.h",
@@ -1469,7 +1465,6 @@
   "default_platform_impl_srcs": [
     "quiche/common/platform/default/quiche_platform_impl/quiche_flags_impl.cc",
     "quiche/common/platform/default/quiche_platform_impl/quiche_logging_impl.cc",
-    "quiche/common/platform/default/quiche_platform_impl/quiche_mutex_impl.cc",
     "quiche/common/platform/default/quiche_platform_impl/quiche_stack_trace_impl.cc",
     "quiche/common/platform/default/quiche_platform_impl/quiche_time_utils_impl.cc",
     "quiche/common/platform/default/quiche_platform_impl/quiche_url_utils_impl.cc"
diff --git a/quiche/blind_sign_auth/blind_sign_auth_test.cc b/quiche/blind_sign_auth/blind_sign_auth_test.cc
index 7c681df..8fa6561 100644
--- a/quiche/blind_sign_auth/blind_sign_auth_test.cc
+++ b/quiche/blind_sign_auth/blind_sign_auth_test.cc
@@ -13,6 +13,7 @@
 #include "absl/status/statusor.h"
 #include "absl/strings/escaping.h"
 #include "absl/strings/string_view.h"
+#include "absl/synchronization/notification.h"
 #include "absl/time/clock.h"
 #include "absl/time/time.h"
 #include "absl/types/span.h"
@@ -26,7 +27,6 @@
 #include "quiche/blind_sign_auth/blind_sign_message_interface.h"
 #include "quiche/blind_sign_auth/blind_sign_message_response.h"
 #include "quiche/blind_sign_auth/test_tools/mock_blind_sign_message_interface.h"
-#include "quiche/common/platform/api/quiche_mutex.h"
 #include "quiche/common/platform/api/quiche_test.h"
 #include "quiche/common/test_tools/quiche_test_utils.h"
 
@@ -266,7 +266,7 @@
       .Times(0);
 
   int num_tokens = 1;
-  QuicheNotification done;
+  absl::Notification done;
   SignedTokenCallback callback =
       [&done](absl::StatusOr<absl::Span<BlindSignToken>> tokens) {
         EXPECT_THAT(tokens.status().code(), absl::StatusCode::kInvalidArgument);
@@ -301,7 +301,7 @@
       .Times(0);
 
   int num_tokens = 1;
-  QuicheNotification done;
+  absl::Notification done;
   SignedTokenCallback callback =
       [&done](absl::StatusOr<absl::Span<BlindSignToken>> tokens) {
         EXPECT_THAT(tokens.status().code(), absl::StatusCode::kInvalidArgument);
@@ -346,7 +346,7 @@
   }
 
   int num_tokens = 1;
-  QuicheNotification done;
+  absl::Notification done;
   SignedTokenCallback callback =
       [&done](absl::StatusOr<absl::Span<BlindSignToken>> tokens) {
         EXPECT_THAT(tokens.status().code(), absl::StatusCode::kInternal);
@@ -389,7 +389,7 @@
   }
 
   int num_tokens = 1;
-  QuicheNotification done;
+  absl::Notification done;
   SignedTokenCallback callback =
       [this, &done](absl::StatusOr<absl::Span<BlindSignToken>> tokens) {
         QUICHE_EXPECT_OK(tokens);
@@ -430,7 +430,7 @@
       });
 
   int num_tokens = 1;
-  QuicheNotification done;
+  absl::Notification done;
   SignedTokenCallback callback =
       [&done](absl::StatusOr<absl::Span<BlindSignToken>> tokens) {
         EXPECT_THAT(tokens.status().code(), absl::StatusCode::kInvalidArgument);
diff --git a/quiche/blind_sign_auth/cached_blind_sign_auth.cc b/quiche/blind_sign_auth/cached_blind_sign_auth.cc
index 4579086..883e2aa 100644
--- a/quiche/blind_sign_auth/cached_blind_sign_auth.cc
+++ b/quiche/blind_sign_auth/cached_blind_sign_auth.cc
@@ -13,12 +13,12 @@
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/str_format.h"
+#include "absl/synchronization/mutex.h"
 #include "absl/time/clock.h"
 #include "absl/time/time.h"
 #include "absl/types/span.h"
 #include "quiche/blind_sign_auth/blind_sign_auth_interface.h"
 #include "quiche/common/platform/api/quiche_logging.h"
-#include "quiche/common/platform/api/quiche_mutex.h"
 
 namespace quiche {
 
@@ -42,7 +42,7 @@
 
   std::vector<BlindSignToken> output_tokens;
   {
-    QuicheWriterMutexLock lock(&mutex_);
+    absl::WriterMutexLock lock(&mutex_);
 
     RemoveExpiredTokens();
     // Try to fill the request from cache.
@@ -83,7 +83,7 @@
   std::vector<BlindSignToken> output_tokens;
   size_t cache_size;
   {
-    QuicheWriterMutexLock lock(&mutex_);
+    absl::WriterMutexLock lock(&mutex_);
 
     // Add returned tokens to cache.
     for (const BlindSignToken& token : *tokens) {
diff --git a/quiche/blind_sign_auth/cached_blind_sign_auth.h b/quiche/blind_sign_auth/cached_blind_sign_auth.h
index 9d90e6c..7eaa677 100644
--- a/quiche/blind_sign_auth/cached_blind_sign_auth.h
+++ b/quiche/blind_sign_auth/cached_blind_sign_auth.h
@@ -8,11 +8,12 @@
 #include <string>
 #include <vector>
 
+#include "absl/base/thread_annotations.h"
 #include "absl/status/statusor.h"
+#include "absl/synchronization/mutex.h"
 #include "absl/types/span.h"
 #include "quiche/blind_sign_auth/blind_sign_auth_interface.h"
 #include "quiche/common/platform/api/quiche_export.h"
-#include "quiche/common/platform/api/quiche_mutex.h"
 #include "quiche/common/quiche_circular_deque.h"
 
 namespace quiche {
@@ -45,7 +46,7 @@
 
   // Removes all tokens in the cache.
   void ClearCache() {
-    QuicheWriterMutexLock lock(&mutex_);
+    absl::WriterMutexLock lock(&mutex_);
     cached_tokens_.clear();
   }
 
@@ -54,13 +55,13 @@
       SignedTokenCallback callback, int num_tokens,
       absl::StatusOr<absl::Span<BlindSignToken>> tokens);
   std::vector<BlindSignToken> CreateOutputTokens(int num_tokens)
-      QUICHE_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
-  void RemoveExpiredTokens() QUICHE_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
+      ABSL_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
+  void RemoveExpiredTokens() ABSL_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
 
   BlindSignAuthInterface* blind_sign_auth_;
   int max_tokens_per_request_;
-  QuicheMutex mutex_;
-  QuicheCircularDeque<BlindSignToken> cached_tokens_ QUICHE_GUARDED_BY(mutex_);
+  absl::Mutex mutex_;
+  QuicheCircularDeque<BlindSignToken> cached_tokens_ ABSL_GUARDED_BY(mutex_);
 };
 
 }  // namespace quiche
diff --git a/quiche/blind_sign_auth/cached_blind_sign_auth_test.cc b/quiche/blind_sign_auth/cached_blind_sign_auth_test.cc
index f353cb6..b84d2f8 100644
--- a/quiche/blind_sign_auth/cached_blind_sign_auth_test.cc
+++ b/quiche/blind_sign_auth/cached_blind_sign_auth_test.cc
@@ -14,12 +14,12 @@
 #include "absl/status/statusor.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
+#include "absl/synchronization/notification.h"
 #include "absl/time/clock.h"
 #include "absl/time/time.h"
 #include "absl/types/span.h"
 #include "quiche/blind_sign_auth/blind_sign_auth_interface.h"
 #include "quiche/blind_sign_auth/test_tools/mock_blind_sign_auth_interface.h"
-#include "quiche/common/platform/api/quiche_mutex.h"
 #include "quiche/common/platform/api/quiche_test.h"
 #include "quiche/common/test_tools/quiche_test_utils.h"
 
@@ -79,7 +79,7 @@
       });
 
   int num_tokens = 5;
-  QuicheNotification done;
+  absl::Notification done;
   SignedTokenCallback callback =
       [num_tokens, &done](absl::StatusOr<absl::Span<BlindSignToken>> tokens) {
         QUICHE_EXPECT_OK(tokens);
@@ -107,7 +107,7 @@
       });
 
   int num_tokens = kBlindSignAuthRequestMaxTokens - 1;
-  QuicheNotification first;
+  absl::Notification first;
   SignedTokenCallback first_callback =
       [num_tokens, &first](absl::StatusOr<absl::Span<BlindSignToken>> tokens) {
         QUICHE_EXPECT_OK(tokens);
@@ -123,7 +123,7 @@
       BlindSignAuthServiceType::kChromeIpBlinding, std::move(first_callback));
   first.WaitForNotification();
 
-  QuicheNotification second;
+  absl::Notification second;
   SignedTokenCallback second_callback =
       [num_tokens, &second](absl::StatusOr<absl::Span<BlindSignToken>> tokens) {
         QUICHE_EXPECT_OK(tokens);
@@ -153,7 +153,7 @@
       });
 
   int num_tokens = kBlindSignAuthRequestMaxTokens / 2;
-  QuicheNotification first;
+  absl::Notification first;
   SignedTokenCallback first_callback =
       [num_tokens, &first](absl::StatusOr<absl::Span<BlindSignToken>> tokens) {
         QUICHE_EXPECT_OK(tokens);
@@ -169,7 +169,7 @@
       BlindSignAuthServiceType::kChromeIpBlinding, std::move(first_callback));
   first.WaitForNotification();
 
-  QuicheNotification second;
+  absl::Notification second;
   SignedTokenCallback second_callback =
       [num_tokens, &second](absl::StatusOr<absl::Span<BlindSignToken>> tokens) {
         QUICHE_EXPECT_OK(tokens);
@@ -198,7 +198,7 @@
       });
 
   int num_tokens = kBlindSignAuthRequestMaxTokens / 2;
-  QuicheNotification first;
+  absl::Notification first;
   SignedTokenCallback first_callback =
       [num_tokens, &first](absl::StatusOr<absl::Span<BlindSignToken>> tokens) {
         QUICHE_EXPECT_OK(tokens);
@@ -214,7 +214,7 @@
       BlindSignAuthServiceType::kChromeIpBlinding, std::move(first_callback));
   first.WaitForNotification();
 
-  QuicheNotification second;
+  absl::Notification second;
   SignedTokenCallback second_callback =
       [num_tokens, &second](absl::StatusOr<absl::Span<BlindSignToken>> tokens) {
         QUICHE_EXPECT_OK(tokens);
@@ -231,7 +231,7 @@
       BlindSignAuthServiceType::kChromeIpBlinding, std::move(second_callback));
   second.WaitForNotification();
 
-  QuicheNotification third;
+  absl::Notification third;
   int third_request_tokens = 10;
   SignedTokenCallback third_callback =
       [third_request_tokens,
@@ -305,7 +305,7 @@
       });
 
   int num_tokens = kBlindSignAuthRequestMaxTokens;
-  QuicheNotification first;
+  absl::Notification first;
   SignedTokenCallback first_callback =
       [&first](absl::StatusOr<absl::Span<BlindSignToken>> tokens) {
         EXPECT_THAT(tokens.status().code(), absl::StatusCode::kInternal);
@@ -318,7 +318,7 @@
       BlindSignAuthServiceType::kChromeIpBlinding, std::move(first_callback));
   first.WaitForNotification();
 
-  QuicheNotification second;
+  absl::Notification second;
   SignedTokenCallback second_callback =
       [&second](absl::StatusOr<absl::Span<BlindSignToken>> tokens) {
         EXPECT_THAT(tokens.status().code(),
@@ -360,7 +360,7 @@
       });
 
   int num_tokens = kBlindSignAuthRequestMaxTokens;
-  QuicheNotification first;
+  absl::Notification first;
   SignedTokenCallback first_callback =
       [&first](absl::StatusOr<absl::Span<BlindSignToken>> tokens) {
         EXPECT_THAT(tokens.status().code(),
@@ -385,7 +385,7 @@
       });
 
   int num_tokens = kBlindSignAuthRequestMaxTokens / 2;
-  QuicheNotification first;
+  absl::Notification first;
   SignedTokenCallback first_callback =
       [&first](absl::StatusOr<absl::Span<BlindSignToken>> tokens) {
         EXPECT_THAT(tokens.status().code(),
@@ -400,7 +400,7 @@
 
   cached_blind_sign_auth_->ClearCache();
 
-  QuicheNotification second;
+  absl::Notification second;
   SignedTokenCallback second_callback =
       [&second](absl::StatusOr<absl::Span<BlindSignToken>> tokens) {
         EXPECT_THAT(tokens.status().code(),
diff --git a/quiche/common/platform/api/quiche_mutex.cc b/quiche/common/platform/api/quiche_mutex.cc
deleted file mode 100644
index e6d4b0c..0000000
--- a/quiche/common/platform/api/quiche_mutex.cc
+++ /dev/null
@@ -1,31 +0,0 @@
-// Copyright (c) 2016 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "quiche/common/platform/api/quiche_mutex.h"
-
-namespace quiche {
-
-void QuicheMutex::WriterLock() { impl_.WriterLock(); }
-
-void QuicheMutex::WriterUnlock() { impl_.WriterUnlock(); }
-
-void QuicheMutex::ReaderLock() { impl_.ReaderLock(); }
-
-void QuicheMutex::ReaderUnlock() { impl_.ReaderUnlock(); }
-
-void QuicheMutex::AssertReaderHeld() const { impl_.AssertReaderHeld(); }
-
-QuicheReaderMutexLock::QuicheReaderMutexLock(QuicheMutex* lock) : lock_(lock) {
-  lock->ReaderLock();
-}
-
-QuicheReaderMutexLock::~QuicheReaderMutexLock() { lock_->ReaderUnlock(); }
-
-QuicheWriterMutexLock::QuicheWriterMutexLock(QuicheMutex* lock) : lock_(lock) {
-  lock->WriterLock();
-}
-
-QuicheWriterMutexLock::~QuicheWriterMutexLock() { lock_->WriterUnlock(); }
-
-}  // namespace quiche
diff --git a/quiche/common/platform/api/quiche_mutex.h b/quiche/common/platform/api/quiche_mutex.h
deleted file mode 100644
index 11e6287..0000000
--- a/quiche/common/platform/api/quiche_mutex.h
+++ /dev/null
@@ -1,101 +0,0 @@
-// Copyright (c) 2016 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef QUICHE_COMMON_PLATFORM_API_QUICHE_MUTEX_H_
-#define QUICHE_COMMON_PLATFORM_API_QUICHE_MUTEX_H_
-
-#include "quiche_platform_impl/quiche_mutex_impl.h"
-
-#define QUICHE_EXCLUSIVE_LOCKS_REQUIRED QUICHE_EXCLUSIVE_LOCKS_REQUIRED_IMPL
-#define QUICHE_GUARDED_BY QUICHE_GUARDED_BY_IMPL
-#define QUICHE_LOCKABLE QUICHE_LOCKABLE_IMPL
-#define QUICHE_LOCKS_EXCLUDED QUICHE_LOCKS_EXCLUDED_IMPL
-#define QUICHE_SHARED_LOCKS_REQUIRED QUICHE_SHARED_LOCKS_REQUIRED_IMPL
-#define QUICHE_EXCLUSIVE_LOCK_FUNCTION QUICHE_EXCLUSIVE_LOCK_FUNCTION_IMPL
-#define QUICHE_UNLOCK_FUNCTION QUICHE_UNLOCK_FUNCTION_IMPL
-#define QUICHE_SHARED_LOCK_FUNCTION QUICHE_SHARED_LOCK_FUNCTION_IMPL
-#define QUICHE_SCOPED_LOCKABLE QUICHE_SCOPED_LOCKABLE_IMPL
-#define QUICHE_ASSERT_SHARED_LOCK QUICHE_ASSERT_SHARED_LOCK_IMPL
-
-namespace quiche {
-
-// A class representing a non-reentrant mutex in QUIC.
-class QUICHE_LOCKABLE QUICHE_EXPORT QuicheMutex {
- public:
-  QuicheMutex() = default;
-  QuicheMutex(const QuicheMutex&) = delete;
-  QuicheMutex& operator=(const QuicheMutex&) = delete;
-
-  // Block until this Mutex is free, then acquire it exclusively.
-  void WriterLock() QUICHE_EXCLUSIVE_LOCK_FUNCTION();
-
-  // Release this Mutex. Caller must hold it exclusively.
-  void WriterUnlock() QUICHE_UNLOCK_FUNCTION();
-
-  // Block until this Mutex is free or shared, then acquire a share of it.
-  void ReaderLock() QUICHE_SHARED_LOCK_FUNCTION();
-
-  // Release this Mutex. Caller could hold it in shared mode.
-  void ReaderUnlock() QUICHE_UNLOCK_FUNCTION();
-
-  // Returns immediately if current thread holds the Mutex in at least shared
-  // mode.  Otherwise, may report an error (typically by crashing with a
-  // diagnostic), or may return immediately.
-  void AssertReaderHeld() const QUICHE_ASSERT_SHARED_LOCK();
-
- private:
-  QuicheLockImpl impl_;
-};
-
-// A helper class that acquires the given QuicheMutex shared lock while the
-// QuicheReaderMutexLock is in scope.
-class QUICHE_SCOPED_LOCKABLE QUICHE_EXPORT QuicheReaderMutexLock {
- public:
-  explicit QuicheReaderMutexLock(QuicheMutex* lock)
-      QUICHE_SHARED_LOCK_FUNCTION(lock);
-  QuicheReaderMutexLock(const QuicheReaderMutexLock&) = delete;
-  QuicheReaderMutexLock& operator=(const QuicheReaderMutexLock&) = delete;
-
-  ~QuicheReaderMutexLock() QUICHE_UNLOCK_FUNCTION();
-
- private:
-  QuicheMutex* const lock_;
-};
-
-// A helper class that acquires the given QuicheMutex exclusive lock while the
-// QuicheWriterMutexLock is in scope.
-class QUICHE_SCOPED_LOCKABLE QUICHE_EXPORT QuicheWriterMutexLock {
- public:
-  explicit QuicheWriterMutexLock(QuicheMutex* lock)
-      QUICHE_EXCLUSIVE_LOCK_FUNCTION(lock);
-  QuicheWriterMutexLock(const QuicheWriterMutexLock&) = delete;
-  QuicheWriterMutexLock& operator=(const QuicheWriterMutexLock&) = delete;
-
-  ~QuicheWriterMutexLock() QUICHE_UNLOCK_FUNCTION();
-
- private:
-  QuicheMutex* const lock_;
-};
-
-// A Notification allows threads to receive notification of a single occurrence
-// of a single event.
-class QUICHE_EXPORT QuicheNotification {
- public:
-  QuicheNotification() = default;
-  QuicheNotification(const QuicheNotification&) = delete;
-  QuicheNotification& operator=(const QuicheNotification&) = delete;
-
-  bool HasBeenNotified() { return impl_.HasBeenNotified(); }
-
-  void Notify() { impl_.Notify(); }
-
-  void WaitForNotification() { impl_.WaitForNotification(); }
-
- private:
-  QuicheNotificationImpl impl_;
-};
-
-}  // namespace quiche
-
-#endif  // QUICHE_COMMON_PLATFORM_API_QUICHE_MUTEX_H_
diff --git a/quiche/common/platform/default/quiche_platform_impl/quiche_mutex_impl.cc b/quiche/common/platform/default/quiche_platform_impl/quiche_mutex_impl.cc
deleted file mode 100644
index 78ca926..0000000
--- a/quiche/common/platform/default/quiche_platform_impl/quiche_mutex_impl.cc
+++ /dev/null
@@ -1,15 +0,0 @@
-#include "quiche_platform_impl/quiche_mutex_impl.h"
-
-namespace quiche {
-
-void QuicheLockImpl::WriterLock() { mu_.WriterLock(); }
-
-void QuicheLockImpl::WriterUnlock() { mu_.WriterUnlock(); }
-
-void QuicheLockImpl::ReaderLock() { mu_.ReaderLock(); }
-
-void QuicheLockImpl::ReaderUnlock() { mu_.ReaderUnlock(); }
-
-void QuicheLockImpl::AssertReaderHeld() const { mu_.AssertReaderHeld(); }
-
-}  // namespace quiche
diff --git a/quiche/common/platform/default/quiche_platform_impl/quiche_mutex_impl.h b/quiche/common/platform/default/quiche_platform_impl/quiche_mutex_impl.h
deleted file mode 100644
index c6f6655..0000000
--- a/quiche/common/platform/default/quiche_platform_impl/quiche_mutex_impl.h
+++ /dev/null
@@ -1,68 +0,0 @@
-#ifndef QUICHE_COMMON_PLATFORM_DEFAULT_QUICHE_PLATFORM_IMPL_QUICHE_MUTEX_IMPL_H_
-#define QUICHE_COMMON_PLATFORM_DEFAULT_QUICHE_PLATFORM_IMPL_QUICHE_MUTEX_IMPL_H_
-
-#include "absl/synchronization/mutex.h"
-#include "absl/synchronization/notification.h"
-#include "quiche/common/platform/api/quiche_export.h"
-
-#define QUICHE_EXCLUSIVE_LOCKS_REQUIRED_IMPL ABSL_EXCLUSIVE_LOCKS_REQUIRED
-#define QUICHE_GUARDED_BY_IMPL ABSL_GUARDED_BY
-#define QUICHE_LOCKABLE_IMPL ABSL_LOCKABLE
-#define QUICHE_LOCKS_EXCLUDED_IMPL ABSL_LOCKS_EXCLUDED
-#define QUICHE_SHARED_LOCKS_REQUIRED_IMPL ABSL_SHARED_LOCKS_REQUIRED
-#define QUICHE_EXCLUSIVE_LOCK_FUNCTION_IMPL ABSL_EXCLUSIVE_LOCK_FUNCTION
-#define QUICHE_UNLOCK_FUNCTION_IMPL ABSL_UNLOCK_FUNCTION
-#define QUICHE_SHARED_LOCK_FUNCTION_IMPL ABSL_SHARED_LOCK_FUNCTION
-#define QUICHE_SCOPED_LOCKABLE_IMPL ABSL_SCOPED_LOCKABLE
-#define QUICHE_ASSERT_SHARED_LOCK_IMPL ABSL_ASSERT_SHARED_LOCK
-
-namespace quiche {
-
-// A class wrapping a non-reentrant mutex.
-class ABSL_LOCKABLE QUICHE_EXPORT QuicheLockImpl {
- public:
-  QuicheLockImpl() = default;
-  QuicheLockImpl(const QuicheLockImpl&) = delete;
-  QuicheLockImpl& operator=(const QuicheLockImpl&) = delete;
-
-  // Block until mu_ is free, then acquire it exclusively.
-  void WriterLock() ABSL_EXCLUSIVE_LOCK_FUNCTION();
-
-  // Release mu_. Caller must hold it exclusively.
-  void WriterUnlock() ABSL_UNLOCK_FUNCTION();
-
-  // Block until mu_ is free or shared, then acquire a share of it.
-  void ReaderLock() ABSL_SHARED_LOCK_FUNCTION();
-
-  // Release mu_. Caller could hold it in shared mode.
-  void ReaderUnlock() ABSL_UNLOCK_FUNCTION();
-
-  // Returns immediately if current thread holds mu_ in at least shared
-  // mode.  Otherwise, reports an error by crashing with a diagnostic.
-  void AssertReaderHeld() const ABSL_ASSERT_SHARED_LOCK();
-
- private:
-  absl::Mutex mu_;
-};
-
-// A Notification allows threads to receive notification of a single occurrence
-// of a single event.
-class QUICHE_EXPORT QuicheNotificationImpl {
- public:
-  QuicheNotificationImpl() = default;
-  QuicheNotificationImpl(const QuicheNotificationImpl&) = delete;
-  QuicheNotificationImpl& operator=(const QuicheNotificationImpl&) = delete;
-
-  bool HasBeenNotified() { return notification_.HasBeenNotified(); }
-
-  void Notify() { notification_.Notify(); }
-
-  void WaitForNotification() { notification_.WaitForNotification(); }
-
- private:
-  absl::Notification notification_;
-};
-
-}  // namespace quiche
-
-#endif  // QUICHE_COMMON_PLATFORM_DEFAULT_QUICHE_PLATFORM_IMPL_QUICHE_MUTEX_IMPL_H_
diff --git a/quiche/quic/core/crypto/crypto_secret_boxer.cc b/quiche/quic/core/crypto/crypto_secret_boxer.cc
index b51ce6b..e133a7f 100644
--- a/quiche/quic/core/crypto/crypto_secret_boxer.cc
+++ b/quiche/quic/core/crypto/crypto_secret_boxer.cc
@@ -11,11 +11,11 @@
 #include <vector>
 
 #include "absl/strings/string_view.h"
+#include "absl/synchronization/mutex.h"
 #include "openssl/aead.h"
 #include "openssl/err.h"
 #include "quiche/quic/core/crypto/quic_random.h"
 #include "quiche/quic/platform/api/quic_logging.h"
-#include "quiche/common/platform/api/quiche_mutex.h"
 
 namespace quic {
 
@@ -68,7 +68,7 @@
     new_state->ctxs.push_back(std::move(ctx));
   }
 
-  quiche::QuicheWriterMutexLock l(&lock_);
+  absl::WriterMutexLock l(&lock_);
   state_ = std::move(new_state);
   return true;
 }
@@ -95,7 +95,7 @@
 
   size_t bytes_written;
   {
-    quiche::QuicheReaderMutexLock l(&lock_);
+    absl::ReaderMutexLock l(&lock_);
     if (!EVP_AEAD_CTX_seal(state_->ctxs[0].get(), out, &bytes_written, out_len,
                            nonce, kSIVNonceSize,
                            reinterpret_cast<const uint8_t*>(plaintext.data()),
@@ -126,7 +126,7 @@
 
   bool ok = false;
   {
-    quiche::QuicheReaderMutexLock l(&lock_);
+    absl::ReaderMutexLock l(&lock_);
     for (const bssl::UniquePtr<EVP_AEAD_CTX>& ctx : state_->ctxs) {
       size_t bytes_written;
       if (EVP_AEAD_CTX_open(ctx.get(),
diff --git a/quiche/quic/core/crypto/crypto_secret_boxer.h b/quiche/quic/core/crypto/crypto_secret_boxer.h
index 5b76891..e3c9119 100644
--- a/quiche/quic/core/crypto/crypto_secret_boxer.h
+++ b/quiche/quic/core/crypto/crypto_secret_boxer.h
@@ -10,10 +10,11 @@
 #include <string>
 #include <vector>
 
+#include "absl/base/thread_annotations.h"
 #include "absl/strings/string_view.h"
+#include "absl/synchronization/mutex.h"
 #include "quiche/quic/core/crypto/quic_random.h"
 #include "quiche/quic/platform/api/quic_export.h"
-#include "quiche/common/platform/api/quiche_mutex.h"
 
 namespace quic {
 
@@ -55,11 +56,11 @@
  private:
   struct State;
 
-  mutable quiche::QuicheMutex lock_;
+  mutable absl::Mutex lock_;
 
   // state_ is an opaque pointer to whatever additional state the concrete
   // implementation of CryptoSecretBoxer requires.
-  std::unique_ptr<State> state_ QUICHE_GUARDED_BY(lock_);
+  std::unique_ptr<State> state_ ABSL_GUARDED_BY(lock_);
 };
 
 }  // namespace quic
diff --git a/quiche/quic/core/crypto/quic_crypto_server_config.cc b/quiche/quic/core/crypto/quic_crypto_server_config.cc
index 6c8d52b..fa85ce1 100644
--- a/quiche/quic/core/crypto/quic_crypto_server_config.cc
+++ b/quiche/quic/core/crypto/quic_crypto_server_config.cc
@@ -438,7 +438,7 @@
   }
 
   {
-    quiche::QuicheWriterMutexLock locked(&configs_lock_);
+    absl::WriterMutexLock locked(&configs_lock_);
     if (configs_.find(config->id) != configs_.end()) {
       QUIC_LOG(WARNING) << "Failed to add config because another with the same "
                            "server config id already exists: "
@@ -501,7 +501,7 @@
 
   QUIC_LOG(INFO) << "Updating configs:";
 
-  quiche::QuicheWriterMutexLock locked(&configs_lock_);
+  absl::WriterMutexLock locked(&configs_lock_);
   ConfigMap new_configs;
 
   for (const quiche::QuicheReferenceCountedPointer<Config>& config :
@@ -552,7 +552,7 @@
 }
 
 std::vector<std::string> QuicCryptoServerConfig::GetConfigIds() const {
-  quiche::QuicheReaderMutexLock locked(&configs_lock_);
+  absl::ReaderMutexLock locked(&configs_lock_);
   std::vector<std::string> scids;
   for (auto it = configs_.begin(); it != configs_.end(); ++it) {
     scids.push_back(it->first);
@@ -1123,7 +1123,7 @@
     const QuicWallTime& now, absl::string_view requested_scid,
     quiche::QuicheReferenceCountedPointer<Config> old_primary_config,
     Configs* configs) const {
-  quiche::QuicheReaderMutexLock locked(&configs_lock_);
+  absl::ReaderMutexLock locked(&configs_lock_);
 
   if (!primary_config_) {
     return false;
@@ -1359,7 +1359,7 @@
   std::string serialized;
   std::string source_address_token;
   {
-    quiche::QuicheReaderMutexLock locked(&configs_lock_);
+    absl::ReaderMutexLock locked(&configs_lock_);
     serialized = primary_config_->serialized;
     source_address_token = NewSourceAddressToken(
         *primary_config_->source_address_token_boxer,
@@ -1717,7 +1717,7 @@
 
 void QuicCryptoServerConfig::AcquirePrimaryConfigChangedCb(
     std::unique_ptr<PrimaryConfigChangedCallback> cb) {
-  quiche::QuicheWriterMutexLock locked(&configs_lock_);
+  absl::WriterMutexLock locked(&configs_lock_);
   primary_config_changed_cb_ = std::move(cb);
 }
 
@@ -1758,7 +1758,7 @@
 }
 
 int QuicCryptoServerConfig::NumberOfConfigs() const {
-  quiche::QuicheReaderMutexLock locked(&configs_lock_);
+  absl::ReaderMutexLock locked(&configs_lock_);
   return configs_.size();
 }
 
diff --git a/quiche/quic/core/crypto/quic_crypto_server_config.h b/quiche/quic/core/crypto/quic_crypto_server_config.h
index 30875a6..1692cea 100644
--- a/quiche/quic/core/crypto/quic_crypto_server_config.h
+++ b/quiche/quic/core/crypto/quic_crypto_server_config.h
@@ -12,7 +12,9 @@
 #include <string>
 #include <vector>
 
+#include "absl/base/thread_annotations.h"
 #include "absl/strings/string_view.h"
+#include "absl/synchronization/mutex.h"
 #include "openssl/base.h"
 #include "quiche/quic/core/crypto/crypto_handshake.h"
 #include "quiche/quic/core/crypto/crypto_handshake_message.h"
@@ -28,7 +30,6 @@
 #include "quiche/quic/core/quic_time.h"
 #include "quiche/quic/platform/api/quic_export.h"
 #include "quiche/quic/platform/api/quic_socket_address.h"
-#include "quiche/common/platform/api/quiche_mutex.h"
 #include "quiche/common/platform/api/quiche_reference_counted.h"
 
 namespace quic {
@@ -539,7 +540,7 @@
   // Get a ref to the config with a given server config id.
   quiche::QuicheReferenceCountedPointer<Config> GetConfigWithScid(
       absl::string_view requested_scid) const
-      QUICHE_SHARED_LOCKS_REQUIRED(configs_lock_);
+      ABSL_SHARED_LOCKS_REQUIRED(configs_lock_);
 
   // A snapshot of the configs associated with an in-progress handshake.
   struct QUICHE_EXPORT Configs {
@@ -568,7 +569,7 @@
   // SelectNewPrimaryConfig reevaluates the primary config based on the
   // "primary_time" deadlines contained in each.
   void SelectNewPrimaryConfig(QuicWallTime now) const
-      QUICHE_EXCLUSIVE_LOCKS_REQUIRED(configs_lock_);
+      ABSL_EXCLUSIVE_LOCKS_REQUIRED(configs_lock_);
 
   // EvaluateClientHello checks |client_hello_state->client_hello| for gross
   // errors and determines whether it is fresh (i.e. not a replay). The results
@@ -843,7 +844,7 @@
 
   // Returns true if the next config promotion should happen now.
   bool IsNextConfigReady(QuicWallTime now) const
-      QUICHE_SHARED_LOCKS_REQUIRED(configs_lock_);
+      ABSL_SHARED_LOCKS_REQUIRED(configs_lock_);
 
   // replay_protection_ controls whether the server enforces that handshakes
   // aren't replays.
@@ -858,16 +859,16 @@
   //   1) configs_.empty() <-> primary_config_ == nullptr
   //   2) primary_config_ != nullptr -> primary_config_->is_primary
   //   3) ∀ c∈configs_, c->is_primary <-> c == primary_config_
-  mutable quiche::QuicheMutex configs_lock_;
+  mutable absl::Mutex configs_lock_;
 
   // configs_ contains all active server configs. It's expected that there are
   // about half-a-dozen configs active at any one time.
-  ConfigMap configs_ QUICHE_GUARDED_BY(configs_lock_);
+  ConfigMap configs_ ABSL_GUARDED_BY(configs_lock_);
 
   // primary_config_ points to a Config (which is also in |configs_|) which is
   // the primary config - i.e. the one that we'll give out to new clients.
   mutable quiche::QuicheReferenceCountedPointer<Config> primary_config_
-      QUICHE_GUARDED_BY(configs_lock_);
+      ABSL_GUARDED_BY(configs_lock_);
 
   // fallback_config_ points to a Config (which is also in |configs_|) which is
   // the fallback config, which will be used if the other configs are unuseable
@@ -875,16 +876,16 @@
   //
   // TODO(b/112548056): This is currently always nullptr.
   quiche::QuicheReferenceCountedPointer<Config> fallback_config_
-      QUICHE_GUARDED_BY(configs_lock_);
+      ABSL_GUARDED_BY(configs_lock_);
 
   // next_config_promotion_time_ contains the nearest, future time when an
   // active config will be promoted to primary.
   mutable QuicWallTime next_config_promotion_time_
-      QUICHE_GUARDED_BY(configs_lock_);
+      ABSL_GUARDED_BY(configs_lock_);
 
   // Callback to invoke when the primary config changes.
   std::unique_ptr<PrimaryConfigChangedCallback> primary_config_changed_cb_
-      QUICHE_GUARDED_BY(configs_lock_);
+      ABSL_GUARDED_BY(configs_lock_);
 
   // Used to protect the source-address tokens that are given to clients.
   CryptoSecretBoxer source_address_token_boxer_;
diff --git a/quiche/quic/core/http/end_to_end_test.cc b/quiche/quic/core/http/end_to_end_test.cc
index 05715e8..2ee4d33 100644
--- a/quiche/quic/core/http/end_to_end_test.cc
+++ b/quiche/quic/core/http/end_to_end_test.cc
@@ -16,6 +16,7 @@
 
 #include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
+#include "absl/synchronization/notification.h"
 #include "absl/time/clock.h"
 #include "absl/time/time.h"
 #include "absl/types/span.h"
@@ -7742,7 +7743,7 @@
   ASSERT_TRUE(Initialize());
 
   const uint32_t server_flow_label = 2;
-  quiche::QuicheNotification set;
+  absl::Notification set;
   server_thread_->Schedule([this, &set]() {
     QuicConnection* server_connection = GetServerConnection();
     if (server_connection != nullptr) {
diff --git a/quiche/quic/core/io/event_loop_connecting_client_socket_test.cc b/quiche/quic/core/io/event_loop_connecting_client_socket_test.cc
index f195d9d..f5583b5 100644
--- a/quiche/quic/core/io/event_loop_connecting_client_socket_test.cc
+++ b/quiche/quic/core/io/event_loop_connecting_client_socket_test.cc
@@ -15,6 +15,7 @@
 #include "absl/status/statusor.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
+#include "absl/synchronization/notification.h"
 #include "absl/types/span.h"
 #include "quiche/quic/core/connecting_client_socket.h"
 #include "quiche/quic/core/io/event_loop_socket_factory.h"
@@ -28,7 +29,6 @@
 #include "quiche/quic/test_tools/quic_test_utils.h"
 #include "quiche/common/platform/api/quiche_logging.h"
 #include "quiche/common/platform/api/quiche_mem_slice.h"
-#include "quiche/common/platform/api/quiche_mutex.h"
 #include "quiche/common/platform/api/quiche_test.h"
 #include "quiche/common/platform/api/quiche_test_loopback.h"
 #include "quiche/common/platform/api/quiche_thread.h"
@@ -63,7 +63,7 @@
 
   const SocketBehavior& behavior() const { return behavior_; }
 
-  quiche::QuicheNotification& completion_notification() {
+  absl::Notification& completion_notification() {
     return completion_notification_;
   }
 
@@ -71,7 +71,7 @@
   const SocketFd server_socket_descriptor_;
   const SocketBehavior behavior_;
 
-  quiche::QuicheNotification completion_notification_;
+  absl::Notification completion_notification_;
 };
 
 class TestTcpServerSocketRunner : public TestServerSocketRunner {
diff --git a/quiche/quic/platform/api/quic_mutex.h b/quiche/quic/platform/api/quic_mutex.h
deleted file mode 100644
index ac42b5a..0000000
--- a/quiche/quic/platform/api/quic_mutex.h
+++ /dev/null
@@ -1,29 +0,0 @@
-// Copyright (c) 2016 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-// TODO(b/178613777): Remove this file.
-
-#ifndef QUICHE_QUIC_PLATFORM_API_QUIC_MUTEX_H_
-#define QUICHE_QUIC_PLATFORM_API_QUIC_MUTEX_H_
-
-#include "quiche/common/platform/api/quiche_mutex.h"
-
-#define QUIC_EXCLUSIVE_LOCKS_REQUIRED QUICHE_EXCLUSIVE_LOCKS_REQUIRED
-#define QUIC_LOCKABLE QUICHE_LOCKABLE
-#define QUIC_LOCKS_EXCLUDED QUICHE_LOCKS_EXCLUDED
-#define QUIC_EXCLUSIVE_LOCK_FUNCTION QUICHE_EXCLUSIVE_LOCK_FUNCTION
-#define QUIC_UNLOCK_FUNCTION QUICHE_UNLOCK_FUNCTION
-#define QUIC_SHARED_LOCK_FUNCTION QUICHE_SHARED_LOCK_FUNCTION
-#define QUIC_SCOPED_LOCKABLE QUICHE_SCOPED_LOCKABLE
-#define QUIC_ASSERT_SHARED_LOCK QUICHE_ASSERT_SHARED_LOCK
-
-namespace quic {
-
-using QuicMutex = quiche::QuicheMutex;
-using QuicWriterMutexLock = quiche::QuicheWriterMutexLock;
-using QuicNotification = quiche::QuicheNotification;
-
-}  // namespace quic
-
-#endif  // QUICHE_QUIC_PLATFORM_API_QUIC_MUTEX_H_
diff --git a/quiche/quic/qbone/bonnet/icmp_reachable.cc b/quiche/quic/qbone/bonnet/icmp_reachable.cc
index 54002e4..5b6c212 100644
--- a/quiche/quic/qbone/bonnet/icmp_reachable.cc
+++ b/quiche/quic/qbone/bonnet/icmp_reachable.cc
@@ -103,7 +103,7 @@
   }
   alarm_->Set(clock_->Now());
 
-  quiche::QuicheWriterMutexLock mu(&header_lock_);
+  absl::WriterMutexLock mu(&header_lock_);
   icmp_header_.icmp6_type = ICMP6_ECHO_REQUEST;
   icmp_header_.icmp6_code = 0;
 
@@ -134,7 +134,7 @@
       absl::string_view(buffer, size));
 
   auto* header = reinterpret_cast<const icmp6_hdr*>(&buffer);
-  quiche::QuicheWriterMutexLock mu(&header_lock_);
+  absl::WriterMutexLock mu(&header_lock_);
   if (header->icmp6_data32[0] != icmp_header_.icmp6_data32[0]) {
     QUIC_VLOG(2) << "Unexpected response. id: " << header->icmp6_id
                  << " seq: " << header->icmp6_seq
@@ -159,7 +159,7 @@
 }
 
 void IcmpReachable::OnAlarm() {
-  quiche::QuicheWriterMutexLock mu(&header_lock_);
+  absl::WriterMutexLock mu(&header_lock_);
 
   if (end_ < start_) {
     QUIC_VLOG(1) << "Timed out on sequence: " << icmp_header_.icmp6_seq;
diff --git a/quiche/quic/qbone/bonnet/icmp_reachable.h b/quiche/quic/qbone/bonnet/icmp_reachable.h
index d706c9b..89e15aa 100644
--- a/quiche/quic/qbone/bonnet/icmp_reachable.h
+++ b/quiche/quic/qbone/bonnet/icmp_reachable.h
@@ -9,7 +9,9 @@
 
 #include <memory>
 
+#include "absl/base/thread_annotations.h"
 #include "absl/strings/string_view.h"
+#include "absl/synchronization/mutex.h"
 #include "quiche/quic/core/io/quic_event_loop.h"
 #include "quiche/quic/core/quic_alarm.h"
 #include "quiche/quic/core/quic_alarm_factory.h"
@@ -18,7 +20,6 @@
 #include "quiche/quic/platform/api/quic_ip_address.h"
 #include "quiche/quic/qbone/bonnet/icmp_reachable_interface.h"
 #include "quiche/quic/qbone/platform/kernel_interface.h"
-#include "quiche/common/platform/api/quiche_mutex.h"
 
 namespace quic {
 
@@ -79,9 +80,9 @@
 
   // Initializes this reachability probe. Must be called from within the
   // |epoll_server|'s thread.
-  bool Init() QUICHE_LOCKS_EXCLUDED(header_lock_) override;
+  bool Init() ABSL_LOCKS_EXCLUDED(header_lock_) override;
 
-  void OnAlarm() QUICHE_LOCKS_EXCLUDED(header_lock_);
+  void OnAlarm() ABSL_LOCKS_EXCLUDED(header_lock_);
 
   static absl::string_view StatusName(Status status);
 
@@ -113,7 +114,7 @@
     IcmpReachable* reachable_;
   };
 
-  bool OnEvent(int fd) QUICHE_LOCKS_EXCLUDED(header_lock_);
+  bool OnEvent(int fd) ABSL_LOCKS_EXCLUDED(header_lock_);
 
   const QuicTime::Delta timeout_;
 
@@ -134,8 +135,8 @@
   int send_fd_;
   int recv_fd_;
 
-  quiche::QuicheMutex header_lock_;
-  icmp6_hdr icmp_header_ QUICHE_GUARDED_BY(header_lock_){};
+  absl::Mutex header_lock_;
+  icmp6_hdr icmp_header_ ABSL_GUARDED_BY(header_lock_){};
 
   QuicTime start_ = QuicTime::Zero();
   QuicTime end_ = QuicTime::Zero();
diff --git a/quiche/quic/qbone/qbone_client_test.cc b/quiche/quic/qbone/qbone_client_test.cc
index d7ea860..d986477 100644
--- a/quiche/quic/qbone/qbone_client_test.cc
+++ b/quiche/quic/qbone/qbone_client_test.cc
@@ -12,6 +12,7 @@
 #include <vector>
 
 #include "absl/strings/string_view.h"
+#include "absl/synchronization/mutex.h"
 #include "quiche/quic/core/io/quic_default_event_loop.h"
 #include "quiche/quic/core/io/quic_event_loop.h"
 #include "quiche/quic/core/quic_alarm_factory.h"
@@ -57,17 +58,17 @@
 class DataSavingQbonePacketWriter : public QbonePacketWriter {
  public:
   void WritePacketToNetwork(const char* packet, size_t size) override {
-    quiche::QuicheWriterMutexLock lock(&mu_);
+    absl::WriterMutexLock lock(&mu_);
     data_.push_back(std::string(packet, size));
   }
 
   std::vector<std::string> data() {
-    quiche::QuicheWriterMutexLock lock(&mu_);
+    absl::WriterMutexLock lock(&mu_);
     return data_;
   }
 
  private:
-  quiche::QuicheMutex mu_;
+  absl::Mutex mu_;
   std::vector<std::string> data_;
 };
 
diff --git a/quiche/quic/test_tools/packet_dropping_test_writer.cc b/quiche/quic/test_tools/packet_dropping_test_writer.cc
index a16cda7..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();
 
-  quiche::QuicheWriterMutexLock 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();
   }
-  quiche::QuicheReaderMutexLock 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 &&
diff --git a/quiche/quic/test_tools/packet_dropping_test_writer.h b/quiche/quic/test_tools/packet_dropping_test_writer.h
index 84bfcfa..6a72795 100644
--- a/quiche/quic/test_tools/packet_dropping_test_writer.h
+++ b/quiche/quic/test_tools/packet_dropping_test_writer.h
@@ -10,13 +10,14 @@
 #include <memory>
 
 #include "absl/base/attributes.h"
+#include "absl/base/thread_annotations.h"
+#include "absl/synchronization/mutex.h"
 #include "quiche/quic/core/quic_alarm.h"
 #include "quiche/quic/core/quic_alarm_factory.h"
 #include "quiche/quic/core/quic_clock.h"
 #include "quiche/quic/core/quic_connection.h"
 #include "quiche/quic/core/quic_packet_writer_wrapper.h"
 #include "quiche/quic/test_tools/quic_test_utils.h"
-#include "quiche/common/platform/api/quiche_mutex.h"
 
 namespace quic {
 namespace test {
@@ -80,7 +81,7 @@
   // |fake_packet_loss_percentage|, because every dropped package is followed by
   // a minimum number of successfully written packets.
   void set_fake_packet_loss_percentage(int32_t fake_packet_loss_percentage) {
-    quiche::QuicheWriterMutexLock lock(&config_mutex_);
+    absl::WriterMutexLock lock(&config_mutex_);
     fake_packet_loss_percentage_ = fake_packet_loss_percentage;
   }
 
@@ -89,14 +90,14 @@
   // simulated error conditions.
   void set_passthrough_for_next_n_packets(
       uint32_t passthrough_for_next_n_packets) {
-    quiche::QuicheWriterMutexLock lock(&config_mutex_);
+    absl::WriterMutexLock lock(&config_mutex_);
     passthrough_for_next_n_packets_ = passthrough_for_next_n_packets;
   }
 
   // Simulate dropping the first n packets unconditionally.
   // Subsequent packets will be lost at fake_packet_loss_percentage_ if set.
   void set_fake_drop_first_n_packets(int32_t fake_drop_first_n_packets) {
-    quiche::QuicheWriterMutexLock lock(&config_mutex_);
+    absl::WriterMutexLock lock(&config_mutex_);
     fake_drop_first_n_packets_ = fake_drop_first_n_packets;
   }
 
@@ -105,14 +106,14 @@
   void set_fake_blocked_socket_percentage(
       int32_t fake_blocked_socket_percentage) {
     QUICHE_DCHECK(clock_);
-    quiche::QuicheWriterMutexLock lock(&config_mutex_);
+    absl::WriterMutexLock lock(&config_mutex_);
     fake_blocked_socket_percentage_ = fake_blocked_socket_percentage;
   }
 
   // The percent of time a packet is simulated as being reordered.
   void set_fake_reorder_percentage(int32_t fake_packet_reorder_percentage) {
     QUICHE_DCHECK(clock_);
-    quiche::QuicheWriterMutexLock lock(&config_mutex_);
+    absl::WriterMutexLock lock(&config_mutex_);
     QUICHE_DCHECK(!fake_packet_delay_.IsZero());
     fake_packet_reorder_percentage_ = fake_packet_reorder_percentage;
   }
@@ -120,7 +121,7 @@
   // The delay before writing this packet.
   void set_fake_packet_delay(QuicTime::Delta fake_packet_delay) {
     QUICHE_DCHECK(clock_);
-    quiche::QuicheWriterMutexLock lock(&config_mutex_);
+    absl::WriterMutexLock lock(&config_mutex_);
     fake_packet_delay_ = fake_packet_delay;
   }
 
@@ -131,7 +132,7 @@
   void set_max_bandwidth_and_buffer_size(QuicBandwidth fake_bandwidth,
                                          QuicByteCount buffer_size) {
     QUICHE_DCHECK(clock_);
-    quiche::QuicheWriterMutexLock lock(&config_mutex_);
+    absl::WriterMutexLock lock(&config_mutex_);
     fake_bandwidth_ = fake_bandwidth;
     buffer_size_ = buffer_size;
   }
@@ -179,17 +180,17 @@
   DelayedPacketList delayed_packets_;
   QuicByteCount cur_buffer_size_;
   uint64_t num_calls_to_write_;
-  uint32_t passthrough_for_next_n_packets_ QUICHE_GUARDED_BY(config_mutex_);
+  uint32_t passthrough_for_next_n_packets_ ABSL_GUARDED_BY(config_mutex_);
   int32_t num_consecutive_succesful_writes_;
 
-  quiche::QuicheMutex config_mutex_;
-  int32_t fake_packet_loss_percentage_ QUICHE_GUARDED_BY(config_mutex_);
-  int32_t fake_drop_first_n_packets_ QUICHE_GUARDED_BY(config_mutex_);
-  int32_t fake_blocked_socket_percentage_ QUICHE_GUARDED_BY(config_mutex_);
-  int32_t fake_packet_reorder_percentage_ QUICHE_GUARDED_BY(config_mutex_);
-  QuicTime::Delta fake_packet_delay_ QUICHE_GUARDED_BY(config_mutex_);
-  QuicBandwidth fake_bandwidth_ QUICHE_GUARDED_BY(config_mutex_);
-  QuicByteCount buffer_size_ QUICHE_GUARDED_BY(config_mutex_);
+  absl::Mutex config_mutex_;
+  int32_t fake_packet_loss_percentage_ ABSL_GUARDED_BY(config_mutex_);
+  int32_t fake_drop_first_n_packets_ ABSL_GUARDED_BY(config_mutex_);
+  int32_t fake_blocked_socket_percentage_ ABSL_GUARDED_BY(config_mutex_);
+  int32_t fake_packet_reorder_percentage_ ABSL_GUARDED_BY(config_mutex_);
+  QuicTime::Delta fake_packet_delay_ ABSL_GUARDED_BY(config_mutex_);
+  QuicBandwidth fake_bandwidth_ ABSL_GUARDED_BY(config_mutex_);
+  QuicByteCount buffer_size_ ABSL_GUARDED_BY(config_mutex_);
 };
 
 }  // namespace test
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 b8a6280..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() {
-  quiche::QuicheReaderMutexLock 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) {
-  quiche::QuicheReaderMutexLock 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) {
-  quiche::QuicheReaderMutexLock 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) {
-  quiche::QuicheWriterMutexLock locked(&server_config_->configs_lock_);
+  absl::WriterMutexLock locked(&server_config_->configs_lock_);
   server_config_->SelectNewPrimaryConfig(
       QuicWallTime::FromUNIXSeconds(seconds));
 }
diff --git a/quiche/quic/test_tools/quic_crypto_server_config_peer.h b/quiche/quic/test_tools/quic_crypto_server_config_peer.h
index fe9f32c..477b0a6 100644
--- a/quiche/quic/test_tools/quic_crypto_server_config_peer.h
+++ b/quiche/quic/test_tools/quic_crypto_server_config_peer.h
@@ -5,6 +5,7 @@
 #ifndef QUICHE_QUIC_TEST_TOOLS_QUIC_CRYPTO_SERVER_CONFIG_PEER_H_
 #define QUICHE_QUIC_TEST_TOOLS_QUIC_CRYPTO_SERVER_CONFIG_PEER_H_
 
+#include "absl/base/thread_annotations.h"
 #include "absl/strings/string_view.h"
 #include "quiche/quic/core/crypto/quic_crypto_server_config.h"
 
@@ -65,7 +66,7 @@
   // ConfigsDebug returns a std::string that contains debugging information
   // about the set of Configs loaded in |server_config_| and their status.
   std::string ConfigsDebug()
-      QUICHE_SHARED_LOCKS_REQUIRED(server_config_->configs_lock_);
+      ABSL_SHARED_LOCKS_REQUIRED(server_config_->configs_lock_);
 
   void SelectNewPrimaryConfig(int seconds);
 
diff --git a/quiche/quic/test_tools/quic_test_server.cc b/quiche/quic/test_tools/quic_test_server.cc
index 9ef1368..09795f7 100644
--- a/quiche/quic/test_tools/quic_test_server.cc
+++ b/quiche/quic/test_tools/quic_test_server.cc
@@ -9,6 +9,7 @@
 
 #include "absl/memory/memory.h"
 #include "absl/strings/string_view.h"
+#include "absl/synchronization/mutex.h"
 #include "quiche/quic/core/connection_id_generator.h"
 #include "quiche/quic/core/io/quic_default_event_loop.h"
 #include "quiche/quic/core/quic_default_connection_helper.h"
@@ -94,7 +95,7 @@
       const ParsedQuicVersion& version,
       const ParsedClientHello& /*parsed_chlo*/,
       ConnectionIdGeneratorInterface& connection_id_generator) override {
-    quiche::QuicheReaderMutexLock 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(),
@@ -130,7 +131,7 @@
   }
 
   void SetSessionFactory(QuicTestServer::SessionFactory* factory) {
-    quiche::QuicheWriterMutexLock lock(&factory_lock_);
+    absl::WriterMutexLock lock(&factory_lock_);
     QUICHE_DCHECK(session_factory_ == nullptr);
     QUICHE_DCHECK(stream_factory_ == nullptr);
     QUICHE_DCHECK(crypto_stream_factory_ == nullptr);
@@ -138,21 +139,21 @@
   }
 
   void SetStreamFactory(QuicTestServer::StreamFactory* factory) {
-    quiche::QuicheWriterMutexLock 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) {
-    quiche::QuicheWriterMutexLock lock(&factory_lock_);
+    absl::WriterMutexLock lock(&factory_lock_);
     QUICHE_DCHECK(session_factory_ == nullptr);
     QUICHE_DCHECK(crypto_stream_factory_ == nullptr);
     crypto_stream_factory_ = factory;
   }
 
  private:
-  quiche::QuicheMutex factory_lock_;
+  absl::Mutex factory_lock_;
   QuicTestServer::SessionFactory* session_factory_;             // Not owned.
   QuicTestServer::StreamFactory* stream_factory_;               // Not owned.
   QuicTestServer::CryptoStreamFactory* crypto_stream_factory_;  // Not owned.
diff --git a/quiche/quic/test_tools/quic_test_utils.h b/quiche/quic/test_tools/quic_test_utils.h
index f2fe5a5..90d9be4 100644
--- a/quiche/quic/test_tools/quic_test_utils.h
+++ b/quiche/quic/test_tools/quic_test_utils.h
@@ -17,6 +17,7 @@
 #include "absl/strings/ascii.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
+#include "absl/synchronization/mutex.h"
 #include "quiche/quic/core/congestion_control/loss_detection_interface.h"
 #include "quiche/quic/core/congestion_control/send_algorithm_interface.h"
 #include "quiche/quic/core/crypto/transport_parameters.h"
@@ -2082,7 +2083,7 @@
                           const QuicSocketAddress& peer_address,
                           PerPacketOptions* options,
                           const QuicPacketWriterParams& params) override {
-    quiche::QuicheReaderMutexLock lock(&mutex_);
+    absl::ReaderMutexLock lock(&mutex_);
     QUIC_LOG(ERROR) << "DroppingPacketsWithSpecificDestinationWriter::"
                        "WritePacket with peer address "
                     << peer_address.ToString() << " and peer_address_to_drop_ "
@@ -2098,12 +2099,12 @@
   }
 
   void set_peer_address_to_drop(const QuicSocketAddress& peer_address) {
-    quiche::QuicheWriterMutexLock lock(&mutex_);
+    absl::WriterMutexLock lock(&mutex_);
     peer_address_to_drop_ = peer_address;
   }
 
  private:
-  quiche::QuicheMutex mutex_;
+  absl::Mutex mutex_;
   QuicSocketAddress peer_address_to_drop_ ABSL_GUARDED_BY(mutex_);
 };
 
diff --git a/quiche/quic/test_tools/server_thread.cc b/quiche/quic/test_tools/server_thread.cc
index dfa1098..c80bff8 100644
--- a/quiche/quic/test_tools/server_thread.cc
+++ b/quiche/quic/test_tools/server_thread.cc
@@ -7,12 +7,13 @@
 #include <memory>
 #include <utility>
 
+#include "absl/synchronization/mutex.h"
+#include "absl/synchronization/notification.h"
 #include "quiche/quic/core/quic_default_clock.h"
 #include "quiche/quic/core/quic_dispatcher.h"
 #include "quiche/quic/test_tools/crypto_test_utils.h"
 #include "quiche/quic/test_tools/quic_dispatcher_peer.h"
 #include "quiche/quic/test_tools/quic_server_peer.h"
-#include "quiche/common/platform/api/quiche_mutex.h"
 #include "quiche/common/quiche_callbacks.h"
 
 namespace quic {
@@ -37,7 +38,7 @@
     return;
   }
 
-  quiche::QuicheWriterMutexLock lock(&port_lock_);
+  absl::WriterMutexLock lock(&port_lock_);
   port_ = server_->port();
 
   initialized_ = true;
@@ -62,20 +63,20 @@
 }
 
 int ServerThread::GetPort() {
-  quiche::QuicheReaderMutexLock lock(&port_lock_);
+  absl::ReaderMutexLock lock(&port_lock_);
   int rc = port_;
   return rc;
 }
 
 void ServerThread::Schedule(quiche::SingleUseCallback<void()> action) {
   QUICHE_DCHECK(!quit_.HasBeenNotified());
-  quiche::QuicheWriterMutexLock lock(&scheduled_actions_lock_);
+  absl::WriterMutexLock lock(&scheduled_actions_lock_);
   scheduled_actions_.push_back(std::move(action));
 }
 
 void ServerThread::ScheduleAndWaitForCompletion(
     quiche::SingleUseCallback<void()> action) {
-  quiche::QuicheNotification action_done;
+  absl::Notification action_done;
   Schedule([&] {
     std::move(action)();
     action_done.Notify();
@@ -92,7 +93,7 @@
     QuicTime::Delta timeout) {
   const QuicTime deadline = clock_->Now() + timeout;
   while (clock_->Now() < deadline) {
-    quiche::QuicheNotification done_checking;
+    absl::Notification done_checking;
     bool should_terminate = false;
     Schedule([&] {
       should_terminate = termination_predicate();
@@ -146,7 +147,7 @@
 void ServerThread::ExecuteScheduledActions() {
   quiche::QuicheCircularDeque<quiche::SingleUseCallback<void()>> actions;
   {
-    quiche::QuicheWriterMutexLock lock(&scheduled_actions_lock_);
+    absl::WriterMutexLock lock(&scheduled_actions_lock_);
     actions.swap(scheduled_actions_);
   }
   while (!actions.empty()) {
diff --git a/quiche/quic/test_tools/server_thread.h b/quiche/quic/test_tools/server_thread.h
index b3d0f8d..3b55dd9 100644
--- a/quiche/quic/test_tools/server_thread.h
+++ b/quiche/quic/test_tools/server_thread.h
@@ -7,11 +7,13 @@
 
 #include <memory>
 
+#include "absl/base/thread_annotations.h"
+#include "absl/synchronization/mutex.h"
+#include "absl/synchronization/notification.h"
 #include "quiche/quic/core/quic_config.h"
 #include "quiche/quic/platform/api/quic_socket_address.h"
 #include "quiche/quic/platform/api/quic_thread.h"
 #include "quiche/quic/tools/quic_server.h"
-#include "quiche/common/platform/api/quiche_mutex.h"
 #include "quiche/common/quiche_callbacks.h"
 
 namespace quic {
@@ -74,25 +76,24 @@
   void MaybeNotifyOfHandshakeConfirmation();
   void ExecuteScheduledActions();
 
-  quiche::QuicheNotification
-      confirmed_;  // Notified when the first handshake is confirmed.
-  quiche::QuicheNotification pause_;   // Notified when the server should pause.
-  quiche::QuicheNotification paused_;  // Notitied when the server has paused
-  quiche::QuicheNotification
-      resume_;                       // Notified when the server should resume.
-  quiche::QuicheNotification quit_;  // Notified when the server should quit.
+  absl::Notification
+      confirmed_;             // Notified when the first handshake is confirmed.
+  absl::Notification pause_;  // Notified when the server should pause.
+  absl::Notification paused_;  // Notitied when the server has paused
+  absl::Notification resume_;  // Notified when the server should resume.
+  absl::Notification quit_;    // Notified when the server should quit.
 
   std::unique_ptr<QuicServer> server_;
   QuicClock* clock_;
   QuicSocketAddress address_;
-  mutable quiche::QuicheMutex port_lock_;
-  int port_ QUICHE_GUARDED_BY(port_lock_);
+  mutable absl::Mutex port_lock_;
+  int port_ ABSL_GUARDED_BY(port_lock_);
 
   bool initialized_;
 
-  quiche::QuicheMutex scheduled_actions_lock_;
+  absl::Mutex scheduled_actions_lock_;
   quiche::QuicheCircularDeque<quiche::SingleUseCallback<void()>>
-      scheduled_actions_ QUICHE_GUARDED_BY(scheduled_actions_lock_);
+      scheduled_actions_ ABSL_GUARDED_BY(scheduled_actions_lock_);
 };
 
 }  // namespace test
diff --git a/quiche/quic/tools/quic_memory_cache_backend.cc b/quiche/quic/tools/quic_memory_cache_backend.cc
index 92c25e0..5290636 100644
--- a/quiche/quic/tools/quic_memory_cache_backend.cc
+++ b/quiche/quic/tools/quic_memory_cache_backend.cc
@@ -14,6 +14,7 @@
 #include "absl/strings/numbers.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
+#include "absl/synchronization/mutex.h"
 #include "quiche/quic/core/http/spdy_utils.h"
 #include "quiche/quic/platform/api/quic_bug_tracker.h"
 #include "quiche/quic/platform/api/quic_logging.h"
@@ -130,7 +131,7 @@
 
 const QuicBackendResponse* QuicMemoryCacheBackend::GetResponse(
     absl::string_view host, absl::string_view path) const {
-  quiche::QuicheWriterMutexLock lock(&response_mutex_);
+  absl::WriterMutexLock lock(&response_mutex_);
 
   auto it = responses_.find(GetKey(host, path));
   if (it == responses_.end()) {
@@ -166,7 +167,7 @@
 }
 
 void QuicMemoryCacheBackend::AddDefaultResponse(QuicBackendResponse* response) {
-  quiche::QuicheWriterMutexLock lock(&response_mutex_);
+  absl::WriterMutexLock lock(&response_mutex_);
   default_response_.reset(response);
 }
 
@@ -193,7 +194,7 @@
 bool QuicMemoryCacheBackend::SetResponseDelay(absl::string_view host,
                                               absl::string_view path,
                                               QuicTime::Delta delay) {
-  quiche::QuicheWriterMutexLock lock(&response_mutex_);
+  absl::WriterMutexLock lock(&response_mutex_);
   auto it = responses_.find(GetKey(host, path));
   if (it == responses_.end()) return false;
 
@@ -271,7 +272,7 @@
 }
 
 void QuicMemoryCacheBackend::GenerateDynamicResponses() {
-  quiche::QuicheWriterMutexLock lock(&response_mutex_);
+  absl::WriterMutexLock lock(&response_mutex_);
   // Add a generate bytes response.
   quiche::HttpHeaderBlock response_headers;
   response_headers[":status"] = "200";
@@ -362,7 +363,7 @@
 
 QuicMemoryCacheBackend::~QuicMemoryCacheBackend() {
   {
-    quiche::QuicheWriterMutexLock lock(&response_mutex_);
+    absl::WriterMutexLock lock(&response_mutex_);
     responses_.clear();
   }
 }
@@ -372,7 +373,7 @@
     SpecialResponseType response_type, HttpHeaderBlock response_headers,
     absl::string_view response_body, HttpHeaderBlock response_trailers,
     const std::vector<quiche::HttpHeaderBlock>& early_hints) {
-  quiche::QuicheWriterMutexLock lock(&response_mutex_);
+  absl::WriterMutexLock lock(&response_mutex_);
 
   QUICHE_DCHECK(!host.empty())
       << "Host must be populated, e.g. \"www.google.com\"";
diff --git a/quiche/quic/tools/quic_memory_cache_backend.h b/quiche/quic/tools/quic_memory_cache_backend.h
index 33c7f8a..409290b 100644
--- a/quiche/quic/tools/quic_memory_cache_backend.h
+++ b/quiche/quic/tools/quic_memory_cache_backend.h
@@ -10,14 +10,15 @@
 #include <memory>
 #include <vector>
 
+#include "absl/base/thread_annotations.h"
 #include "absl/container/flat_hash_map.h"
 #include "absl/strings/string_view.h"
+#include "absl/synchronization/mutex.h"
 #include "quiche/http2/core/spdy_framer.h"
 #include "quiche/quic/core/http/spdy_utils.h"
 #include "quiche/quic/tools/quic_backend_response.h"
 #include "quiche/quic/tools/quic_simple_server_backend.h"
 #include "quiche/common/http/http_header_block.h"
-#include "quiche/common/platform/api/quiche_mutex.h"
 
 namespace quic {
 
@@ -153,19 +154,19 @@
 
   // Cached responses.
   absl::flat_hash_map<std::string, std::unique_ptr<QuicBackendResponse>>
-      responses_ QUICHE_GUARDED_BY(response_mutex_);
+      responses_ ABSL_GUARDED_BY(response_mutex_);
 
   // The default response for cache misses, if set.
   std::unique_ptr<QuicBackendResponse> default_response_
-      QUICHE_GUARDED_BY(response_mutex_);
+      ABSL_GUARDED_BY(response_mutex_);
 
   // The generate bytes response, if set.
   std::unique_ptr<QuicBackendResponse> generate_bytes_response_
-      QUICHE_GUARDED_BY(response_mutex_);
+      ABSL_GUARDED_BY(response_mutex_);
 
   // Protects against concurrent access from test threads setting responses, and
   // server threads accessing those responses.
-  mutable quiche::QuicheMutex response_mutex_;
+  mutable absl::Mutex response_mutex_;
   bool cache_initialized_;
 
   bool enable_webtransport_ = false;