Remove QuicheMutex, etc., indirection
As of https://chromium-review.googlesource.com/c/chromium/src/+/6020098,
I believe no one is using this override. Just use Abseil directly.
PiperOrigin-RevId: 697415717
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;
