Remove QuicUint128 from platform.
Use Abseil directly.
PiperOrigin-RevId: 366984087
Change-Id: Iffc36bb4267828f2979b023f347f34e804b0fe4e
diff --git a/quic/core/chlo_extractor.cc b/quic/core/chlo_extractor.cc
index 198d455..0cce9f9 100644
--- a/quic/core/chlo_extractor.cc
+++ b/quic/core/chlo_extractor.cc
@@ -4,6 +4,7 @@
#include "quic/core/chlo_extractor.h"
+#include "absl/numeric/int128.h"
#include "absl/strings/match.h"
#include "absl/strings/string_view.h"
#include "quic/core/crypto/crypto_framer.h"
@@ -81,7 +82,7 @@
bool OnHandshakeDoneFrame(const QuicHandshakeDoneFrame& frame) override;
bool OnAckFrequencyFrame(const QuicAckFrequencyFrame& farme) override;
void OnPacketComplete() override {}
- bool IsValidStatelessResetToken(QuicUint128 token) const override;
+ bool IsValidStatelessResetToken(absl::uint128 token) const override;
void OnAuthenticatedIetfStatelessResetPacket(
const QuicIetfStatelessResetPacket& /*packet*/) override {}
void OnKeyUpdate(KeyUpdateReason /*reason*/) override;
@@ -303,7 +304,7 @@
}
bool ChloFramerVisitor::IsValidStatelessResetToken(
- QuicUint128 /*token*/) const {
+ absl::uint128 /*token*/) const {
return false;
}
diff --git a/quic/core/crypto/crypto_handshake_message.cc b/quic/core/crypto/crypto_handshake_message.cc
index 9628ed9..c71c051 100644
--- a/quic/core/crypto/crypto_handshake_message.cc
+++ b/quic/core/crypto/crypto_handshake_message.cc
@@ -222,8 +222,8 @@
}
QuicErrorCode CryptoHandshakeMessage::GetUint128(QuicTag tag,
- QuicUint128* out) const {
- return GetPOD(tag, out, sizeof(QuicUint128));
+ absl::uint128* out) const {
+ return GetPOD(tag, out, sizeof(absl::uint128));
}
size_t CryptoHandshakeMessage::size() const {
diff --git a/quic/core/crypto/crypto_handshake_message.h b/quic/core/crypto/crypto_handshake_message.h
index 61fb757..de02d6c 100644
--- a/quic/core/crypto/crypto_handshake_message.h
+++ b/quic/core/crypto/crypto_handshake_message.h
@@ -11,10 +11,10 @@
#include <string>
#include <vector>
+#include "absl/numeric/int128.h"
#include "absl/strings/string_view.h"
#include "quic/core/quic_packets.h"
#include "quic/platform/api/quic_export.h"
-#include "quic/platform/api/quic_uint128.h"
namespace quic {
@@ -110,7 +110,7 @@
absl::string_view* out) const;
QuicErrorCode GetUint32(QuicTag tag, uint32_t* out) const;
QuicErrorCode GetUint64(QuicTag tag, uint64_t* out) const;
- QuicErrorCode GetUint128(QuicTag tag, QuicUint128* out) const;
+ QuicErrorCode GetUint128(QuicTag tag, absl::uint128* out) const;
// size returns 4 (message tag) + 2 (uint16_t, number of entries) +
// (4 (tag) + 4 (end offset))*tag_value_map_.size() + ∑ value sizes.
diff --git a/quic/core/crypto/null_decrypter.cc b/quic/core/crypto/null_decrypter.cc
index 4162edc..fd611bd 100644
--- a/quic/core/crypto/null_decrypter.cc
+++ b/quic/core/crypto/null_decrypter.cc
@@ -6,11 +6,11 @@
#include <cstdint>
+#include "absl/numeric/int128.h"
#include "absl/strings/string_view.h"
#include "quic/core/quic_data_reader.h"
#include "quic/core/quic_utils.h"
#include "quic/platform/api/quic_bug_tracker.h"
-#include "quic/platform/api/quic_uint128.h"
#include "common/quiche_endian.h"
namespace quic {
@@ -53,7 +53,7 @@
size_t max_output_length) {
QuicDataReader reader(ciphertext.data(), ciphertext.length(),
quiche::HOST_BYTE_ORDER);
- QuicUint128 hash;
+ absl::uint128 hash;
if (!ReadHash(&reader, &hash)) {
return false;
@@ -107,19 +107,19 @@
return std::numeric_limits<QuicPacketCount>::max();
}
-bool NullDecrypter::ReadHash(QuicDataReader* reader, QuicUint128* hash) {
+bool NullDecrypter::ReadHash(QuicDataReader* reader, absl::uint128* hash) {
uint64_t lo;
uint32_t hi;
if (!reader->ReadUInt64(&lo) || !reader->ReadUInt32(&hi)) {
return false;
}
- *hash = MakeQuicUint128(hi, lo);
+ *hash = absl::MakeUint128(hi, lo);
return true;
}
-QuicUint128 NullDecrypter::ComputeHash(const absl::string_view data1,
- const absl::string_view data2) const {
- QuicUint128 correct_hash;
+absl::uint128 NullDecrypter::ComputeHash(const absl::string_view data1,
+ const absl::string_view data2) const {
+ absl::uint128 correct_hash;
if (perspective_ == Perspective::IS_CLIENT) {
// Peer is a server.
correct_hash = QuicUtils::FNV1a_128_Hash_Three(data1, data2, "Server");
@@ -127,7 +127,7 @@
// Peer is a client.
correct_hash = QuicUtils::FNV1a_128_Hash_Three(data1, data2, "Client");
}
- QuicUint128 mask = MakeQuicUint128(UINT64_C(0x0), UINT64_C(0xffffffff));
+ absl::uint128 mask = absl::MakeUint128(UINT64_C(0x0), UINT64_C(0xffffffff));
mask <<= 96;
correct_hash &= ~mask;
return correct_hash;
diff --git a/quic/core/crypto/null_decrypter.h b/quic/core/crypto/null_decrypter.h
index fd06d3a..b36fa82 100644
--- a/quic/core/crypto/null_decrypter.h
+++ b/quic/core/crypto/null_decrypter.h
@@ -8,11 +8,11 @@
#include <cstddef>
#include <cstdint>
+#include "absl/numeric/int128.h"
#include "absl/strings/string_view.h"
#include "quic/core/crypto/quic_decrypter.h"
#include "quic/core/quic_types.h"
#include "quic/platform/api/quic_export.h"
-#include "quic/platform/api/quic_uint128.h"
namespace quic {
@@ -53,9 +53,9 @@
QuicPacketCount GetIntegrityLimit() const override;
private:
- bool ReadHash(QuicDataReader* reader, QuicUint128* hash);
- QuicUint128 ComputeHash(absl::string_view data1,
- absl::string_view data2) const;
+ bool ReadHash(QuicDataReader* reader, absl::uint128* hash);
+ absl::uint128 ComputeHash(absl::string_view data1,
+ absl::string_view data2) const;
Perspective perspective_;
};
diff --git a/quic/core/crypto/null_encrypter.cc b/quic/core/crypto/null_encrypter.cc
index dd9cfd9..a385321 100644
--- a/quic/core/crypto/null_encrypter.cc
+++ b/quic/core/crypto/null_encrypter.cc
@@ -4,6 +4,7 @@
#include "quic/core/crypto/null_encrypter.h"
+#include "absl/numeric/int128.h"
#include "absl/strings/string_view.h"
#include "quic/core/quic_data_writer.h"
#include "quic/core/quic_utils.h"
@@ -41,7 +42,7 @@
if (max_output_length < len) {
return false;
}
- QuicUint128 hash;
+ absl::uint128 hash;
if (perspective_ == Perspective::IS_SERVER) {
hash =
QuicUtils::FNV1a_128_Hash_Three(associated_data, plaintext, "Server");
diff --git a/quic/core/frames/quic_frames_test.cc b/quic/core/frames/quic_frames_test.cc
index d5ca0a4..82070f0 100644
--- a/quic/core/frames/quic_frames_test.cc
+++ b/quic/core/frames/quic_frames_test.cc
@@ -2,6 +2,7 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
+#include "absl/numeric/int128.h"
#include "quic/core/frames/quic_ack_frame.h"
#include "quic/core/frames/quic_blocked_frame.h"
#include "quic/core/frames/quic_connection_close_frame.h"
@@ -116,7 +117,7 @@
new_connection_id_frame.connection_id = TestConnectionId(2);
new_connection_id_frame.sequence_number = 2u;
new_connection_id_frame.retire_prior_to = 1u;
- new_connection_id_frame.stateless_reset_token = MakeQuicUint128(0, 1);
+ new_connection_id_frame.stateless_reset_token = absl::MakeUint128(0, 1);
std::ostringstream stream;
stream << new_connection_id_frame;
EXPECT_EQ(
diff --git a/quic/core/frames/quic_new_connection_id_frame.cc b/quic/core/frames/quic_new_connection_id_frame.cc
index fa99dfe..3d8787e 100644
--- a/quic/core/frames/quic_new_connection_id_frame.cc
+++ b/quic/core/frames/quic_new_connection_id_frame.cc
@@ -10,7 +10,7 @@
QuicControlFrameId control_frame_id,
QuicConnectionId connection_id,
QuicConnectionIdSequenceNumber sequence_number,
- const QuicUint128 stateless_reset_token,
+ const absl::uint128 stateless_reset_token,
uint64_t retire_prior_to)
: control_frame_id(control_frame_id),
connection_id(connection_id),
diff --git a/quic/core/frames/quic_new_connection_id_frame.h b/quic/core/frames/quic_new_connection_id_frame.h
index 4cf0258..9cad262 100644
--- a/quic/core/frames/quic_new_connection_id_frame.h
+++ b/quic/core/frames/quic_new_connection_id_frame.h
@@ -7,11 +7,11 @@
#include <ostream>
+#include "absl/numeric/int128.h"
#include "quic/core/quic_connection_id.h"
#include "quic/core/quic_constants.h"
#include "quic/core/quic_error_codes.h"
#include "quic/core/quic_types.h"
-#include "quic/platform/api/quic_uint128.h"
namespace quic {
@@ -20,7 +20,7 @@
QuicNewConnectionIdFrame(QuicControlFrameId control_frame_id,
QuicConnectionId connection_id,
QuicConnectionIdSequenceNumber sequence_number,
- const QuicUint128 stateless_reset_token,
+ const absl::uint128 stateless_reset_token,
uint64_t retire_prior_to);
friend QUIC_EXPORT_PRIVATE std::ostream& operator<<(
@@ -32,7 +32,7 @@
QuicControlFrameId control_frame_id = kInvalidControlFrameId;
QuicConnectionId connection_id = EmptyQuicConnectionId();
QuicConnectionIdSequenceNumber sequence_number = 0;
- QuicUint128 stateless_reset_token;
+ absl::uint128 stateless_reset_token;
uint64_t retire_prior_to;
};
diff --git a/quic/core/frames/quic_retire_connection_id_frame.h b/quic/core/frames/quic_retire_connection_id_frame.h
index c6fc411..cbfc7af 100644
--- a/quic/core/frames/quic_retire_connection_id_frame.h
+++ b/quic/core/frames/quic_retire_connection_id_frame.h
@@ -7,10 +7,10 @@
#include <ostream>
+#include "absl/numeric/int128.h"
#include "quic/core/quic_constants.h"
#include "quic/core/quic_error_codes.h"
#include "quic/core/quic_types.h"
-#include "quic/platform/api/quic_uint128.h"
namespace quic {
diff --git a/quic/core/http/end_to_end_test.cc b/quic/core/http/end_to_end_test.cc
index 6a83d2e..308b4e2 100644
--- a/quic/core/http/end_to_end_test.cc
+++ b/quic/core/http/end_to_end_test.cc
@@ -11,6 +11,7 @@
#include <utility>
#include <vector>
+#include "absl/numeric/int128.h"
#include "absl/strings/str_cat.h"
#include "absl/strings/string_view.h"
#include "quic/core/crypto/null_encrypter.h"
@@ -3339,7 +3340,7 @@
QuicConfig* config = client_session->config();
ASSERT_TRUE(config);
EXPECT_TRUE(config->HasReceivedStatelessResetToken());
- QuicUint128 stateless_reset_token = config->ReceivedStatelessResetToken();
+ absl::uint128 stateless_reset_token = config->ReceivedStatelessResetToken();
// Send the public reset.
QuicConnection* client_connection = GetClientConnection();
@@ -3381,7 +3382,7 @@
QuicConfig* config = client_session->config();
ASSERT_TRUE(config);
EXPECT_TRUE(config->HasReceivedStatelessResetToken());
- QuicUint128 stateless_reset_token = config->ReceivedStatelessResetToken();
+ absl::uint128 stateless_reset_token = config->ReceivedStatelessResetToken();
// Send the public reset.
QuicConnection* client_connection = GetClientConnection();
ASSERT_TRUE(client_connection);
diff --git a/quic/core/quic_config.cc b/quic/core/quic_config.cc
index 379b5a1..1f81daa 100644
--- a/quic/core/quic_config.cc
+++ b/quic/core/quic_config.cc
@@ -11,6 +11,7 @@
#include <utility>
#include "absl/base/attributes.h"
+#include "absl/numeric/int128.h"
#include "absl/strings/string_view.h"
#include "quic/core/crypto/crypto_handshake_message.h"
#include "quic/core/crypto/crypto_protocol.h"
@@ -24,7 +25,6 @@
#include "quic/platform/api/quic_flags.h"
#include "quic/platform/api/quic_logging.h"
#include "quic/platform/api/quic_socket_address.h"
-#include "quic/platform/api/quic_uint128.h"
namespace quic {
@@ -235,13 +235,13 @@
return has_send_value_;
}
-QuicUint128 QuicFixedUint128::GetSendValue() const {
+absl::uint128 QuicFixedUint128::GetSendValue() const {
QUIC_BUG_IF(quic_bug_12743_4, !has_send_value_)
<< "No send value to get for tag:" << QuicTagToString(tag_);
return send_value_;
}
-void QuicFixedUint128::SetSendValue(QuicUint128 value) {
+void QuicFixedUint128::SetSendValue(absl::uint128 value) {
has_send_value_ = true;
send_value_ = value;
}
@@ -250,13 +250,13 @@
return has_receive_value_;
}
-QuicUint128 QuicFixedUint128::GetReceivedValue() const {
+absl::uint128 QuicFixedUint128::GetReceivedValue() const {
QUIC_BUG_IF(quic_bug_12743_5, !has_receive_value_)
<< "No receive value to get for tag:" << QuicTagToString(tag_);
return receive_value_;
}
-void QuicFixedUint128::SetReceivedValue(QuicUint128 value) {
+void QuicFixedUint128::SetReceivedValue(absl::uint128 value) {
has_receive_value_ = true;
receive_value_ = value;
}
@@ -887,7 +887,7 @@
void QuicConfig::SetIPv6AlternateServerAddressToSend(
const QuicSocketAddress& alternate_server_address_ipv6,
const QuicConnectionId& connection_id,
- QuicUint128 stateless_reset_token) {
+ absl::uint128 stateless_reset_token) {
if (!alternate_server_address_ipv6.host().IsIPv6()) {
QUIC_BUG(quic_bug_10575_10)
<< "Cannot use SetIPv6AlternateServerAddressToSend with "
@@ -922,7 +922,7 @@
void QuicConfig::SetIPv4AlternateServerAddressToSend(
const QuicSocketAddress& alternate_server_address_ipv4,
const QuicConnectionId& connection_id,
- QuicUint128 stateless_reset_token) {
+ absl::uint128 stateless_reset_token) {
if (!alternate_server_address_ipv4.host().IsIPv4()) {
QUIC_BUG(quic_bug_10575_12)
<< "Cannot use SetIPv4AlternateServerAddressToSend with "
@@ -949,7 +949,7 @@
preferred_address_connection_id_and_token_.has_value();
}
-const std::pair<QuicConnectionId, QuicUint128>&
+const std::pair<QuicConnectionId, absl::uint128>&
QuicConfig::ReceivedPreferredAddressConnectionIdAndToken() const {
QUICHE_DCHECK(HasReceivedPreferredAddressConnectionIdAndToken());
return *preferred_address_connection_id_and_token_;
@@ -1008,7 +1008,7 @@
}
void QuicConfig::SetStatelessResetTokenToSend(
- QuicUint128 stateless_reset_token) {
+ absl::uint128 stateless_reset_token) {
stateless_reset_token_.SetSendValue(stateless_reset_token);
}
@@ -1016,7 +1016,7 @@
return stateless_reset_token_.HasReceivedValue();
}
-QuicUint128 QuicConfig::ReceivedStatelessResetToken() const {
+absl::uint128 QuicConfig::ReceivedStatelessResetToken() const {
return stateless_reset_token_.GetReceivedValue();
}
@@ -1204,7 +1204,7 @@
max_idle_timeout_to_send_.ToMilliseconds());
if (stateless_reset_token_.HasSendValue()) {
- QuicUint128 stateless_reset_token = stateless_reset_token_.GetSendValue();
+ absl::uint128 stateless_reset_token = stateless_reset_token_.GetSendValue();
params->stateless_reset_token.assign(
reinterpret_cast<const char*>(&stateless_reset_token),
reinterpret_cast<const char*>(&stateless_reset_token) +
@@ -1319,7 +1319,7 @@
}
if (!is_resumption && !params.stateless_reset_token.empty()) {
- QuicUint128 stateless_reset_token;
+ absl::uint128 stateless_reset_token;
if (params.stateless_reset_token.size() != sizeof(stateless_reset_token)) {
QUIC_BUG(quic_bug_10575_16) << "Bad stateless reset token length "
<< params.stateless_reset_token.size();
@@ -1385,7 +1385,7 @@
if (!params.preferred_address->connection_id.IsEmpty()) {
preferred_address_connection_id_and_token_ = std::make_pair(
params.preferred_address->connection_id,
- *reinterpret_cast<const QuicUint128*>(
+ *reinterpret_cast<const absl::uint128*>(
¶ms.preferred_address->stateless_reset_token.front()));
}
}
diff --git a/quic/core/quic_config.h b/quic/core/quic_config.h
index d0fa2c7..e196fc5 100644
--- a/quic/core/quic_config.h
+++ b/quic/core/quic_config.h
@@ -9,13 +9,13 @@
#include <cstdint>
#include <string>
+#include "absl/numeric/int128.h"
#include "absl/types/optional.h"
#include "quic/core/crypto/transport_parameters.h"
#include "quic/core/quic_connection_id.h"
#include "quic/core/quic_packets.h"
#include "quic/core/quic_time.h"
#include "quic/platform/api/quic_export.h"
-#include "quic/platform/api/quic_uint128.h"
namespace quic {
@@ -142,15 +142,15 @@
bool HasSendValue() const;
- QuicUint128 GetSendValue() const;
+ absl::uint128 GetSendValue() const;
- void SetSendValue(QuicUint128 value);
+ void SetSendValue(absl::uint128 value);
bool HasReceivedValue() const;
- QuicUint128 GetReceivedValue() const;
+ absl::uint128 GetReceivedValue() const;
- void SetReceivedValue(QuicUint128 value);
+ void SetReceivedValue(absl::uint128 value);
// If has_send_value is true, serialises |tag_| and |send_value_| to |out|.
void ToHandshakeMessage(CryptoHandshakeMessage* out) const override;
@@ -163,8 +163,8 @@
private:
bool has_send_value_;
bool has_receive_value_;
- QuicUint128 send_value_;
- QuicUint128 receive_value_;
+ absl::uint128 send_value_;
+ absl::uint128 receive_value_;
};
// Stores tag from CHLO or SHLO messages that are not negotiated.
@@ -394,7 +394,7 @@
void SetIPv6AlternateServerAddressToSend(
const QuicSocketAddress& alternate_server_address_ipv6,
const QuicConnectionId& connection_id,
- QuicUint128 stateless_reset_token);
+ absl::uint128 stateless_reset_token);
bool HasReceivedIPv6AlternateServerAddress() const;
const QuicSocketAddress& ReceivedIPv6AlternateServerAddress() const;
@@ -404,13 +404,13 @@
void SetIPv4AlternateServerAddressToSend(
const QuicSocketAddress& alternate_server_address_ipv4,
const QuicConnectionId& connection_id,
- QuicUint128 stateless_reset_token);
+ absl::uint128 stateless_reset_token);
bool HasReceivedIPv4AlternateServerAddress() const;
const QuicSocketAddress& ReceivedIPv4AlternateServerAddress() const;
// Preferred Address Connection ID and Token.
bool HasReceivedPreferredAddressConnectionIdAndToken() const;
- const std::pair<QuicConnectionId, QuicUint128>&
+ const std::pair<QuicConnectionId, absl::uint128>&
ReceivedPreferredAddressConnectionIdAndToken() const;
// Original destination connection ID.
@@ -420,9 +420,9 @@
QuicConnectionId ReceivedOriginalConnectionId() const;
// Stateless reset token.
- void SetStatelessResetTokenToSend(QuicUint128 stateless_reset_token);
+ void SetStatelessResetTokenToSend(absl::uint128 stateless_reset_token);
bool HasReceivedStatelessResetToken() const;
- QuicUint128 ReceivedStatelessResetToken() const;
+ absl::uint128 ReceivedStatelessResetToken() const;
// Manage the IETF QUIC Max ACK Delay transport parameter.
// The sent value is the delay that this node uses
@@ -604,7 +604,7 @@
QuicFixedSocketAddress alternate_server_address_ipv4_;
// Connection Id data to send from the server or receive at the client as part
// of the preferred address transport parameter.
- absl::optional<std::pair<QuicConnectionId, QuicUint128>>
+ absl::optional<std::pair<QuicConnectionId, absl::uint128>>
preferred_address_connection_id_and_token_;
// Stateless reset token used in IETF public reset packet.
diff --git a/quic/core/quic_config_test.cc b/quic/core/quic_config_test.cc
index 2f37835..1253740 100644
--- a/quic/core/quic_config_test.cc
+++ b/quic/core/quic_config_test.cc
@@ -7,6 +7,7 @@
#include <memory>
#include <string>
+#include "absl/numeric/int128.h"
#include "quic/core/crypto/crypto_handshake_message.h"
#include "quic/core/crypto/crypto_protocol.h"
#include "quic/core/crypto/transport_parameters.h"
@@ -17,7 +18,6 @@
#include "quic/platform/api/quic_expect_bug.h"
#include "quic/platform/api/quic_flags.h"
#include "quic/platform/api/quic_test.h"
-#include "quic/platform/api/quic_uint128.h"
#include "quic/test_tools/quic_config_peer.h"
#include "quic/test_tools/quic_test_utils.h"
@@ -188,7 +188,7 @@
QuicIpAddress host;
host.FromString("127.0.3.1");
const QuicSocketAddress kTestServerAddress = QuicSocketAddress(host, 1234);
- const QuicUint128 kTestResetToken = MakeQuicUint128(0, 10111100001);
+ const absl::uint128 kTestResetToken = absl::MakeUint128(0, 10111100001);
const uint32_t kTestMaxAckDelayMs =
static_cast<uint32_t>(kDefaultDelayedAckTimeMs + 1);
QuicConfig server_config;
@@ -481,7 +481,7 @@
host.FromString("127.0.3.1");
QuicSocketAddress kTestServerAddress = QuicSocketAddress(host, 1234);
QuicConnectionId new_connection_id = TestConnectionId(5);
- QuicUint128 new_stateless_reset_token =
+ absl::uint128 new_stateless_reset_token =
QuicUtils::GenerateStatelessResetToken(new_connection_id);
config_.SetIPv4AlternateServerAddressToSend(
kTestServerAddress, new_connection_id, new_stateless_reset_token);
@@ -522,7 +522,7 @@
EXPECT_EQ(params.preferred_address->ipv4_socket_address, kTestServerAddress);
EXPECT_EQ(params.preferred_address->connection_id, new_connection_id);
- EXPECT_EQ(*reinterpret_cast<QuicUint128*>(
+ EXPECT_EQ(*reinterpret_cast<absl::uint128*>(
¶ms.preferred_address->stateless_reset_token.front()),
new_stateless_reset_token);
}
@@ -775,7 +775,7 @@
host.FromString("::ffff:192.0.2.128");
QuicSocketAddress kTestServerAddress = QuicSocketAddress(host, 1234);
QuicConnectionId new_connection_id = TestConnectionId(5);
- QuicUint128 new_stateless_reset_token =
+ absl::uint128 new_stateless_reset_token =
QuicUtils::GenerateStatelessResetToken(new_connection_id);
auto preferred_address =
std::make_unique<TransportParameters::PreferredAddress>();
@@ -795,7 +795,7 @@
EXPECT_TRUE(config_.HasReceivedIPv6AlternateServerAddress());
EXPECT_EQ(config_.ReceivedIPv6AlternateServerAddress(), kTestServerAddress);
EXPECT_TRUE(config_.HasReceivedPreferredAddressConnectionIdAndToken());
- const std::pair<QuicConnectionId, QuicUint128>&
+ const std::pair<QuicConnectionId, absl::uint128>&
preferred_address_connection_id_and_token =
config_.ReceivedPreferredAddressConnectionIdAndToken();
EXPECT_EQ(preferred_address_connection_id_and_token.first, new_connection_id);
diff --git a/quic/core/quic_connection.cc b/quic/core/quic_connection.cc
index 6a1780e..acab3f7 100644
--- a/quic/core/quic_connection.cc
+++ b/quic/core/quic_connection.cc
@@ -2194,7 +2194,7 @@
}
}
-bool QuicConnection::IsValidStatelessResetToken(QuicUint128 token) const {
+bool QuicConnection::IsValidStatelessResetToken(absl::uint128 token) const {
return stateless_reset_token_received_ &&
token == received_stateless_reset_token_;
}
diff --git a/quic/core/quic_connection.h b/quic/core/quic_connection.h
index 5febede..0eb67dc 100644
--- a/quic/core/quic_connection.h
+++ b/quic/core/quic_connection.h
@@ -24,6 +24,7 @@
#include <string>
#include <vector>
+#include "absl/numeric/int128.h"
#include "absl/strings/string_view.h"
#include "absl/types/optional.h"
#include "quic/core/crypto/quic_decrypter.h"
@@ -689,7 +690,7 @@
bool OnHandshakeDoneFrame(const QuicHandshakeDoneFrame& frame) override;
bool OnAckFrequencyFrame(const QuicAckFrequencyFrame& frame) override;
void OnPacketComplete() override;
- bool IsValidStatelessResetToken(QuicUint128 token) const override;
+ bool IsValidStatelessResetToken(absl::uint128 token) const override;
void OnAuthenticatedIetfStatelessResetPacket(
const QuicIetfStatelessResetPacket& packet) override;
void OnKeyUpdate(KeyUpdateReason reason) override;
@@ -2007,7 +2008,7 @@
bool stateless_reset_token_received_;
// Stores received stateless reset token from peer. Used to verify whether a
// packet is a stateless reset packet.
- QuicUint128 received_stateless_reset_token_;
+ absl::uint128 received_stateless_reset_token_;
// Id of latest sent control frame. 0 if no control frame has been sent.
QuicControlFrameId last_control_frame_id_;
diff --git a/quic/core/quic_connection_id.h b/quic/core/quic_connection_id.h
index 7712033..909d916 100644
--- a/quic/core/quic_connection_id.h
+++ b/quic/core/quic_connection_id.h
@@ -8,8 +8,8 @@
#include <string>
#include <vector>
+#include "absl/numeric/int128.h"
#include "quic/platform/api/quic_export.h"
-#include "quic/platform/api/quic_uint128.h"
namespace quic {
diff --git a/quic/core/quic_connection_id_manager.cc b/quic/core/quic_connection_id_manager.cc
index fee6b25..5bf647a 100644
--- a/quic/core/quic_connection_id_manager.cc
+++ b/quic/core/quic_connection_id_manager.cc
@@ -5,18 +5,18 @@
#include "quic/core/quic_connection_id_manager.h"
#include <cstdio>
+#include "absl/numeric/int128.h"
#include "quic/core/quic_clock.h"
#include "quic/core/quic_connection_id.h"
#include "quic/core/quic_error_codes.h"
#include "quic/core/quic_utils.h"
-#include "quic/platform/api/quic_uint128.h"
namespace quic {
QuicConnectionIdData::QuicConnectionIdData(
const QuicConnectionId& connection_id,
uint64_t sequence_number,
- QuicUint128 stateless_reset_token)
+ absl::uint128 stateless_reset_token)
: connection_id(connection_id),
sequence_number(sequence_number),
stateless_reset_token(stateless_reset_token) {}
@@ -73,7 +73,7 @@
QUICHE_DCHECK(!initial_peer_issued_connection_id.IsEmpty());
active_connection_id_data_.emplace_back(initial_peer_issued_connection_id,
/*sequence_number=*/0u,
- QuicUint128());
+ absl::uint128());
recent_new_connection_id_sequence_numbers_.Add(0u, 1u);
}
diff --git a/quic/core/quic_connection_id_manager.h b/quic/core/quic_connection_id_manager.h
index 0968277..91ff934 100644
--- a/quic/core/quic_connection_id_manager.h
+++ b/quic/core/quic_connection_id_manager.h
@@ -12,6 +12,8 @@
#include <cstddef>
#include <memory>
+
+#include "absl/numeric/int128.h"
#include "quic/core/frames/quic_new_connection_id_frame.h"
#include "quic/core/frames/quic_retire_connection_id_frame.h"
#include "quic/core/quic_alarm.h"
@@ -20,7 +22,6 @@
#include "quic/core/quic_connection_id.h"
#include "quic/core/quic_interval_set.h"
#include "quic/platform/api/quic_export.h"
-#include "quic/platform/api/quic_uint128.h"
namespace quic {
@@ -31,11 +32,11 @@
struct QUIC_EXPORT_PRIVATE QuicConnectionIdData {
QuicConnectionIdData(const QuicConnectionId& connection_id,
uint64_t sequence_number,
- QuicUint128 stateless_reset_token);
+ absl::uint128 stateless_reset_token);
QuicConnectionId connection_id;
uint64_t sequence_number;
- QuicUint128 stateless_reset_token;
+ absl::uint128 stateless_reset_token;
};
// Used by QuicSelfIssuedConnectionIdManager
diff --git a/quic/core/quic_connection_test.cc b/quic/core/quic_connection_test.cc
index cfac0be..187ef66 100644
--- a/quic/core/quic_connection_test.cc
+++ b/quic/core/quic_connection_test.cc
@@ -12,6 +12,7 @@
#include <utility>
#include "absl/base/macros.h"
+#include "absl/numeric/int128.h"
#include "absl/strings/str_cat.h"
#include "absl/strings/string_view.h"
#include "quic/core/congestion_control/loss_detection_interface.h"
@@ -6899,7 +6900,7 @@
if (!GetParam().version.HasIetfInvariantHeader()) {
return;
}
- const QuicUint128 kTestStatelessResetToken = 1010101;
+ const absl::uint128 kTestStatelessResetToken = 1010101;
QuicConfig config;
QuicConfigPeer::SetReceivedStatelessResetToken(&config,
kTestStatelessResetToken);
@@ -8611,8 +8612,8 @@
}
TEST_P(QuicConnectionTest, ValidStatelessResetToken) {
- const QuicUint128 kTestToken = 1010101;
- const QuicUint128 kWrongTestToken = 1010100;
+ const absl::uint128 kTestToken = 1010101;
+ const absl::uint128 kWrongTestToken = 1010100;
QuicConfig config;
// No token has been received.
EXPECT_FALSE(connection_.IsValidStatelessResetToken(kTestToken));
@@ -11845,7 +11846,7 @@
return;
}
PathProbeTestInit(Perspective::IS_CLIENT);
- const QuicUint128 kTestStatelessResetToken = 1010101;
+ const absl::uint128 kTestStatelessResetToken = 1010101;
QuicConfig config;
QuicConfigPeer::SetReceivedStatelessResetToken(&config,
kTestStatelessResetToken);
diff --git a/quic/core/quic_control_frame_manager.cc b/quic/core/quic_control_frame_manager.cc
index 1a95bdd..1a6d2aa 100644
--- a/quic/core/quic_control_frame_manager.cc
+++ b/quic/core/quic_control_frame_manager.cc
@@ -138,7 +138,7 @@
const QuicConnectionId& connection_id,
uint64_t sequence_number,
uint64_t retire_prior_to,
- QuicUint128 stateless_reset_token) {
+ absl::uint128 stateless_reset_token) {
QUIC_DVLOG(1) << "Writing NEW_CONNECTION_ID frame";
WriteOrBufferQuicFrame(QuicFrame(new QuicNewConnectionIdFrame(
++last_control_frame_id_, connection_id, sequence_number,
diff --git a/quic/core/quic_control_frame_manager.h b/quic/core/quic_control_frame_manager.h
index e4a5526..1406872 100644
--- a/quic/core/quic_control_frame_manager.h
+++ b/quic/core/quic_control_frame_manager.h
@@ -8,6 +8,7 @@
#include <cstdint>
#include <string>
+#include "absl/numeric/int128.h"
#include "quic/core/frames/quic_frame.h"
#include "quic/core/quic_circular_deque.h"
#include "quic/core/quic_connection_id.h"
@@ -95,7 +96,7 @@
void WriteOrBufferNewConnectionId(const QuicConnectionId& connection_id,
uint64_t sequence_number,
uint64_t retire_prior_to,
- QuicUint128 stateless_reset_token);
+ absl::uint128 stateless_reset_token);
// Tries to send a RETIRE_CONNNECTION_ID frame. The frame is buffered if it
// cannot be sent immediately.
diff --git a/quic/core/quic_control_frame_manager_test.cc b/quic/core/quic_control_frame_manager_test.cc
index 5aed6e0..d077410 100644
--- a/quic/core/quic_control_frame_manager_test.cc
+++ b/quic/core/quic_control_frame_manager_test.cc
@@ -6,6 +6,7 @@
#include <utility>
+#include "absl/numeric/int128.h"
#include "quic/core/crypto/null_encrypter.h"
#include "quic/core/frames/quic_ack_frequency_frame.h"
#include "quic/core/frames/quic_retire_connection_id_frame.h"
@@ -250,7 +251,7 @@
// Send NewConnectionIdFrame as frame 6.
manager_->WriteOrBufferNewConnectionId(
TestConnectionId(3), /*sequence_number=*/2, /*retire_prior_to=*/1,
- /*stateless_reset_token=*/MakeQuicUint128(1, 1));
+ /*stateless_reset_token=*/absl::MakeUint128(1, 1));
// Send RetireConnectionIdFrame as frame 7.
manager_->WriteOrBufferRetireConnectionId(/*sequence_number=*/0);
manager_->OnCanWrite();
diff --git a/quic/core/quic_framer.cc b/quic/core/quic_framer.cc
index 1200956..ebaa091 100644
--- a/quic/core/quic_framer.cc
+++ b/quic/core/quic_framer.cc
@@ -1300,14 +1300,14 @@
// static
size_t QuicFramer::GetMinStatelessResetPacketLength() {
// 5 bytes (40 bits) = 2 Fixed Bits (01) + 38 Unpredictable bits
- return 5 + sizeof(quic::QuicUint128);
+ return 5 + sizeof(absl::uint128);
}
// static
std::unique_ptr<QuicEncryptedPacket> QuicFramer::BuildIetfStatelessResetPacket(
QuicConnectionId /*connection_id*/,
size_t received_packet_length,
- QuicUint128 stateless_reset_token) {
+ absl::uint128 stateless_reset_token) {
QUIC_DVLOG(1) << "Building IETF stateless reset packet.";
if (GetQuicReloadableFlag(quic_fix_stateless_reset)) {
if (received_packet_length <= GetMinStatelessResetPacketLength()) {
@@ -1329,9 +1329,9 @@
// cryptographic use, and does not need a secure cryptographic pseudo-random
// number generator. It's therefore safe to use WriteInsecureRandomBytes.
if (!writer.WriteInsecureRandomBytes(QuicRandom::GetInstance(),
- len - sizeof(quic::QuicUint128))) {
+ len - sizeof(absl::uint128))) {
QUIC_BUG(362045737_2) << "Failed to append random bytes of length: "
- << len - sizeof(quic::QuicUint128);
+ << len - sizeof(absl::uint128);
return nullptr;
}
// Change first 2 fixed bits to 01.
diff --git a/quic/core/quic_framer.h b/quic/core/quic_framer.h
index 13f9ee5..5704cb5 100644
--- a/quic/core/quic_framer.h
+++ b/quic/core/quic_framer.h
@@ -10,6 +10,7 @@
#include <memory>
#include <string>
+#include "absl/numeric/int128.h"
#include "absl/strings/string_view.h"
#include "quic/core/crypto/quic_decrypter.h"
#include "quic/core/crypto/quic_encrypter.h"
@@ -225,7 +226,7 @@
virtual void OnPacketComplete() = 0;
// Called to check whether |token| is a valid stateless reset token.
- virtual bool IsValidStatelessResetToken(QuicUint128 token) const = 0;
+ virtual bool IsValidStatelessResetToken(absl::uint128 token) const = 0;
// Called when an IETF stateless reset packet has been parsed and validated
// with the stateless reset token.
@@ -477,7 +478,7 @@
static std::unique_ptr<QuicEncryptedPacket> BuildIetfStatelessResetPacket(
QuicConnectionId connection_id,
size_t received_packet_length,
- QuicUint128 stateless_reset_token);
+ absl::uint128 stateless_reset_token);
// Returns a new version negotiation packet.
static std::unique_ptr<QuicEncryptedPacket> BuildVersionNegotiationPacket(
diff --git a/quic/core/quic_framer_test.cc b/quic/core/quic_framer_test.cc
index 6e04f67..f64e7a5 100644
--- a/quic/core/quic_framer_test.cc
+++ b/quic/core/quic_framer_test.cc
@@ -47,7 +47,7 @@
const uint64_t kEpoch = UINT64_C(1) << 32;
const uint64_t kMask = kEpoch - 1;
-const QuicUint128 kTestStatelessResetToken = 1010101; // 0x0F69B5
+const absl::uint128 kTestStatelessResetToken = 1010101; // 0x0F69B5
// Use fields in which each byte is distinct to ensure that every byte is
// framed correctly. The values are otherwise arbitrary.
@@ -571,7 +571,7 @@
return true;
}
- bool IsValidStatelessResetToken(QuicUint128 token) const override {
+ bool IsValidStatelessResetToken(absl::uint128 token) const override {
EXPECT_EQ(0u, framer_->current_received_frame_type());
return token == kTestStatelessResetToken;
}
diff --git a/quic/core/quic_packet_number.h b/quic/core/quic_packet_number.h
index a1ea62f..affd714 100644
--- a/quic/core/quic_packet_number.h
+++ b/quic/core/quic_packet_number.h
@@ -11,7 +11,6 @@
#include "quic/platform/api/quic_export.h"
#include "quic/platform/api/quic_logging.h"
-#include "quic/platform/api/quic_uint128.h"
namespace quic {
diff --git a/quic/core/quic_packets.cc b/quic/core/quic_packets.cc
index 5f3e5a2..a7599cf 100644
--- a/quic/core/quic_packets.cc
+++ b/quic/core/quic_packets.cc
@@ -219,7 +219,7 @@
QuicIetfStatelessResetPacket::QuicIetfStatelessResetPacket(
const QuicPacketHeader& header,
- QuicUint128 token)
+ absl::uint128 token)
: header(header), stateless_reset_token(token) {}
QuicIetfStatelessResetPacket::QuicIetfStatelessResetPacket(
diff --git a/quic/core/quic_packets.h b/quic/core/quic_packets.h
index 4643ebc..338adae 100644
--- a/quic/core/quic_packets.h
+++ b/quic/core/quic_packets.h
@@ -14,6 +14,7 @@
#include <utility>
#include <vector>
+#include "absl/numeric/int128.h"
#include "absl/strings/string_view.h"
#include "quic/core/frames/quic_frame.h"
#include "quic/core/quic_ack_listener_interface.h"
@@ -25,7 +26,6 @@
#include "quic/core/quic_versions.h"
#include "quic/platform/api/quic_export.h"
#include "quic/platform/api/quic_socket_address.h"
-#include "quic/platform/api/quic_uint128.h"
namespace quic {
@@ -155,7 +155,7 @@
// Only valid if |has_possible_stateless_reset_token| is true.
// Stores last 16 bytes of a this packet, used to check whether this packet is
// a stateless reset packet on decryption failure.
- QuicUint128 possible_stateless_reset_token;
+ absl::uint128 possible_stateless_reset_token;
// Length of the retry token length variable length integer field,
// carried only by v99 IETF Initial packets.
QuicVariableLengthIntegerLength retry_token_length_length;
@@ -196,12 +196,12 @@
struct QUIC_EXPORT_PRIVATE QuicIetfStatelessResetPacket {
QuicIetfStatelessResetPacket();
QuicIetfStatelessResetPacket(const QuicPacketHeader& header,
- QuicUint128 token);
+ absl::uint128 token);
QuicIetfStatelessResetPacket(const QuicIetfStatelessResetPacket& other);
~QuicIetfStatelessResetPacket();
QuicPacketHeader header;
- QuicUint128 stateless_reset_token;
+ absl::uint128 stateless_reset_token;
};
class QUIC_EXPORT_PRIVATE QuicData {
diff --git a/quic/core/quic_session.cc b/quic/core/quic_session.cc
index 89f140b..55a9c19 100644
--- a/quic/core/quic_session.cc
+++ b/quic/core/quic_session.cc
@@ -2359,7 +2359,7 @@
writer);
}
-QuicUint128 QuicSession::GetStatelessResetToken() const {
+absl::uint128 QuicSession::GetStatelessResetToken() const {
return QuicUtils::GenerateStatelessResetToken(connection_->connection_id());
}
diff --git a/quic/core/quic_session.h b/quic/core/quic_session.h
index f225f26..bd65bf3 100644
--- a/quic/core/quic_session.h
+++ b/quic/core/quic_session.h
@@ -15,6 +15,7 @@
#include <vector>
#include "absl/container/flat_hash_map.h"
+#include "absl/numeric/int128.h"
#include "absl/strings/string_view.h"
#include "absl/types/optional.h"
#include "quic/core/frames/quic_ack_frequency_frame.h"
@@ -720,7 +721,7 @@
// Returns a stateless reset token which will be included in the public reset
// packet.
- virtual QuicUint128 GetStatelessResetToken() const;
+ virtual absl::uint128 GetStatelessResetToken() const;
QuicControlFrameManager& control_frame_manager() {
return control_frame_manager_;
diff --git a/quic/core/quic_time_wait_list_manager.cc b/quic/core/quic_time_wait_list_manager.cc
index 4f7b615..857b6c7 100644
--- a/quic/core/quic_time_wait_list_manager.cc
+++ b/quic/core/quic_time_wait_list_manager.cc
@@ -500,7 +500,7 @@
QuicTimeWaitListManager::ConnectionIdData::~ConnectionIdData() = default;
-QuicUint128 QuicTimeWaitListManager::GetStatelessResetToken(
+absl::uint128 QuicTimeWaitListManager::GetStatelessResetToken(
QuicConnectionId connection_id) const {
return QuicUtils::GenerateStatelessResetToken(connection_id);
}
diff --git a/quic/core/quic_time_wait_list_manager.h b/quic/core/quic_time_wait_list_manager.h
index aa5686d..5e097b5 100644
--- a/quic/core/quic_time_wait_list_manager.h
+++ b/quic/core/quic_time_wait_list_manager.h
@@ -12,6 +12,7 @@
#include <memory>
#include "absl/container/flat_hash_map.h"
+#include "absl/numeric/int128.h"
#include "quic/core/quic_blocked_writer_interface.h"
#include "quic/core/quic_connection_id.h"
#include "quic/core/quic_framer.h"
@@ -186,7 +187,7 @@
// Returns a stateless reset token which will be included in the public reset
// packet.
- virtual QuicUint128 GetStatelessResetToken(
+ virtual absl::uint128 GetStatelessResetToken(
QuicConnectionId connection_id) const;
// Internal structure to store pending termination packets.
diff --git a/quic/core/quic_time_wait_list_manager_test.cc b/quic/core/quic_time_wait_list_manager_test.cc
index 37c7f37..b423713 100644
--- a/quic/core/quic_time_wait_list_manager_test.cc
+++ b/quic/core/quic_time_wait_list_manager_test.cc
@@ -9,6 +9,7 @@
#include <ostream>
#include <utility>
+#include "absl/numeric/int128.h"
#include "quic/core/crypto/crypto_protocol.h"
#include "quic/core/crypto/null_encrypter.h"
#include "quic/core/crypto/quic_decrypter.h"
@@ -21,7 +22,6 @@
#include "quic/core/quic_utils.h"
#include "quic/platform/api/quic_flags.h"
#include "quic/platform/api/quic_test.h"
-#include "quic/platform/api/quic_uint128.h"
#include "quic/test_tools/mock_quic_session_visitor.h"
#include "quic/test_tools/quic_test_utils.h"
#include "quic/test_tools/quic_time_wait_list_manager_peer.h"
@@ -57,7 +57,7 @@
return public_reset_packet_;
}
- bool IsValidStatelessResetToken(QuicUint128 token) const override {
+ bool IsValidStatelessResetToken(absl::uint128 token) const override {
return token == QuicUtils::GenerateStatelessResetToken(connection_id_);
}
@@ -220,7 +220,7 @@
QuicIetfStatelessResetPacket stateless_reset =
visitor.stateless_reset_packet();
- QuicUint128 expected_stateless_reset_token =
+ absl::uint128 expected_stateless_reset_token =
QuicUtils::GenerateStatelessResetToken(expected_connection_id);
bool stateless_reset_is_valid =
diff --git a/quic/core/quic_utils.cc b/quic/core/quic_utils.cc
index 95c5b90..7e3652e 100644
--- a/quic/core/quic_utils.cc
+++ b/quic/core/quic_utils.cc
@@ -12,6 +12,7 @@
#include "absl/base/macros.h"
#include "absl/base/optimization.h"
+#include "absl/numeric/int128.h"
#include "absl/strings/string_view.h"
#include "quic/core/quic_connection_id.h"
#include "quic/core/quic_constants.h"
@@ -21,7 +22,6 @@
#include "quic/platform/api/quic_flag_utils.h"
#include "quic/platform/api/quic_flags.h"
#include "quic/platform/api/quic_prefetch.h"
-#include "quic/platform/api/quic_uint128.h"
#include "common/platform/api/quiche_logging.h"
#include "common/quiche_endian.h"
@@ -38,42 +38,43 @@
#endif
#ifdef QUIC_UTIL_HAS_UINT128
-QuicUint128 IncrementalHashFast(QuicUint128 uhash, absl::string_view data) {
+absl::uint128 IncrementalHashFast(absl::uint128 uhash, absl::string_view data) {
// This code ends up faster than the naive implementation for 2 reasons:
- // 1. QuicUint128 is sufficiently complicated that the compiler
+ // 1. absl::uint128 is sufficiently complicated that the compiler
// cannot transform the multiplication by kPrime into a shift-multiply-add;
// it has go through all of the instructions for a 128-bit multiply.
// 2. Because there are so fewer instructions (around 13), the hot loop fits
// nicely in the instruction queue of many Intel CPUs.
// kPrime = 309485009821345068724781371
- static const QuicUint128 kPrime =
- (static_cast<QuicUint128>(16777216) << 64) + 315;
- auto hi = QuicUint128High64(uhash);
- auto lo = QuicUint128Low64(uhash);
- QuicUint128 xhash = (static_cast<QuicUint128>(hi) << 64) + lo;
+ static const absl::uint128 kPrime =
+ (static_cast<absl::uint128>(16777216) << 64) + 315;
+ auto hi = absl::Uint128High64(uhash);
+ auto lo = absl::Uint128Low64(uhash);
+ absl::uint128 xhash = (static_cast<absl::uint128>(hi) << 64) + lo;
const uint8_t* octets = reinterpret_cast<const uint8_t*>(data.data());
for (size_t i = 0; i < data.length(); ++i) {
xhash = (xhash ^ static_cast<uint32_t>(octets[i])) * kPrime;
}
- return MakeQuicUint128(QuicUint128High64(xhash), QuicUint128Low64(xhash));
+ return absl::MakeUint128(absl::Uint128High64(xhash),
+ absl::Uint128Low64(xhash));
}
#endif
#ifndef QUIC_UTIL_HAS_UINT128
// Slow implementation of IncrementalHash. In practice, only used by Chromium.
-QuicUint128 IncrementalHashSlow(QuicUint128 hash, absl::string_view data) {
+absl::uint128 IncrementalHashSlow(absl::uint128 hash, absl::string_view data) {
// kPrime = 309485009821345068724781371
- static const QuicUint128 kPrime = MakeQuicUint128(16777216, 315);
+ static const absl::uint128 kPrime = absl::MakeUint128(16777216, 315);
const uint8_t* octets = reinterpret_cast<const uint8_t*>(data.data());
for (size_t i = 0; i < data.length(); ++i) {
- hash = hash ^ MakeQuicUint128(0, octets[i]);
+ hash = hash ^ absl::MakeUint128(0, octets[i]);
hash = hash * kPrime;
}
return hash;
}
#endif
-QuicUint128 IncrementalHash(QuicUint128 hash, absl::string_view data) {
+absl::uint128 IncrementalHash(absl::uint128 hash, absl::string_view data) {
#ifdef QUIC_UTIL_HAS_UINT128
return IncrementalHashFast(hash, data);
#else
@@ -101,27 +102,27 @@
}
// static
-QuicUint128 QuicUtils::FNV1a_128_Hash(absl::string_view data) {
+absl::uint128 QuicUtils::FNV1a_128_Hash(absl::string_view data) {
return FNV1a_128_Hash_Three(data, absl::string_view(), absl::string_view());
}
// static
-QuicUint128 QuicUtils::FNV1a_128_Hash_Two(absl::string_view data1,
- absl::string_view data2) {
+absl::uint128 QuicUtils::FNV1a_128_Hash_Two(absl::string_view data1,
+ absl::string_view data2) {
return FNV1a_128_Hash_Three(data1, data2, absl::string_view());
}
// static
-QuicUint128 QuicUtils::FNV1a_128_Hash_Three(absl::string_view data1,
- absl::string_view data2,
- absl::string_view data3) {
+absl::uint128 QuicUtils::FNV1a_128_Hash_Three(absl::string_view data1,
+ absl::string_view data2,
+ absl::string_view data3) {
// The two constants are defined as part of the hash algorithm.
// see http://www.isthe.com/chongo/tech/comp/fnv/
// kOffset = 144066263297769815596495629667062367629
- const QuicUint128 kOffset = MakeQuicUint128(UINT64_C(7809847782465536322),
- UINT64_C(7113472399480571277));
+ const absl::uint128 kOffset = absl::MakeUint128(
+ UINT64_C(7809847782465536322), UINT64_C(7113472399480571277));
- QuicUint128 hash = IncrementalHash(kOffset, data1);
+ absl::uint128 hash = IncrementalHash(kOffset, data1);
if (data2.empty()) {
return hash;
}
@@ -134,9 +135,9 @@
}
// static
-void QuicUtils::SerializeUint128Short(QuicUint128 v, uint8_t* out) {
- const uint64_t lo = QuicUint128Low64(v);
- const uint64_t hi = QuicUint128High64(v);
+void QuicUtils::SerializeUint128Short(absl::uint128 v, uint8_t* out) {
+ const uint64_t lo = absl::Uint128Low64(v);
+ const uint64_t hi = absl::Uint128High64(v);
// This assumes that the system is little-endian.
memcpy(out, &lo, sizeof(lo));
memcpy(out + sizeof(lo), &hi, sizeof(hi) / 2);
@@ -535,7 +536,7 @@
expected_connection_id_length);
}
char new_connection_id_data[255] = {};
- const QuicUint128 connection_id_hash128 = FNV1a_128_Hash(
+ const absl::uint128 connection_id_hash128 = FNV1a_128_Hash(
absl::string_view(connection_id.data(), connection_id.length()));
static_assert(sizeof(connection_id_hash64) + sizeof(connection_id_hash128) <=
sizeof(new_connection_id_data),
@@ -629,7 +630,7 @@
transport_version);
}
-QuicUint128 QuicUtils::GenerateStatelessResetToken(
+absl::uint128 QuicUtils::GenerateStatelessResetToken(
QuicConnectionId connection_id) {
return FNV1a_128_Hash(
absl::string_view(connection_id.data(), connection_id.length()));
diff --git a/quic/core/quic_utils.h b/quic/core/quic_utils.h
index 463b63f..abef12b 100644
--- a/quic/core/quic_utils.h
+++ b/quic/core/quic_utils.h
@@ -11,6 +11,7 @@
#include <string>
#include <type_traits>
+#include "absl/numeric/int128.h"
#include "absl/strings/string_view.h"
#include "quic/core/crypto/quic_random.h"
#include "quic/core/frames/quic_frame.h"
@@ -21,7 +22,6 @@
#include "quic/platform/api/quic_export.h"
#include "quic/platform/api/quic_iovec.h"
#include "quic/platform/api/quic_socket_address.h"
-#include "quic/platform/api/quic_uint128.h"
namespace quic {
@@ -35,22 +35,22 @@
// Returns the 128 bit FNV1a hash of the data. See
// http://www.isthe.com/chongo/tech/comp/fnv/index.html#FNV-param
- static QuicUint128 FNV1a_128_Hash(absl::string_view data);
+ static absl::uint128 FNV1a_128_Hash(absl::string_view data);
// Returns the 128 bit FNV1a hash of the two sequences of data. See
// http://www.isthe.com/chongo/tech/comp/fnv/index.html#FNV-param
- static QuicUint128 FNV1a_128_Hash_Two(absl::string_view data1,
- absl::string_view data2);
+ static absl::uint128 FNV1a_128_Hash_Two(absl::string_view data1,
+ absl::string_view data2);
// Returns the 128 bit FNV1a hash of the three sequences of data. See
// http://www.isthe.com/chongo/tech/comp/fnv/index.html#FNV-param
- static QuicUint128 FNV1a_128_Hash_Three(absl::string_view data1,
- absl::string_view data2,
- absl::string_view data3);
+ static absl::uint128 FNV1a_128_Hash_Three(absl::string_view data1,
+ absl::string_view data2,
+ absl::string_view data3);
// SerializeUint128 writes the first 96 bits of |v| in little-endian form
// to |out|.
- static void SerializeUint128Short(QuicUint128 v, uint8_t* out);
+ static void SerializeUint128Short(absl::uint128 v, uint8_t* out);
// Returns AddressChangeType as a string.
static std::string AddressChangeTypeToString(AddressChangeType type);
@@ -219,7 +219,7 @@
static QuicConnectionId CreateZeroConnectionId(QuicTransportVersion version);
// Generates a 128bit stateless reset token based on a connection ID.
- static QuicUint128 GenerateStatelessResetToken(
+ static absl::uint128 GenerateStatelessResetToken(
QuicConnectionId connection_id);
// Determines packet number space from |encryption_level|.
diff --git a/quic/core/quic_utils_test.cc b/quic/core/quic_utils_test.cc
index a5249d7..a178725 100644
--- a/quic/core/quic_utils_test.cc
+++ b/quic/core/quic_utils_test.cc
@@ -7,6 +7,7 @@
#include <string>
#include "absl/base/macros.h"
+#include "absl/numeric/int128.h"
#include "absl/strings/string_view.h"
#include "quic/core/crypto/crypto_protocol.h"
#include "quic/core/quic_connection_id.h"
@@ -79,17 +80,17 @@
QuicUtils::DetermineAddressChangeType(old_address, new_address));
}
-QuicUint128 IncrementalHashReference(const void* data, size_t len) {
+absl::uint128 IncrementalHashReference(const void* data, size_t len) {
// The two constants are defined as part of the hash algorithm.
// see http://www.isthe.com/chongo/tech/comp/fnv/
// hash = 144066263297769815596495629667062367629
- QuicUint128 hash = MakeQuicUint128(UINT64_C(7809847782465536322),
- UINT64_C(7113472399480571277));
+ absl::uint128 hash = absl::MakeUint128(UINT64_C(7809847782465536322),
+ UINT64_C(7113472399480571277));
// kPrime = 309485009821345068724781371
- const QuicUint128 kPrime = MakeQuicUint128(16777216, 315);
+ const absl::uint128 kPrime = absl::MakeUint128(16777216, 315);
const uint8_t* octets = reinterpret_cast<const uint8_t*>(data);
for (size_t i = 0; i < len; ++i) {
- hash = hash ^ MakeQuicUint128(0, octets[i]);
+ hash = hash ^ absl::MakeUint128(0, octets[i]);
hash = hash * kPrime;
}
return hash;
@@ -311,9 +312,11 @@
QuicConnectionId connection_id1a = test::TestConnectionId(1);
QuicConnectionId connection_id1b = test::TestConnectionId(1);
QuicConnectionId connection_id2 = test::TestConnectionId(2);
- QuicUint128 token1a = QuicUtils::GenerateStatelessResetToken(connection_id1a);
- QuicUint128 token1b = QuicUtils::GenerateStatelessResetToken(connection_id1b);
- QuicUint128 token2 = QuicUtils::GenerateStatelessResetToken(connection_id2);
+ absl::uint128 token1a =
+ QuicUtils::GenerateStatelessResetToken(connection_id1a);
+ absl::uint128 token1b =
+ QuicUtils::GenerateStatelessResetToken(connection_id1b);
+ absl::uint128 token2 = QuicUtils::GenerateStatelessResetToken(connection_id2);
EXPECT_EQ(token1a, token1b);
EXPECT_NE(token1a, token2);
}
diff --git a/quic/core/tls_chlo_extractor.h b/quic/core/tls_chlo_extractor.h
index f7392a5..8383af1 100644
--- a/quic/core/tls_chlo_extractor.h
+++ b/quic/core/tls_chlo_extractor.h
@@ -8,6 +8,7 @@
#include <memory>
#include <string>
#include <vector>
+#include "absl/numeric/int128.h"
#include "third_party/boringssl/src/include/openssl/ssl.h"
#include "quic/core/frames/quic_ack_frequency_frame.h"
#include "quic/core/quic_framer.h"
@@ -156,7 +157,7 @@
return true;
}
void OnPacketComplete() override {}
- bool IsValidStatelessResetToken(QuicUint128 /*token*/) const override {
+ bool IsValidStatelessResetToken(absl::uint128 /*token*/) const override {
return true;
}
void OnAuthenticatedIetfStatelessResetPacket(
