diff options
Diffstat (limited to 'chromium/net/third_party/quiche/src/spdy')
41 files changed, 431 insertions, 3128 deletions
diff --git a/chromium/net/third_party/quiche/src/spdy/core/hpack/hpack_constants.cc b/chromium/net/third_party/quiche/src/spdy/core/hpack/hpack_constants.cc index 231fd547460..a8e48a2feb5 100644 --- a/chromium/net/third_party/quiche/src/spdy/core/hpack/hpack_constants.cc +++ b/chromium/net/third_party/quiche/src/spdy/core/hpack/hpack_constants.cc @@ -9,8 +9,8 @@ #include <vector> #include "absl/base/macros.h" +#include "common/platform/api/quiche_logging.h" #include "spdy/core/hpack/hpack_static_table.h" -#include "spdy/platform/api/spdy_logging.h" namespace spdy { diff --git a/chromium/net/third_party/quiche/src/spdy/core/hpack/hpack_decoder_adapter.cc b/chromium/net/third_party/quiche/src/spdy/core/hpack/hpack_decoder_adapter.cc index 4d03cc50018..3fd6ebcf87d 100644 --- a/chromium/net/third_party/quiche/src/spdy/core/hpack/hpack_decoder_adapter.cc +++ b/chromium/net/third_party/quiche/src/spdy/core/hpack/hpack_decoder_adapter.cc @@ -6,9 +6,8 @@ #include "http2/decoder/decode_buffer.h" #include "http2/decoder/decode_status.h" +#include "common/platform/api/quiche_logging.h" #include "spdy/platform/api/spdy_estimate_memory_usage.h" -#include "spdy/platform/api/spdy_flags.h" -#include "spdy/platform/api/spdy_logging.h" using ::http2::DecodeBuffer; @@ -27,13 +26,13 @@ HpackDecoderAdapter::HpackDecoderAdapter() HpackDecoderAdapter::~HpackDecoderAdapter() = default; void HpackDecoderAdapter::ApplyHeaderTableSizeSetting(size_t size_setting) { - SPDY_DVLOG(2) << "HpackDecoderAdapter::ApplyHeaderTableSizeSetting"; + QUICHE_DVLOG(2) << "HpackDecoderAdapter::ApplyHeaderTableSizeSetting"; hpack_decoder_.ApplyHeaderTableSizeSetting(size_setting); } void HpackDecoderAdapter::HandleControlFrameHeadersStart( SpdyHeadersHandlerInterface* handler) { - SPDY_DVLOG(2) << "HpackDecoderAdapter::HandleControlFrameHeadersStart"; + QUICHE_DVLOG(2) << "HpackDecoderAdapter::HandleControlFrameHeadersStart"; QUICHE_DCHECK(!header_block_started_); listener_adapter_.set_handler(handler); } @@ -41,8 +40,8 @@ void HpackDecoderAdapter::HandleControlFrameHeadersStart( bool HpackDecoderAdapter::HandleControlFrameHeadersData( const char* headers_data, size_t headers_data_length) { - SPDY_DVLOG(2) << "HpackDecoderAdapter::HandleControlFrameHeadersData: len=" - << headers_data_length; + QUICHE_DVLOG(2) << "HpackDecoderAdapter::HandleControlFrameHeadersData: len=" + << headers_data_length; if (!header_block_started_) { // Initialize the decoding process here rather than in // HandleControlFrameHeadersStart because that method is not always called. @@ -61,9 +60,9 @@ bool HpackDecoderAdapter::HandleControlFrameHeadersData( if (headers_data_length > 0) { QUICHE_DCHECK_NE(headers_data, nullptr); if (headers_data_length > max_decode_buffer_size_bytes_) { - SPDY_DVLOG(1) << "max_decode_buffer_size_bytes_ < headers_data_length: " - << max_decode_buffer_size_bytes_ << " < " - << headers_data_length; + QUICHE_DVLOG(1) << "max_decode_buffer_size_bytes_ < headers_data_length: " + << max_decode_buffer_size_bytes_ << " < " + << headers_data_length; error_ = http2::HpackDecodingError::kFragmentTooLong; detailed_error_ = ""; return false; @@ -89,12 +88,12 @@ bool HpackDecoderAdapter::HandleControlFrameHeadersData( bool HpackDecoderAdapter::HandleControlFrameHeadersComplete( size_t* compressed_len) { - SPDY_DVLOG(2) << "HpackDecoderAdapter::HandleControlFrameHeadersComplete"; + QUICHE_DVLOG(2) << "HpackDecoderAdapter::HandleControlFrameHeadersComplete"; if (compressed_len != nullptr) { *compressed_len = listener_adapter_.total_hpack_bytes(); } if (!hpack_decoder_.EndDecodingBlock()) { - SPDY_DVLOG(3) << "EndDecodingBlock returned false"; + QUICHE_DVLOG(3) << "EndDecodingBlock returned false"; error_ = hpack_decoder_.error(); detailed_error_ = hpack_decoder_.detailed_error(); return false; @@ -109,7 +108,7 @@ const SpdyHeaderBlock& HpackDecoderAdapter::decoded_block() const { void HpackDecoderAdapter::set_max_decode_buffer_size_bytes( size_t max_decode_buffer_size_bytes) { - SPDY_DVLOG(2) << "HpackDecoderAdapter::set_max_decode_buffer_size_bytes"; + QUICHE_DVLOG(2) << "HpackDecoderAdapter::set_max_decode_buffer_size_bytes"; max_decode_buffer_size_bytes_ = max_decode_buffer_size_bytes; hpack_decoder_.set_max_string_size_bytes(max_decode_buffer_size_bytes); } @@ -132,7 +131,7 @@ void HpackDecoderAdapter::ListenerAdapter::set_handler( } void HpackDecoderAdapter::ListenerAdapter::OnHeaderListStart() { - SPDY_DVLOG(2) << "HpackDecoderAdapter::ListenerAdapter::OnHeaderListStart"; + QUICHE_DVLOG(2) << "HpackDecoderAdapter::ListenerAdapter::OnHeaderListStart"; total_hpack_bytes_ = 0; total_uncompressed_bytes_ = 0; decoded_block_.clear(); @@ -143,20 +142,20 @@ void HpackDecoderAdapter::ListenerAdapter::OnHeaderListStart() { void HpackDecoderAdapter::ListenerAdapter::OnHeader(const std::string& name, const std::string& value) { - SPDY_DVLOG(2) << "HpackDecoderAdapter::ListenerAdapter::OnHeader:\n name: " - << name << "\n value: " << value; + QUICHE_DVLOG(2) << "HpackDecoderAdapter::ListenerAdapter::OnHeader:\n name: " + << name << "\n value: " << value; total_uncompressed_bytes_ += name.size() + value.size(); if (handler_ == nullptr) { - SPDY_DVLOG(3) << "Adding to decoded_block"; + QUICHE_DVLOG(3) << "Adding to decoded_block"; decoded_block_.AppendValueOrAddHeader(name, value); } else { - SPDY_DVLOG(3) << "Passing to handler"; + QUICHE_DVLOG(3) << "Passing to handler"; handler_->OnHeader(name, value); } } void HpackDecoderAdapter::ListenerAdapter::OnHeaderListEnd() { - SPDY_DVLOG(2) << "HpackDecoderAdapter::ListenerAdapter::OnHeaderListEnd"; + QUICHE_DVLOG(2) << "HpackDecoderAdapter::ListenerAdapter::OnHeaderListEnd"; // We don't clear the SpdyHeaderBlock here to allow access to it until the // next HPACK block is decoded. if (handler_ != nullptr) { @@ -167,7 +166,7 @@ void HpackDecoderAdapter::ListenerAdapter::OnHeaderListEnd() { void HpackDecoderAdapter::ListenerAdapter::OnHeaderErrorDetected( absl::string_view error_message) { - SPDY_VLOG(1) << error_message; + QUICHE_VLOG(1) << error_message; } } // namespace spdy diff --git a/chromium/net/third_party/quiche/src/spdy/core/hpack/hpack_decoder_adapter_test.cc b/chromium/net/third_party/quiche/src/spdy/core/hpack/hpack_decoder_adapter_test.cc index 0a12fe49a21..d223ccf9f5a 100644 --- a/chromium/net/third_party/quiche/src/spdy/core/hpack/hpack_decoder_adapter_test.cc +++ b/chromium/net/third_party/quiche/src/spdy/core/hpack/hpack_decoder_adapter_test.cc @@ -14,17 +14,18 @@ #include <vector> #include "absl/base/macros.h" +#include "absl/strings/escaping.h" #include "http2/hpack/decoder/hpack_decoder_state.h" #include "http2/hpack/decoder/hpack_decoder_tables.h" #include "http2/hpack/tools/hpack_block_builder.h" #include "http2/test_tools/http2_random.h" +#include "common/platform/api/quiche_logging.h" #include "common/platform/api/quiche_test.h" #include "spdy/core/hpack/hpack_constants.h" #include "spdy/core/hpack/hpack_encoder.h" #include "spdy/core/hpack/hpack_output_stream.h" #include "spdy/core/recording_headers_handler.h" #include "spdy/core/spdy_test_utils.h" -#include "spdy/platform/api/spdy_logging.h" #include "spdy/platform/api/spdy_string_utils.h" using ::http2::HpackEntryType; @@ -134,7 +135,7 @@ class HpackDecoderAdapterTest } bool HandleControlFrameHeadersData(absl::string_view str) { - SPDY_VLOG(3) << "HandleControlFrameHeadersData:\n" << SpdyHexDump(str); + QUICHE_VLOG(3) << "HandleControlFrameHeadersData:\n" << SpdyHexDump(str); bytes_passed_in_ += str.size(); return decoder_.HandleControlFrameHeadersData(str.data(), str.size()); } @@ -680,7 +681,7 @@ TEST_P(HpackDecoderAdapterTest, TruncatedHuffmanLiteral) { // | www.example.com // | -> :authority: www.example.com - std::string first = SpdyHexDecode("418cf1e3c2e5f23a6ba0ab90f4ff"); + std::string first = absl::HexStringToBytes("418cf1e3c2e5f23a6ba0ab90f4ff"); EXPECT_TRUE(DecodeHeaderBlock(first)); first.pop_back(); EXPECT_FALSE(DecodeHeaderBlock(first)); @@ -700,9 +701,9 @@ TEST_P(HpackDecoderAdapterTest, HuffmanEOSError) { // | www.example.com // | -> :authority: www.example.com - std::string first = SpdyHexDecode("418cf1e3c2e5f23a6ba0ab90f4ff"); + std::string first = absl::HexStringToBytes("418cf1e3c2e5f23a6ba0ab90f4ff"); EXPECT_TRUE(DecodeHeaderBlock(first)); - first = SpdyHexDecode("418df1e3c2e5f23a6ba0ab90f4ffff"); + first = absl::HexStringToBytes("418df1e3c2e5f23a6ba0ab90f4ffff"); EXPECT_FALSE(DecodeHeaderBlock(first)); } @@ -749,7 +750,8 @@ TEST_P(HpackDecoderAdapterTest, SectionC4RequestHuffmanExamples) { // | Decoded: // | www.example.com // | -> :authority: www.example.com - std::string first = SpdyHexDecode("828684418cf1e3c2e5f23a6ba0ab90f4ff"); + std::string first = + absl::HexStringToBytes("828684418cf1e3c2e5f23a6ba0ab90f4ff"); const SpdyHeaderBlock& first_header_set = DecodeBlockExpectingSuccess(first); EXPECT_THAT(first_header_set, @@ -786,7 +788,7 @@ TEST_P(HpackDecoderAdapterTest, SectionC4RequestHuffmanExamples) { // | no-cache // | -> cache-control: no-cache - std::string second = SpdyHexDecode("828684be5886a8eb10649cbf"); + std::string second = absl::HexStringToBytes("828684be5886a8eb10649cbf"); const SpdyHeaderBlock& second_header_set = DecodeBlockExpectingSuccess(second); @@ -828,8 +830,8 @@ TEST_P(HpackDecoderAdapterTest, SectionC4RequestHuffmanExamples) { // | Decoded: // | custom-value // | -> custom-key: custom-value - std::string third = - SpdyHexDecode("828785bf408825a849e95ba97d7f8925a849e95bb8e8b4bf"); + std::string third = absl::HexStringToBytes( + "828785bf408825a849e95ba97d7f8925a849e95bb8e8b4bf"); const SpdyHeaderBlock& third_header_set = DecodeBlockExpectingSuccess(third); EXPECT_THAT( @@ -898,7 +900,7 @@ TEST_P(HpackDecoderAdapterTest, SectionC6ResponseHuffmanExamples) { // | -> location: https://www.e // | xample.com - std::string first = SpdyHexDecode( + std::string first = absl::HexStringToBytes( "488264025885aec3771a4b6196d07abe" "941054d444a8200595040b8166e082a6" "2d1bff6e919d29ad171863c78f0b97c8" @@ -941,7 +943,7 @@ TEST_P(HpackDecoderAdapterTest, SectionC6ResponseHuffmanExamples) { // | idx = 63 // | -> location: // | https://www.example.com - std::string second = SpdyHexDecode("4883640effc1c0bf"); + std::string second = absl::HexStringToBytes("4883640effc1c0bf"); const SpdyHeaderBlock& second_header_set = DecodeBlockExpectingSuccess(second); @@ -1013,7 +1015,7 @@ TEST_P(HpackDecoderAdapterTest, SectionC6ResponseHuffmanExamples) { // | -> set-cookie: foo=ASDJKHQ // | KBZXOQWEOPIUAXQWEOIU; // | max-age=3600; version=1 - std::string third = SpdyHexDecode( + std::string third = absl::HexStringToBytes( "88c16196d07abe941054d444a8200595" "040b8166e084a62d1bffc05a839bd9ab" "77ad94e7821dd7f2e6c7b335dfdfcd5b" @@ -1116,7 +1118,7 @@ TEST_P(HpackDecoderAdapterTest, Cookies) { SpdyHeaderBlock expected_header_set; expected_header_set["cookie"] = "foo; bar"; - EXPECT_TRUE(DecodeHeaderBlock(SpdyHexDecode("608294e76003626172"))); + EXPECT_TRUE(DecodeHeaderBlock(absl::HexStringToBytes("608294e76003626172"))); EXPECT_EQ(expected_header_set, decoded_block()); } diff --git a/chromium/net/third_party/quiche/src/spdy/core/hpack/hpack_encoder.cc b/chromium/net/third_party/quiche/src/spdy/core/hpack/hpack_encoder.cc index 6dc27b9ca7f..27f0444f274 100644 --- a/chromium/net/third_party/quiche/src/spdy/core/hpack/hpack_encoder.cc +++ b/chromium/net/third_party/quiche/src/spdy/core/hpack/hpack_encoder.cc @@ -9,13 +9,12 @@ #include <utility> #include "http2/hpack/huffman/hpack_huffman_encoder.h" +#include "common/platform/api/quiche_bug_tracker.h" +#include "common/platform/api/quiche_logging.h" #include "spdy/core/hpack/hpack_constants.h" #include "spdy/core/hpack/hpack_header_table.h" #include "spdy/core/hpack/hpack_output_stream.h" #include "spdy/platform/api/spdy_estimate_memory_usage.h" -#include "spdy/platform/api/spdy_flag_utils.h" -#include "spdy/platform/api/spdy_flags.h" -#include "spdy/platform/api/spdy_logging.h" namespace spdy { @@ -155,14 +154,14 @@ void HpackEncoder::EncodeRepresentations(RepresentationIterator* iter, } void HpackEncoder::EmitIndex(size_t index) { - SPDY_DVLOG(2) << "Emitting index " << index; + QUICHE_DVLOG(2) << "Emitting index " << index; output_stream_.AppendPrefix(kIndexedOpcode); output_stream_.AppendUint32(index); } void HpackEncoder::EmitIndexedLiteral(const Representation& representation) { - SPDY_DVLOG(2) << "Emitting indexed literal: (" << representation.first << ", " - << representation.second << ")"; + QUICHE_DVLOG(2) << "Emitting indexed literal: (" << representation.first + << ", " << representation.second << ")"; output_stream_.AppendPrefix(kLiteralIncrementalIndexOpcode); EmitLiteral(representation); header_table_.TryAddEntry(representation.first, representation.second); @@ -170,8 +169,8 @@ void HpackEncoder::EmitIndexedLiteral(const Representation& representation) { void HpackEncoder::EmitNonIndexedLiteral(const Representation& representation, bool enable_compression) { - SPDY_DVLOG(2) << "Emitting nonindexed literal: (" << representation.first - << ", " << representation.second << ")"; + QUICHE_DVLOG(2) << "Emitting nonindexed literal: (" << representation.first + << ", " << representation.second << ")"; output_stream_.AppendPrefix(kLiteralNoIndexOpcode); size_t name_index = header_table_.GetByName(representation.first); if (enable_compression && name_index != kHpackEntryNotFound) { @@ -198,13 +197,13 @@ void HpackEncoder::EmitString(absl::string_view str) { size_t encoded_size = enable_compression_ ? http2::HuffmanSize(str) : str.size(); if (encoded_size < str.size()) { - SPDY_DVLOG(2) << "Emitted Huffman-encoded string of length " - << encoded_size; + QUICHE_DVLOG(2) << "Emitted Huffman-encoded string of length " + << encoded_size; output_stream_.AppendPrefix(kStringLiteralHuffmanEncoded); output_stream_.AppendUint32(encoded_size); http2::HuffmanEncodeFast(str, encoded_size, output_stream_.MutableString()); } else { - SPDY_DVLOG(2) << "Emitted literal string of length " << str.size(); + QUICHE_DVLOG(2) << "Emitted literal string of length " << str.size(); output_stream_.AppendPrefix(kStringLiteralIdentityEncoded); output_stream_.AppendUint32(str.size()); output_stream_.AppendBytes(str); @@ -216,9 +215,9 @@ void HpackEncoder::MaybeEmitTableSize() { return; } const size_t current_size = CurrentHeaderTableSizeSetting(); - SPDY_DVLOG(1) << "MaybeEmitTableSize current_size=" << current_size; - SPDY_DVLOG(1) << "MaybeEmitTableSize min_table_size_setting_received_=" - << min_table_size_setting_received_; + QUICHE_DVLOG(1) << "MaybeEmitTableSize current_size=" << current_size; + QUICHE_DVLOG(1) << "MaybeEmitTableSize min_table_size_setting_received_=" + << min_table_size_setting_received_; if (min_table_size_setting_received_ < current_size) { output_stream_.AppendPrefix(kHeaderTableSizeUpdateOpcode); output_stream_.AppendUint32(min_table_size_setting_received_); @@ -347,7 +346,7 @@ HpackEncoder::Encoderator::Encoderator(const Representations& representations, void HpackEncoder::Encoderator::Next(size_t max_encoded_bytes, std::string* output) { - SPDY_BUG_IF(spdy_bug_61_1, !has_next_) + QUICHE_BUG_IF(spdy_bug_61_1, !has_next_) << "Encoderator::Next called with nothing left to encode."; const bool enable_compression = encoder_->enable_compression_; diff --git a/chromium/net/third_party/quiche/src/spdy/core/hpack/hpack_encoder_test.cc b/chromium/net/third_party/quiche/src/spdy/core/hpack/hpack_encoder_test.cc index 85fa4fbc321..774a06e8129 100644 --- a/chromium/net/third_party/quiche/src/spdy/core/hpack/hpack_encoder_test.cc +++ b/chromium/net/third_party/quiche/src/spdy/core/hpack/hpack_encoder_test.cc @@ -12,7 +12,6 @@ #include "common/platform/api/quiche_test.h" #include "spdy/core/hpack/hpack_static_table.h" #include "spdy/core/spdy_simple_arena.h" -#include "spdy/platform/api/spdy_flags.h" namespace spdy { diff --git a/chromium/net/third_party/quiche/src/spdy/core/hpack/hpack_entry.cc b/chromium/net/third_party/quiche/src/spdy/core/hpack/hpack_entry.cc index b8350df4ff4..4deb0dfcc81 100644 --- a/chromium/net/third_party/quiche/src/spdy/core/hpack/hpack_entry.cc +++ b/chromium/net/third_party/quiche/src/spdy/core/hpack/hpack_entry.cc @@ -6,7 +6,6 @@ #include "absl/strings/str_cat.h" #include "spdy/platform/api/spdy_estimate_memory_usage.h" -#include "spdy/platform/api/spdy_logging.h" namespace spdy { diff --git a/chromium/net/third_party/quiche/src/spdy/core/hpack/hpack_header_table.cc b/chromium/net/third_party/quiche/src/spdy/core/hpack/hpack_header_table.cc index ec69d47b6ae..8536a8523fc 100644 --- a/chromium/net/third_party/quiche/src/spdy/core/hpack/hpack_header_table.cc +++ b/chromium/net/third_party/quiche/src/spdy/core/hpack/hpack_header_table.cc @@ -6,10 +6,10 @@ #include <algorithm> +#include "common/platform/api/quiche_logging.h" #include "spdy/core/hpack/hpack_constants.h" #include "spdy/core/hpack/hpack_static_table.h" #include "spdy/platform/api/spdy_estimate_memory_usage.h" -#include "spdy/platform/api/spdy_logging.h" namespace spdy { @@ -155,9 +155,9 @@ const HpackEntry* HpackHeaderTable::TryAddEntry(absl::string_view name, if (!index_result.second) { // An entry with the same name and value already exists in the dynamic // index. We should replace it with the newly added entry. - SPDY_DVLOG(1) << "Found existing entry at: " << index_result.first->second - << " replacing with: " << new_entry->GetDebugString() - << " at: " << index; + QUICHE_DVLOG(1) << "Found existing entry at: " << index_result.first->second + << " replacing with: " << new_entry->GetDebugString() + << " at: " << index; QUICHE_DCHECK_GT(index, index_result.first->second); dynamic_index_.erase(index_result.first); auto insert_result = dynamic_index_.insert(std::make_pair( @@ -170,9 +170,9 @@ const HpackEntry* HpackHeaderTable::TryAddEntry(absl::string_view name, if (!name_result.second) { // An entry with the same name already exists in the dynamic index. We // should replace it with the newly added entry. - SPDY_DVLOG(1) << "Found existing entry at: " << name_result.first->second - << " replacing with: " << new_entry->GetDebugString() - << " at: " << index; + QUICHE_DVLOG(1) << "Found existing entry at: " << name_result.first->second + << " replacing with: " << new_entry->GetDebugString() + << " at: " << index; QUICHE_DCHECK_GT(index, name_result.first->second); dynamic_name_index_.erase(name_result.first); auto insert_result = diff --git a/chromium/net/third_party/quiche/src/spdy/core/hpack/hpack_header_table.h b/chromium/net/third_party/quiche/src/spdy/core/hpack/hpack_header_table.h index 893aaa7bb21..49478cd35b2 100644 --- a/chromium/net/third_party/quiche/src/spdy/core/hpack/hpack_header_table.h +++ b/chromium/net/third_party/quiche/src/spdy/core/hpack/hpack_header_table.h @@ -43,11 +43,6 @@ class QUICHE_EXPORT_PRIVATE HpackHeaderTable { // HpackHeaderTable takes advantage of the deque property that references // remain valid, so long as insertions & deletions are at the head & tail. // This precludes the use of base::circular_deque. - // - // If this changes (we want to change to circular_deque or we start to drop - // entries from the middle of the table), this should to be a std::list, in - // which case |*_index_| can be trivially extended to map to list iterators. - // // TODO(b/182349990): Change to a more memory efficient container. using DynamicEntryTable = std::deque<HpackEntry>; diff --git a/chromium/net/third_party/quiche/src/spdy/core/hpack/hpack_output_stream.cc b/chromium/net/third_party/quiche/src/spdy/core/hpack/hpack_output_stream.cc index d2ec46c49c5..7b925680d4b 100644 --- a/chromium/net/third_party/quiche/src/spdy/core/hpack/hpack_output_stream.cc +++ b/chromium/net/third_party/quiche/src/spdy/core/hpack/hpack_output_stream.cc @@ -6,8 +6,8 @@ #include <utility> +#include "common/platform/api/quiche_logging.h" #include "spdy/platform/api/spdy_estimate_memory_usage.h" -#include "spdy/platform/api/spdy_logging.h" namespace spdy { diff --git a/chromium/net/third_party/quiche/src/spdy/core/hpack/hpack_static_table.cc b/chromium/net/third_party/quiche/src/spdy/core/hpack/hpack_static_table.cc index 8c8248c2343..7594943b43e 100644 --- a/chromium/net/third_party/quiche/src/spdy/core/hpack/hpack_static_table.cc +++ b/chromium/net/third_party/quiche/src/spdy/core/hpack/hpack_static_table.cc @@ -5,10 +5,10 @@ #include "spdy/core/hpack/hpack_static_table.h" #include "absl/strings/string_view.h" +#include "common/platform/api/quiche_logging.h" #include "spdy/core/hpack/hpack_constants.h" #include "spdy/core/hpack/hpack_entry.h" #include "spdy/platform/api/spdy_estimate_memory_usage.h" -#include "spdy/platform/api/spdy_logging.h" namespace spdy { diff --git a/chromium/net/third_party/quiche/src/spdy/core/http2_frame_decoder_adapter.cc b/chromium/net/third_party/quiche/src/spdy/core/http2_frame_decoder_adapter.cc index cb9c176090a..b20d0032aff 100644 --- a/chromium/net/third_party/quiche/src/spdy/core/http2_frame_decoder_adapter.cc +++ b/chromium/net/third_party/quiche/src/spdy/core/http2_frame_decoder_adapter.cc @@ -4,9 +4,9 @@ #include "spdy/core/http2_frame_decoder_adapter.h" -// Logging policy: If an error in the input is detected, SPDY_VLOG(n) is used so -// that the option exists to debug the situation. Otherwise, this code mostly -// uses SPDY_DVLOG so that the logging does not slow down production code when +// Logging policy: If an error in the input is detected, QUICHE_VLOG(n) is used +// so that the option exists to debug the situation. Otherwise, this code mostly +// uses QUICHE_DVLOG so that the logging does not slow down production code when // things are working OK. #include <stddef.h> @@ -21,6 +21,8 @@ #include "http2/decoder/http2_frame_decoder_listener.h" #include "http2/http2_constants.h" #include "http2/http2_structures.h" +#include "common/platform/api/quiche_bug_tracker.h" +#include "common/platform/api/quiche_logging.h" #include "common/quiche_endian.h" #include "spdy/core/hpack/hpack_decoder_adapter.h" #include "spdy/core/hpack/hpack_header_table.h" @@ -28,10 +30,7 @@ #include "spdy/core/spdy_header_block.h" #include "spdy/core/spdy_headers_handler_interface.h" #include "spdy/core/spdy_protocol.h" -#include "spdy/platform/api/spdy_bug_tracker.h" #include "spdy/platform/api/spdy_estimate_memory_usage.h" -#include "spdy/platform/api/spdy_flags.h" -#include "spdy/platform/api/spdy_logging.h" #include "spdy/platform/api/spdy_string_utils.h" using ::spdy::ExtensionVisitorInterface; @@ -257,7 +256,7 @@ const char* Http2DecoderAdapter::SpdyFramerErrorToString( } Http2DecoderAdapter::Http2DecoderAdapter() { - SPDY_DVLOG(1) << "Http2DecoderAdapter ctor"; + QUICHE_DVLOG(1) << "Http2DecoderAdapter ctor"; ResetInternal(); } @@ -335,7 +334,7 @@ size_t Http2DecoderAdapter::EstimateMemoryUsage() const { // This function is largely based on Http2DecoderAdapter::ValidateFrameHeader // and some parts of Http2DecoderAdapter::ProcessCommonHeader. bool Http2DecoderAdapter::OnFrameHeader(const Http2FrameHeader& header) { - SPDY_DVLOG(1) << "OnFrameHeader: " << header; + QUICHE_DVLOG(1) << "OnFrameHeader: " << header; decoded_frame_header_ = true; if (!latched_probable_http_response_) { latched_probable_http_response_ = header.IsProbableHttpResponse(); @@ -347,10 +346,10 @@ bool Http2DecoderAdapter::OnFrameHeader(const Http2FrameHeader& header) { // Report an unexpected frame error and close the connection if we // expect a known frame type (probably CONTINUATION) and receive an // unknown frame. - SPDY_VLOG(1) << "The framer was expecting to receive a " - << expected_frame_type_ - << " frame, but instead received an unknown frame of type " - << header.type; + QUICHE_VLOG(1) << "The framer was expecting to receive a " + << expected_frame_type_ + << " frame, but instead received an unknown frame of type " + << header.type; SetSpdyErrorAndNotify(SpdyFramerError::SPDY_UNEXPECTED_FRAME, ""); return false; } @@ -366,34 +365,35 @@ bool Http2DecoderAdapter::OnFrameHeader(const Http2FrameHeader& header) { visitor()->OnUnknownFrame(header.stream_id, raw_frame_type); if (!valid_stream) { // Report an invalid frame error if the stream_id is not valid. - SPDY_VLOG(1) << "Unknown control frame type " << header.type - << " received on invalid stream " << header.stream_id; + QUICHE_VLOG(1) << "Unknown control frame type " << header.type + << " received on invalid stream " << header.stream_id; SetSpdyErrorAndNotify(SpdyFramerError::SPDY_INVALID_CONTROL_FRAME, ""); return false; } else { - SPDY_DVLOG(1) << "Ignoring unknown frame type " << header.type; + QUICHE_DVLOG(1) << "Ignoring unknown frame type " << header.type; return true; } } SpdyFrameType frame_type = ToSpdyFrameType(header.type); if (!IsValidHTTP2FrameStreamId(header.stream_id, frame_type)) { - SPDY_VLOG(1) << "The framer received an invalid streamID of " - << header.stream_id << " for a frame of type " << header.type; + QUICHE_VLOG(1) << "The framer received an invalid streamID of " + << header.stream_id << " for a frame of type " + << header.type; SetSpdyErrorAndNotify(SpdyFramerError::SPDY_INVALID_STREAM_ID, ""); return false; } if (has_expected_frame_type_ && header.type != expected_frame_type_) { - SPDY_VLOG(1) << "Expected frame type " << expected_frame_type_ << ", not " - << header.type; + QUICHE_VLOG(1) << "Expected frame type " << expected_frame_type_ << ", not " + << header.type; SetSpdyErrorAndNotify(SpdyFramerError::SPDY_UNEXPECTED_FRAME, ""); return false; } if (!has_expected_frame_type_ && header.type == Http2FrameType::CONTINUATION) { - SPDY_VLOG(1) << "Got CONTINUATION frame when not expected."; + QUICHE_VLOG(1) << "Got CONTINUATION frame when not expected."; SetSpdyErrorAndNotify(SpdyFramerError::SPDY_UNEXPECTED_FRAME, ""); return false; } @@ -411,7 +411,7 @@ bool Http2DecoderAdapter::OnFrameHeader(const Http2FrameHeader& header) { } void Http2DecoderAdapter::OnDataStart(const Http2FrameHeader& header) { - SPDY_DVLOG(1) << "OnDataStart: " << header; + QUICHE_DVLOG(1) << "OnDataStart: " << header; if (IsOkToStartFrame(header) && HasRequiredStreamId(header)) { frame_header_ = header; @@ -422,14 +422,14 @@ void Http2DecoderAdapter::OnDataStart(const Http2FrameHeader& header) { } void Http2DecoderAdapter::OnDataPayload(const char* data, size_t len) { - SPDY_DVLOG(1) << "OnDataPayload: len=" << len; + QUICHE_DVLOG(1) << "OnDataPayload: len=" << len; QUICHE_DCHECK(has_frame_header_); QUICHE_DCHECK_EQ(frame_header_.type, Http2FrameType::DATA); visitor()->OnStreamFrameData(frame_header().stream_id, data, len); } void Http2DecoderAdapter::OnDataEnd() { - SPDY_DVLOG(1) << "OnDataEnd"; + QUICHE_DVLOG(1) << "OnDataEnd"; QUICHE_DCHECK(has_frame_header_); QUICHE_DCHECK_EQ(frame_header_.type, Http2FrameType::DATA); if (frame_header().IsEndStream()) { @@ -439,7 +439,7 @@ void Http2DecoderAdapter::OnDataEnd() { } void Http2DecoderAdapter::OnHeadersStart(const Http2FrameHeader& header) { - SPDY_DVLOG(1) << "OnHeadersStart: " << header; + QUICHE_DVLOG(1) << "OnHeadersStart: " << header; if (IsOkToStartFrame(header) && HasRequiredStreamId(header)) { frame_header_ = header; has_frame_header_ = true; @@ -462,7 +462,7 @@ void Http2DecoderAdapter::OnHeadersStart(const Http2FrameHeader& header) { void Http2DecoderAdapter::OnHeadersPriority( const Http2PriorityFields& priority) { - SPDY_DVLOG(1) << "OnHeadersPriority: " << priority; + QUICHE_DVLOG(1) << "OnHeadersPriority: " << priority; QUICHE_DCHECK(has_frame_header_); QUICHE_DCHECK_EQ(frame_type(), Http2FrameType::HEADERS) << frame_header_; QUICHE_DCHECK(frame_header_.HasPriority()); @@ -470,7 +470,7 @@ void Http2DecoderAdapter::OnHeadersPriority( on_headers_called_ = true; ReportReceiveCompressedFrame(frame_header_); if (!visitor()) { - SPDY_BUG(spdy_bug_1_1) + QUICHE_BUG(spdy_bug_1_1) << "Visitor is nullptr, handling priority in headers failed." << " priority:" << priority << " frame_header:" << frame_header_; return; @@ -483,7 +483,7 @@ void Http2DecoderAdapter::OnHeadersPriority( } void Http2DecoderAdapter::OnHpackFragment(const char* data, size_t len) { - SPDY_DVLOG(1) << "OnHpackFragment: len=" << len; + QUICHE_DVLOG(1) << "OnHpackFragment: len=" << len; on_hpack_fragment_called_ = true; auto* decoder = GetHpackDecoder(); if (!decoder->HandleControlFrameHeadersData(data, len)) { @@ -494,14 +494,15 @@ void Http2DecoderAdapter::OnHpackFragment(const char* data, size_t len) { } void Http2DecoderAdapter::OnHeadersEnd() { - SPDY_DVLOG(1) << "OnHeadersEnd"; + QUICHE_DVLOG(1) << "OnHeadersEnd"; CommonHpackFragmentEnd(); opt_pad_length_.reset(); } void Http2DecoderAdapter::OnPriorityFrame(const Http2FrameHeader& header, const Http2PriorityFields& priority) { - SPDY_DVLOG(1) << "OnPriorityFrame: " << header << "; priority: " << priority; + QUICHE_DVLOG(1) << "OnPriorityFrame: " << header + << "; priority: " << priority; if (IsOkToStartFrame(header) && HasRequiredStreamId(header)) { visitor()->OnPriority(header.stream_id, priority.stream_dependency, priority.weight, priority.is_exclusive); @@ -509,7 +510,7 @@ void Http2DecoderAdapter::OnPriorityFrame(const Http2FrameHeader& header, } void Http2DecoderAdapter::OnContinuationStart(const Http2FrameHeader& header) { - SPDY_DVLOG(1) << "OnContinuationStart: " << header; + QUICHE_DVLOG(1) << "OnContinuationStart: " << header; if (IsOkToStartFrame(header) && HasRequiredStreamId(header)) { QUICHE_DCHECK(has_hpack_first_frame_header_); if (header.stream_id != hpack_first_frame_header_.stream_id) { @@ -524,12 +525,12 @@ void Http2DecoderAdapter::OnContinuationStart(const Http2FrameHeader& header) { } void Http2DecoderAdapter::OnContinuationEnd() { - SPDY_DVLOG(1) << "OnContinuationEnd"; + QUICHE_DVLOG(1) << "OnContinuationEnd"; CommonHpackFragmentEnd(); } void Http2DecoderAdapter::OnPadLength(size_t trailing_length) { - SPDY_DVLOG(1) << "OnPadLength: " << trailing_length; + QUICHE_DVLOG(1) << "OnPadLength: " << trailing_length; opt_pad_length_ = trailing_length; QUICHE_DCHECK_LT(trailing_length, 256u); if (frame_header_.type == Http2FrameType::DATA) { @@ -539,7 +540,7 @@ void Http2DecoderAdapter::OnPadLength(size_t trailing_length) { void Http2DecoderAdapter::OnPadding(const char* /*padding*/, size_t skipped_length) { - SPDY_DVLOG(1) << "OnPadding: " << skipped_length; + QUICHE_DVLOG(1) << "OnPadding: " << skipped_length; if (frame_header_.type == Http2FrameType::DATA) { visitor()->OnStreamPadding(stream_id(), skipped_length); } else { @@ -549,7 +550,7 @@ void Http2DecoderAdapter::OnPadding(const char* /*padding*/, void Http2DecoderAdapter::OnRstStream(const Http2FrameHeader& header, Http2ErrorCode http2_error_code) { - SPDY_DVLOG(1) << "OnRstStream: " << header << "; code=" << http2_error_code; + QUICHE_DVLOG(1) << "OnRstStream: " << header << "; code=" << http2_error_code; if (IsOkToStartFrame(header) && HasRequiredStreamId(header)) { SpdyErrorCode error_code = ParseErrorCode(static_cast<uint32_t>(http2_error_code)); @@ -558,7 +559,7 @@ void Http2DecoderAdapter::OnRstStream(const Http2FrameHeader& header, } void Http2DecoderAdapter::OnSettingsStart(const Http2FrameHeader& header) { - SPDY_DVLOG(1) << "OnSettingsStart: " << header; + QUICHE_DVLOG(1) << "OnSettingsStart: " << header; if (IsOkToStartFrame(header) && HasRequiredStreamIdZero(header)) { frame_header_ = header; has_frame_header_ = true; @@ -567,7 +568,7 @@ void Http2DecoderAdapter::OnSettingsStart(const Http2FrameHeader& header) { } void Http2DecoderAdapter::OnSetting(const Http2SettingFields& setting_fields) { - SPDY_DVLOG(1) << "OnSetting: " << setting_fields; + QUICHE_DVLOG(1) << "OnSetting: " << setting_fields; const auto parameter = static_cast<SpdySettingsId>(setting_fields.parameter); visitor()->OnSetting(parameter, setting_fields.value); if (extension_ != nullptr) { @@ -576,12 +577,12 @@ void Http2DecoderAdapter::OnSetting(const Http2SettingFields& setting_fields) { } void Http2DecoderAdapter::OnSettingsEnd() { - SPDY_DVLOG(1) << "OnSettingsEnd"; + QUICHE_DVLOG(1) << "OnSettingsEnd"; visitor()->OnSettingsEnd(); } void Http2DecoderAdapter::OnSettingsAck(const Http2FrameHeader& header) { - SPDY_DVLOG(1) << "OnSettingsAck: " << header; + QUICHE_DVLOG(1) << "OnSettingsAck: " << header; if (IsOkToStartFrame(header) && HasRequiredStreamIdZero(header)) { visitor()->OnSettingsAck(); } @@ -591,8 +592,9 @@ void Http2DecoderAdapter::OnPushPromiseStart( const Http2FrameHeader& header, const Http2PushPromiseFields& promise, size_t total_padding_length) { - SPDY_DVLOG(1) << "OnPushPromiseStart: " << header << "; promise: " << promise - << "; total_padding_length: " << total_padding_length; + QUICHE_DVLOG(1) << "OnPushPromiseStart: " << header + << "; promise: " << promise + << "; total_padding_length: " << total_padding_length; if (IsOkToStartFrame(header) && HasRequiredStreamId(header)) { if (promise.promised_stream_id == 0) { SetSpdyErrorAndNotify(SpdyFramerError::SPDY_INVALID_CONTROL_FRAME, ""); @@ -608,14 +610,14 @@ void Http2DecoderAdapter::OnPushPromiseStart( } void Http2DecoderAdapter::OnPushPromiseEnd() { - SPDY_DVLOG(1) << "OnPushPromiseEnd"; + QUICHE_DVLOG(1) << "OnPushPromiseEnd"; CommonHpackFragmentEnd(); opt_pad_length_.reset(); } void Http2DecoderAdapter::OnPing(const Http2FrameHeader& header, const Http2PingFields& ping) { - SPDY_DVLOG(1) << "OnPing: " << header << "; ping: " << ping; + QUICHE_DVLOG(1) << "OnPing: " << header << "; ping: " << ping; if (IsOkToStartFrame(header) && HasRequiredStreamIdZero(header)) { visitor()->OnPing(ToSpdyPingId(ping), false); } @@ -623,7 +625,7 @@ void Http2DecoderAdapter::OnPing(const Http2FrameHeader& header, void Http2DecoderAdapter::OnPingAck(const Http2FrameHeader& header, const Http2PingFields& ping) { - SPDY_DVLOG(1) << "OnPingAck: " << header << "; ping: " << ping; + QUICHE_DVLOG(1) << "OnPingAck: " << header << "; ping: " << ping; if (IsOkToStartFrame(header) && HasRequiredStreamIdZero(header)) { visitor()->OnPing(ToSpdyPingId(ping), true); } @@ -631,7 +633,7 @@ void Http2DecoderAdapter::OnPingAck(const Http2FrameHeader& header, void Http2DecoderAdapter::OnGoAwayStart(const Http2FrameHeader& header, const Http2GoAwayFields& goaway) { - SPDY_DVLOG(1) << "OnGoAwayStart: " << header << "; goaway: " << goaway; + QUICHE_DVLOG(1) << "OnGoAwayStart: " << header << "; goaway: " << goaway; if (IsOkToStartFrame(header) && HasRequiredStreamIdZero(header)) { frame_header_ = header; has_frame_header_ = true; @@ -642,18 +644,19 @@ void Http2DecoderAdapter::OnGoAwayStart(const Http2FrameHeader& header, } void Http2DecoderAdapter::OnGoAwayOpaqueData(const char* data, size_t len) { - SPDY_DVLOG(1) << "OnGoAwayOpaqueData: len=" << len; + QUICHE_DVLOG(1) << "OnGoAwayOpaqueData: len=" << len; visitor()->OnGoAwayFrameData(data, len); } void Http2DecoderAdapter::OnGoAwayEnd() { - SPDY_DVLOG(1) << "OnGoAwayEnd"; + QUICHE_DVLOG(1) << "OnGoAwayEnd"; visitor()->OnGoAwayFrameData(nullptr, 0); } void Http2DecoderAdapter::OnWindowUpdate(const Http2FrameHeader& header, uint32_t increment) { - SPDY_DVLOG(1) << "OnWindowUpdate: " << header << "; increment=" << increment; + QUICHE_DVLOG(1) << "OnWindowUpdate: " << header + << "; increment=" << increment; if (IsOkToStartFrame(header)) { visitor()->OnWindowUpdate(header.stream_id, increment); } @@ -666,9 +669,9 @@ void Http2DecoderAdapter::OnWindowUpdate(const Http2FrameHeader& header, void Http2DecoderAdapter::OnAltSvcStart(const Http2FrameHeader& header, size_t origin_length, size_t value_length) { - SPDY_DVLOG(1) << "OnAltSvcStart: " << header - << "; origin_length: " << origin_length - << "; value_length: " << value_length; + QUICHE_DVLOG(1) << "OnAltSvcStart: " << header + << "; origin_length: " << origin_length + << "; value_length: " << value_length; if (!IsOkToStartFrame(header)) { return; } @@ -679,24 +682,24 @@ void Http2DecoderAdapter::OnAltSvcStart(const Http2FrameHeader& header, } void Http2DecoderAdapter::OnAltSvcOriginData(const char* data, size_t len) { - SPDY_DVLOG(1) << "OnAltSvcOriginData: len=" << len; + QUICHE_DVLOG(1) << "OnAltSvcOriginData: len=" << len; alt_svc_origin_.append(data, len); } // Called when decoding the Alt-Svc-Field-Value of an ALTSVC; // the field is uninterpreted. void Http2DecoderAdapter::OnAltSvcValueData(const char* data, size_t len) { - SPDY_DVLOG(1) << "OnAltSvcValueData: len=" << len; + QUICHE_DVLOG(1) << "OnAltSvcValueData: len=" << len; alt_svc_value_.append(data, len); } void Http2DecoderAdapter::OnAltSvcEnd() { - SPDY_DVLOG(1) << "OnAltSvcEnd: origin.size(): " << alt_svc_origin_.size() - << "; value.size(): " << alt_svc_value_.size(); + QUICHE_DVLOG(1) << "OnAltSvcEnd: origin.size(): " << alt_svc_origin_.size() + << "; value.size(): " << alt_svc_value_.size(); SpdyAltSvcWireFormat::AlternativeServiceVector altsvc_vector; if (!SpdyAltSvcWireFormat::ParseHeaderFieldValue(alt_svc_value_, &altsvc_vector)) { - SPDY_DLOG(ERROR) << "SpdyAltSvcWireFormat::ParseHeaderFieldValue failed."; + QUICHE_DLOG(ERROR) << "SpdyAltSvcWireFormat::ParseHeaderFieldValue failed."; SetSpdyErrorAndNotify(SpdyFramerError::SPDY_INVALID_CONTROL_FRAME, ""); return; } @@ -711,9 +714,9 @@ void Http2DecoderAdapter::OnAltSvcEnd() { void Http2DecoderAdapter::OnPriorityUpdateStart( const Http2FrameHeader& header, const Http2PriorityUpdateFields& priority_update) { - SPDY_DVLOG(1) << "OnPriorityUpdateStart: " << header - << "; prioritized_stream_id: " - << priority_update.prioritized_stream_id; + QUICHE_DVLOG(1) << "OnPriorityUpdateStart: " << header + << "; prioritized_stream_id: " + << priority_update.prioritized_stream_id; if (IsOkToStartFrame(header) && HasRequiredStreamIdZero(header) && HasRequiredStreamId(priority_update.prioritized_stream_id)) { frame_header_ = header; @@ -724,13 +727,13 @@ void Http2DecoderAdapter::OnPriorityUpdateStart( void Http2DecoderAdapter::OnPriorityUpdatePayload(const char* data, size_t len) { - SPDY_DVLOG(1) << "OnPriorityUpdatePayload: len=" << len; + QUICHE_DVLOG(1) << "OnPriorityUpdatePayload: len=" << len; priority_field_value_.append(data, len); } void Http2DecoderAdapter::OnPriorityUpdateEnd() { - SPDY_DVLOG(1) << "OnPriorityUpdateEnd: priority_field_value.size(): " - << priority_field_value_.size(); + QUICHE_DVLOG(1) << "OnPriorityUpdateEnd: priority_field_value.size(): " + << priority_field_value_.size(); visitor()->OnPriorityUpdate(prioritized_stream_id_, priority_field_value_); priority_field_value_.clear(); } @@ -738,7 +741,7 @@ void Http2DecoderAdapter::OnPriorityUpdateEnd() { // Except for BLOCKED frames, all other unknown frames are either dropped or // passed to a registered extension. void Http2DecoderAdapter::OnUnknownStart(const Http2FrameHeader& header) { - SPDY_DVLOG(1) << "OnUnknownStart: " << header; + QUICHE_DVLOG(1) << "OnUnknownStart: " << header; if (IsOkToStartFrame(header)) { if (extension_ != nullptr) { const uint8_t type = static_cast<uint8_t>(header.type); @@ -753,19 +756,19 @@ void Http2DecoderAdapter::OnUnknownPayload(const char* data, size_t len) { if (handling_extension_payload_) { extension_->OnFramePayload(data, len); } else { - SPDY_DVLOG(1) << "OnUnknownPayload: len=" << len; + QUICHE_DVLOG(1) << "OnUnknownPayload: len=" << len; } } void Http2DecoderAdapter::OnUnknownEnd() { - SPDY_DVLOG(1) << "OnUnknownEnd"; + QUICHE_DVLOG(1) << "OnUnknownEnd"; handling_extension_payload_ = false; } void Http2DecoderAdapter::OnPaddingTooLong(const Http2FrameHeader& header, size_t missing_length) { - SPDY_DVLOG(1) << "OnPaddingTooLong: " << header - << "; missing_length: " << missing_length; + QUICHE_DVLOG(1) << "OnPaddingTooLong: " << header + << "; missing_length: " << missing_length; if (header.type == Http2FrameType::DATA) { if (header.payload_length == 0) { QUICHE_DCHECK_EQ(1u, missing_length); @@ -778,7 +781,7 @@ void Http2DecoderAdapter::OnPaddingTooLong(const Http2FrameHeader& header, } void Http2DecoderAdapter::OnFrameSizeError(const Http2FrameHeader& header) { - SPDY_DVLOG(1) << "OnFrameSizeError: " << header; + QUICHE_DVLOG(1) << "OnFrameSizeError: " << header; size_t recv_limit = recv_frame_size_limit_; if (header.payload_length > recv_limit) { SetSpdyErrorAndNotify(SpdyFramerError::SPDY_OVERSIZED_PAYLOAD, ""); @@ -809,8 +812,8 @@ size_t Http2DecoderAdapter::ProcessInputFrame(const char* data, size_t len) { if (spdy_state_ != SpdyState::SPDY_ERROR) { DetermineSpdyState(status); } else { - SPDY_VLOG(1) << "ProcessInputFrame spdy_framer_error_=" - << SpdyFramerErrorToString(spdy_framer_error_); + QUICHE_VLOG(1) << "ProcessInputFrame spdy_framer_error_=" + << SpdyFramerErrorToString(spdy_framer_error_); if (spdy_framer_error_ == SpdyFramerError::SPDY_INVALID_PADDING && has_frame_header_ && frame_type() != Http2FrameType::DATA) { // spdy_framer_test checks that all of the available frame payload @@ -818,11 +821,11 @@ size_t Http2DecoderAdapter::ProcessInputFrame(const char* data, size_t len) { size_t total = remaining_total_payload(); if (total <= frame_header().payload_length) { size_t avail = db.MinLengthRemaining(total); - SPDY_VLOG(1) << "Skipping past " << avail << " bytes, of " << total - << " total remaining in the frame's payload."; + QUICHE_VLOG(1) << "Skipping past " << avail << " bytes, of " << total + << " total remaining in the frame's payload."; db.AdvanceCursor(avail); } else { - SPDY_BUG(spdy_bug_1_2) + QUICHE_BUG(spdy_bug_1_2) << "Total remaining (" << total << ") should not be greater than the payload length; " << frame_header(); @@ -841,11 +844,11 @@ void Http2DecoderAdapter::DetermineSpdyState(DecodeStatus status) { QUICHE_DCHECK(!HasError()) << spdy_framer_error_; switch (status) { case DecodeStatus::kDecodeDone: - SPDY_DVLOG(1) << "ProcessInputFrame -> DecodeStatus::kDecodeDone"; + QUICHE_DVLOG(1) << "ProcessInputFrame -> DecodeStatus::kDecodeDone"; ResetBetweenFrames(); break; case DecodeStatus::kDecodeInProgress: - SPDY_DVLOG(1) << "ProcessInputFrame -> DecodeStatus::kDecodeInProgress"; + QUICHE_DVLOG(1) << "ProcessInputFrame -> DecodeStatus::kDecodeInProgress"; if (decoded_frame_header_) { if (IsDiscardingPayload()) { set_spdy_state(SpdyState::SPDY_IGNORE_REMAINING_PAYLOAD); @@ -865,7 +868,7 @@ void Http2DecoderAdapter::DetermineSpdyState(DecodeStatus status) { } break; case DecodeStatus::kDecodeError: - SPDY_VLOG(1) << "ProcessInputFrame -> DecodeStatus::kDecodeError"; + QUICHE_VLOG(1) << "ProcessInputFrame -> DecodeStatus::kDecodeError"; if (IsDiscardingPayload()) { if (remaining_total_payload() == 0) { // Push the Http2FrameDecoder out of state kDiscardPayload now @@ -873,11 +876,11 @@ void Http2DecoderAdapter::DetermineSpdyState(DecodeStatus status) { DecodeBuffer tmp("", 0); DecodeStatus status = frame_decoder_->DecodeFrame(&tmp); if (status != DecodeStatus::kDecodeDone) { - SPDY_BUG(spdy_bug_1_3) + QUICHE_BUG(spdy_bug_1_3) << "Expected to be done decoding the frame, not " << status; SetSpdyErrorAndNotify(SPDY_INTERNAL_FRAMER_ERROR, ""); } else if (spdy_framer_error_ != SPDY_NO_ERROR) { - SPDY_BUG(spdy_bug_1_4) + QUICHE_BUG(spdy_bug_1_4) << "Expected to have no error, not " << SpdyFramerErrorToString(spdy_framer_error_); } else { @@ -921,7 +924,7 @@ void Http2DecoderAdapter::ResetInternal() { } void Http2DecoderAdapter::set_spdy_state(SpdyState v) { - SPDY_DVLOG(2) << "set_spdy_state(" << StateToString(v) << ")"; + QUICHE_DVLOG(2) << "set_spdy_state(" << StateToString(v) << ")"; spdy_state_ = v; } @@ -930,8 +933,8 @@ void Http2DecoderAdapter::SetSpdyErrorAndNotify(SpdyFramerError error, if (HasError()) { QUICHE_DCHECK_EQ(spdy_state_, SpdyState::SPDY_ERROR); } else { - SPDY_VLOG(2) << "SetSpdyErrorAndNotify(" << SpdyFramerErrorToString(error) - << ")"; + QUICHE_VLOG(2) << "SetSpdyErrorAndNotify(" << SpdyFramerErrorToString(error) + << ")"; QUICHE_DCHECK_NE(error, SpdyFramerError::SPDY_NO_ERROR); spdy_framer_error_ = error; set_spdy_state(SpdyState::SPDY_ERROR); @@ -974,33 +977,33 @@ size_t Http2DecoderAdapter::remaining_total_payload() const { bool Http2DecoderAdapter::IsReadingPaddingLength() { bool result = frame_header_.IsPadded() && !opt_pad_length_; - SPDY_DVLOG(2) << "Http2DecoderAdapter::IsReadingPaddingLength: " << result; + QUICHE_DVLOG(2) << "Http2DecoderAdapter::IsReadingPaddingLength: " << result; return result; } bool Http2DecoderAdapter::IsSkippingPadding() { bool result = frame_header_.IsPadded() && opt_pad_length_ && frame_decoder_->remaining_payload() == 0 && frame_decoder_->remaining_padding() > 0; - SPDY_DVLOG(2) << "Http2DecoderAdapter::IsSkippingPadding: " << result; + QUICHE_DVLOG(2) << "Http2DecoderAdapter::IsSkippingPadding: " << result; return result; } bool Http2DecoderAdapter::IsDiscardingPayload() { bool result = decoded_frame_header_ && frame_decoder_->IsDiscardingPayload(); - SPDY_DVLOG(2) << "Http2DecoderAdapter::IsDiscardingPayload: " << result; + QUICHE_DVLOG(2) << "Http2DecoderAdapter::IsDiscardingPayload: " << result; return result; } // Called from OnXyz or OnXyzStart methods to decide whether it is OK to // handle the callback. bool Http2DecoderAdapter::IsOkToStartFrame(const Http2FrameHeader& header) { - SPDY_DVLOG(3) << "IsOkToStartFrame"; + QUICHE_DVLOG(3) << "IsOkToStartFrame"; if (HasError()) { - SPDY_VLOG(2) << "HasError()"; + QUICHE_VLOG(2) << "HasError()"; return false; } QUICHE_DCHECK(!has_frame_header_); if (has_expected_frame_type_ && header.type != expected_frame_type_) { - SPDY_VLOG(1) << "Expected frame type " << expected_frame_type_ << ", not " - << header.type; + QUICHE_VLOG(1) << "Expected frame type " << expected_frame_type_ << ", not " + << header.type; SetSpdyErrorAndNotify(SpdyFramerError::SPDY_UNEXPECTED_FRAME, ""); return false; } @@ -1009,15 +1012,15 @@ bool Http2DecoderAdapter::IsOkToStartFrame(const Http2FrameHeader& header) { } bool Http2DecoderAdapter::HasRequiredStreamId(uint32_t stream_id) { - SPDY_DVLOG(3) << "HasRequiredStreamId: " << stream_id; + QUICHE_DVLOG(3) << "HasRequiredStreamId: " << stream_id; if (HasError()) { - SPDY_VLOG(2) << "HasError()"; + QUICHE_VLOG(2) << "HasError()"; return false; } if (stream_id != 0) { return true; } - SPDY_VLOG(1) << "Stream Id is required, but zero provided"; + QUICHE_VLOG(1) << "Stream Id is required, but zero provided"; SetSpdyErrorAndNotify(SpdyFramerError::SPDY_INVALID_STREAM_ID, ""); return false; } @@ -1027,15 +1030,15 @@ bool Http2DecoderAdapter::HasRequiredStreamId(const Http2FrameHeader& header) { } bool Http2DecoderAdapter::HasRequiredStreamIdZero(uint32_t stream_id) { - SPDY_DVLOG(3) << "HasRequiredStreamIdZero: " << stream_id; + QUICHE_DVLOG(3) << "HasRequiredStreamIdZero: " << stream_id; if (HasError()) { - SPDY_VLOG(2) << "HasError()"; + QUICHE_VLOG(2) << "HasError()"; return false; } if (stream_id == 0) { return true; } - SPDY_VLOG(1) << "Stream Id was not zero, as required: " << stream_id; + QUICHE_VLOG(1) << "Stream Id was not zero, as required: " << stream_id; SetSpdyErrorAndNotify(SpdyFramerError::SPDY_INVALID_STREAM_ID, ""); return false; } @@ -1062,7 +1065,7 @@ HpackDecoderAdapter* Http2DecoderAdapter::GetHpackDecoder() { } void Http2DecoderAdapter::CommonStartHpackBlock() { - SPDY_DVLOG(1) << "CommonStartHpackBlock"; + QUICHE_DVLOG(1) << "CommonStartHpackBlock"; QUICHE_DCHECK(!has_hpack_first_frame_header_); if (!frame_header_.IsEndHeaders()) { hpack_first_frame_header_ = frame_header_; @@ -1074,7 +1077,7 @@ void Http2DecoderAdapter::CommonStartHpackBlock() { SpdyHeadersHandlerInterface* handler = visitor()->OnHeaderFrameStart(stream_id()); if (handler == nullptr) { - SPDY_BUG(spdy_bug_1_5) << "visitor_->OnHeaderFrameStart returned nullptr"; + QUICHE_BUG(spdy_bug_1_5) << "visitor_->OnHeaderFrameStart returned nullptr"; SetSpdyErrorAndNotify(SpdyFramerError::SPDY_INTERNAL_FRAMER_ERROR, ""); return; } @@ -1091,9 +1094,9 @@ void Http2DecoderAdapter::MaybeAnnounceEmptyFirstHpackFragment() { } void Http2DecoderAdapter::CommonHpackFragmentEnd() { - SPDY_DVLOG(1) << "CommonHpackFragmentEnd: stream_id=" << stream_id(); + QUICHE_DVLOG(1) << "CommonHpackFragmentEnd: stream_id=" << stream_id(); if (HasError()) { - SPDY_VLOG(1) << "HasError(), returning"; + QUICHE_VLOG(1) << "HasError(), returning"; return; } QUICHE_DCHECK(has_frame_header_); diff --git a/chromium/net/third_party/quiche/src/spdy/core/http2_priority_write_scheduler.h b/chromium/net/third_party/quiche/src/spdy/core/http2_priority_write_scheduler.h deleted file mode 100644 index 5820145aac4..00000000000 --- a/chromium/net/third_party/quiche/src/spdy/core/http2_priority_write_scheduler.h +++ /dev/null @@ -1,791 +0,0 @@ -// Copyright (c) 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_SPDY_CORE_HTTP2_PRIORITY_WRITE_SCHEDULER_H_ -#define QUICHE_SPDY_CORE_HTTP2_PRIORITY_WRITE_SCHEDULER_H_ - -#include <cstdint> -#include <deque> -#include <map> -#include <memory> -#include <queue> -#include <set> -#include <string> -#include <tuple> -#include <unordered_map> -#include <utility> -#include <vector> - -#include "absl/strings/str_cat.h" -#include "spdy/core/spdy_intrusive_list.h" -#include "spdy/core/spdy_protocol.h" -#include "spdy/core/write_scheduler.h" -#include "spdy/platform/api/spdy_bug_tracker.h" -#include "spdy/platform/api/spdy_containers.h" -#include "spdy/platform/api/spdy_logging.h" -#include "spdy/platform/api/spdy_string_utils.h" - -namespace spdy { - -namespace test { -template <typename StreamIdType> -class Http2PriorityWriteSchedulerPeer; -} - -// This data structure implements the HTTP/2 stream priority tree defined in -// section 5.3 of RFC 7540: -// http://tools.ietf.org/html/rfc7540#section-5.3 -// -// Streams can be added and removed, and dependencies between them defined. -// Streams constitute a tree rooted at stream ID 0: each stream has a single -// parent stream, and 0 or more child streams. Individual streams can be -// marked as ready to read/write, and then the whole structure can be queried -// to pick the next stream to read/write out of those that are ready. -template <typename StreamIdType> -class Http2PriorityWriteScheduler : public WriteScheduler<StreamIdType> { - public: - using typename WriteScheduler<StreamIdType>::StreamPrecedenceType; - - Http2PriorityWriteScheduler(); - Http2PriorityWriteScheduler(const Http2PriorityWriteScheduler&) = delete; - Http2PriorityWriteScheduler& operator=(const Http2PriorityWriteScheduler&) = - delete; - - // WriteScheduler methods - void RegisterStream(StreamIdType stream_id, - const StreamPrecedenceType& precedence) override; - void UnregisterStream(StreamIdType stream_id) override; - bool StreamRegistered(StreamIdType stream_id) const override; - StreamPrecedenceType GetStreamPrecedence( - StreamIdType stream_id) const override; - void UpdateStreamPrecedence(StreamIdType stream_id, - const StreamPrecedenceType& precedence) override; - std::vector<StreamIdType> GetStreamChildren( - StreamIdType stream_id) const override; - void RecordStreamEventTime(StreamIdType stream_id, - int64_t now_in_usec) override; - int64_t GetLatestEventWithPrecedence(StreamIdType stream_id) const override; - bool ShouldYield(StreamIdType stream_id) const override; - void MarkStreamReady(StreamIdType stream_id, bool add_to_front) override; - void MarkStreamNotReady(StreamIdType stream_id) override; - bool HasReadyStreams() const override; - StreamIdType PopNextReadyStream() override; - std::tuple<StreamIdType, StreamPrecedenceType> - PopNextReadyStreamAndPrecedence() override; - size_t NumReadyStreams() const override; - bool IsStreamReady(StreamIdType stream_id) const override; - size_t NumRegisteredStreams() const override; - std::string DebugString() const override; - - private: - friend class test::Http2PriorityWriteSchedulerPeer<StreamIdType>; - - struct StreamInfo; - using StreamInfoVector = absl::InlinedVector<StreamInfo*, 4>; - - struct StreamInfo : public SpdyIntrusiveLink<StreamInfo> { - // ID for this stream. - StreamIdType id; - // StreamInfo for parent stream. - StreamInfo* parent = nullptr; - // Weights can range between 1 and 256 (inclusive). - int weight = kHttp2DefaultStreamWeight; - // The total weight of this stream's direct descendants. - int total_child_weights = 0; - // Pointers to StreamInfos for children, if any. - StreamInfoVector children; - // Whether the stream is ready for writing. The stream is present in - // scheduling_queue_ iff true. - bool ready = false; - // The scheduling priority of this stream. Streams with higher priority - // values are scheduled first. - // TODO(mpw): rename to avoid confusion with SPDY priorities, - // which this is not. - float priority = 0; - // Ordinal value for this stream, used to ensure round-robin scheduling: - // among streams with the same scheduling priority, streams with lower - // ordinal are scheduled first. - int64_t ordinal = 0; - // Time of latest write event for stream of this priority, in microseconds. - int64_t last_event_time_usec = 0; - - // Returns true if this stream is ancestor of |other|. - bool IsAncestorOf(const StreamInfo& other) const { - for (const StreamInfo* p = other.parent; p != nullptr; p = p->parent) { - if (p == this) { - return true; - } - } - return false; - } - - // Whether this stream should be scheduled ahead of another stream. - bool SchedulesBefore(const StreamInfo& other) const { - return (priority != other.priority) ? priority > other.priority - : ordinal < other.ordinal; - } - - // Returns the StreamPrecedenceType for this StreamInfo. - StreamPrecedenceType ToStreamPrecedence() const { - StreamIdType parent_id = - parent == nullptr ? kHttp2RootStreamId : parent->id; - bool exclusive = parent != nullptr && parent->children.size() == 1; - return StreamPrecedenceType(parent_id, weight, exclusive); - } - }; - - static bool Remove(StreamInfoVector* stream_infos, - const StreamInfo* stream_info); - - // Returns true iff any direct or transitive parent of the given stream is - // currently ready. - static bool HasReadyAncestor(const StreamInfo& stream_info); - - // Returns StreamInfo for the given stream, or nullptr if it isn't - // registered. - const StreamInfo* FindStream(StreamIdType stream_id) const; - StreamInfo* FindStream(StreamIdType stream_id); - - // Helpers for UpdateStreamPrecedence(). - void UpdateStreamParent(StreamInfo* stream_info, - StreamIdType parent_id, - bool exclusive); - void UpdateStreamWeight(StreamInfo* stream_info, int weight); - - // Update all priority values in the subtree rooted at the given stream, not - // including the stream itself. If this results in priority value changes for - // scheduled streams, those streams are rescheduled to ensure proper ordering - // of scheduling_queue_. - // TODO(mpw): rename to avoid confusion with SPDY priorities. - void UpdatePrioritiesUnder(StreamInfo* stream_info); - - // Inserts stream into scheduling_queue_ at the appropriate location given - // its priority and ordinal. Time complexity is O(scheduling_queue.size()). - void Schedule(StreamInfo* stream_info); - - // Removes stream from scheduling_queue_. - void Unschedule(StreamInfo* stream_info); - - // Return true if all internal invariants hold (useful for unit tests). - // Unless there are bugs, this should always return true. - bool ValidateInvariantsForTests() const; - - // Returns true if the parent stream has the given stream in its children. - bool StreamHasChild(const StreamInfo& parent_info, - const StreamInfo* child_info) const; - - // Pointee owned by all_stream_infos_. - StreamInfo* root_stream_info_; - // Maps from stream IDs to StreamInfo objects. - SpdySmallMap<StreamIdType, std::unique_ptr<StreamInfo>, 10> all_stream_infos_; - // Queue containing all ready streams, ordered with streams of higher - // priority before streams of lower priority, and, among streams of equal - // priority, streams with lower ordinal before those with higher - // ordinal. Note that not all streams in scheduling_queue_ are eligible to be - // picked as the next stream: some may have ancestor stream(s) that are ready - // and unblocked. In these situations the occluded child streams are left in - // the queue, to reduce churn. - SpdyIntrusiveList<StreamInfo> scheduling_queue_; - // Ordinal value to assign to next node inserted into scheduling_queue_ when - // |add_to_front == true|. Decremented after each assignment. - int64_t head_ordinal_ = -1; - // Ordinal value to assign to next node inserted into scheduling_queue_ when - // |add_to_front == false|. Incremented after each assignment. - int64_t tail_ordinal_ = 0; -}; - -template <typename StreamIdType> -Http2PriorityWriteScheduler<StreamIdType>::Http2PriorityWriteScheduler() { - auto root_stream_info = std::make_unique<StreamInfo>(); - root_stream_info_ = root_stream_info.get(); - root_stream_info->id = kHttp2RootStreamId; - root_stream_info->weight = kHttp2DefaultStreamWeight; - root_stream_info->parent = nullptr; - root_stream_info->priority = 1.0; - root_stream_info->ready = false; - all_stream_infos_[kHttp2RootStreamId] = std::move(root_stream_info); -} - -template <typename StreamIdType> -bool Http2PriorityWriteScheduler<StreamIdType>::StreamRegistered( - StreamIdType stream_id) const { - return all_stream_infos_.find(stream_id) != all_stream_infos_.end(); -} - -template <typename StreamIdType> -void Http2PriorityWriteScheduler<StreamIdType>::RegisterStream( - StreamIdType stream_id, - const StreamPrecedenceType& precedence) { - // TODO(mpw): uncomment the SPDY_BUG_IF below once all tests - // (e.g. SpdyClientDispatcher) modified to pass StreamPrecedence instances - // appropriate for protocol version under test. - // - // SPDY_BUG_IF(spdy_bug_8_1, precedence.is_spdy3_priority()) - // << "Expected HTTP/2 stream dependency"; - - if (StreamRegistered(stream_id)) { - SPDY_BUG(spdy_bug_8_2) << "Stream " << stream_id << " already registered"; - return; - } - - StreamInfo* parent = FindStream(precedence.parent_id()); - if (parent == nullptr) { - // parent_id may legitimately not be registered yet--see b/15676312. - SPDY_VLOG(1) << "Parent stream " << precedence.parent_id() - << " not registered"; - parent = root_stream_info_; - } - - auto new_stream_info = std::make_unique<StreamInfo>(); - StreamInfo* new_stream_info_ptr = new_stream_info.get(); - new_stream_info_ptr->id = stream_id; - new_stream_info_ptr->weight = precedence.weight(); - new_stream_info_ptr->parent = parent; - all_stream_infos_[stream_id] = std::move(new_stream_info); - if (precedence.is_exclusive()) { - // Move the parent's current children below the new stream. - using std::swap; - swap(new_stream_info_ptr->children, parent->children); - new_stream_info_ptr->total_child_weights = parent->total_child_weights; - // Update each child's parent. - for (StreamInfo* child : new_stream_info_ptr->children) { - child->parent = new_stream_info_ptr; - } - // Clear parent's old child data. - QUICHE_DCHECK(parent->children.empty()); - parent->total_child_weights = 0; - } - // Add new stream to parent. - parent->children.push_back(new_stream_info_ptr); - parent->total_child_weights += precedence.weight(); - - // Update all priorities under parent, since addition of a stream affects - // sibling priorities as well. - UpdatePrioritiesUnder(parent); - - // Stream starts with ready == false, so no need to schedule it yet. - QUICHE_DCHECK(!new_stream_info_ptr->ready); -} - -template <typename StreamIdType> -void Http2PriorityWriteScheduler<StreamIdType>::UnregisterStream( - StreamIdType stream_id) { - if (stream_id == kHttp2RootStreamId) { - SPDY_BUG(spdy_bug_8_3) << "Cannot unregister root stream"; - return; - } - // Remove the stream from table. - auto it = all_stream_infos_.find(stream_id); - if (it == all_stream_infos_.end()) { - SPDY_BUG(spdy_bug_8_4) << "Stream " << stream_id << " not registered"; - return; - } - std::unique_ptr<StreamInfo> stream_info(std::move(it->second)); - all_stream_infos_.erase(it); - // If ready (and hence scheduled), unschedule. - if (stream_info->ready) { - Unschedule(stream_info.get()); - } - - StreamInfo* parent = stream_info->parent; - // Remove the stream from parent's child list. - Remove(&parent->children, stream_info.get()); - parent->total_child_weights -= stream_info->weight; - - // Move the stream's children to the parent's child list. - // Update each child's parent and weight. - for (StreamInfo* child : stream_info->children) { - child->parent = parent; - parent->children.push_back(child); - // Divide the removed stream's weight among its children, rounding to the - // nearest valid weight. - float float_weight = stream_info->weight * - static_cast<float>(child->weight) / - static_cast<float>(stream_info->total_child_weights); - int new_weight = floor(float_weight + 0.5); - if (new_weight == 0) { - new_weight = 1; - } - child->weight = new_weight; - parent->total_child_weights += child->weight; - } - UpdatePrioritiesUnder(parent); -} - -template <typename StreamIdType> -typename Http2PriorityWriteScheduler<StreamIdType>::StreamPrecedenceType -Http2PriorityWriteScheduler<StreamIdType>::GetStreamPrecedence( - StreamIdType stream_id) const { - const StreamInfo* stream_info = FindStream(stream_id); - if (stream_info == nullptr) { - // Unknown streams tolerated due to b/15676312. However, return lowest - // weight. - SPDY_VLOG(1) << "Stream " << stream_id << " not registered"; - return StreamPrecedenceType(kHttp2RootStreamId, kHttp2MinStreamWeight, - false); - } - return stream_info->ToStreamPrecedence(); -} - -template <typename StreamIdType> -std::vector<StreamIdType> -Http2PriorityWriteScheduler<StreamIdType>::GetStreamChildren( - StreamIdType stream_id) const { - std::vector<StreamIdType> child_vec; - const StreamInfo* stream_info = FindStream(stream_id); - if (stream_info == nullptr) { - SPDY_BUG(spdy_bug_8_5) << "Stream " << stream_id << " not registered"; - } else { - child_vec.reserve(stream_info->children.size()); - for (StreamInfo* child : stream_info->children) { - child_vec.push_back(child->id); - } - } - return child_vec; -} - -template <typename StreamIdType> -void Http2PriorityWriteScheduler<StreamIdType>::UpdateStreamPrecedence( - StreamIdType stream_id, - const StreamPrecedenceType& precedence) { - // TODO(mpw): uncomment the SPDY_BUG_IF below once all tests - // (e.g. SpdyClientDispatcher) modified to pass StreamPrecedence instances - // appropriate for protocol version under test. - // - // SPDY_BUG_IF(spdy_bug_8_6, precedence.is_spdy3_priority()) - // << "Expected HTTP/2 stream dependency"; - if (stream_id == kHttp2RootStreamId) { - SPDY_BUG(spdy_bug_8_7) << "Cannot set precedence of root stream"; - return; - } - - StreamInfo* stream_info = FindStream(stream_id); - if (stream_info == nullptr) { - // TODO(mpw): add to all_stream_infos_ on demand--see b/15676312. - SPDY_VLOG(1) << "Stream " << stream_id << " not registered"; - return; - } - UpdateStreamParent(stream_info, precedence.parent_id(), - precedence.is_exclusive()); - UpdateStreamWeight(stream_info, precedence.weight()); -} - -template <typename StreamIdType> -void Http2PriorityWriteScheduler<StreamIdType>::UpdateStreamWeight( - StreamInfo* stream_info, - int weight) { - if (weight == stream_info->weight) { - return; - } - if (stream_info->parent != nullptr) { - stream_info->parent->total_child_weights += (weight - stream_info->weight); - } - stream_info->weight = weight; - - // Change in weight also affects sibling priorities. - UpdatePrioritiesUnder(stream_info->parent); -} - -template <typename StreamIdType> -void Http2PriorityWriteScheduler<StreamIdType>::UpdateStreamParent( - StreamInfo* stream_info, - StreamIdType parent_id, - bool exclusive) { - if (stream_info->id == parent_id) { - SPDY_BUG(spdy_bug_8_8) << "Cannot set stream to be its own parent"; - return; - } - StreamInfo* new_parent = FindStream(parent_id); - if (new_parent == nullptr) { - // parent_id may legitimately not be registered yet--see b/15676312. - SPDY_VLOG(1) << "Parent stream " << parent_id << " not registered"; - return; - } - - if (stream_info->parent == new_parent && - (!exclusive || new_parent->children.size() == 1u)) { - // If the new parent is already the stream's parent, and exclusivity (if - // specified) is already satisfied, we are done. - return; - } - - // Next, check to see if the new parent is currently a descendant - // of the stream. - StreamInfo* last = new_parent->parent; - bool cycle_exists = false; - while (last != nullptr) { - if (last == stream_info) { - cycle_exists = true; - break; - } - last = last->parent; - } - - if (cycle_exists) { - // The new parent moves to the level of the current stream. - UpdateStreamParent(new_parent, stream_info->parent->id, false); - } - - // Remove stream from old parent's child list. - StreamInfo* old_parent = stream_info->parent; - Remove(&old_parent->children, stream_info); - old_parent->total_child_weights -= stream_info->weight; - UpdatePrioritiesUnder(old_parent); - - if (exclusive) { - // Move the new parent's current children below the current stream. - for (StreamInfo* child : new_parent->children) { - child->parent = stream_info; - stream_info->children.push_back(child); - } - stream_info->total_child_weights += new_parent->total_child_weights; - // Clear new parent's old child data. - new_parent->children.clear(); - new_parent->total_child_weights = 0; - } - - // Make the change. - stream_info->parent = new_parent; - new_parent->children.push_back(stream_info); - new_parent->total_child_weights += stream_info->weight; - UpdatePrioritiesUnder(new_parent); -} - -template <typename StreamIdType> -void Http2PriorityWriteScheduler<StreamIdType>::RecordStreamEventTime( - StreamIdType stream_id, - int64_t now_in_usec) { - if (stream_id == kHttp2RootStreamId) { - SPDY_BUG(spdy_bug_8_9) << "Cannot record event time for root stream"; - return; - } - StreamInfo* stream_info = FindStream(stream_id); - if (stream_info == nullptr) { - SPDY_BUG(spdy_bug_8_10) << "Stream " << stream_id << " not registered"; - return; - } - stream_info->last_event_time_usec = now_in_usec; -} - -// O(n) in the number of streams, which isn't great. However, this method will -// soon be superseded by -// Http2WeightedWriteScheduler::GetLatestEventWithPrecedence(), for which an -// efficient implementation is straightforward. Also, this method is only -// called when calculating idle timeouts, so performance isn't key. -template <typename StreamIdType> -int64_t Http2PriorityWriteScheduler<StreamIdType>::GetLatestEventWithPrecedence( - StreamIdType stream_id) const { - if (stream_id == kHttp2RootStreamId) { - SPDY_BUG(spdy_bug_8_11) << "Invalid argument: root stream"; - return 0; - } - const StreamInfo* stream_info = FindStream(stream_id); - if (stream_info == nullptr) { - SPDY_BUG(spdy_bug_8_12) << "Stream " << stream_id << " not registered"; - return 0; - } - int64_t last_event_time_usec = 0; - for (const auto& kv : all_stream_infos_) { - const StreamInfo& other = *kv.second; - if (other.priority > stream_info->priority) { - last_event_time_usec = - std::max(last_event_time_usec, other.last_event_time_usec); - } - } - return last_event_time_usec; -} - -// Worst-case time complexity of O(n*d), where n is scheduling queue length and -// d is tree depth. In practice, should be much shorter, since loop terminates -// at first writable stream or |stream_id| (whichever is first). -template <typename StreamIdType> -bool Http2PriorityWriteScheduler<StreamIdType>::ShouldYield( - StreamIdType stream_id) const { - if (stream_id == kHttp2RootStreamId) { - SPDY_BUG(spdy_bug_8_13) << "Invalid argument: root stream"; - return false; - } - const StreamInfo* stream_info = FindStream(stream_id); - if (stream_info == nullptr) { - SPDY_BUG(spdy_bug_8_14) << "Stream " << stream_id << " not registered"; - return false; - } - if (HasReadyAncestor(*stream_info)) { - return true; - } - for (const StreamInfo& scheduled : scheduling_queue_) { - if (HasReadyAncestor(scheduled)) { - // Skip streams which cannot be scheduled. - continue; - } - if (stream_info->IsAncestorOf(scheduled)) { - // Do not yield to descendants. - return false; - } - // Yield to streams with higher priorities. - return scheduled.SchedulesBefore(*stream_info); - } - return false; -} - -template <typename StreamIdType> -void Http2PriorityWriteScheduler<StreamIdType>::MarkStreamReady( - StreamIdType stream_id, - bool add_to_front) { - if (stream_id == kHttp2RootStreamId) { - SPDY_BUG(spdy_bug_8_15) << "Cannot mark root stream ready"; - return; - } - StreamInfo* stream_info = FindStream(stream_id); - if (stream_info == nullptr) { - SPDY_BUG(spdy_bug_8_16) << "Stream " << stream_id << " not registered"; - return; - } - if (stream_info->ready) { - return; - } - stream_info->ordinal = add_to_front ? head_ordinal_-- : tail_ordinal_++; - Schedule(stream_info); -} - -template <typename StreamIdType> -void Http2PriorityWriteScheduler<StreamIdType>::MarkStreamNotReady( - StreamIdType stream_id) { - if (stream_id == kHttp2RootStreamId) { - SPDY_BUG(spdy_bug_8_17) << "Cannot mark root stream unready"; - return; - } - StreamInfo* stream_info = FindStream(stream_id); - if (stream_info == nullptr) { - SPDY_BUG(spdy_bug_8_18) << "Stream " << stream_id << " not registered"; - return; - } - if (!stream_info->ready) { - return; - } - Unschedule(stream_info); -} - -template <typename StreamIdType> -bool Http2PriorityWriteScheduler<StreamIdType>::Remove( - StreamInfoVector* stream_infos, - const StreamInfo* stream_info) { - for (typename StreamInfoVector::iterator it = stream_infos->begin(); - it != stream_infos->end(); ++it) { - if (*it == stream_info) { - stream_infos->erase(it); - return true; - } - } - return false; -} - -template <typename StreamIdType> -bool Http2PriorityWriteScheduler<StreamIdType>::HasReadyAncestor( - const StreamInfo& stream_info) { - for (const StreamInfo* parent = stream_info.parent; parent != nullptr; - parent = parent->parent) { - if (parent->ready) { - return true; - } - } - return false; -} - -template <typename StreamIdType> -const typename Http2PriorityWriteScheduler<StreamIdType>::StreamInfo* -Http2PriorityWriteScheduler<StreamIdType>::FindStream( - StreamIdType stream_id) const { - auto it = all_stream_infos_.find(stream_id); - return it == all_stream_infos_.end() ? nullptr : it->second.get(); -} - -template <typename StreamIdType> -typename Http2PriorityWriteScheduler<StreamIdType>::StreamInfo* -Http2PriorityWriteScheduler<StreamIdType>::FindStream(StreamIdType stream_id) { - auto it = all_stream_infos_.find(stream_id); - return it == all_stream_infos_.end() ? nullptr : it->second.get(); -} - -template <typename StreamIdType> -void Http2PriorityWriteScheduler<StreamIdType>::UpdatePrioritiesUnder( - StreamInfo* stream_info) { - for (StreamInfo* child : stream_info->children) { - child->priority = stream_info->priority * - (static_cast<float>(child->weight) / - static_cast<float>(stream_info->total_child_weights)); - if (child->ready) { - // Reposition in scheduling_queue_. Use post-order for scheduling, to - // benefit from the fact that children have priority <= parent priority. - Unschedule(child); - UpdatePrioritiesUnder(child); - Schedule(child); - } else { - UpdatePrioritiesUnder(child); - } - } -} - -template <typename StreamIdType> -void Http2PriorityWriteScheduler<StreamIdType>::Schedule( - StreamInfo* stream_info) { - QUICHE_DCHECK(!stream_info->ready); - for (StreamInfo& s : scheduling_queue_) { - if (stream_info->SchedulesBefore(s)) { - scheduling_queue_.insert(&s, stream_info); - stream_info->ready = true; - return; - } - } - scheduling_queue_.push_back(stream_info); - stream_info->ready = true; -} - -template <typename StreamIdType> -void Http2PriorityWriteScheduler<StreamIdType>::Unschedule( - StreamInfo* stream_info) { - QUICHE_DCHECK(stream_info->ready); - scheduling_queue_.erase(stream_info); - stream_info->ready = false; -} - -template <typename StreamIdType> -bool Http2PriorityWriteScheduler<StreamIdType>::StreamHasChild( - const StreamInfo& parent_info, - const StreamInfo* child_info) const { - auto found = std::find(parent_info.children.begin(), - parent_info.children.end(), child_info); - return found != parent_info.children.end(); -} - -template <typename StreamIdType> -bool Http2PriorityWriteScheduler<StreamIdType>::HasReadyStreams() const { - return !scheduling_queue_.empty(); -} - -template <typename StreamIdType> -StreamIdType Http2PriorityWriteScheduler<StreamIdType>::PopNextReadyStream() { - return std::get<0>(PopNextReadyStreamAndPrecedence()); -} - -template <typename StreamIdType> -std::tuple< - StreamIdType, - typename Http2PriorityWriteScheduler<StreamIdType>::StreamPrecedenceType> -Http2PriorityWriteScheduler<StreamIdType>::PopNextReadyStreamAndPrecedence() { - for (StreamInfo& stream_info : scheduling_queue_) { - if (!HasReadyAncestor(stream_info)) { - Unschedule(&stream_info); - return std::make_tuple(stream_info.id, stream_info.ToStreamPrecedence()); - } - } - SPDY_BUG(spdy_bug_8_19) << "No ready streams"; - return std::make_tuple( - kHttp2RootStreamId, - StreamPrecedenceType(kHttp2RootStreamId, kHttp2MinStreamWeight, false)); -} - -template <typename StreamIdType> -size_t Http2PriorityWriteScheduler<StreamIdType>::NumReadyStreams() const { - return scheduling_queue_.size(); -} - -template <typename StreamIdType> -bool Http2PriorityWriteScheduler<StreamIdType>::IsStreamReady( - StreamIdType stream_id) const { - if (stream_id == kHttp2RootStreamId) { - SPDY_BUG(spdy_bug_8_20) << "Try to check whether root stream is ready"; - return false; - } - const StreamInfo* stream_info = FindStream(stream_id); - if (stream_info == nullptr) { - SPDY_BUG(spdy_bug_8_21) << "Stream " << stream_id << " not registered"; - return false; - } - return stream_info->ready; -} - -template <typename StreamIdType> -size_t Http2PriorityWriteScheduler<StreamIdType>::NumRegisteredStreams() const { - return all_stream_infos_.size(); -} - -template <typename StreamIdType> -std::string Http2PriorityWriteScheduler<StreamIdType>::DebugString() const { - return absl::StrCat("Http2PriorityWriteScheduler {num_registered_streams=", - NumRegisteredStreams(), - " num_ready_streams=", NumReadyStreams(), "}"); -} - -template <typename StreamIdType> -bool Http2PriorityWriteScheduler<StreamIdType>::ValidateInvariantsForTests() - const { - size_t total_streams = 0; - size_t streams_visited = 0; - // Iterate through all streams in the map. - for (const auto& kv : all_stream_infos_) { - ++total_streams; - ++streams_visited; - StreamIdType stream_id = kv.first; - const StreamInfo& stream_info = *kv.second; - - // Verify each StreamInfo mapped under the proper stream ID. - if (stream_id != stream_info.id) { - SPDY_DLOG(INFO) << "Stream ID " << stream_id - << " maps to StreamInfo with ID " << stream_info.id; - return false; - } - - // All streams except the root should have a parent, and should appear in - // the children of that parent. - if (stream_info.id != kHttp2RootStreamId && - !StreamHasChild(*stream_info.parent, &stream_info)) { - SPDY_DLOG(INFO) << "Parent stream " << stream_info.parent->id - << " is not registered, or does not list stream " - << stream_info.id << " as its child."; - return false; - } - - if (!stream_info.children.empty()) { - int total_child_weights = 0; - // Iterate through the stream's children. - for (StreamInfo* child : stream_info.children) { - ++streams_visited; - // Each stream in the list should exist and should have this stream - // set as its parent. - if (!StreamRegistered(child->id) || child->parent != &stream_info) { - SPDY_DLOG(INFO) << "Child stream " << child->id - << " is not registered, " - << "or does not list " << stream_info.id - << " as its parent."; - return false; - } - total_child_weights += child->weight; - } - // Verify that total_child_weights is correct. - if (total_child_weights != stream_info.total_child_weights) { - SPDY_DLOG(INFO) << "Child weight totals do not agree. For stream " - << stream_info.id << " total_child_weights has value " - << stream_info.total_child_weights << ", expected " - << total_child_weights; - return false; - } - } - } - - // Make sure NumRegisteredStreams() reflects the total number of streams the - // map contains. - if (total_streams != NumRegisteredStreams()) { - SPDY_DLOG(INFO) << "Map contains incorrect number of streams."; - return false; - } - // Validate the validation function; we should have visited each stream twice - // (except for the root) - QUICHE_DCHECK(streams_visited == 2 * NumRegisteredStreams() - 1); - return true; -} - -} // namespace spdy - -#endif // QUICHE_SPDY_CORE_HTTP2_PRIORITY_WRITE_SCHEDULER_H_ diff --git a/chromium/net/third_party/quiche/src/spdy/core/http2_priority_write_scheduler_test.cc b/chromium/net/third_party/quiche/src/spdy/core/http2_priority_write_scheduler_test.cc deleted file mode 100644 index 7c9c2595811..00000000000 --- a/chromium/net/third_party/quiche/src/spdy/core/http2_priority_write_scheduler_test.cc +++ /dev/null @@ -1,965 +0,0 @@ -// Copyright (c) 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. - -#include "spdy/core/http2_priority_write_scheduler.h" - -#include <initializer_list> - -#include "common/platform/api/quiche_test.h" -#include "spdy/platform/api/spdy_test_helpers.h" - -using ::testing::AssertionFailure; -using ::testing::AssertionResult; -using ::testing::AssertionSuccess; -using ::testing::ElementsAre; -using ::testing::IsEmpty; -using ::testing::UnorderedElementsAre; - -namespace spdy { - -namespace test { - -template <typename StreamIdType> -class Http2PriorityWriteSchedulerPeer { - public: - explicit Http2PriorityWriteSchedulerPeer( - Http2PriorityWriteScheduler<StreamIdType>* scheduler) - : scheduler_(scheduler) {} - - int TotalChildWeights(StreamIdType stream_id) const { - return scheduler_->FindStream(stream_id)->total_child_weights; - } - - bool ValidateInvariants() const { - return scheduler_->ValidateInvariantsForTests(); - } - - private: - Http2PriorityWriteScheduler<StreamIdType>* scheduler_; -}; - -class Http2PriorityWriteSchedulerTest : public QuicheTest { - protected: - typedef uint32_t SpdyStreamId; - - Http2PriorityWriteSchedulerTest() : peer_(&scheduler_) {} - - Http2PriorityWriteScheduler<SpdyStreamId> scheduler_; - Http2PriorityWriteSchedulerPeer<SpdyStreamId> peer_; -}; - -TEST_F(Http2PriorityWriteSchedulerTest, RegisterAndUnregisterStreams) { - EXPECT_EQ(1u, scheduler_.NumRegisteredStreams()); - EXPECT_TRUE(scheduler_.StreamRegistered(0)); - EXPECT_FALSE(scheduler_.StreamRegistered(1)); - - scheduler_.RegisterStream(1, SpdyStreamPrecedence(0, 100, false)); - EXPECT_EQ(2u, scheduler_.NumRegisteredStreams()); - ASSERT_TRUE(scheduler_.StreamRegistered(1)); - EXPECT_EQ(100, scheduler_.GetStreamPrecedence(1).weight()); - EXPECT_FALSE(scheduler_.StreamRegistered(5)); - EXPECT_THAT(scheduler_.GetStreamChildren(0), ElementsAre(1)); - - scheduler_.RegisterStream(5, SpdyStreamPrecedence(0, 50, false)); - // Should not be able to add a stream with an id that already exists. - EXPECT_SPDY_BUG( - scheduler_.RegisterStream(5, SpdyStreamPrecedence(1, 50, false)), - "Stream 5 already registered"); - EXPECT_EQ(3u, scheduler_.NumRegisteredStreams()); - EXPECT_TRUE(scheduler_.StreamRegistered(1)); - ASSERT_TRUE(scheduler_.StreamRegistered(5)); - EXPECT_EQ(50, scheduler_.GetStreamPrecedence(5).weight()); - EXPECT_FALSE(scheduler_.StreamRegistered(13)); - - scheduler_.RegisterStream(13, SpdyStreamPrecedence(5, 130, true)); - EXPECT_EQ(4u, scheduler_.NumRegisteredStreams()); - EXPECT_TRUE(scheduler_.StreamRegistered(1)); - EXPECT_TRUE(scheduler_.StreamRegistered(5)); - ASSERT_TRUE(scheduler_.StreamRegistered(13)); - EXPECT_EQ(130, scheduler_.GetStreamPrecedence(13).weight()); - EXPECT_EQ(5u, scheduler_.GetStreamPrecedence(13).parent_id()); - - scheduler_.UnregisterStream(5); - // Cannot remove a stream that has already been removed. - EXPECT_SPDY_BUG(scheduler_.UnregisterStream(5), "Stream 5 not registered"); - EXPECT_EQ(3u, scheduler_.NumRegisteredStreams()); - EXPECT_TRUE(scheduler_.StreamRegistered(1)); - EXPECT_FALSE(scheduler_.StreamRegistered(5)); - EXPECT_TRUE(scheduler_.StreamRegistered(13)); - EXPECT_EQ(kHttp2RootStreamId, scheduler_.GetStreamPrecedence(13).parent_id()); - - // The parent stream 19 doesn't exist, so this should use 0 as parent stream: - scheduler_.RegisterStream(7, SpdyStreamPrecedence(19, 70, false)); - EXPECT_TRUE(scheduler_.StreamRegistered(7)); - EXPECT_EQ(0u, scheduler_.GetStreamPrecedence(7).parent_id()); - // Now stream 7 already exists, so this should fail: - EXPECT_SPDY_BUG( - scheduler_.RegisterStream(7, SpdyStreamPrecedence(1, 70, false)), - "Stream 7 already registered"); - // Try adding a second child to stream 13: - scheduler_.RegisterStream(17, SpdyStreamPrecedence(13, 170, false)); - - scheduler_.UpdateStreamPrecedence(17, SpdyStreamPrecedence(13, 150, false)); - EXPECT_EQ(150, scheduler_.GetStreamPrecedence(17).weight()); - - ASSERT_TRUE(peer_.ValidateInvariants()); -} - -TEST_F(Http2PriorityWriteSchedulerTest, RegisterStreamWithSpdy3Priority) { - EXPECT_FALSE(scheduler_.StreamRegistered(1)); - scheduler_.RegisterStream(1, SpdyStreamPrecedence(3)); - EXPECT_EQ(0u, scheduler_.NumReadyStreams()); - EXPECT_TRUE(scheduler_.StreamRegistered(1)); - EXPECT_EQ(3, scheduler_.GetStreamPrecedence(1).spdy3_priority()); - EXPECT_EQ(147, scheduler_.GetStreamPrecedence(1).weight()); - EXPECT_EQ(kHttp2RootStreamId, scheduler_.GetStreamPrecedence(1).parent_id()); - EXPECT_THAT(scheduler_.GetStreamChildren(1), IsEmpty()); - - EXPECT_SPDY_BUG(scheduler_.RegisterStream(1, SpdyStreamPrecedence(4)), - "Stream 1 already registered"); - EXPECT_EQ(3, scheduler_.GetStreamPrecedence(1).spdy3_priority()); -} - -TEST_F(Http2PriorityWriteSchedulerTest, GetStreamWeight) { - // Unknown streams tolerated due to b/15676312. - EXPECT_EQ(kHttp2MinStreamWeight, scheduler_.GetStreamPrecedence(3).weight()); - scheduler_.RegisterStream(3, SpdyStreamPrecedence(0, 130, true)); - EXPECT_EQ(130, scheduler_.GetStreamPrecedence(3).weight()); - scheduler_.UpdateStreamPrecedence(3, SpdyStreamPrecedence(0, 50, true)); - EXPECT_EQ(50, scheduler_.GetStreamPrecedence(3).weight()); - scheduler_.UnregisterStream(3); - EXPECT_EQ(kHttp2MinStreamWeight, scheduler_.GetStreamPrecedence(3).weight()); -} - -TEST_F(Http2PriorityWriteSchedulerTest, GetStreamPriority) { - // Unknown streams tolerated due to b/15676312. - EXPECT_EQ(kV3LowestPriority, - scheduler_.GetStreamPrecedence(3).spdy3_priority()); - scheduler_.RegisterStream(3, SpdyStreamPrecedence(0, 130, true)); - EXPECT_EQ(3, scheduler_.GetStreamPrecedence(3).spdy3_priority()); - scheduler_.UpdateStreamPrecedence(3, SpdyStreamPrecedence(0, 50, true)); - EXPECT_EQ(5, scheduler_.GetStreamPrecedence(3).spdy3_priority()); - scheduler_.UnregisterStream(3); - EXPECT_EQ(kV3LowestPriority, - scheduler_.GetStreamPrecedence(3).spdy3_priority()); -} - -TEST_F(Http2PriorityWriteSchedulerTest, GetStreamParent) { - // Unknown streams tolerated due to b/15676312. - EXPECT_EQ(kHttp2RootStreamId, scheduler_.GetStreamPrecedence(3).parent_id()); - scheduler_.RegisterStream(2, SpdyStreamPrecedence(0, 20, false)); - scheduler_.RegisterStream(3, SpdyStreamPrecedence(2, 30, false)); - EXPECT_EQ(2u, scheduler_.GetStreamPrecedence(3).parent_id()); - scheduler_.UnregisterStream(3); - EXPECT_EQ(kHttp2RootStreamId, scheduler_.GetStreamPrecedence(3).parent_id()); -} - -TEST_F(Http2PriorityWriteSchedulerTest, GetStreamChildren) { - EXPECT_SPDY_BUG(EXPECT_THAT(scheduler_.GetStreamChildren(7), IsEmpty()), - "Stream 7 not registered"); - scheduler_.RegisterStream(7, SpdyStreamPrecedence(0, 70, false)); - EXPECT_THAT(scheduler_.GetStreamChildren(7), IsEmpty()); - scheduler_.RegisterStream(9, SpdyStreamPrecedence(7, 90, false)); - scheduler_.RegisterStream(15, SpdyStreamPrecedence(7, 150, false)); - EXPECT_THAT(scheduler_.GetStreamChildren(7), UnorderedElementsAre(9, 15)); - scheduler_.UnregisterStream(7); - EXPECT_SPDY_BUG(EXPECT_THAT(scheduler_.GetStreamChildren(7), IsEmpty()), - "Stream 7 not registered"); -} - -TEST_F(Http2PriorityWriteSchedulerTest, UpdateStreamWeight) { - EXPECT_SPDY_BUG( - scheduler_.UpdateStreamPrecedence(0, SpdyStreamPrecedence(0, 10, false)), - "Cannot set precedence of root stream"); - - // For the moment, updating stream precedence on a non-registered stream - // should have no effect. In the future, it will lazily cause the stream to - // be registered (b/15676312). - scheduler_.UpdateStreamPrecedence(3, SpdyStreamPrecedence(0, 10, false)); - EXPECT_FALSE(scheduler_.StreamRegistered(3)); - - scheduler_.RegisterStream(3, SpdyStreamPrecedence(0, 10, false)); - scheduler_.UpdateStreamPrecedence(3, SpdyStreamPrecedence(0, 20, false)); - EXPECT_EQ(20, scheduler_.GetStreamPrecedence(3).weight()); - ASSERT_TRUE(peer_.ValidateInvariants()); - - EXPECT_SPDY_BUG( - scheduler_.UpdateStreamPrecedence(3, SpdyStreamPrecedence(0, 500, false)), - "Invalid weight: 500"); - EXPECT_EQ(kHttp2MaxStreamWeight, scheduler_.GetStreamPrecedence(3).weight()); - EXPECT_SPDY_BUG( - scheduler_.UpdateStreamPrecedence(3, SpdyStreamPrecedence(0, 0, false)), - "Invalid weight: 0"); - EXPECT_EQ(kHttp2MinStreamWeight, scheduler_.GetStreamPrecedence(3).weight()); - ASSERT_TRUE(peer_.ValidateInvariants()); - - scheduler_.UnregisterStream(3); -} - -// Basic case of reparenting a subtree. -TEST_F(Http2PriorityWriteSchedulerTest, UpdateStreamParentBasicNonExclusive) { - /* Tree: - 0 - / \ - 1 2 - / \ - 3 4 - */ - scheduler_.RegisterStream(1, SpdyStreamPrecedence(0, 100, false)); - scheduler_.RegisterStream(2, SpdyStreamPrecedence(0, 100, false)); - scheduler_.RegisterStream(3, SpdyStreamPrecedence(1, 100, false)); - scheduler_.RegisterStream(4, SpdyStreamPrecedence(1, 100, false)); - scheduler_.UpdateStreamPrecedence(1, SpdyStreamPrecedence(2, 100, false)); - EXPECT_THAT(scheduler_.GetStreamChildren(0), ElementsAre(2)); - EXPECT_THAT(scheduler_.GetStreamChildren(1), UnorderedElementsAre(3, 4)); - EXPECT_THAT(scheduler_.GetStreamChildren(2), ElementsAre(1)); - EXPECT_THAT(scheduler_.GetStreamChildren(3), IsEmpty()); - EXPECT_THAT(scheduler_.GetStreamChildren(4), IsEmpty()); - ASSERT_TRUE(peer_.ValidateInvariants()); -} - -// Basic case of reparenting a subtree. Result here is the same as the -// non-exclusive case. -TEST_F(Http2PriorityWriteSchedulerTest, UpdateStreamParentBasicExclusive) { - /* Tree: - 0 - / \ - 1 2 - / \ - 3 4 - */ - scheduler_.RegisterStream(1, SpdyStreamPrecedence(0, 100, false)); - scheduler_.RegisterStream(2, SpdyStreamPrecedence(0, 100, false)); - scheduler_.RegisterStream(3, SpdyStreamPrecedence(1, 100, false)); - scheduler_.RegisterStream(4, SpdyStreamPrecedence(1, 100, false)); - scheduler_.UpdateStreamPrecedence(1, SpdyStreamPrecedence(2, 100, true)); - EXPECT_THAT(scheduler_.GetStreamChildren(0), ElementsAre(2)); - EXPECT_THAT(scheduler_.GetStreamChildren(1), UnorderedElementsAre(3, 4)); - EXPECT_THAT(scheduler_.GetStreamChildren(2), ElementsAre(1)); - EXPECT_THAT(scheduler_.GetStreamChildren(3), IsEmpty()); - EXPECT_THAT(scheduler_.GetStreamChildren(4), IsEmpty()); - ASSERT_TRUE(peer_.ValidateInvariants()); -} - -// We can't set the parent of a nonexistent stream, or set the parent to a -// nonexistent stream. -TEST_F(Http2PriorityWriteSchedulerTest, UpdateStreamParentNonexistent) { - scheduler_.RegisterStream(1, SpdyStreamPrecedence(0, 100, false)); - scheduler_.RegisterStream(2, SpdyStreamPrecedence(0, 100, false)); - for (bool exclusive : {true, false}) { - // For the moment, updating stream precedence on a non-registered stream or - // attempting to set parent to a nonexistent stream should have no - // effect. In the future, it will lazily cause the stream(s) to be - // registered (b/15676312). - - // No-op: parent stream 3 not registered - scheduler_.UpdateStreamPrecedence(1, - SpdyStreamPrecedence(3, 100, exclusive)); - - // No-op: stream 4 not registered - scheduler_.UpdateStreamPrecedence(4, - SpdyStreamPrecedence(2, 100, exclusive)); - - // No-op: stream 3 not registered - scheduler_.UpdateStreamPrecedence(3, - SpdyStreamPrecedence(4, 100, exclusive)); - - EXPECT_THAT(scheduler_.GetStreamChildren(0), UnorderedElementsAre(1, 2)); - EXPECT_THAT(scheduler_.GetStreamChildren(1), IsEmpty()); - EXPECT_THAT(scheduler_.GetStreamChildren(2), IsEmpty()); - EXPECT_FALSE(scheduler_.StreamRegistered(3)); - EXPECT_FALSE(scheduler_.StreamRegistered(4)); - } - ASSERT_TRUE(peer_.ValidateInvariants()); -} - -// We should be able to add multiple children to streams. -TEST_F(Http2PriorityWriteSchedulerTest, - UpdateStreamParentMultipleChildrenNonExclusive) { - /* Tree: - 0 - / \ - 1 2 - / \ \ - 3 4 5 - */ - scheduler_.RegisterStream(1, SpdyStreamPrecedence(0, 100, false)); - scheduler_.RegisterStream(2, SpdyStreamPrecedence(0, 100, false)); - scheduler_.RegisterStream(3, SpdyStreamPrecedence(1, 100, false)); - scheduler_.RegisterStream(4, SpdyStreamPrecedence(1, 100, false)); - scheduler_.RegisterStream(5, SpdyStreamPrecedence(2, 100, false)); - scheduler_.UpdateStreamPrecedence(2, SpdyStreamPrecedence(1, 100, false)); - EXPECT_THAT(scheduler_.GetStreamChildren(0), ElementsAre(1)); - EXPECT_THAT(scheduler_.GetStreamChildren(1), UnorderedElementsAre(2, 3, 4)); - EXPECT_THAT(scheduler_.GetStreamChildren(2), ElementsAre(5)); - EXPECT_THAT(scheduler_.GetStreamChildren(3), IsEmpty()); - EXPECT_THAT(scheduler_.GetStreamChildren(4), IsEmpty()); - EXPECT_THAT(scheduler_.GetStreamChildren(5), IsEmpty()); - ASSERT_TRUE(peer_.ValidateInvariants()); -} - -TEST_F(Http2PriorityWriteSchedulerTest, - UpdateStreamParentMultipleChildrenExclusive) { - /* Tree: - 0 - / \ - 1 2 - / \ \ - 3 4 5 - */ - scheduler_.RegisterStream(1, SpdyStreamPrecedence(0, 100, false)); - scheduler_.RegisterStream(2, SpdyStreamPrecedence(0, 100, false)); - scheduler_.RegisterStream(3, SpdyStreamPrecedence(1, 100, false)); - scheduler_.RegisterStream(4, SpdyStreamPrecedence(1, 100, false)); - scheduler_.RegisterStream(5, SpdyStreamPrecedence(2, 100, false)); - scheduler_.UpdateStreamPrecedence(2, SpdyStreamPrecedence(1, 100, true)); - EXPECT_THAT(scheduler_.GetStreamChildren(0), ElementsAre(1)); - EXPECT_THAT(scheduler_.GetStreamChildren(1), ElementsAre(2)); - EXPECT_THAT(scheduler_.GetStreamChildren(2), UnorderedElementsAre(3, 4, 5)); - EXPECT_THAT(scheduler_.GetStreamChildren(3), IsEmpty()); - EXPECT_THAT(scheduler_.GetStreamChildren(4), IsEmpty()); - EXPECT_THAT(scheduler_.GetStreamChildren(5), IsEmpty()); - ASSERT_TRUE(peer_.ValidateInvariants()); -} - -TEST_F(Http2PriorityWriteSchedulerTest, UpdateStreamParentToChildNonExclusive) { - /* Tree: - 0 - | - 1 - / \ - 2 3 - | - 4 - */ - scheduler_.RegisterStream(1, SpdyStreamPrecedence(0, 100, false)); - scheduler_.RegisterStream(2, SpdyStreamPrecedence(1, 100, false)); - scheduler_.RegisterStream(3, SpdyStreamPrecedence(1, 100, false)); - scheduler_.RegisterStream(4, SpdyStreamPrecedence(2, 100, false)); - scheduler_.UpdateStreamPrecedence(1, SpdyStreamPrecedence(2, 100, false)); - EXPECT_THAT(scheduler_.GetStreamChildren(0), ElementsAre(2)); - EXPECT_THAT(scheduler_.GetStreamChildren(1), ElementsAre(3)); - EXPECT_THAT(scheduler_.GetStreamChildren(2), UnorderedElementsAre(1, 4)); - EXPECT_THAT(scheduler_.GetStreamChildren(3), IsEmpty()); - EXPECT_THAT(scheduler_.GetStreamChildren(4), IsEmpty()); - ASSERT_TRUE(peer_.ValidateInvariants()); -} - -TEST_F(Http2PriorityWriteSchedulerTest, UpdateStreamParentToChildExclusive) { - /* Tree: - 0 - | - 1 - / \ - 2 3 - | - 4 - */ - scheduler_.RegisterStream(1, SpdyStreamPrecedence(0, 100, false)); - scheduler_.RegisterStream(2, SpdyStreamPrecedence(1, 100, false)); - scheduler_.RegisterStream(3, SpdyStreamPrecedence(1, 100, false)); - scheduler_.RegisterStream(4, SpdyStreamPrecedence(2, 100, false)); - scheduler_.UpdateStreamPrecedence(1, SpdyStreamPrecedence(2, 100, true)); - EXPECT_THAT(scheduler_.GetStreamChildren(0), ElementsAre(2)); - EXPECT_THAT(scheduler_.GetStreamChildren(1), UnorderedElementsAre(3, 4)); - EXPECT_THAT(scheduler_.GetStreamChildren(2), ElementsAre(1)); - EXPECT_THAT(scheduler_.GetStreamChildren(3), IsEmpty()); - EXPECT_THAT(scheduler_.GetStreamChildren(4), IsEmpty()); - ASSERT_TRUE(peer_.ValidateInvariants()); -} - -TEST_F(Http2PriorityWriteSchedulerTest, - UpdateStreamParentToGrandchildNonExclusive) { - /* Tree: - 0 - | - 1 - / \ - 2 3 - / \ - 4 5 - | - 6 - */ - scheduler_.RegisterStream(1, SpdyStreamPrecedence(0, 100, false)); - scheduler_.RegisterStream(2, SpdyStreamPrecedence(1, 100, false)); - scheduler_.RegisterStream(3, SpdyStreamPrecedence(1, 100, false)); - scheduler_.RegisterStream(4, SpdyStreamPrecedence(2, 100, false)); - scheduler_.RegisterStream(5, SpdyStreamPrecedence(2, 100, false)); - scheduler_.RegisterStream(6, SpdyStreamPrecedence(4, 100, false)); - scheduler_.UpdateStreamPrecedence(1, SpdyStreamPrecedence(4, 100, false)); - EXPECT_THAT(scheduler_.GetStreamChildren(0), ElementsAre(4)); - EXPECT_THAT(scheduler_.GetStreamChildren(1), UnorderedElementsAre(2, 3)); - EXPECT_THAT(scheduler_.GetStreamChildren(2), ElementsAre(5)); - EXPECT_THAT(scheduler_.GetStreamChildren(3), IsEmpty()); - EXPECT_THAT(scheduler_.GetStreamChildren(4), UnorderedElementsAre(1, 6)); - EXPECT_THAT(scheduler_.GetStreamChildren(5), IsEmpty()); - EXPECT_THAT(scheduler_.GetStreamChildren(6), IsEmpty()); - ASSERT_TRUE(peer_.ValidateInvariants()); -} - -TEST_F(Http2PriorityWriteSchedulerTest, - UpdateStreamParentToGrandchildExclusive) { - /* Tree: - 0 - | - 1 - / \ - 2 3 - / \ - 4 5 - | - 6 - */ - scheduler_.RegisterStream(1, SpdyStreamPrecedence(0, 100, false)); - scheduler_.RegisterStream(2, SpdyStreamPrecedence(1, 100, false)); - scheduler_.RegisterStream(3, SpdyStreamPrecedence(1, 100, false)); - scheduler_.RegisterStream(4, SpdyStreamPrecedence(2, 100, false)); - scheduler_.RegisterStream(5, SpdyStreamPrecedence(2, 100, false)); - scheduler_.RegisterStream(6, SpdyStreamPrecedence(4, 100, false)); - scheduler_.UpdateStreamPrecedence(1, SpdyStreamPrecedence(4, 100, true)); - EXPECT_THAT(scheduler_.GetStreamChildren(0), ElementsAre(4)); - EXPECT_THAT(scheduler_.GetStreamChildren(1), UnorderedElementsAre(2, 3, 6)); - EXPECT_THAT(scheduler_.GetStreamChildren(2), ElementsAre(5)); - EXPECT_THAT(scheduler_.GetStreamChildren(3), IsEmpty()); - EXPECT_THAT(scheduler_.GetStreamChildren(4), ElementsAre(1)); - EXPECT_THAT(scheduler_.GetStreamChildren(5), IsEmpty()); - EXPECT_THAT(scheduler_.GetStreamChildren(6), IsEmpty()); - ASSERT_TRUE(peer_.ValidateInvariants()); -} - -TEST_F(Http2PriorityWriteSchedulerTest, RegisterStreamParentExclusive) { - /* 0 - / \ - 1 2 - */ - scheduler_.RegisterStream(1, SpdyStreamPrecedence(0, 100, false)); - scheduler_.RegisterStream(2, SpdyStreamPrecedence(0, 100, false)); - /* 0 - | - 3 - / \ - 1 2 - */ - scheduler_.RegisterStream(3, SpdyStreamPrecedence(0, 100, true)); - EXPECT_THAT(scheduler_.GetStreamChildren(0), ElementsAre(3)); - EXPECT_THAT(scheduler_.GetStreamChildren(3), UnorderedElementsAre(1, 2)); - EXPECT_THAT(scheduler_.GetStreamChildren(1), IsEmpty()); - EXPECT_THAT(scheduler_.GetStreamChildren(2), IsEmpty()); - ASSERT_TRUE(peer_.ValidateInvariants()); -} - -TEST_F(Http2PriorityWriteSchedulerTest, UpdateStreamParentExclusive) { - /* 0 - /|\ - 1 2 3 - */ - scheduler_.RegisterStream(1, SpdyStreamPrecedence(0, 100, false)); - scheduler_.RegisterStream(2, SpdyStreamPrecedence(0, 100, false)); - scheduler_.RegisterStream(3, SpdyStreamPrecedence(0, 100, false)); - /* 0 - | - 1 - / \ - 2 3 - */ - scheduler_.UpdateStreamPrecedence(1, SpdyStreamPrecedence(0, 100, true)); - EXPECT_THAT(scheduler_.GetStreamChildren(0), ElementsAre(1)); - EXPECT_THAT(scheduler_.GetStreamChildren(1), UnorderedElementsAre(2, 3)); - EXPECT_THAT(scheduler_.GetStreamChildren(2), IsEmpty()); - EXPECT_THAT(scheduler_.GetStreamChildren(3), IsEmpty()); - ASSERT_TRUE(peer_.ValidateInvariants()); -} - -TEST_F(Http2PriorityWriteSchedulerTest, UpdateStreamParentExclusive2) { - /* 0 - | - 1 - / \ - 2 3 - / \ - 4 5 - | - 6 - */ - scheduler_.RegisterStream(1, SpdyStreamPrecedence(0, 100, false)); - scheduler_.RegisterStream(2, SpdyStreamPrecedence(1, 100, false)); - scheduler_.RegisterStream(3, SpdyStreamPrecedence(1, 100, false)); - scheduler_.RegisterStream(4, SpdyStreamPrecedence(3, 100, false)); - scheduler_.RegisterStream(5, SpdyStreamPrecedence(3, 100, false)); - scheduler_.RegisterStream(6, SpdyStreamPrecedence(4, 100, false)); - // Update stream 1's parent to 4 exclusive. - /* 0 - | - 4 - | - 1 - /|\ - 2 3 6 - | - 5 - */ - scheduler_.UpdateStreamPrecedence(1, SpdyStreamPrecedence(4, 100, true)); - EXPECT_THAT(scheduler_.GetStreamChildren(0), ElementsAre(4)); - EXPECT_THAT(scheduler_.GetStreamChildren(4), ElementsAre(1)); - EXPECT_THAT(scheduler_.GetStreamChildren(1), UnorderedElementsAre(2, 3, 6)); - EXPECT_THAT(scheduler_.GetStreamChildren(2), IsEmpty()); - EXPECT_THAT(scheduler_.GetStreamChildren(3), ElementsAre(5)); - EXPECT_THAT(scheduler_.GetStreamChildren(6), IsEmpty()); - ASSERT_TRUE(peer_.ValidateInvariants()); -} - -TEST_F(Http2PriorityWriteSchedulerTest, UpdateStreamParentNonExclusive) { - /* 0 - | - 1 - / \ - 2 3 - / \ - 4 5 - | - 6 - */ - scheduler_.RegisterStream(1, SpdyStreamPrecedence(0, 100, false)); - scheduler_.RegisterStream(2, SpdyStreamPrecedence(1, 100, false)); - scheduler_.RegisterStream(3, SpdyStreamPrecedence(1, 100, false)); - scheduler_.RegisterStream(4, SpdyStreamPrecedence(3, 100, false)); - scheduler_.RegisterStream(5, SpdyStreamPrecedence(3, 100, false)); - scheduler_.RegisterStream(6, SpdyStreamPrecedence(4, 100, false)); - // Update stream 1's parent to 4. - /* 0 - | - 4 - / \ - 6 1 - / \ - 2 3 - | - 5 - */ - scheduler_.UpdateStreamPrecedence(1, SpdyStreamPrecedence(4, 100, false)); - EXPECT_THAT(scheduler_.GetStreamChildren(0), ElementsAre(4)); - EXPECT_THAT(scheduler_.GetStreamChildren(4), UnorderedElementsAre(6, 1)); - EXPECT_THAT(scheduler_.GetStreamChildren(6), IsEmpty()); - EXPECT_THAT(scheduler_.GetStreamChildren(1), UnorderedElementsAre(2, 3)); - EXPECT_THAT(scheduler_.GetStreamChildren(2), IsEmpty()); - EXPECT_THAT(scheduler_.GetStreamChildren(3), ElementsAre(5)); - EXPECT_THAT(scheduler_.GetStreamChildren(5), IsEmpty()); - ASSERT_TRUE(peer_.ValidateInvariants()); -} - -TEST_F(Http2PriorityWriteSchedulerTest, UpdateStreamParentToParent) { - scheduler_.RegisterStream(1, SpdyStreamPrecedence(0, 100, false)); - scheduler_.RegisterStream(2, SpdyStreamPrecedence(1, 100, false)); - scheduler_.RegisterStream(3, SpdyStreamPrecedence(1, 100, false)); - EXPECT_THAT(scheduler_.GetStreamChildren(1), UnorderedElementsAre(2, 3)); - EXPECT_THAT(scheduler_.GetStreamChildren(2), IsEmpty()); - EXPECT_THAT(scheduler_.GetStreamChildren(3), IsEmpty()); - for (bool exclusive : {true, false}) { - scheduler_.UpdateStreamPrecedence(2, - SpdyStreamPrecedence(1, 100, exclusive)); - EXPECT_THAT(scheduler_.GetStreamChildren(0), ElementsAre(1)); - EXPECT_THAT(scheduler_.GetStreamChildren(1), UnorderedElementsAre(2)); - EXPECT_THAT(scheduler_.GetStreamChildren(2), UnorderedElementsAre(3)); - EXPECT_THAT(scheduler_.GetStreamChildren(3), IsEmpty()); - } - ASSERT_TRUE(peer_.ValidateInvariants()); -} - -TEST_F(Http2PriorityWriteSchedulerTest, UpdateStreamParentToSelf) { - scheduler_.RegisterStream(1, SpdyStreamPrecedence(0, 100, false)); - EXPECT_SPDY_BUG( - scheduler_.UpdateStreamPrecedence(1, SpdyStreamPrecedence(1, 100, false)), - "Cannot set stream to be its own parent"); - EXPECT_SPDY_BUG( - scheduler_.UpdateStreamPrecedence(1, SpdyStreamPrecedence(1, 100, true)), - "Cannot set stream to be its own parent"); - EXPECT_THAT(scheduler_.GetStreamChildren(0), ElementsAre(1)); - EXPECT_THAT(scheduler_.GetStreamChildren(1), IsEmpty()); - ASSERT_TRUE(peer_.ValidateInvariants()); -} - -TEST_F(Http2PriorityWriteSchedulerTest, BlockAndUnblock) { - /* Create the tree. - - 0 - / | \ - / | \ - 1 2 3 - / \ \ \ - 4 5 6 7 - /| / \ | |\ - 8 9 10 11 12 13 14 - / \ - 15 16 - - */ - scheduler_.RegisterStream(1, SpdyStreamPrecedence(0, 100, false)); - scheduler_.RegisterStream(2, SpdyStreamPrecedence(0, 100, false)); - scheduler_.RegisterStream(3, SpdyStreamPrecedence(0, 100, false)); - scheduler_.RegisterStream(4, SpdyStreamPrecedence(1, 100, false)); - scheduler_.RegisterStream(5, SpdyStreamPrecedence(1, 100, false)); - scheduler_.RegisterStream(8, SpdyStreamPrecedence(4, 100, false)); - scheduler_.RegisterStream(9, SpdyStreamPrecedence(4, 100, false)); - scheduler_.RegisterStream(10, SpdyStreamPrecedence(5, 100, false)); - scheduler_.RegisterStream(11, SpdyStreamPrecedence(5, 100, false)); - scheduler_.RegisterStream(15, SpdyStreamPrecedence(8, 100, false)); - scheduler_.RegisterStream(16, SpdyStreamPrecedence(8, 100, false)); - scheduler_.RegisterStream(12, SpdyStreamPrecedence(2, 100, false)); - scheduler_.RegisterStream(6, SpdyStreamPrecedence(2, 100, true)); - scheduler_.RegisterStream(7, SpdyStreamPrecedence(0, 100, false)); - scheduler_.RegisterStream(13, SpdyStreamPrecedence(7, 100, true)); - scheduler_.RegisterStream(14, SpdyStreamPrecedence(7, 100, false)); - scheduler_.UpdateStreamPrecedence(7, SpdyStreamPrecedence(3, 100, false)); - EXPECT_EQ(0u, scheduler_.GetStreamPrecedence(1).parent_id()); - EXPECT_EQ(0u, scheduler_.GetStreamPrecedence(2).parent_id()); - EXPECT_EQ(0u, scheduler_.GetStreamPrecedence(3).parent_id()); - EXPECT_EQ(1u, scheduler_.GetStreamPrecedence(4).parent_id()); - EXPECT_EQ(1u, scheduler_.GetStreamPrecedence(5).parent_id()); - EXPECT_EQ(2u, scheduler_.GetStreamPrecedence(6).parent_id()); - EXPECT_EQ(3u, scheduler_.GetStreamPrecedence(7).parent_id()); - EXPECT_EQ(4u, scheduler_.GetStreamPrecedence(8).parent_id()); - EXPECT_EQ(4u, scheduler_.GetStreamPrecedence(9).parent_id()); - EXPECT_EQ(5u, scheduler_.GetStreamPrecedence(10).parent_id()); - EXPECT_EQ(5u, scheduler_.GetStreamPrecedence(11).parent_id()); - EXPECT_EQ(6u, scheduler_.GetStreamPrecedence(12).parent_id()); - EXPECT_EQ(7u, scheduler_.GetStreamPrecedence(13).parent_id()); - EXPECT_EQ(7u, scheduler_.GetStreamPrecedence(14).parent_id()); - EXPECT_EQ(8u, scheduler_.GetStreamPrecedence(15).parent_id()); - EXPECT_EQ(8u, scheduler_.GetStreamPrecedence(16).parent_id()); - ASSERT_TRUE(peer_.ValidateInvariants()); - - EXPECT_EQ(peer_.TotalChildWeights(0), - scheduler_.GetStreamPrecedence(1).weight() + - scheduler_.GetStreamPrecedence(2).weight() + - scheduler_.GetStreamPrecedence(3).weight()); - EXPECT_EQ(peer_.TotalChildWeights(3), - scheduler_.GetStreamPrecedence(7).weight()); - EXPECT_EQ(peer_.TotalChildWeights(7), - scheduler_.GetStreamPrecedence(13).weight() + - scheduler_.GetStreamPrecedence(14).weight()); - EXPECT_EQ(peer_.TotalChildWeights(13), 0); - EXPECT_EQ(peer_.TotalChildWeights(14), 0); - - ASSERT_TRUE(peer_.ValidateInvariants()); -} - -TEST_F(Http2PriorityWriteSchedulerTest, HasReadyStreams) { - EXPECT_FALSE(scheduler_.HasReadyStreams()); - scheduler_.RegisterStream(1, SpdyStreamPrecedence(0, 10, false)); - EXPECT_FALSE(scheduler_.HasReadyStreams()); - scheduler_.MarkStreamReady(1, false); - EXPECT_TRUE(scheduler_.HasReadyStreams()); - EXPECT_TRUE(scheduler_.IsStreamReady(1)); - scheduler_.MarkStreamNotReady(1); - EXPECT_FALSE(scheduler_.HasReadyStreams()); - EXPECT_FALSE(scheduler_.IsStreamReady(1)); - scheduler_.MarkStreamReady(1, true); - EXPECT_TRUE(scheduler_.HasReadyStreams()); - EXPECT_TRUE(scheduler_.IsStreamReady(1)); - scheduler_.UnregisterStream(1); - EXPECT_FALSE(scheduler_.HasReadyStreams()); - ASSERT_TRUE(peer_.ValidateInvariants()); - EXPECT_SPDY_BUG(scheduler_.IsStreamReady(1), "Stream 1 not registered"); -} - -TEST_F(Http2PriorityWriteSchedulerTest, CalculateRoundedWeights) { - /* Create the tree. - - 0 - / \ - 1 2 - /| |\ |\ - 8 3 4 5 6 7 - */ - scheduler_.RegisterStream(3, SpdyStreamPrecedence(0, 100, false)); - scheduler_.RegisterStream(4, SpdyStreamPrecedence(0, 100, false)); - scheduler_.RegisterStream(5, SpdyStreamPrecedence(0, 100, false)); - scheduler_.RegisterStream(1, SpdyStreamPrecedence(0, 10, true)); - scheduler_.RegisterStream(2, SpdyStreamPrecedence(0, 5, false)); - scheduler_.RegisterStream(6, SpdyStreamPrecedence(2, 1, false)); - scheduler_.RegisterStream(7, SpdyStreamPrecedence(2, 1, false)); - scheduler_.RegisterStream(8, SpdyStreamPrecedence(1, 1, false)); - - // Remove higher-level streams. - scheduler_.UnregisterStream(1); - scheduler_.UnregisterStream(2); - - // 3.3 rounded down = 3. - EXPECT_EQ(3, scheduler_.GetStreamPrecedence(3).weight()); - EXPECT_EQ(3, scheduler_.GetStreamPrecedence(4).weight()); - EXPECT_EQ(3, scheduler_.GetStreamPrecedence(5).weight()); - // 2.5 rounded up = 3. - EXPECT_EQ(3, scheduler_.GetStreamPrecedence(6).weight()); - EXPECT_EQ(3, scheduler_.GetStreamPrecedence(7).weight()); - // 0 is not a valid weight, so round up to 1. - EXPECT_EQ(1, scheduler_.GetStreamPrecedence(8).weight()); - ASSERT_TRUE(peer_.ValidateInvariants()); -} - -TEST_F(Http2PriorityWriteSchedulerTest, GetLatestEventWithPrecedence) { - EXPECT_SPDY_BUG(scheduler_.RecordStreamEventTime(3, 5), - "Stream 3 not registered"); - EXPECT_SPDY_BUG(EXPECT_EQ(0, scheduler_.GetLatestEventWithPrecedence(4)), - "Stream 4 not registered"); - - for (int i = 1; i < 5; ++i) { - int weight = SpdyStreamPrecedence(i).weight(); - scheduler_.RegisterStream(i, SpdyStreamPrecedence(0, weight, false)); - } - for (int i = 1; i < 5; ++i) { - EXPECT_EQ(0, scheduler_.GetLatestEventWithPrecedence(i)); - } - for (int i = 1; i < 5; ++i) { - scheduler_.RecordStreamEventTime(i, i * 100); - } - for (int i = 1; i < 5; ++i) { - EXPECT_EQ((i - 1) * 100, scheduler_.GetLatestEventWithPrecedence(i)); - } -} - -// Add ready streams at front and back. -TEST_F(Http2PriorityWriteSchedulerTest, MarkReadyFrontAndBack) { - scheduler_.RegisterStream(1, SpdyStreamPrecedence(0, 10, false)); - scheduler_.RegisterStream(2, SpdyStreamPrecedence(0, 20, false)); - scheduler_.RegisterStream(3, SpdyStreamPrecedence(0, 20, false)); - scheduler_.RegisterStream(4, SpdyStreamPrecedence(0, 20, false)); - scheduler_.RegisterStream(5, SpdyStreamPrecedence(0, 30, false)); - - for (int i = 1; i < 6; ++i) { - scheduler_.MarkStreamReady(i, false); - } - EXPECT_EQ(5u, scheduler_.PopNextReadyStream()); - EXPECT_EQ(2u, scheduler_.PopNextReadyStream()); - scheduler_.MarkStreamReady(2, false); - EXPECT_EQ(3u, scheduler_.PopNextReadyStream()); - scheduler_.MarkStreamReady(3, false); - EXPECT_EQ(4u, scheduler_.PopNextReadyStream()); - scheduler_.MarkStreamReady(4, false); - EXPECT_EQ(2u, scheduler_.PopNextReadyStream()); - scheduler_.MarkStreamReady(2, true); - EXPECT_EQ(2u, scheduler_.PopNextReadyStream()); - scheduler_.MarkStreamReady(5, false); - scheduler_.MarkStreamReady(2, true); - EXPECT_EQ(5u, scheduler_.PopNextReadyStream()); -} - -// Add ready streams at front and back and pop them with -// PopNextReadyStreamAndPrecedence. -TEST_F(Http2PriorityWriteSchedulerTest, PopNextReadyStreamAndPrecedence) { - scheduler_.RegisterStream(1, SpdyStreamPrecedence(0, 10, false)); - scheduler_.RegisterStream(2, SpdyStreamPrecedence(0, 20, false)); - scheduler_.RegisterStream(3, SpdyStreamPrecedence(0, 20, false)); - scheduler_.RegisterStream(4, SpdyStreamPrecedence(0, 20, false)); - scheduler_.RegisterStream(5, SpdyStreamPrecedence(0, 30, false)); - - for (int i = 1; i < 6; ++i) { - scheduler_.MarkStreamReady(i, false); - } - EXPECT_EQ(std::make_tuple(5, SpdyStreamPrecedence(0, 30, false)), - scheduler_.PopNextReadyStreamAndPrecedence()); - EXPECT_EQ(std::make_tuple(2, SpdyStreamPrecedence(0, 20, false)), - scheduler_.PopNextReadyStreamAndPrecedence()); - scheduler_.MarkStreamReady(2, false); - EXPECT_EQ(std::make_tuple(3, SpdyStreamPrecedence(0, 20, false)), - scheduler_.PopNextReadyStreamAndPrecedence()); - scheduler_.MarkStreamReady(3, false); - EXPECT_EQ(std::make_tuple(4, SpdyStreamPrecedence(0, 20, false)), - scheduler_.PopNextReadyStreamAndPrecedence()); - scheduler_.MarkStreamReady(4, false); - EXPECT_EQ(std::make_tuple(2, SpdyStreamPrecedence(0, 20, false)), - scheduler_.PopNextReadyStreamAndPrecedence()); - scheduler_.MarkStreamReady(2, true); - EXPECT_EQ(std::make_tuple(2, SpdyStreamPrecedence(0, 20, false)), - scheduler_.PopNextReadyStreamAndPrecedence()); - scheduler_.MarkStreamReady(5, false); - scheduler_.MarkStreamReady(2, true); - EXPECT_EQ(std::make_tuple(5, SpdyStreamPrecedence(0, 30, false)), - scheduler_.PopNextReadyStreamAndPrecedence()); -} - -TEST_F(Http2PriorityWriteSchedulerTest, ShouldYield) { - /* - 0 - /|\ - 1 2 3 - /|\ \ - 4 5 6 7 - | - 8 - - */ - scheduler_.RegisterStream(1, SpdyStreamPrecedence(0, 100, false)); - scheduler_.RegisterStream(2, SpdyStreamPrecedence(0, 100, false)); - scheduler_.RegisterStream(3, SpdyStreamPrecedence(0, 100, false)); - scheduler_.RegisterStream(4, SpdyStreamPrecedence(1, 100, false)); - scheduler_.RegisterStream(5, SpdyStreamPrecedence(1, 200, false)); - scheduler_.RegisterStream(6, SpdyStreamPrecedence(1, 255, false)); - scheduler_.RegisterStream(7, SpdyStreamPrecedence(2, 100, false)); - scheduler_.RegisterStream(8, SpdyStreamPrecedence(5, 100, false)); - - scheduler_.MarkStreamReady(5, false); - - for (int i = 1; i <= 8; ++i) { - // Verify only 4 and 8 should yield to 5. - if (i == 4 || i == 8) { - EXPECT_TRUE(scheduler_.ShouldYield(i)) << "stream_id: " << i; - } else { - EXPECT_FALSE(scheduler_.ShouldYield(i)) << "stream_id: " << i; - } - } - - // Marks streams 1 and 2 ready. - scheduler_.MarkStreamReady(1, false); - scheduler_.MarkStreamReady(2, false); - // 1 should not yield. - EXPECT_FALSE(scheduler_.ShouldYield(1)); - // Verify 2 should yield to 1. - EXPECT_TRUE(scheduler_.ShouldYield(2)); -} - -class PopNextReadyStreamTest : public Http2PriorityWriteSchedulerTest { - protected: - void SetUp() override { - /* Create the tree. - - 0 - /|\ - 1 2 3 - /| |\ - 4 5 6 7 - / - 8 - - */ - scheduler_.RegisterStream(1, SpdyStreamPrecedence(0, 100, false)); - scheduler_.RegisterStream(2, SpdyStreamPrecedence(0, 100, false)); - scheduler_.RegisterStream(3, SpdyStreamPrecedence(0, 100, false)); - scheduler_.RegisterStream(4, SpdyStreamPrecedence(1, 100, false)); - scheduler_.RegisterStream(5, SpdyStreamPrecedence(1, 100, false)); - scheduler_.RegisterStream(6, SpdyStreamPrecedence(2, 100, false)); - scheduler_.RegisterStream(7, SpdyStreamPrecedence(2, 100, false)); - scheduler_.RegisterStream(8, SpdyStreamPrecedence(4, 100, false)); - - // Set all nodes ready to write. - for (SpdyStreamId id = 1; id <= 8; ++id) { - scheduler_.MarkStreamReady(id, false); - } - } - - AssertionResult PopNextReturnsCycle( - std::initializer_list<SpdyStreamId> stream_ids) { - int count = 0; - const int kNumCyclesToCheck = 2; - for (int i = 0; i < kNumCyclesToCheck; i++) { - for (SpdyStreamId expected_id : stream_ids) { - SpdyStreamId next_id = scheduler_.PopNextReadyStream(); - scheduler_.MarkStreamReady(next_id, false); - if (next_id != expected_id) { - return AssertionFailure() << "Pick " << count << ": expected stream " - << expected_id << " instead of " << next_id; - } - if (!peer_.ValidateInvariants()) { - return AssertionFailure() << "ValidateInvariants failed"; - } - ++count; - } - } - return AssertionSuccess(); - } -}; - -// When all streams are schedulable, only top-level streams should be returned. -TEST_F(PopNextReadyStreamTest, NoneBlocked) { - EXPECT_TRUE(PopNextReturnsCycle({1, 2, 3})); -} - -// When a parent stream is blocked, its children should be scheduled, if -// priorities allow. -TEST_F(PopNextReadyStreamTest, SingleStreamBlocked) { - scheduler_.MarkStreamNotReady(1); - - // Round-robin only across 2 and 3, since children of 1 have lower priority. - EXPECT_TRUE(PopNextReturnsCycle({2, 3})); - - // Make children of 1 have equal priority as 2 and 3, after which they should - // be returned as well. - scheduler_.UpdateStreamPrecedence(1, SpdyStreamPrecedence(0, 200, false)); - EXPECT_TRUE(PopNextReturnsCycle({4, 5, 2, 3})); -} - -// Block multiple levels of streams. -TEST_F(PopNextReadyStreamTest, MultiLevelBlocked) { - for (SpdyStreamId stream_id : {1, 4, 5}) { - scheduler_.MarkStreamNotReady(stream_id); - } - // Round-robin only across 2 and 3, since children of 1 have lower priority. - EXPECT_TRUE(PopNextReturnsCycle({2, 3})); - - // Make 8 have equal priority as 2 and 3. - scheduler_.UpdateStreamPrecedence(1, SpdyStreamPrecedence(0, 200, false)); - EXPECT_TRUE(PopNextReturnsCycle({8, 2, 3})); -} - -// A removed stream shouldn't be scheduled. -TEST_F(PopNextReadyStreamTest, RemoveStream) { - scheduler_.UnregisterStream(1); - - // Round-robin only across 2 and 3, since previous children of 1 have lower - // priority (the weight of 4 and 5 is scaled down when they are elevated to - // siblings of 2 and 3). - EXPECT_TRUE(PopNextReturnsCycle({2, 3})); - - // Make previous children of 1 have equal priority as 2 and 3. - scheduler_.UpdateStreamPrecedence(4, SpdyStreamPrecedence(0, 100, false)); - scheduler_.UpdateStreamPrecedence(5, SpdyStreamPrecedence(0, 100, false)); - EXPECT_TRUE(PopNextReturnsCycle({4, 5, 2, 3})); -} - -// Block an entire subtree. -TEST_F(PopNextReadyStreamTest, SubtreeBlocked) { - for (SpdyStreamId stream_id : {1, 4, 5, 8}) { - scheduler_.MarkStreamNotReady(stream_id); - } - EXPECT_TRUE(PopNextReturnsCycle({2, 3})); -} - -// If all parent streams are blocked, children should be returned. -TEST_F(PopNextReadyStreamTest, ParentsBlocked) { - for (SpdyStreamId stream_id : {1, 2, 3}) { - scheduler_.MarkStreamNotReady(stream_id); - } - EXPECT_TRUE(PopNextReturnsCycle({4, 5, 6, 7})); -} - -// Unblocking streams should make them schedulable. -TEST_F(PopNextReadyStreamTest, BlockAndUnblock) { - EXPECT_TRUE(PopNextReturnsCycle({1, 2, 3})); - scheduler_.MarkStreamNotReady(2); - EXPECT_TRUE(PopNextReturnsCycle({1, 3})); - scheduler_.MarkStreamReady(2, false); - // Cycle order permuted since 2 effectively appended at tail. - EXPECT_TRUE(PopNextReturnsCycle({1, 3, 2})); -} - -// Block nodes in multiple subtrees. -TEST_F(PopNextReadyStreamTest, ScatteredBlocked) { - for (SpdyStreamId stream_id : {1, 2, 6, 7}) { - scheduler_.MarkStreamNotReady(stream_id); - } - // Only 3 returned, since of remaining streams it has highest priority. - EXPECT_TRUE(PopNextReturnsCycle({3})); - - // Make children of 1 have priority equal to 3. - scheduler_.UpdateStreamPrecedence(1, SpdyStreamPrecedence(0, 200, false)); - EXPECT_TRUE(PopNextReturnsCycle({4, 5, 3})); - - // When 4 is blocked, its child 8 should take its place, since it has same - // priority. - scheduler_.MarkStreamNotReady(4); - EXPECT_TRUE(PopNextReturnsCycle({8, 5, 3})); -} - -} // namespace test -} // namespace spdy diff --git a/chromium/net/third_party/quiche/src/spdy/core/priority_write_scheduler.h b/chromium/net/third_party/quiche/src/spdy/core/priority_write_scheduler.h deleted file mode 100644 index fde9a286ed5..00000000000 --- a/chromium/net/third_party/quiche/src/spdy/core/priority_write_scheduler.h +++ /dev/null @@ -1,329 +0,0 @@ -// Copyright (c) 2015 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_SPDY_CORE_PRIORITY_WRITE_SCHEDULER_H_ -#define QUICHE_SPDY_CORE_PRIORITY_WRITE_SCHEDULER_H_ - -#include <algorithm> -#include <cstddef> -#include <cstdint> -#include <deque> -#include <string> -#include <tuple> -#include <unordered_map> -#include <utility> -#include <vector> - -#include "absl/strings/str_cat.h" -#include "spdy/core/spdy_protocol.h" -#include "spdy/core/write_scheduler.h" -#include "spdy/platform/api/spdy_bug_tracker.h" -#include "spdy/platform/api/spdy_logging.h" - -namespace spdy { - -namespace test { -template <typename StreamIdType> -class PriorityWriteSchedulerPeer; -} - -// WriteScheduler implementation that manages the order in which streams are -// written using the SPDY priority scheme described at: -// https://www.chromium.org/spdy/spdy-protocol/spdy-protocol-draft3-1#TOC-2.3.3-Stream-priority -// -// Internally, PriorityWriteScheduler consists of 8 PriorityInfo objects, one -// for each priority value. Each PriorityInfo contains a list of streams of -// that priority that are ready to write, as well as a timestamp of the last -// I/O event that occurred for a stream of that priority. -// -// DO NOT USE. Deprecated. -template <typename StreamIdType> -class PriorityWriteScheduler : public WriteScheduler<StreamIdType> { - public: - using typename WriteScheduler<StreamIdType>::StreamPrecedenceType; - - // Creates scheduler with no streams. - PriorityWriteScheduler() : PriorityWriteScheduler(kHttp2RootStreamId) {} - explicit PriorityWriteScheduler(StreamIdType root_stream_id) - : root_stream_id_(root_stream_id) {} - - void RegisterStream(StreamIdType stream_id, - const StreamPrecedenceType& precedence) override { - // TODO(mpw): verify |precedence.is_spdy3_priority() == true| once - // Http2PriorityWriteScheduler enabled for HTTP/2. - - // parent_id not used here, but may as well validate it. However, - // parent_id may legitimately not be registered yet--see b/15676312. - StreamIdType parent_id = precedence.parent_id(); - SPDY_DVLOG_IF(1, - parent_id != root_stream_id_ && !StreamRegistered(parent_id)) - << "Parent stream " << parent_id << " not registered"; - - if (stream_id == root_stream_id_) { - SPDY_BUG(spdy_bug_19_1) - << "Stream " << root_stream_id_ << " already registered"; - return; - } - StreamInfo stream_info = {precedence.spdy3_priority(), stream_id, false}; - bool inserted = - stream_infos_.insert(std::make_pair(stream_id, stream_info)).second; - SPDY_BUG_IF(spdy_bug_19_2, !inserted) - << "Stream " << stream_id << " already registered"; - } - - void UnregisterStream(StreamIdType stream_id) override { - auto it = stream_infos_.find(stream_id); - if (it == stream_infos_.end()) { - SPDY_BUG(spdy_bug_19_3) << "Stream " << stream_id << " not registered"; - return; - } - StreamInfo& stream_info = it->second; - if (stream_info.ready) { - bool erased = - Erase(&priority_infos_[stream_info.priority].ready_list, stream_info); - QUICHE_DCHECK(erased); - } - stream_infos_.erase(it); - } - - bool StreamRegistered(StreamIdType stream_id) const override { - return stream_infos_.find(stream_id) != stream_infos_.end(); - } - - StreamPrecedenceType GetStreamPrecedence( - StreamIdType stream_id) const override { - auto it = stream_infos_.find(stream_id); - if (it == stream_infos_.end()) { - SPDY_DVLOG(1) << "Stream " << stream_id << " not registered"; - return StreamPrecedenceType(kV3LowestPriority); - } - return StreamPrecedenceType(it->second.priority); - } - - void UpdateStreamPrecedence(StreamIdType stream_id, - const StreamPrecedenceType& precedence) override { - // TODO(mpw): verify |precedence.is_spdy3_priority() == true| once - // Http2PriorityWriteScheduler enabled for HTTP/2. - - // parent_id not used here, but may as well validate it. However, - // parent_id may legitimately not be registered yet--see b/15676312. - StreamIdType parent_id = precedence.parent_id(); - SPDY_DVLOG_IF(1, - parent_id != root_stream_id_ && !StreamRegistered(parent_id)) - << "Parent stream " << parent_id << " not registered"; - - auto it = stream_infos_.find(stream_id); - if (it == stream_infos_.end()) { - // TODO(mpw): add to stream_infos_ on demand--see b/15676312. - SPDY_DVLOG(1) << "Stream " << stream_id << " not registered"; - return; - } - StreamInfo& stream_info = it->second; - SpdyPriority new_priority = precedence.spdy3_priority(); - if (stream_info.priority == new_priority) { - return; - } - if (stream_info.ready) { - bool erased = - Erase(&priority_infos_[stream_info.priority].ready_list, stream_info); - QUICHE_DCHECK(erased); - priority_infos_[new_priority].ready_list.push_back(&stream_info); - ++num_ready_streams_; - } - stream_info.priority = new_priority; - } - - std::vector<StreamIdType> GetStreamChildren( - StreamIdType /*stream_id*/) const override { - return std::vector<StreamIdType>(); - } - - void RecordStreamEventTime(StreamIdType stream_id, - int64_t now_in_usec) override { - auto it = stream_infos_.find(stream_id); - if (it == stream_infos_.end()) { - SPDY_BUG(spdy_bug_19_4) << "Stream " << stream_id << " not registered"; - return; - } - PriorityInfo& priority_info = priority_infos_[it->second.priority]; - priority_info.last_event_time_usec = - std::max(priority_info.last_event_time_usec, now_in_usec); - } - - int64_t GetLatestEventWithPrecedence(StreamIdType stream_id) const override { - auto it = stream_infos_.find(stream_id); - if (it == stream_infos_.end()) { - SPDY_BUG(spdy_bug_19_5) << "Stream " << stream_id << " not registered"; - return 0; - } - int64_t last_event_time_usec = 0; - const StreamInfo& stream_info = it->second; - for (SpdyPriority p = kV3HighestPriority; p < stream_info.priority; ++p) { - last_event_time_usec = std::max(last_event_time_usec, - priority_infos_[p].last_event_time_usec); - } - return last_event_time_usec; - } - - StreamIdType PopNextReadyStream() override { - return std::get<0>(PopNextReadyStreamAndPrecedence()); - } - - // Returns the next ready stream and its precedence. - std::tuple<StreamIdType, StreamPrecedenceType> - PopNextReadyStreamAndPrecedence() override { - for (SpdyPriority p = kV3HighestPriority; p <= kV3LowestPriority; ++p) { - ReadyList& ready_list = priority_infos_[p].ready_list; - if (!ready_list.empty()) { - StreamInfo* info = ready_list.front(); - ready_list.pop_front(); - --num_ready_streams_; - - QUICHE_DCHECK(stream_infos_.find(info->stream_id) != - stream_infos_.end()); - info->ready = false; - return std::make_tuple(info->stream_id, - StreamPrecedenceType(info->priority)); - } - } - SPDY_BUG(spdy_bug_19_6) << "No ready streams available"; - return std::make_tuple(0, StreamPrecedenceType(kV3LowestPriority)); - } - - bool ShouldYield(StreamIdType stream_id) const override { - auto it = stream_infos_.find(stream_id); - if (it == stream_infos_.end()) { - SPDY_BUG(spdy_bug_19_7) << "Stream " << stream_id << " not registered"; - return false; - } - - // If there's a higher priority stream, this stream should yield. - const StreamInfo& stream_info = it->second; - for (SpdyPriority p = kV3HighestPriority; p < stream_info.priority; ++p) { - if (!priority_infos_[p].ready_list.empty()) { - return true; - } - } - - // If this priority level is empty, or this stream is the next up, there's - // no need to yield. - const auto& ready_list = priority_infos_[it->second.priority].ready_list; - if (ready_list.empty() || ready_list.front()->stream_id == stream_id) { - return false; - } - - // There are other streams in this priority level which take precedence. - // Yield. - return true; - } - - void MarkStreamReady(StreamIdType stream_id, bool add_to_front) override { - auto it = stream_infos_.find(stream_id); - if (it == stream_infos_.end()) { - SPDY_BUG(spdy_bug_19_8) << "Stream " << stream_id << " not registered"; - return; - } - StreamInfo& stream_info = it->second; - if (stream_info.ready) { - return; - } - ReadyList& ready_list = priority_infos_[stream_info.priority].ready_list; - if (add_to_front) { - ready_list.push_front(&stream_info); - } else { - ready_list.push_back(&stream_info); - } - ++num_ready_streams_; - stream_info.ready = true; - } - - void MarkStreamNotReady(StreamIdType stream_id) override { - auto it = stream_infos_.find(stream_id); - if (it == stream_infos_.end()) { - SPDY_BUG(spdy_bug_19_9) << "Stream " << stream_id << " not registered"; - return; - } - StreamInfo& stream_info = it->second; - if (!stream_info.ready) { - return; - } - bool erased = - Erase(&priority_infos_[stream_info.priority].ready_list, stream_info); - QUICHE_DCHECK(erased); - stream_info.ready = false; - } - - // Returns true iff the number of ready streams is non-zero. - bool HasReadyStreams() const override { return num_ready_streams_ > 0; } - - // Returns the number of ready streams. - size_t NumReadyStreams() const override { return num_ready_streams_; } - - size_t NumRegisteredStreams() const override { return stream_infos_.size(); } - - std::string DebugString() const override { - return absl::StrCat( - "PriorityWriteScheduler {num_streams=", stream_infos_.size(), - " num_ready_streams=", NumReadyStreams(), "}"); - } - - // Returns true if a stream is ready. - bool IsStreamReady(StreamIdType stream_id) const override { - auto it = stream_infos_.find(stream_id); - if (it == stream_infos_.end()) { - SPDY_DLOG(INFO) << "Stream " << stream_id << " not registered"; - return false; - } - return it->second.ready; - } - - private: - friend class test::PriorityWriteSchedulerPeer<StreamIdType>; - - // State kept for all registered streams. All ready streams have ready = true - // and should be present in priority_infos_[priority].ready_list. - struct StreamInfo { - SpdyPriority priority; - StreamIdType stream_id; - bool ready; - }; - - // O(1) size lookup, O(1) insert at front or back (amortized). - using ReadyList = std::deque<StreamInfo*>; - - // State kept for each priority level. - struct PriorityInfo { - // IDs of streams that are ready to write. - ReadyList ready_list; - // Time of latest write event for stream of this priority, in microseconds. - int64_t last_event_time_usec = 0; - }; - - typedef std::unordered_map<StreamIdType, StreamInfo> StreamInfoMap; - - // Erases first occurrence (which should be the only one) of |info| in - // |ready_list|, returning true if found (and erased), or false otherwise. - // Decrements |num_ready_streams_| if an entry is erased. - bool Erase(ReadyList* ready_list, const StreamInfo& info) { - auto it = std::find(ready_list->begin(), ready_list->end(), &info); - if (it == ready_list->end()) { - return false; - } - ready_list->erase(it); - --num_ready_streams_; - return true; - } - - // Number of ready streams. - size_t num_ready_streams_ = 0; - // Per-priority state, including ready lists. - PriorityInfo priority_infos_[kV3LowestPriority + 1]; - // StreamInfos for all registered streams. - StreamInfoMap stream_infos_; - StreamIdType root_stream_id_; -}; - -} // namespace spdy - -#endif // QUICHE_SPDY_CORE_PRIORITY_WRITE_SCHEDULER_H_ diff --git a/chromium/net/third_party/quiche/src/spdy/core/priority_write_scheduler_test.cc b/chromium/net/third_party/quiche/src/spdy/core/priority_write_scheduler_test.cc deleted file mode 100644 index a76e0dc5801..00000000000 --- a/chromium/net/third_party/quiche/src/spdy/core/priority_write_scheduler_test.cc +++ /dev/null @@ -1,377 +0,0 @@ -// Copyright (c) 2015 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 "spdy/core/priority_write_scheduler.h" - -#include "common/platform/api/quiche_test.h" -#include "spdy/core/spdy_protocol.h" -#include "spdy/core/spdy_test_utils.h" -#include "spdy/platform/api/spdy_test_helpers.h" - -namespace spdy { -namespace test { - -template <typename StreamIdType> -class PriorityWriteSchedulerPeer { - public: - explicit PriorityWriteSchedulerPeer( - PriorityWriteScheduler<StreamIdType>* scheduler) - : scheduler_(scheduler) {} - - size_t NumReadyStreams(SpdyPriority priority) const { - return scheduler_->priority_infos_[priority].ready_list.size(); - } - - private: - PriorityWriteScheduler<StreamIdType>* scheduler_; -}; - -namespace { - -class PriorityWriteSchedulerTest : public QuicheTest { - public: - PriorityWriteSchedulerTest() : peer_(&scheduler_) {} - - PriorityWriteScheduler<SpdyStreamId> scheduler_; - PriorityWriteSchedulerPeer<SpdyStreamId> peer_; -}; - -TEST_F(PriorityWriteSchedulerTest, RegisterUnregisterStreams) { - EXPECT_FALSE(scheduler_.HasReadyStreams()); - EXPECT_FALSE(scheduler_.StreamRegistered(1)); - EXPECT_EQ(0u, scheduler_.NumRegisteredStreams()); - scheduler_.RegisterStream(1, SpdyStreamPrecedence(1)); - EXPECT_TRUE(scheduler_.StreamRegistered(1)); - EXPECT_EQ(1u, scheduler_.NumRegisteredStreams()); - - // Root stream counts as already registered. - EXPECT_SPDY_BUG( - scheduler_.RegisterStream(kHttp2RootStreamId, SpdyStreamPrecedence(1)), - "Stream 0 already registered"); - - // Try redundant registrations. - EXPECT_SPDY_BUG(scheduler_.RegisterStream(1, SpdyStreamPrecedence(1)), - "Stream 1 already registered"); - EXPECT_SPDY_BUG(scheduler_.RegisterStream(1, SpdyStreamPrecedence(2)), - "Stream 1 already registered"); - - scheduler_.RegisterStream(2, SpdyStreamPrecedence(3)); - EXPECT_EQ(2u, scheduler_.NumRegisteredStreams()); - - // Verify registration != ready. - EXPECT_FALSE(scheduler_.HasReadyStreams()); - - scheduler_.UnregisterStream(1); - EXPECT_EQ(1u, scheduler_.NumRegisteredStreams()); - scheduler_.UnregisterStream(2); - EXPECT_EQ(0u, scheduler_.NumRegisteredStreams()); - - // Try redundant unregistration. - EXPECT_SPDY_BUG(scheduler_.UnregisterStream(1), "Stream 1 not registered"); - EXPECT_SPDY_BUG(scheduler_.UnregisterStream(2), "Stream 2 not registered"); -} - -TEST_F(PriorityWriteSchedulerTest, RegisterStreamWithHttp2StreamDependency) { - EXPECT_FALSE(scheduler_.HasReadyStreams()); - EXPECT_FALSE(scheduler_.StreamRegistered(1)); - scheduler_.RegisterStream( - 1, SpdyStreamPrecedence(kHttp2RootStreamId, 123, false)); - EXPECT_TRUE(scheduler_.StreamRegistered(1)); - EXPECT_TRUE(scheduler_.GetStreamPrecedence(1).is_spdy3_priority()); - EXPECT_EQ(3, scheduler_.GetStreamPrecedence(1).spdy3_priority()); - EXPECT_FALSE(scheduler_.HasReadyStreams()); - - EXPECT_SPDY_BUG(scheduler_.RegisterStream( - 1, SpdyStreamPrecedence(kHttp2RootStreamId, 256, false)), - "Stream 1 already registered"); - EXPECT_TRUE(scheduler_.GetStreamPrecedence(1).is_spdy3_priority()); - EXPECT_EQ(3, scheduler_.GetStreamPrecedence(1).spdy3_priority()); - - // Registering stream with a non-existent parent stream is permissible, per - // b/15676312, but parent stream will always be reset to 0. - scheduler_.RegisterStream(2, SpdyStreamPrecedence(3, 123, false)); - EXPECT_TRUE(scheduler_.StreamRegistered(2)); - EXPECT_FALSE(scheduler_.StreamRegistered(3)); - EXPECT_EQ(kHttp2RootStreamId, scheduler_.GetStreamPrecedence(2).parent_id()); -} - -TEST_F(PriorityWriteSchedulerTest, GetStreamPrecedence) { - // Unknown streams tolerated due to b/15676312. However, return lowest - // priority. - EXPECT_EQ(kV3LowestPriority, - scheduler_.GetStreamPrecedence(1).spdy3_priority()); - - scheduler_.RegisterStream(1, SpdyStreamPrecedence(3)); - EXPECT_TRUE(scheduler_.GetStreamPrecedence(1).is_spdy3_priority()); - EXPECT_EQ(3, scheduler_.GetStreamPrecedence(1).spdy3_priority()); - - // Redundant registration shouldn't change stream priority. - EXPECT_SPDY_BUG(scheduler_.RegisterStream(1, SpdyStreamPrecedence(4)), - "Stream 1 already registered"); - EXPECT_EQ(3, scheduler_.GetStreamPrecedence(1).spdy3_priority()); - - scheduler_.UpdateStreamPrecedence(1, SpdyStreamPrecedence(5)); - EXPECT_EQ(5, scheduler_.GetStreamPrecedence(1).spdy3_priority()); - - // Toggling ready state shouldn't change stream priority. - scheduler_.MarkStreamReady(1, true); - EXPECT_EQ(5, scheduler_.GetStreamPrecedence(1).spdy3_priority()); - - // Test changing priority of ready stream. - EXPECT_EQ(1u, peer_.NumReadyStreams(5)); - scheduler_.UpdateStreamPrecedence(1, SpdyStreamPrecedence(6)); - EXPECT_EQ(6, scheduler_.GetStreamPrecedence(1).spdy3_priority()); - EXPECT_EQ(0u, peer_.NumReadyStreams(5)); - EXPECT_EQ(1u, peer_.NumReadyStreams(6)); - - EXPECT_EQ(1u, scheduler_.PopNextReadyStream()); - EXPECT_EQ(6, scheduler_.GetStreamPrecedence(1).spdy3_priority()); - - scheduler_.UnregisterStream(1); - EXPECT_EQ(kV3LowestPriority, - scheduler_.GetStreamPrecedence(1).spdy3_priority()); -} - -TEST_F(PriorityWriteSchedulerTest, PopNextReadyStreamAndPrecedence) { - scheduler_.RegisterStream(1, SpdyStreamPrecedence(3)); - scheduler_.MarkStreamReady(1, true); - EXPECT_EQ(std::make_tuple(1u, SpdyStreamPrecedence(3)), - scheduler_.PopNextReadyStreamAndPrecedence()); - scheduler_.UnregisterStream(1); -} - -TEST_F(PriorityWriteSchedulerTest, UpdateStreamPrecedence) { - // For the moment, updating stream precedence on a non-registered stream - // should have no effect. In the future, it will lazily cause the stream to - // be registered (b/15676312). - EXPECT_EQ(kV3LowestPriority, - scheduler_.GetStreamPrecedence(3).spdy3_priority()); - EXPECT_FALSE(scheduler_.StreamRegistered(3)); - scheduler_.UpdateStreamPrecedence(3, SpdyStreamPrecedence(1)); - EXPECT_FALSE(scheduler_.StreamRegistered(3)); - EXPECT_EQ(kV3LowestPriority, - scheduler_.GetStreamPrecedence(3).spdy3_priority()); - - scheduler_.RegisterStream(3, SpdyStreamPrecedence(1)); - EXPECT_EQ(1, scheduler_.GetStreamPrecedence(3).spdy3_priority()); - scheduler_.UpdateStreamPrecedence(3, SpdyStreamPrecedence(2)); - EXPECT_EQ(2, scheduler_.GetStreamPrecedence(3).spdy3_priority()); - - // Updating priority of stream to current priority value is valid, but has no - // effect. - scheduler_.UpdateStreamPrecedence(3, SpdyStreamPrecedence(2)); - EXPECT_EQ(2, scheduler_.GetStreamPrecedence(3).spdy3_priority()); - - // Even though stream 4 is marked ready after stream 5, it should be returned - // first by PopNextReadyStream() since it has higher priority. - scheduler_.RegisterStream(4, SpdyStreamPrecedence(1)); - scheduler_.MarkStreamReady(3, false); // priority 2 - EXPECT_TRUE(scheduler_.IsStreamReady(3)); - scheduler_.MarkStreamReady(4, false); // priority 1 - EXPECT_TRUE(scheduler_.IsStreamReady(4)); - EXPECT_EQ(4u, scheduler_.PopNextReadyStream()); - EXPECT_FALSE(scheduler_.IsStreamReady(4)); - EXPECT_EQ(3u, scheduler_.PopNextReadyStream()); - EXPECT_FALSE(scheduler_.IsStreamReady(3)); - - // Verify that lowering priority of stream 4 causes it to be returned later - // by PopNextReadyStream(). - scheduler_.MarkStreamReady(3, false); // priority 2 - scheduler_.MarkStreamReady(4, false); // priority 1 - scheduler_.UpdateStreamPrecedence(4, SpdyStreamPrecedence(3)); - EXPECT_EQ(3u, scheduler_.PopNextReadyStream()); - EXPECT_EQ(4u, scheduler_.PopNextReadyStream()); - - scheduler_.UnregisterStream(3); -} - -TEST_F(PriorityWriteSchedulerTest, - UpdateStreamPrecedenceWithHttp2StreamDependency) { - // Unknown streams tolerated due to b/15676312, but should have no effect. - scheduler_.UpdateStreamPrecedence(3, SpdyStreamPrecedence(0, 100, false)); - EXPECT_FALSE(scheduler_.StreamRegistered(3)); - - scheduler_.RegisterStream(3, SpdyStreamPrecedence(3)); - scheduler_.UpdateStreamPrecedence(3, SpdyStreamPrecedence(0, 100, false)); - EXPECT_TRUE(scheduler_.GetStreamPrecedence(3).is_spdy3_priority()); - EXPECT_EQ(4, scheduler_.GetStreamPrecedence(3).spdy3_priority()); - - scheduler_.UnregisterStream(3); - scheduler_.UpdateStreamPrecedence(3, SpdyStreamPrecedence(0, 100, false)); - EXPECT_FALSE(scheduler_.StreamRegistered(3)); -} - -TEST_F(PriorityWriteSchedulerTest, MarkStreamReadyBack) { - EXPECT_FALSE(scheduler_.HasReadyStreams()); - EXPECT_SPDY_BUG(scheduler_.MarkStreamReady(1, false), - "Stream 1 not registered"); - EXPECT_FALSE(scheduler_.HasReadyStreams()); - EXPECT_SPDY_BUG(EXPECT_EQ(0u, scheduler_.PopNextReadyStream()), - "No ready streams available"); - - // Add a bunch of ready streams to tail of per-priority lists. - // Expected order: (P2) 4, (P3) 1, 2, 3, (P5) 5. - scheduler_.RegisterStream(1, SpdyStreamPrecedence(3)); - scheduler_.MarkStreamReady(1, false); - EXPECT_TRUE(scheduler_.HasReadyStreams()); - scheduler_.RegisterStream(2, SpdyStreamPrecedence(3)); - scheduler_.MarkStreamReady(2, false); - scheduler_.RegisterStream(3, SpdyStreamPrecedence(3)); - scheduler_.MarkStreamReady(3, false); - scheduler_.RegisterStream(4, SpdyStreamPrecedence(2)); - scheduler_.MarkStreamReady(4, false); - scheduler_.RegisterStream(5, SpdyStreamPrecedence(5)); - scheduler_.MarkStreamReady(5, false); - - EXPECT_EQ(4u, scheduler_.PopNextReadyStream()); - EXPECT_EQ(1u, scheduler_.PopNextReadyStream()); - EXPECT_EQ(2u, scheduler_.PopNextReadyStream()); - EXPECT_EQ(3u, scheduler_.PopNextReadyStream()); - EXPECT_EQ(5u, scheduler_.PopNextReadyStream()); - EXPECT_SPDY_BUG(EXPECT_EQ(0u, scheduler_.PopNextReadyStream()), - "No ready streams available"); -} - -TEST_F(PriorityWriteSchedulerTest, MarkStreamReadyFront) { - EXPECT_FALSE(scheduler_.HasReadyStreams()); - EXPECT_SPDY_BUG(scheduler_.MarkStreamReady(1, true), - "Stream 1 not registered"); - EXPECT_FALSE(scheduler_.HasReadyStreams()); - EXPECT_SPDY_BUG(EXPECT_EQ(0u, scheduler_.PopNextReadyStream()), - "No ready streams available"); - - // Add a bunch of ready streams to head of per-priority lists. - // Expected order: (P2) 4, (P3) 3, 2, 1, (P5) 5 - scheduler_.RegisterStream(1, SpdyStreamPrecedence(3)); - scheduler_.MarkStreamReady(1, true); - EXPECT_TRUE(scheduler_.HasReadyStreams()); - scheduler_.RegisterStream(2, SpdyStreamPrecedence(3)); - scheduler_.MarkStreamReady(2, true); - scheduler_.RegisterStream(3, SpdyStreamPrecedence(3)); - scheduler_.MarkStreamReady(3, true); - scheduler_.RegisterStream(4, SpdyStreamPrecedence(2)); - scheduler_.MarkStreamReady(4, true); - scheduler_.RegisterStream(5, SpdyStreamPrecedence(5)); - scheduler_.MarkStreamReady(5, true); - - EXPECT_EQ(4u, scheduler_.PopNextReadyStream()); - EXPECT_EQ(3u, scheduler_.PopNextReadyStream()); - EXPECT_EQ(2u, scheduler_.PopNextReadyStream()); - EXPECT_EQ(1u, scheduler_.PopNextReadyStream()); - EXPECT_EQ(5u, scheduler_.PopNextReadyStream()); - EXPECT_SPDY_BUG(EXPECT_EQ(0u, scheduler_.PopNextReadyStream()), - "No ready streams available"); -} - -TEST_F(PriorityWriteSchedulerTest, MarkStreamReadyBackAndFront) { - scheduler_.RegisterStream(1, SpdyStreamPrecedence(4)); - scheduler_.RegisterStream(2, SpdyStreamPrecedence(3)); - scheduler_.RegisterStream(3, SpdyStreamPrecedence(3)); - scheduler_.RegisterStream(4, SpdyStreamPrecedence(3)); - scheduler_.RegisterStream(5, SpdyStreamPrecedence(4)); - scheduler_.RegisterStream(6, SpdyStreamPrecedence(1)); - - // Add a bunch of ready streams to per-priority lists, with variety of adding - // at head and tail. - // Expected order: (P1) 6, (P3) 4, 2, 3, (P4) 1, 5 - scheduler_.MarkStreamReady(1, true); - scheduler_.MarkStreamReady(2, true); - scheduler_.MarkStreamReady(3, false); - scheduler_.MarkStreamReady(4, true); - scheduler_.MarkStreamReady(5, false); - scheduler_.MarkStreamReady(6, true); - - EXPECT_EQ(6u, scheduler_.PopNextReadyStream()); - EXPECT_EQ(4u, scheduler_.PopNextReadyStream()); - EXPECT_EQ(2u, scheduler_.PopNextReadyStream()); - EXPECT_EQ(3u, scheduler_.PopNextReadyStream()); - EXPECT_EQ(1u, scheduler_.PopNextReadyStream()); - EXPECT_EQ(5u, scheduler_.PopNextReadyStream()); - EXPECT_SPDY_BUG(EXPECT_EQ(0u, scheduler_.PopNextReadyStream()), - "No ready streams available"); -} - -TEST_F(PriorityWriteSchedulerTest, MarkStreamNotReady) { - // Verify ready state reflected in NumReadyStreams(). - scheduler_.RegisterStream(1, SpdyStreamPrecedence(1)); - EXPECT_EQ(0u, scheduler_.NumReadyStreams()); - scheduler_.MarkStreamReady(1, false); - EXPECT_EQ(1u, scheduler_.NumReadyStreams()); - scheduler_.MarkStreamNotReady(1); - EXPECT_EQ(0u, scheduler_.NumReadyStreams()); - - // Empty pop should fail. - EXPECT_SPDY_BUG(EXPECT_EQ(0u, scheduler_.PopNextReadyStream()), - "No ready streams available"); - - // Tolerate redundant marking of a stream as not ready. - scheduler_.MarkStreamNotReady(1); - EXPECT_EQ(0u, scheduler_.NumReadyStreams()); - - // Should only be able to mark registered streams. - EXPECT_SPDY_BUG(scheduler_.MarkStreamNotReady(3), "Stream 3 not registered"); -} - -TEST_F(PriorityWriteSchedulerTest, UnregisterRemovesStream) { - scheduler_.RegisterStream(3, SpdyStreamPrecedence(4)); - scheduler_.MarkStreamReady(3, false); - EXPECT_EQ(1u, scheduler_.NumReadyStreams()); - - // Unregistering a stream should remove it from set of ready streams. - scheduler_.UnregisterStream(3); - EXPECT_EQ(0u, scheduler_.NumReadyStreams()); - EXPECT_SPDY_BUG(EXPECT_EQ(0u, scheduler_.PopNextReadyStream()), - "No ready streams available"); -} - -TEST_F(PriorityWriteSchedulerTest, ShouldYield) { - scheduler_.RegisterStream(1, SpdyStreamPrecedence(1)); - scheduler_.RegisterStream(4, SpdyStreamPrecedence(4)); - scheduler_.RegisterStream(5, SpdyStreamPrecedence(4)); - scheduler_.RegisterStream(7, SpdyStreamPrecedence(7)); - - // Make sure we don't yield when the list is empty. - EXPECT_FALSE(scheduler_.ShouldYield(1)); - - // Add a low priority stream. - scheduler_.MarkStreamReady(4, false); - // 4 should not yield to itself. - EXPECT_FALSE(scheduler_.ShouldYield(4)); - // 7 should yield as 4 is blocked and a higher priority. - EXPECT_TRUE(scheduler_.ShouldYield(7)); - // 5 should yield to 4 as they are the same priority. - EXPECT_TRUE(scheduler_.ShouldYield(5)); - // 1 should not yield as 1 is higher priority. - EXPECT_FALSE(scheduler_.ShouldYield(1)); - - // Add a second stream in that priority class. - scheduler_.MarkStreamReady(5, false); - // 4 and 5 are both blocked, but 4 is at the front so should not yield. - EXPECT_FALSE(scheduler_.ShouldYield(4)); - EXPECT_TRUE(scheduler_.ShouldYield(5)); -} - -TEST_F(PriorityWriteSchedulerTest, GetLatestEventWithPrecedence) { - EXPECT_SPDY_BUG(scheduler_.RecordStreamEventTime(3, 5), - "Stream 3 not registered"); - EXPECT_SPDY_BUG(EXPECT_EQ(0, scheduler_.GetLatestEventWithPrecedence(4)), - "Stream 4 not registered"); - - for (int i = 1; i < 5; ++i) { - scheduler_.RegisterStream(i, SpdyStreamPrecedence(i)); - } - for (int i = 1; i < 5; ++i) { - EXPECT_EQ(0, scheduler_.GetLatestEventWithPrecedence(i)); - } - for (int i = 1; i < 5; ++i) { - scheduler_.RecordStreamEventTime(i, i * 100); - } - for (int i = 1; i < 5; ++i) { - EXPECT_EQ((i - 1) * 100, scheduler_.GetLatestEventWithPrecedence(i)); - } -} - -} // namespace -} // namespace test -} // namespace spdy diff --git a/chromium/net/third_party/quiche/src/spdy/core/spdy_alt_svc_wire_format.cc b/chromium/net/third_party/quiche/src/spdy/core/spdy_alt_svc_wire_format.cc index 5b6af98a9ac..94218f697da 100644 --- a/chromium/net/third_party/quiche/src/spdy/core/spdy_alt_svc_wire_format.cc +++ b/chromium/net/third_party/quiche/src/spdy/core/spdy_alt_svc_wire_format.cc @@ -9,7 +9,8 @@ #include <limits> #include "absl/strings/str_cat.h" -#include "spdy/platform/api/spdy_logging.h" + +#include "common/platform/api/quiche_logging.h" #include "spdy/platform/api/spdy_string_utils.h" namespace spdy { @@ -195,9 +196,9 @@ bool SpdyAltSvcWireFormat::ParseHeaderFieldValue( // hq=":443";quic=51303338 // ... will be stored in |versions| as 0x51303338. uint32_t quic_version; - if (!SpdyHexDecodeToUInt32(absl::string_view(&*parameter_value_begin, - c - parameter_value_begin), - &quic_version) || + if (!HexDecodeToUInt32(absl::string_view(&*parameter_value_begin, + c - parameter_value_begin), + &quic_version) || quic_version == 0) { return false; } @@ -314,12 +315,12 @@ bool SpdyAltSvcWireFormat::PercentDecode(absl::string_view::const_iterator c, return false; } // Network byte order is big-endian. - char decoded = SpdyHexDigitToInt(*c) << 4; + char decoded = HexDigitToInt(*c) << 4; ++c; if (c == end || !std::isxdigit(*c)) { return false; } - decoded += SpdyHexDigitToInt(*c); + decoded += HexDigitToInt(*c); output->push_back(decoded); } return true; @@ -388,4 +389,41 @@ bool SpdyAltSvcWireFormat::ParsePositiveInteger32( return ParsePositiveIntegerImpl<uint32_t>(c, end, value); } +// static +char SpdyAltSvcWireFormat::HexDigitToInt(char c) { + QUICHE_DCHECK(std::isxdigit(c)); + + if (std::isdigit(c)) { + return c - '0'; + } + if (c >= 'A' && c <= 'F') { + return c - 'A' + 10; + } + if (c >= 'a' && c <= 'f') { + return c - 'a' + 10; + } + + return 0; +} + +// static +bool SpdyAltSvcWireFormat::HexDecodeToUInt32(absl::string_view data, + uint32_t* value) { + if (data.empty() || data.length() > 8u) { + return false; + } + + *value = 0; + for (char c : data) { + if (!std::isxdigit(c)) { + return false; + } + + *value <<= 4; + *value += HexDigitToInt(c); + } + + return true; +} + } // namespace spdy diff --git a/chromium/net/third_party/quiche/src/spdy/core/spdy_alt_svc_wire_format.h b/chromium/net/third_party/quiche/src/spdy/core/spdy_alt_svc_wire_format.h index fccda75ac6e..a8e10948a8c 100644 --- a/chromium/net/third_party/quiche/src/spdy/core/spdy_alt_svc_wire_format.h +++ b/chromium/net/third_party/quiche/src/spdy/core/spdy_alt_svc_wire_format.h @@ -66,21 +66,40 @@ class QUICHE_EXPORT_PRIVATE SpdyAltSvcWireFormat { const AlternativeServiceVector& altsvc_vector); private: + // Forward |*c| over space and tab or until |end| is reached. static void SkipWhiteSpace(absl::string_view::const_iterator* c, absl::string_view::const_iterator end); + // Decode percent-decoded string between |c| and |end| into |*output|. + // Return true on success, false if input is invalid. static bool PercentDecode(absl::string_view::const_iterator c, absl::string_view::const_iterator end, std::string* output); + // Parse the authority part of Alt-Svc between |c| and |end| into |*host| and + // |*port|. Return true on success, false if input is invalid. static bool ParseAltAuthority(absl::string_view::const_iterator c, absl::string_view::const_iterator end, std::string* host, uint16_t* port); + // Parse a positive integer between |c| and |end| into |*value|. + // Return true on success, false if input is not a positive integer or it + // cannot be represented on uint16_t. static bool ParsePositiveInteger16(absl::string_view::const_iterator c, absl::string_view::const_iterator end, uint16_t* value); + // Parse a positive integer between |c| and |end| into |*value|. + // Return true on success, false if input is not a positive integer or it + // cannot be represented on uint32_t. static bool ParsePositiveInteger32(absl::string_view::const_iterator c, absl::string_view::const_iterator end, uint32_t* value); + // Parse |c| as hexadecimal digit, case insensitive. |c| must be [0-9a-fA-F]. + // Output is between 0 and 15. + static char HexDigitToInt(char c); + // Parse |data| as hexadecimal number into |*value|. |data| must only contain + // hexadecimal digits, no "0x" prefix. + // Return true on success, false if input is empty, not valid hexadecimal + // number, or cannot be represented on uint32_t. + static bool HexDecodeToUInt32(absl::string_view data, uint32_t* value); }; } // namespace spdy diff --git a/chromium/net/third_party/quiche/src/spdy/core/spdy_alt_svc_wire_format_test.cc b/chromium/net/third_party/quiche/src/spdy/core/spdy_alt_svc_wire_format_test.cc index e698c2f690b..497f19dad86 100644 --- a/chromium/net/third_party/quiche/src/spdy/core/spdy_alt_svc_wire_format_test.cc +++ b/chromium/net/third_party/quiche/src/spdy/core/spdy_alt_svc_wire_format_test.cc @@ -5,7 +5,6 @@ #include "spdy/core/spdy_alt_svc_wire_format.h" #include "common/platform/api/quiche_test.h" -#include "spdy/platform/api/spdy_logging.h" namespace spdy { @@ -39,10 +38,14 @@ class SpdyAltSvcWireFormatPeer { uint32_t* max_age) { return SpdyAltSvcWireFormat::ParsePositiveInteger32(c, end, max_age); } + static char HexDigitToInt(char c) { + return SpdyAltSvcWireFormat::HexDigitToInt(c); + } + static bool HexDecodeToUInt32(absl::string_view data, uint32_t* value) { + return SpdyAltSvcWireFormat::HexDecodeToUInt32(data, value); + } }; -} // namespace test - namespace { // Generate header field values, possibly with multiply defined parameters and @@ -389,13 +392,13 @@ TEST(SpdyAltSvcWireFormatTest, ParseTruncatedHeaderFieldValue) { TEST(SpdyAltSvcWireFormatTest, SkipWhiteSpace) { absl::string_view input("a \tb "); absl::string_view::const_iterator c = input.begin(); - test::SpdyAltSvcWireFormatPeer::SkipWhiteSpace(&c, input.end()); + SpdyAltSvcWireFormatPeer::SkipWhiteSpace(&c, input.end()); ASSERT_EQ(input.begin(), c); ++c; - test::SpdyAltSvcWireFormatPeer::SkipWhiteSpace(&c, input.end()); + SpdyAltSvcWireFormatPeer::SkipWhiteSpace(&c, input.end()); ASSERT_EQ(input.begin() + 3, c); ++c; - test::SpdyAltSvcWireFormatPeer::SkipWhiteSpace(&c, input.end()); + SpdyAltSvcWireFormatPeer::SkipWhiteSpace(&c, input.end()); ASSERT_EQ(input.end(), c); } @@ -403,20 +406,20 @@ TEST(SpdyAltSvcWireFormatTest, SkipWhiteSpace) { TEST(SpdyAltSvcWireFormatTest, PercentDecodeValid) { absl::string_view input(""); std::string output; - ASSERT_TRUE(test::SpdyAltSvcWireFormatPeer::PercentDecode( - input.begin(), input.end(), &output)); + ASSERT_TRUE(SpdyAltSvcWireFormatPeer::PercentDecode(input.begin(), + input.end(), &output)); EXPECT_EQ("", output); input = absl::string_view("foo"); output.clear(); - ASSERT_TRUE(test::SpdyAltSvcWireFormatPeer::PercentDecode( - input.begin(), input.end(), &output)); + ASSERT_TRUE(SpdyAltSvcWireFormatPeer::PercentDecode(input.begin(), + input.end(), &output)); EXPECT_EQ("foo", output); input = absl::string_view("%2ca%5Cb"); output.clear(); - ASSERT_TRUE(test::SpdyAltSvcWireFormatPeer::PercentDecode( - input.begin(), input.end(), &output)); + ASSERT_TRUE(SpdyAltSvcWireFormatPeer::PercentDecode(input.begin(), + input.end(), &output)); EXPECT_EQ(",a\\b", output); } @@ -426,8 +429,8 @@ TEST(SpdyAltSvcWireFormatTest, PercentDecodeInvalid) { for (const char* invalid_input : invalid_input_array) { absl::string_view input(invalid_input); std::string output; - EXPECT_FALSE(test::SpdyAltSvcWireFormatPeer::PercentDecode( - input.begin(), input.end(), &output)) + EXPECT_FALSE(SpdyAltSvcWireFormatPeer::PercentDecode(input.begin(), + input.end(), &output)) << input; } } @@ -437,19 +440,19 @@ TEST(SpdyAltSvcWireFormatTest, ParseAltAuthorityValid) { absl::string_view input(":42"); std::string host; uint16_t port; - ASSERT_TRUE(test::SpdyAltSvcWireFormatPeer::ParseAltAuthority( + ASSERT_TRUE(SpdyAltSvcWireFormatPeer::ParseAltAuthority( input.begin(), input.end(), &host, &port)); EXPECT_TRUE(host.empty()); EXPECT_EQ(42, port); input = absl::string_view("foo:137"); - ASSERT_TRUE(test::SpdyAltSvcWireFormatPeer::ParseAltAuthority( + ASSERT_TRUE(SpdyAltSvcWireFormatPeer::ParseAltAuthority( input.begin(), input.end(), &host, &port)); EXPECT_EQ("foo", host); EXPECT_EQ(137, port); input = absl::string_view("[2003:8:0:16::509d:9615]:443"); - ASSERT_TRUE(test::SpdyAltSvcWireFormatPeer::ParseAltAuthority( + ASSERT_TRUE(SpdyAltSvcWireFormatPeer::ParseAltAuthority( input.begin(), input.end(), &host, &port)); EXPECT_EQ("[2003:8:0:16::509d:9615]", host); EXPECT_EQ(443, port); @@ -478,7 +481,7 @@ TEST(SpdyAltSvcWireFormatTest, ParseAltAuthorityInvalid) { absl::string_view input(invalid_input); std::string host; uint16_t port; - EXPECT_FALSE(test::SpdyAltSvcWireFormatPeer::ParseAltAuthority( + EXPECT_FALSE(SpdyAltSvcWireFormatPeer::ParseAltAuthority( input.begin(), input.end(), &host, &port)) << input; } @@ -488,12 +491,12 @@ TEST(SpdyAltSvcWireFormatTest, ParseAltAuthorityInvalid) { TEST(SpdyAltSvcWireFormatTest, ParseIntegerValid) { absl::string_view input("3"); uint16_t value; - ASSERT_TRUE(test::SpdyAltSvcWireFormatPeer::ParsePositiveInteger16( + ASSERT_TRUE(SpdyAltSvcWireFormatPeer::ParsePositiveInteger16( input.begin(), input.end(), &value)); EXPECT_EQ(3, value); input = absl::string_view("1337"); - ASSERT_TRUE(test::SpdyAltSvcWireFormatPeer::ParsePositiveInteger16( + ASSERT_TRUE(SpdyAltSvcWireFormatPeer::ParsePositiveInteger16( input.begin(), input.end(), &value)); EXPECT_EQ(1337, value); } @@ -505,7 +508,7 @@ TEST(SpdyAltSvcWireFormatTest, ParseIntegerInvalid) { for (const char* invalid_input : invalid_input_array) { absl::string_view input(invalid_input); uint16_t value; - EXPECT_FALSE(test::SpdyAltSvcWireFormatPeer::ParsePositiveInteger16( + EXPECT_FALSE(SpdyAltSvcWireFormatPeer::ParsePositiveInteger16( input.begin(), input.end(), &value)) << input; } @@ -516,38 +519,38 @@ TEST(SpdyAltSvcWireFormatTest, ParseIntegerOverflow) { // Largest possible uint16_t value. absl::string_view input("65535"); uint16_t value16; - ASSERT_TRUE(test::SpdyAltSvcWireFormatPeer::ParsePositiveInteger16( + ASSERT_TRUE(SpdyAltSvcWireFormatPeer::ParsePositiveInteger16( input.begin(), input.end(), &value16)); EXPECT_EQ(65535, value16); // Overflow uint16_t, ParsePositiveInteger16() should return false. input = absl::string_view("65536"); - ASSERT_FALSE(test::SpdyAltSvcWireFormatPeer::ParsePositiveInteger16( + ASSERT_FALSE(SpdyAltSvcWireFormatPeer::ParsePositiveInteger16( input.begin(), input.end(), &value16)); // However, even if overflow is not checked for, 65536 overflows to 0, which // returns false anyway. Check for a larger number which overflows to 1. input = absl::string_view("65537"); - ASSERT_FALSE(test::SpdyAltSvcWireFormatPeer::ParsePositiveInteger16( + ASSERT_FALSE(SpdyAltSvcWireFormatPeer::ParsePositiveInteger16( input.begin(), input.end(), &value16)); // Largest possible uint32_t value. input = absl::string_view("4294967295"); uint32_t value32; - ASSERT_TRUE(test::SpdyAltSvcWireFormatPeer::ParsePositiveInteger32( + ASSERT_TRUE(SpdyAltSvcWireFormatPeer::ParsePositiveInteger32( input.begin(), input.end(), &value32)); EXPECT_EQ(4294967295, value32); // Overflow uint32_t, ParsePositiveInteger32() should return false. input = absl::string_view("4294967296"); - ASSERT_FALSE(test::SpdyAltSvcWireFormatPeer::ParsePositiveInteger32( + ASSERT_FALSE(SpdyAltSvcWireFormatPeer::ParsePositiveInteger32( input.begin(), input.end(), &value32)); // However, even if overflow is not checked for, 4294967296 overflows to 0, // which returns false anyway. Check for a larger number which overflows to // 1. input = absl::string_view("4294967297"); - ASSERT_FALSE(test::SpdyAltSvcWireFormatPeer::ParsePositiveInteger32( + ASSERT_FALSE(SpdyAltSvcWireFormatPeer::ParsePositiveInteger32( input.begin(), input.end(), &value32)); } @@ -567,6 +570,64 @@ TEST(SpdyAltSvcWireFormatTest, ParseIPLiteral) { EXPECT_THAT(altsvc_vector[0].version, ::testing::ElementsAre(36, 35)); } +TEST(SpdyAltSvcWireFormatTest, HexDigitToInt) { + EXPECT_EQ(0, SpdyAltSvcWireFormatPeer::HexDigitToInt('0')); + EXPECT_EQ(1, SpdyAltSvcWireFormatPeer::HexDigitToInt('1')); + EXPECT_EQ(2, SpdyAltSvcWireFormatPeer::HexDigitToInt('2')); + EXPECT_EQ(3, SpdyAltSvcWireFormatPeer::HexDigitToInt('3')); + EXPECT_EQ(4, SpdyAltSvcWireFormatPeer::HexDigitToInt('4')); + EXPECT_EQ(5, SpdyAltSvcWireFormatPeer::HexDigitToInt('5')); + EXPECT_EQ(6, SpdyAltSvcWireFormatPeer::HexDigitToInt('6')); + EXPECT_EQ(7, SpdyAltSvcWireFormatPeer::HexDigitToInt('7')); + EXPECT_EQ(8, SpdyAltSvcWireFormatPeer::HexDigitToInt('8')); + EXPECT_EQ(9, SpdyAltSvcWireFormatPeer::HexDigitToInt('9')); + + EXPECT_EQ(10, SpdyAltSvcWireFormatPeer::HexDigitToInt('a')); + EXPECT_EQ(11, SpdyAltSvcWireFormatPeer::HexDigitToInt('b')); + EXPECT_EQ(12, SpdyAltSvcWireFormatPeer::HexDigitToInt('c')); + EXPECT_EQ(13, SpdyAltSvcWireFormatPeer::HexDigitToInt('d')); + EXPECT_EQ(14, SpdyAltSvcWireFormatPeer::HexDigitToInt('e')); + EXPECT_EQ(15, SpdyAltSvcWireFormatPeer::HexDigitToInt('f')); + + EXPECT_EQ(10, SpdyAltSvcWireFormatPeer::HexDigitToInt('A')); + EXPECT_EQ(11, SpdyAltSvcWireFormatPeer::HexDigitToInt('B')); + EXPECT_EQ(12, SpdyAltSvcWireFormatPeer::HexDigitToInt('C')); + EXPECT_EQ(13, SpdyAltSvcWireFormatPeer::HexDigitToInt('D')); + EXPECT_EQ(14, SpdyAltSvcWireFormatPeer::HexDigitToInt('E')); + EXPECT_EQ(15, SpdyAltSvcWireFormatPeer::HexDigitToInt('F')); +} + +TEST(SpdyAltSvcWireFormatTest, HexDecodeToUInt32) { + uint32_t out; + EXPECT_TRUE(SpdyAltSvcWireFormatPeer::HexDecodeToUInt32("0", &out)); + EXPECT_EQ(0u, out); + EXPECT_TRUE(SpdyAltSvcWireFormatPeer::HexDecodeToUInt32("00", &out)); + EXPECT_EQ(0u, out); + EXPECT_TRUE(SpdyAltSvcWireFormatPeer::HexDecodeToUInt32("0000000", &out)); + EXPECT_EQ(0u, out); + EXPECT_TRUE(SpdyAltSvcWireFormatPeer::HexDecodeToUInt32("00000000", &out)); + EXPECT_EQ(0u, out); + EXPECT_TRUE(SpdyAltSvcWireFormatPeer::HexDecodeToUInt32("1", &out)); + EXPECT_EQ(1u, out); + EXPECT_TRUE(SpdyAltSvcWireFormatPeer::HexDecodeToUInt32("ffffFFF", &out)); + EXPECT_EQ(0xFFFFFFFu, out); + EXPECT_TRUE(SpdyAltSvcWireFormatPeer::HexDecodeToUInt32("fFfFffFf", &out)); + EXPECT_EQ(0xFFFFFFFFu, out); + EXPECT_TRUE(SpdyAltSvcWireFormatPeer::HexDecodeToUInt32("01AEF", &out)); + EXPECT_EQ(0x1AEFu, out); + EXPECT_TRUE(SpdyAltSvcWireFormatPeer::HexDecodeToUInt32("abcde", &out)); + EXPECT_EQ(0xABCDEu, out); + EXPECT_TRUE(SpdyAltSvcWireFormatPeer::HexDecodeToUInt32("1234abcd", &out)); + EXPECT_EQ(0x1234ABCDu, out); + + EXPECT_FALSE(SpdyAltSvcWireFormatPeer::HexDecodeToUInt32("", &out)); + EXPECT_FALSE(SpdyAltSvcWireFormatPeer::HexDecodeToUInt32("111111111", &out)); + EXPECT_FALSE(SpdyAltSvcWireFormatPeer::HexDecodeToUInt32("1111111111", &out)); + EXPECT_FALSE(SpdyAltSvcWireFormatPeer::HexDecodeToUInt32("0x1111", &out)); +} + } // namespace +} // namespace test + } // namespace spdy diff --git a/chromium/net/third_party/quiche/src/spdy/core/spdy_frame_builder.cc b/chromium/net/third_party/quiche/src/spdy/core/spdy_frame_builder.cc index ee63594ca6c..0b75271bf44 100644 --- a/chromium/net/third_party/quiche/src/spdy/core/spdy_frame_builder.cc +++ b/chromium/net/third_party/quiche/src/spdy/core/spdy_frame_builder.cc @@ -9,10 +9,10 @@ #include <limits> #include <new> +#include "common/platform/api/quiche_bug_tracker.h" +#include "common/platform/api/quiche_logging.h" #include "spdy/core/spdy_protocol.h" #include "spdy/core/zero_copy_output_buffer.h" -#include "spdy/platform/api/spdy_bug_tracker.h" -#include "spdy/platform/api/spdy_logging.h" namespace spdy { @@ -69,7 +69,7 @@ bool SpdyFrameBuilder::BeginNewFrame(SpdyFrameType type, QUICHE_DCHECK_EQ(0u, stream_id & ~kStreamIdMask); bool success = true; if (length_ > 0) { - SPDY_BUG(spdy_bug_73_1) + QUICHE_BUG(spdy_bug_73_1) << "SpdyFrameBuilder doesn't have a clean state when BeginNewFrame" << "is called. Leftover length_ is " << length_; offset_ += length_; @@ -91,7 +91,7 @@ bool SpdyFrameBuilder::BeginNewFrame(SpdyFrameType type, uint8_t raw_frame_type = SerializeFrameType(type); QUICHE_DCHECK(IsDefinedFrameType(raw_frame_type)); QUICHE_DCHECK_EQ(0u, stream_id & ~kStreamIdMask); - SPDY_BUG_IF(spdy_bug_73_2, length > kHttp2DefaultFramePayloadLimit) + QUICHE_BUG_IF(spdy_bug_73_2, length > kHttp2DefaultFramePayloadLimit) << "Frame length " << length_ << " is longer than frame size limit."; return BeginNewFrameInternal(raw_frame_type, flags, stream_id, length); } @@ -168,8 +168,9 @@ bool SpdyFrameBuilder::CanWrite(size_t length) const { if (output_ == nullptr) { if (offset_ + length_ + length > capacity_) { - SPDY_DLOG(FATAL) << "Requested: " << length << " capacity: " << capacity_ - << " used: " << offset_ + length_; + QUICHE_DLOG(FATAL) << "Requested: " << length + << " capacity: " << capacity_ + << " used: " << offset_ + length_; return false; } } else { diff --git a/chromium/net/third_party/quiche/src/spdy/core/spdy_frame_builder.h b/chromium/net/third_party/quiche/src/spdy/core/spdy_frame_builder.h index 01fce6be819..4625aa18a41 100644 --- a/chromium/net/third_party/quiche/src/spdy/core/spdy_frame_builder.h +++ b/chromium/net/third_party/quiche/src/spdy/core/spdy_frame_builder.h @@ -10,11 +10,11 @@ #include <memory> #include "absl/strings/string_view.h" +#include "common/platform/api/quiche_bug_tracker.h" #include "common/platform/api/quiche_export.h" #include "common/quiche_endian.h" #include "spdy/core/spdy_protocol.h" #include "spdy/core/zero_copy_output_buffer.h" -#include "spdy/platform/api/spdy_bug_tracker.h" namespace spdy { @@ -66,10 +66,10 @@ class QUICHE_EXPORT_PRIVATE SpdyFrameBuilder { // Takes the buffer from the SpdyFrameBuilder. SpdySerializedFrame take() { - SPDY_BUG_IF(spdy_bug_39_1, output_ != nullptr) + QUICHE_BUG_IF(spdy_bug_39_1, output_ != nullptr) << "ZeroCopyOutputBuffer is used to build " << "frames. take() shouldn't be called"; - SPDY_BUG_IF(spdy_bug_39_2, kMaxFrameSizeLimit < length_) + QUICHE_BUG_IF(spdy_bug_39_2, kMaxFrameSizeLimit < length_) << "Frame length " << length_ << " is longer than the maximum possible allowed length."; SpdySerializedFrame rv(buffer_.release(), length(), true); diff --git a/chromium/net/third_party/quiche/src/spdy/core/spdy_framer.cc b/chromium/net/third_party/quiche/src/spdy/core/spdy_framer.cc index bc7cd1767a0..d6f0f889876 100644 --- a/chromium/net/third_party/quiche/src/spdy/core/spdy_framer.cc +++ b/chromium/net/third_party/quiche/src/spdy/core/spdy_framer.cc @@ -13,12 +13,12 @@ #include "absl/memory/memory.h" #include "http2/platform/api/http2_macros.h" +#include "common/platform/api/quiche_bug_tracker.h" +#include "common/platform/api/quiche_logging.h" #include "spdy/core/spdy_bitmasks.h" #include "spdy/core/spdy_frame_builder.h" #include "spdy/core/spdy_frame_reader.h" -#include "spdy/platform/api/spdy_bug_tracker.h" #include "spdy/platform/api/spdy_estimate_memory_usage.h" -#include "spdy/platform/api/spdy_logging.h" #include "spdy/platform/api/spdy_string_utils.h" namespace spdy { @@ -129,7 +129,8 @@ bool SerializeHeadersGivenEncoding(const SpdyHeadersIR& headers, } if (!ret) { - SPDY_DLOG(WARNING) << "Failed to build HEADERS. Not enough space in output"; + QUICHE_DLOG(WARNING) + << "Failed to build HEADERS. Not enough space in output"; } return ret; } @@ -159,7 +160,7 @@ bool SerializePushPromiseGivenEncoding(const SpdyPushPromiseIR& push_promise, ok = builder.WriteBytes(padding.data(), padding.length()); } - SPDY_DLOG_IF(ERROR, !ok) + QUICHE_DLOG_IF(ERROR, !ok) << "Failed to write PUSH_PROMISE encoding, not enough " << "space in output"; return ok; @@ -177,8 +178,8 @@ bool WritePayloadWithContinuation(SpdyFrameBuilder* builder, } else if (type == SpdyFrameType::PUSH_PROMISE) { end_flag = PUSH_PROMISE_FLAG_END_PUSH_PROMISE; } else { - SPDY_DLOG(FATAL) << "CONTINUATION frames cannot be used with frame type " - << FrameTypeToString(type); + QUICHE_DLOG(FATAL) << "CONTINUATION frames cannot be used with frame type " + << FrameTypeToString(type); } // Write all the padding payload and as much of the data payload as possible @@ -294,7 +295,7 @@ SpdyFramer::SpdyFrameIterator::~SpdyFrameIterator() = default; size_t SpdyFramer::SpdyFrameIterator::NextFrame(ZeroCopyOutputBuffer* output) { const SpdyFrameIR& frame_ir = GetIR(); if (!has_next_frame_) { - SPDY_BUG(spdy_bug_75_1) + QUICHE_BUG(spdy_bug_75_1) << "SpdyFramer::SpdyFrameIterator::NextFrame called without " << "a next frame."; return false; @@ -422,7 +423,7 @@ std::unique_ptr<SpdyFrameSequence> SpdyFramer::CreateIterator( frame_ir.release()))); } case SpdyFrameType::DATA: { - SPDY_DVLOG(1) << "Serialize a stream end DATA frame for VTL"; + QUICHE_DVLOG(1) << "Serialize a stream end DATA frame for VTL"; HTTP2_FALLTHROUGH; } default: { diff --git a/chromium/net/third_party/quiche/src/spdy/core/spdy_framer_test.cc b/chromium/net/third_party/quiche/src/spdy/core/spdy_framer_test.cc index d7fb6a7a332..c4b5979a874 100644 --- a/chromium/net/third_party/quiche/src/spdy/core/spdy_framer_test.cc +++ b/chromium/net/third_party/quiche/src/spdy/core/spdy_framer_test.cc @@ -14,6 +14,7 @@ #include <vector> #include "absl/base/macros.h" +#include "common/platform/api/quiche_logging.h" #include "common/platform/api/quiche_test.h" #include "spdy/core/array_output_buffer.h" #include "spdy/core/mock_spdy_framer_visitor.h" @@ -23,8 +24,6 @@ #include "spdy/core/spdy_frame_reader.h" #include "spdy/core/spdy_protocol.h" #include "spdy/core/spdy_test_utils.h" -#include "spdy/platform/api/spdy_flags.h" -#include "spdy/platform/api/spdy_logging.h" #include "spdy/platform/api/spdy_string_utils.h" using ::http2::Http2DecoderAdapter; @@ -62,7 +61,7 @@ MATCHER_P(IsFrameUnionOf, frame_list, "") { size_t size_verified = 0; for (const auto& frame : *frame_list) { if (arg.size() < size_verified + frame.size()) { - SPDY_LOG(FATAL) + QUICHE_LOG(FATAL) << "Incremental header serialization should not lead to a " << "higher total frame length than non-incremental method."; return false; @@ -268,16 +267,16 @@ class TestSpdyVisitor : public SpdyFramerVisitorInterface, void OnError(Http2DecoderAdapter::SpdyFramerError error, std::string /*detailed_error*/) override { - SPDY_VLOG(1) << "SpdyFramer Error: " - << Http2DecoderAdapter::SpdyFramerErrorToString(error); + QUICHE_VLOG(1) << "SpdyFramer Error: " + << Http2DecoderAdapter::SpdyFramerErrorToString(error); ++error_count_; } void OnDataFrameHeader(SpdyStreamId stream_id, size_t length, bool fin) override { - SPDY_VLOG(1) << "OnDataFrameHeader(" << stream_id << ", " << length << ", " - << fin << ")"; + QUICHE_VLOG(1) << "OnDataFrameHeader(" << stream_id << ", " << length + << ", " << fin << ")"; ++data_frame_count_; header_stream_id_ = stream_id; } @@ -285,30 +284,30 @@ class TestSpdyVisitor : public SpdyFramerVisitorInterface, void OnStreamFrameData(SpdyStreamId stream_id, const char* data, size_t len) override { - SPDY_VLOG(1) << "OnStreamFrameData(" << stream_id << ", data, " << len - << ", " - << ") data:\n" - << SpdyHexDump(absl::string_view(data, len)); + QUICHE_VLOG(1) << "OnStreamFrameData(" << stream_id << ", data, " << len + << ", " + << ") data:\n" + << SpdyHexDump(absl::string_view(data, len)); EXPECT_EQ(header_stream_id_, stream_id); data_bytes_ += len; } void OnStreamEnd(SpdyStreamId stream_id) override { - SPDY_VLOG(1) << "OnStreamEnd(" << stream_id << ")"; + QUICHE_VLOG(1) << "OnStreamEnd(" << stream_id << ")"; EXPECT_EQ(header_stream_id_, stream_id); ++end_of_stream_count_; } void OnStreamPadLength(SpdyStreamId stream_id, size_t value) override { - SPDY_VLOG(1) << "OnStreamPadding(" << stream_id << ", " << value << ")\n"; + QUICHE_VLOG(1) << "OnStreamPadding(" << stream_id << ", " << value << ")\n"; EXPECT_EQ(header_stream_id_, stream_id); // Count the padding length field byte against total data bytes. data_bytes_ += 1; } void OnStreamPadding(SpdyStreamId stream_id, size_t len) override { - SPDY_VLOG(1) << "OnStreamPadding(" << stream_id << ", " << len << ")\n"; + QUICHE_VLOG(1) << "OnStreamPadding(" << stream_id << ", " << len << ")\n"; EXPECT_EQ(header_stream_id_, stream_id); data_bytes_ += len; } @@ -329,34 +328,34 @@ class TestSpdyVisitor : public SpdyFramerVisitorInterface, } void OnRstStream(SpdyStreamId stream_id, SpdyErrorCode error_code) override { - SPDY_VLOG(1) << "OnRstStream(" << stream_id << ", " << error_code << ")"; + QUICHE_VLOG(1) << "OnRstStream(" << stream_id << ", " << error_code << ")"; ++fin_frame_count_; } void OnSetting(SpdySettingsId id, uint32_t value) override { - SPDY_VLOG(1) << "OnSetting(" << id << ", " << std::hex << value << ")"; + QUICHE_VLOG(1) << "OnSetting(" << id << ", " << std::hex << value << ")"; ++setting_count_; } void OnSettingsAck() override { - SPDY_VLOG(1) << "OnSettingsAck"; + QUICHE_VLOG(1) << "OnSettingsAck"; ++settings_ack_received_; } void OnSettingsEnd() override { - SPDY_VLOG(1) << "OnSettingsEnd"; + QUICHE_VLOG(1) << "OnSettingsEnd"; ++settings_ack_sent_; } void OnPing(SpdyPingId unique_id, bool is_ack) override { - SPDY_LOG(DFATAL) << "OnPing(" << unique_id << ", " << (is_ack ? 1 : 0) - << ")"; + QUICHE_LOG(DFATAL) << "OnPing(" << unique_id << ", " << (is_ack ? 1 : 0) + << ")"; } void OnGoAway(SpdyStreamId last_accepted_stream_id, SpdyErrorCode error_code) override { - SPDY_VLOG(1) << "OnGoAway(" << last_accepted_stream_id << ", " << error_code - << ")"; + QUICHE_VLOG(1) << "OnGoAway(" << last_accepted_stream_id << ", " + << error_code << ")"; ++goaway_count_; } @@ -367,9 +366,9 @@ class TestSpdyVisitor : public SpdyFramerVisitorInterface, bool exclusive, bool fin, bool end) override { - SPDY_VLOG(1) << "OnHeaders(" << stream_id << ", " << has_priority << ", " - << weight << ", " << parent_stream_id << ", " << exclusive - << ", " << fin << ", " << end << ")"; + QUICHE_VLOG(1) << "OnHeaders(" << stream_id << ", " << has_priority << ", " + << weight << ", " << parent_stream_id << ", " << exclusive + << ", " << fin << ", " << end << ")"; ++headers_frame_count_; InitHeaderStreaming(SpdyFrameType::HEADERS, stream_id); if (fin) { @@ -381,8 +380,8 @@ class TestSpdyVisitor : public SpdyFramerVisitorInterface, } void OnWindowUpdate(SpdyStreamId stream_id, int delta_window_size) override { - SPDY_VLOG(1) << "OnWindowUpdate(" << stream_id << ", " << delta_window_size - << ")"; + QUICHE_VLOG(1) << "OnWindowUpdate(" << stream_id << ", " + << delta_window_size << ")"; last_window_update_stream_ = stream_id; last_window_update_delta_ = delta_window_size; } @@ -390,8 +389,8 @@ class TestSpdyVisitor : public SpdyFramerVisitorInterface, void OnPushPromise(SpdyStreamId stream_id, SpdyStreamId promised_stream_id, bool end) override { - SPDY_VLOG(1) << "OnPushPromise(" << stream_id << ", " << promised_stream_id - << ", " << end << ")"; + QUICHE_VLOG(1) << "OnPushPromise(" << stream_id << ", " + << promised_stream_id << ", " << end << ")"; ++push_promise_frame_count_; InitHeaderStreaming(SpdyFrameType::PUSH_PROMISE, stream_id); last_push_promise_stream_ = stream_id; @@ -399,7 +398,7 @@ class TestSpdyVisitor : public SpdyFramerVisitorInterface, } void OnContinuation(SpdyStreamId stream_id, bool end) override { - SPDY_VLOG(1) << "OnContinuation(" << stream_id << ", " << end << ")"; + QUICHE_VLOG(1) << "OnContinuation(" << stream_id << ", " << end << ")"; ++continuation_count_; } @@ -407,8 +406,8 @@ class TestSpdyVisitor : public SpdyFramerVisitorInterface, absl::string_view origin, const SpdyAltSvcWireFormat::AlternativeServiceVector& altsvc_vector) override { - SPDY_VLOG(1) << "OnAltSvc(" << stream_id << ", \"" << origin - << "\", altsvc_vector)"; + QUICHE_VLOG(1) << "OnAltSvc(" << stream_id << ", \"" << origin + << "\", altsvc_vector)"; test_altsvc_ir_ = std::make_unique<SpdyAltSvcIR>(stream_id); if (origin.length() > 0) { test_altsvc_ir_->set_origin(std::string(origin)); @@ -423,19 +422,20 @@ class TestSpdyVisitor : public SpdyFramerVisitorInterface, SpdyStreamId parent_stream_id, int weight, bool exclusive) override { - SPDY_VLOG(1) << "OnPriority(" << stream_id << ", " << parent_stream_id - << ", " << weight << ", " << (exclusive ? 1 : 0) << ")"; + QUICHE_VLOG(1) << "OnPriority(" << stream_id << ", " << parent_stream_id + << ", " << weight << ", " << (exclusive ? 1 : 0) << ")"; ++priority_count_; } void OnPriorityUpdate(SpdyStreamId prioritized_stream_id, absl::string_view priority_field_value) override { - SPDY_VLOG(1) << "OnPriorityUpdate(" << prioritized_stream_id << ", " - << priority_field_value << ")"; + QUICHE_VLOG(1) << "OnPriorityUpdate(" << prioritized_stream_id << ", " + << priority_field_value << ")"; } bool OnUnknownFrame(SpdyStreamId stream_id, uint8_t frame_type) override { - SPDY_VLOG(1) << "OnUnknownFrame(" << stream_id << ", " << frame_type << ")"; + QUICHE_VLOG(1) << "OnUnknownFrame(" << stream_id << ", " << frame_type + << ")"; return on_unknown_frame_result_; } @@ -443,8 +443,8 @@ class TestSpdyVisitor : public SpdyFramerVisitorInterface, SpdyFrameType type, size_t payload_len, size_t frame_len) override { - SPDY_VLOG(1) << "OnSendCompressedFrame(" << stream_id << ", " << type - << ", " << payload_len << ", " << frame_len << ")"; + QUICHE_VLOG(1) << "OnSendCompressedFrame(" << stream_id << ", " << type + << ", " << payload_len << ", " << frame_len << ")"; last_payload_len_ = payload_len; last_frame_len_ = frame_len; } @@ -452,8 +452,8 @@ class TestSpdyVisitor : public SpdyFramerVisitorInterface, void OnReceiveCompressedFrame(SpdyStreamId stream_id, SpdyFrameType type, size_t frame_len) override { - SPDY_VLOG(1) << "OnReceiveCompressedFrame(" << stream_id << ", " << type - << ", " << frame_len << ")"; + QUICHE_VLOG(1) << "OnReceiveCompressedFrame(" << stream_id << ", " << type + << ", " << frame_len << ")"; last_frame_len_ = frame_len; } @@ -479,8 +479,9 @@ class TestSpdyVisitor : public SpdyFramerVisitorInterface, void InitHeaderStreaming(SpdyFrameType header_control_type, SpdyStreamId stream_id) { if (!IsDefinedFrameType(SerializeFrameType(header_control_type))) { - SPDY_DLOG(FATAL) << "Attempted to init header streaming with " - << "invalid control frame type: " << header_control_type; + QUICHE_DLOG(FATAL) << "Attempted to init header streaming with " + << "invalid control frame type: " + << header_control_type; } memset(header_buffer_.get(), 0, header_buffer_size_); header_buffer_length_ = 0; @@ -4817,8 +4818,8 @@ TEST_P(SpdyFramerTest, ProcessAllInput) { const size_t frame1_size = frame1.size(); const size_t frame2_size = frame2.size(); - SPDY_VLOG(1) << "frame1_size = " << frame1_size; - SPDY_VLOG(1) << "frame2_size = " << frame2_size; + QUICHE_VLOG(1) << "frame1_size = " << frame1_size; + QUICHE_VLOG(1) << "frame2_size = " << frame2_size; std::string input_buffer; input_buffer.append(frame1.data(), frame1_size); @@ -4827,7 +4828,7 @@ TEST_P(SpdyFramerTest, ProcessAllInput) { const char* buf = input_buffer.data(); const size_t buf_size = input_buffer.size(); - SPDY_VLOG(1) << "buf_size = " << buf_size; + QUICHE_VLOG(1) << "buf_size = " << buf_size; size_t processed = deframer_.ProcessInput(buf, buf_size); EXPECT_EQ(buf_size, processed); diff --git a/chromium/net/third_party/quiche/src/spdy/core/spdy_header_block.cc b/chromium/net/third_party/quiche/src/spdy/core/spdy_header_block.cc index 59a9069a220..b5790470e02 100644 --- a/chromium/net/third_party/quiche/src/spdy/core/spdy_header_block.cc +++ b/chromium/net/third_party/quiche/src/spdy/core/spdy_header_block.cc @@ -10,8 +10,8 @@ #include <utility> #include "absl/strings/str_cat.h" +#include "common/platform/api/quiche_logging.h" #include "spdy/platform/api/spdy_estimate_memory_usage.h" -#include "spdy/platform/api/spdy_logging.h" namespace spdy { namespace { @@ -144,14 +144,14 @@ Http2HeaderBlock::ValueProxy& Http2HeaderBlock::ValueProxy::operator=( *spdy_header_block_value_size_ += value.size(); SpdyHeaderStorage* storage = &block_->storage_; if (lookup_result_ == block_->map_.end()) { - SPDY_DVLOG(1) << "Inserting: (" << key_ << ", " << value << ")"; + QUICHE_DVLOG(1) << "Inserting: (" << key_ << ", " << value << ")"; lookup_result_ = block_->map_ .emplace(std::make_pair( key_, HeaderValue(storage, key_, storage->Write(value)))) .first; } else { - SPDY_DVLOG(1) << "Updating key: " << key_ << " with value: " << value; + QUICHE_DVLOG(1) << "Updating key: " << key_ << " with value: " << value; *spdy_header_block_value_size_ -= lookup_result_->second.SizeEstimate(); lookup_result_->second = HeaderValue(storage, key_, storage->Write(value)); } @@ -232,7 +232,7 @@ std::string Http2HeaderBlock::DebugString() const { void Http2HeaderBlock::erase(absl::string_view key) { auto iter = map_.find(key); if (iter != map_.end()) { - SPDY_DVLOG(1) << "Erasing header with name: " << key; + QUICHE_DVLOG(1) << "Erasing header with name: " << key; key_size_ -= key.size(); value_size_ -= iter->second.SizeEstimate(); map_.erase(iter); @@ -252,12 +252,12 @@ void Http2HeaderBlock::insert(const Http2HeaderBlock::value_type& value) { auto iter = map_.find(value.first); if (iter == map_.end()) { - SPDY_DVLOG(1) << "Inserting: (" << value.first << ", " << value.second - << ")"; + QUICHE_DVLOG(1) << "Inserting: (" << value.first << ", " << value.second + << ")"; AppendHeader(value.first, value.second); } else { - SPDY_DVLOG(1) << "Updating key: " << iter->first - << " with value: " << value.second; + QUICHE_DVLOG(1) << "Updating key: " << iter->first + << " with value: " << value.second; value_size_ -= iter->second.SizeEstimate(); iter->second = HeaderValue(&storage_, iter->first, storage_.Write(value.second)); @@ -266,16 +266,16 @@ void Http2HeaderBlock::insert(const Http2HeaderBlock::value_type& value) { Http2HeaderBlock::ValueProxy Http2HeaderBlock::operator[]( const absl::string_view key) { - SPDY_DVLOG(2) << "Operator[] saw key: " << key; + QUICHE_DVLOG(2) << "Operator[] saw key: " << key; absl::string_view out_key; auto iter = map_.find(key); if (iter == map_.end()) { // We write the key first, to assure that the ValueProxy has a // reference to a valid absl::string_view in its operator=. out_key = WriteKey(key); - SPDY_DVLOG(2) << "Key written as: " << std::hex - << static_cast<const void*>(key.data()) << ", " << std::dec - << key.size(); + QUICHE_DVLOG(2) << "Key written as: " << std::hex + << static_cast<const void*>(key.data()) << ", " << std::dec + << key.size(); } else { out_key = iter->first; } @@ -288,13 +288,13 @@ void Http2HeaderBlock::AppendValueOrAddHeader(const absl::string_view key, auto iter = map_.find(key); if (iter == map_.end()) { - SPDY_DVLOG(1) << "Inserting: (" << key << ", " << value << ")"; + QUICHE_DVLOG(1) << "Inserting: (" << key << ", " << value << ")"; AppendHeader(key, value); return; } - SPDY_DVLOG(1) << "Updating key: " << iter->first - << "; appending value: " << value; + QUICHE_DVLOG(1) << "Updating key: " << iter->first + << "; appending value: " << value; value_size_ += SeparatorForKey(key).size(); iter->second.Append(storage_.Write(value)); } diff --git a/chromium/net/third_party/quiche/src/spdy/core/spdy_header_storage.cc b/chromium/net/third_party/quiche/src/spdy/core/spdy_header_storage.cc index 207a3be6e00..e99590568b9 100644 --- a/chromium/net/third_party/quiche/src/spdy/core/spdy_header_storage.cc +++ b/chromium/net/third_party/quiche/src/spdy/core/spdy_header_storage.cc @@ -2,7 +2,7 @@ #include <cstring> -#include "spdy/platform/api/spdy_logging.h" +#include "common/platform/api/quiche_logging.h" namespace spdy { namespace { diff --git a/chromium/net/third_party/quiche/src/spdy/core/spdy_prefixed_buffer_reader.cc b/chromium/net/third_party/quiche/src/spdy/core/spdy_prefixed_buffer_reader.cc index 0cb07cf48b0..767dea36074 100644 --- a/chromium/net/third_party/quiche/src/spdy/core/spdy_prefixed_buffer_reader.cc +++ b/chromium/net/third_party/quiche/src/spdy/core/spdy_prefixed_buffer_reader.cc @@ -6,7 +6,7 @@ #include <new> -#include "spdy/platform/api/spdy_logging.h" +#include "common/platform/api/quiche_logging.h" namespace spdy { diff --git a/chromium/net/third_party/quiche/src/spdy/core/spdy_protocol.cc b/chromium/net/third_party/quiche/src/spdy/core/spdy_protocol.cc index ea90b6500ed..4bde56a29d7 100644 --- a/chromium/net/third_party/quiche/src/spdy/core/spdy_protocol.cc +++ b/chromium/net/third_party/quiche/src/spdy/core/spdy_protocol.cc @@ -8,7 +8,7 @@ #include <ostream> #include "absl/strings/str_cat.h" -#include "spdy/platform/api/spdy_bug_tracker.h" +#include "common/platform/api/quiche_bug_tracker.h" namespace spdy { @@ -28,7 +28,7 @@ SpdyPriority ClampSpdy3Priority(SpdyPriority priority) { "The value of given priority shouldn't be smaller than highest " "priority. Check this invariant explicitly."); if (priority > kV3LowestPriority) { - SPDY_BUG(spdy_bug_22_1) + QUICHE_BUG(spdy_bug_22_1) << "Invalid priority: " << static_cast<int>(priority); return kV3LowestPriority; } @@ -37,11 +37,11 @@ SpdyPriority ClampSpdy3Priority(SpdyPriority priority) { int ClampHttp2Weight(int weight) { if (weight < kHttp2MinStreamWeight) { - SPDY_BUG(spdy_bug_22_2) << "Invalid weight: " << weight; + QUICHE_BUG(spdy_bug_22_2) << "Invalid weight: " << weight; return kHttp2MinStreamWeight; } if (weight > kHttp2MaxStreamWeight) { - SPDY_BUG(spdy_bug_22_3) << "Invalid weight: " << weight; + QUICHE_BUG(spdy_bug_22_3) << "Invalid weight: " << weight; return kHttp2MaxStreamWeight; } return weight; @@ -92,7 +92,7 @@ bool IsDefinedFrameType(uint8_t frame_type_field) { } SpdyFrameType ParseFrameType(uint8_t frame_type_field) { - SPDY_BUG_IF(spdy_bug_22_4, !IsDefinedFrameType(frame_type_field)) + QUICHE_BUG_IF(spdy_bug_22_4, !IsDefinedFrameType(frame_type_field)) << "Frame type not defined: " << static_cast<int>(frame_type_field); return static_cast<SpdyFrameType>(frame_type_field); } @@ -462,7 +462,7 @@ SpdyFrameType SpdyContinuationIR::frame_type() const { size_t SpdyContinuationIR::size() const { // We don't need to get the size of CONTINUATION frame directly. It is // calculated in HEADERS or PUSH_PROMISE frame. - SPDY_DLOG(WARNING) << "Shouldn't not call size() for CONTINUATION frame."; + QUICHE_DLOG(WARNING) << "Shouldn't not call size() for CONTINUATION frame."; return 0; } diff --git a/chromium/net/third_party/quiche/src/spdy/core/spdy_protocol.h b/chromium/net/third_party/quiche/src/spdy/core/spdy_protocol.h index d4a671b8933..16d6b9a7ecd 100644 --- a/chromium/net/third_party/quiche/src/spdy/core/spdy_protocol.h +++ b/chromium/net/third_party/quiche/src/spdy/core/spdy_protocol.h @@ -21,11 +21,10 @@ #include "absl/strings/string_view.h" #include "common/platform/api/quiche_export.h" +#include "common/platform/api/quiche_logging.h" #include "spdy/core/spdy_alt_svc_wire_format.h" #include "spdy/core/spdy_bitmasks.h" #include "spdy/core/spdy_header_block.h" -#include "spdy/platform/api/spdy_bug_tracker.h" -#include "spdy/platform/api/spdy_logging.h" namespace spdy { diff --git a/chromium/net/third_party/quiche/src/spdy/core/spdy_protocol_test.cc b/chromium/net/third_party/quiche/src/spdy/core/spdy_protocol_test.cc index 966c4716c75..dbea0e328ca 100644 --- a/chromium/net/third_party/quiche/src/spdy/core/spdy_protocol_test.cc +++ b/chromium/net/third_party/quiche/src/spdy/core/spdy_protocol_test.cc @@ -9,9 +9,9 @@ #include <memory> #include "common/platform/api/quiche_test.h" +#include "common/platform/api/quiche_test_helpers.h" #include "spdy/core/spdy_bitmasks.h" #include "spdy/core/spdy_test_utils.h" -#include "spdy/platform/api/spdy_test_helpers.h" namespace spdy { @@ -31,16 +31,16 @@ std::ostream& operator<<(std::ostream& os, namespace test { TEST(SpdyProtocolTest, ClampSpdy3Priority) { - EXPECT_SPDY_BUG(EXPECT_EQ(7, ClampSpdy3Priority(8)), "Invalid priority: 8"); + EXPECT_QUICHE_BUG(EXPECT_EQ(7, ClampSpdy3Priority(8)), "Invalid priority: 8"); EXPECT_EQ(kV3LowestPriority, ClampSpdy3Priority(kV3LowestPriority)); EXPECT_EQ(kV3HighestPriority, ClampSpdy3Priority(kV3HighestPriority)); } TEST(SpdyProtocolTest, ClampHttp2Weight) { - EXPECT_SPDY_BUG(EXPECT_EQ(kHttp2MinStreamWeight, ClampHttp2Weight(0)), - "Invalid weight: 0"); - EXPECT_SPDY_BUG(EXPECT_EQ(kHttp2MaxStreamWeight, ClampHttp2Weight(300)), - "Invalid weight: 300"); + EXPECT_QUICHE_BUG(EXPECT_EQ(kHttp2MinStreamWeight, ClampHttp2Weight(0)), + "Invalid weight: 0"); + EXPECT_QUICHE_BUG(EXPECT_EQ(kHttp2MaxStreamWeight, ClampHttp2Weight(300)), + "Invalid weight: 300"); EXPECT_EQ(kHttp2MinStreamWeight, ClampHttp2Weight(kHttp2MinStreamWeight)); EXPECT_EQ(kHttp2MaxStreamWeight, ClampHttp2Weight(kHttp2MaxStreamWeight)); } @@ -175,14 +175,14 @@ TEST(SpdyStreamPrecedenceTest, Basic) { } TEST(SpdyStreamPrecedenceTest, Clamping) { - EXPECT_SPDY_BUG(EXPECT_EQ(7, SpdyStreamPrecedence(8).spdy3_priority()), - "Invalid priority: 8"); - EXPECT_SPDY_BUG(EXPECT_EQ(kHttp2MinStreamWeight, - SpdyStreamPrecedence(3, 0, false).weight()), - "Invalid weight: 0"); - EXPECT_SPDY_BUG(EXPECT_EQ(kHttp2MaxStreamWeight, - SpdyStreamPrecedence(3, 300, false).weight()), - "Invalid weight: 300"); + EXPECT_QUICHE_BUG(EXPECT_EQ(7, SpdyStreamPrecedence(8).spdy3_priority()), + "Invalid priority: 8"); + EXPECT_QUICHE_BUG(EXPECT_EQ(kHttp2MinStreamWeight, + SpdyStreamPrecedence(3, 0, false).weight()), + "Invalid weight: 0"); + EXPECT_QUICHE_BUG(EXPECT_EQ(kHttp2MaxStreamWeight, + SpdyStreamPrecedence(3, 300, false).weight()), + "Invalid weight: 300"); } TEST(SpdyStreamPrecedenceTest, Copying) { diff --git a/chromium/net/third_party/quiche/src/spdy/core/spdy_protocol_test_utils.cc b/chromium/net/third_party/quiche/src/spdy/core/spdy_protocol_test_utils.cc index 63917499eb9..1888176d673 100644 --- a/chromium/net/third_party/quiche/src/spdy/core/spdy_protocol_test_utils.cc +++ b/chromium/net/third_party/quiche/src/spdy/core/spdy_protocol_test_utils.cc @@ -17,7 +17,7 @@ namespace test { ::testing::AssertionResult VerifySpdyFrameWithHeaderBlockIREquals( const SpdyFrameWithHeaderBlockIR& expected, const SpdyFrameWithHeaderBlockIR& actual) { - SPDY_VLOG(1) << "VerifySpdyFrameWithHeaderBlockIREquals"; + QUICHE_VLOG(1) << "VerifySpdyFrameWithHeaderBlockIREquals"; VERIFY_TRUE(actual.header_block() == expected.header_block()); return ::testing::AssertionSuccess(); } @@ -40,7 +40,7 @@ namespace test { ::testing::AssertionResult VerifySpdyFrameIREquals(const SpdyDataIR& expected, const SpdyDataIR& actual) { - SPDY_VLOG(1) << "VerifySpdyFrameIREquals SpdyDataIR"; + QUICHE_VLOG(1) << "VerifySpdyFrameIREquals SpdyDataIR"; VERIFY_EQ(expected.stream_id(), actual.stream_id()); VERIFY_EQ(expected.fin(), actual.fin()); VERIFY_EQ(expected.data_len(), actual.data_len()); @@ -56,7 +56,7 @@ namespace test { ::testing::AssertionResult VerifySpdyFrameIREquals(const SpdyGoAwayIR& expected, const SpdyGoAwayIR& actual) { - SPDY_VLOG(1) << "VerifySpdyFrameIREquals SpdyGoAwayIR"; + QUICHE_VLOG(1) << "VerifySpdyFrameIREquals SpdyGoAwayIR"; VERIFY_EQ(expected.last_good_stream_id(), actual.last_good_stream_id()); VERIFY_EQ(expected.error_code(), actual.error_code()); VERIFY_EQ(expected.description(), actual.description()); @@ -66,7 +66,7 @@ namespace test { ::testing::AssertionResult VerifySpdyFrameIREquals( const SpdyHeadersIR& expected, const SpdyHeadersIR& actual) { - SPDY_VLOG(1) << "VerifySpdyFrameIREquals SpdyHeadersIR"; + QUICHE_VLOG(1) << "VerifySpdyFrameIREquals SpdyHeadersIR"; VERIFY_EQ(expected.stream_id(), actual.stream_id()); VERIFY_EQ(expected.fin(), actual.fin()); VERIFY_SUCCESS(VerifySpdyFrameWithHeaderBlockIREquals(expected, actual)); @@ -80,7 +80,7 @@ namespace test { ::testing::AssertionResult VerifySpdyFrameIREquals(const SpdyPingIR& expected, const SpdyPingIR& actual) { - SPDY_VLOG(1) << "VerifySpdyFrameIREquals SpdyPingIR"; + QUICHE_VLOG(1) << "VerifySpdyFrameIREquals SpdyPingIR"; VERIFY_EQ(expected.id(), actual.id()); VERIFY_EQ(expected.is_ack(), actual.is_ack()); return ::testing::AssertionSuccess(); @@ -89,7 +89,7 @@ namespace test { ::testing::AssertionResult VerifySpdyFrameIREquals( const SpdyPriorityIR& expected, const SpdyPriorityIR& actual) { - SPDY_VLOG(1) << "VerifySpdyFrameIREquals SpdyPriorityIR"; + QUICHE_VLOG(1) << "VerifySpdyFrameIREquals SpdyPriorityIR"; VERIFY_EQ(expected.stream_id(), actual.stream_id()); VERIFY_SUCCESS(VerifySpdyFrameWithPriorityIREquals(expected, actual)); return ::testing::AssertionSuccess(); @@ -98,7 +98,7 @@ namespace test { ::testing::AssertionResult VerifySpdyFrameIREquals( const SpdyPushPromiseIR& expected, const SpdyPushPromiseIR& actual) { - SPDY_VLOG(1) << "VerifySpdyFrameIREquals SpdyPushPromiseIR"; + QUICHE_VLOG(1) << "VerifySpdyFrameIREquals SpdyPushPromiseIR"; VERIFY_EQ(expected.stream_id(), actual.stream_id()); VERIFY_SUCCESS(VerifySpdyFrameWithPaddingIREquals(expected, actual)); VERIFY_EQ(expected.promised_stream_id(), actual.promised_stream_id()); @@ -109,7 +109,7 @@ namespace test { ::testing::AssertionResult VerifySpdyFrameIREquals( const SpdyRstStreamIR& expected, const SpdyRstStreamIR& actual) { - SPDY_VLOG(1) << "VerifySpdyFrameIREquals SpdyRstStreamIR"; + QUICHE_VLOG(1) << "VerifySpdyFrameIREquals SpdyRstStreamIR"; VERIFY_EQ(expected.stream_id(), actual.stream_id()); VERIFY_EQ(expected.error_code(), actual.error_code()); return ::testing::AssertionSuccess(); @@ -118,7 +118,7 @@ namespace test { ::testing::AssertionResult VerifySpdyFrameIREquals( const SpdySettingsIR& expected, const SpdySettingsIR& actual) { - SPDY_VLOG(1) << "VerifySpdyFrameIREquals SpdySettingsIR"; + QUICHE_VLOG(1) << "VerifySpdyFrameIREquals SpdySettingsIR"; // Note, ignoring non-HTTP/2 fields such as clear_settings. VERIFY_EQ(expected.is_ack(), actual.is_ack()); @@ -145,7 +145,7 @@ namespace test { ::testing::AssertionResult VerifySpdyFrameIREquals( const SpdyWindowUpdateIR& expected, const SpdyWindowUpdateIR& actual) { - SPDY_VLOG(1) << "VerifySpdyFrameIREquals SpdyWindowUpdateIR"; + QUICHE_VLOG(1) << "VerifySpdyFrameIREquals SpdyWindowUpdateIR"; VERIFY_EQ(expected.stream_id(), actual.stream_id()); VERIFY_EQ(expected.delta(), actual.delta()); return ::testing::AssertionSuccess(); diff --git a/chromium/net/third_party/quiche/src/spdy/core/spdy_protocol_test_utils.h b/chromium/net/third_party/quiche/src/spdy/core/spdy_protocol_test_utils.h index daccebb06a4..de716d50984 100644 --- a/chromium/net/third_party/quiche/src/spdy/core/spdy_protocol_test_utils.h +++ b/chromium/net/third_party/quiche/src/spdy/core/spdy_protocol_test_utils.h @@ -20,10 +20,10 @@ #include <typeinfo> #include "http2/platform/api/http2_test_helpers.h" +#include "common/platform/api/quiche_logging.h" #include "common/platform/api/quiche_test.h" #include "spdy/core/spdy_protocol.h" #include "spdy/core/spdy_test_utils.h" -#include "spdy/platform/api/spdy_logging.h" namespace spdy { namespace test { @@ -38,7 +38,7 @@ namespace test { template <class T> ::testing::AssertionResult VerifySpdyFrameWithPaddingIREquals(const T& expected, const T& actual) { - SPDY_VLOG(1) << "VerifySpdyFrameWithPaddingIREquals"; + QUICHE_VLOG(1) << "VerifySpdyFrameWithPaddingIREquals"; VERIFY_EQ(expected.padded(), actual.padded()); if (expected.padded()) { VERIFY_EQ(expected.padding_payload_len(), actual.padding_payload_len()); @@ -52,7 +52,7 @@ template <class T> ::testing::AssertionResult VerifySpdyFrameWithPriorityIREquals( const T& expected, const T& actual) { - SPDY_VLOG(1) << "VerifySpdyFrameWithPriorityIREquals"; + QUICHE_VLOG(1) << "VerifySpdyFrameWithPriorityIREquals"; VERIFY_EQ(expected.parent_stream_id(), actual.parent_stream_id()); VERIFY_EQ(expected.weight(), actual.weight()); VERIFY_EQ(expected.exclusive(), actual.exclusive()); @@ -123,12 +123,12 @@ template <class E> ::testing::AssertionResult VerifySpdyFrameIREquals(const E* expected, const SpdyFrameIR* actual) { if (expected == nullptr || actual == nullptr) { - SPDY_VLOG(1) << "VerifySpdyFrameIREquals one null"; + QUICHE_VLOG(1) << "VerifySpdyFrameIREquals one null"; VERIFY_EQ(expected, nullptr); VERIFY_EQ(actual, nullptr); return ::testing::AssertionSuccess(); } - SPDY_VLOG(1) << "VerifySpdyFrameIREquals not null"; + QUICHE_VLOG(1) << "VerifySpdyFrameIREquals not null"; VERIFY_EQ(actual->frame_type(), expected->frame_type()); const E* actual2 = static_cast<const E*>(actual); return VerifySpdyFrameIREquals(*expected, *actual2); @@ -139,7 +139,7 @@ template <class E> template <class E> ::testing::AssertionResult VerifySpdyFrameIREquals(const E& expected, const SpdyFrameIR* actual) { - SPDY_VLOG(1) << "VerifySpdyFrameIREquals"; + QUICHE_VLOG(1) << "VerifySpdyFrameIREquals"; return VerifySpdyFrameIREquals(&expected, actual); } diff --git a/chromium/net/third_party/quiche/src/spdy/core/spdy_simple_arena.cc b/chromium/net/third_party/quiche/src/spdy/core/spdy_simple_arena.cc index 15c8fea2614..4df224629c6 100644 --- a/chromium/net/third_party/quiche/src/spdy/core/spdy_simple_arena.cc +++ b/chromium/net/third_party/quiche/src/spdy/core/spdy_simple_arena.cc @@ -7,7 +7,7 @@ #include <algorithm> #include <cstring> -#include "spdy/platform/api/spdy_logging.h" +#include "common/platform/api/quiche_logging.h" namespace spdy { diff --git a/chromium/net/third_party/quiche/src/spdy/core/spdy_test_utils.cc b/chromium/net/third_party/quiche/src/spdy/core/spdy_test_utils.cc index 482d8e24263..4ea1ce82895 100644 --- a/chromium/net/third_party/quiche/src/spdy/core/spdy_test_utils.cc +++ b/chromium/net/third_party/quiche/src/spdy/core/spdy_test_utils.cc @@ -11,9 +11,9 @@ #include <utility> #include <vector> +#include "common/platform/api/quiche_logging.h" #include "common/platform/api/quiche_test.h" #include "common/quiche_endian.h" -#include "spdy/platform/api/spdy_logging.h" namespace spdy { namespace test { @@ -27,7 +27,7 @@ std::string HexDumpWithMarks(const unsigned char* data, const int kSizeLimit = 1024; if (length > kSizeLimit || mark_length > kSizeLimit) { - SPDY_LOG(ERROR) << "Only dumping first " << kSizeLimit << " bytes."; + QUICHE_LOG(ERROR) << "Only dumping first " << kSizeLimit << " bytes."; length = std::min(length, kSizeLimit); mark_length = std::min(mark_length, kSizeLimit); } diff --git a/chromium/net/third_party/quiche/src/spdy/core/write_scheduler.h b/chromium/net/third_party/quiche/src/spdy/core/write_scheduler.h deleted file mode 100644 index de9264d6a47..00000000000 --- a/chromium/net/third_party/quiche/src/spdy/core/write_scheduler.h +++ /dev/null @@ -1,162 +0,0 @@ -// Copyright (c) 2016 The Chromium Authors. All rights reserved. -// Use of this source code is governed by a BSD-style license that can be -// found in the LICENSE file. - -#ifndef QUICHE_SPDY_CORE_WRITE_SCHEDULER_H_ -#define QUICHE_SPDY_CORE_WRITE_SCHEDULER_H_ - -#include <cstdint> -#include <string> -#include <tuple> -#include <vector> - -#include "common/platform/api/quiche_export.h" -#include "spdy/core/spdy_protocol.h" - -namespace spdy { - -// Abstract superclass for classes that decide which SPDY or HTTP/2 stream to -// write next. Concrete subclasses implement various scheduling policies: -// -// PriorityWriteScheduler: implements SPDY priority-based stream scheduling, -// where (writable) higher-priority streams are always given precedence -// over lower-priority streams. -// -// Http2PriorityWriteScheduler: implements SPDY priority-based stream -// scheduling coupled with the HTTP/2 stream dependency model. This is only -// intended as a transitional step towards Http2WeightedWriteScheduler. -// -// Http2WeightedWriteScheduler (coming soon): implements the HTTP/2 stream -// dependency model with weighted stream scheduling, fully conforming to -// RFC 7540. -// -// The type used to represent stream IDs (StreamIdType) is templated in order -// to allow for use by both SPDY and QUIC codebases. It must be a POD that -// supports comparison (i.e., a numeric type). -// -// Each stream can be in one of two states: ready or not ready (for writing). -// Ready state is changed by calling the MarkStreamReady() and -// MarkStreamNotReady() methods. Only streams in the ready state can be -// returned by PopNextReadyStream(); when returned by that method, the stream's -// state changes to not ready. -template <typename StreamIdType> -class QUICHE_EXPORT_PRIVATE WriteScheduler { - public: - typedef StreamPrecedence<StreamIdType> StreamPrecedenceType; - - virtual ~WriteScheduler() {} - - // Registers new stream |stream_id| with the scheduler, assigning it the - // given precedence. If the scheduler supports stream dependencies, the - // stream is inserted into the dependency tree under - // |precedence.parent_id()|. - // - // Preconditions: |stream_id| should be unregistered, and - // |precedence.parent_id()| should be registered or |kHttp2RootStreamId|. - virtual void RegisterStream(StreamIdType stream_id, - const StreamPrecedenceType& precedence) = 0; - - // Unregisters the given stream from the scheduler, which will no longer keep - // state for it. - // - // Preconditions: |stream_id| should be registered. - virtual void UnregisterStream(StreamIdType stream_id) = 0; - - // Returns true if the given stream is currently registered. - virtual bool StreamRegistered(StreamIdType stream_id) const = 0; - - // Returns the precedence of the specified stream. If the scheduler supports - // stream dependencies, calling |parent_id()| on the return value returns the - // stream's parent, and calling |exclusive()| returns true iff the specified - // stream is an only child of the parent stream. - // - // Preconditions: |stream_id| should be registered. - virtual StreamPrecedenceType GetStreamPrecedence( - StreamIdType stream_id) const = 0; - - // Updates the precedence of the given stream. If the scheduler supports - // stream dependencies, |stream_id|'s parent will be updated to be - // |precedence.parent_id()| if it is not already. - // - // Preconditions: |stream_id| should be unregistered, and - // |precedence.parent_id()| should be registered or |kHttp2RootStreamId|. - virtual void UpdateStreamPrecedence( - StreamIdType stream_id, - const StreamPrecedenceType& precedence) = 0; - - // Returns child streams of the given stream, if any. If the scheduler - // doesn't support stream dependencies, returns an empty vector. - // - // Preconditions: |stream_id| should be registered. - virtual std::vector<StreamIdType> GetStreamChildren( - StreamIdType stream_id) const = 0; - - // Records time (in microseconds) of a read/write event for the given - // stream. - // - // Preconditions: |stream_id| should be registered. - virtual void RecordStreamEventTime(StreamIdType stream_id, - int64_t now_in_usec) = 0; - - // Returns time (in microseconds) of the last read/write event for a stream - // with higher priority than the priority of the given stream, or 0 if there - // is no such event. - // - // Preconditions: |stream_id| should be registered. - virtual int64_t GetLatestEventWithPrecedence( - StreamIdType stream_id) const = 0; - - // If the scheduler has any ready streams, returns the next scheduled - // ready stream, in the process transitioning the stream from ready to not - // ready. - // - // Preconditions: |HasReadyStreams() == true| - virtual StreamIdType PopNextReadyStream() = 0; - - // If the scheduler has any ready streams, returns the next scheduled - // ready stream and its priority, in the process transitioning the stream from - // ready to not ready. - // - // Preconditions: |HasReadyStreams() == true| - virtual std::tuple<StreamIdType, StreamPrecedenceType> - PopNextReadyStreamAndPrecedence() = 0; - - // Returns true if there's another stream ahead of the given stream in the - // scheduling queue. This function can be called to see if the given stream - // should yield work to another stream. - // - // Preconditions: |stream_id| should be registered. - virtual bool ShouldYield(StreamIdType stream_id) const = 0; - - // Marks the stream as ready to write. If the stream was already ready, does - // nothing. If add_to_front is true, the stream is scheduled ahead of other - // streams of the same priority/weight, otherwise it is scheduled behind them. - // - // Preconditions: |stream_id| should be registered. - virtual void MarkStreamReady(StreamIdType stream_id, bool add_to_front) = 0; - - // Marks the stream as not ready to write. If the stream is not registered or - // not ready, does nothing. - // - // Preconditions: |stream_id| should be registered. - virtual void MarkStreamNotReady(StreamIdType stream_id) = 0; - - // Returns true iff the scheduler has any ready streams. - virtual bool HasReadyStreams() const = 0; - - // Returns the number of streams currently marked ready. - virtual size_t NumReadyStreams() const = 0; - - // Returns true if stream with |stream_id| is ready. - virtual bool IsStreamReady(StreamIdType stream_id) const = 0; - - // Returns the number of registered streams. - virtual size_t NumRegisteredStreams() const = 0; - - // Returns summary of internal state, for logging/debugging. - virtual std::string DebugString() const = 0; -}; - -} // namespace spdy - -#endif // QUICHE_SPDY_CORE_WRITE_SCHEDULER_H_ diff --git a/chromium/net/third_party/quiche/src/spdy/platform/api/spdy_bug_tracker.h b/chromium/net/third_party/quiche/src/spdy/platform/api/spdy_bug_tracker.h deleted file mode 100644 index f00bbc8b376..00000000000 --- a/chromium/net/third_party/quiche/src/spdy/platform/api/spdy_bug_tracker.h +++ /dev/null @@ -1,16 +0,0 @@ -// Copyright (c) 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_SPDY_PLATFORM_API_SPDY_BUG_TRACKER_H_ -#define QUICHE_SPDY_PLATFORM_API_SPDY_BUG_TRACKER_H_ - -#include "net/spdy/platform/impl/spdy_bug_tracker_impl.h" - -#define SPDY_BUG SPDY_BUG_IMPL -#define SPDY_BUG_IF(bug_id, condition) SPDY_BUG_IF_IMPL(bug_id, condition) - -#define FLAGS_spdy_always_log_bugs_for_tests \ - FLAGS_spdy_always_log_bugs_for_tests_impl - -#endif // QUICHE_SPDY_PLATFORM_API_SPDY_BUG_TRACKER_H_ diff --git a/chromium/net/third_party/quiche/src/spdy/platform/api/spdy_containers.h b/chromium/net/third_party/quiche/src/spdy/platform/api/spdy_containers.h index 9e3813f5b42..2adf3f4b87a 100644 --- a/chromium/net/third_party/quiche/src/spdy/platform/api/spdy_containers.h +++ b/chromium/net/third_party/quiche/src/spdy/platform/api/spdy_containers.h @@ -13,12 +13,6 @@ namespace spdy { template <typename Key, typename Value, typename Hash, typename Eq> using SpdyLinkedHashMap = SpdyLinkedHashMapImpl<Key, Value, Hash, Eq>; -// Used for maps that are typically small, then it is faster than (for example) -// hash_map which is optimized for large data sets. SpdySmallMap upgrades itself -// automatically to a SpdySmallMapImpl-specified map when it runs out of space. -template <typename Key, typename Value, int Size> -using SpdySmallMap = SpdySmallMapImpl<Key, Value, Size>; - } // namespace spdy #endif // QUICHE_SPDY_PLATFORM_API_SPDY_CONTAINERS_H_ diff --git a/chromium/net/third_party/quiche/src/spdy/platform/api/spdy_flag_utils.h b/chromium/net/third_party/quiche/src/spdy/platform/api/spdy_flag_utils.h deleted file mode 100644 index 07c97fbc343..00000000000 --- a/chromium/net/third_party/quiche/src/spdy/platform/api/spdy_flag_utils.h +++ /dev/null @@ -1,19 +0,0 @@ -// Copyright 2020 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_SPDY_PLATFORM_API_SPDY_FLAG_UTILS_H_ -#define QUICHE_SPDY_PLATFORM_API_SPDY_FLAG_UTILS_H_ - -#include "common/platform/api/quiche_flag_utils.h" - -#define SPDY_RELOADABLE_FLAG_COUNT QUICHE_RELOADABLE_FLAG_COUNT -#define SPDY_RELOADABLE_FLAG_COUNT_N QUICHE_RELOADABLE_FLAG_COUNT_N - -#define SPDY_RESTART_FLAG_COUNT QUICHE_RESTART_FLAG_COUNT -#define SPDY_RESTART_FLAG_COUNT_N QUICHE_RESTART_FLAG_COUNT_N - -#define SPDY_CODE_COUNT QUICHE_CODE_COUNT -#define SPDY_CODE_COUNT_N QUICHE_CODE_COUNT_N - -#endif // QUICHE_SPDY_PLATFORM_API_SPDY_FLAG_UTILS_H_ diff --git a/chromium/net/third_party/quiche/src/spdy/platform/api/spdy_flags.h b/chromium/net/third_party/quiche/src/spdy/platform/api/spdy_flags.h deleted file mode 100644 index f8cb5a60d5b..00000000000 --- a/chromium/net/third_party/quiche/src/spdy/platform/api/spdy_flags.h +++ /dev/null @@ -1,18 +0,0 @@ -// Copyright 2018 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_SPDY_PLATFORM_API_SPDY_FLAGS_H_ -#define QUICHE_SPDY_PLATFORM_API_SPDY_FLAGS_H_ - -#include "common/platform/api/quiche_flags.h" - -#define GetSpdyReloadableFlag(flag) GetQuicheReloadableFlag(spdy, flag) -#define SetSpdyReloadableFlag(flag, value) \ - SetQuicheReloadableFlag(spdy, flag, value) -#define GetSpdyRestartFlag(flag) GetQuicheRestartFlag(spdy, flag) -#define SetSpdyRestartFlag(flag, value) SetQuicheRestartFlag(spdy, flag, value) -#define GetSpdyFlag(flag) GetQuicheFlag(flag) -#define SetSpdyFlag(flag, value) SetQuicheFlag(flag, value) - -#endif // QUICHE_SPDY_PLATFORM_API_SPDY_FLAGS_H_ diff --git a/chromium/net/third_party/quiche/src/spdy/platform/api/spdy_logging.h b/chromium/net/third_party/quiche/src/spdy/platform/api/spdy_logging.h deleted file mode 100644 index c1f5268e287..00000000000 --- a/chromium/net/third_party/quiche/src/spdy/platform/api/spdy_logging.h +++ /dev/null @@ -1,23 +0,0 @@ -// 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_SPDY_PLATFORM_API_SPDY_LOGGING_H_ -#define QUICHE_SPDY_PLATFORM_API_SPDY_LOGGING_H_ - -#include "common/platform/api/quiche_logging.h" - -#define SPDY_LOG(severity) QUICHE_LOG(severity) - -#define SPDY_VLOG(verbose_level) QUICHE_VLOG(verbose_level) - -#define SPDY_DLOG(severity) QUICHE_DLOG(severity) - -#define SPDY_DLOG_IF(severity, condition) QUICHE_DLOG_IF(severity, condition) - -#define SPDY_DVLOG(verbose_level) QUICHE_DVLOG(verbose_level) - -#define SPDY_DVLOG_IF(verbose_level, condition) \ - QUICHE_DVLOG_IF(verbose_level, condition) - -#endif // QUICHE_SPDY_PLATFORM_API_SPDY_LOGGING_H_ diff --git a/chromium/net/third_party/quiche/src/spdy/platform/api/spdy_string_utils.h b/chromium/net/third_party/quiche/src/spdy/platform/api/spdy_string_utils.h index 178415b0ed6..83660bab06f 100644 --- a/chromium/net/third_party/quiche/src/spdy/platform/api/spdy_string_utils.h +++ b/chromium/net/third_party/quiche/src/spdy/platform/api/spdy_string_utils.h @@ -6,29 +6,12 @@ #define QUICHE_SPDY_PLATFORM_API_SPDY_STRING_UTILS_H_ #include <string> -#include <utility> #include "absl/strings/string_view.h" #include "net/spdy/platform/impl/spdy_string_utils_impl.h" namespace spdy { -inline char SpdyHexDigitToInt(char c) { - return SpdyHexDigitToIntImpl(c); -} - -inline std::string SpdyHexDecode(absl::string_view data) { - return SpdyHexDecodeImpl(data); -} - -inline bool SpdyHexDecodeToUInt32(absl::string_view data, uint32_t* out) { - return SpdyHexDecodeToUInt32Impl(data, out); -} - -inline std::string SpdyHexEncode(const char* bytes, size_t size) { - return SpdyHexEncodeImpl(bytes, size); -} - inline std::string SpdyHexDump(absl::string_view data) { return SpdyHexDumpImpl(data); } diff --git a/chromium/net/third_party/quiche/src/spdy/platform/api/spdy_string_utils_test.cc b/chromium/net/third_party/quiche/src/spdy/platform/api/spdy_string_utils_test.cc deleted file mode 100644 index cb73a9b2ece..00000000000 --- a/chromium/net/third_party/quiche/src/spdy/platform/api/spdy_string_utils_test.cc +++ /dev/null @@ -1,78 +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 "spdy/platform/api/spdy_string_utils.h" - -#include <cstdint> - -#include "absl/strings/string_view.h" -#include "common/platform/api/quiche_test.h" - -namespace spdy { -namespace test { -namespace { - -TEST(SpdyStringUtilsTest, SpdyHexDigitToInt) { - EXPECT_EQ(0, SpdyHexDigitToInt('0')); - EXPECT_EQ(1, SpdyHexDigitToInt('1')); - EXPECT_EQ(2, SpdyHexDigitToInt('2')); - EXPECT_EQ(3, SpdyHexDigitToInt('3')); - EXPECT_EQ(4, SpdyHexDigitToInt('4')); - EXPECT_EQ(5, SpdyHexDigitToInt('5')); - EXPECT_EQ(6, SpdyHexDigitToInt('6')); - EXPECT_EQ(7, SpdyHexDigitToInt('7')); - EXPECT_EQ(8, SpdyHexDigitToInt('8')); - EXPECT_EQ(9, SpdyHexDigitToInt('9')); - - EXPECT_EQ(10, SpdyHexDigitToInt('a')); - EXPECT_EQ(11, SpdyHexDigitToInt('b')); - EXPECT_EQ(12, SpdyHexDigitToInt('c')); - EXPECT_EQ(13, SpdyHexDigitToInt('d')); - EXPECT_EQ(14, SpdyHexDigitToInt('e')); - EXPECT_EQ(15, SpdyHexDigitToInt('f')); - - EXPECT_EQ(10, SpdyHexDigitToInt('A')); - EXPECT_EQ(11, SpdyHexDigitToInt('B')); - EXPECT_EQ(12, SpdyHexDigitToInt('C')); - EXPECT_EQ(13, SpdyHexDigitToInt('D')); - EXPECT_EQ(14, SpdyHexDigitToInt('E')); - EXPECT_EQ(15, SpdyHexDigitToInt('F')); -} - -TEST(SpdyStringUtilsTest, SpdyHexDecodeToUInt32) { - uint32_t out; - EXPECT_TRUE(SpdyHexDecodeToUInt32("0", &out)); - EXPECT_EQ(0u, out); - EXPECT_TRUE(SpdyHexDecodeToUInt32("00", &out)); - EXPECT_EQ(0u, out); - EXPECT_TRUE(SpdyHexDecodeToUInt32("0000000", &out)); - EXPECT_EQ(0u, out); - EXPECT_TRUE(SpdyHexDecodeToUInt32("00000000", &out)); - EXPECT_EQ(0u, out); - EXPECT_TRUE(SpdyHexDecodeToUInt32("1", &out)); - EXPECT_EQ(1u, out); - EXPECT_TRUE(SpdyHexDecodeToUInt32("ffffFFF", &out)); - EXPECT_EQ(0xFFFFFFFu, out); - EXPECT_TRUE(SpdyHexDecodeToUInt32("fFfFffFf", &out)); - EXPECT_EQ(0xFFFFFFFFu, out); - EXPECT_TRUE(SpdyHexDecodeToUInt32("01AEF", &out)); - EXPECT_EQ(0x1AEFu, out); - EXPECT_TRUE(SpdyHexDecodeToUInt32("abcde", &out)); - EXPECT_EQ(0xABCDEu, out); - - EXPECT_FALSE(SpdyHexDecodeToUInt32("", &out)); - EXPECT_FALSE(SpdyHexDecodeToUInt32("111111111", &out)); - EXPECT_FALSE(SpdyHexDecodeToUInt32("1111111111", &out)); - EXPECT_FALSE(SpdyHexDecodeToUInt32("0x1111", &out)); -} - -TEST(SpdyStringUtilsTest, SpdyHexEncode) { - unsigned char bytes[] = {0x01, 0xff, 0x02, 0xfe, 0x03, 0x80, 0x81}; - EXPECT_EQ("01ff02fe038081", - SpdyHexEncode(reinterpret_cast<char*>(bytes), sizeof(bytes))); -} - -} // namespace -} // namespace test -} // namespace spdy diff --git a/chromium/net/third_party/quiche/src/spdy/platform/api/spdy_test_helpers.h b/chromium/net/third_party/quiche/src/spdy/platform/api/spdy_test_helpers.h deleted file mode 100644 index 367d330b6c9..00000000000 --- a/chromium/net/third_party/quiche/src/spdy/platform/api/spdy_test_helpers.h +++ /dev/null @@ -1,12 +0,0 @@ -// Copyright (c) 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_SPDY_PLATFORM_API_SPDY_TEST_HELPERS_H_ -#define QUICHE_SPDY_PLATFORM_API_SPDY_TEST_HELPERS_H_ - -#include "net/spdy/platform/impl/spdy_test_helpers_impl.h" - -#define EXPECT_SPDY_BUG EXPECT_SPDY_BUG_IMPL - -#endif // QUICHE_SPDY_PLATFORM_API_SPDY_TEST_HELPERS_H_ |