OLD | NEW |
---|---|
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "net/spdy/spdy_framer.h" | 5 #include "net/spdy/spdy_framer.h" |
6 | 6 |
7 #include <stdlib.h> | 7 #include <stdlib.h> |
8 #include <string.h> | 8 #include <string.h> |
9 | 9 |
10 #include <algorithm> | 10 #include <algorithm> |
11 #include <cstdint> | 11 #include <cstdint> |
12 #include <limits> | 12 #include <limits> |
13 #include <memory> | 13 #include <memory> |
14 #include <string> | 14 #include <string> |
15 #include <tuple> | 15 #include <tuple> |
16 #include <vector> | 16 #include <vector> |
17 | 17 |
18 #include "base/compiler_specific.h" | 18 #include "base/compiler_specific.h" |
19 #include "base/logging.h" | 19 #include "base/logging.h" |
20 #include "base/macros.h" | 20 #include "base/macros.h" |
21 #include "base/memory/ptr_util.h" | 21 #include "base/memory/ptr_util.h" |
22 #include "base/strings/string_number_conversions.h" | 22 #include "base/strings/string_number_conversions.h" |
23 #include "net/quic/core/quic_flags.h" | 23 #include "net/quic/core/quic_flags.h" |
24 #include "net/spdy/array_output_buffer.h" | |
24 #include "net/spdy/hpack/hpack_constants.h" | 25 #include "net/spdy/hpack/hpack_constants.h" |
25 #include "net/spdy/mock_spdy_framer_visitor.h" | 26 #include "net/spdy/mock_spdy_framer_visitor.h" |
26 #include "net/spdy/spdy_flags.h" | 27 #include "net/spdy/spdy_flags.h" |
27 #include "net/spdy/spdy_frame_builder.h" | 28 #include "net/spdy/spdy_frame_builder.h" |
28 #include "net/spdy/spdy_frame_reader.h" | 29 #include "net/spdy/spdy_frame_reader.h" |
29 #include "net/spdy/spdy_protocol.h" | 30 #include "net/spdy/spdy_protocol.h" |
30 #include "net/spdy/spdy_test_utils.h" | 31 #include "net/spdy/spdy_test_utils.h" |
31 #include "testing/gmock/include/gmock/gmock.h" | 32 #include "testing/gmock/include/gmock/gmock.h" |
32 #include "testing/gtest/include/gtest/gtest.h" | 33 #include "testing/gtest/include/gtest/gtest.h" |
33 #include "testing/platform_test.h" | 34 #include "testing/platform_test.h" |
34 | 35 |
35 using base::StringPiece; | 36 using base::StringPiece; |
36 using std::string; | 37 using std::string; |
37 using testing::_; | 38 using testing::_; |
38 | 39 |
39 namespace net { | 40 namespace net { |
40 | 41 |
41 namespace test { | 42 namespace test { |
42 | 43 |
44 namespace { | |
45 | |
46 const int64_t kSize = 64 * 1024; | |
47 char output_buffer[kSize] = ""; | |
48 } | |
49 | |
43 class MockDebugVisitor : public SpdyFramerDebugVisitorInterface { | 50 class MockDebugVisitor : public SpdyFramerDebugVisitorInterface { |
44 public: | 51 public: |
45 MOCK_METHOD4(OnSendCompressedFrame, | 52 MOCK_METHOD4(OnSendCompressedFrame, |
46 void(SpdyStreamId stream_id, | 53 void(SpdyStreamId stream_id, |
47 SpdyFrameType type, | 54 SpdyFrameType type, |
48 size_t payload_len, | 55 size_t payload_len, |
49 size_t frame_len)); | 56 size_t frame_len)); |
50 | 57 |
51 MOCK_METHOD3(OnReceiveCompressedFrame, | 58 MOCK_METHOD3(OnReceiveCompressedFrame, |
52 void(SpdyStreamId stream_id, | 59 void(SpdyStreamId stream_id, |
(...skipping 201 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
254 std::vector<SpdySerializedFrame> frame_list; | 261 std::vector<SpdySerializedFrame> frame_list; |
255 SpdyFramer::SpdyHeaderFrameIterator it(framer, CloneSpdyHeadersIR(headers)); | 262 SpdyFramer::SpdyHeaderFrameIterator it(framer, CloneSpdyHeadersIR(headers)); |
256 while (it.HasNextFrame()) { | 263 while (it.HasNextFrame()) { |
257 frame_list.push_back(it.NextFrame()); | 264 frame_list.push_back(it.NextFrame()); |
258 } | 265 } |
259 framer->debug_visitor_ = saved_debug_visitor; | 266 framer->debug_visitor_ = saved_debug_visitor; |
260 | 267 |
261 EXPECT_THAT(serialized_headers_old_version, IsFrameUnionOf(&frame_list)); | 268 EXPECT_THAT(serialized_headers_old_version, IsFrameUnionOf(&frame_list)); |
262 return serialized_headers_old_version; | 269 return serialized_headers_old_version; |
263 } | 270 } |
271 | |
272 static SpdySerializedFrame SerializeHeaders(SpdyFramer* framer, | |
273 const SpdyHeadersIR& headers, | |
274 ArrayOutputBuffer* output) { | |
275 if (output == nullptr) { | |
276 return SerializeHeaders(framer, headers); | |
277 } | |
278 output->Reset(); | |
279 EXPECT_TRUE(framer->SerializeHeaders(headers, output)); | |
280 SpdySerializedFrame serialized_headers_old_version(output->Begin(), | |
281 output->Size(), false); | |
282 framer->hpack_encoder_.reset(nullptr); | |
283 auto* saved_debug_visitor = framer->debug_visitor_; | |
284 framer->debug_visitor_ = nullptr; | |
285 | |
286 std::vector<SpdySerializedFrame> frame_list; | |
287 SpdyFramer::SpdyHeaderFrameIterator it(framer, CloneSpdyHeadersIR(headers)); | |
288 while (it.HasNextFrame()) { | |
289 frame_list.push_back(it.NextFrame()); | |
290 } | |
291 framer->debug_visitor_ = saved_debug_visitor; | |
292 | |
293 EXPECT_THAT(serialized_headers_old_version, IsFrameUnionOf(&frame_list)); | |
294 return serialized_headers_old_version; | |
295 } | |
264 }; | 296 }; |
265 | 297 |
266 class TestSpdyVisitor : public SpdyFramerVisitorInterface, | 298 class TestSpdyVisitor : public SpdyFramerVisitorInterface, |
267 public SpdyFramerDebugVisitorInterface { | 299 public SpdyFramerDebugVisitorInterface { |
268 public: | 300 public: |
269 // This is larger than our max frame size because header blocks that | 301 // This is larger than our max frame size because header blocks that |
270 // are too long can spill over into CONTINUATION frames. | 302 // are too long can spill over into CONTINUATION frames. |
271 static const size_t kDefaultHeaderBufferSize = 16 * 1024 * 1024; | 303 static const size_t kDefaultHeaderBufferSize = 16 * 1024 * 1024; |
272 | 304 |
273 explicit TestSpdyVisitor(SpdyFramer::CompressionOption option) | 305 explicit TestSpdyVisitor(SpdyFramer::CompressionOption option) |
(...skipping 356 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
630 DCHECK_EQ(HEADERS, type); | 662 DCHECK_EQ(HEADERS, type); |
631 uint8_t flags; | 663 uint8_t flags; |
632 reader.ReadUInt8(&flags); | 664 reader.ReadUInt8(&flags); |
633 | 665 |
634 return StringPiece(frame.data() + framer.GetHeadersMinimumSize(), | 666 return StringPiece(frame.data() + framer.GetHeadersMinimumSize(), |
635 frame.size() - framer.GetHeadersMinimumSize()); | 667 frame.size() - framer.GetHeadersMinimumSize()); |
636 } | 668 } |
637 | 669 |
638 enum DecoderChoice { DECODER_SELF, DECODER_NESTED, DECODER_HTTP2 }; | 670 enum DecoderChoice { DECODER_SELF, DECODER_NESTED, DECODER_HTTP2 }; |
639 enum HpackChoice { HPACK_DECODER_1, HPACK_DECODER_2, HPACK_DECODER_3 }; | 671 enum HpackChoice { HPACK_DECODER_1, HPACK_DECODER_2, HPACK_DECODER_3 }; |
672 enum Output { USE, NOT_USE }; | |
640 | 673 |
641 class SpdyFramerTest | 674 class SpdyFramerTest : public ::testing::TestWithParam< |
642 : public ::testing::TestWithParam<std::tuple<DecoderChoice, HpackChoice>> { | 675 std::tuple<DecoderChoice, HpackChoice, Output>> { |
676 public: | |
677 SpdyFramerTest() : output_(output_buffer, kSize) {} | |
678 | |
643 protected: | 679 protected: |
644 void SetUp() override { | 680 void SetUp() override { |
645 auto param = GetParam(); | 681 auto param = GetParam(); |
646 switch (std::get<0>(param)) { | 682 switch (std::get<0>(param)) { |
647 case DECODER_SELF: | 683 case DECODER_SELF: |
648 FLAGS_use_nested_spdy_framer_decoder = false; | 684 FLAGS_use_nested_spdy_framer_decoder = false; |
649 FLAGS_chromium_http2_flag_spdy_use_http2_frame_decoder_adapter = false; | 685 FLAGS_chromium_http2_flag_spdy_use_http2_frame_decoder_adapter = false; |
650 break; | 686 break; |
651 case DECODER_NESTED: | 687 case DECODER_NESTED: |
652 FLAGS_use_nested_spdy_framer_decoder = true; | 688 FLAGS_use_nested_spdy_framer_decoder = true; |
(...skipping 11 matching lines...) Expand all Loading... | |
664 break; | 700 break; |
665 case HPACK_DECODER_2: | 701 case HPACK_DECODER_2: |
666 FLAGS_chromium_http2_flag_spdy_use_hpack_decoder2 = true; | 702 FLAGS_chromium_http2_flag_spdy_use_hpack_decoder2 = true; |
667 FLAGS_chromium_http2_flag_spdy_use_hpack_decoder3 = false; | 703 FLAGS_chromium_http2_flag_spdy_use_hpack_decoder3 = false; |
668 break; | 704 break; |
669 case HPACK_DECODER_3: | 705 case HPACK_DECODER_3: |
670 FLAGS_chromium_http2_flag_spdy_use_hpack_decoder2 = false; | 706 FLAGS_chromium_http2_flag_spdy_use_hpack_decoder2 = false; |
671 FLAGS_chromium_http2_flag_spdy_use_hpack_decoder3 = true; | 707 FLAGS_chromium_http2_flag_spdy_use_hpack_decoder3 = true; |
672 break; | 708 break; |
673 } | 709 } |
710 switch (std::get<2>(param)) { | |
711 case USE: | |
712 use_output_ = true; | |
713 break; | |
714 case NOT_USE: | |
715 // TODO(yasong): remove this case after | |
716 // gfe2_reloadable_flag_write_queue_zero_copy_buffer deprecates. | |
Bence
2017/03/16 18:12:54
s/gfe2_reloadable_flag_write_queue_zero_copy_buffe
yasong
2017/03/16 22:28:52
Done.
| |
717 use_output_ = false; | |
718 break; | |
719 } | |
674 } | 720 } |
675 | 721 |
676 void CompareFrame(const string& description, | 722 void CompareFrame(const string& description, |
677 const SpdySerializedFrame& actual_frame, | 723 const SpdySerializedFrame& actual_frame, |
678 const unsigned char* expected, | 724 const unsigned char* expected, |
679 const int expected_len) { | 725 const int expected_len) { |
680 const unsigned char* actual = | 726 const unsigned char* actual = |
681 reinterpret_cast<const unsigned char*>(actual_frame.data()); | 727 reinterpret_cast<const unsigned char*>(actual_frame.data()); |
682 CompareCharArraysWithHexError(description, actual, actual_frame.size(), | 728 CompareCharArraysWithHexError(description, actual, actual_frame.size(), |
683 expected, expected_len); | 729 expected, expected_len); |
684 } | 730 } |
685 | 731 |
686 void CompareFrames(const string& description, | 732 void CompareFrames(const string& description, |
687 const SpdySerializedFrame& expected_frame, | 733 const SpdySerializedFrame& expected_frame, |
688 const SpdySerializedFrame& actual_frame) { | 734 const SpdySerializedFrame& actual_frame) { |
689 CompareCharArraysWithHexError( | 735 CompareCharArraysWithHexError( |
690 description, | 736 description, |
691 reinterpret_cast<const unsigned char*>(expected_frame.data()), | 737 reinterpret_cast<const unsigned char*>(expected_frame.data()), |
692 expected_frame.size(), | 738 expected_frame.size(), |
693 reinterpret_cast<const unsigned char*>(actual_frame.data()), | 739 reinterpret_cast<const unsigned char*>(actual_frame.data()), |
694 actual_frame.size()); | 740 actual_frame.size()); |
695 } | 741 } |
742 | |
743 bool use_output_ = false; | |
744 ArrayOutputBuffer output_; | |
696 }; | 745 }; |
697 | 746 |
698 INSTANTIATE_TEST_CASE_P( | 747 INSTANTIATE_TEST_CASE_P( |
699 SpdyFramerTests, | 748 SpdyFramerTests, |
700 SpdyFramerTest, | 749 SpdyFramerTest, |
701 ::testing::Combine( | 750 ::testing::Combine( |
702 ::testing::Values(DECODER_SELF, DECODER_NESTED, DECODER_HTTP2), | 751 ::testing::Values(DECODER_SELF, DECODER_NESTED, DECODER_HTTP2), |
703 ::testing::Values(HPACK_DECODER_1, HPACK_DECODER_2, HPACK_DECODER_3))); | 752 ::testing::Values(HPACK_DECODER_1, HPACK_DECODER_2, HPACK_DECODER_3), |
753 ::testing::Values(USE, NOT_USE))); | |
704 | 754 |
705 // Test that we can encode and decode a SpdyHeaderBlock in serialized form. | 755 // Test that we can encode and decode a SpdyHeaderBlock in serialized form. |
706 TEST_P(SpdyFramerTest, HeaderBlockInBuffer) { | 756 TEST_P(SpdyFramerTest, HeaderBlockInBuffer) { |
707 SpdyFramer framer(SpdyFramer::DISABLE_COMPRESSION); | 757 SpdyFramer framer(SpdyFramer::DISABLE_COMPRESSION); |
708 | 758 |
709 // Encode the header block into a Headers frame. | 759 // Encode the header block into a Headers frame. |
710 SpdyHeadersIR headers(1); | 760 SpdyHeadersIR headers(1); |
711 headers.SetHeader("alpha", "beta"); | 761 headers.SetHeader("alpha", "beta"); |
712 headers.SetHeader("gamma", "charlie"); | 762 headers.SetHeader("gamma", "charlie"); |
713 headers.SetHeader("cookie", "key1=value1; key2=value2"); | 763 headers.SetHeader("cookie", "key1=value1; key2=value2"); |
714 SpdySerializedFrame frame(SpdyFramerPeer::SerializeHeaders(&framer, headers)); | 764 SpdySerializedFrame frame(SpdyFramerPeer::SerializeHeaders( |
765 &framer, headers, use_output_ ? &output_ : nullptr)); | |
715 | 766 |
716 TestSpdyVisitor visitor(SpdyFramer::DISABLE_COMPRESSION); | 767 TestSpdyVisitor visitor(SpdyFramer::DISABLE_COMPRESSION); |
717 visitor.SimulateInFramer(reinterpret_cast<unsigned char*>(frame.data()), | 768 visitor.SimulateInFramer(reinterpret_cast<unsigned char*>(frame.data()), |
718 frame.size()); | 769 frame.size()); |
719 | 770 |
720 EXPECT_EQ(0, visitor.zero_length_control_frame_header_data_count_); | 771 EXPECT_EQ(0, visitor.zero_length_control_frame_header_data_count_); |
721 EXPECT_EQ(headers.header_block(), visitor.headers_); | 772 EXPECT_EQ(headers.header_block(), visitor.headers_); |
722 } | 773 } |
723 | 774 |
724 // Test that if there's not a full frame, we fail to parse it. | 775 // Test that if there's not a full frame, we fail to parse it. |
725 TEST_P(SpdyFramerTest, UndersizedHeaderBlockInBuffer) { | 776 TEST_P(SpdyFramerTest, UndersizedHeaderBlockInBuffer) { |
726 SpdyFramer framer(SpdyFramer::DISABLE_COMPRESSION); | 777 SpdyFramer framer(SpdyFramer::DISABLE_COMPRESSION); |
727 | 778 |
728 // Encode the header block into a Headers frame. | 779 // Encode the header block into a Headers frame. |
729 SpdyHeadersIR headers(1); | 780 SpdyHeadersIR headers(1); |
730 headers.SetHeader("alpha", "beta"); | 781 headers.SetHeader("alpha", "beta"); |
731 headers.SetHeader("gamma", "charlie"); | 782 headers.SetHeader("gamma", "charlie"); |
732 SpdySerializedFrame frame(SpdyFramerPeer::SerializeHeaders(&framer, headers)); | 783 SpdySerializedFrame frame(SpdyFramerPeer::SerializeHeaders( |
784 &framer, headers, use_output_ ? &output_ : nullptr)); | |
733 | 785 |
734 TestSpdyVisitor visitor(SpdyFramer::DISABLE_COMPRESSION); | 786 TestSpdyVisitor visitor(SpdyFramer::DISABLE_COMPRESSION); |
735 visitor.SimulateInFramer(reinterpret_cast<unsigned char*>(frame.data()), | 787 visitor.SimulateInFramer(reinterpret_cast<unsigned char*>(frame.data()), |
736 frame.size() - 2); | 788 frame.size() - 2); |
737 | 789 |
738 EXPECT_EQ(0, visitor.zero_length_control_frame_header_data_count_); | 790 EXPECT_EQ(0, visitor.zero_length_control_frame_header_data_count_); |
739 EXPECT_EQ(0u, visitor.headers_.size()); | 791 EXPECT_EQ(0u, visitor.headers_.size()); |
740 } | 792 } |
741 | 793 |
742 // Test that we treat incoming upper-case or mixed-case header values as | 794 // Test that we treat incoming upper-case or mixed-case header values as |
(...skipping 36 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
779 SpdyFramer framer(SpdyFramer::DISABLE_COMPRESSION); | 831 SpdyFramer framer(SpdyFramer::DISABLE_COMPRESSION); |
780 | 832 |
781 const SpdyStreamId parent_stream_id_test_array[] = {0, 3}; | 833 const SpdyStreamId parent_stream_id_test_array[] = {0, 3}; |
782 for (SpdyStreamId parent_stream_id : parent_stream_id_test_array) { | 834 for (SpdyStreamId parent_stream_id : parent_stream_id_test_array) { |
783 const bool exclusive_test_array[] = {true, false}; | 835 const bool exclusive_test_array[] = {true, false}; |
784 for (bool exclusive : exclusive_test_array) { | 836 for (bool exclusive : exclusive_test_array) { |
785 SpdyHeadersIR headers(1); | 837 SpdyHeadersIR headers(1); |
786 headers.set_has_priority(true); | 838 headers.set_has_priority(true); |
787 headers.set_parent_stream_id(parent_stream_id); | 839 headers.set_parent_stream_id(parent_stream_id); |
788 headers.set_exclusive(exclusive); | 840 headers.set_exclusive(exclusive); |
789 SpdySerializedFrame frame( | 841 SpdySerializedFrame frame(SpdyFramerPeer::SerializeHeaders( |
790 SpdyFramerPeer::SerializeHeaders(&framer, headers)); | 842 &framer, headers, use_output_ ? &output_ : nullptr)); |
791 | 843 |
792 TestSpdyVisitor visitor(SpdyFramer::DISABLE_COMPRESSION); | 844 TestSpdyVisitor visitor(SpdyFramer::DISABLE_COMPRESSION); |
793 visitor.SimulateInFramer(reinterpret_cast<unsigned char*>(frame.data()), | 845 visitor.SimulateInFramer(reinterpret_cast<unsigned char*>(frame.data()), |
794 frame.size()); | 846 frame.size()); |
795 | 847 |
796 EXPECT_TRUE(visitor.header_has_priority_); | 848 EXPECT_TRUE(visitor.header_has_priority_); |
797 EXPECT_EQ(parent_stream_id, visitor.header_parent_stream_id_); | 849 EXPECT_EQ(parent_stream_id, visitor.header_parent_stream_id_); |
798 EXPECT_EQ(exclusive, visitor.header_exclusive_); | 850 EXPECT_EQ(exclusive, visitor.header_exclusive_); |
799 } | 851 } |
800 } | 852 } |
(...skipping 200 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
1001 | 1053 |
1002 // Test that if we receive a HEADERS with stream ID zero, we signal an error | 1054 // Test that if we receive a HEADERS with stream ID zero, we signal an error |
1003 // (but don't crash). | 1055 // (but don't crash). |
1004 TEST_P(SpdyFramerTest, HeadersWithStreamIdZero) { | 1056 TEST_P(SpdyFramerTest, HeadersWithStreamIdZero) { |
1005 testing::StrictMock<test::MockSpdyFramerVisitor> visitor; | 1057 testing::StrictMock<test::MockSpdyFramerVisitor> visitor; |
1006 SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION); | 1058 SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION); |
1007 framer.set_visitor(&visitor); | 1059 framer.set_visitor(&visitor); |
1008 | 1060 |
1009 SpdyHeadersIR headers(0); | 1061 SpdyHeadersIR headers(0); |
1010 headers.SetHeader("alpha", "beta"); | 1062 headers.SetHeader("alpha", "beta"); |
1011 SpdySerializedFrame frame(SpdyFramerPeer::SerializeHeaders(&framer, headers)); | 1063 SpdySerializedFrame frame(SpdyFramerPeer::SerializeHeaders( |
1064 &framer, headers, use_output_ ? &output_ : nullptr)); | |
1012 | 1065 |
1013 // We shouldn't have to read the whole frame before we signal an error. | 1066 // We shouldn't have to read the whole frame before we signal an error. |
1014 EXPECT_CALL(visitor, OnError(testing::Eq(&framer))); | 1067 EXPECT_CALL(visitor, OnError(testing::Eq(&framer))); |
1015 EXPECT_GT(frame.size(), framer.ProcessInput(frame.data(), frame.size())); | 1068 EXPECT_GT(frame.size(), framer.ProcessInput(frame.data(), frame.size())); |
1016 EXPECT_TRUE(framer.HasError()); | 1069 EXPECT_TRUE(framer.HasError()); |
1017 EXPECT_EQ(SpdyFramer::SPDY_INVALID_STREAM_ID, framer.spdy_framer_error()) | 1070 EXPECT_EQ(SpdyFramer::SPDY_INVALID_STREAM_ID, framer.spdy_framer_error()) |
1018 << SpdyFramer::SpdyFramerErrorToString(framer.spdy_framer_error()); | 1071 << SpdyFramer::SpdyFramerErrorToString(framer.spdy_framer_error()); |
1019 } | 1072 } |
1020 | 1073 |
1021 // Test that if we receive a PRIORITY with stream ID zero, we signal an error | 1074 // Test that if we receive a PRIORITY with stream ID zero, we signal an error |
1022 // (but don't crash). | 1075 // (but don't crash). |
1023 TEST_P(SpdyFramerTest, PriorityWithStreamIdZero) { | 1076 TEST_P(SpdyFramerTest, PriorityWithStreamIdZero) { |
1024 testing::StrictMock<test::MockSpdyFramerVisitor> visitor; | 1077 testing::StrictMock<test::MockSpdyFramerVisitor> visitor; |
1025 SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION); | 1078 SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION); |
1026 framer.set_visitor(&visitor); | 1079 framer.set_visitor(&visitor); |
1027 | 1080 |
1028 SpdyPriorityIR priority_ir(0, 1, 16, true); | 1081 SpdyPriorityIR priority_ir(0, 1, 16, true); |
1029 SpdySerializedFrame frame(framer.SerializeFrame(priority_ir)); | 1082 SpdySerializedFrame frame(framer.SerializeFrame(priority_ir)); |
1083 if (use_output_) { | |
1084 EXPECT_TRUE(framer.SerializeFrame(priority_ir, &output_)); | |
Bence
2017/03/16 18:12:54
Please use ASSERT_TRUE instead of EXPECT_TRUE, bec
yasong
2017/03/16 22:28:52
Done.
| |
1085 frame = SpdySerializedFrame(output_.Begin(), output_.Size(), false); | |
1086 } | |
1030 | 1087 |
1031 // We shouldn't have to read the whole frame before we signal an error. | 1088 // We shouldn't have to read the whole frame before we signal an error. |
1032 EXPECT_CALL(visitor, OnError(testing::Eq(&framer))); | 1089 EXPECT_CALL(visitor, OnError(testing::Eq(&framer))); |
1033 EXPECT_GT(frame.size(), framer.ProcessInput(frame.data(), frame.size())); | 1090 EXPECT_GT(frame.size(), framer.ProcessInput(frame.data(), frame.size())); |
1034 EXPECT_TRUE(framer.HasError()); | 1091 EXPECT_TRUE(framer.HasError()); |
1035 EXPECT_EQ(SpdyFramer::SPDY_INVALID_STREAM_ID, framer.spdy_framer_error()) | 1092 EXPECT_EQ(SpdyFramer::SPDY_INVALID_STREAM_ID, framer.spdy_framer_error()) |
1036 << SpdyFramer::SpdyFramerErrorToString(framer.spdy_framer_error()); | 1093 << SpdyFramer::SpdyFramerErrorToString(framer.spdy_framer_error()); |
1037 } | 1094 } |
1038 | 1095 |
1039 // Test that if we receive a RST_STREAM with stream ID zero, we signal an error | 1096 // Test that if we receive a RST_STREAM with stream ID zero, we signal an error |
1040 // (but don't crash). | 1097 // (but don't crash). |
1041 TEST_P(SpdyFramerTest, RstStreamWithStreamIdZero) { | 1098 TEST_P(SpdyFramerTest, RstStreamWithStreamIdZero) { |
1042 testing::StrictMock<test::MockSpdyFramerVisitor> visitor; | 1099 testing::StrictMock<test::MockSpdyFramerVisitor> visitor; |
1043 SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION); | 1100 SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION); |
1044 framer.set_visitor(&visitor); | 1101 framer.set_visitor(&visitor); |
1045 | 1102 |
1046 SpdyRstStreamIR rst_stream_ir(0, ERROR_CODE_PROTOCOL_ERROR); | 1103 SpdyRstStreamIR rst_stream_ir(0, ERROR_CODE_PROTOCOL_ERROR); |
1047 SpdySerializedFrame frame(framer.SerializeRstStream(rst_stream_ir)); | 1104 SpdySerializedFrame frame(framer.SerializeRstStream(rst_stream_ir)); |
1105 if (use_output_) { | |
1106 EXPECT_TRUE(framer.SerializeRstStream(rst_stream_ir, &output_)); | |
1107 frame = SpdySerializedFrame(output_.Begin(), output_.Size(), false); | |
1108 } | |
1048 | 1109 |
1049 // We shouldn't have to read the whole frame before we signal an error. | 1110 // We shouldn't have to read the whole frame before we signal an error. |
1050 EXPECT_CALL(visitor, OnError(testing::Eq(&framer))); | 1111 EXPECT_CALL(visitor, OnError(testing::Eq(&framer))); |
1051 EXPECT_GT(frame.size(), framer.ProcessInput(frame.data(), frame.size())); | 1112 EXPECT_GT(frame.size(), framer.ProcessInput(frame.data(), frame.size())); |
1052 EXPECT_TRUE(framer.HasError()); | 1113 EXPECT_TRUE(framer.HasError()); |
1053 EXPECT_EQ(SpdyFramer::SPDY_INVALID_STREAM_ID, framer.spdy_framer_error()) | 1114 EXPECT_EQ(SpdyFramer::SPDY_INVALID_STREAM_ID, framer.spdy_framer_error()) |
1054 << SpdyFramer::SpdyFramerErrorToString(framer.spdy_framer_error()); | 1115 << SpdyFramer::SpdyFramerErrorToString(framer.spdy_framer_error()); |
1055 } | 1116 } |
1056 | 1117 |
1057 // Test that if we receive a SETTINGS with stream ID other than zero, | 1118 // Test that if we receive a SETTINGS with stream ID other than zero, |
(...skipping 57 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
1115 testing::StrictMock<test::MockSpdyFramerVisitor> visitor; | 1176 testing::StrictMock<test::MockSpdyFramerVisitor> visitor; |
1116 SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION); | 1177 SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION); |
1117 framer.set_visitor(&visitor); | 1178 framer.set_visitor(&visitor); |
1118 | 1179 |
1119 SpdyContinuationIR continuation(0); | 1180 SpdyContinuationIR continuation(0); |
1120 auto some_nonsense_encoding = | 1181 auto some_nonsense_encoding = |
1121 base::MakeUnique<string>("some nonsense encoding"); | 1182 base::MakeUnique<string>("some nonsense encoding"); |
1122 continuation.take_encoding(std::move(some_nonsense_encoding)); | 1183 continuation.take_encoding(std::move(some_nonsense_encoding)); |
1123 continuation.set_end_headers(true); | 1184 continuation.set_end_headers(true); |
1124 SpdySerializedFrame frame(framer.SerializeContinuation(continuation)); | 1185 SpdySerializedFrame frame(framer.SerializeContinuation(continuation)); |
1186 if (use_output_) { | |
1187 EXPECT_TRUE(framer.SerializeContinuation(continuation, &output_)); | |
1188 frame = SpdySerializedFrame(output_.Begin(), output_.Size(), false); | |
1189 } | |
1125 | 1190 |
1126 // We shouldn't have to read the whole frame before we signal an error. | 1191 // We shouldn't have to read the whole frame before we signal an error. |
1127 EXPECT_CALL(visitor, OnError(testing::Eq(&framer))); | 1192 EXPECT_CALL(visitor, OnError(testing::Eq(&framer))); |
1128 EXPECT_GT(frame.size(), framer.ProcessInput(frame.data(), frame.size())); | 1193 EXPECT_GT(frame.size(), framer.ProcessInput(frame.data(), frame.size())); |
1129 EXPECT_TRUE(framer.HasError()); | 1194 EXPECT_TRUE(framer.HasError()); |
1130 EXPECT_EQ(SpdyFramer::SPDY_INVALID_STREAM_ID, framer.spdy_framer_error()) | 1195 EXPECT_EQ(SpdyFramer::SPDY_INVALID_STREAM_ID, framer.spdy_framer_error()) |
1131 << SpdyFramer::SpdyFramerErrorToString(framer.spdy_framer_error()); | 1196 << SpdyFramer::SpdyFramerErrorToString(framer.spdy_framer_error()); |
1132 } | 1197 } |
1133 | 1198 |
1134 // Test that if we receive a PUSH_PROMISE with stream ID zero, we signal an | 1199 // Test that if we receive a PUSH_PROMISE with stream ID zero, we signal an |
1135 // SPDY_INVALID_STREAM_ID. | 1200 // SPDY_INVALID_STREAM_ID. |
1136 TEST_P(SpdyFramerTest, PushPromiseWithStreamIdZero) { | 1201 TEST_P(SpdyFramerTest, PushPromiseWithStreamIdZero) { |
1137 testing::StrictMock<test::MockSpdyFramerVisitor> visitor; | 1202 testing::StrictMock<test::MockSpdyFramerVisitor> visitor; |
1138 SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION); | 1203 SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION); |
1139 framer.set_visitor(&visitor); | 1204 framer.set_visitor(&visitor); |
1140 | 1205 |
1141 SpdyPushPromiseIR push_promise(0, 4); | 1206 SpdyPushPromiseIR push_promise(0, 4); |
1142 push_promise.SetHeader("alpha", "beta"); | 1207 push_promise.SetHeader("alpha", "beta"); |
1143 SpdySerializedFrame frame(framer.SerializePushPromise(push_promise)); | 1208 SpdySerializedFrame frame(framer.SerializePushPromise(push_promise)); |
1209 if (use_output_) { | |
1210 EXPECT_TRUE(framer.SerializePushPromise(push_promise, &output_)); | |
1211 frame = SpdySerializedFrame(output_.Begin(), output_.Size(), false); | |
1212 } | |
1144 | 1213 |
1145 // We shouldn't have to read the whole frame before we signal an error. | 1214 // We shouldn't have to read the whole frame before we signal an error. |
1146 EXPECT_CALL(visitor, OnError(testing::Eq(&framer))); | 1215 EXPECT_CALL(visitor, OnError(testing::Eq(&framer))); |
1147 EXPECT_GT(frame.size(), framer.ProcessInput(frame.data(), frame.size())); | 1216 EXPECT_GT(frame.size(), framer.ProcessInput(frame.data(), frame.size())); |
1148 EXPECT_TRUE(framer.HasError()); | 1217 EXPECT_TRUE(framer.HasError()); |
1149 EXPECT_EQ(SpdyFramer::SPDY_INVALID_STREAM_ID, framer.spdy_framer_error()) | 1218 EXPECT_EQ(SpdyFramer::SPDY_INVALID_STREAM_ID, framer.spdy_framer_error()) |
1150 << SpdyFramer::SpdyFramerErrorToString(framer.spdy_framer_error()); | 1219 << SpdyFramer::SpdyFramerErrorToString(framer.spdy_framer_error()); |
1151 } | 1220 } |
1152 | 1221 |
1153 // Test that if we receive a PUSH_PROMISE with promised stream ID zero, we | 1222 // Test that if we receive a PUSH_PROMISE with promised stream ID zero, we |
1154 // signal SPDY_INVALID_STREAM_ID. | 1223 // signal SPDY_INVALID_STREAM_ID. |
1155 TEST_P(SpdyFramerTest, PushPromiseWithPromisedStreamIdZero) { | 1224 TEST_P(SpdyFramerTest, PushPromiseWithPromisedStreamIdZero) { |
1156 testing::StrictMock<test::MockSpdyFramerVisitor> visitor; | 1225 testing::StrictMock<test::MockSpdyFramerVisitor> visitor; |
1157 SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION); | 1226 SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION); |
1158 framer.set_visitor(&visitor); | 1227 framer.set_visitor(&visitor); |
1159 | 1228 |
1160 SpdyPushPromiseIR push_promise(3, 0); | 1229 SpdyPushPromiseIR push_promise(3, 0); |
1161 push_promise.SetHeader("alpha", "beta"); | 1230 push_promise.SetHeader("alpha", "beta"); |
1162 SpdySerializedFrame frame(framer.SerializePushPromise(push_promise)); | 1231 SpdySerializedFrame frame(framer.SerializePushPromise(push_promise)); |
1232 if (use_output_) { | |
1233 EXPECT_TRUE(framer.SerializePushPromise(push_promise, &output_)); | |
1234 frame = SpdySerializedFrame(output_.Begin(), output_.Size(), false); | |
1235 } | |
1163 | 1236 |
1164 EXPECT_CALL(visitor, OnError(testing::Eq(&framer))); | 1237 EXPECT_CALL(visitor, OnError(testing::Eq(&framer))); |
1165 framer.ProcessInput(frame.data(), frame.size()); | 1238 framer.ProcessInput(frame.data(), frame.size()); |
1166 EXPECT_TRUE(framer.HasError()); | 1239 EXPECT_TRUE(framer.HasError()); |
1167 EXPECT_EQ(SpdyFramer::SPDY_INVALID_CONTROL_FRAME, framer.spdy_framer_error()) | 1240 EXPECT_EQ(SpdyFramer::SPDY_INVALID_CONTROL_FRAME, framer.spdy_framer_error()) |
1168 << SpdyFramer::SpdyFramerErrorToString(framer.spdy_framer_error()); | 1241 << SpdyFramer::SpdyFramerErrorToString(framer.spdy_framer_error()); |
1169 } | 1242 } |
1170 | 1243 |
1171 TEST_P(SpdyFramerTest, DuplicateHeader) { | 1244 TEST_P(SpdyFramerTest, DuplicateHeader) { |
1172 SpdyFramer framer(SpdyFramer::DISABLE_COMPRESSION); | 1245 SpdyFramer framer(SpdyFramer::DISABLE_COMPRESSION); |
(...skipping 226 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
1399 SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION); | 1472 SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION); |
1400 | 1473 |
1401 const char kHeader1[] = "header1"; | 1474 const char kHeader1[] = "header1"; |
1402 const char kHeader2[] = "header2"; | 1475 const char kHeader2[] = "header2"; |
1403 const char kValue1[] = "value1"; | 1476 const char kValue1[] = "value1"; |
1404 const char kValue2[] = "value2"; | 1477 const char kValue2[] = "value2"; |
1405 | 1478 |
1406 SpdyHeadersIR headers(1); | 1479 SpdyHeadersIR headers(1); |
1407 headers.SetHeader(kHeader1, kValue1); | 1480 headers.SetHeader(kHeader1, kValue1); |
1408 headers.SetHeader(kHeader2, kValue2); | 1481 headers.SetHeader(kHeader2, kValue2); |
1409 SpdySerializedFrame headers_frame( | 1482 SpdySerializedFrame headers_frame(SpdyFramerPeer::SerializeHeaders( |
1410 SpdyFramerPeer::SerializeHeaders(&framer, headers)); | 1483 &framer, headers, use_output_ ? &output_ : nullptr)); |
1411 | 1484 |
1412 const char bytes[] = "this is a test test test test test!"; | 1485 const char bytes[] = "this is a test test test test test!"; |
1413 SpdyDataIR data_ir(1, StringPiece(bytes, arraysize(bytes))); | 1486 SpdyDataIR data_ir(1, StringPiece(bytes, arraysize(bytes))); |
1414 data_ir.set_fin(true); | 1487 data_ir.set_fin(true); |
1415 SpdySerializedFrame send_frame(framer.SerializeData(data_ir)); | 1488 SpdySerializedFrame send_frame(framer.SerializeData(data_ir)); |
1416 | 1489 |
1417 // Run the inputs through the framer. | 1490 // Run the inputs through the framer. |
1418 TestSpdyVisitor visitor(SpdyFramer::ENABLE_COMPRESSION); | 1491 TestSpdyVisitor visitor(SpdyFramer::ENABLE_COMPRESSION); |
1419 const unsigned char* data; | 1492 const unsigned char* data; |
1420 data = reinterpret_cast<const unsigned char*>(headers_frame.data()); | 1493 data = reinterpret_cast<const unsigned char*>(headers_frame.data()); |
(...skipping 11 matching lines...) Expand all Loading... | |
1432 EXPECT_EQ(1, visitor.headers_frame_count_); | 1505 EXPECT_EQ(1, visitor.headers_frame_count_); |
1433 EXPECT_EQ(arraysize(bytes), static_cast<unsigned>(visitor.data_bytes_)); | 1506 EXPECT_EQ(arraysize(bytes), static_cast<unsigned>(visitor.data_bytes_)); |
1434 EXPECT_EQ(0, visitor.fin_frame_count_); | 1507 EXPECT_EQ(0, visitor.fin_frame_count_); |
1435 EXPECT_EQ(0, visitor.fin_flag_count_); | 1508 EXPECT_EQ(0, visitor.fin_flag_count_); |
1436 EXPECT_EQ(1, visitor.end_of_stream_count_); | 1509 EXPECT_EQ(1, visitor.end_of_stream_count_); |
1437 EXPECT_EQ(1, visitor.data_frame_count_); | 1510 EXPECT_EQ(1, visitor.data_frame_count_); |
1438 } | 1511 } |
1439 | 1512 |
1440 TEST_P(SpdyFramerTest, WindowUpdateFrame) { | 1513 TEST_P(SpdyFramerTest, WindowUpdateFrame) { |
1441 SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION); | 1514 SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION); |
1442 SpdySerializedFrame frame( | 1515 SpdyWindowUpdateIR window_update(1, 0x12345678); |
1443 framer.SerializeWindowUpdate(SpdyWindowUpdateIR(1, 0x12345678))); | 1516 SpdySerializedFrame frame(framer.SerializeWindowUpdate(window_update)); |
1517 if (use_output_) { | |
1518 EXPECT_TRUE(framer.SerializeWindowUpdate(window_update, &output_)); | |
1519 frame = SpdySerializedFrame(output_.Begin(), output_.Size(), false); | |
1520 } | |
1444 | 1521 |
1445 const char kDescription[] = "WINDOW_UPDATE frame, stream 1, delta 0x12345678"; | 1522 const char kDescription[] = "WINDOW_UPDATE frame, stream 1, delta 0x12345678"; |
1446 const unsigned char kH2FrameData[] = { | 1523 const unsigned char kH2FrameData[] = { |
1447 0x00, 0x00, 0x04, // Length: 4 | 1524 0x00, 0x00, 0x04, // Length: 4 |
1448 0x08, // Type: WINDOW_UPDATE | 1525 0x08, // Type: WINDOW_UPDATE |
1449 0x00, // Flags: none | 1526 0x00, // Flags: none |
1450 0x00, 0x00, 0x00, 0x01, // Stream: 1 | 1527 0x00, 0x00, 0x00, 0x01, // Stream: 1 |
1451 0x12, 0x34, 0x56, 0x78, // Increment: 305419896 | 1528 0x12, 0x34, 0x56, 0x78, // Increment: 305419896 |
1452 }; | 1529 }; |
1453 | 1530 |
(...skipping 209 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
1663 const char kDescription[] = "RST_STREAM frame"; | 1740 const char kDescription[] = "RST_STREAM frame"; |
1664 const unsigned char kH2FrameData[] = { | 1741 const unsigned char kH2FrameData[] = { |
1665 0x00, 0x00, 0x04, // Length: 4 | 1742 0x00, 0x00, 0x04, // Length: 4 |
1666 0x03, // Type: RST_STREAM | 1743 0x03, // Type: RST_STREAM |
1667 0x00, // Flags: none | 1744 0x00, // Flags: none |
1668 0x00, 0x00, 0x00, 0x01, // Stream: 1 | 1745 0x00, 0x00, 0x00, 0x01, // Stream: 1 |
1669 0x00, 0x00, 0x00, 0x01, // Error: PROTOCOL_ERROR | 1746 0x00, 0x00, 0x00, 0x01, // Error: PROTOCOL_ERROR |
1670 }; | 1747 }; |
1671 SpdyRstStreamIR rst_stream(1, ERROR_CODE_PROTOCOL_ERROR); | 1748 SpdyRstStreamIR rst_stream(1, ERROR_CODE_PROTOCOL_ERROR); |
1672 SpdySerializedFrame frame(framer.SerializeRstStream(rst_stream)); | 1749 SpdySerializedFrame frame(framer.SerializeRstStream(rst_stream)); |
1750 if (use_output_) { | |
1751 EXPECT_TRUE(framer.SerializeRstStream(rst_stream, &output_)); | |
1752 frame = SpdySerializedFrame(output_.Begin(), output_.Size(), false); | |
1753 } | |
1673 CompareFrame(kDescription, frame, kH2FrameData, arraysize(kH2FrameData)); | 1754 CompareFrame(kDescription, frame, kH2FrameData, arraysize(kH2FrameData)); |
1674 } | 1755 } |
1675 | 1756 |
1676 { | 1757 { |
1677 const char kDescription[] = "RST_STREAM frame with max stream ID"; | 1758 const char kDescription[] = "RST_STREAM frame with max stream ID"; |
1678 const unsigned char kH2FrameData[] = { | 1759 const unsigned char kH2FrameData[] = { |
1679 0x00, 0x00, 0x04, // Length: 4 | 1760 0x00, 0x00, 0x04, // Length: 4 |
1680 0x03, // Type: RST_STREAM | 1761 0x03, // Type: RST_STREAM |
1681 0x00, // Flags: none | 1762 0x00, // Flags: none |
1682 0x7f, 0xff, 0xff, 0xff, // Stream: 0x7fffffff | 1763 0x7f, 0xff, 0xff, 0xff, // Stream: 0x7fffffff |
1683 0x00, 0x00, 0x00, 0x01, // Error: PROTOCOL_ERROR | 1764 0x00, 0x00, 0x00, 0x01, // Error: PROTOCOL_ERROR |
1684 }; | 1765 }; |
1685 SpdyRstStreamIR rst_stream(0x7FFFFFFF, ERROR_CODE_PROTOCOL_ERROR); | 1766 SpdyRstStreamIR rst_stream(0x7FFFFFFF, ERROR_CODE_PROTOCOL_ERROR); |
1686 SpdySerializedFrame frame(framer.SerializeRstStream(rst_stream)); | 1767 SpdySerializedFrame frame(framer.SerializeRstStream(rst_stream)); |
1768 if (use_output_) { | |
1769 output_.Reset(); | |
1770 EXPECT_TRUE(framer.SerializeRstStream(rst_stream, &output_)); | |
1771 frame = SpdySerializedFrame(output_.Begin(), output_.Size(), false); | |
1772 } | |
1687 CompareFrame(kDescription, frame, kH2FrameData, arraysize(kH2FrameData)); | 1773 CompareFrame(kDescription, frame, kH2FrameData, arraysize(kH2FrameData)); |
1688 } | 1774 } |
1689 | 1775 |
1690 { | 1776 { |
1691 const char kDescription[] = "RST_STREAM frame with max status code"; | 1777 const char kDescription[] = "RST_STREAM frame with max status code"; |
1692 const unsigned char kH2FrameData[] = { | 1778 const unsigned char kH2FrameData[] = { |
1693 0x00, 0x00, 0x04, // Length: 4 | 1779 0x00, 0x00, 0x04, // Length: 4 |
1694 0x03, // Type: RST_STREAM | 1780 0x03, // Type: RST_STREAM |
1695 0x00, // Flags: none | 1781 0x00, // Flags: none |
1696 0x7f, 0xff, 0xff, 0xff, // Stream: 0x7fffffff | 1782 0x7f, 0xff, 0xff, 0xff, // Stream: 0x7fffffff |
1697 0x00, 0x00, 0x00, 0x02, // Error: INTERNAL_ERROR | 1783 0x00, 0x00, 0x00, 0x02, // Error: INTERNAL_ERROR |
1698 }; | 1784 }; |
1699 SpdyRstStreamIR rst_stream(0x7FFFFFFF, ERROR_CODE_INTERNAL_ERROR); | 1785 SpdyRstStreamIR rst_stream(0x7FFFFFFF, ERROR_CODE_INTERNAL_ERROR); |
1700 SpdySerializedFrame frame(framer.SerializeRstStream(rst_stream)); | 1786 SpdySerializedFrame frame(framer.SerializeRstStream(rst_stream)); |
1787 if (use_output_) { | |
1788 output_.Reset(); | |
1789 EXPECT_TRUE(framer.SerializeRstStream(rst_stream, &output_)); | |
1790 frame = SpdySerializedFrame(output_.Begin(), output_.Size(), false); | |
1791 } | |
1701 CompareFrame(kDescription, frame, kH2FrameData, arraysize(kH2FrameData)); | 1792 CompareFrame(kDescription, frame, kH2FrameData, arraysize(kH2FrameData)); |
1702 } | 1793 } |
1703 } | 1794 } |
1704 | 1795 |
1705 TEST_P(SpdyFramerTest, CreateSettings) { | 1796 TEST_P(SpdyFramerTest, CreateSettings) { |
1706 SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION); | 1797 SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION); |
1707 | 1798 |
1708 { | 1799 { |
1709 const char kDescription[] = "Network byte order SETTINGS frame"; | 1800 const char kDescription[] = "Network byte order SETTINGS frame"; |
1710 | 1801 |
1711 const unsigned char kH2FrameData[] = { | 1802 const unsigned char kH2FrameData[] = { |
1712 0x00, 0x00, 0x06, // Length: 6 | 1803 0x00, 0x00, 0x06, // Length: 6 |
1713 0x04, // Type: SETTINGS | 1804 0x04, // Type: SETTINGS |
1714 0x00, // Flags: none | 1805 0x00, // Flags: none |
1715 0x00, 0x00, 0x00, 0x00, // Stream: 0 | 1806 0x00, 0x00, 0x00, 0x00, // Stream: 0 |
1716 0x00, 0x04, // Param: INITIAL_WINDOW_SIZE | 1807 0x00, 0x04, // Param: INITIAL_WINDOW_SIZE |
1717 0x0a, 0x0b, 0x0c, 0x0d, // Value: 168496141 | 1808 0x0a, 0x0b, 0x0c, 0x0d, // Value: 168496141 |
1718 }; | 1809 }; |
1719 | 1810 |
1720 uint32_t kValue = 0x0a0b0c0d; | 1811 uint32_t kValue = 0x0a0b0c0d; |
1721 SpdySettingsIR settings_ir; | 1812 SpdySettingsIR settings_ir; |
1722 | 1813 |
1723 SpdySettingsIds kId = SETTINGS_INITIAL_WINDOW_SIZE; | 1814 SpdySettingsIds kId = SETTINGS_INITIAL_WINDOW_SIZE; |
1724 settings_ir.AddSetting(kId, kValue); | 1815 settings_ir.AddSetting(kId, kValue); |
1725 | 1816 |
1726 SpdySerializedFrame frame(framer.SerializeSettings(settings_ir)); | 1817 SpdySerializedFrame frame(framer.SerializeSettings(settings_ir)); |
1818 if (use_output_) { | |
1819 EXPECT_TRUE(framer.SerializeSettings(settings_ir, &output_)); | |
1820 frame = SpdySerializedFrame(output_.Begin(), output_.Size(), false); | |
1821 } | |
1727 CompareFrame(kDescription, frame, kH2FrameData, arraysize(kH2FrameData)); | 1822 CompareFrame(kDescription, frame, kH2FrameData, arraysize(kH2FrameData)); |
1728 } | 1823 } |
1729 | 1824 |
1730 { | 1825 { |
1731 const char kDescription[] = "Basic SETTINGS frame"; | 1826 const char kDescription[] = "Basic SETTINGS frame"; |
1732 // These end up seemingly out of order because of the way that our internal | 1827 // These end up seemingly out of order because of the way that our internal |
1733 // ordering for settings_ir works. HTTP2 has no requirement on ordering on | 1828 // ordering for settings_ir works. HTTP2 has no requirement on ordering on |
1734 // the wire. | 1829 // the wire. |
1735 const unsigned char kH2FrameData[] = { | 1830 const unsigned char kH2FrameData[] = { |
1736 0x00, 0x00, 0x18, // Length: 24 | 1831 0x00, 0x00, 0x18, // Length: 24 |
1737 0x04, // Type: SETTINGS | 1832 0x04, // Type: SETTINGS |
1738 0x00, // Flags: none | 1833 0x00, // Flags: none |
1739 0x00, 0x00, 0x00, 0x00, // Stream: 0 | 1834 0x00, 0x00, 0x00, 0x00, // Stream: 0 |
1740 0x00, 0x01, // Param: HEADER_TABLE_SIZE | 1835 0x00, 0x01, // Param: HEADER_TABLE_SIZE |
1741 0x00, 0x00, 0x00, 0x05, // Value: 5 | 1836 0x00, 0x00, 0x00, 0x05, // Value: 5 |
1742 0x00, 0x02, // Param: ENABLE_PUSH | 1837 0x00, 0x02, // Param: ENABLE_PUSH |
1743 0x00, 0x00, 0x00, 0x06, // Value: 6 | 1838 0x00, 0x00, 0x00, 0x06, // Value: 6 |
1744 0x00, 0x03, // Param: MAX_CONCURRENT_STREAMS | 1839 0x00, 0x03, // Param: MAX_CONCURRENT_STREAMS |
1745 0x00, 0x00, 0x00, 0x07, // Value: 7 | 1840 0x00, 0x00, 0x00, 0x07, // Value: 7 |
1746 0x00, 0x04, // Param: INITIAL_WINDOW_SIZE | 1841 0x00, 0x04, // Param: INITIAL_WINDOW_SIZE |
1747 0x00, 0x00, 0x00, 0x08, // Value: 8 | 1842 0x00, 0x00, 0x00, 0x08, // Value: 8 |
1748 }; | 1843 }; |
1749 | 1844 |
1750 SpdySettingsIR settings_ir; | 1845 SpdySettingsIR settings_ir; |
1751 settings_ir.AddSetting(SETTINGS_HEADER_TABLE_SIZE, 5); | 1846 settings_ir.AddSetting(SETTINGS_HEADER_TABLE_SIZE, 5); |
1752 settings_ir.AddSetting(SETTINGS_ENABLE_PUSH, 6); | 1847 settings_ir.AddSetting(SETTINGS_ENABLE_PUSH, 6); |
1753 settings_ir.AddSetting(SETTINGS_MAX_CONCURRENT_STREAMS, 7); | 1848 settings_ir.AddSetting(SETTINGS_MAX_CONCURRENT_STREAMS, 7); |
1754 settings_ir.AddSetting(SETTINGS_INITIAL_WINDOW_SIZE, 8); | 1849 settings_ir.AddSetting(SETTINGS_INITIAL_WINDOW_SIZE, 8); |
1755 SpdySerializedFrame frame(framer.SerializeSettings(settings_ir)); | 1850 SpdySerializedFrame frame(framer.SerializeSettings(settings_ir)); |
1851 if (use_output_) { | |
1852 output_.Reset(); | |
1853 EXPECT_TRUE(framer.SerializeSettings(settings_ir, &output_)); | |
1854 frame = SpdySerializedFrame(output_.Begin(), output_.Size(), false); | |
1855 } | |
1756 | 1856 |
1757 CompareFrame(kDescription, frame, kH2FrameData, arraysize(kH2FrameData)); | 1857 CompareFrame(kDescription, frame, kH2FrameData, arraysize(kH2FrameData)); |
1758 } | 1858 } |
1759 | 1859 |
1760 { | 1860 { |
1761 const char kDescription[] = "Empty SETTINGS frame"; | 1861 const char kDescription[] = "Empty SETTINGS frame"; |
1762 | 1862 |
1763 const unsigned char kH2FrameData[] = { | 1863 const unsigned char kH2FrameData[] = { |
1764 0x00, 0x00, 0x00, // Length: 0 | 1864 0x00, 0x00, 0x00, // Length: 0 |
1765 0x04, // Type: SETTINGS | 1865 0x04, // Type: SETTINGS |
1766 0x00, // Flags: none | 1866 0x00, // Flags: none |
1767 0x00, 0x00, 0x00, 0x00, // Stream: 0 | 1867 0x00, 0x00, 0x00, 0x00, // Stream: 0 |
1768 }; | 1868 }; |
1769 SpdySettingsIR settings_ir; | 1869 SpdySettingsIR settings_ir; |
1770 SpdySerializedFrame frame(framer.SerializeSettings(settings_ir)); | 1870 SpdySerializedFrame frame(framer.SerializeSettings(settings_ir)); |
1871 if (use_output_) { | |
1872 output_.Reset(); | |
1873 EXPECT_TRUE(framer.SerializeSettings(settings_ir, &output_)); | |
1874 frame = SpdySerializedFrame(output_.Begin(), output_.Size(), false); | |
1875 } | |
1876 | |
1771 CompareFrame(kDescription, frame, kH2FrameData, arraysize(kH2FrameData)); | 1877 CompareFrame(kDescription, frame, kH2FrameData, arraysize(kH2FrameData)); |
1772 } | 1878 } |
1773 } | 1879 } |
1774 | 1880 |
1775 TEST_P(SpdyFramerTest, CreatePingFrame) { | 1881 TEST_P(SpdyFramerTest, CreatePingFrame) { |
1776 SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION); | 1882 SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION); |
1777 | 1883 |
1778 { | 1884 { |
1779 const char kDescription[] = "PING frame"; | 1885 const char kDescription[] = "PING frame"; |
1780 const unsigned char kH2FrameData[] = { | 1886 const unsigned char kH2FrameData[] = { |
(...skipping 11 matching lines...) Expand all Loading... | |
1792 0x00, 0x00, 0x00, 0x00, // Stream: 0 | 1898 0x00, 0x00, 0x00, 0x00, // Stream: 0 |
1793 0x12, 0x34, 0x56, 0x78, // Opaque | 1899 0x12, 0x34, 0x56, 0x78, // Opaque |
1794 0x9a, 0xbc, 0xde, 0xff, // Data | 1900 0x9a, 0xbc, 0xde, 0xff, // Data |
1795 }; | 1901 }; |
1796 SpdySerializedFrame frame; | 1902 SpdySerializedFrame frame; |
1797 const SpdyPingId kPingId = 0x123456789abcdeffULL; | 1903 const SpdyPingId kPingId = 0x123456789abcdeffULL; |
1798 SpdyPingIR ping_ir(kPingId); | 1904 SpdyPingIR ping_ir(kPingId); |
1799 // Tests SpdyPingIR when the ping is not an ack. | 1905 // Tests SpdyPingIR when the ping is not an ack. |
1800 ASSERT_FALSE(ping_ir.is_ack()); | 1906 ASSERT_FALSE(ping_ir.is_ack()); |
1801 frame = framer.SerializePing(ping_ir); | 1907 frame = framer.SerializePing(ping_ir); |
1908 if (use_output_) { | |
1909 EXPECT_TRUE(framer.SerializePing(ping_ir, &output_)); | |
1910 frame = SpdySerializedFrame(output_.Begin(), output_.Size(), false); | |
1911 } | |
1802 CompareFrame(kDescription, frame, kH2FrameData, arraysize(kH2FrameData)); | 1912 CompareFrame(kDescription, frame, kH2FrameData, arraysize(kH2FrameData)); |
1803 | 1913 |
1804 // Tests SpdyPingIR when the ping is an ack. | 1914 // Tests SpdyPingIR when the ping is an ack. |
1805 ping_ir.set_is_ack(true); | 1915 ping_ir.set_is_ack(true); |
1806 frame = framer.SerializePing(ping_ir); | 1916 frame = framer.SerializePing(ping_ir); |
1917 if (use_output_) { | |
1918 output_.Reset(); | |
1919 EXPECT_TRUE(framer.SerializePing(ping_ir, &output_)); | |
1920 frame = SpdySerializedFrame(output_.Begin(), output_.Size(), false); | |
1921 } | |
1807 CompareFrame(kDescription, frame, kH2FrameDataWithAck, | 1922 CompareFrame(kDescription, frame, kH2FrameDataWithAck, |
1808 arraysize(kH2FrameDataWithAck)); | 1923 arraysize(kH2FrameDataWithAck)); |
1809 } | 1924 } |
1810 } | 1925 } |
1811 | 1926 |
1812 TEST_P(SpdyFramerTest, CreateGoAway) { | 1927 TEST_P(SpdyFramerTest, CreateGoAway) { |
1813 SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION); | 1928 SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION); |
1814 | 1929 |
1815 { | 1930 { |
1816 const char kDescription[] = "GOAWAY frame"; | 1931 const char kDescription[] = "GOAWAY frame"; |
1817 const unsigned char kH2FrameData[] = { | 1932 const unsigned char kH2FrameData[] = { |
1818 0x00, 0x00, 0x0a, // Length: 10 | 1933 0x00, 0x00, 0x0a, // Length: 10 |
1819 0x07, // Type: GOAWAY | 1934 0x07, // Type: GOAWAY |
1820 0x00, // Flags: none | 1935 0x00, // Flags: none |
1821 0x00, 0x00, 0x00, 0x00, // Stream: 0 | 1936 0x00, 0x00, 0x00, 0x00, // Stream: 0 |
1822 0x00, 0x00, 0x00, 0x00, // Last: 0 | 1937 0x00, 0x00, 0x00, 0x00, // Last: 0 |
1823 0x00, 0x00, 0x00, 0x00, // Error: NO_ERROR | 1938 0x00, 0x00, 0x00, 0x00, // Error: NO_ERROR |
1824 0x47, 0x41, // Description | 1939 0x47, 0x41, // Description |
1825 }; | 1940 }; |
1826 SpdyGoAwayIR goaway_ir(0, ERROR_CODE_NO_ERROR, "GA"); | 1941 SpdyGoAwayIR goaway_ir(0, ERROR_CODE_NO_ERROR, "GA"); |
1827 SpdySerializedFrame frame(framer.SerializeGoAway(goaway_ir)); | 1942 SpdySerializedFrame frame(framer.SerializeGoAway(goaway_ir)); |
1943 if (use_output_) { | |
1944 EXPECT_TRUE(framer.SerializeGoAway(goaway_ir, &output_)); | |
1945 frame = SpdySerializedFrame(output_.Begin(), output_.Size(), false); | |
1946 } | |
1828 CompareFrame(kDescription, frame, kH2FrameData, arraysize(kH2FrameData)); | 1947 CompareFrame(kDescription, frame, kH2FrameData, arraysize(kH2FrameData)); |
1829 } | 1948 } |
1830 | 1949 |
1831 { | 1950 { |
1832 const char kDescription[] = "GOAWAY frame with max stream ID, status"; | 1951 const char kDescription[] = "GOAWAY frame with max stream ID, status"; |
1833 const unsigned char kH2FrameData[] = { | 1952 const unsigned char kH2FrameData[] = { |
1834 0x00, 0x00, 0x0a, // Length: 10 | 1953 0x00, 0x00, 0x0a, // Length: 10 |
1835 0x07, // Type: GOAWAY | 1954 0x07, // Type: GOAWAY |
1836 0x00, // Flags: none | 1955 0x00, // Flags: none |
1837 0x00, 0x00, 0x00, 0x00, // Stream: 0 | 1956 0x00, 0x00, 0x00, 0x00, // Stream: 0 |
1838 0x7f, 0xff, 0xff, 0xff, // Last: 0x7fffffff | 1957 0x7f, 0xff, 0xff, 0xff, // Last: 0x7fffffff |
1839 0x00, 0x00, 0x00, 0x02, // Error: INTERNAL_ERROR | 1958 0x00, 0x00, 0x00, 0x02, // Error: INTERNAL_ERROR |
1840 0x47, 0x41, // Description | 1959 0x47, 0x41, // Description |
1841 }; | 1960 }; |
1842 SpdyGoAwayIR goaway_ir(0x7FFFFFFF, ERROR_CODE_INTERNAL_ERROR, "GA"); | 1961 SpdyGoAwayIR goaway_ir(0x7FFFFFFF, ERROR_CODE_INTERNAL_ERROR, "GA"); |
1843 SpdySerializedFrame frame(framer.SerializeGoAway(goaway_ir)); | 1962 SpdySerializedFrame frame(framer.SerializeGoAway(goaway_ir)); |
1963 if (use_output_) { | |
1964 output_.Reset(); | |
1965 EXPECT_TRUE(framer.SerializeGoAway(goaway_ir, &output_)); | |
1966 frame = SpdySerializedFrame(output_.Begin(), output_.Size(), false); | |
1967 } | |
1844 CompareFrame(kDescription, frame, kH2FrameData, arraysize(kH2FrameData)); | 1968 CompareFrame(kDescription, frame, kH2FrameData, arraysize(kH2FrameData)); |
1845 } | 1969 } |
1846 } | 1970 } |
1847 | 1971 |
1848 TEST_P(SpdyFramerTest, CreateHeadersUncompressed) { | 1972 TEST_P(SpdyFramerTest, CreateHeadersUncompressed) { |
1849 SpdyFramer framer(SpdyFramer::DISABLE_COMPRESSION); | 1973 SpdyFramer framer(SpdyFramer::DISABLE_COMPRESSION); |
1850 | 1974 |
1851 { | 1975 { |
1852 const char kDescription[] = "HEADERS frame, no FIN"; | 1976 const char kDescription[] = "HEADERS frame, no FIN"; |
1853 // frame-format off | 1977 // frame-format off |
(...skipping 13 matching lines...) Expand all Loading... | |
1867 0x03, // Name Len: 3 | 1991 0x03, // Name Len: 3 |
1868 0x66, 0x6f, 0x6f, // foo | 1992 0x66, 0x6f, 0x6f, // foo |
1869 0x03, // Value Len: 3 | 1993 0x03, // Value Len: 3 |
1870 0x62, 0x61, 0x72, // bar | 1994 0x62, 0x61, 0x72, // bar |
1871 }; | 1995 }; |
1872 // frame-format on | 1996 // frame-format on |
1873 | 1997 |
1874 SpdyHeadersIR headers(1); | 1998 SpdyHeadersIR headers(1); |
1875 headers.SetHeader("bar", "foo"); | 1999 headers.SetHeader("bar", "foo"); |
1876 headers.SetHeader("foo", "bar"); | 2000 headers.SetHeader("foo", "bar"); |
1877 SpdySerializedFrame frame( | 2001 SpdySerializedFrame frame(SpdyFramerPeer::SerializeHeaders( |
1878 SpdyFramerPeer::SerializeHeaders(&framer, headers)); | 2002 &framer, headers, use_output_ ? &output_ : nullptr)); |
1879 CompareFrame(kDescription, frame, kH2FrameData, arraysize(kH2FrameData)); | 2003 CompareFrame(kDescription, frame, kH2FrameData, arraysize(kH2FrameData)); |
1880 } | 2004 } |
1881 | 2005 |
1882 { | 2006 { |
1883 const char kDescription[] = | 2007 const char kDescription[] = |
1884 "HEADERS frame with a 0-length header name, FIN, max stream ID"; | 2008 "HEADERS frame with a 0-length header name, FIN, max stream ID"; |
1885 // frame-format off | 2009 // frame-format off |
1886 const unsigned char kH2FrameData[] = { | 2010 const unsigned char kH2FrameData[] = { |
1887 0x00, 0x00, 0x0f, // Length: 15 | 2011 0x00, 0x00, 0x0f, // Length: 15 |
1888 0x01, // Type: HEADERS | 2012 0x01, // Type: HEADERS |
1889 0x05, // Flags: END_STREAM|END_HEADERS | 2013 0x05, // Flags: END_STREAM|END_HEADERS |
1890 0x7f, 0xff, 0xff, 0xff, // Stream: 2147483647 | 2014 0x7f, 0xff, 0xff, 0xff, // Stream: 2147483647 |
1891 | 2015 |
1892 0x00, // Unindexed Entry | 2016 0x00, // Unindexed Entry |
1893 0x00, // Name Len: 0 | 2017 0x00, // Name Len: 0 |
1894 0x03, // Value Len: 3 | 2018 0x03, // Value Len: 3 |
1895 0x66, 0x6f, 0x6f, // foo | 2019 0x66, 0x6f, 0x6f, // foo |
1896 | 2020 |
1897 0x00, // Unindexed Entry | 2021 0x00, // Unindexed Entry |
1898 0x03, // Name Len: 3 | 2022 0x03, // Name Len: 3 |
1899 0x66, 0x6f, 0x6f, // foo | 2023 0x66, 0x6f, 0x6f, // foo |
1900 0x03, // Value Len: 3 | 2024 0x03, // Value Len: 3 |
1901 0x62, 0x61, 0x72, // bar | 2025 0x62, 0x61, 0x72, // bar |
1902 }; | 2026 }; |
1903 // frame-format on | 2027 // frame-format on |
1904 SpdyHeadersIR headers(0x7fffffff); | 2028 SpdyHeadersIR headers(0x7fffffff); |
1905 headers.set_fin(true); | 2029 headers.set_fin(true); |
1906 headers.SetHeader("", "foo"); | 2030 headers.SetHeader("", "foo"); |
1907 headers.SetHeader("foo", "bar"); | 2031 headers.SetHeader("foo", "bar"); |
1908 SpdySerializedFrame frame( | 2032 SpdySerializedFrame frame(SpdyFramerPeer::SerializeHeaders( |
1909 SpdyFramerPeer::SerializeHeaders(&framer, headers)); | 2033 &framer, headers, use_output_ ? &output_ : nullptr)); |
1910 CompareFrame(kDescription, frame, kH2FrameData, arraysize(kH2FrameData)); | 2034 CompareFrame(kDescription, frame, kH2FrameData, arraysize(kH2FrameData)); |
1911 } | 2035 } |
1912 | 2036 |
1913 { | 2037 { |
1914 const char kDescription[] = | 2038 const char kDescription[] = |
1915 "HEADERS frame with a 0-length header val, FIN, max stream ID"; | 2039 "HEADERS frame with a 0-length header val, FIN, max stream ID"; |
1916 // frame-format off | 2040 // frame-format off |
1917 const unsigned char kH2FrameData[] = { | 2041 const unsigned char kH2FrameData[] = { |
1918 0x00, 0x00, 0x0f, // Length: 15 | 2042 0x00, 0x00, 0x0f, // Length: 15 |
1919 0x01, // Type: HEADERS | 2043 0x01, // Type: HEADERS |
1920 0x05, // Flags: END_STREAM|END_HEADERS | 2044 0x05, // Flags: END_STREAM|END_HEADERS |
1921 0x7f, 0xff, 0xff, 0xff, // Stream: 2147483647 | 2045 0x7f, 0xff, 0xff, 0xff, // Stream: 2147483647 |
1922 | 2046 |
1923 0x00, // Unindexed Entry | 2047 0x00, // Unindexed Entry |
1924 0x03, // Name Len: 3 | 2048 0x03, // Name Len: 3 |
1925 0x62, 0x61, 0x72, // bar | 2049 0x62, 0x61, 0x72, // bar |
1926 0x03, // Value Len: 3 | 2050 0x03, // Value Len: 3 |
1927 0x66, 0x6f, 0x6f, // foo | 2051 0x66, 0x6f, 0x6f, // foo |
1928 | 2052 |
1929 0x00, // Unindexed Entry | 2053 0x00, // Unindexed Entry |
1930 0x03, // Name Len: 3 | 2054 0x03, // Name Len: 3 |
1931 0x66, 0x6f, 0x6f, // foo | 2055 0x66, 0x6f, 0x6f, // foo |
1932 0x00, // Value Len: 0 | 2056 0x00, // Value Len: 0 |
1933 }; | 2057 }; |
1934 // frame-format on | 2058 // frame-format on |
1935 SpdyHeadersIR headers_ir(0x7fffffff); | 2059 SpdyHeadersIR headers_ir(0x7fffffff); |
1936 headers_ir.set_fin(true); | 2060 headers_ir.set_fin(true); |
1937 headers_ir.SetHeader("bar", "foo"); | 2061 headers_ir.SetHeader("bar", "foo"); |
1938 headers_ir.SetHeader("foo", ""); | 2062 headers_ir.SetHeader("foo", ""); |
1939 SpdySerializedFrame frame( | 2063 SpdySerializedFrame frame(SpdyFramerPeer::SerializeHeaders( |
1940 SpdyFramerPeer::SerializeHeaders(&framer, headers_ir)); | 2064 &framer, headers_ir, use_output_ ? &output_ : nullptr)); |
1941 CompareFrame(kDescription, frame, kH2FrameData, arraysize(kH2FrameData)); | 2065 CompareFrame(kDescription, frame, kH2FrameData, arraysize(kH2FrameData)); |
1942 } | 2066 } |
1943 | 2067 |
1944 { | 2068 { |
1945 const char kDescription[] = | 2069 const char kDescription[] = |
1946 "HEADERS frame with a 0-length header val, FIN, max stream ID, pri"; | 2070 "HEADERS frame with a 0-length header val, FIN, max stream ID, pri"; |
1947 | 2071 |
1948 // frame-format off | 2072 // frame-format off |
1949 const unsigned char kH2FrameData[] = { | 2073 const unsigned char kH2FrameData[] = { |
1950 0x00, 0x00, 0x14, // Length: 20 | 2074 0x00, 0x00, 0x14, // Length: 20 |
(...skipping 14 matching lines...) Expand all Loading... | |
1965 0x66, 0x6f, 0x6f, // foo | 2089 0x66, 0x6f, 0x6f, // foo |
1966 0x00, // Value Len: 0 | 2090 0x00, // Value Len: 0 |
1967 }; | 2091 }; |
1968 // frame-format on | 2092 // frame-format on |
1969 SpdyHeadersIR headers_ir(0x7fffffff); | 2093 SpdyHeadersIR headers_ir(0x7fffffff); |
1970 headers_ir.set_fin(true); | 2094 headers_ir.set_fin(true); |
1971 headers_ir.set_has_priority(true); | 2095 headers_ir.set_has_priority(true); |
1972 headers_ir.set_weight(220); | 2096 headers_ir.set_weight(220); |
1973 headers_ir.SetHeader("bar", "foo"); | 2097 headers_ir.SetHeader("bar", "foo"); |
1974 headers_ir.SetHeader("foo", ""); | 2098 headers_ir.SetHeader("foo", ""); |
1975 SpdySerializedFrame frame( | 2099 SpdySerializedFrame frame(SpdyFramerPeer::SerializeHeaders( |
1976 SpdyFramerPeer::SerializeHeaders(&framer, headers_ir)); | 2100 &framer, headers_ir, use_output_ ? &output_ : nullptr)); |
1977 CompareFrame(kDescription, frame, kH2FrameData, arraysize(kH2FrameData)); | 2101 CompareFrame(kDescription, frame, kH2FrameData, arraysize(kH2FrameData)); |
1978 } | 2102 } |
1979 | 2103 |
1980 { | 2104 { |
1981 const char kDescription[] = | 2105 const char kDescription[] = |
1982 "HEADERS frame with a 0-length header val, FIN, max stream ID, pri, " | 2106 "HEADERS frame with a 0-length header val, FIN, max stream ID, pri, " |
1983 "exclusive=true, parent_stream=0"; | 2107 "exclusive=true, parent_stream=0"; |
1984 | 2108 |
1985 // frame-format off | 2109 // frame-format off |
1986 const unsigned char kV4FrameData[] = { | 2110 const unsigned char kV4FrameData[] = { |
(...skipping 17 matching lines...) Expand all Loading... | |
2004 }; | 2128 }; |
2005 // frame-format on | 2129 // frame-format on |
2006 SpdyHeadersIR headers_ir(0x7fffffff); | 2130 SpdyHeadersIR headers_ir(0x7fffffff); |
2007 headers_ir.set_fin(true); | 2131 headers_ir.set_fin(true); |
2008 headers_ir.set_has_priority(true); | 2132 headers_ir.set_has_priority(true); |
2009 headers_ir.set_weight(220); | 2133 headers_ir.set_weight(220); |
2010 headers_ir.set_exclusive(true); | 2134 headers_ir.set_exclusive(true); |
2011 headers_ir.set_parent_stream_id(0); | 2135 headers_ir.set_parent_stream_id(0); |
2012 headers_ir.SetHeader("bar", "foo"); | 2136 headers_ir.SetHeader("bar", "foo"); |
2013 headers_ir.SetHeader("foo", ""); | 2137 headers_ir.SetHeader("foo", ""); |
2014 SpdySerializedFrame frame( | 2138 SpdySerializedFrame frame(SpdyFramerPeer::SerializeHeaders( |
2015 SpdyFramerPeer::SerializeHeaders(&framer, headers_ir)); | 2139 &framer, headers_ir, use_output_ ? &output_ : nullptr)); |
2016 CompareFrame(kDescription, frame, kV4FrameData, arraysize(kV4FrameData)); | 2140 CompareFrame(kDescription, frame, kV4FrameData, arraysize(kV4FrameData)); |
2017 } | 2141 } |
2018 | 2142 |
2019 { | 2143 { |
2020 const char kDescription[] = | 2144 const char kDescription[] = |
2021 "HEADERS frame with a 0-length header val, FIN, max stream ID, pri, " | 2145 "HEADERS frame with a 0-length header val, FIN, max stream ID, pri, " |
2022 "exclusive=false, parent_stream=max stream ID"; | 2146 "exclusive=false, parent_stream=max stream ID"; |
2023 | 2147 |
2024 // frame-format off | 2148 // frame-format off |
2025 const unsigned char kV4FrameData[] = { | 2149 const unsigned char kV4FrameData[] = { |
(...skipping 17 matching lines...) Expand all Loading... | |
2043 }; | 2167 }; |
2044 // frame-format on | 2168 // frame-format on |
2045 SpdyHeadersIR headers_ir(0x7fffffff); | 2169 SpdyHeadersIR headers_ir(0x7fffffff); |
2046 headers_ir.set_fin(true); | 2170 headers_ir.set_fin(true); |
2047 headers_ir.set_has_priority(true); | 2171 headers_ir.set_has_priority(true); |
2048 headers_ir.set_weight(220); | 2172 headers_ir.set_weight(220); |
2049 headers_ir.set_exclusive(false); | 2173 headers_ir.set_exclusive(false); |
2050 headers_ir.set_parent_stream_id(0x7fffffff); | 2174 headers_ir.set_parent_stream_id(0x7fffffff); |
2051 headers_ir.SetHeader("bar", "foo"); | 2175 headers_ir.SetHeader("bar", "foo"); |
2052 headers_ir.SetHeader("foo", ""); | 2176 headers_ir.SetHeader("foo", ""); |
2053 SpdySerializedFrame frame( | 2177 SpdySerializedFrame frame(SpdyFramerPeer::SerializeHeaders( |
2054 SpdyFramerPeer::SerializeHeaders(&framer, headers_ir)); | 2178 &framer, headers_ir, use_output_ ? &output_ : nullptr)); |
2055 CompareFrame(kDescription, frame, kV4FrameData, arraysize(kV4FrameData)); | 2179 CompareFrame(kDescription, frame, kV4FrameData, arraysize(kV4FrameData)); |
2056 } | 2180 } |
2057 | 2181 |
2058 { | 2182 { |
2059 const char kDescription[] = | 2183 const char kDescription[] = |
2060 "HEADERS frame with a 0-length header name, FIN, max stream ID, padded"; | 2184 "HEADERS frame with a 0-length header name, FIN, max stream ID, padded"; |
2061 | 2185 |
2062 // frame-format off | 2186 // frame-format off |
2063 const unsigned char kH2FrameData[] = { | 2187 const unsigned char kH2FrameData[] = { |
2064 0x00, 0x00, 0x15, // Length: 21 | 2188 0x00, 0x00, 0x15, // Length: 21 |
(...skipping 15 matching lines...) Expand all Loading... | |
2080 | 2204 |
2081 0x00, 0x00, 0x00, 0x00, // Padding | 2205 0x00, 0x00, 0x00, 0x00, // Padding |
2082 0x00, // Padding | 2206 0x00, // Padding |
2083 }; | 2207 }; |
2084 // frame-format on | 2208 // frame-format on |
2085 SpdyHeadersIR headers_ir(0x7fffffff); | 2209 SpdyHeadersIR headers_ir(0x7fffffff); |
2086 headers_ir.set_fin(true); | 2210 headers_ir.set_fin(true); |
2087 headers_ir.SetHeader("", "foo"); | 2211 headers_ir.SetHeader("", "foo"); |
2088 headers_ir.SetHeader("foo", "bar"); | 2212 headers_ir.SetHeader("foo", "bar"); |
2089 headers_ir.set_padding_len(6); | 2213 headers_ir.set_padding_len(6); |
2090 SpdySerializedFrame frame( | 2214 SpdySerializedFrame frame(SpdyFramerPeer::SerializeHeaders( |
2091 SpdyFramerPeer::SerializeHeaders(&framer, headers_ir)); | 2215 &framer, headers_ir, use_output_ ? &output_ : nullptr)); |
2092 CompareFrame(kDescription, frame, kH2FrameData, arraysize(kH2FrameData)); | 2216 CompareFrame(kDescription, frame, kH2FrameData, arraysize(kH2FrameData)); |
2093 } | 2217 } |
2094 } | 2218 } |
2095 | 2219 |
2096 // TODO(phajdan.jr): Clean up after we no longer need | 2220 // TODO(phajdan.jr): Clean up after we no longer need |
2097 // to workaround http://crbug.com/139744. | 2221 // to workaround http://crbug.com/139744. |
2098 #if !defined(USE_SYSTEM_ZLIB) | 2222 #if !defined(USE_SYSTEM_ZLIB) |
2099 TEST_P(SpdyFramerTest, CreateHeadersCompressed) { | 2223 TEST_P(SpdyFramerTest, CreateHeadersCompressed) { |
2100 SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION); | 2224 SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION); |
2101 | 2225 |
2102 { | 2226 { |
2103 SpdyHeadersIR headers_ir(1); | 2227 SpdyHeadersIR headers_ir(1); |
2104 headers_ir.SetHeader("bar", "foo"); | 2228 headers_ir.SetHeader("bar", "foo"); |
2105 headers_ir.SetHeader("foo", "bar"); | 2229 headers_ir.SetHeader("foo", "bar"); |
2106 SpdySerializedFrame frame( | 2230 SpdySerializedFrame frame(SpdyFramerPeer::SerializeHeaders( |
2107 SpdyFramerPeer::SerializeHeaders(&framer, headers_ir)); | 2231 &framer, headers_ir, use_output_ ? &output_ : nullptr)); |
2108 // Deflate compression doesn't apply to HPACK. | 2232 // Deflate compression doesn't apply to HPACK. |
2109 } | 2233 } |
2110 } | 2234 } |
2111 #endif // !defined(USE_SYSTEM_ZLIB) | 2235 #endif // !defined(USE_SYSTEM_ZLIB) |
2112 | 2236 |
2113 TEST_P(SpdyFramerTest, CreateWindowUpdate) { | 2237 TEST_P(SpdyFramerTest, CreateWindowUpdate) { |
2114 SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION); | 2238 SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION); |
2115 | 2239 |
2116 { | 2240 { |
2117 const char kDescription[] = "WINDOW_UPDATE frame"; | 2241 const char kDescription[] = "WINDOW_UPDATE frame"; |
2118 const unsigned char kH2FrameData[] = { | 2242 const unsigned char kH2FrameData[] = { |
2119 0x00, 0x00, 0x04, // Length: 4 | 2243 0x00, 0x00, 0x04, // Length: 4 |
2120 0x08, // Type: WINDOW_UPDATE | 2244 0x08, // Type: WINDOW_UPDATE |
2121 0x00, // Flags: none | 2245 0x00, // Flags: none |
2122 0x00, 0x00, 0x00, 0x01, // Stream: 1 | 2246 0x00, 0x00, 0x00, 0x01, // Stream: 1 |
2123 0x00, 0x00, 0x00, 0x01, // Increment: 1 | 2247 0x00, 0x00, 0x00, 0x01, // Increment: 1 |
2124 }; | 2248 }; |
2125 SpdySerializedFrame frame( | 2249 SpdySerializedFrame frame( |
2126 framer.SerializeWindowUpdate(SpdyWindowUpdateIR(1, 1))); | 2250 framer.SerializeWindowUpdate(SpdyWindowUpdateIR(1, 1))); |
2251 if (use_output_) { | |
2252 output_.Reset(); | |
2253 EXPECT_TRUE( | |
2254 framer.SerializeWindowUpdate(SpdyWindowUpdateIR(1, 1), &output_)); | |
2255 frame = SpdySerializedFrame(output_.Begin(), output_.Size(), false); | |
2256 } | |
2127 CompareFrame(kDescription, frame, kH2FrameData, arraysize(kH2FrameData)); | 2257 CompareFrame(kDescription, frame, kH2FrameData, arraysize(kH2FrameData)); |
2128 } | 2258 } |
2129 | 2259 |
2130 { | 2260 { |
2131 const char kDescription[] = "WINDOW_UPDATE frame with max stream ID"; | 2261 const char kDescription[] = "WINDOW_UPDATE frame with max stream ID"; |
2132 const unsigned char kH2FrameData[] = { | 2262 const unsigned char kH2FrameData[] = { |
2133 0x00, 0x00, 0x04, // Length: 4 | 2263 0x00, 0x00, 0x04, // Length: 4 |
2134 0x08, // Type: WINDOW_UPDATE | 2264 0x08, // Type: WINDOW_UPDATE |
2135 0x00, // Flags: none | 2265 0x00, // Flags: none |
2136 0x7f, 0xff, 0xff, 0xff, // Stream: 0x7fffffff | 2266 0x7f, 0xff, 0xff, 0xff, // Stream: 0x7fffffff |
2137 0x00, 0x00, 0x00, 0x01, // Increment: 1 | 2267 0x00, 0x00, 0x00, 0x01, // Increment: 1 |
2138 }; | 2268 }; |
2139 SpdySerializedFrame frame( | 2269 SpdySerializedFrame frame( |
2140 framer.SerializeWindowUpdate(SpdyWindowUpdateIR(0x7FFFFFFF, 1))); | 2270 framer.SerializeWindowUpdate(SpdyWindowUpdateIR(0x7FFFFFFF, 1))); |
2271 if (use_output_) { | |
2272 output_.Reset(); | |
2273 EXPECT_TRUE(framer.SerializeWindowUpdate( | |
2274 SpdyWindowUpdateIR(0x7FFFFFFF, 1), &output_)); | |
2275 frame = SpdySerializedFrame(output_.Begin(), output_.Size(), false); | |
2276 } | |
2141 CompareFrame(kDescription, frame, kH2FrameData, arraysize(kH2FrameData)); | 2277 CompareFrame(kDescription, frame, kH2FrameData, arraysize(kH2FrameData)); |
2142 } | 2278 } |
2143 | 2279 |
2144 { | 2280 { |
2145 const char kDescription[] = "WINDOW_UPDATE frame with max window delta"; | 2281 const char kDescription[] = "WINDOW_UPDATE frame with max window delta"; |
2146 const unsigned char kH2FrameData[] = { | 2282 const unsigned char kH2FrameData[] = { |
2147 0x00, 0x00, 0x04, // Length: 4 | 2283 0x00, 0x00, 0x04, // Length: 4 |
2148 0x08, // Type: WINDOW_UPDATE | 2284 0x08, // Type: WINDOW_UPDATE |
2149 0x00, // Flags: none | 2285 0x00, // Flags: none |
2150 0x00, 0x00, 0x00, 0x01, // Stream: 1 | 2286 0x00, 0x00, 0x00, 0x01, // Stream: 1 |
2151 0x7f, 0xff, 0xff, 0xff, // Increment: 0x7fffffff | 2287 0x7f, 0xff, 0xff, 0xff, // Increment: 0x7fffffff |
2152 }; | 2288 }; |
2153 SpdySerializedFrame frame( | 2289 SpdySerializedFrame frame( |
2154 framer.SerializeWindowUpdate(SpdyWindowUpdateIR(1, 0x7FFFFFFF))); | 2290 framer.SerializeWindowUpdate(SpdyWindowUpdateIR(1, 0x7FFFFFFF))); |
2291 if (use_output_) { | |
2292 output_.Reset(); | |
2293 EXPECT_TRUE(framer.SerializeWindowUpdate( | |
2294 SpdyWindowUpdateIR(1, 0x7FFFFFFF), &output_)); | |
2295 frame = SpdySerializedFrame(output_.Begin(), output_.Size(), false); | |
2296 } | |
2155 CompareFrame(kDescription, frame, kH2FrameData, arraysize(kH2FrameData)); | 2297 CompareFrame(kDescription, frame, kH2FrameData, arraysize(kH2FrameData)); |
2156 } | 2298 } |
2157 } | 2299 } |
2158 | 2300 |
2159 TEST_P(SpdyFramerTest, SerializeBlocked) { | 2301 TEST_P(SpdyFramerTest, SerializeBlocked) { |
2160 SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION); | 2302 SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION); |
2161 | 2303 |
2162 const char kDescription[] = "BLOCKED frame"; | 2304 const char kDescription[] = "BLOCKED frame"; |
2163 const unsigned char kType = static_cast<unsigned char>(BLOCKED); | 2305 const unsigned char kType = static_cast<unsigned char>(BLOCKED); |
2164 const unsigned char kFrameData[] = { | 2306 const unsigned char kFrameData[] = { |
2165 0x00, 0x00, 0x00, // Length: 0 | 2307 0x00, 0x00, 0x00, // Length: 0 |
2166 kType, // Type: BLOCKED | 2308 kType, // Type: BLOCKED |
2167 0x00, // Flags: none | 2309 0x00, // Flags: none |
2168 0x00, 0x00, 0x00, 0x00, // Stream: 0 | 2310 0x00, 0x00, 0x00, 0x00, // Stream: 0 |
2169 }; | 2311 }; |
2170 SpdyBlockedIR blocked_ir(0); | 2312 SpdyBlockedIR blocked_ir(0); |
2171 SpdySerializedFrame frame(framer.SerializeFrame(blocked_ir)); | 2313 SpdySerializedFrame frame(framer.SerializeFrame(blocked_ir)); |
2314 if (use_output_) { | |
2315 EXPECT_TRUE(framer.SerializeFrame(blocked_ir, &output_)); | |
2316 frame = SpdySerializedFrame(output_.Begin(), output_.Size(), false); | |
2317 } | |
2172 CompareFrame(kDescription, frame, kFrameData, arraysize(kFrameData)); | 2318 CompareFrame(kDescription, frame, kFrameData, arraysize(kFrameData)); |
2173 } | 2319 } |
2174 | 2320 |
2175 TEST_P(SpdyFramerTest, CreateBlocked) { | 2321 TEST_P(SpdyFramerTest, CreateBlocked) { |
2176 SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION); | 2322 SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION); |
2177 | 2323 |
2178 const char kDescription[] = "BLOCKED frame"; | 2324 const char kDescription[] = "BLOCKED frame"; |
2179 const SpdyStreamId kStreamId = 3; | 2325 const SpdyStreamId kStreamId = 3; |
2180 | 2326 |
2181 SpdySerializedFrame frame_serialized( | 2327 SpdySerializedFrame frame_serialized( |
2182 framer.SerializeBlocked(SpdyBlockedIR(kStreamId))); | 2328 framer.SerializeBlocked(SpdyBlockedIR(kStreamId))); |
2329 if (use_output_) { | |
2330 EXPECT_TRUE(framer.SerializeBlocked(SpdyBlockedIR(kStreamId), &output_)); | |
2331 frame_serialized = | |
2332 SpdySerializedFrame(output_.Begin(), output_.Size(), false); | |
2333 } | |
2183 SpdyBlockedIR blocked_ir(kStreamId); | 2334 SpdyBlockedIR blocked_ir(kStreamId); |
2184 SpdySerializedFrame frame_created(framer.SerializeFrame(blocked_ir)); | 2335 SpdySerializedFrame frame_created(framer.SerializeFrame(blocked_ir)); |
2185 | 2336 |
2186 CompareFrames(kDescription, frame_serialized, frame_created); | 2337 CompareFrames(kDescription, frame_serialized, frame_created); |
2187 } | 2338 } |
2188 | 2339 |
2189 TEST_P(SpdyFramerTest, CreatePushPromiseUncompressed) { | 2340 TEST_P(SpdyFramerTest, CreatePushPromiseUncompressed) { |
2190 { | 2341 { |
2191 // Test framing PUSH_PROMISE without padding. | 2342 // Test framing PUSH_PROMISE without padding. |
2192 SpdyFramer framer(SpdyFramer::DISABLE_COMPRESSION); | 2343 SpdyFramer framer(SpdyFramer::DISABLE_COMPRESSION); |
(...skipping 18 matching lines...) Expand all Loading... | |
2211 0x66, 0x6f, 0x6f, // foo | 2362 0x66, 0x6f, 0x6f, // foo |
2212 0x03, // Value Len: 3 | 2363 0x03, // Value Len: 3 |
2213 0x62, 0x61, 0x72, // bar | 2364 0x62, 0x61, 0x72, // bar |
2214 }; | 2365 }; |
2215 // frame-format on | 2366 // frame-format on |
2216 | 2367 |
2217 SpdyPushPromiseIR push_promise(41, 58); | 2368 SpdyPushPromiseIR push_promise(41, 58); |
2218 push_promise.SetHeader("bar", "foo"); | 2369 push_promise.SetHeader("bar", "foo"); |
2219 push_promise.SetHeader("foo", "bar"); | 2370 push_promise.SetHeader("foo", "bar"); |
2220 SpdySerializedFrame frame(framer.SerializePushPromise(push_promise)); | 2371 SpdySerializedFrame frame(framer.SerializePushPromise(push_promise)); |
2372 if (use_output_) { | |
2373 EXPECT_TRUE(framer.SerializePushPromise(push_promise, &output_)); | |
2374 frame = SpdySerializedFrame(output_.Begin(), output_.Size(), false); | |
2375 } | |
2221 CompareFrame(kDescription, frame, kFrameData, arraysize(kFrameData)); | 2376 CompareFrame(kDescription, frame, kFrameData, arraysize(kFrameData)); |
2222 } | 2377 } |
2223 | 2378 |
2224 { | 2379 { |
2225 // Test framing PUSH_PROMISE with one byte of padding. | 2380 // Test framing PUSH_PROMISE with one byte of padding. |
2226 SpdyFramer framer(SpdyFramer::DISABLE_COMPRESSION); | 2381 SpdyFramer framer(SpdyFramer::DISABLE_COMPRESSION); |
2227 const char kDescription[] = "PUSH_PROMISE frame with one byte of padding"; | 2382 const char kDescription[] = "PUSH_PROMISE frame with one byte of padding"; |
2228 | 2383 |
2229 // frame-format off | 2384 // frame-format off |
2230 const unsigned char kFrameData[] = { | 2385 const unsigned char kFrameData[] = { |
(...skipping 16 matching lines...) Expand all Loading... | |
2247 0x03, // Value Len: 3 | 2402 0x03, // Value Len: 3 |
2248 0x62, 0x61, 0x72, // bar | 2403 0x62, 0x61, 0x72, // bar |
2249 }; | 2404 }; |
2250 // frame-format on | 2405 // frame-format on |
2251 | 2406 |
2252 SpdyPushPromiseIR push_promise(41, 58); | 2407 SpdyPushPromiseIR push_promise(41, 58); |
2253 push_promise.set_padding_len(1); | 2408 push_promise.set_padding_len(1); |
2254 push_promise.SetHeader("bar", "foo"); | 2409 push_promise.SetHeader("bar", "foo"); |
2255 push_promise.SetHeader("foo", "bar"); | 2410 push_promise.SetHeader("foo", "bar"); |
2256 SpdySerializedFrame frame(framer.SerializePushPromise(push_promise)); | 2411 SpdySerializedFrame frame(framer.SerializePushPromise(push_promise)); |
2412 if (use_output_) { | |
2413 output_.Reset(); | |
2414 EXPECT_TRUE(framer.SerializePushPromise(push_promise, &output_)); | |
2415 frame = SpdySerializedFrame(output_.Begin(), output_.Size(), false); | |
2416 } | |
2257 CompareFrame(kDescription, frame, kFrameData, arraysize(kFrameData)); | 2417 CompareFrame(kDescription, frame, kFrameData, arraysize(kFrameData)); |
2258 } | 2418 } |
2259 | 2419 |
2260 { | 2420 { |
2261 // Test framing PUSH_PROMISE with 177 bytes of padding. | 2421 // Test framing PUSH_PROMISE with 177 bytes of padding. |
2262 SpdyFramer framer(SpdyFramer::DISABLE_COMPRESSION); | 2422 SpdyFramer framer(SpdyFramer::DISABLE_COMPRESSION); |
2263 const char kDescription[] = "PUSH_PROMISE frame with 177 bytes of padding"; | 2423 const char kDescription[] = "PUSH_PROMISE frame with 177 bytes of padding"; |
2264 | 2424 |
2265 // frame-format off | 2425 // frame-format off |
2266 // clang-format off | 2426 // clang-format off |
(...skipping 36 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
2303 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, | 2463 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
2304 }; | 2464 }; |
2305 // clang-format on | 2465 // clang-format on |
2306 // frame-format on | 2466 // frame-format on |
2307 | 2467 |
2308 SpdyPushPromiseIR push_promise(42, 57); | 2468 SpdyPushPromiseIR push_promise(42, 57); |
2309 push_promise.set_padding_len(177); | 2469 push_promise.set_padding_len(177); |
2310 push_promise.SetHeader("bar", "foo"); | 2470 push_promise.SetHeader("bar", "foo"); |
2311 push_promise.SetHeader("foo", "bar"); | 2471 push_promise.SetHeader("foo", "bar"); |
2312 SpdySerializedFrame frame(framer.SerializePushPromise(push_promise)); | 2472 SpdySerializedFrame frame(framer.SerializePushPromise(push_promise)); |
2473 if (use_output_) { | |
2474 output_.Reset(); | |
2475 EXPECT_TRUE(framer.SerializePushPromise(push_promise, &output_)); | |
2476 frame = SpdySerializedFrame(output_.Begin(), output_.Size(), false); | |
2477 } | |
2313 CompareFrame(kDescription, frame, kFrameData, arraysize(kFrameData)); | 2478 CompareFrame(kDescription, frame, kFrameData, arraysize(kFrameData)); |
2314 } | 2479 } |
2315 } | 2480 } |
2316 | 2481 |
2317 // Regression test for https://crbug.com/464748. | 2482 // Regression test for https://crbug.com/464748. |
2318 TEST_P(SpdyFramerTest, GetNumberRequiredContinuationFrames) { | 2483 TEST_P(SpdyFramerTest, GetNumberRequiredContinuationFrames) { |
2319 SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION); | 2484 SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION); |
2320 EXPECT_EQ(1u, SpdyFramerPeer::GetNumberRequiredContinuationFrames( | 2485 EXPECT_EQ(1u, SpdyFramerPeer::GetNumberRequiredContinuationFrames( |
2321 &framer, 16383 + 16374)); | 2486 &framer, 16383 + 16374)); |
2322 EXPECT_EQ(2u, SpdyFramerPeer::GetNumberRequiredContinuationFrames( | 2487 EXPECT_EQ(2u, SpdyFramerPeer::GetNumberRequiredContinuationFrames( |
(...skipping 35 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
2358 auto buffer = base::MakeUnique<string>(); | 2523 auto buffer = base::MakeUnique<string>(); |
2359 HpackEncoder encoder(ObtainHpackHuffmanTable()); | 2524 HpackEncoder encoder(ObtainHpackHuffmanTable()); |
2360 encoder.DisableCompression(); | 2525 encoder.DisableCompression(); |
2361 encoder.EncodeHeaderSet(header_block, buffer.get()); | 2526 encoder.EncodeHeaderSet(header_block, buffer.get()); |
2362 | 2527 |
2363 SpdyContinuationIR continuation(42); | 2528 SpdyContinuationIR continuation(42); |
2364 continuation.take_encoding(std::move(buffer)); | 2529 continuation.take_encoding(std::move(buffer)); |
2365 continuation.set_end_headers(true); | 2530 continuation.set_end_headers(true); |
2366 | 2531 |
2367 SpdySerializedFrame frame(framer.SerializeContinuation(continuation)); | 2532 SpdySerializedFrame frame(framer.SerializeContinuation(continuation)); |
2533 if (use_output_) { | |
2534 EXPECT_TRUE(framer.SerializeContinuation(continuation, &output_)); | |
2535 frame = SpdySerializedFrame(output_.Begin(), output_.Size(), false); | |
2536 } | |
2368 CompareFrame(kDescription, frame, kFrameData, arraysize(kFrameData)); | 2537 CompareFrame(kDescription, frame, kFrameData, arraysize(kFrameData)); |
2369 } | 2538 } |
2370 | 2539 |
2371 // Test that if we send an unexpected CONTINUATION | 2540 // Test that if we send an unexpected CONTINUATION |
2372 // we signal an error (but don't crash). | 2541 // we signal an error (but don't crash). |
2373 TEST_P(SpdyFramerTest, SendUnexpectedContinuation) { | 2542 TEST_P(SpdyFramerTest, SendUnexpectedContinuation) { |
2374 testing::StrictMock<test::MockSpdyFramerVisitor> visitor; | 2543 testing::StrictMock<test::MockSpdyFramerVisitor> visitor; |
2375 SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION); | 2544 SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION); |
2376 framer.set_visitor(&visitor); | 2545 framer.set_visitor(&visitor); |
2377 | 2546 |
(...skipping 84 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
2462 0x78, 0x78, 0x78, 0x78, // xxxx | 2631 0x78, 0x78, 0x78, 0x78, // xxxx |
2463 0x78, // x | 2632 0x78, // x |
2464 }; | 2633 }; |
2465 // frame-format on | 2634 // frame-format on |
2466 | 2635 |
2467 SpdyPushPromiseIR push_promise(42, 57); | 2636 SpdyPushPromiseIR push_promise(42, 57); |
2468 push_promise.set_padding_len(1); | 2637 push_promise.set_padding_len(1); |
2469 string big_value(TestSpdyVisitor::sent_control_frame_max_size(), 'x'); | 2638 string big_value(TestSpdyVisitor::sent_control_frame_max_size(), 'x'); |
2470 push_promise.SetHeader("xxx", big_value); | 2639 push_promise.SetHeader("xxx", big_value); |
2471 SpdySerializedFrame frame(framer.SerializePushPromise(push_promise)); | 2640 SpdySerializedFrame frame(framer.SerializePushPromise(push_promise)); |
2641 if (use_output_) { | |
2642 EXPECT_TRUE(framer.SerializePushPromise(push_promise, &output_)); | |
2643 frame = SpdySerializedFrame(output_.Begin(), output_.Size(), false); | |
2644 } | |
2472 | 2645 |
2473 // The entire frame should look like below: | 2646 // The entire frame should look like below: |
2474 // Name Length in Byte | 2647 // Name Length in Byte |
2475 // ------------------------------------------- Begin of PUSH_PROMISE frame | 2648 // ------------------------------------------- Begin of PUSH_PROMISE frame |
2476 // PUSH_PROMISE header 9 | 2649 // PUSH_PROMISE header 9 |
2477 // Pad length field 1 | 2650 // Pad length field 1 |
2478 // Promised stream 4 | 2651 // Promised stream 4 |
2479 // Length field of key 2 | 2652 // Length field of key 2 |
2480 // Content of key 3 | 2653 // Content of key 3 |
2481 // Length field of value 3 | 2654 // Length field of value 3 |
(...skipping 38 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
2520 's', 't', ':', '1', '2', '3', '"', ';', ' ', 'm', 'a', '=', | 2693 's', 't', ':', '1', '2', '3', '"', ';', ' ', 'm', 'a', '=', |
2521 '4', '2', ';', ' ', 'v', '=', '"', '2', '4', '"'}; | 2694 '4', '2', ';', ' ', 'v', '=', '"', '2', '4', '"'}; |
2522 SpdyAltSvcIR altsvc_ir(3); | 2695 SpdyAltSvcIR altsvc_ir(3); |
2523 altsvc_ir.set_origin("origin"); | 2696 altsvc_ir.set_origin("origin"); |
2524 altsvc_ir.add_altsvc(SpdyAltSvcWireFormat::AlternativeService( | 2697 altsvc_ir.add_altsvc(SpdyAltSvcWireFormat::AlternativeService( |
2525 "pid1", "host", 443, 5, SpdyAltSvcWireFormat::VersionVector())); | 2698 "pid1", "host", 443, 5, SpdyAltSvcWireFormat::VersionVector())); |
2526 altsvc_ir.add_altsvc(SpdyAltSvcWireFormat::AlternativeService( | 2699 altsvc_ir.add_altsvc(SpdyAltSvcWireFormat::AlternativeService( |
2527 "p\"=i:d", "h_\\o\"st", 123, 42, | 2700 "p\"=i:d", "h_\\o\"st", 123, 42, |
2528 SpdyAltSvcWireFormat::VersionVector{24})); | 2701 SpdyAltSvcWireFormat::VersionVector{24})); |
2529 SpdySerializedFrame frame(framer.SerializeFrame(altsvc_ir)); | 2702 SpdySerializedFrame frame(framer.SerializeFrame(altsvc_ir)); |
2703 if (use_output_) { | |
2704 EXPECT_TRUE(framer.SerializeFrame(altsvc_ir, &output_)); | |
2705 frame = SpdySerializedFrame(output_.Begin(), output_.Size(), false); | |
2706 } | |
2530 CompareFrame(kDescription, frame, kFrameData, arraysize(kFrameData)); | 2707 CompareFrame(kDescription, frame, kFrameData, arraysize(kFrameData)); |
2531 } | 2708 } |
2532 | 2709 |
2533 TEST_P(SpdyFramerTest, CreatePriority) { | 2710 TEST_P(SpdyFramerTest, CreatePriority) { |
2534 SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION); | 2711 SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION); |
2535 | 2712 |
2536 const char kDescription[] = "PRIORITY frame"; | 2713 const char kDescription[] = "PRIORITY frame"; |
2537 const unsigned char kFrameData[] = { | 2714 const unsigned char kFrameData[] = { |
2538 0x00, 0x00, 0x05, // Length: 5 | 2715 0x00, 0x00, 0x05, // Length: 5 |
2539 0x02, // Type: PRIORITY | 2716 0x02, // Type: PRIORITY |
2540 0x00, // Flags: none | 2717 0x00, // Flags: none |
2541 0x00, 0x00, 0x00, 0x02, // Stream: 2 | 2718 0x00, 0x00, 0x00, 0x02, // Stream: 2 |
2542 0x80, 0x00, 0x00, 0x01, // Parent: 1 (Exclusive) | 2719 0x80, 0x00, 0x00, 0x01, // Parent: 1 (Exclusive) |
2543 0x10, // Weight: 17 | 2720 0x10, // Weight: 17 |
2544 }; | 2721 }; |
2545 SpdyPriorityIR priority_ir(2, 1, 17, true); | 2722 SpdyPriorityIR priority_ir(2, 1, 17, true); |
2546 SpdySerializedFrame frame(framer.SerializeFrame(priority_ir)); | 2723 SpdySerializedFrame frame(framer.SerializeFrame(priority_ir)); |
2724 if (use_output_) { | |
2725 EXPECT_TRUE(framer.SerializeFrame(priority_ir, &output_)); | |
2726 frame = SpdySerializedFrame(output_.Begin(), output_.Size(), false); | |
2727 } | |
2547 CompareFrame(kDescription, frame, kFrameData, arraysize(kFrameData)); | 2728 CompareFrame(kDescription, frame, kFrameData, arraysize(kFrameData)); |
2548 SpdyPriorityIR priority2(2); | 2729 SpdyPriorityIR priority2(2); |
2549 priority2.set_parent_stream_id(1); | 2730 priority2.set_parent_stream_id(1); |
2550 priority2.set_weight(17); | 2731 priority2.set_weight(17); |
2551 priority2.set_exclusive(true); | 2732 priority2.set_exclusive(true); |
2552 frame = framer.SerializeFrame(priority2); | 2733 if (use_output_) { |
2734 output_.Reset(); | |
2735 EXPECT_TRUE(framer.SerializeFrame(priority2, &output_)); | |
2736 frame = SpdySerializedFrame(output_.Begin(), output_.Size(), false); | |
2737 } else { | |
2738 frame = framer.SerializeFrame(priority2); | |
2739 } | |
2553 CompareFrame(kDescription, frame, kFrameData, arraysize(kFrameData)); | 2740 CompareFrame(kDescription, frame, kFrameData, arraysize(kFrameData)); |
2554 } | 2741 } |
2555 | 2742 |
2556 TEST_P(SpdyFramerTest, ReadCompressedHeadersHeaderBlock) { | 2743 TEST_P(SpdyFramerTest, ReadCompressedHeadersHeaderBlock) { |
2557 SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION); | 2744 SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION); |
2558 SpdyHeadersIR headers_ir(1); | 2745 SpdyHeadersIR headers_ir(1); |
2559 headers_ir.SetHeader("alpha", "beta"); | 2746 headers_ir.SetHeader("alpha", "beta"); |
2560 headers_ir.SetHeader("gamma", "delta"); | 2747 headers_ir.SetHeader("gamma", "delta"); |
2561 SpdySerializedFrame control_frame( | 2748 SpdySerializedFrame control_frame(SpdyFramerPeer::SerializeHeaders( |
2562 SpdyFramerPeer::SerializeHeaders(&framer, headers_ir)); | 2749 &framer, headers_ir, use_output_ ? &output_ : nullptr)); |
2563 TestSpdyVisitor visitor(SpdyFramer::ENABLE_COMPRESSION); | 2750 TestSpdyVisitor visitor(SpdyFramer::ENABLE_COMPRESSION); |
2564 visitor.SimulateInFramer( | 2751 visitor.SimulateInFramer( |
2565 reinterpret_cast<unsigned char*>(control_frame.data()), | 2752 reinterpret_cast<unsigned char*>(control_frame.data()), |
2566 control_frame.size()); | 2753 control_frame.size()); |
2567 EXPECT_EQ(1, visitor.headers_frame_count_); | 2754 EXPECT_EQ(1, visitor.headers_frame_count_); |
2568 EXPECT_EQ(0, visitor.control_frame_header_data_count_); | 2755 EXPECT_EQ(0, visitor.control_frame_header_data_count_); |
2569 EXPECT_EQ(0, visitor.zero_length_control_frame_header_data_count_); | 2756 EXPECT_EQ(0, visitor.zero_length_control_frame_header_data_count_); |
2570 EXPECT_EQ(0, visitor.end_of_stream_count_); | 2757 EXPECT_EQ(0, visitor.end_of_stream_count_); |
2571 EXPECT_EQ(headers_ir.header_block(), visitor.headers_); | 2758 EXPECT_EQ(headers_ir.header_block(), visitor.headers_); |
2572 } | 2759 } |
2573 | 2760 |
2574 TEST_P(SpdyFramerTest, ReadCompressedHeadersHeaderBlockWithHalfClose) { | 2761 TEST_P(SpdyFramerTest, ReadCompressedHeadersHeaderBlockWithHalfClose) { |
2575 SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION); | 2762 SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION); |
2576 SpdyHeadersIR headers_ir(1); | 2763 SpdyHeadersIR headers_ir(1); |
2577 headers_ir.set_fin(true); | 2764 headers_ir.set_fin(true); |
2578 headers_ir.SetHeader("alpha", "beta"); | 2765 headers_ir.SetHeader("alpha", "beta"); |
2579 headers_ir.SetHeader("gamma", "delta"); | 2766 headers_ir.SetHeader("gamma", "delta"); |
2580 SpdySerializedFrame control_frame( | 2767 SpdySerializedFrame control_frame(SpdyFramerPeer::SerializeHeaders( |
2581 SpdyFramerPeer::SerializeHeaders(&framer, headers_ir)); | 2768 &framer, headers_ir, use_output_ ? &output_ : nullptr)); |
2582 TestSpdyVisitor visitor(SpdyFramer::ENABLE_COMPRESSION); | 2769 TestSpdyVisitor visitor(SpdyFramer::ENABLE_COMPRESSION); |
2583 visitor.SimulateInFramer( | 2770 visitor.SimulateInFramer( |
2584 reinterpret_cast<unsigned char*>(control_frame.data()), | 2771 reinterpret_cast<unsigned char*>(control_frame.data()), |
2585 control_frame.size()); | 2772 control_frame.size()); |
2586 EXPECT_EQ(1, visitor.headers_frame_count_); | 2773 EXPECT_EQ(1, visitor.headers_frame_count_); |
2587 EXPECT_EQ(0, visitor.control_frame_header_data_count_); | 2774 EXPECT_EQ(0, visitor.control_frame_header_data_count_); |
2588 EXPECT_EQ(0, visitor.zero_length_control_frame_header_data_count_); | 2775 EXPECT_EQ(0, visitor.zero_length_control_frame_header_data_count_); |
2589 EXPECT_EQ(1, visitor.end_of_stream_count_); | 2776 EXPECT_EQ(1, visitor.end_of_stream_count_); |
2590 EXPECT_EQ(headers_ir.header_block(), visitor.headers_); | 2777 EXPECT_EQ(headers_ir.header_block(), visitor.headers_); |
2591 } | 2778 } |
2592 | 2779 |
2593 TEST_P(SpdyFramerTest, TooLargeHeadersFrameUsesContinuation) { | 2780 TEST_P(SpdyFramerTest, TooLargeHeadersFrameUsesContinuation) { |
2594 SpdyFramer framer(SpdyFramer::DISABLE_COMPRESSION); | 2781 SpdyFramer framer(SpdyFramer::DISABLE_COMPRESSION); |
2595 SpdyHeadersIR headers(1); | 2782 SpdyHeadersIR headers(1); |
2596 headers.set_padding_len(256); | 2783 headers.set_padding_len(256); |
2597 | 2784 |
2598 // Exact payload length will change with HPACK, but this should be long | 2785 // Exact payload length will change with HPACK, but this should be long |
2599 // enough to cause an overflow. | 2786 // enough to cause an overflow. |
2600 const size_t kBigValueSize = TestSpdyVisitor::sent_control_frame_max_size(); | 2787 const size_t kBigValueSize = TestSpdyVisitor::sent_control_frame_max_size(); |
2601 string big_value(kBigValueSize, 'x'); | 2788 string big_value(kBigValueSize, 'x'); |
2602 headers.SetHeader("aa", big_value); | 2789 headers.SetHeader("aa", big_value); |
2603 SpdySerializedFrame control_frame( | 2790 SpdySerializedFrame control_frame(SpdyFramerPeer::SerializeHeaders( |
2604 SpdyFramerPeer::SerializeHeaders(&framer, headers)); | 2791 &framer, headers, use_output_ ? &output_ : nullptr)); |
2605 EXPECT_GT(control_frame.size(), | 2792 EXPECT_GT(control_frame.size(), |
2606 TestSpdyVisitor::sent_control_frame_max_size()); | 2793 TestSpdyVisitor::sent_control_frame_max_size()); |
2607 | 2794 |
2608 TestSpdyVisitor visitor(SpdyFramer::DISABLE_COMPRESSION); | 2795 TestSpdyVisitor visitor(SpdyFramer::DISABLE_COMPRESSION); |
2609 visitor.SimulateInFramer( | 2796 visitor.SimulateInFramer( |
2610 reinterpret_cast<unsigned char*>(control_frame.data()), | 2797 reinterpret_cast<unsigned char*>(control_frame.data()), |
2611 control_frame.size()); | 2798 control_frame.size()); |
2612 EXPECT_TRUE(visitor.header_buffer_valid_); | 2799 EXPECT_TRUE(visitor.header_buffer_valid_); |
2613 EXPECT_EQ(0, visitor.error_count_); | 2800 EXPECT_EQ(0, visitor.error_count_); |
2614 EXPECT_EQ(1, visitor.headers_frame_count_); | 2801 EXPECT_EQ(1, visitor.headers_frame_count_); |
(...skipping 66 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
2681 SpdyFramer framer(SpdyFramer::DISABLE_COMPRESSION); | 2868 SpdyFramer framer(SpdyFramer::DISABLE_COMPRESSION); |
2682 SpdyPushPromiseIR push_promise(1, 2); | 2869 SpdyPushPromiseIR push_promise(1, 2); |
2683 push_promise.set_padding_len(256); | 2870 push_promise.set_padding_len(256); |
2684 | 2871 |
2685 // Exact payload length will change with HPACK, but this should be long | 2872 // Exact payload length will change with HPACK, but this should be long |
2686 // enough to cause an overflow. | 2873 // enough to cause an overflow. |
2687 const size_t kBigValueSize = TestSpdyVisitor::sent_control_frame_max_size(); | 2874 const size_t kBigValueSize = TestSpdyVisitor::sent_control_frame_max_size(); |
2688 string big_value(kBigValueSize, 'x'); | 2875 string big_value(kBigValueSize, 'x'); |
2689 push_promise.SetHeader("aa", big_value); | 2876 push_promise.SetHeader("aa", big_value); |
2690 SpdySerializedFrame control_frame(framer.SerializePushPromise(push_promise)); | 2877 SpdySerializedFrame control_frame(framer.SerializePushPromise(push_promise)); |
2878 if (use_output_) { | |
2879 EXPECT_TRUE(framer.SerializePushPromise(push_promise, &output_)); | |
2880 control_frame = SpdySerializedFrame(output_.Begin(), output_.Size(), false); | |
2881 } | |
2691 EXPECT_GT(control_frame.size(), | 2882 EXPECT_GT(control_frame.size(), |
2692 TestSpdyVisitor::sent_control_frame_max_size()); | 2883 TestSpdyVisitor::sent_control_frame_max_size()); |
2693 | 2884 |
2694 TestSpdyVisitor visitor(SpdyFramer::DISABLE_COMPRESSION); | 2885 TestSpdyVisitor visitor(SpdyFramer::DISABLE_COMPRESSION); |
2695 visitor.SimulateInFramer( | 2886 visitor.SimulateInFramer( |
2696 reinterpret_cast<unsigned char*>(control_frame.data()), | 2887 reinterpret_cast<unsigned char*>(control_frame.data()), |
2697 control_frame.size()); | 2888 control_frame.size()); |
2698 EXPECT_TRUE(visitor.header_buffer_valid_); | 2889 EXPECT_TRUE(visitor.header_buffer_valid_); |
2699 EXPECT_EQ(0, visitor.error_count_); | 2890 EXPECT_EQ(0, visitor.error_count_); |
2700 EXPECT_EQ(1, visitor.push_promise_frame_count_); | 2891 EXPECT_EQ(1, visitor.push_promise_frame_count_); |
2701 EXPECT_EQ(1, visitor.continuation_count_); | 2892 EXPECT_EQ(1, visitor.continuation_count_); |
2702 EXPECT_EQ(0, visitor.zero_length_control_frame_header_data_count_); | 2893 EXPECT_EQ(0, visitor.zero_length_control_frame_header_data_count_); |
2703 } | 2894 } |
2704 | 2895 |
2705 // Check that the framer stops delivering header data chunks once the visitor | 2896 // Check that the framer stops delivering header data chunks once the visitor |
2706 // declares it doesn't want any more. This is important to guard against | 2897 // declares it doesn't want any more. This is important to guard against |
2707 // "zip bomb" types of attacks. | 2898 // "zip bomb" types of attacks. |
2708 TEST_P(SpdyFramerTest, ControlFrameMuchTooLarge) { | 2899 TEST_P(SpdyFramerTest, ControlFrameMuchTooLarge) { |
2709 const size_t kHeaderBufferChunks = 4; | 2900 const size_t kHeaderBufferChunks = 4; |
2710 const size_t kHeaderBufferSize = | 2901 const size_t kHeaderBufferSize = |
2711 TestSpdyVisitor::header_data_chunk_max_size() * kHeaderBufferChunks; | 2902 TestSpdyVisitor::header_data_chunk_max_size() * kHeaderBufferChunks; |
2712 const size_t kBigValueSize = kHeaderBufferSize * 2; | 2903 const size_t kBigValueSize = kHeaderBufferSize * 2; |
2713 string big_value(kBigValueSize, 'x'); | 2904 string big_value(kBigValueSize, 'x'); |
2714 SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION); | 2905 SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION); |
2715 SpdyHeadersIR headers(1); | 2906 SpdyHeadersIR headers(1); |
2716 headers.set_fin(true); | 2907 headers.set_fin(true); |
2717 headers.SetHeader("aa", big_value); | 2908 headers.SetHeader("aa", big_value); |
2718 SpdySerializedFrame control_frame( | 2909 SpdySerializedFrame control_frame(SpdyFramerPeer::SerializeHeaders( |
2719 SpdyFramerPeer::SerializeHeaders(&framer, headers)); | 2910 &framer, headers, use_output_ ? &output_ : nullptr)); |
2720 TestSpdyVisitor visitor(SpdyFramer::ENABLE_COMPRESSION); | 2911 TestSpdyVisitor visitor(SpdyFramer::ENABLE_COMPRESSION); |
2721 visitor.set_header_buffer_size(kHeaderBufferSize); | 2912 visitor.set_header_buffer_size(kHeaderBufferSize); |
2722 visitor.SimulateInFramer( | 2913 visitor.SimulateInFramer( |
2723 reinterpret_cast<unsigned char*>(control_frame.data()), | 2914 reinterpret_cast<unsigned char*>(control_frame.data()), |
2724 control_frame.size()); | 2915 control_frame.size()); |
2725 // It's up to the visitor to ignore extraneous header data; the framer | 2916 // It's up to the visitor to ignore extraneous header data; the framer |
2726 // won't throw an error. | 2917 // won't throw an error. |
2727 EXPECT_GT(visitor.header_bytes_received_, visitor.header_buffer_size_); | 2918 EXPECT_GT(visitor.header_bytes_received_, visitor.header_buffer_size_); |
2728 EXPECT_EQ(1, visitor.end_of_stream_count_); | 2919 EXPECT_EQ(1, visitor.end_of_stream_count_); |
2729 } | 2920 } |
(...skipping 33 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
2763 visitor.framer_.spdy_framer_error()) | 2954 visitor.framer_.spdy_framer_error()) |
2764 << SpdyFramer::SpdyFramerErrorToString( | 2955 << SpdyFramer::SpdyFramerErrorToString( |
2765 visitor.framer_.spdy_framer_error()); | 2956 visitor.framer_.spdy_framer_error()); |
2766 EXPECT_EQ(0, visitor.goaway_count_); // Frame not parsed. | 2957 EXPECT_EQ(0, visitor.goaway_count_); // Frame not parsed. |
2767 } | 2958 } |
2768 | 2959 |
2769 TEST_P(SpdyFramerTest, ReadZeroLenSettingsFrame) { | 2960 TEST_P(SpdyFramerTest, ReadZeroLenSettingsFrame) { |
2770 SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION); | 2961 SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION); |
2771 SpdySettingsIR settings_ir; | 2962 SpdySettingsIR settings_ir; |
2772 SpdySerializedFrame control_frame(framer.SerializeSettings(settings_ir)); | 2963 SpdySerializedFrame control_frame(framer.SerializeSettings(settings_ir)); |
2964 if (use_output_) { | |
2965 EXPECT_TRUE(framer.SerializeSettings(settings_ir, &output_)); | |
2966 control_frame = SpdySerializedFrame(output_.Begin(), output_.Size(), false); | |
2967 } | |
2773 SetFrameLength(&control_frame, 0); | 2968 SetFrameLength(&control_frame, 0); |
2774 TestSpdyVisitor visitor(SpdyFramer::DISABLE_COMPRESSION); | 2969 TestSpdyVisitor visitor(SpdyFramer::DISABLE_COMPRESSION); |
2775 visitor.SimulateInFramer( | 2970 visitor.SimulateInFramer( |
2776 reinterpret_cast<unsigned char*>(control_frame.data()), | 2971 reinterpret_cast<unsigned char*>(control_frame.data()), |
2777 framer.GetFrameHeaderSize()); | 2972 framer.GetFrameHeaderSize()); |
2778 // Zero-len settings frames are permitted as of HTTP/2. | 2973 // Zero-len settings frames are permitted as of HTTP/2. |
2779 EXPECT_EQ(0, visitor.error_count_); | 2974 EXPECT_EQ(0, visitor.error_count_); |
2780 } | 2975 } |
2781 | 2976 |
2782 // Tests handling of SETTINGS frames with invalid length. | 2977 // Tests handling of SETTINGS frames with invalid length. |
2783 TEST_P(SpdyFramerTest, ReadBogusLenSettingsFrame) { | 2978 TEST_P(SpdyFramerTest, ReadBogusLenSettingsFrame) { |
2784 SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION); | 2979 SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION); |
2785 SpdySettingsIR settings_ir; | 2980 SpdySettingsIR settings_ir; |
2786 | 2981 |
2787 // Add settings to more than fill the frame so that we don't get a buffer | 2982 // Add settings to more than fill the frame so that we don't get a buffer |
2788 // overflow when calling SimulateInFramer() below. These settings must be | 2983 // overflow when calling SimulateInFramer() below. These settings must be |
2789 // distinct parameters because SpdySettingsIR has a map for settings, and will | 2984 // distinct parameters because SpdySettingsIR has a map for settings, and will |
2790 // collapse multiple copies of the same parameter. | 2985 // collapse multiple copies of the same parameter. |
2791 settings_ir.AddSetting(SETTINGS_INITIAL_WINDOW_SIZE, 0x00000002); | 2986 settings_ir.AddSetting(SETTINGS_INITIAL_WINDOW_SIZE, 0x00000002); |
2792 settings_ir.AddSetting(SETTINGS_MAX_CONCURRENT_STREAMS, 0x00000002); | 2987 settings_ir.AddSetting(SETTINGS_MAX_CONCURRENT_STREAMS, 0x00000002); |
2793 SpdySerializedFrame control_frame(framer.SerializeSettings(settings_ir)); | 2988 SpdySerializedFrame control_frame(framer.SerializeSettings(settings_ir)); |
2989 if (use_output_) { | |
2990 EXPECT_TRUE(framer.SerializeSettings(settings_ir, &output_)); | |
2991 control_frame = SpdySerializedFrame(output_.Begin(), output_.Size(), false); | |
2992 } | |
2794 const size_t kNewLength = 8; | 2993 const size_t kNewLength = 8; |
2795 SetFrameLength(&control_frame, kNewLength); | 2994 SetFrameLength(&control_frame, kNewLength); |
2796 TestSpdyVisitor visitor(SpdyFramer::DISABLE_COMPRESSION); | 2995 TestSpdyVisitor visitor(SpdyFramer::DISABLE_COMPRESSION); |
2797 visitor.SimulateInFramer( | 2996 visitor.SimulateInFramer( |
2798 reinterpret_cast<unsigned char*>(control_frame.data()), | 2997 reinterpret_cast<unsigned char*>(control_frame.data()), |
2799 framer.GetFrameHeaderSize() + kNewLength); | 2998 framer.GetFrameHeaderSize() + kNewLength); |
2800 // Should generate an error, since its not possible to have a | 2999 // Should generate an error, since its not possible to have a |
2801 // settings frame of length kNewLength. | 3000 // settings frame of length kNewLength. |
2802 EXPECT_EQ(1, visitor.error_count_); | 3001 EXPECT_EQ(1, visitor.error_count_); |
2803 EXPECT_EQ(SpdyFramer::SPDY_INVALID_CONTROL_FRAME_SIZE, | 3002 EXPECT_EQ(SpdyFramer::SPDY_INVALID_CONTROL_FRAME_SIZE, |
2804 visitor.framer_.spdy_framer_error()) | 3003 visitor.framer_.spdy_framer_error()) |
2805 << SpdyFramer::SpdyFramerErrorToString( | 3004 << SpdyFramer::SpdyFramerErrorToString( |
2806 visitor.framer_.spdy_framer_error()); | 3005 visitor.framer_.spdy_framer_error()); |
2807 } | 3006 } |
2808 | 3007 |
2809 // Tests handling of SETTINGS frames larger than the frame buffer size. | 3008 // Tests handling of SETTINGS frames larger than the frame buffer size. |
2810 TEST_P(SpdyFramerTest, ReadLargeSettingsFrame) { | 3009 TEST_P(SpdyFramerTest, ReadLargeSettingsFrame) { |
2811 SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION); | 3010 SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION); |
2812 SpdySettingsIR settings_ir; | 3011 SpdySettingsIR settings_ir; |
2813 settings_ir.AddSetting(SETTINGS_HEADER_TABLE_SIZE, 5); | 3012 settings_ir.AddSetting(SETTINGS_HEADER_TABLE_SIZE, 5); |
2814 settings_ir.AddSetting(SETTINGS_ENABLE_PUSH, 6); | 3013 settings_ir.AddSetting(SETTINGS_ENABLE_PUSH, 6); |
2815 settings_ir.AddSetting(SETTINGS_MAX_CONCURRENT_STREAMS, 7); | 3014 settings_ir.AddSetting(SETTINGS_MAX_CONCURRENT_STREAMS, 7); |
2816 | 3015 |
2817 SpdySerializedFrame control_frame(framer.SerializeSettings(settings_ir)); | 3016 SpdySerializedFrame control_frame(framer.SerializeSettings(settings_ir)); |
3017 if (use_output_) { | |
3018 EXPECT_TRUE(framer.SerializeSettings(settings_ir, &output_)); | |
3019 control_frame = SpdySerializedFrame(output_.Begin(), output_.Size(), false); | |
3020 } | |
3021 | |
2818 EXPECT_LT(SpdyFramerPeer::ControlFrameBufferSize(), control_frame.size()); | 3022 EXPECT_LT(SpdyFramerPeer::ControlFrameBufferSize(), control_frame.size()); |
2819 TestSpdyVisitor visitor(SpdyFramer::DISABLE_COMPRESSION); | 3023 TestSpdyVisitor visitor(SpdyFramer::DISABLE_COMPRESSION); |
2820 | 3024 |
2821 // Read all at once. | 3025 // Read all at once. |
2822 visitor.SimulateInFramer( | 3026 visitor.SimulateInFramer( |
2823 reinterpret_cast<unsigned char*>(control_frame.data()), | 3027 reinterpret_cast<unsigned char*>(control_frame.data()), |
2824 control_frame.size()); | 3028 control_frame.size()); |
2825 EXPECT_EQ(0, visitor.error_count_); | 3029 EXPECT_EQ(0, visitor.error_count_); |
2826 EXPECT_EQ(3, visitor.setting_count_); | 3030 EXPECT_EQ(3, visitor.setting_count_); |
2827 EXPECT_EQ(1, visitor.settings_ack_sent_); | 3031 EXPECT_EQ(1, visitor.settings_ack_sent_); |
(...skipping 191 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
3019 EXPECT_CALL(visitor, OnStreamPadding(1, 18)); | 3223 EXPECT_CALL(visitor, OnStreamPadding(1, 18)); |
3020 CHECK_EQ(18u, framer.ProcessInput(frame.data() + bytes_consumed, 18)); | 3224 CHECK_EQ(18u, framer.ProcessInput(frame.data() + bytes_consumed, 18)); |
3021 CHECK_EQ(framer.state(), SpdyFramer::SPDY_READY_FOR_FRAME); | 3225 CHECK_EQ(framer.state(), SpdyFramer::SPDY_READY_FOR_FRAME); |
3022 CHECK_EQ(framer.spdy_framer_error(), SpdyFramer::SPDY_NO_ERROR); | 3226 CHECK_EQ(framer.spdy_framer_error(), SpdyFramer::SPDY_NO_ERROR); |
3023 } | 3227 } |
3024 | 3228 |
3025 TEST_P(SpdyFramerTest, ReadWindowUpdate) { | 3229 TEST_P(SpdyFramerTest, ReadWindowUpdate) { |
3026 SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION); | 3230 SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION); |
3027 SpdySerializedFrame control_frame( | 3231 SpdySerializedFrame control_frame( |
3028 framer.SerializeWindowUpdate(SpdyWindowUpdateIR(1, 2))); | 3232 framer.SerializeWindowUpdate(SpdyWindowUpdateIR(1, 2))); |
3233 if (use_output_) { | |
3234 EXPECT_TRUE( | |
3235 framer.SerializeWindowUpdate(SpdyWindowUpdateIR(1, 2), &output_)); | |
3236 control_frame = SpdySerializedFrame(output_.Begin(), output_.Size(), false); | |
3237 } | |
3029 TestSpdyVisitor visitor(SpdyFramer::DISABLE_COMPRESSION); | 3238 TestSpdyVisitor visitor(SpdyFramer::DISABLE_COMPRESSION); |
3030 visitor.SimulateInFramer( | 3239 visitor.SimulateInFramer( |
3031 reinterpret_cast<unsigned char*>(control_frame.data()), | 3240 reinterpret_cast<unsigned char*>(control_frame.data()), |
3032 control_frame.size()); | 3241 control_frame.size()); |
3033 EXPECT_EQ(1u, visitor.last_window_update_stream_); | 3242 EXPECT_EQ(1u, visitor.last_window_update_stream_); |
3034 EXPECT_EQ(2, visitor.last_window_update_delta_); | 3243 EXPECT_EQ(2, visitor.last_window_update_delta_); |
3035 } | 3244 } |
3036 | 3245 |
3037 TEST_P(SpdyFramerTest, ReadCompressedPushPromise) { | 3246 TEST_P(SpdyFramerTest, ReadCompressedPushPromise) { |
3038 SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION); | 3247 SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION); |
3039 SpdyPushPromiseIR push_promise(42, 57); | 3248 SpdyPushPromiseIR push_promise(42, 57); |
3040 push_promise.SetHeader("foo", "bar"); | 3249 push_promise.SetHeader("foo", "bar"); |
3041 push_promise.SetHeader("bar", "foofoo"); | 3250 push_promise.SetHeader("bar", "foofoo"); |
3042 SpdySerializedFrame frame(framer.SerializePushPromise(push_promise)); | 3251 SpdySerializedFrame frame(framer.SerializePushPromise(push_promise)); |
3252 if (use_output_) { | |
3253 // Use a new framer to clean up the hpack dynamic table. | |
3254 SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION); | |
3255 EXPECT_TRUE(framer.SerializePushPromise(push_promise, &output_)); | |
3256 frame = SpdySerializedFrame(output_.Begin(), output_.Size(), false); | |
3257 } | |
3043 TestSpdyVisitor visitor(SpdyFramer::ENABLE_COMPRESSION); | 3258 TestSpdyVisitor visitor(SpdyFramer::ENABLE_COMPRESSION); |
3044 visitor.SimulateInFramer(reinterpret_cast<unsigned char*>(frame.data()), | 3259 visitor.SimulateInFramer(reinterpret_cast<unsigned char*>(frame.data()), |
3045 frame.size()); | 3260 frame.size()); |
3046 EXPECT_EQ(42u, visitor.last_push_promise_stream_); | 3261 EXPECT_EQ(42u, visitor.last_push_promise_stream_); |
3047 EXPECT_EQ(57u, visitor.last_push_promise_promised_stream_); | 3262 EXPECT_EQ(57u, visitor.last_push_promise_promised_stream_); |
3048 EXPECT_EQ(push_promise.header_block(), visitor.headers_); | 3263 EXPECT_EQ(push_promise.header_block(), visitor.headers_); |
3049 } | 3264 } |
3050 | 3265 |
3051 TEST_P(SpdyFramerTest, ReadHeadersWithContinuation) { | 3266 TEST_P(SpdyFramerTest, ReadHeadersWithContinuation) { |
3052 // frame-format off | 3267 // frame-format off |
(...skipping 405 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
3458 // Simulate the case where the stream id validation checks out. | 3673 // Simulate the case where the stream id validation checks out. |
3459 visitor.on_unknown_frame_result_ = true; | 3674 visitor.on_unknown_frame_result_ = true; |
3460 visitor.SimulateInFramer(unknown_frame, arraysize(unknown_frame)); | 3675 visitor.SimulateInFramer(unknown_frame, arraysize(unknown_frame)); |
3461 EXPECT_EQ(0, visitor.error_count_); | 3676 EXPECT_EQ(0, visitor.error_count_); |
3462 | 3677 |
3463 // Follow it up with a valid control frame to make sure we handle | 3678 // Follow it up with a valid control frame to make sure we handle |
3464 // subsequent frames correctly. | 3679 // subsequent frames correctly. |
3465 SpdySettingsIR settings_ir; | 3680 SpdySettingsIR settings_ir; |
3466 settings_ir.AddSetting(SETTINGS_HEADER_TABLE_SIZE, 10); | 3681 settings_ir.AddSetting(SETTINGS_HEADER_TABLE_SIZE, 10); |
3467 SpdySerializedFrame control_frame(framer.SerializeSettings(settings_ir)); | 3682 SpdySerializedFrame control_frame(framer.SerializeSettings(settings_ir)); |
3683 if (use_output_) { | |
3684 EXPECT_TRUE(framer.SerializeSettings(settings_ir, &output_)); | |
3685 control_frame = SpdySerializedFrame(output_.Begin(), output_.Size(), false); | |
3686 } | |
3468 visitor.SimulateInFramer( | 3687 visitor.SimulateInFramer( |
3469 reinterpret_cast<unsigned char*>(control_frame.data()), | 3688 reinterpret_cast<unsigned char*>(control_frame.data()), |
3470 control_frame.size()); | 3689 control_frame.size()); |
3471 EXPECT_EQ(0, visitor.error_count_); | 3690 EXPECT_EQ(0, visitor.error_count_); |
3472 EXPECT_EQ(1u, static_cast<unsigned>(visitor.setting_count_)); | 3691 EXPECT_EQ(1u, static_cast<unsigned>(visitor.setting_count_)); |
3473 EXPECT_EQ(1u, static_cast<unsigned>(visitor.settings_ack_sent_)); | 3692 EXPECT_EQ(1u, static_cast<unsigned>(visitor.settings_ack_sent_)); |
3474 } | 3693 } |
3475 | 3694 |
3476 TEST_P(SpdyFramerTest, ReadGarbageWithValidLength) { | 3695 TEST_P(SpdyFramerTest, ReadGarbageWithValidLength) { |
3477 SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION); | 3696 SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION); |
(...skipping 189 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
3667 do { | 3886 do { |
3668 SCOPED_TRACE(testing::Message() << "Flags " << flags << std::hex | 3887 SCOPED_TRACE(testing::Message() << "Flags " << flags << std::hex |
3669 << static_cast<int>(flags)); | 3888 << static_cast<int>(flags)); |
3670 | 3889 |
3671 testing::StrictMock<test::MockSpdyFramerVisitor> visitor; | 3890 testing::StrictMock<test::MockSpdyFramerVisitor> visitor; |
3672 SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION); | 3891 SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION); |
3673 framer.set_visitor(&visitor); | 3892 framer.set_visitor(&visitor); |
3674 | 3893 |
3675 SpdyRstStreamIR rst_stream(13, ERROR_CODE_CANCEL); | 3894 SpdyRstStreamIR rst_stream(13, ERROR_CODE_CANCEL); |
3676 SpdySerializedFrame frame(framer.SerializeRstStream(rst_stream)); | 3895 SpdySerializedFrame frame(framer.SerializeRstStream(rst_stream)); |
3896 if (use_output_) { | |
3897 output_.Reset(); | |
3898 EXPECT_TRUE(framer.SerializeRstStream(rst_stream, &output_)); | |
3899 frame = SpdySerializedFrame(output_.Begin(), output_.Size(), false); | |
3900 } | |
3677 SetFrameFlags(&frame, flags); | 3901 SetFrameFlags(&frame, flags); |
3678 | 3902 |
3679 EXPECT_CALL(visitor, OnRstStream(13, ERROR_CODE_CANCEL)); | 3903 EXPECT_CALL(visitor, OnRstStream(13, ERROR_CODE_CANCEL)); |
3680 | 3904 |
3681 framer.ProcessInput(frame.data(), frame.size()); | 3905 framer.ProcessInput(frame.data(), frame.size()); |
3682 | 3906 |
3683 EXPECT_EQ(SpdyFramer::SPDY_READY_FOR_FRAME, framer.state()); | 3907 EXPECT_EQ(SpdyFramer::SPDY_READY_FOR_FRAME, framer.state()); |
3684 EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.spdy_framer_error()) | 3908 EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.spdy_framer_error()) |
3685 << SpdyFramer::SpdyFramerErrorToString(framer.spdy_framer_error()); | 3909 << SpdyFramer::SpdyFramerErrorToString(framer.spdy_framer_error()); |
3686 } while (++flags != 0); | 3910 } while (++flags != 0); |
3687 } | 3911 } |
3688 | 3912 |
3689 TEST_P(SpdyFramerTest, SettingsFrameFlags) { | 3913 TEST_P(SpdyFramerTest, SettingsFrameFlags) { |
3690 uint8_t flags = 0; | 3914 uint8_t flags = 0; |
3691 do { | 3915 do { |
3692 SCOPED_TRACE(testing::Message() << "Flags " << flags << std::hex | 3916 SCOPED_TRACE(testing::Message() << "Flags " << flags << std::hex |
3693 << static_cast<int>(flags)); | 3917 << static_cast<int>(flags)); |
3694 | 3918 |
3695 testing::StrictMock<test::MockSpdyFramerVisitor> visitor; | 3919 testing::StrictMock<test::MockSpdyFramerVisitor> visitor; |
3696 SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION); | 3920 SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION); |
3697 framer.set_visitor(&visitor); | 3921 framer.set_visitor(&visitor); |
3698 | 3922 |
3699 SpdySettingsIR settings_ir; | 3923 SpdySettingsIR settings_ir; |
3700 settings_ir.AddSetting(SETTINGS_INITIAL_WINDOW_SIZE, 16); | 3924 settings_ir.AddSetting(SETTINGS_INITIAL_WINDOW_SIZE, 16); |
3701 SpdySerializedFrame frame(framer.SerializeSettings(settings_ir)); | 3925 SpdySerializedFrame frame(framer.SerializeSettings(settings_ir)); |
3926 if (use_output_) { | |
3927 output_.Reset(); | |
3928 EXPECT_TRUE(framer.SerializeSettings(settings_ir, &output_)); | |
3929 frame = SpdySerializedFrame(output_.Begin(), output_.Size(), false); | |
3930 } | |
3702 SetFrameFlags(&frame, flags); | 3931 SetFrameFlags(&frame, flags); |
3703 | 3932 |
3704 if (flags & SETTINGS_FLAG_ACK) { | 3933 if (flags & SETTINGS_FLAG_ACK) { |
3705 EXPECT_CALL(visitor, OnError(_)); | 3934 EXPECT_CALL(visitor, OnError(_)); |
3706 } else { | 3935 } else { |
3707 EXPECT_CALL(visitor, OnSettings(flags & SETTINGS_FLAG_ACK)); | 3936 EXPECT_CALL(visitor, OnSettings(flags & SETTINGS_FLAG_ACK)); |
3708 EXPECT_CALL(visitor, OnSetting(SETTINGS_INITIAL_WINDOW_SIZE, 16)); | 3937 EXPECT_CALL(visitor, OnSetting(SETTINGS_INITIAL_WINDOW_SIZE, 16)); |
3709 EXPECT_CALL(visitor, OnSettingsEnd()); | 3938 EXPECT_CALL(visitor, OnSettingsEnd()); |
3710 } | 3939 } |
3711 | 3940 |
(...skipping 17 matching lines...) Expand all Loading... | |
3729 do { | 3958 do { |
3730 SCOPED_TRACE(testing::Message() << "Flags " << flags << std::hex | 3959 SCOPED_TRACE(testing::Message() << "Flags " << flags << std::hex |
3731 << static_cast<int>(flags)); | 3960 << static_cast<int>(flags)); |
3732 | 3961 |
3733 testing::StrictMock<test::MockSpdyFramerVisitor> visitor; | 3962 testing::StrictMock<test::MockSpdyFramerVisitor> visitor; |
3734 SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION); | 3963 SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION); |
3735 framer.set_visitor(&visitor); | 3964 framer.set_visitor(&visitor); |
3736 | 3965 |
3737 SpdyGoAwayIR goaway_ir(97, ERROR_CODE_NO_ERROR, "test"); | 3966 SpdyGoAwayIR goaway_ir(97, ERROR_CODE_NO_ERROR, "test"); |
3738 SpdySerializedFrame frame(framer.SerializeGoAway(goaway_ir)); | 3967 SpdySerializedFrame frame(framer.SerializeGoAway(goaway_ir)); |
3968 if (use_output_) { | |
3969 output_.Reset(); | |
3970 EXPECT_TRUE(framer.SerializeGoAway(goaway_ir, &output_)); | |
3971 frame = SpdySerializedFrame(output_.Begin(), output_.Size(), false); | |
3972 } | |
3739 SetFrameFlags(&frame, flags); | 3973 SetFrameFlags(&frame, flags); |
3740 | 3974 |
3741 EXPECT_CALL(visitor, OnGoAway(97, ERROR_CODE_NO_ERROR)); | 3975 EXPECT_CALL(visitor, OnGoAway(97, ERROR_CODE_NO_ERROR)); |
3742 | 3976 |
3743 framer.ProcessInput(frame.data(), frame.size()); | 3977 framer.ProcessInput(frame.data(), frame.size()); |
3744 EXPECT_EQ(SpdyFramer::SPDY_READY_FOR_FRAME, framer.state()); | 3978 EXPECT_EQ(SpdyFramer::SPDY_READY_FOR_FRAME, framer.state()); |
3745 EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.spdy_framer_error()) | 3979 EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.spdy_framer_error()) |
3746 << SpdyFramer::SpdyFramerErrorToString(framer.spdy_framer_error()); | 3980 << SpdyFramer::SpdyFramerErrorToString(framer.spdy_framer_error()); |
3747 } while (++flags != 0); | 3981 } while (++flags != 0); |
3748 } | 3982 } |
3749 | 3983 |
3750 TEST_P(SpdyFramerTest, HeadersFrameFlags) { | 3984 TEST_P(SpdyFramerTest, HeadersFrameFlags) { |
3751 uint8_t flags = 0; | 3985 uint8_t flags = 0; |
3752 do { | 3986 do { |
3753 SCOPED_TRACE(testing::Message() << "Flags " << flags << std::hex | 3987 SCOPED_TRACE(testing::Message() << "Flags " << flags << std::hex |
3754 << static_cast<int>(flags)); | 3988 << static_cast<int>(flags)); |
3755 | 3989 |
3756 testing::StrictMock<test::MockSpdyFramerVisitor> visitor; | 3990 testing::StrictMock<test::MockSpdyFramerVisitor> visitor; |
3757 SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION); | 3991 SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION); |
3758 framer.set_visitor(&visitor); | 3992 framer.set_visitor(&visitor); |
3759 | 3993 |
3760 SpdyHeadersIR headers_ir(57); | 3994 SpdyHeadersIR headers_ir(57); |
3761 if (flags & HEADERS_FLAG_PRIORITY) { | 3995 if (flags & HEADERS_FLAG_PRIORITY) { |
3762 headers_ir.set_weight(3); | 3996 headers_ir.set_weight(3); |
3763 headers_ir.set_has_priority(true); | 3997 headers_ir.set_has_priority(true); |
3764 headers_ir.set_parent_stream_id(5); | 3998 headers_ir.set_parent_stream_id(5); |
3765 headers_ir.set_exclusive(true); | 3999 headers_ir.set_exclusive(true); |
3766 } | 4000 } |
3767 headers_ir.SetHeader("foo", "bar"); | 4001 headers_ir.SetHeader("foo", "bar"); |
3768 SpdySerializedFrame frame( | 4002 SpdySerializedFrame frame(SpdyFramerPeer::SerializeHeaders( |
3769 SpdyFramerPeer::SerializeHeaders(&framer, headers_ir)); | 4003 &framer, headers_ir, use_output_ ? &output_ : nullptr)); |
3770 uint8_t set_flags = flags & ~HEADERS_FLAG_PADDED; | 4004 uint8_t set_flags = flags & ~HEADERS_FLAG_PADDED; |
3771 SetFrameFlags(&frame, set_flags); | 4005 SetFrameFlags(&frame, set_flags); |
3772 | 4006 |
3773 // Expected callback values | 4007 // Expected callback values |
3774 SpdyStreamId stream_id = 57; | 4008 SpdyStreamId stream_id = 57; |
3775 bool has_priority = false; | 4009 bool has_priority = false; |
3776 SpdyPriority priority = 0; | 4010 SpdyPriority priority = 0; |
3777 SpdyStreamId parent_stream_id = 0; | 4011 SpdyStreamId parent_stream_id = 0; |
3778 bool exclusive = false; | 4012 bool exclusive = false; |
3779 bool fin = flags & CONTROL_FLAG_FIN; | 4013 bool fin = flags & CONTROL_FLAG_FIN; |
(...skipping 125 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
3905 framer.set_visitor(&visitor); | 4139 framer.set_visitor(&visitor); |
3906 framer.set_debug_visitor(&debug_visitor); | 4140 framer.set_debug_visitor(&debug_visitor); |
3907 | 4141 |
3908 EXPECT_CALL(debug_visitor, OnSendCompressedFrame(42, HEADERS, _, _)); | 4142 EXPECT_CALL(debug_visitor, OnSendCompressedFrame(42, HEADERS, _, _)); |
3909 EXPECT_CALL(debug_visitor, OnReceiveCompressedFrame(42, HEADERS, _)); | 4143 EXPECT_CALL(debug_visitor, OnReceiveCompressedFrame(42, HEADERS, _)); |
3910 EXPECT_CALL(visitor, OnHeaders(42, false, 0, 0, false, false, false)); | 4144 EXPECT_CALL(visitor, OnHeaders(42, false, 0, 0, false, false, false)); |
3911 EXPECT_CALL(visitor, OnHeaderFrameStart(42)).Times(1); | 4145 EXPECT_CALL(visitor, OnHeaderFrameStart(42)).Times(1); |
3912 | 4146 |
3913 SpdyHeadersIR headers_ir(42); | 4147 SpdyHeadersIR headers_ir(42); |
3914 headers_ir.SetHeader("foo", "bar"); | 4148 headers_ir.SetHeader("foo", "bar"); |
3915 SpdySerializedFrame frame0( | 4149 SpdySerializedFrame frame0(SpdyFramerPeer::SerializeHeaders( |
3916 SpdyFramerPeer::SerializeHeaders(&framer, headers_ir)); | 4150 &framer, headers_ir, use_output_ ? &output_ : nullptr)); |
3917 SetFrameFlags(&frame0, 0); | 4151 SetFrameFlags(&frame0, 0); |
3918 | 4152 |
3919 SpdyContinuationIR continuation(42); | 4153 SpdyContinuationIR continuation(42); |
3920 SpdySerializedFrame frame(framer.SerializeContinuation(continuation)); | 4154 SpdySerializedFrame frame(framer.SerializeContinuation(continuation)); |
4155 if (use_output_) { | |
4156 output_.Reset(); | |
4157 EXPECT_TRUE(framer.SerializeContinuation(continuation, &output_)); | |
4158 frame = SpdySerializedFrame(output_.Begin(), output_.Size(), false); | |
4159 } | |
3921 SetFrameFlags(&frame, flags); | 4160 SetFrameFlags(&frame, flags); |
3922 | 4161 |
3923 EXPECT_CALL(debug_visitor, OnReceiveCompressedFrame(42, CONTINUATION, _)); | 4162 EXPECT_CALL(debug_visitor, OnReceiveCompressedFrame(42, CONTINUATION, _)); |
3924 EXPECT_CALL(visitor, OnContinuation(42, flags & HEADERS_FLAG_END_HEADERS)); | 4163 EXPECT_CALL(visitor, OnContinuation(42, flags & HEADERS_FLAG_END_HEADERS)); |
3925 bool end = flags & HEADERS_FLAG_END_HEADERS; | 4164 bool end = flags & HEADERS_FLAG_END_HEADERS; |
3926 if (end) { | 4165 if (end) { |
3927 EXPECT_CALL(visitor, OnHeaderFrameEnd(42, _)).Times(1); | 4166 EXPECT_CALL(visitor, OnHeaderFrameEnd(42, _)).Times(1); |
3928 } | 4167 } |
3929 | 4168 |
3930 framer.ProcessInput(frame0.data(), frame0.size()); | 4169 framer.ProcessInput(frame0.data(), frame0.size()); |
(...skipping 96 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
4027 const SpdyStreamId kStreamId = 0; | 4266 const SpdyStreamId kStreamId = 0; |
4028 | 4267 |
4029 testing::StrictMock<test::MockSpdyFramerVisitor> visitor; | 4268 testing::StrictMock<test::MockSpdyFramerVisitor> visitor; |
4030 SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION); | 4269 SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION); |
4031 framer.set_visitor(&visitor); | 4270 framer.set_visitor(&visitor); |
4032 | 4271 |
4033 EXPECT_CALL(visitor, OnBlocked(kStreamId)); | 4272 EXPECT_CALL(visitor, OnBlocked(kStreamId)); |
4034 | 4273 |
4035 SpdyBlockedIR blocked_ir(0); | 4274 SpdyBlockedIR blocked_ir(0); |
4036 SpdySerializedFrame frame(framer.SerializeFrame(blocked_ir)); | 4275 SpdySerializedFrame frame(framer.SerializeFrame(blocked_ir)); |
4276 if (use_output_) { | |
4277 output_.Reset(); | |
4278 EXPECT_TRUE(framer.SerializeFrame(blocked_ir, &output_)); | |
4279 frame = SpdySerializedFrame(output_.Begin(), output_.Size(), false); | |
4280 } | |
4037 framer.ProcessInput(frame.data(), framer.GetBlockedSize()); | 4281 framer.ProcessInput(frame.data(), framer.GetBlockedSize()); |
4038 | 4282 |
4039 EXPECT_EQ(SpdyFramer::SPDY_READY_FOR_FRAME, framer.state()); | 4283 EXPECT_EQ(SpdyFramer::SPDY_READY_FOR_FRAME, framer.state()); |
4040 EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.spdy_framer_error()) | 4284 EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.spdy_framer_error()) |
4041 << SpdyFramer::SpdyFramerErrorToString(framer.spdy_framer_error()); | 4285 << SpdyFramer::SpdyFramerErrorToString(framer.spdy_framer_error()); |
4042 } | 4286 } |
4043 | 4287 |
4044 TEST_P(SpdyFramerTest, OnAltSvcWithOrigin) { | 4288 TEST_P(SpdyFramerTest, OnAltSvcWithOrigin) { |
4045 const SpdyStreamId kStreamId = 0; // Stream id must be zero if origin given. | 4289 const SpdyStreamId kStreamId = 0; // Stream id must be zero if origin given. |
4046 | 4290 |
4047 testing::StrictMock<test::MockSpdyFramerVisitor> visitor; | 4291 testing::StrictMock<test::MockSpdyFramerVisitor> visitor; |
4048 SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION); | 4292 SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION); |
4049 framer.set_visitor(&visitor); | 4293 framer.set_visitor(&visitor); |
4050 | 4294 |
4051 SpdyAltSvcWireFormat::AlternativeService altsvc1( | 4295 SpdyAltSvcWireFormat::AlternativeService altsvc1( |
4052 "pid1", "host", 443, 5, SpdyAltSvcWireFormat::VersionVector()); | 4296 "pid1", "host", 443, 5, SpdyAltSvcWireFormat::VersionVector()); |
4053 SpdyAltSvcWireFormat::AlternativeService altsvc2( | 4297 SpdyAltSvcWireFormat::AlternativeService altsvc2( |
4054 "p\"=i:d", "h_\\o\"st", 123, 42, SpdyAltSvcWireFormat::VersionVector{24}); | 4298 "p\"=i:d", "h_\\o\"st", 123, 42, SpdyAltSvcWireFormat::VersionVector{24}); |
4055 SpdyAltSvcWireFormat::AlternativeServiceVector altsvc_vector; | 4299 SpdyAltSvcWireFormat::AlternativeServiceVector altsvc_vector; |
4056 altsvc_vector.push_back(altsvc1); | 4300 altsvc_vector.push_back(altsvc1); |
4057 altsvc_vector.push_back(altsvc2); | 4301 altsvc_vector.push_back(altsvc2); |
4058 EXPECT_CALL(visitor, | 4302 EXPECT_CALL(visitor, |
4059 OnAltSvc(kStreamId, StringPiece("o_r|g!n"), altsvc_vector)); | 4303 OnAltSvc(kStreamId, StringPiece("o_r|g!n"), altsvc_vector)); |
4060 | 4304 |
4061 SpdyAltSvcIR altsvc_ir(kStreamId); | 4305 SpdyAltSvcIR altsvc_ir(kStreamId); |
4062 altsvc_ir.set_origin("o_r|g!n"); | 4306 altsvc_ir.set_origin("o_r|g!n"); |
4063 altsvc_ir.add_altsvc(altsvc1); | 4307 altsvc_ir.add_altsvc(altsvc1); |
4064 altsvc_ir.add_altsvc(altsvc2); | 4308 altsvc_ir.add_altsvc(altsvc2); |
4065 SpdySerializedFrame frame(framer.SerializeFrame(altsvc_ir)); | 4309 SpdySerializedFrame frame(framer.SerializeFrame(altsvc_ir)); |
4310 if (use_output_) { | |
4311 output_.Reset(); | |
4312 EXPECT_TRUE(framer.SerializeFrame(altsvc_ir, &output_)); | |
4313 frame = SpdySerializedFrame(output_.Begin(), output_.Size(), false); | |
4314 } | |
4066 framer.ProcessInput(frame.data(), frame.size()); | 4315 framer.ProcessInput(frame.data(), frame.size()); |
4067 | 4316 |
4068 EXPECT_EQ(SpdyFramer::SPDY_READY_FOR_FRAME, framer.state()); | 4317 EXPECT_EQ(SpdyFramer::SPDY_READY_FOR_FRAME, framer.state()); |
4069 EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.spdy_framer_error()) | 4318 EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.spdy_framer_error()) |
4070 << SpdyFramer::SpdyFramerErrorToString(framer.spdy_framer_error()); | 4319 << SpdyFramer::SpdyFramerErrorToString(framer.spdy_framer_error()); |
4071 } | 4320 } |
4072 | 4321 |
4073 TEST_P(SpdyFramerTest, OnAltSvcNoOrigin) { | 4322 TEST_P(SpdyFramerTest, OnAltSvcNoOrigin) { |
4074 const SpdyStreamId kStreamId = 1; | 4323 const SpdyStreamId kStreamId = 1; |
4075 | 4324 |
(...skipping 30 matching lines...) Expand all Loading... | |
4106 | 4355 |
4107 EXPECT_CALL(visitor, OnError(testing::Eq(&framer))); | 4356 EXPECT_CALL(visitor, OnError(testing::Eq(&framer))); |
4108 | 4357 |
4109 SpdyAltSvcIR altsvc_ir(kStreamId); | 4358 SpdyAltSvcIR altsvc_ir(kStreamId); |
4110 altsvc_ir.set_origin("o1"); | 4359 altsvc_ir.set_origin("o1"); |
4111 altsvc_ir.add_altsvc(SpdyAltSvcWireFormat::AlternativeService( | 4360 altsvc_ir.add_altsvc(SpdyAltSvcWireFormat::AlternativeService( |
4112 "pid1", "host", 443, 5, SpdyAltSvcWireFormat::VersionVector())); | 4361 "pid1", "host", 443, 5, SpdyAltSvcWireFormat::VersionVector())); |
4113 altsvc_ir.add_altsvc(SpdyAltSvcWireFormat::AlternativeService( | 4362 altsvc_ir.add_altsvc(SpdyAltSvcWireFormat::AlternativeService( |
4114 "", "h1", 443, 10, SpdyAltSvcWireFormat::VersionVector())); | 4363 "", "h1", 443, 10, SpdyAltSvcWireFormat::VersionVector())); |
4115 SpdySerializedFrame frame(framer.SerializeFrame(altsvc_ir)); | 4364 SpdySerializedFrame frame(framer.SerializeFrame(altsvc_ir)); |
4365 if (use_output_) { | |
4366 output_.Reset(); | |
4367 EXPECT_TRUE(framer.SerializeFrame(altsvc_ir, &output_)); | |
4368 frame = SpdySerializedFrame(output_.Begin(), output_.Size(), false); | |
4369 } | |
4116 framer.ProcessInput(frame.data(), frame.size()); | 4370 framer.ProcessInput(frame.data(), frame.size()); |
4117 | 4371 |
4118 EXPECT_EQ(SpdyFramer::SPDY_ERROR, framer.state()); | 4372 EXPECT_EQ(SpdyFramer::SPDY_ERROR, framer.state()); |
4119 EXPECT_EQ(SpdyFramer::SPDY_INVALID_CONTROL_FRAME, framer.spdy_framer_error()) | 4373 EXPECT_EQ(SpdyFramer::SPDY_INVALID_CONTROL_FRAME, framer.spdy_framer_error()) |
4120 << SpdyFramer::SpdyFramerErrorToString(framer.spdy_framer_error()); | 4374 << SpdyFramer::SpdyFramerErrorToString(framer.spdy_framer_error()); |
4121 } | 4375 } |
4122 | 4376 |
4123 TEST_P(SpdyFramerTest, OnAltSvcBadLengths) { | 4377 TEST_P(SpdyFramerTest, OnAltSvcBadLengths) { |
4124 const char kType = static_cast<unsigned char>(ALTSVC); | 4378 const char kType = static_cast<unsigned char>(ALTSVC); |
4125 const unsigned char kFrameDataOriginLenLargerThanFrame[] = { | 4379 const unsigned char kFrameDataOriginLenLargerThanFrame[] = { |
(...skipping 102 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
4228 EXPECT_EQ(SpdyFramer::SPDY_ERROR, framer.state()); | 4482 EXPECT_EQ(SpdyFramer::SPDY_ERROR, framer.state()); |
4229 EXPECT_EQ(SpdyFramer::SPDY_INVALID_CONTROL_FRAME, framer.spdy_framer_error()) | 4483 EXPECT_EQ(SpdyFramer::SPDY_INVALID_CONTROL_FRAME, framer.spdy_framer_error()) |
4230 << SpdyFramer::SpdyFramerErrorToString(framer.spdy_framer_error()); | 4484 << SpdyFramer::SpdyFramerErrorToString(framer.spdy_framer_error()); |
4231 } | 4485 } |
4232 | 4486 |
4233 // Tests handling of PRIORITY frames. | 4487 // Tests handling of PRIORITY frames. |
4234 TEST_P(SpdyFramerTest, ReadPriority) { | 4488 TEST_P(SpdyFramerTest, ReadPriority) { |
4235 SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION); | 4489 SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION); |
4236 SpdyPriorityIR priority(3, 1, 256, false); | 4490 SpdyPriorityIR priority(3, 1, 256, false); |
4237 SpdySerializedFrame frame(framer.SerializePriority(priority)); | 4491 SpdySerializedFrame frame(framer.SerializePriority(priority)); |
4492 if (use_output_) { | |
4493 output_.Reset(); | |
4494 EXPECT_TRUE(framer.SerializePriority(priority, &output_)); | |
4495 frame = SpdySerializedFrame(output_.Begin(), output_.Size(), false); | |
4496 } | |
4238 testing::StrictMock<test::MockSpdyFramerVisitor> visitor; | 4497 testing::StrictMock<test::MockSpdyFramerVisitor> visitor; |
4239 framer.set_visitor(&visitor); | 4498 framer.set_visitor(&visitor); |
4240 EXPECT_CALL(visitor, OnPriority(3, 1, 256, false)); | 4499 EXPECT_CALL(visitor, OnPriority(3, 1, 256, false)); |
4241 framer.ProcessInput(frame.data(), frame.size()); | 4500 framer.ProcessInput(frame.data(), frame.size()); |
4242 | 4501 |
4243 EXPECT_EQ(SpdyFramer::SPDY_READY_FOR_FRAME, framer.state()); | 4502 EXPECT_EQ(SpdyFramer::SPDY_READY_FOR_FRAME, framer.state()); |
4244 EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.spdy_framer_error()) | 4503 EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.spdy_framer_error()) |
4245 << SpdyFramer::SpdyFramerErrorToString(framer.spdy_framer_error()); | 4504 << SpdyFramer::SpdyFramerErrorToString(framer.spdy_framer_error()); |
4246 // TODO(mlavan): once we actually maintain a priority tree, | 4505 // TODO(mlavan): once we actually maintain a priority tree, |
4247 // check that state is adjusted correctly. | 4506 // check that state is adjusted correctly. |
(...skipping 111 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
4359 SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION); | 4618 SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION); |
4360 std::unique_ptr<TestSpdyVisitor> visitor( | 4619 std::unique_ptr<TestSpdyVisitor> visitor( |
4361 new TestSpdyVisitor(SpdyFramer::DISABLE_COMPRESSION)); | 4620 new TestSpdyVisitor(SpdyFramer::DISABLE_COMPRESSION)); |
4362 framer.set_visitor(visitor.get()); | 4621 framer.set_visitor(visitor.get()); |
4363 | 4622 |
4364 // Create two input frames. | 4623 // Create two input frames. |
4365 SpdyHeadersIR headers(1); | 4624 SpdyHeadersIR headers(1); |
4366 headers.SetHeader("alpha", "beta"); | 4625 headers.SetHeader("alpha", "beta"); |
4367 headers.SetHeader("gamma", "charlie"); | 4626 headers.SetHeader("gamma", "charlie"); |
4368 headers.SetHeader("cookie", "key1=value1; key2=value2"); | 4627 headers.SetHeader("cookie", "key1=value1; key2=value2"); |
4369 SpdySerializedFrame headers_frame( | 4628 SpdySerializedFrame headers_frame(SpdyFramerPeer::SerializeHeaders( |
4370 SpdyFramerPeer::SerializeHeaders(&framer, headers)); | 4629 &framer, headers, use_output_ ? &output_ : nullptr)); |
4371 | 4630 |
4372 const char four_score[] = "Four score and seven years ago"; | 4631 const char four_score[] = "Four score and seven years ago"; |
4373 SpdyDataIR four_score_ir(1, four_score); | 4632 SpdyDataIR four_score_ir(1, four_score); |
4374 SpdySerializedFrame four_score_frame(framer.SerializeData(four_score_ir)); | 4633 SpdySerializedFrame four_score_frame(framer.SerializeData(four_score_ir)); |
4375 | 4634 |
4376 // Put them in a single buffer (new variables here to make it easy to | 4635 // Put them in a single buffer (new variables here to make it easy to |
4377 // change the order and type of frames). | 4636 // change the order and type of frames). |
4378 SpdySerializedFrame frame1 = std::move(headers_frame); | 4637 SpdySerializedFrame frame1 = std::move(headers_frame); |
4379 SpdySerializedFrame frame2 = std::move(four_score_frame); | 4638 SpdySerializedFrame frame2 = std::move(four_score_frame); |
4380 | 4639 |
(...skipping 99 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
4480 | 4739 |
4481 EXPECT_EQ(1, visitor->data_frame_count_); | 4740 EXPECT_EQ(1, visitor->data_frame_count_); |
4482 EXPECT_EQ(strlen(four_score), static_cast<unsigned>(visitor->data_bytes_)); | 4741 EXPECT_EQ(strlen(four_score), static_cast<unsigned>(visitor->data_bytes_)); |
4483 EXPECT_EQ(0, visitor->headers_frame_count_); | 4742 EXPECT_EQ(0, visitor->headers_frame_count_); |
4484 } | 4743 } |
4485 } | 4744 } |
4486 | 4745 |
4487 } // namespace test | 4746 } // namespace test |
4488 | 4747 |
4489 } // namespace net | 4748 } // namespace net |
OLD | NEW |