Move quic::QuicEndian to quiche::QuicheEndian This change will enable us to reuse the endian library in new third_party repos without introducing a dependency on //third_party/quic. gfe-relnote: Refactor of QUIC Endian library PiperOrigin-RevId: 281406510 Change-Id: If1b72425a799bad7469281f32a12d6630fe787c4
diff --git a/common/platform/api/quiche_endian.h b/common/platform/api/quiche_endian.h new file mode 100644 index 0000000..f8a9ee6 --- /dev/null +++ b/common/platform/api/quiche_endian.h
@@ -0,0 +1,55 @@ +// Copyright 2019 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_ENDIAN_H_ +#define QUICHE_COMMON_PLATFORM_API_QUICHE_ENDIAN_H_ + +#include "net/third_party/quiche/src/common/platform/api/quiche_export.h" +#include "net/quiche/common/platform/impl/quiche_endian_impl.h" + +namespace quiche { + +enum Endianness { + NETWORK_BYTE_ORDER, // big endian + HOST_BYTE_ORDER // little endian +}; + +// Provide utility functions that convert from/to network order (big endian) +// to/from host order (can be either little or big endian depending on the +// platform). +class QUICHE_EXPORT_PRIVATE QuicheEndian { + public: + // Convert |x| from host order (can be either little or big endian depending + // on the platform) to network order (big endian). + static uint16_t HostToNet16(uint16_t x) { + return QuicheEndianImpl::HostToNet16(x); + } + static uint32_t HostToNet32(uint32_t x) { + return QuicheEndianImpl::HostToNet32(x); + } + static uint64_t HostToNet64(uint64_t x) { + return QuicheEndianImpl::HostToNet64(x); + } + + // Convert |x| from network order (big endian) to host order (can be either + // little or big endian depending on the platform). + static uint16_t NetToHost16(uint16_t x) { + return QuicheEndianImpl::NetToHost16(x); + } + static uint32_t NetToHost32(uint32_t x) { + return QuicheEndianImpl::NetToHost32(x); + } + static uint64_t NetToHost64(uint64_t x) { + return QuicheEndianImpl::NetToHost64(x); + } + + // Returns true if current host order is little endian. + static bool HostIsLittleEndian() { + return QuicheEndianImpl::HostIsLittleEndian(); + } +}; + +} // namespace quiche + +#endif // QUICHE_COMMON_PLATFORM_API_QUICHE_ENDIAN_H_
diff --git a/common/platform/api/quiche_endian_test.cc b/common/platform/api/quiche_endian_test.cc new file mode 100644 index 0000000..98e16fe --- /dev/null +++ b/common/platform/api/quiche_endian_test.cc
@@ -0,0 +1,59 @@ +// Copyright 2017 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 "net/third_party/quiche/src/common/platform/api/quiche_endian.h" +#include "net/third_party/quiche/src/common/platform/api/quiche_test.h" + +namespace quiche { +namespace test { +namespace { + +const uint16_t k16BitTestData = 0xaabb; +const uint16_t k16BitSwappedTestData = 0xbbaa; +const uint32_t k32BitTestData = 0xaabbccdd; +const uint32_t k32BitSwappedTestData = 0xddccbbaa; +const uint64_t k64BitTestData = 0xaabbccdd44332211; +const uint64_t k64BitSwappedTestData = 0x11223344ddccbbaa; + +class QuicheEndianTest : public QuicheTest {}; + +TEST_F(QuicheEndianTest, HostToNet) { + if (quiche::QuicheEndian::HostIsLittleEndian()) { + EXPECT_EQ(k16BitSwappedTestData, + quiche::QuicheEndian::HostToNet16(k16BitTestData)); + EXPECT_EQ(k32BitSwappedTestData, + quiche::QuicheEndian::HostToNet32(k32BitTestData)); + EXPECT_EQ(k64BitSwappedTestData, + quiche::QuicheEndian::HostToNet64(k64BitTestData)); + } else { + EXPECT_EQ(k16BitTestData, + quiche::QuicheEndian::HostToNet16(k16BitTestData)); + EXPECT_EQ(k32BitTestData, + quiche::QuicheEndian::HostToNet32(k32BitTestData)); + EXPECT_EQ(k64BitTestData, + quiche::QuicheEndian::HostToNet64(k64BitTestData)); + } +} + +TEST_F(QuicheEndianTest, NetToHost) { + if (quiche::QuicheEndian::HostIsLittleEndian()) { + EXPECT_EQ(k16BitTestData, + quiche::QuicheEndian::NetToHost16(k16BitSwappedTestData)); + EXPECT_EQ(k32BitTestData, + quiche::QuicheEndian::NetToHost32(k32BitSwappedTestData)); + EXPECT_EQ(k64BitTestData, + quiche::QuicheEndian::NetToHost64(k64BitSwappedTestData)); + } else { + EXPECT_EQ(k16BitSwappedTestData, + quiche::QuicheEndian::NetToHost16(k16BitSwappedTestData)); + EXPECT_EQ(k32BitSwappedTestData, + quiche::QuicheEndian::NetToHost32(k32BitSwappedTestData)); + EXPECT_EQ(k64BitSwappedTestData, + quiche::QuicheEndian::NetToHost64(k64BitSwappedTestData)); + } +} + +} // namespace +} // namespace test +} // namespace quiche
diff --git a/common/platform/api/quiche_export.h b/common/platform/api/quiche_export.h new file mode 100644 index 0000000..22cc1f9 --- /dev/null +++ b/common/platform/api/quiche_export.h
@@ -0,0 +1,17 @@ +// Copyright 2019 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 THIRD_PARTY_QUICHE_PLATFORM_API_QUICHE_EXPORT_H_ +#define THIRD_PARTY_QUICHE_PLATFORM_API_QUICHE_EXPORT_H_ + +#include "net/quiche/common/platform/impl/quiche_export_impl.h" + +// quiche_export_impl.h defines the following macros: +// - QUICHE_EXPORT is not meant to be used. +// - QUICHE_EXPORT_PRIVATE is meant for QUICHE functionality that is built in +// Chromium as part of //net, and not fully contained in headers. +// - QUICHE_NO_EXPORT is meant for QUICHE functionality that is either fully +// defined in a header, or is built in Chromium as part of tests or tools. + +#endif // THIRD_PARTY_QUICHE_PLATFORM_API_QUICHE_EXPORT_H_
diff --git a/quic/core/crypto/chacha_base_decrypter.cc b/quic/core/crypto/chacha_base_decrypter.cc index eb1e95f..c67fd89 100644 --- a/quic/core/crypto/chacha_base_decrypter.cc +++ b/quic/core/crypto/chacha_base_decrypter.cc
@@ -10,6 +10,7 @@ #include "net/third_party/quiche/src/quic/core/quic_data_reader.h" #include "net/third_party/quiche/src/quic/platform/api/quic_arraysize.h" #include "net/third_party/quiche/src/quic/platform/api/quic_bug_tracker.h" +#include "net/third_party/quiche/src/common/platform/api/quiche_endian.h" namespace quic { @@ -30,7 +31,7 @@ } const uint8_t* nonce = reinterpret_cast<const uint8_t*>(sample.data()) + 4; uint32_t counter; - QuicDataReader(sample.data(), 4, Endianness::HOST_BYTE_ORDER) + QuicDataReader(sample.data(), 4, quiche::HOST_BYTE_ORDER) .ReadUInt32(&counter); const uint8_t zeroes[] = {0, 0, 0, 0, 0}; std::string out(QUIC_ARRAYSIZE(zeroes), 0);
diff --git a/quic/core/crypto/chacha_base_encrypter.cc b/quic/core/crypto/chacha_base_encrypter.cc index 04d902f..9c465a9 100644 --- a/quic/core/crypto/chacha_base_encrypter.cc +++ b/quic/core/crypto/chacha_base_encrypter.cc
@@ -8,6 +8,7 @@ #include "net/third_party/quiche/src/quic/core/quic_data_reader.h" #include "net/third_party/quiche/src/quic/platform/api/quic_arraysize.h" #include "net/third_party/quiche/src/quic/platform/api/quic_bug_tracker.h" +#include "net/third_party/quiche/src/common/platform/api/quiche_endian.h" namespace quic { @@ -27,7 +28,7 @@ } const uint8_t* nonce = reinterpret_cast<const uint8_t*>(sample.data()) + 4; uint32_t counter; - QuicDataReader(sample.data(), 4, Endianness::HOST_BYTE_ORDER) + QuicDataReader(sample.data(), 4, quiche::HOST_BYTE_ORDER) .ReadUInt32(&counter); const uint8_t zeroes[] = {0, 0, 0, 0, 0}; std::string out(QUIC_ARRAYSIZE(zeroes), 0);
diff --git a/quic/core/crypto/crypto_framer.cc b/quic/core/crypto/crypto_framer.cc index 6feaa8a..c3dd2aa 100644 --- a/quic/core/crypto/crypto_framer.cc +++ b/quic/core/crypto/crypto_framer.cc
@@ -15,6 +15,7 @@ #include "net/third_party/quiche/src/quic/platform/api/quic_logging.h" #include "net/third_party/quiche/src/quic/platform/api/quic_str_cat.h" #include "net/third_party/quiche/src/quic/platform/api/quic_string_piece.h" +#include "net/third_party/quiche/src/common/platform/api/quiche_endian.h" namespace quic { @@ -117,7 +118,8 @@ } void CryptoFramer::ForceHandshake() { - QuicDataReader reader(buffer_.data(), buffer_.length(), HOST_BYTE_ORDER); + QuicDataReader reader(buffer_.data(), buffer_.length(), + quiche::HOST_BYTE_ORDER); for (const std::pair<QuicTag, size_t>& item : tags_and_lengths_) { QuicStringPiece value; if (reader.BytesRemaining() < item.second) { @@ -156,7 +158,7 @@ } std::unique_ptr<char[]> buffer(new char[len]); - QuicDataWriter writer(len, buffer.get(), HOST_BYTE_ORDER); + QuicDataWriter writer(len, buffer.get(), quiche::HOST_BYTE_ORDER); if (!writer.WriteTag(message.tag())) { DCHECK(false) << "Failed to write message tag."; return nullptr; @@ -244,7 +246,8 @@ QuicErrorCode CryptoFramer::Process(QuicStringPiece input) { // Add this data to the buffer. buffer_.append(input.data(), input.length()); - QuicDataReader reader(buffer_.data(), buffer_.length(), HOST_BYTE_ORDER); + QuicDataReader reader(buffer_.data(), buffer_.length(), + quiche::HOST_BYTE_ORDER); switch (state_) { case STATE_READING_TAG:
diff --git a/quic/core/crypto/crypto_handshake_message.cc b/quic/core/crypto/crypto_handshake_message.cc index 762a279..56f0bd6 100644 --- a/quic/core/crypto/crypto_handshake_message.cc +++ b/quic/core/crypto/crypto_handshake_message.cc
@@ -12,10 +12,10 @@ #include "net/third_party/quiche/src/quic/core/crypto/crypto_utils.h" #include "net/third_party/quiche/src/quic/core/quic_socket_address_coder.h" #include "net/third_party/quiche/src/quic/core/quic_utils.h" -#include "net/third_party/quiche/src/quic/platform/api/quic_endian.h" #include "net/third_party/quiche/src/quic/platform/api/quic_map_util.h" #include "net/third_party/quiche/src/quic/platform/api/quic_str_cat.h" #include "net/third_party/quiche/src/quic/platform/api/quic_text_utils.h" +#include "net/third_party/quiche/src/common/platform/api/quiche_endian.h" namespace quic { @@ -73,14 +73,15 @@ QuicVersionLabelVector version_labels; for (ParsedQuicVersion version : versions) { version_labels.push_back( - QuicEndian::HostToNet32(CreateQuicVersionLabel(version))); + quiche::QuicheEndian::HostToNet32(CreateQuicVersionLabel(version))); } SetVector(tag, version_labels); } void CryptoHandshakeMessage::SetVersion(QuicTag tag, ParsedQuicVersion version) { - SetValue(tag, QuicEndian::HostToNet32(CreateQuicVersionLabel(version))); + SetValue(tag, + quiche::QuicheEndian::HostToNet32(CreateQuicVersionLabel(version))); } void CryptoHandshakeMessage::SetStringPiece(QuicTag tag, @@ -128,7 +129,7 @@ } for (size_t i = 0; i < out->size(); ++i) { - (*out)[i] = QuicEndian::HostToNet32((*out)[i]); + (*out)[i] = quiche::QuicheEndian::HostToNet32((*out)[i]); } return QUIC_NO_ERROR; @@ -142,7 +143,7 @@ return error; } - *out = QuicEndian::HostToNet32(*out); + *out = quiche::QuicheEndian::HostToNet32(*out); return QUIC_NO_ERROR; }
diff --git a/quic/core/crypto/crypto_handshake_message_test.cc b/quic/core/crypto/crypto_handshake_message_test.cc index f595581..b6dfdd4 100644 --- a/quic/core/crypto/crypto_handshake_message_test.cc +++ b/quic/core/crypto/crypto_handshake_message_test.cc
@@ -6,8 +6,8 @@ #include "net/third_party/quiche/src/quic/core/crypto/crypto_handshake.h" #include "net/third_party/quiche/src/quic/core/crypto/crypto_protocol.h" -#include "net/third_party/quiche/src/quic/platform/api/quic_endian.h" #include "net/third_party/quiche/src/quic/platform/api/quic_test.h" +#include "net/third_party/quiche/src/common/platform/api/quiche_endian.h" namespace quic { namespace test {
diff --git a/quic/core/crypto/crypto_server_test.cc b/quic/core/crypto/crypto_server_test.cc index 902d41e..2db49d2 100644 --- a/quic/core/crypto/crypto_server_test.cc +++ b/quic/core/crypto/crypto_server_test.cc
@@ -22,7 +22,6 @@ #include "net/third_party/quiche/src/quic/core/quic_socket_address_coder.h" #include "net/third_party/quiche/src/quic/core/quic_utils.h" #include "net/third_party/quiche/src/quic/platform/api/quic_arraysize.h" -#include "net/third_party/quiche/src/quic/platform/api/quic_endian.h" #include "net/third_party/quiche/src/quic/platform/api/quic_flags.h" #include "net/third_party/quiche/src/quic/platform/api/quic_string_piece.h" #include "net/third_party/quiche/src/quic/platform/api/quic_test.h" @@ -33,6 +32,7 @@ #include "net/third_party/quiche/src/quic/test_tools/mock_random.h" #include "net/third_party/quiche/src/quic/test_tools/quic_crypto_server_config_peer.h" #include "net/third_party/quiche/src/quic/test_tools/quic_test_utils.h" +#include "net/third_party/quiche/src/common/platform/api/quiche_endian.h" namespace quic { namespace test {
diff --git a/quic/core/crypto/crypto_utils.cc b/quic/core/crypto/crypto_utils.cc index 1c249b9..037990a 100644 --- a/quic/core/crypto/crypto_utils.cc +++ b/quic/core/crypto/crypto_utils.cc
@@ -30,6 +30,7 @@ #include "net/third_party/quiche/src/quic/platform/api/quic_bug_tracker.h" #include "net/third_party/quiche/src/quic/platform/api/quic_logging.h" #include "net/third_party/quiche/src/quic/platform/api/quic_str_cat.h" +#include "net/third_party/quiche/src/common/platform/api/quiche_endian.h" namespace quic { @@ -299,7 +300,7 @@ psk_premaster_secret = std::make_unique<char[]>(psk_premaster_secret_size); QuicDataWriter writer(psk_premaster_secret_size, psk_premaster_secret.get(), - HOST_BYTE_ORDER); + quiche::HOST_BYTE_ORDER); if (!writer.WriteStringPiece(label) || !writer.WriteUInt8(0) || !writer.WriteStringPiece(pre_shared_key) ||
diff --git a/quic/core/crypto/null_decrypter.cc b/quic/core/crypto/null_decrypter.cc index af0a886..51d8b11 100644 --- a/quic/core/crypto/null_decrypter.cc +++ b/quic/core/crypto/null_decrypter.cc
@@ -10,6 +10,7 @@ #include "net/third_party/quiche/src/quic/core/quic_utils.h" #include "net/third_party/quiche/src/quic/platform/api/quic_bug_tracker.h" #include "net/third_party/quiche/src/quic/platform/api/quic_uint128.h" +#include "net/third_party/quiche/src/common/platform/api/quiche_endian.h" namespace quic { @@ -50,7 +51,7 @@ size_t* output_length, size_t max_output_length) { QuicDataReader reader(ciphertext.data(), ciphertext.length(), - HOST_BYTE_ORDER); + quiche::HOST_BYTE_ORDER); QuicUint128 hash; if (!ReadHash(&reader, &hash)) {
diff --git a/quic/core/crypto/quic_crypto_client_config.cc b/quic/core/crypto/quic_crypto_client_config.cc index 6b00c4c..d674126 100644 --- a/quic/core/crypto/quic_crypto_client_config.cc +++ b/quic/core/crypto/quic_crypto_client_config.cc
@@ -28,7 +28,6 @@ #include "net/third_party/quiche/src/quic/platform/api/quic_arraysize.h" #include "net/third_party/quiche/src/quic/platform/api/quic_bug_tracker.h" #include "net/third_party/quiche/src/quic/platform/api/quic_client_stats.h" -#include "net/third_party/quiche/src/quic/platform/api/quic_endian.h" #include "net/third_party/quiche/src/quic/platform/api/quic_hostname_utils.h" #include "net/third_party/quiche/src/quic/platform/api/quic_logging.h" #include "net/third_party/quiche/src/quic/platform/api/quic_map_util.h"
diff --git a/quic/core/crypto/quic_crypto_client_config_test.cc b/quic/core/crypto/quic_crypto_client_config_test.cc index 7a34d21..8b5f116 100644 --- a/quic/core/crypto/quic_crypto_client_config_test.cc +++ b/quic/core/crypto/quic_crypto_client_config_test.cc
@@ -10,7 +10,6 @@ #include "net/third_party/quiche/src/quic/core/quic_server_id.h" #include "net/third_party/quiche/src/quic/core/quic_types.h" #include "net/third_party/quiche/src/quic/core/quic_utils.h" -#include "net/third_party/quiche/src/quic/platform/api/quic_endian.h" #include "net/third_party/quiche/src/quic/platform/api/quic_test.h" #include "net/third_party/quiche/src/quic/test_tools/crypto_test_utils.h" #include "net/third_party/quiche/src/quic/test_tools/mock_random.h"
diff --git a/quic/core/crypto/quic_crypto_server_config.cc b/quic/core/crypto/quic_crypto_server_config.cc index 68ee910..d568986 100644 --- a/quic/core/crypto/quic_crypto_server_config.cc +++ b/quic/core/crypto/quic_crypto_server_config.cc
@@ -38,7 +38,6 @@ #include "net/third_party/quiche/src/quic/platform/api/quic_bug_tracker.h" #include "net/third_party/quiche/src/quic/platform/api/quic_cert_utils.h" #include "net/third_party/quiche/src/quic/platform/api/quic_clock.h" -#include "net/third_party/quiche/src/quic/platform/api/quic_endian.h" #include "net/third_party/quiche/src/quic/platform/api/quic_fallthrough.h" #include "net/third_party/quiche/src/quic/platform/api/quic_flag_utils.h" #include "net/third_party/quiche/src/quic/platform/api/quic_flags.h"
diff --git a/quic/core/http/quic_headers_stream_test.cc b/quic/core/http/quic_headers_stream_test.cc index 973c60c..4cf11cc 100644 --- a/quic/core/http/quic_headers_stream_test.cc +++ b/quic/core/http/quic_headers_stream_test.cc
@@ -25,6 +25,7 @@ #include "net/third_party/quiche/src/quic/test_tools/quic_spdy_session_peer.h" #include "net/third_party/quiche/src/quic/test_tools/quic_stream_peer.h" #include "net/third_party/quiche/src/quic/test_tools/quic_test_utils.h" +#include "net/third_party/quiche/src/common/platform/api/quiche_endian.h" #include "net/third_party/quiche/src/spdy/core/http2_frame_decoder_adapter.h" #include "net/third_party/quiche/src/spdy/core/spdy_alt_svc_wire_format.h" #include "net/third_party/quiche/src/spdy/core/spdy_protocol.h" @@ -226,7 +227,7 @@ QuicConsumedData SaveIov(size_t write_length) { char* buf = new char[write_length]; - QuicDataWriter writer(write_length, buf, NETWORK_BYTE_ORDER); + QuicDataWriter writer(write_length, buf, quiche::NETWORK_BYTE_ORDER); headers_stream_->WriteStreamData(headers_stream_->stream_bytes_written(), write_length, &writer); saved_data_.append(buf, write_length);
diff --git a/quic/core/http/quic_spdy_session_test.cc b/quic/core/http/quic_spdy_session_test.cc index b22f00d..a8deb18 100644 --- a/quic/core/http/quic_spdy_session_test.cc +++ b/quic/core/http/quic_spdy_session_test.cc
@@ -40,6 +40,7 @@ #include "net/third_party/quiche/src/quic/test_tools/quic_stream_peer.h" #include "net/third_party/quiche/src/quic/test_tools/quic_stream_send_buffer_peer.h" #include "net/third_party/quiche/src/quic/test_tools/quic_test_utils.h" +#include "net/third_party/quiche/src/common/platform/api/quiche_endian.h" #include "net/third_party/quiche/src/spdy/core/spdy_framer.h" using spdy::kV3HighestPriority; @@ -1249,7 +1250,7 @@ config.ToHandshakeMessage(&crypto_message, transport_version()); crypto_stream->SendHandshakeMessage(crypto_message); char buf[1000]; - QuicDataWriter writer(1000, buf, NETWORK_BYTE_ORDER); + QuicDataWriter writer(1000, buf, quiche::NETWORK_BYTE_ORDER); crypto_stream->WriteStreamData(offset, crypto_message.size(), &writer); } EXPECT_TRUE(crypto_stream->flow_controller()->IsBlocked());
diff --git a/quic/core/quic_connection_id.cc b/quic/core/quic_connection_id.cc index c2a8754..49e90b6 100644 --- a/quic/core/quic_connection_id.cc +++ b/quic/core/quic_connection_id.cc
@@ -14,11 +14,11 @@ #include "net/third_party/quiche/src/quic/core/crypto/quic_random.h" #include "net/third_party/quiche/src/quic/core/quic_types.h" #include "net/third_party/quiche/src/quic/platform/api/quic_bug_tracker.h" -#include "net/third_party/quiche/src/quic/platform/api/quic_endian.h" #include "net/third_party/quiche/src/quic/platform/api/quic_flag_utils.h" #include "net/third_party/quiche/src/quic/platform/api/quic_flags.h" #include "net/third_party/quiche/src/quic/platform/api/quic_logging.h" #include "net/third_party/quiche/src/quic/platform/api/quic_text_utils.h" +#include "net/third_party/quiche/src/common/platform/api/quiche_endian.h" namespace quic {
diff --git a/quic/core/quic_data_reader.cc b/quic/core/quic_data_reader.cc index c9a76be..17fb6cd 100644 --- a/quic/core/quic_data_reader.cc +++ b/quic/core/quic_data_reader.cc
@@ -9,18 +9,19 @@ #include "net/third_party/quiche/src/quic/platform/api/quic_bug_tracker.h" #include "net/third_party/quiche/src/quic/platform/api/quic_flags.h" #include "net/third_party/quiche/src/quic/platform/api/quic_str_cat.h" +#include "net/third_party/quiche/src/common/platform/api/quiche_endian.h" namespace quic { QuicDataReader::QuicDataReader(QuicStringPiece data) - : QuicDataReader(data.data(), data.length(), NETWORK_BYTE_ORDER) {} + : QuicDataReader(data.data(), data.length(), quiche::NETWORK_BYTE_ORDER) {} QuicDataReader::QuicDataReader(const char* data, const size_t len) - : QuicDataReader(data, len, NETWORK_BYTE_ORDER) {} + : QuicDataReader(data, len, quiche::NETWORK_BYTE_ORDER) {} QuicDataReader::QuicDataReader(const char* data, const size_t len, - Endianness endianness) + quiche::Endianness endianness) : data_(data), len_(len), pos_(0), endianness_(endianness) {} bool QuicDataReader::ReadUInt8(uint8_t* result) { @@ -31,8 +32,8 @@ if (!ReadBytes(result, sizeof(*result))) { return false; } - if (endianness_ == NETWORK_BYTE_ORDER) { - *result = QuicEndian::NetToHost16(*result); + if (endianness_ == quiche::NETWORK_BYTE_ORDER) { + *result = quiche::QuicheEndian::NetToHost16(*result); } return true; } @@ -41,8 +42,8 @@ if (!ReadBytes(result, sizeof(*result))) { return false; } - if (endianness_ == NETWORK_BYTE_ORDER) { - *result = QuicEndian::NetToHost32(*result); + if (endianness_ == quiche::NETWORK_BYTE_ORDER) { + *result = quiche::QuicheEndian::NetToHost32(*result); } return true; } @@ -51,8 +52,8 @@ if (!ReadBytes(result, sizeof(*result))) { return false; } - if (endianness_ == NETWORK_BYTE_ORDER) { - *result = QuicEndian::NetToHost64(*result); + if (endianness_ == quiche::NETWORK_BYTE_ORDER) { + *result = quiche::QuicheEndian::NetToHost64(*result); } return true; } @@ -62,7 +63,7 @@ if (num_bytes > sizeof(*result)) { return false; } - if (endianness_ == HOST_BYTE_ORDER) { + if (endianness_ == quiche::HOST_BYTE_ORDER) { return ReadBytes(result, num_bytes); } @@ -70,7 +71,7 @@ num_bytes)) { return false; } - *result = QuicEndian::NetToHost64(*result); + *result = quiche::QuicheEndian::NetToHost64(*result); return true; } @@ -217,7 +218,7 @@ } QuicVariableLengthIntegerLength QuicDataReader::PeekVarInt62Length() { - DCHECK_EQ(endianness_, NETWORK_BYTE_ORDER); + DCHECK_EQ(endianness_, quiche::NETWORK_BYTE_ORDER); const unsigned char* next = reinterpret_cast<const unsigned char*>(data_ + pos_); if (BytesRemaining() == 0) { @@ -275,7 +276,7 @@ // Low-level optimization is useful here because this function will be // called frequently, leading to outsize benefits. bool QuicDataReader::ReadVarInt62(uint64_t* result) { - DCHECK_EQ(endianness_, NETWORK_BYTE_ORDER); + DCHECK_EQ(endianness_, quiche::NETWORK_BYTE_ORDER); size_t remaining = BytesRemaining(); const unsigned char* next =
diff --git a/quic/core/quic_data_reader.h b/quic/core/quic_data_reader.h index 74ed226..a8b6521 100644 --- a/quic/core/quic_data_reader.h +++ b/quic/core/quic_data_reader.h
@@ -9,9 +9,9 @@ #include <cstdint> #include "net/third_party/quiche/src/quic/core/quic_types.h" -#include "net/third_party/quiche/src/quic/platform/api/quic_endian.h" #include "net/third_party/quiche/src/quic/platform/api/quic_export.h" #include "net/third_party/quiche/src/quic/platform/api/quic_string_piece.h" +#include "net/third_party/quiche/src/common/platform/api/quiche_endian.h" namespace quic { @@ -39,7 +39,9 @@ QuicDataReader(const char* data, const size_t len); // Constructs a reader using the specified endianness. // Caller must provide an underlying buffer to work on. - QuicDataReader(const char* data, const size_t len, Endianness endianness); + QuicDataReader(const char* data, + const size_t len, + quiche::Endianness endianness); QuicDataReader(const QuicDataReader&) = delete; QuicDataReader& operator=(const QuicDataReader&) = delete; @@ -152,7 +154,9 @@ // DOES NOT forward the internal iterator. uint8_t PeekByte() const; - void set_endianness(Endianness endianness) { endianness_ = endianness; } + void set_endianness(quiche::Endianness endianness) { + endianness_ = endianness; + } // Read an IETF-encoded Variable Length Integer and place the result // in |*result|. @@ -190,7 +194,7 @@ size_t pos_; // The endianness to read integers and floating numbers. - Endianness endianness_; + quiche::Endianness endianness_; }; } // namespace quic
diff --git a/quic/core/quic_data_writer.cc b/quic/core/quic_data_writer.cc index e01eb6c..d2d7113 100644 --- a/quic/core/quic_data_writer.cc +++ b/quic/core/quic_data_writer.cc
@@ -12,13 +12,16 @@ #include "net/third_party/quiche/src/quic/platform/api/quic_bug_tracker.h" #include "net/third_party/quiche/src/quic/platform/api/quic_flags.h" #include "net/third_party/quiche/src/quic/platform/api/quic_str_cat.h" +#include "net/third_party/quiche/src/common/platform/api/quiche_endian.h" namespace quic { QuicDataWriter::QuicDataWriter(size_t size, char* buffer) - : QuicDataWriter(size, buffer, NETWORK_BYTE_ORDER) {} + : QuicDataWriter(size, buffer, quiche::NETWORK_BYTE_ORDER) {} -QuicDataWriter::QuicDataWriter(size_t size, char* buffer, Endianness endianness) +QuicDataWriter::QuicDataWriter(size_t size, + char* buffer, + quiche::Endianness endianness) : buffer_(buffer), capacity_(size), length_(0), endianness_(endianness) {} QuicDataWriter::~QuicDataWriter() {} @@ -32,22 +35,22 @@ } bool QuicDataWriter::WriteUInt16(uint16_t value) { - if (endianness_ == NETWORK_BYTE_ORDER) { - value = QuicEndian::HostToNet16(value); + if (endianness_ == quiche::NETWORK_BYTE_ORDER) { + value = quiche::QuicheEndian::HostToNet16(value); } return WriteBytes(&value, sizeof(value)); } bool QuicDataWriter::WriteUInt32(uint32_t value) { - if (endianness_ == NETWORK_BYTE_ORDER) { - value = QuicEndian::HostToNet32(value); + if (endianness_ == quiche::NETWORK_BYTE_ORDER) { + value = quiche::QuicheEndian::HostToNet32(value); } return WriteBytes(&value, sizeof(value)); } bool QuicDataWriter::WriteUInt64(uint64_t value) { - if (endianness_ == NETWORK_BYTE_ORDER) { - value = QuicEndian::HostToNet64(value); + if (endianness_ == quiche::NETWORK_BYTE_ORDER) { + value = quiche::QuicheEndian::HostToNet64(value); } return WriteBytes(&value, sizeof(value)); } @@ -56,11 +59,11 @@ if (num_bytes > sizeof(value)) { return false; } - if (endianness_ == HOST_BYTE_ORDER) { + if (endianness_ == quiche::HOST_BYTE_ORDER) { return WriteBytes(&value, num_bytes); } - value = QuicEndian::HostToNet64(value); + value = quiche::QuicheEndian::HostToNet64(value); return WriteBytes(reinterpret_cast<char*>(&value) + sizeof(value) - num_bytes, num_bytes); } @@ -101,8 +104,8 @@ result = static_cast<uint16_t>(value + (exponent << kUFloat16MantissaBits)); } - if (endianness_ == NETWORK_BYTE_ORDER) { - result = QuicEndian::HostToNet16(result); + if (endianness_ == quiche::NETWORK_BYTE_ORDER) { + result = quiche::QuicheEndian::HostToNet16(result); } return WriteBytes(&result, sizeof(result)); } @@ -227,7 +230,7 @@ // Low-level optimization is useful here because this function will be // called frequently, leading to outsize benefits. bool QuicDataWriter::WriteVarInt62(uint64_t value) { - DCHECK_EQ(endianness_, NETWORK_BYTE_ORDER); + DCHECK_EQ(endianness_, quiche::NETWORK_BYTE_ORDER); size_t remaining = capacity_ - length_; char* next = buffer_ + length_; @@ -298,7 +301,7 @@ bool QuicDataWriter::WriteVarInt62( uint64_t value, QuicVariableLengthIntegerLength write_length) { - DCHECK_EQ(endianness_, NETWORK_BYTE_ORDER); + DCHECK_EQ(endianness_, quiche::NETWORK_BYTE_ORDER); size_t remaining = capacity_ - length_; if (remaining < write_length) {
diff --git a/quic/core/quic_data_writer.h b/quic/core/quic_data_writer.h index c43d0ff..8f1b21d 100644 --- a/quic/core/quic_data_writer.h +++ b/quic/core/quic_data_writer.h
@@ -9,9 +9,9 @@ #include <cstdint> #include "net/third_party/quiche/src/quic/core/quic_types.h" -#include "net/third_party/quiche/src/quic/platform/api/quic_endian.h" #include "net/third_party/quiche/src/quic/platform/api/quic_export.h" #include "net/third_party/quiche/src/quic/platform/api/quic_string_piece.h" +#include "net/third_party/quiche/src/common/platform/api/quiche_endian.h" namespace quic { @@ -42,7 +42,7 @@ QuicDataWriter(size_t size, char* buffer); // Creates a QuicDataWriter where |buffer| is not owned // using the specified endianness. - QuicDataWriter(size_t size, char* buffer, Endianness endianness); + QuicDataWriter(size_t size, char* buffer, quiche::Endianness endianness); QuicDataWriter(const QuicDataWriter&) = delete; QuicDataWriter& operator=(const QuicDataWriter&) = delete; @@ -144,7 +144,7 @@ size_t length_; // Current length of the buffer. // The endianness to write integers and floating numbers. - Endianness endianness_; + quiche::Endianness endianness_; }; } // namespace quic
diff --git a/quic/core/quic_data_writer_test.cc b/quic/core/quic_data_writer_test.cc index 60abf96..104df8d 100644 --- a/quic/core/quic_data_writer_test.cc +++ b/quic/core/quic_data_writer_test.cc
@@ -15,6 +15,7 @@ #include "net/third_party/quiche/src/quic/platform/api/quic_flags.h" #include "net/third_party/quiche/src/quic/platform/api/quic_test.h" #include "net/third_party/quiche/src/quic/test_tools/quic_test_utils.h" +#include "net/third_party/quiche/src/common/platform/api/quiche_endian.h" namespace quic { namespace test { @@ -25,20 +26,22 @@ } struct TestParams { - explicit TestParams(Endianness endianness) : endianness(endianness) {} + explicit TestParams(quiche::Endianness endianness) : endianness(endianness) {} - Endianness endianness; + quiche::Endianness endianness; }; // Used by ::testing::PrintToStringParamName(). std::string PrintToString(const TestParams& p) { - return QuicStrCat((p.endianness == NETWORK_BYTE_ORDER ? "Network" : "Host"), - "ByteOrder"); + return QuicStrCat( + (p.endianness == quiche::NETWORK_BYTE_ORDER ? "Network" : "Host"), + "ByteOrder"); } std::vector<TestParams> GetTestParams() { std::vector<TestParams> params; - for (Endianness endianness : {NETWORK_BYTE_ORDER, HOST_BYTE_ORDER}) { + for (quiche::Endianness endianness : + {quiche::NETWORK_BYTE_ORDER, quiche::HOST_BYTE_ORDER}) { params.push_back(TestParams(endianness)); } return params; @@ -135,8 +138,8 @@ QuicDataWriter writer(2, buffer, GetParam().endianness); EXPECT_TRUE(writer.WriteUFloat16(test_cases[i].decoded)); uint16_t result = *reinterpret_cast<uint16_t*>(writer.data()); - if (GetParam().endianness == NETWORK_BYTE_ORDER) { - result = QuicEndian::HostToNet16(result); + if (GetParam().endianness == quiche::NETWORK_BYTE_ORDER) { + result = quiche::QuicheEndian::HostToNet16(result); } EXPECT_EQ(test_cases[i].encoded, result); } @@ -196,8 +199,8 @@ for (int i = 0; i < num_test_cases; ++i) { uint16_t encoded_ufloat = test_cases[i].encoded; - if (GetParam().endianness == NETWORK_BYTE_ORDER) { - encoded_ufloat = QuicEndian::HostToNet16(encoded_ufloat); + if (GetParam().endianness == quiche::NETWORK_BYTE_ORDER) { + encoded_ufloat = quiche::QuicheEndian::HostToNet16(encoded_ufloat); } QuicDataReader reader(reinterpret_cast<char*>(&encoded_ufloat), 2, GetParam().endianness); @@ -213,8 +216,8 @@ for (uint16_t i = 1; i < 0xFFFF; ++i) { // Read the two bytes. uint16_t read_number = i; - if (GetParam().endianness == NETWORK_BYTE_ORDER) { - read_number = QuicEndian::HostToNet16(read_number); + if (GetParam().endianness == quiche::NETWORK_BYTE_ORDER) { + read_number = quiche::QuicheEndian::HostToNet16(read_number); } QuicDataReader reader(reinterpret_cast<char*>(&read_number), 2, GetParam().endianness); @@ -243,10 +246,10 @@ uint16_t encoded1 = *reinterpret_cast<uint16_t*>(writer.data()); uint16_t encoded2 = *reinterpret_cast<uint16_t*>(writer.data() + 2); uint16_t encoded3 = *reinterpret_cast<uint16_t*>(writer.data() + 4); - if (GetParam().endianness == NETWORK_BYTE_ORDER) { - encoded1 = QuicEndian::NetToHost16(encoded1); - encoded2 = QuicEndian::NetToHost16(encoded2); - encoded3 = QuicEndian::NetToHost16(encoded3); + if (GetParam().endianness == quiche::NETWORK_BYTE_ORDER) { + encoded1 = quiche::QuicheEndian::NetToHost16(encoded1); + encoded2 = quiche::QuicheEndian::NetToHost16(encoded2); + encoded3 = quiche::QuicheEndian::NetToHost16(encoded3); } EXPECT_EQ(i - 1, encoded1); // Check roundtrip. @@ -384,8 +387,8 @@ writer.WriteUInt16(in_memory16); test::CompareCharArraysWithHexError( "uint16_t", buffer16, 2, - GetParam().endianness == NETWORK_BYTE_ORDER ? big_endian16 - : little_endian16, + GetParam().endianness == quiche::NETWORK_BYTE_ORDER ? big_endian16 + : little_endian16, 2); uint16_t read_number16; @@ -400,8 +403,8 @@ writer.WriteBytesToUInt64(2, in_memory16); test::CompareCharArraysWithHexError( "uint16_t", buffer16, 2, - GetParam().endianness == NETWORK_BYTE_ORDER ? big_endian16 - : little_endian16, + GetParam().endianness == quiche::NETWORK_BYTE_ORDER ? big_endian16 + : little_endian16, 2); uint64_t read_number16; @@ -420,8 +423,8 @@ writer.WriteBytesToUInt64(3, in_memory24); test::CompareCharArraysWithHexError( "uint24", buffer24, 3, - GetParam().endianness == NETWORK_BYTE_ORDER ? big_endian24 - : little_endian24, + GetParam().endianness == quiche::NETWORK_BYTE_ORDER ? big_endian24 + : little_endian24, 3); uint64_t read_number24; @@ -440,8 +443,8 @@ writer.WriteUInt32(in_memory32); test::CompareCharArraysWithHexError( "uint32_t", buffer32, 4, - GetParam().endianness == NETWORK_BYTE_ORDER ? big_endian32 - : little_endian32, + GetParam().endianness == quiche::NETWORK_BYTE_ORDER ? big_endian32 + : little_endian32, 4); uint32_t read_number32; @@ -456,8 +459,8 @@ writer.WriteBytesToUInt64(4, in_memory32); test::CompareCharArraysWithHexError( "uint32_t", buffer32, 4, - GetParam().endianness == NETWORK_BYTE_ORDER ? big_endian32 - : little_endian32, + GetParam().endianness == quiche::NETWORK_BYTE_ORDER ? big_endian32 + : little_endian32, 4); uint64_t read_number32; @@ -476,8 +479,8 @@ writer.WriteBytesToUInt64(5, in_memory40); test::CompareCharArraysWithHexError( "uint40", buffer40, 5, - GetParam().endianness == NETWORK_BYTE_ORDER ? big_endian40 - : little_endian40, + GetParam().endianness == quiche::NETWORK_BYTE_ORDER ? big_endian40 + : little_endian40, 5); uint64_t read_number40; @@ -495,8 +498,8 @@ writer.WriteBytesToUInt64(6, in_memory48); test::CompareCharArraysWithHexError( "uint48", buffer48, 6, - GetParam().endianness == NETWORK_BYTE_ORDER ? big_endian48 - : little_endian48, + GetParam().endianness == quiche::NETWORK_BYTE_ORDER ? big_endian48 + : little_endian48, 6); uint64_t read_number48; @@ -514,8 +517,8 @@ writer.WriteBytesToUInt64(7, in_memory56); test::CompareCharArraysWithHexError( "uint56", buffer56, 7, - GetParam().endianness == NETWORK_BYTE_ORDER ? big_endian56 - : little_endian56, + GetParam().endianness == quiche::NETWORK_BYTE_ORDER ? big_endian56 + : little_endian56, 7); uint64_t read_number56; @@ -535,8 +538,9 @@ writer.WriteBytesToUInt64(8, in_memory64); test::CompareCharArraysWithHexError( "uint64_t", buffer64, 8, - GetParam().endianness == NETWORK_BYTE_ORDER ? AsChars(big_endian64) - : AsChars(little_endian64), + GetParam().endianness == quiche::NETWORK_BYTE_ORDER + ? AsChars(big_endian64) + : AsChars(little_endian64), 8); uint64_t read_number64; @@ -548,8 +552,9 @@ writer2.WriteUInt64(in_memory64); test::CompareCharArraysWithHexError( "uint64_t", buffer64, 8, - GetParam().endianness == NETWORK_BYTE_ORDER ? AsChars(big_endian64) - : AsChars(little_endian64), + GetParam().endianness == quiche::NETWORK_BYTE_ORDER + ? AsChars(big_endian64) + : AsChars(little_endian64), 8); read_number64 = 0u; QuicDataReader reader2(buffer64, 8, GetParam().endianness); @@ -674,7 +679,8 @@ // make a writer. Note that for IETF encoding // we do not care about endianness... It's always big-endian, // but the c'tor expects to be told what endianness is in force... - QuicDataWriter writer(size_of_buffer, buffer, Endianness::NETWORK_BYTE_ORDER); + QuicDataWriter writer(size_of_buffer, buffer, + quiche::Endianness::NETWORK_BYTE_ORDER); // Try to write the value. if (writer.WriteVarInt62(value_in) != true) { @@ -699,7 +705,7 @@ // set up a reader, just the length we've used, no more, no less. QuicDataReader reader(buffer, expected_length, - Endianness::NETWORK_BYTE_ORDER); + quiche::Endianness::NETWORK_BYTE_ORDER); uint64_t value_out; if (reader.ReadVarInt62(&value_out) == false) { @@ -721,7 +727,7 @@ // are always encoded big endian... memset(buffer, 0, sizeof(buffer)); QuicDataWriter writer(sizeof(buffer), static_cast<char*>(buffer), - Endianness::NETWORK_BYTE_ORDER); + quiche::Endianness::NETWORK_BYTE_ORDER); EXPECT_TRUE(writer.WriteVarInt62(UINT64_C(0x3142f3e4d5c6b7a8))); EXPECT_EQ(static_cast<unsigned char>(*(writer.data() + 0)), (0x31 + 0xc0)); // 0xc0 for encoding @@ -743,7 +749,7 @@ // are always encoded big endian... memset(buffer, 0, sizeof(buffer)); QuicDataWriter writer(sizeof(buffer), static_cast<char*>(buffer), - Endianness::NETWORK_BYTE_ORDER); + quiche::Endianness::NETWORK_BYTE_ORDER); EXPECT_TRUE(writer.WriteVarInt62(0x3243f4e5)); EXPECT_EQ(static_cast<unsigned char>(*(writer.data() + 0)), (0x32 + 0x80)); // 0x80 for encoding @@ -761,7 +767,7 @@ // are always encoded big endian... memset(buffer, 0, sizeof(buffer)); QuicDataWriter writer(sizeof(buffer), static_cast<char*>(buffer), - Endianness::NETWORK_BYTE_ORDER); + quiche::Endianness::NETWORK_BYTE_ORDER); EXPECT_TRUE(writer.WriteVarInt62(0x3647)); EXPECT_EQ(static_cast<unsigned char>(*(writer.data() + 0)), (0x36 + 0x40)); // 0x40 for encoding @@ -777,7 +783,7 @@ // is correct. Bytes are always encoded big endian... memset(buffer, 0, sizeof(buffer)); QuicDataWriter writer(sizeof(buffer), static_cast<char*>(buffer), - Endianness::NETWORK_BYTE_ORDER); + quiche::Endianness::NETWORK_BYTE_ORDER); EXPECT_TRUE(writer.WriteVarInt62(0x3f)); EXPECT_EQ(static_cast<unsigned char>(*(writer.data() + 0)), 0x3f); } @@ -883,7 +889,7 @@ char buffer[8 * kMultiVarCount]; memset(buffer, 0, sizeof(buffer)); QuicDataWriter writer(sizeof(buffer), static_cast<char*>(buffer), - Endianness::NETWORK_BYTE_ORDER); + quiche::Endianness::NETWORK_BYTE_ORDER); // Put N values into the buffer. Adding i to the value ensures that // each value is different so we can detect if we overwrite values, // or read the same value over and over. @@ -897,7 +903,8 @@ // Now we should be able to read out the N values that were // successfully encoded. - QuicDataReader reader(buffer, sizeof(buffer), Endianness::NETWORK_BYTE_ORDER); + QuicDataReader reader(buffer, sizeof(buffer), + quiche::Endianness::NETWORK_BYTE_ORDER); for (int i = 0; i < kMultiVarCount; i++) { EXPECT_TRUE(reader.ReadVarInt62(&test_val)); EXPECT_EQ(test_val, (UINT64_C(0x3142f3e4d5c6b7a8) + i)); @@ -912,7 +919,7 @@ char buffer[4 * kMultiVarCount]; memset(buffer, 0, sizeof(buffer)); QuicDataWriter writer(sizeof(buffer), static_cast<char*>(buffer), - Endianness::NETWORK_BYTE_ORDER); + quiche::Endianness::NETWORK_BYTE_ORDER); // Put N values into the buffer. Adding i to the value ensures that // each value is different so we can detect if we overwrite values, // or read the same value over and over. @@ -926,7 +933,8 @@ // Now we should be able to read out the N values that were // successfully encoded. - QuicDataReader reader(buffer, sizeof(buffer), Endianness::NETWORK_BYTE_ORDER); + QuicDataReader reader(buffer, sizeof(buffer), + quiche::Endianness::NETWORK_BYTE_ORDER); for (int i = 0; i < kMultiVarCount; i++) { EXPECT_TRUE(reader.ReadVarInt62(&test_val)); EXPECT_EQ(test_val, (UINT64_C(0x3142f3e4) + i)); @@ -941,7 +949,7 @@ char buffer[2 * kMultiVarCount]; memset(buffer, 0, sizeof(buffer)); QuicDataWriter writer(sizeof(buffer), static_cast<char*>(buffer), - Endianness::NETWORK_BYTE_ORDER); + quiche::Endianness::NETWORK_BYTE_ORDER); // Put N values into the buffer. Adding i to the value ensures that // each value is different so we can detect if we overwrite values, // or read the same value over and over. @@ -955,7 +963,8 @@ // Now we should be able to read out the N values that were // successfully encoded. - QuicDataReader reader(buffer, sizeof(buffer), Endianness::NETWORK_BYTE_ORDER); + QuicDataReader reader(buffer, sizeof(buffer), + quiche::Endianness::NETWORK_BYTE_ORDER); for (int i = 0; i < kMultiVarCount; i++) { EXPECT_TRUE(reader.ReadVarInt62(&test_val)); EXPECT_EQ(test_val, (UINT64_C(0x3142) + i)); @@ -970,7 +979,7 @@ char buffer[1 * kMultiVarCount]; memset(buffer, 0, sizeof(buffer)); QuicDataWriter writer(sizeof(buffer), static_cast<char*>(buffer), - Endianness::NETWORK_BYTE_ORDER); + quiche::Endianness::NETWORK_BYTE_ORDER); // Put N values into the buffer. Adding i to the value ensures that // each value is different so we can detect if we overwrite values, // or read the same value over and over. &0xf ensures we do not @@ -985,7 +994,8 @@ // Now we should be able to read out the N values that were // successfully encoded. - QuicDataReader reader(buffer, sizeof(buffer), Endianness::NETWORK_BYTE_ORDER); + QuicDataReader reader(buffer, sizeof(buffer), + quiche::Endianness::NETWORK_BYTE_ORDER); for (int i = 0; i < kMultiVarCount; i++) { EXPECT_TRUE(reader.ReadVarInt62(&test_val)); EXPECT_EQ(test_val, (UINT64_C(0x30) + (i & 0xf))); @@ -999,7 +1009,7 @@ char buffer[90]; memset(buffer, 0, sizeof(buffer)); QuicDataWriter writer(sizeof(buffer), static_cast<char*>(buffer), - Endianness::NETWORK_BYTE_ORDER); + quiche::Endianness::NETWORK_BYTE_ORDER); writer.WriteVarInt62(1, VARIABLE_LENGTH_INTEGER_LENGTH_1); writer.WriteVarInt62(1, VARIABLE_LENGTH_INTEGER_LENGTH_2); @@ -1027,7 +1037,8 @@ writer.WriteVarInt62(1073741824, VARIABLE_LENGTH_INTEGER_LENGTH_8); - QuicDataReader reader(buffer, sizeof(buffer), Endianness::NETWORK_BYTE_ORDER); + QuicDataReader reader(buffer, sizeof(buffer), + quiche::Endianness::NETWORK_BYTE_ORDER); uint64_t test_val = 0; for (int i = 0; i < 4; ++i) { @@ -1071,10 +1082,11 @@ // Encode the given Stream ID. QuicDataWriter writer(sizeof(buffer), static_cast<char*>(buffer), - Endianness::NETWORK_BYTE_ORDER); + quiche::Endianness::NETWORK_BYTE_ORDER); EXPECT_TRUE(writer.WriteVarInt62(value_in)); - QuicDataReader reader(buffer, sizeof(buffer), Endianness::NETWORK_BYTE_ORDER); + QuicDataReader reader(buffer, sizeof(buffer), + quiche::Endianness::NETWORK_BYTE_ORDER); QuicStreamId received_stream_id; bool read_result = reader.ReadVarIntU32(&received_stream_id); EXPECT_EQ(expected_decode_result, read_result); @@ -1124,28 +1136,28 @@ TEST_P(QuicDataWriterTest, PeekVarInt62Length) { // In range [0, 63], variable length should be 1 byte. char buffer[20]; - QuicDataWriter writer(20, buffer, NETWORK_BYTE_ORDER); + QuicDataWriter writer(20, buffer, quiche::NETWORK_BYTE_ORDER); EXPECT_TRUE(writer.WriteVarInt62(50)); - QuicDataReader reader(buffer, 20, NETWORK_BYTE_ORDER); + QuicDataReader reader(buffer, 20, quiche::NETWORK_BYTE_ORDER); EXPECT_EQ(1, reader.PeekVarInt62Length()); // In range (63-16383], variable length should be 2 byte2. char buffer2[20]; - QuicDataWriter writer2(20, buffer2, NETWORK_BYTE_ORDER); + QuicDataWriter writer2(20, buffer2, quiche::NETWORK_BYTE_ORDER); EXPECT_TRUE(writer2.WriteVarInt62(100)); - QuicDataReader reader2(buffer2, 20, NETWORK_BYTE_ORDER); + QuicDataReader reader2(buffer2, 20, quiche::NETWORK_BYTE_ORDER); EXPECT_EQ(2, reader2.PeekVarInt62Length()); // In range (16383, 1073741823], variable length should be 4 bytes. char buffer3[20]; - QuicDataWriter writer3(20, buffer3, NETWORK_BYTE_ORDER); + QuicDataWriter writer3(20, buffer3, quiche::NETWORK_BYTE_ORDER); EXPECT_TRUE(writer3.WriteVarInt62(20000)); - QuicDataReader reader3(buffer3, 20, NETWORK_BYTE_ORDER); + QuicDataReader reader3(buffer3, 20, quiche::NETWORK_BYTE_ORDER); EXPECT_EQ(4, reader3.PeekVarInt62Length()); // In range (1073741823, 4611686018427387903], variable length should be 8 // bytes. char buffer4[20]; - QuicDataWriter writer4(20, buffer4, NETWORK_BYTE_ORDER); + QuicDataWriter writer4(20, buffer4, quiche::NETWORK_BYTE_ORDER); EXPECT_TRUE(writer4.WriteVarInt62(2000000000)); - QuicDataReader reader4(buffer4, 20, NETWORK_BYTE_ORDER); + QuicDataReader reader4(buffer4, 20, quiche::NETWORK_BYTE_ORDER); EXPECT_EQ(8, reader4.PeekVarInt62Length()); } @@ -1171,7 +1183,7 @@ char buffer[1024]; memset(buffer, 0, sizeof(buffer)); QuicDataWriter writer(sizeof(buffer), static_cast<char*>(buffer), - Endianness::NETWORK_BYTE_ORDER); + quiche::Endianness::NETWORK_BYTE_ORDER); QuicDataReader reader(buffer, sizeof(buffer)); const QuicStreamCount write_stream_count = 0xffeeddcc; EXPECT_TRUE(writer.WriteVarInt62(write_stream_count)); @@ -1184,7 +1196,7 @@ char buffer[1024]; memset(buffer, 0, sizeof(buffer)); QuicDataWriter writer(sizeof(buffer), static_cast<char*>(buffer), - Endianness::NETWORK_BYTE_ORDER); + quiche::Endianness::NETWORK_BYTE_ORDER); QuicDataReader reader(buffer, sizeof(buffer)); EXPECT_TRUE(writer.WriteVarInt62(UINT64_C(0x1ffeeddcc))); QuicStreamCount read_stream_count = 123456;
diff --git a/quic/core/quic_ietf_framer_test.cc b/quic/core/quic_ietf_framer_test.cc index 90ae8b9..8557a35 100644 --- a/quic/core/quic_ietf_framer_test.cc +++ b/quic/core/quic_ietf_framer_test.cc
@@ -247,8 +247,8 @@ // initialize a writer so that the serialized packet is placed in // packet_buffer. QuicDataWriter writer(packet_buffer_size, packet_buffer, - NETWORK_BYTE_ORDER); // do not really care - // about endianness. + quiche::NETWORK_BYTE_ORDER); // do not really care + // about endianness. // set up to define the source frame we wish to send. QuicStreamFrame source_stream_frame( stream_id, fin_bit, offset, xmit_packet_data, xmit_packet_data_size); @@ -259,7 +259,8 @@ // Better have something in the packet buffer. EXPECT_NE(0u, writer.length()); // Now set up a reader to read in the frame. - QuicDataReader reader(packet_buffer, writer.length(), NETWORK_BYTE_ORDER); + QuicDataReader reader(packet_buffer, writer.length(), + quiche::NETWORK_BYTE_ORDER); // A StreamFrame to hold the results... we know the frame type, // put it into the QuicIetfStreamFrame @@ -323,7 +324,8 @@ // Make a writer so that the serialized packet is placed in // packet_buffer. - QuicDataWriter writer(expected_size, packet_buffer, NETWORK_BYTE_ORDER); + QuicDataWriter writer(expected_size, packet_buffer, + quiche::NETWORK_BYTE_ORDER); // Write the frame to the packet buffer. EXPECT_TRUE(QuicFramerPeer::AppendIetfAckFrameAndTypeByte( @@ -338,7 +340,8 @@ // and what is in the buffer should be the expected size. EXPECT_EQ(expected_size, writer.length()) << "Frame is " << transmit_frame; // Now set up a reader to read in the frame. - QuicDataReader reader(packet_buffer, writer.length(), NETWORK_BYTE_ORDER); + QuicDataReader reader(packet_buffer, writer.length(), + quiche::NETWORK_BYTE_ORDER); // read in the frame type uint8_t received_frame_type; @@ -384,7 +387,7 @@ // Make a writer so that the serialized packet is placed in // packet_buffer. QuicDataWriter writer(packet_buffer_size, packet_buffer, - NETWORK_BYTE_ORDER); + quiche::NETWORK_BYTE_ORDER); QuicPathChallengeFrame transmit_frame(0, data); @@ -396,7 +399,8 @@ EXPECT_EQ(kQuicPathChallengeFrameSize, writer.length()); // now set up a reader to read in the frame. - QuicDataReader reader(packet_buffer, writer.length(), NETWORK_BYTE_ORDER); + QuicDataReader reader(packet_buffer, writer.length(), + quiche::NETWORK_BYTE_ORDER); QuicPathChallengeFrame receive_frame; @@ -417,7 +421,7 @@ // Make a writer so that the serialized packet is placed in // packet_buffer. QuicDataWriter writer(packet_buffer_size, packet_buffer, - NETWORK_BYTE_ORDER); + quiche::NETWORK_BYTE_ORDER); QuicPathResponseFrame transmit_frame(0, data); @@ -429,7 +433,8 @@ EXPECT_EQ(kQuicPathResponseFrameSize, writer.length()); // Set up a reader to read in the frame. - QuicDataReader reader(packet_buffer, writer.length(), NETWORK_BYTE_ORDER); + QuicDataReader reader(packet_buffer, writer.length(), + quiche::NETWORK_BYTE_ORDER); QuicPathResponseFrame receive_frame; @@ -452,7 +457,7 @@ // Initialize a writer so that the serialized packet is placed in // packet_buffer. QuicDataWriter writer(packet_buffer_size, packet_buffer, - NETWORK_BYTE_ORDER); + quiche::NETWORK_BYTE_ORDER); QuicRstStreamFrame transmit_frame(static_cast<QuicControlFrameId>(1), stream_id, error_code, final_offset); @@ -465,7 +470,8 @@ EXPECT_LT(2u, writer.length()); EXPECT_GT(25u, writer.length()); // Now set up a reader to read in the thing in. - QuicDataReader reader(packet_buffer, writer.length(), NETWORK_BYTE_ORDER); + QuicDataReader reader(packet_buffer, writer.length(), + quiche::NETWORK_BYTE_ORDER); // A QuicRstStreamFrame to hold the results QuicRstStreamFrame receive_frame; @@ -487,7 +493,7 @@ Perspective old_perspective = framer_.perspective(); // Set up the writer and transmit QuicMaxStreamsFrame QuicDataWriter writer(sizeof(packet_buffer), packet_buffer, - NETWORK_BYTE_ORDER); + quiche::NETWORK_BYTE_ORDER); // Set the perspective of the sender. If the stream id is supposed to // be server-initiated, then the sender of the MAX_STREAMS should be @@ -512,7 +518,8 @@ : Perspective::IS_CLIENT); // Set up reader and empty receive QuicPaddingFrame. - QuicDataReader reader(packet_buffer, writer.length(), NETWORK_BYTE_ORDER); + QuicDataReader reader(packet_buffer, writer.length(), + quiche::NETWORK_BYTE_ORDER); QuicMaxStreamsFrame receive_frame; // Deframe it @@ -537,7 +544,7 @@ Perspective old_perspective = framer_.perspective(); // Set up the writer and transmit QuicStreamsBlockedFrame QuicDataWriter writer(sizeof(packet_buffer), packet_buffer, - NETWORK_BYTE_ORDER); + quiche::NETWORK_BYTE_ORDER); // Set the perspective of the sender. If the stream id is supposed to // be server-initiated, then the sender of the STREAMS_BLOCKED should be @@ -562,7 +569,8 @@ : Perspective::IS_SERVER); // Set up reader and empty receive QuicPaddingFrame. - QuicDataReader reader(packet_buffer, writer.length(), NETWORK_BYTE_ORDER); + QuicDataReader reader(packet_buffer, writer.length(), + quiche::NETWORK_BYTE_ORDER); QuicStreamsBlockedFrame receive_frame; // Deframe it @@ -762,13 +770,14 @@ data_producer.SaveCryptoData(ENCRYPTION_INITIAL, offset, frame_data); QuicDataWriter writer(QUIC_ARRAYSIZE(packet_buffer), packet_buffer, - NETWORK_BYTE_ORDER); + quiche::NETWORK_BYTE_ORDER); // Write the frame. EXPECT_TRUE(QuicFramerPeer::AppendCryptoFrame(&framer_, frame, &writer)); EXPECT_NE(0u, writer.length()); // Read it back. - QuicDataReader reader(packet_buffer, writer.length(), NETWORK_BYTE_ORDER); + QuicDataReader reader(packet_buffer, writer.length(), + quiche::NETWORK_BYTE_ORDER); QuicCryptoFrame read_frame; EXPECT_TRUE( QuicFramerPeer::ProcessCryptoFrame(&framer_, &reader, &read_frame)); @@ -787,7 +796,7 @@ // initialize a writer so that the serialized packet is placed in // packet_buffer. QuicDataWriter writer(sizeof(packet_buffer), packet_buffer, - NETWORK_BYTE_ORDER); + quiche::NETWORK_BYTE_ORDER); std::string test_string = "Ich Bin Ein Jelly Donut?"; QuicConnectionCloseFrame sent_frame(QUIC_VERSION_99, QUIC_NO_ERROR, @@ -802,7 +811,8 @@ EXPECT_NE(0u, writer.length()); // now set up a reader to read in the frame. - QuicDataReader reader(packet_buffer, writer.length(), NETWORK_BYTE_ORDER); + QuicDataReader reader(packet_buffer, writer.length(), + quiche::NETWORK_BYTE_ORDER); // a QuicConnectionCloseFrame to hold the results. QuicConnectionCloseFrame sink_frame; @@ -824,7 +834,7 @@ // initialize a writer so that the serialized packet is placed in // packet_buffer. QuicDataWriter writer(sizeof(packet_buffer), packet_buffer, - NETWORK_BYTE_ORDER); + quiche::NETWORK_BYTE_ORDER); std::string test_string = "Ich Bin Ein Jelly Donut?"; QuicConnectionCloseFrame sent_frame(QUIC_VERSION_99, QUIC_LAST_ERROR, @@ -839,7 +849,8 @@ EXPECT_NE(0u, writer.length()); // now set up a reader to read in the frame. - QuicDataReader reader(packet_buffer, writer.length(), NETWORK_BYTE_ORDER); + QuicDataReader reader(packet_buffer, writer.length(), + quiche::NETWORK_BYTE_ORDER); // a QuicConnectionCloseFrame to hold the results. QuicConnectionCloseFrame sink_frame; @@ -1061,7 +1072,7 @@ // Make a writer so that the serialized packet is placed in // packet_buffer. QuicDataWriter writer(sizeof(packet_buffer), packet_buffer, - NETWORK_BYTE_ORDER); + quiche::NETWORK_BYTE_ORDER); QuicAckFrame transmit_frame; transmit_frame.largest_acked = QuicPacketNumber(1); @@ -1085,7 +1096,8 @@ EXPECT_EQ(0, memcmp(packet, packet_buffer, writer.length())); // Now set up a reader to read in the frame. - QuicDataReader reader(packet_buffer, writer.length(), NETWORK_BYTE_ORDER); + QuicDataReader reader(packet_buffer, writer.length(), + quiche::NETWORK_BYTE_ORDER); // an AckFrame to hold the results QuicAckFrame receive_frame; @@ -1150,7 +1162,7 @@ // Make a writer so that the serialized packet is placed in // packet_buffer. QuicDataWriter writer(sizeof(packet_buffer), packet_buffer, - NETWORK_BYTE_ORDER); + quiche::NETWORK_BYTE_ORDER); QuicStopSendingFrame transmit_frame; transmit_frame.stream_id = 12345; @@ -1164,7 +1176,8 @@ EXPECT_LE(3u, writer.length()); EXPECT_GE(10u, writer.length()); - QuicDataReader reader(packet_buffer, writer.length(), NETWORK_BYTE_ORDER); + QuicDataReader reader(packet_buffer, writer.length(), + quiche::NETWORK_BYTE_ORDER); // A frame to hold the results QuicStopSendingFrame receive_frame; @@ -1190,7 +1203,7 @@ // Set up the writer and transmit QuicWindowUpdateFrame QuicDataWriter writer(sizeof(packet_buffer), packet_buffer, - NETWORK_BYTE_ORDER); + quiche::NETWORK_BYTE_ORDER); QuicWindowUpdateFrame transmit_frame(0, 99, window_size); // Add the frame. @@ -1202,7 +1215,8 @@ EXPECT_GE(8u, writer.length()); // Set up reader and an empty QuicWindowUpdateFrame - QuicDataReader reader(packet_buffer, writer.length(), NETWORK_BYTE_ORDER); + QuicDataReader reader(packet_buffer, writer.length(), + quiche::NETWORK_BYTE_ORDER); QuicWindowUpdateFrame receive_frame; // Deframe it @@ -1231,7 +1245,7 @@ // Set up the writer and transmit QuicWindowUpdateFrame QuicDataWriter writer(sizeof(packet_buffer), packet_buffer, - NETWORK_BYTE_ORDER); + quiche::NETWORK_BYTE_ORDER); QuicWindowUpdateFrame transmit_frame(0, stream_id, window_size); // Add the frame. @@ -1243,7 +1257,8 @@ EXPECT_GE(16u, writer.length()); // Set up reader and empty receive QuicPaddingFrame. - QuicDataReader reader(packet_buffer, writer.length(), NETWORK_BYTE_ORDER); + QuicDataReader reader(packet_buffer, writer.length(), + quiche::NETWORK_BYTE_ORDER); QuicWindowUpdateFrame receive_frame; // Deframe it @@ -1286,7 +1301,7 @@ // Set up the writer and transmit QuicBlockedFrame QuicDataWriter writer(sizeof(packet_buffer), packet_buffer, - NETWORK_BYTE_ORDER); + quiche::NETWORK_BYTE_ORDER); QuicBlockedFrame transmit_frame( 0, QuicUtils::GetInvalidStreamId(framer_.transport_version()), offset); @@ -1299,7 +1314,8 @@ EXPECT_GE(8u, writer.length()); // Set up reader and empty receive QuicFrame. - QuicDataReader reader(packet_buffer, writer.length(), NETWORK_BYTE_ORDER); + QuicDataReader reader(packet_buffer, writer.length(), + quiche::NETWORK_BYTE_ORDER); QuicBlockedFrame receive_frame; // Deframe it @@ -1328,7 +1344,7 @@ // Set up the writer and transmit QuicWindowUpdateFrame QuicDataWriter writer(sizeof(packet_buffer), packet_buffer, - NETWORK_BYTE_ORDER); + quiche::NETWORK_BYTE_ORDER); QuicBlockedFrame transmit_frame(0, stream_id, offset); // Add the frame. @@ -1340,7 +1356,8 @@ EXPECT_GE(16u, writer.length()); // Set up reader and empty receive QuicPaddingFrame. - QuicDataReader reader(packet_buffer, writer.length(), NETWORK_BYTE_ORDER); + QuicDataReader reader(packet_buffer, writer.length(), + quiche::NETWORK_BYTE_ORDER); QuicBlockedFrame receive_frame; // Deframe it @@ -1398,7 +1415,7 @@ // Set up the writer and transmit a QuicNewConnectionIdFrame QuicDataWriter writer(sizeof(packet_buffer), packet_buffer, - NETWORK_BYTE_ORDER); + quiche::NETWORK_BYTE_ORDER); // Add the frame. EXPECT_TRUE(QuicFramerPeer::AppendNewConnectionIdFrame( @@ -1424,7 +1441,8 @@ EXPECT_EQ(0, memcmp(packet_buffer, packet, sizeof(packet))); // Set up reader and empty receive QuicPaddingFrame. - QuicDataReader reader(packet_buffer, writer.length(), NETWORK_BYTE_ORDER); + QuicDataReader reader(packet_buffer, writer.length(), + quiche::NETWORK_BYTE_ORDER); QuicNewConnectionIdFrame receive_frame; // Deframe it @@ -1449,7 +1467,7 @@ // Set up the writer and transmit QuicRetireConnectionIdFrame QuicDataWriter writer(sizeof(packet_buffer), packet_buffer, - NETWORK_BYTE_ORDER); + quiche::NETWORK_BYTE_ORDER); // Add the frame. EXPECT_TRUE(QuicFramerPeer::AppendRetireConnectionIdFrame( @@ -1466,7 +1484,8 @@ EXPECT_EQ(0, memcmp(packet_buffer, packet, sizeof(packet))); // Set up reader and empty receive QuicPaddingFrame. - QuicDataReader reader(packet_buffer, writer.length(), NETWORK_BYTE_ORDER); + QuicDataReader reader(packet_buffer, writer.length(), + quiche::NETWORK_BYTE_ORDER); QuicRetireConnectionIdFrame receive_frame; // Deframe it
diff --git a/quic/core/quic_packet_creator_test.cc b/quic/core/quic_packet_creator_test.cc index 9aa737a..c7a38b2 100644 --- a/quic/core/quic_packet_creator_test.cc +++ b/quic/core/quic_packet_creator_test.cc
@@ -229,7 +229,7 @@ EXPECT_EQ(STREAM_FRAME, frame.type); EXPECT_EQ(stream_id, frame.stream_frame.stream_id); char buf[kMaxOutgoingPacketSize]; - QuicDataWriter writer(kMaxOutgoingPacketSize, buf, HOST_BYTE_ORDER); + QuicDataWriter writer(kMaxOutgoingPacketSize, buf, quiche::HOST_BYTE_ORDER); if (frame.stream_frame.data_length > 0) { producer_.WriteStreamData(stream_id, frame.stream_frame.offset, frame.stream_frame.data_length, &writer);
diff --git a/quic/core/quic_session_test.cc b/quic/core/quic_session_test.cc index 16a9917..d3df0a7 100644 --- a/quic/core/quic_session_test.cc +++ b/quic/core/quic_session_test.cc
@@ -1563,7 +1563,7 @@ config.ToHandshakeMessage(&crypto_message, transport_version()); crypto_stream->SendHandshakeMessage(crypto_message); char buf[1000]; - QuicDataWriter writer(1000, buf, NETWORK_BYTE_ORDER); + QuicDataWriter writer(1000, buf, quiche::NETWORK_BYTE_ORDER); crypto_stream->WriteStreamData(offset, crypto_message.size(), &writer); } EXPECT_TRUE(crypto_stream->flow_controller()->IsBlocked());
diff --git a/quic/core/quic_stream_send_buffer_test.cc b/quic/core/quic_stream_send_buffer_test.cc index 4a37c1e..90fcd6e 100644 --- a/quic/core/quic_stream_send_buffer_test.cc +++ b/quic/core/quic_stream_send_buffer_test.cc
@@ -64,7 +64,7 @@ void WriteAllData() { // Write all data. char buf[4000]; - QuicDataWriter writer(4000, buf, HOST_BYTE_ORDER); + QuicDataWriter writer(4000, buf, quiche::HOST_BYTE_ORDER); send_buffer_.WriteStreamData(0, 3840u, &writer); send_buffer_.OnStreamDataConsumed(3840u); @@ -78,7 +78,7 @@ TEST_F(QuicStreamSendBufferTest, CopyDataToBuffer) { char buf[4000]; - QuicDataWriter writer(4000, buf, HOST_BYTE_ORDER); + QuicDataWriter writer(4000, buf, quiche::HOST_BYTE_ORDER); std::string copy1(1024, 'a'); std::string copy2 = std::string(512, 'a') + std::string(256, 'b') + std::string(256, 'c'); @@ -95,7 +95,7 @@ EXPECT_EQ(copy4, QuicStringPiece(buf + 3072, 768)); // Test data piece across boundries. - QuicDataWriter writer2(4000, buf, HOST_BYTE_ORDER); + QuicDataWriter writer2(4000, buf, quiche::HOST_BYTE_ORDER); std::string copy5 = std::string(536, 'a') + std::string(256, 'b') + std::string(232, 'c'); ASSERT_TRUE(send_buffer_.WriteStreamData(1000, 1024, &writer2)); @@ -105,7 +105,7 @@ EXPECT_EQ(copy6, QuicStringPiece(buf + 1024, 1024)); // Invalid data copy. - QuicDataWriter writer3(4000, buf, HOST_BYTE_ORDER); + QuicDataWriter writer3(4000, buf, quiche::HOST_BYTE_ORDER); EXPECT_FALSE(send_buffer_.WriteStreamData(3000, 1024, &writer3)); EXPECT_QUIC_BUG(send_buffer_.WriteStreamData(0, 4000, &writer3), "Writer fails to write."); @@ -123,7 +123,7 @@ std::string(512, 'a') + std::string(256, 'b') + std::string(256, 'c'); std::string copy3 = std::string(1024, 'c') + std::string(100, 'd'); char buf[6000]; - QuicDataWriter writer(6000, buf, HOST_BYTE_ORDER); + QuicDataWriter writer(6000, buf, quiche::HOST_BYTE_ORDER); // Write more than one slice. EXPECT_EQ(0, QuicStreamSendBufferPeer::write_index(&send_buffer_)); ASSERT_TRUE(send_buffer_.WriteStreamData(0, 1024, &writer)); @@ -290,7 +290,7 @@ TEST_F(QuicStreamSendBufferTest, CurrentWriteIndex) { char buf[4000]; - QuicDataWriter writer(4000, buf, HOST_BYTE_ORDER); + QuicDataWriter writer(4000, buf, quiche::HOST_BYTE_ORDER); // With data buffered, index points to the 1st slice of data. EXPECT_EQ(0u, QuicStreamSendBufferPeer::CurrentWriteSlice(&send_buffer_)->offset);
diff --git a/quic/core/quic_trace_visitor.cc b/quic/core/quic_trace_visitor.cc index 8295e72..99681af 100644 --- a/quic/core/quic_trace_visitor.cc +++ b/quic/core/quic_trace_visitor.cc
@@ -6,7 +6,7 @@ #include <string> -#include "net/third_party/quiche/src/quic/platform/api/quic_endian.h" +#include "net/third_party/quiche/src/common/platform/api/quiche_endian.h" namespace quic { @@ -265,7 +265,8 @@ void QuicTraceVisitor::OnSuccessfulVersionNegotiation( const ParsedQuicVersion& version) { - uint32_t tag = QuicEndian::HostToNet32(CreateQuicVersionLabel(version)); + uint32_t tag = + quiche::QuicheEndian::HostToNet32(CreateQuicVersionLabel(version)); std::string binary_tag(reinterpret_cast<const char*>(&tag), sizeof(tag)); trace_.set_protocol_version(binary_tag); }
diff --git a/quic/core/quic_utils.cc b/quic/core/quic_utils.cc index eed0e37..a69efcd 100644 --- a/quic/core/quic_utils.cc +++ b/quic/core/quic_utils.cc
@@ -15,11 +15,11 @@ #include "net/third_party/quiche/src/quic/platform/api/quic_aligned.h" #include "net/third_party/quiche/src/quic/platform/api/quic_arraysize.h" #include "net/third_party/quiche/src/quic/platform/api/quic_bug_tracker.h" -#include "net/third_party/quiche/src/quic/platform/api/quic_endian.h" #include "net/third_party/quiche/src/quic/platform/api/quic_flag_utils.h" #include "net/third_party/quiche/src/quic/platform/api/quic_flags.h" #include "net/third_party/quiche/src/quic/platform/api/quic_prefetch.h" #include "net/third_party/quiche/src/quic/platform/api/quic_uint128.h" +#include "net/third_party/quiche/src/common/platform/api/quiche_endian.h" namespace quic { namespace {
diff --git a/quic/core/quic_versions.cc b/quic/core/quic_versions.cc index 8d666a3..b68c988 100644 --- a/quic/core/quic_versions.cc +++ b/quic/core/quic_versions.cc
@@ -11,11 +11,11 @@ #include "net/third_party/quiche/src/quic/core/quic_types.h" #include "net/third_party/quiche/src/quic/platform/api/quic_arraysize.h" #include "net/third_party/quiche/src/quic/platform/api/quic_bug_tracker.h" -#include "net/third_party/quiche/src/quic/platform/api/quic_endian.h" #include "net/third_party/quiche/src/quic/platform/api/quic_flag_utils.h" #include "net/third_party/quiche/src/quic/platform/api/quic_flags.h" #include "net/third_party/quiche/src/quic/platform/api/quic_logging.h" #include "net/third_party/quiche/src/quic/platform/api/quic_text_utils.h" +#include "net/third_party/quiche/src/common/platform/api/quiche_endian.h" namespace quic { namespace { @@ -324,7 +324,7 @@ } std::string QuicVersionLabelToString(QuicVersionLabel version_label) { - return QuicTagToString(QuicEndian::HostToNet32(version_label)); + return QuicTagToString(quiche::QuicheEndian::HostToNet32(version_label)); } std::string QuicVersionLabelVectorToString(
diff --git a/quic/platform/api/quic_endian.h b/quic/platform/api/quic_endian.h deleted file mode 100644 index 56a69a9..0000000 --- a/quic/platform/api/quic_endian.h +++ /dev/null
@@ -1,55 +0,0 @@ -// Copyright 2017 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_QUIC_PLATFORM_API_QUIC_ENDIAN_H_ -#define QUICHE_QUIC_PLATFORM_API_QUIC_ENDIAN_H_ - -#include "net/third_party/quiche/src/quic/platform/api/quic_export.h" -#include "net/quic/platform/impl/quic_endian_impl.h" - -namespace quic { - -enum Endianness { - NETWORK_BYTE_ORDER, // big endian - HOST_BYTE_ORDER // little endian -}; - -// Provide utility functions that convert from/to network order (big endian) -// to/from host order (can be either little or big endian depending on the -// platform). -class QUIC_EXPORT_PRIVATE QuicEndian { - public: - // Convert |x| from host order (can be either little or big endian depending - // on the platform) to network order (big endian). - static uint16_t HostToNet16(uint16_t x) { - return QuicEndianImpl::HostToNet16(x); - } - static uint32_t HostToNet32(uint32_t x) { - return QuicEndianImpl::HostToNet32(x); - } - static uint64_t HostToNet64(uint64_t x) { - return QuicEndianImpl::HostToNet64(x); - } - - // Convert |x| from network order (big endian) to host order (can be either - // little or big endian depending on the platform). - static uint16_t NetToHost16(uint16_t x) { - return QuicEndianImpl::NetToHost16(x); - } - static uint32_t NetToHost32(uint32_t x) { - return QuicEndianImpl::NetToHost32(x); - } - static uint64_t NetToHost64(uint64_t x) { - return QuicEndianImpl::NetToHost64(x); - } - - // Returns true if current host order is little endian. - static bool HostIsLittleEndian() { - return QuicEndianImpl::HostIsLittleEndian(); - } -}; - -} // namespace quic - -#endif // QUICHE_QUIC_PLATFORM_API_QUIC_ENDIAN_H_
diff --git a/quic/platform/api/quic_endian_test.cc b/quic/platform/api/quic_endian_test.cc deleted file mode 100644 index d054d96..0000000 --- a/quic/platform/api/quic_endian_test.cc +++ /dev/null
@@ -1,51 +0,0 @@ -// Copyright 2017 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 "net/third_party/quiche/src/quic/platform/api/quic_endian.h" - -#include "net/third_party/quiche/src/quic/platform/api/quic_test.h" - -namespace quic { -namespace test { -namespace { - -const uint16_t k16BitTestData = 0xaabb; -const uint16_t k16BitSwappedTestData = 0xbbaa; -const uint32_t k32BitTestData = 0xaabbccdd; -const uint32_t k32BitSwappedTestData = 0xddccbbaa; -const uint64_t k64BitTestData = 0xaabbccdd44332211; -const uint64_t k64BitSwappedTestData = 0x11223344ddccbbaa; - -class QuicEndianTest : public QuicTest {}; - -TEST_F(QuicEndianTest, HostToNet) { - if (QuicEndian::HostIsLittleEndian()) { - EXPECT_EQ(k16BitSwappedTestData, QuicEndian::HostToNet16(k16BitTestData)); - EXPECT_EQ(k32BitSwappedTestData, QuicEndian::HostToNet32(k32BitTestData)); - EXPECT_EQ(k64BitSwappedTestData, QuicEndian::HostToNet64(k64BitTestData)); - } else { - EXPECT_EQ(k16BitTestData, QuicEndian::HostToNet16(k16BitTestData)); - EXPECT_EQ(k32BitTestData, QuicEndian::HostToNet32(k32BitTestData)); - EXPECT_EQ(k64BitTestData, QuicEndian::HostToNet64(k64BitTestData)); - } -} - -TEST_F(QuicEndianTest, NetToHost) { - if (QuicEndian::HostIsLittleEndian()) { - EXPECT_EQ(k16BitTestData, QuicEndian::NetToHost16(k16BitSwappedTestData)); - EXPECT_EQ(k32BitTestData, QuicEndian::NetToHost32(k32BitSwappedTestData)); - EXPECT_EQ(k64BitTestData, QuicEndian::NetToHost64(k64BitSwappedTestData)); - } else { - EXPECT_EQ(k16BitSwappedTestData, - QuicEndian::NetToHost16(k16BitSwappedTestData)); - EXPECT_EQ(k32BitSwappedTestData, - QuicEndian::NetToHost32(k32BitSwappedTestData)); - EXPECT_EQ(k64BitSwappedTestData, - QuicEndian::NetToHost64(k64BitSwappedTestData)); - } -} - -} // namespace -} // namespace test -} // namespace quic
diff --git a/quic/qbone/bonnet/icmp_reachable.cc b/quic/qbone/bonnet/icmp_reachable.cc index 7779a8b..a6913d1 100644 --- a/quic/qbone/bonnet/icmp_reachable.cc +++ b/quic/qbone/bonnet/icmp_reachable.cc
@@ -7,11 +7,11 @@ #include <netinet/ip6.h> #include "net/third_party/quiche/src/quic/core/crypto/quic_random.h" -#include "net/third_party/quiche/src/quic/platform/api/quic_endian.h" #include "net/third_party/quiche/src/quic/platform/api/quic_logging.h" #include "net/third_party/quiche/src/quic/platform/api/quic_mutex.h" #include "net/third_party/quiche/src/quic/platform/api/quic_text_utils.h" #include "net/third_party/quiche/src/quic/qbone/platform/icmp_packet.h" +#include "net/third_party/quiche/src/common/platform/api/quiche_endian.h" namespace quic { namespace {
diff --git a/quic/qbone/platform/icmp_packet.cc b/quic/qbone/platform/icmp_packet.cc index 8ba3916..9039944 100644 --- a/quic/qbone/platform/icmp_packet.cc +++ b/quic/qbone/platform/icmp_packet.cc
@@ -5,8 +5,9 @@ #include "net/third_party/quiche/src/quic/qbone/platform/icmp_packet.h" #include <netinet/ip6.h> -#include "net/third_party/quiche/src/quic/platform/api/quic_endian.h" + #include "net/third_party/quiche/src/quic/qbone/platform/internet_checksum.h" +#include "net/third_party/quiche/src/common/platform/api/quiche_endian.h" namespace quic { namespace { @@ -46,7 +47,8 @@ // Set version to 6. icmp_packet.ip_header.ip6_vfc = 0x6 << 4; // Set the payload size, protocol and TTL. - icmp_packet.ip_header.ip6_plen = QuicEndian::HostToNet16(payload_size); + icmp_packet.ip_header.ip6_plen = + quiche::QuicheEndian::HostToNet16(payload_size); icmp_packet.ip_header.ip6_nxt = IPPROTO_ICMPV6; icmp_packet.ip_header.ip6_hops = kIcmpTtl; // Set the source address to the specified self IP. @@ -58,7 +60,7 @@ icmp_packet.icmp_header.icmp6_cksum = 0; IPv6PseudoHeader pseudo_header{}; - pseudo_header.payload_size = QuicEndian::HostToNet32(payload_size); + pseudo_header.payload_size = quiche::QuicheEndian::HostToNet32(payload_size); InternetChecksum checksum; // Pseudoheader.
diff --git a/quic/qbone/platform/internet_checksum.cc b/quic/qbone/platform/internet_checksum.cc index 9cbe227..b98c857 100644 --- a/quic/qbone/platform/internet_checksum.cc +++ b/quic/qbone/platform/internet_checksum.cc
@@ -3,7 +3,6 @@ // found in the LICENSE file. #include "net/third_party/quiche/src/quic/qbone/platform/internet_checksum.h" -#include "net/third_party/quiche/src/quic/platform/api/quic_endian.h" namespace quic {
diff --git a/quic/qbone/platform/ip_range.cc b/quic/qbone/platform/ip_range.cc index 15ebb72..03ad640 100644 --- a/quic/qbone/platform/ip_range.cc +++ b/quic/qbone/platform/ip_range.cc
@@ -4,7 +4,7 @@ #include "net/third_party/quiche/src/quic/qbone/platform/ip_range.h" -#include "net/third_party/quiche/src/quic/platform/api/quic_endian.h" +#include "net/third_party/quiche/src/common/platform/api/quiche_endian.h" namespace quic { @@ -23,9 +23,9 @@ } uint32_t raw_address = *reinterpret_cast<const uint32_t*>(input.ToPackedString().data()); - raw_address = QuicEndian::NetToHost32(raw_address); + raw_address = quiche::QuicheEndian::NetToHost32(raw_address); raw_address &= ~0U << (kIPv4Size - *prefix_length); - raw_address = QuicEndian::HostToNet32(raw_address); + raw_address = quiche::QuicheEndian::HostToNet32(raw_address); output.FromPackedString(reinterpret_cast<const char*>(&raw_address), sizeof(raw_address)); return output; @@ -42,16 +42,16 @@ // out. // The endianess between raw_address[0] and raw_address[1] is handled // explicitly by handling lower and higher bytes separately. - raw_address[0] = QuicEndian::NetToHost64(raw_address[0]); - raw_address[1] = QuicEndian::NetToHost64(raw_address[1]); + raw_address[0] = quiche::QuicheEndian::NetToHost64(raw_address[0]); + raw_address[1] = quiche::QuicheEndian::NetToHost64(raw_address[1]); if (*prefix_length <= kIPv6Size / 2) { raw_address[0] &= ~uint64_t{0} << (kIPv6Size / 2 - *prefix_length); raw_address[1] = 0; } else { raw_address[1] &= ~uint64_t{0} << (kIPv6Size - *prefix_length); } - raw_address[0] = QuicEndian::HostToNet64(raw_address[0]); - raw_address[1] = QuicEndian::HostToNet64(raw_address[1]); + raw_address[0] = quiche::QuicheEndian::HostToNet64(raw_address[0]); + raw_address[1] = quiche::QuicheEndian::HostToNet64(raw_address[1]); output.FromPackedString(reinterpret_cast<const char*>(raw_address), sizeof(raw_address)); return output;
diff --git a/quic/qbone/platform/tcp_packet.cc b/quic/qbone/platform/tcp_packet.cc index 56fa88a..2566d25 100644 --- a/quic/qbone/platform/tcp_packet.cc +++ b/quic/qbone/platform/tcp_packet.cc
@@ -6,9 +6,9 @@ #include <netinet/ip6.h> -#include "net/third_party/quiche/src/quic/platform/api/quic_endian.h" #include "net/third_party/quiche/src/quic/platform/api/quic_logging.h" #include "net/third_party/quiche/src/quic/qbone/platform/internet_checksum.h" +#include "net/third_party/quiche/src/common/platform/api/quiche_endian.h" namespace quic { namespace { @@ -45,8 +45,8 @@ if (QUIC_PREDICT_FALSE(ip6_header->ip6_nxt != IPPROTO_TCP)) { return; } - if (QUIC_PREDICT_FALSE(QuicEndian::NetToHost16(ip6_header->ip6_plen) < - sizeof(tcphdr))) { + if (QUIC_PREDICT_FALSE(quiche::QuicheEndian::NetToHost16( + ip6_header->ip6_plen) < sizeof(tcphdr))) { return; } auto* tcp_header = reinterpret_cast<const tcphdr*>(ip6_header + 1); @@ -60,7 +60,8 @@ // Set version to 6. tcp_packet.ip_header.ip6_vfc = 0x6 << 4; // Set the payload size, protocol and TTL. - tcp_packet.ip_header.ip6_plen = QuicEndian::HostToNet16(payload_size); + tcp_packet.ip_header.ip6_plen = + quiche::QuicheEndian::HostToNet16(payload_size); tcp_packet.ip_header.ip6_nxt = IPPROTO_TCP; tcp_packet.ip_header.ip6_hops = kTcpTtl; // Since the TCP RST is impersonating the endpoint, flip the source and @@ -98,12 +99,12 @@ // the sum of the sequence number and segment length of the incoming segment tcp_packet.tcp_header.ack = 1; tcp_packet.tcp_header.seq = 0; - tcp_packet.tcp_header.ack_seq = - QuicEndian::HostToNet32(QuicEndian::NetToHost32(tcp_header->seq) + 1); + tcp_packet.tcp_header.ack_seq = quiche::QuicheEndian::HostToNet32( + quiche::QuicheEndian::NetToHost32(tcp_header->seq) + 1); } TCPv6PseudoHeader pseudo_header{}; - pseudo_header.payload_size = QuicEndian::HostToNet32(payload_size); + pseudo_header.payload_size = quiche::QuicheEndian::HostToNet32(payload_size); InternetChecksum checksum; // Pseudoheader.
diff --git a/quic/qbone/qbone_packet_processor.cc b/quic/qbone/qbone_packet_processor.cc index db7a138..39b622b 100644 --- a/quic/qbone/qbone_packet_processor.cc +++ b/quic/qbone/qbone_packet_processor.cc
@@ -7,11 +7,11 @@ #include <cstring> #include "net/third_party/quiche/src/quic/platform/api/quic_bug_tracker.h" -#include "net/third_party/quiche/src/quic/platform/api/quic_endian.h" #include "net/third_party/quiche/src/quic/platform/api/quic_logging.h" #include "net/third_party/quiche/src/quic/qbone/platform/icmp_packet.h" #include "net/third_party/quiche/src/quic/qbone/platform/internet_checksum.h" #include "net/third_party/quiche/src/quic/qbone/platform/tcp_packet.h" +#include "net/third_party/quiche/src/common/platform/api/quiche_endian.h" namespace { @@ -171,7 +171,7 @@ // Check payload size. const size_t declared_payload_size = - QuicEndian::NetToHost16(header->ip6_plen); + quiche::QuicheEndian::NetToHost16(header->ip6_plen); const size_t actual_payload_size = packet->size() - kIPv6HeaderSize; if (declared_payload_size != actual_payload_size) { QUIC_DVLOG(1)
diff --git a/quic/quartc/quartc_stream_test.cc b/quic/quartc/quartc_stream_test.cc index c8a68fc..0acaded 100644 --- a/quic/quartc/quartc_stream_test.cc +++ b/quic/quartc/quartc_stream_test.cc
@@ -27,7 +27,6 @@ #include "net/third_party/quiche/src/quic/core/quic_versions.h" #include "net/third_party/quiche/src/quic/core/quic_write_blocked_list.h" #include "net/third_party/quiche/src/quic/platform/api/quic_clock.h" -#include "net/third_party/quiche/src/quic/platform/api/quic_endian.h" #include "net/third_party/quiche/src/quic/platform/api/quic_flags.h" #include "net/third_party/quiche/src/quic/platform/api/quic_ip_address.h" #include "net/third_party/quiche/src/quic/platform/api/quic_socket_address.h" @@ -36,6 +35,7 @@ #include "net/third_party/quiche/src/quic/quartc/quartc_factory.h" #include "net/third_party/quiche/src/quic/test_tools/mock_clock.h" #include "net/third_party/quiche/src/quic/test_tools/quic_test_utils.h" +#include "net/third_party/quiche/src/common/platform/api/quiche_endian.h" #include "net/third_party/quiche/src/spdy/core/spdy_protocol.h" namespace quic { @@ -73,7 +73,7 @@ // WritevData does not pass down a iovec, data is saved in stream before // data is consumed. Retrieve data from stream. char* buf = new char[write_length]; - QuicDataWriter writer(write_length, buf, NETWORK_BYTE_ORDER); + QuicDataWriter writer(write_length, buf, quiche::NETWORK_BYTE_ORDER); if (write_length > 0) { stream->WriteStreamData(offset, write_length, &writer); }
diff --git a/quic/test_tools/qpack/qpack_offline_decoder.cc b/quic/test_tools/qpack/qpack_offline_decoder.cc index 1472dd4..a5a74aa 100644 --- a/quic/test_tools/qpack/qpack_offline_decoder.cc +++ b/quic/test_tools/qpack/qpack_offline_decoder.cc
@@ -31,11 +31,11 @@ #include <utility> #include "net/third_party/quiche/src/quic/core/quic_types.h" -#include "net/third_party/quiche/src/quic/platform/api/quic_endian.h" #include "net/third_party/quiche/src/quic/platform/api/quic_file_utils.h" #include "net/third_party/quiche/src/quic/platform/api/quic_logging.h" #include "net/third_party/quiche/src/quic/platform/api/quic_text_utils.h" #include "net/third_party/quiche/src/quic/test_tools/qpack/qpack_test_utils.h" +#include "net/third_party/quiche/src/common/platform/api/quiche_endian.h" namespace quic { @@ -142,11 +142,11 @@ return false; } - uint64_t stream_id = QuicEndian::NetToHost64( + uint64_t stream_id = quiche::QuicheEndian::NetToHost64( *reinterpret_cast<const uint64_t*>(input_data.data())); input_data = input_data.substr(sizeof(uint64_t)); - uint32_t length = QuicEndian::NetToHost32( + uint32_t length = quiche::QuicheEndian::NetToHost32( *reinterpret_cast<const uint32_t*>(input_data.data())); input_data = input_data.substr(sizeof(uint32_t));
diff --git a/quic/test_tools/quic_test_utils.cc b/quic/test_tools/quic_test_utils.cc index aeb4eee..1d2ec74 100644 --- a/quic/test_tools/quic_test_utils.cc +++ b/quic/test_tools/quic_test_utils.cc
@@ -22,12 +22,12 @@ #include "net/third_party/quiche/src/quic/core/quic_packet_creator.h" #include "net/third_party/quiche/src/quic/core/quic_utils.h" #include "net/third_party/quiche/src/quic/platform/api/quic_arraysize.h" -#include "net/third_party/quiche/src/quic/platform/api/quic_endian.h" #include "net/third_party/quiche/src/quic/platform/api/quic_flags.h" #include "net/third_party/quiche/src/quic/platform/api/quic_logging.h" #include "net/third_party/quiche/src/quic/test_tools/crypto_test_utils.h" #include "net/third_party/quiche/src/quic/test_tools/quic_config_peer.h" #include "net/third_party/quiche/src/quic/test_tools/quic_connection_peer.h" +#include "net/third_party/quiche/src/common/platform/api/quiche_endian.h" #include "net/third_party/quiche/src/spdy/core/spdy_frame_builder.h" using testing::_; @@ -44,14 +44,14 @@ QuicConnectionId TestConnectionId(uint64_t connection_number) { const uint64_t connection_id64_net = - QuicEndian::HostToNet64(connection_number); + quiche::QuicheEndian::HostToNet64(connection_number); return QuicConnectionId(reinterpret_cast<const char*>(&connection_id64_net), sizeof(connection_id64_net)); } QuicConnectionId TestConnectionIdNineBytesLong(uint64_t connection_number) { const uint64_t connection_number_net = - QuicEndian::HostToNet64(connection_number); + quiche::QuicheEndian::HostToNet64(connection_number); char connection_id_bytes[9] = {}; static_assert( sizeof(connection_id_bytes) == 1 + sizeof(connection_number_net), @@ -67,7 +67,7 @@ memcpy(&connection_id64_net, connection_id.data(), std::min<size_t>(static_cast<size_t>(connection_id.length()), sizeof(connection_id64_net))); - return QuicEndian::NetToHost64(connection_id64_net); + return quiche::QuicheEndian::NetToHost64(connection_id64_net); } QuicAckFrame InitAckFrame(const std::vector<QuicAckBlock>& ack_blocks) { @@ -576,7 +576,7 @@ StreamSendingState state) { if (write_length > 0) { auto buf = std::make_unique<char[]>(write_length); - QuicDataWriter writer(write_length, buf.get(), HOST_BYTE_ORDER); + QuicDataWriter writer(write_length, buf.get(), quiche::HOST_BYTE_ORDER); stream->WriteStreamData(offset, write_length, &writer); } else { DCHECK(state != NO_FIN);