Chromium Code Reviews Chromium Code Reviews
Issue 710713002:
Remove SPDY2 and SPDY/3.0 from tests. (Closed)
Base URL: https://chromium.googlesource.com/chromium/src.git@master| Index: net/spdy/spdy_framer_test.cc |
| diff --git a/net/spdy/spdy_framer_test.cc b/net/spdy/spdy_framer_test.cc |
| index 2b7bc4bd2096e3dd6456fe9446b593215514dc8c..d14c28bb7ab9e347bdf95983f5e29561f9b18ba4 100644 |
| --- a/net/spdy/spdy_framer_test.cc |
| +++ b/net/spdy/spdy_framer_test.cc |
| @@ -670,7 +670,6 @@ class SpdyFramerTest : public ::testing::TestWithParam<SpdyMajorVersion> { |
| return true; |
| } |
| - bool IsSpdy2() { return spdy_version_ == SPDY2; } |
|
Ryan Hamilton
2014/11/10 23:08:27
Have these changes been made server side too?
|
| bool IsSpdy3() { return spdy_version_ == SPDY3; } |
| bool IsSpdy4() { return spdy_version_ == SPDY4; } |
| bool IsSpdy5() { return spdy_version_ == SPDY5; } |
| @@ -680,10 +679,9 @@ class SpdyFramerTest : public ::testing::TestWithParam<SpdyMajorVersion> { |
| unsigned char spdy_version_ch_; |
| }; |
| -// All tests are run with 3 different SPDY versions: SPDY/2, SPDY/3, SPDY/4. |
| INSTANTIATE_TEST_CASE_P(SpdyFramerTests, |
| SpdyFramerTest, |
| - ::testing::Values(SPDY2, SPDY3, SPDY4)); |
| + ::testing::Values(SPDY3, SPDY4)); |
| // Test that we ignore cookie where both name and value are empty. |
| TEST_P(SpdyFramerTest, HeaderBlockWithEmptyCookie) { |
| @@ -875,19 +873,11 @@ TEST_P(SpdyFramerTest, DuplicateHeader) { |
| frame.WriteUInt32(framer.GetHighestPriority()); |
| } |
| - if (IsSpdy2()) { |
| - frame.WriteUInt16(2); // Number of headers. |
| - frame.WriteString("name"); |
| - frame.WriteString("value1"); |
| - frame.WriteString("name"); |
| - frame.WriteString("value2"); |
| - } else { |
| - frame.WriteUInt32(2); // Number of headers. |
| - frame.WriteStringPiece32("name"); |
| - frame.WriteStringPiece32("value1"); |
| - frame.WriteStringPiece32("name"); |
| - frame.WriteStringPiece32("value2"); |
| - } |
| + frame.WriteUInt32(2); // Number of headers. |
| + frame.WriteStringPiece32("name"); |
| + frame.WriteStringPiece32("value1"); |
| + frame.WriteStringPiece32("name"); |
| + frame.WriteStringPiece32("value2"); |
| // write the length |
| frame.RewriteLength(framer); |
| @@ -921,11 +911,7 @@ TEST_P(SpdyFramerTest, MultiValueHeader) { |
| } |
| string value("value1\0value2", 13); |
| - if (IsSpdy2()) { |
| - frame.WriteUInt16(1); // Number of headers. |
| - frame.WriteString("name"); |
| - frame.WriteString(value); |
| - } else if (spdy_version_ > SPDY3) { |
| + if (spdy_version_ > SPDY3) { |
| // TODO(jgraettinger): If this pattern appears again, move to test class. |
| std::map<string, string> header_set; |
| header_set["name"] = value; |
| @@ -974,21 +960,12 @@ TEST_P(SpdyFramerTest, BasicCompression) { |
| size_t uncompressed_size1 = visitor->last_payload_len_; |
| size_t compressed_size1 = |
| visitor->last_frame_len_ - framer.GetSynStreamMinimumSize(); |
| - if (IsSpdy2()) { |
| - EXPECT_EQ(139u, uncompressed_size1); |
| + EXPECT_EQ(165u, uncompressed_size1); |
| #if defined(USE_SYSTEM_ZLIB) |
| - EXPECT_EQ(155u, compressed_size1); |
| + EXPECT_EQ(181u, compressed_size1); |
| #else // !defined(USE_SYSTEM_ZLIB) |
| - EXPECT_EQ(135u, compressed_size1); |
| + EXPECT_EQ(117u, compressed_size1); |
| #endif // !defined(USE_SYSTEM_ZLIB) |
| - } else { |
| - EXPECT_EQ(165u, uncompressed_size1); |
| -#if defined(USE_SYSTEM_ZLIB) |
| - EXPECT_EQ(181u, compressed_size1); |
| -#else // !defined(USE_SYSTEM_ZLIB) |
| - EXPECT_EQ(117u, compressed_size1); |
| -#endif // !defined(USE_SYSTEM_ZLIB) |
| - } |
| scoped_ptr<SpdyFrame> frame2(framer.SerializeSynStream(syn_stream)); |
| size_t uncompressed_size2 = visitor->last_payload_len_; |
| size_t compressed_size2 = |
| @@ -1010,21 +987,12 @@ TEST_P(SpdyFramerTest, BasicCompression) { |
| frame4->size() - framer.GetSynStreamMinimumSize(); |
| size_t compressed_size4 = |
| visitor->last_frame_len_ - framer.GetSynStreamMinimumSize(); |
| - if (IsSpdy2()) { |
| - EXPECT_EQ(139u, uncompressed_size4); |
| + EXPECT_EQ(165u, uncompressed_size4); |
| #if defined(USE_SYSTEM_ZLIB) |
| - EXPECT_EQ(149u, compressed_size4); |
| + EXPECT_EQ(175u, compressed_size4); |
| #else // !defined(USE_SYSTEM_ZLIB) |
| - EXPECT_EQ(101u, compressed_size4); |
| + EXPECT_EQ(102u, compressed_size4); |
| #endif // !defined(USE_SYSTEM_ZLIB) |
| - } else { |
| - EXPECT_EQ(165u, uncompressed_size4); |
| -#if defined(USE_SYSTEM_ZLIB) |
| - EXPECT_EQ(175u, compressed_size4); |
| -#else // !defined(USE_SYSTEM_ZLIB) |
| - EXPECT_EQ(102u, compressed_size4); |
| -#endif // !defined(USE_SYSTEM_ZLIB) |
| - } |
| EXPECT_EQ(uncompressed_size1, uncompressed_size2); |
| EXPECT_EQ(uncompressed_size1, uncompressed_size4); |
| @@ -1058,59 +1026,6 @@ TEST_P(SpdyFramerTest, CompressEmptyHeaders) { |
| } |
| TEST_P(SpdyFramerTest, Basic) { |
| - const unsigned char kV2Input[] = { |
| - 0x80, spdy_version_ch_, 0x00, 0x01, // SYN Stream #1 |
| - 0x00, 0x00, 0x00, 0x14, |
| - 0x00, 0x00, 0x00, 0x01, |
| - 0x00, 0x00, 0x00, 0x00, |
| - 0x00, 0x00, 0x00, 0x01, |
| - 0x00, 0x02, 'h', 'h', |
| - 0x00, 0x02, 'v', 'v', |
| - |
| - 0x80, spdy_version_ch_, 0x00, 0x08, // HEADERS on Stream #1 |
| - 0x00, 0x00, 0x00, 0x18, |
| - 0x00, 0x00, 0x00, 0x01, |
| - 0x00, 0x00, 0x00, 0x02, |
| - 0x00, 0x02, 'h', '2', |
| - 0x00, 0x02, 'v', '2', |
| - 0x00, 0x02, 'h', '3', |
| - 0x00, 0x02, 'v', '3', |
| - |
| - 0x00, 0x00, 0x00, 0x01, // DATA on Stream #1 |
| - 0x00, 0x00, 0x00, 0x0c, |
| - 0xde, 0xad, 0xbe, 0xef, |
| - 0xde, 0xad, 0xbe, 0xef, |
| - 0xde, 0xad, 0xbe, 0xef, |
| - |
| - 0x80, spdy_version_ch_, 0x00, 0x01, // SYN Stream #3 |
| - 0x00, 0x00, 0x00, 0x0c, |
| - 0x00, 0x00, 0x00, 0x03, |
| - 0x00, 0x00, 0x00, 0x00, |
| - 0x00, 0x00, 0x00, 0x00, |
| - |
| - 0x00, 0x00, 0x00, 0x03, // DATA on Stream #3 |
| - 0x00, 0x00, 0x00, 0x08, |
| - 0xde, 0xad, 0xbe, 0xef, |
| - 0xde, 0xad, 0xbe, 0xef, |
| - |
| - 0x00, 0x00, 0x00, 0x01, // DATA on Stream #1 |
| - 0x00, 0x00, 0x00, 0x04, |
| - 0xde, 0xad, 0xbe, 0xef, |
| - |
| - 0x80, spdy_version_ch_, 0x00, 0x03, // RST_STREAM on Stream #1 |
| - 0x00, 0x00, 0x00, 0x08, |
| - 0x00, 0x00, 0x00, 0x01, |
| - 0x00, 0x00, 0x00, 0x05, // RST_STREAM_CANCEL |
| - |
| - 0x00, 0x00, 0x00, 0x03, // DATA on Stream #3 |
| - 0x00, 0x00, 0x00, 0x00, |
| - |
| - 0x80, spdy_version_ch_, 0x00, 0x03, // RST_STREAM on Stream #3 |
| - 0x00, 0x00, 0x00, 0x08, |
| - 0x00, 0x00, 0x00, 0x03, |
| - 0x00, 0x00, 0x00, 0x05, // RST_STREAM_CANCEL |
| - }; |
| - |
| const unsigned char kV3Input[] = { |
| 0x80, spdy_version_ch_, 0x00, 0x01, // SYN Stream #1 |
| 0x00, 0x00, 0x00, 0x1a, |
| @@ -1223,9 +1138,7 @@ TEST_P(SpdyFramerTest, Basic) { |
| }; |
| TestSpdyVisitor visitor(spdy_version_); |
| - if (IsSpdy2()) { |
| - visitor.SimulateInFramer(kV2Input, sizeof(kV2Input)); |
| - } else if (IsSpdy3()) { |
| + if (IsSpdy3()) { |
| visitor.SimulateInFramer(kV3Input, sizeof(kV3Input)); |
| } else { |
| visitor.SimulateInFramer(kV4Input, sizeof(kV4Input)); |
| @@ -1255,32 +1168,6 @@ TEST_P(SpdyFramerTest, Basic) { |
| // Test that the FIN flag on a data frame signifies EOF. |
| TEST_P(SpdyFramerTest, FinOnDataFrame) { |
| - const unsigned char kV2Input[] = { |
| - 0x80, spdy_version_ch_, 0x00, 0x01, // SYN Stream #1 |
| - 0x00, 0x00, 0x00, 0x14, |
| - 0x00, 0x00, 0x00, 0x01, |
| - 0x00, 0x00, 0x00, 0x00, |
| - 0x00, 0x00, 0x00, 0x01, |
| - 0x00, 0x02, 'h', 'h', |
| - 0x00, 0x02, 'v', 'v', |
| - |
| - 0x80, spdy_version_ch_, 0x00, 0x02, // SYN REPLY Stream #1 |
| - 0x00, 0x00, 0x00, 0x10, |
| - 0x00, 0x00, 0x00, 0x01, |
| - 0x00, 0x00, 0x00, 0x01, |
| - 0x00, 0x02, 'a', 'a', |
| - 0x00, 0x02, 'b', 'b', |
| - |
| - 0x00, 0x00, 0x00, 0x01, // DATA on Stream #1 |
| - 0x00, 0x00, 0x00, 0x0c, |
| - 0xde, 0xad, 0xbe, 0xef, |
| - 0xde, 0xad, 0xbe, 0xef, |
| - 0xde, 0xad, 0xbe, 0xef, |
| - |
| - 0x00, 0x00, 0x00, 0x01, // DATA on Stream #1, with EOF |
| - 0x01, 0x00, 0x00, 0x04, |
| - 0xde, 0xad, 0xbe, 0xef, |
| - }; |
| const unsigned char kV3Input[] = { |
| 0x80, spdy_version_ch_, 0x00, 0x01, // SYN Stream #1 |
| 0x00, 0x00, 0x00, 0x1a, |
| @@ -1337,9 +1224,7 @@ TEST_P(SpdyFramerTest, FinOnDataFrame) { |
| }; |
| TestSpdyVisitor visitor(spdy_version_); |
| - if (IsSpdy2()) { |
| - visitor.SimulateInFramer(kV2Input, sizeof(kV2Input)); |
| - } else if (IsSpdy3()) { |
| + if (IsSpdy3()) { |
| visitor.SimulateInFramer(kV3Input, sizeof(kV3Input)); |
| } else { |
| visitor.SimulateInFramer(kV4Input, sizeof(kV4Input)); |
| @@ -1364,24 +1249,6 @@ TEST_P(SpdyFramerTest, FinOnDataFrame) { |
| // Test that the FIN flag on a SYN reply frame signifies EOF. |
| TEST_P(SpdyFramerTest, FinOnSynReplyFrame) { |
| - const unsigned char kV2Input[] = { |
| - 0x80, spdy_version_ch_, 0x00, // SYN Stream #1 |
| - 0x01, 0x00, 0x00, 0x00, |
| - 0x14, 0x00, 0x00, 0x00, |
| - 0x01, 0x00, 0x00, 0x00, |
| - 0x00, 0x00, 0x00, 0x00, |
| - 0x01, 0x00, 0x02, 'h', |
| - 'h', 0x00, 0x02, 'v', |
| - 'v', |
| - |
| - 0x80, spdy_version_ch_, 0x00, // SYN REPLY Stream #1 |
| - 0x02, 0x01, 0x00, 0x00, |
| - 0x10, 0x00, 0x00, 0x00, |
| - 0x01, 0x00, 0x00, 0x00, |
| - 0x01, 0x00, 0x02, 'a', |
| - 'a', 0x00, 0x02, 'b', |
| - 'b', |
| - }; |
| const unsigned char kV3Input[] = { |
| 0x80, spdy_version_ch_, 0x00, // SYN Stream #1 |
| 0x01, 0x00, 0x00, 0x00, |
| @@ -1417,9 +1284,7 @@ TEST_P(SpdyFramerTest, FinOnSynReplyFrame) { |
| }; |
| TestSpdyVisitor visitor(spdy_version_); |
| - if (IsSpdy2()) { |
| - visitor.SimulateInFramer(kV2Input, sizeof(kV2Input)); |
| - } else if (IsSpdy3()) { |
| + if (IsSpdy3()) { |
| visitor.SimulateInFramer(kV3Input, sizeof(kV3Input)); |
| } else { |
| visitor.SimulateInFramer(kV4Input, sizeof(kV4Input)); |
| @@ -1892,7 +1757,7 @@ TEST_P(SpdyFramerTest, CreateDataFrame) { |
| } |
| TEST_P(SpdyFramerTest, CreateSynStreamUncompressed) { |
| - if (!IsSpdy2() && !IsSpdy3()) { |
| + if (spdy_version_ > SPDY3) { |
| // SYN_STREAM unsupported in SPDY>3 |
| return; |
| } |
| @@ -1901,20 +1766,7 @@ TEST_P(SpdyFramerTest, CreateSynStreamUncompressed) { |
| { |
| const char kDescription[] = "SYN_STREAM frame, lowest pri, no FIN"; |
| - |
| - const unsigned char kPri = IsSpdy2() ? 0xC0 : 0xE0; |
| - const unsigned char kV2FrameData[] = { |
| - 0x80, spdy_version_ch_, 0x00, 0x01, |
| - 0x00, 0x00, 0x00, 0x20, |
| - 0x00, 0x00, 0x00, 0x01, |
| - 0x00, 0x00, 0x00, 0x00, |
| - kPri, 0x00, 0x00, 0x02, |
| - 0x00, 0x03, 'b', 'a', |
| - 'r', 0x00, 0x03, 'f', |
| - 'o', 'o', 0x00, 0x03, |
| - 'f', 'o', 'o', 0x00, |
| - 0x03, 'b', 'a', 'r' |
| - }; |
| + const unsigned char kPri = 0xE0; |
| const unsigned char kV3FrameData[] = { |
| 0x80, spdy_version_ch_, 0x00, 0x01, |
| 0x00, 0x00, 0x00, 0x2a, |
| @@ -1935,32 +1787,13 @@ TEST_P(SpdyFramerTest, CreateSynStreamUncompressed) { |
| syn_stream.SetHeader("bar", "foo"); |
| syn_stream.SetHeader("foo", "bar"); |
| scoped_ptr<SpdyFrame> frame(framer.SerializeSynStream(syn_stream)); |
| - if (IsSpdy2()) { |
| - CompareFrame(kDescription, *frame, kV2FrameData, arraysize(kV2FrameData)); |
| - } else if (IsSpdy3()) { |
| - CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData)); |
| - } else { |
| - LOG(FATAL) << "Unsupported version in test."; |
| - } |
| + CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData)); |
| } |
| { |
| const char kDescription[] = |
| "SYN_STREAM frame with a 0-length header name, highest pri, FIN, " |
| "max stream ID"; |
| - |
| - const unsigned char kV2FrameData[] = { |
| - 0x80, spdy_version_ch_, 0x00, 0x01, |
| - 0x01, 0x00, 0x00, 0x1D, |
| - 0x7f, 0xff, 0xff, 0xff, |
| - 0x7f, 0xff, 0xff, 0xff, |
| - 0x00, 0x00, 0x00, 0x02, |
| - 0x00, 0x00, 0x00, 0x03, |
| - 'f', 'o', 'o', 0x00, |
| - 0x03, 'f', 'o', 'o', |
| - 0x00, 0x03, 'b', 'a', |
| - 'r' |
| - }; |
| const unsigned char kV3FrameData[] = { |
| 0x80, spdy_version_ch_, 0x00, 0x01, |
| 0x01, 0x00, 0x00, 0x27, |
| @@ -1982,33 +1815,14 @@ TEST_P(SpdyFramerTest, CreateSynStreamUncompressed) { |
| syn_stream.SetHeader("", "foo"); |
| syn_stream.SetHeader("foo", "bar"); |
| scoped_ptr<SpdyFrame> frame(framer.SerializeSynStream(syn_stream)); |
| - if (IsSpdy2()) { |
| - CompareFrame(kDescription, *frame, kV2FrameData, arraysize(kV2FrameData)); |
| - } else if (IsSpdy3()) { |
| - CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData)); |
| - } else { |
| - LOG(FATAL) << "Unsupported version in test."; |
| - } |
| + CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData)); |
| } |
| { |
| const char kDescription[] = |
| "SYN_STREAM frame with a 0-length header val, high pri, FIN, " |
| "max stream ID"; |
| - |
| - const unsigned char kPri = IsSpdy2() ? 0x40 : 0x20; |
| - const unsigned char kV2FrameData[] = { |
| - 0x80, spdy_version_ch_, 0x00, 0x01, |
| - 0x01, 0x00, 0x00, 0x1D, |
| - 0x7f, 0xff, 0xff, 0xff, |
| - 0x7f, 0xff, 0xff, 0xff, |
| - kPri, 0x00, 0x00, 0x02, |
| - 0x00, 0x03, 'b', 'a', |
| - 'r', 0x00, 0x03, 'f', |
| - 'o', 'o', 0x00, 0x03, |
| - 'f', 'o', 'o', 0x00, |
| - 0x00 |
| - }; |
| + const unsigned char kPri = 0x20; |
| const unsigned char kV3FrameData[] = { |
| 0x80, spdy_version_ch_, 0x00, 0x01, |
| 0x01, 0x00, 0x00, 0x27, |
| @@ -2030,13 +1844,7 @@ TEST_P(SpdyFramerTest, CreateSynStreamUncompressed) { |
| syn_stream.SetHeader("bar", "foo"); |
| syn_stream.SetHeader("foo", ""); |
| scoped_ptr<SpdyFrame> frame(framer.SerializeSynStream(syn_stream)); |
| - if (IsSpdy2()) { |
| - CompareFrame(kDescription, *frame, kV2FrameData, arraysize(kV2FrameData)); |
| - } else if (IsSpdy3()) { |
| - CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData)); |
| - } else { |
| - LOG(FATAL) << "Unsupported version in test."; |
| - } |
| + CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData)); |
| } |
| } |
| @@ -2044,7 +1852,7 @@ TEST_P(SpdyFramerTest, CreateSynStreamUncompressed) { |
| // to workaround http://crbug.com/139744. |
| #if !defined(USE_SYSTEM_ZLIB) |
| TEST_P(SpdyFramerTest, CreateSynStreamCompressed) { |
| - if (!IsSpdy2() && !IsSpdy3()) { |
| + if (spdy_version_ > SPDY3) { |
| // SYN_STREAM not supported for SPDY>3 |
| return; |
| } |
| @@ -2054,26 +1862,8 @@ TEST_P(SpdyFramerTest, CreateSynStreamCompressed) { |
| { |
| const char kDescription[] = |
| "SYN_STREAM frame, low pri, no FIN"; |
| - const SpdyPriority priority = IsSpdy2() ? 2 : 4; |
| + const SpdyPriority priority = 4; |
| - const unsigned char kV2FrameData[] = { |
| - 0x80, spdy_version_ch_, 0x00, 0x01, |
| - 0x00, 0x00, 0x00, 0x36, |
| - 0x00, 0x00, 0x00, 0x01, |
| - 0x00, 0x00, 0x00, 0x00, |
| - 0x80, 0x00, 0x38, 0xea, |
| - 0xdf, 0xa2, 0x51, 0xb2, |
| - 0x62, 0x60, 0x62, 0x60, |
| - 0x4e, 0x4a, 0x2c, 0x62, |
| - 0x60, 0x06, 0x08, 0xa0, |
| - 0xb4, 0xfc, 0x7c, 0x80, |
| - 0x00, 0x62, 0x60, 0x4e, |
| - 0xcb, 0xcf, 0x67, 0x60, |
| - 0x06, 0x08, 0xa0, 0xa4, |
| - 0xc4, 0x22, 0x80, 0x00, |
| - 0x02, 0x00, 0x00, 0x00, |
| - 0xff, 0xff, |
| - }; |
| const unsigned char kV3FrameData[] = { |
| 0x80, spdy_version_ch_, 0x00, 0x01, |
| 0x00, 0x00, 0x00, 0x37, |
| @@ -2092,23 +1882,6 @@ TEST_P(SpdyFramerTest, CreateSynStreamCompressed) { |
| 0x80, 0x00, 0x00, 0x00, |
| 0x00, 0xFF, 0xFF, |
| }; |
| - const unsigned char kV2SIMDFrameData[] = { |
| - 0x80, spdy_version_ch_, 0x00, 0x01, |
| - 0x00, 0x00, 0x00, 0x33, |
| - 0x00, 0x00, 0x00, 0x01, |
| - 0x00, 0x00, 0x00, 0x00, |
| - 0x80, 0x00, 0x38, 0xea, |
| - 0xdf, 0xa2, 0x51, 0xb2, |
| - 0x62, 0x60, 0x62, 0x60, |
| - 0x4e, 0x4a, 0x2c, 0x62, |
| - 0x60, 0x06, 0x08, 0xa0, |
| - 0xb4, 0xfc, 0x7c, 0x80, |
| - 0x00, 0x62, 0x60, 0x06, |
| - 0x13, 0x00, 0x01, 0x94, |
| - 0x94, 0x58, 0x04, 0x10, |
| - 0x40, 0x00, 0x00, 0x00, |
| - 0x00, 0xff, 0xff, |
| - }; |
| const unsigned char kV3SIMDFrameData[] = { |
| 0x80, spdy_version_ch_, 0x00, 0x01, |
| 0x00, 0x00, 0x00, 0x32, |
| @@ -2134,30 +1907,14 @@ TEST_P(SpdyFramerTest, CreateSynStreamCompressed) { |
| scoped_ptr<SpdyFrame> frame(framer.SerializeSynStream(syn_stream)); |
| const unsigned char* frame_data = |
| reinterpret_cast<const unsigned char*>(frame->data()); |
| - if (IsSpdy2()) { |
| - // Try comparing with SIMD version, if that fails, do a failing check |
| - // with pretty printing against non-SIMD version |
| - if (memcmp(frame_data, |
| - kV2SIMDFrameData, |
| - std::min(arraysize(kV2SIMDFrameData), frame->size())) != 0) { |
| - CompareCharArraysWithHexError(kDescription, |
| - frame_data, |
| - frame->size(), |
| - kV2FrameData, |
| - arraysize(kV2FrameData)); |
| - } |
| - } else if (IsSpdy3()) { |
| - if (memcmp(frame_data, |
| - kV3SIMDFrameData, |
| - std::min(arraysize(kV3SIMDFrameData), frame->size())) != 0) { |
| - CompareCharArraysWithHexError(kDescription, |
| - frame_data, |
| - frame->size(), |
| - kV3FrameData, |
| - arraysize(kV3FrameData)); |
| - } |
| - } else { |
| - LOG(FATAL) << "Unsupported version in test."; |
| + if (memcmp(frame_data, |
| + kV3SIMDFrameData, |
| + std::min(arraysize(kV3SIMDFrameData), frame->size())) != 0) { |
| + CompareCharArraysWithHexError(kDescription, |
| + frame_data, |
| + frame->size(), |
| + kV3FrameData, |
| + arraysize(kV3FrameData)); |
| } |
| } |
| } |
| @@ -2173,18 +1930,6 @@ TEST_P(SpdyFramerTest, CreateSynReplyUncompressed) { |
| { |
| const char kDescription[] = "SYN_REPLY frame, no FIN"; |
| - |
| - const unsigned char kV2FrameData[] = { |
| - 0x80, spdy_version_ch_, 0x00, 0x02, |
| - 0x00, 0x00, 0x00, 0x1C, |
| - 0x00, 0x00, 0x00, 0x01, |
| - 0x00, 0x00, 0x00, 0x02, |
| - 0x00, 0x03, 'b', 'a', |
| - 'r', 0x00, 0x03, 'f', |
| - 'o', 'o', 0x00, 0x03, |
| - 'f', 'o', 'o', 0x00, |
| - 0x03, 'b', 'a', 'r' |
| - }; |
| const unsigned char kV3FrameData[] = { |
| 0x80, spdy_version_ch_, 0x00, 0x02, |
| 0x00, 0x00, 0x00, 0x24, |
| @@ -2202,30 +1947,12 @@ TEST_P(SpdyFramerTest, CreateSynReplyUncompressed) { |
| syn_reply.SetHeader("bar", "foo"); |
| syn_reply.SetHeader("foo", "bar"); |
| scoped_ptr<SpdyFrame> frame(framer.SerializeSynReply(syn_reply)); |
| - if (IsSpdy2()) { |
| - CompareFrame(kDescription, *frame, kV2FrameData, arraysize(kV2FrameData)); |
| - } else if (IsSpdy3()) { |
| - CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData)); |
| - } else { |
| - LOG(FATAL) << "Unsupported version in test."; |
| - } |
| + CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData)); |
| } |
| { |
| const char kDescription[] = |
| "SYN_REPLY frame with a 0-length header name, FIN, max stream ID"; |
| - |
| - const unsigned char kV2FrameData[] = { |
| - 0x80, spdy_version_ch_, 0x00, 0x02, |
| - 0x01, 0x00, 0x00, 0x19, |
| - 0x7f, 0xff, 0xff, 0xff, |
| - 0x00, 0x00, 0x00, 0x02, |
| - 0x00, 0x00, 0x00, 0x03, |
| - 'f', 'o', 'o', 0x00, |
| - 0x03, 'f', 'o', 'o', |
| - 0x00, 0x03, 'b', 'a', |
| - 'r' |
| - }; |
| const unsigned char kV3FrameData[] = { |
| 0x80, spdy_version_ch_, 0x00, 0x02, |
| 0x01, 0x00, 0x00, 0x21, |
| @@ -2244,30 +1971,12 @@ TEST_P(SpdyFramerTest, CreateSynReplyUncompressed) { |
| syn_reply.SetHeader("", "foo"); |
| syn_reply.SetHeader("foo", "bar"); |
| scoped_ptr<SpdyFrame> frame(framer.SerializeSynReply(syn_reply)); |
| - if (IsSpdy2()) { |
| - CompareFrame(kDescription, *frame, kV2FrameData, arraysize(kV2FrameData)); |
| - } else if (IsSpdy3()) { |
| - CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData)); |
| - } else { |
| - LOG(FATAL) << "Unsupported version in test."; |
| - } |
| + CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData)); |
| } |
| { |
| const char kDescription[] = |
| "SYN_REPLY frame with a 0-length header val, FIN, max stream ID"; |
| - |
| - const unsigned char kV2FrameData[] = { |
| - 0x80, spdy_version_ch_, 0x00, 0x02, |
| - 0x01, 0x00, 0x00, 0x19, |
| - 0x7f, 0xff, 0xff, 0xff, |
| - 0x00, 0x00, 0x00, 0x02, |
| - 0x00, 0x03, 'b', 'a', |
| - 'r', 0x00, 0x03, 'f', |
| - 'o', 'o', 0x00, 0x03, |
| - 'f', 'o', 'o', 0x00, |
| - 0x00 |
| - }; |
| const unsigned char kV3FrameData[] = { |
| 0x80, spdy_version_ch_, 0x00, 0x02, |
| 0x01, 0x00, 0x00, 0x21, |
| @@ -2286,13 +1995,7 @@ TEST_P(SpdyFramerTest, CreateSynReplyUncompressed) { |
| syn_reply.SetHeader("bar", "foo"); |
| syn_reply.SetHeader("foo", ""); |
| scoped_ptr<SpdyFrame> frame(framer.SerializeSynReply(syn_reply)); |
| - if (IsSpdy2()) { |
| - CompareFrame(kDescription, *frame, kV2FrameData, arraysize(kV2FrameData)); |
| - } else if (IsSpdy3()) { |
| - CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData)); |
| - } else { |
| - LOG(FATAL) << "Unsupported version in test."; |
| - } |
| + CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData)); |
| } |
| } |
| @@ -2309,24 +2012,6 @@ TEST_P(SpdyFramerTest, CreateSynReplyCompressed) { |
| { |
| const char kDescription[] = "SYN_REPLY frame, no FIN"; |
| - |
| - const unsigned char kV2FrameData[] = { |
| - 0x80, spdy_version_ch_, 0x00, 0x02, |
| - 0x00, 0x00, 0x00, 0x32, |
| - 0x00, 0x00, 0x00, 0x01, |
| - 0x00, 0x00, 0x38, 0xea, |
| - 0xdf, 0xa2, 0x51, 0xb2, |
| - 0x62, 0x60, 0x62, 0x60, |
| - 0x4e, 0x4a, 0x2c, 0x62, |
| - 0x60, 0x06, 0x08, 0xa0, |
| - 0xb4, 0xfc, 0x7c, 0x80, |
| - 0x00, 0x62, 0x60, 0x4e, |
| - 0xcb, 0xcf, 0x67, 0x60, |
| - 0x06, 0x08, 0xa0, 0xa4, |
| - 0xc4, 0x22, 0x80, 0x00, |
| - 0x02, 0x00, 0x00, 0x00, |
| - 0xff, 0xff, |
| - }; |
| const unsigned char kV3FrameData[] = { |
| 0x80, spdy_version_ch_, 0x00, 0x02, |
| 0x00, 0x00, 0x00, 0x31, |
| @@ -2344,22 +2029,6 @@ TEST_P(SpdyFramerTest, CreateSynReplyCompressed) { |
| 0x00, 0x00, 0x00, 0xff, |
| 0xff, |
| }; |
| - const unsigned char kV2SIMDFrameData[] = { |
| - 0x80, spdy_version_ch_, 0x00, 0x02, |
| - 0x00, 0x00, 0x00, 0x2f, |
| - 0x00, 0x00, 0x00, 0x01, |
| - 0x00, 0x00, 0x38, 0xea, |
| - 0xdf, 0xa2, 0x51, 0xb2, |
| - 0x62, 0x60, 0x62, 0x60, |
| - 0x4e, 0x4a, 0x2c, 0x62, |
| - 0x60, 0x06, 0x08, 0xa0, |
| - 0xb4, 0xfc, 0x7c, 0x80, |
| - 0x00, 0x62, 0x60, 0x06, |
| - 0x13, 0x00, 0x01, 0x94, |
| - 0x94, 0x58, 0x04, 0x10, |
| - 0x40, 0x00, 0x00, 0x00, |
| - 0x00, 0xff, 0xff, |
| - }; |
| const unsigned char kV3SIMDFrameData[] = { |
| 0x80, spdy_version_ch_, 0x00, 0x02, |
| 0x00, 0x00, 0x00, 0x2c, |
| @@ -2382,30 +2051,14 @@ TEST_P(SpdyFramerTest, CreateSynReplyCompressed) { |
| scoped_ptr<SpdyFrame> frame(framer.SerializeSynReply(syn_reply)); |
| const unsigned char* frame_data = |
| reinterpret_cast<const unsigned char*>(frame->data()); |
| - if (IsSpdy2()) { |
| - // Try comparing with SIMD version, if that fails, do a failing check |
| - // with pretty printing against non-SIMD version |
| - if (memcmp(frame_data, |
| - kV2SIMDFrameData, |
| - std::min(arraysize(kV2SIMDFrameData), frame->size())) != 0) { |
| - CompareCharArraysWithHexError(kDescription, |
| - frame_data, |
| - frame->size(), |
| - kV2FrameData, |
| - arraysize(kV2FrameData)); |
| - } |
| - } else if (IsSpdy3()) { |
| - if (memcmp(frame_data, |
| - kV3SIMDFrameData, |
| - std::min(arraysize(kV3SIMDFrameData), frame->size())) != 0) { |
| - CompareCharArraysWithHexError(kDescription, |
| - frame_data, |
| - frame->size(), |
| - kV3FrameData, |
| - arraysize(kV3FrameData)); |
| - } |
| - } else { |
| - LOG(FATAL) << "Unsupported version in test."; |
| + if (memcmp(frame_data, |
| + kV3SIMDFrameData, |
| + std::min(arraysize(kV3SIMDFrameData), frame->size())) != 0) { |
| + CompareCharArraysWithHexError(kDescription, |
| + frame_data, |
| + frame->size(), |
| + kV3FrameData, |
| + arraysize(kV3FrameData)); |
| } |
| } |
| } |
| @@ -2493,14 +2146,6 @@ TEST_P(SpdyFramerTest, CreateSettings) { |
| { |
| const char kDescription[] = "Network byte order SETTINGS frame"; |
| - |
| - const unsigned char kV2FrameData[] = { |
| - 0x80, spdy_version_ch_, 0x00, 0x04, |
| - 0x00, 0x00, 0x00, 0x0c, |
| - 0x00, 0x00, 0x00, 0x01, |
| - 0x07, 0x00, 0x00, 0x01, |
| - 0x0a, 0x0b, 0x0c, 0x0d, |
| - }; |
| const unsigned char kV3FrameData[] = { |
| 0x80, spdy_version_ch_, 0x00, 0x04, |
| 0x00, 0x00, 0x00, 0x0c, |
| @@ -2530,9 +2175,7 @@ TEST_P(SpdyFramerTest, CreateSettings) { |
| kValue); |
| scoped_ptr<SpdyFrame> frame(framer.SerializeSettings(settings_ir)); |
| - if (IsSpdy2()) { |
| - CompareFrame(kDescription, *frame, kV2FrameData, arraysize(kV2FrameData)); |
| - } else if (IsSpdy3()) { |
| + if (IsSpdy3()) { |
| CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData)); |
| } else { |
| CompareFrame(kDescription, *frame, kV4FrameData, arraysize(kV4FrameData)); |
| @@ -2541,20 +2184,6 @@ TEST_P(SpdyFramerTest, CreateSettings) { |
| { |
| const char kDescription[] = "Basic SETTINGS frame"; |
| - |
| - const unsigned char kV2FrameData[] = { |
| - 0x80, spdy_version_ch_, 0x00, 0x04, |
| - 0x00, 0x00, 0x00, 0x24, |
| - 0x00, 0x00, 0x00, 0x04, |
| - 0x01, 0x00, 0x00, 0x00, // 1st Setting |
| - 0x00, 0x00, 0x00, 0x05, |
| - 0x02, 0x00, 0x00, 0x00, // 2nd Setting |
| - 0x00, 0x00, 0x00, 0x06, |
| - 0x03, 0x00, 0x00, 0x00, // 3rd Setting |
| - 0x00, 0x00, 0x00, 0x07, |
| - 0x04, 0x00, 0x00, 0x00, // 4th Setting |
| - 0x00, 0x00, 0x00, 0x08, |
| - }; |
| const unsigned char kV3FrameData[] = { |
| 0x80, spdy_version_ch_, 0x00, 0x04, |
| 0x00, 0x00, 0x00, 0x24, |
| @@ -2603,9 +2232,7 @@ TEST_P(SpdyFramerTest, CreateSettings) { |
| 8); |
| scoped_ptr<SpdyFrame> frame(framer.SerializeSettings(settings_ir)); |
| - if (IsSpdy2()) { |
| - CompareFrame(kDescription, *frame, kV2FrameData, arraysize(kV2FrameData)); |
| - } else if (IsSpdy3()) { |
| + if (IsSpdy3()) { |
| CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData)); |
| } else { |
| CompareFrame(kDescription, *frame, kV4FrameData, arraysize(kV4FrameData)); |
| @@ -2614,7 +2241,6 @@ TEST_P(SpdyFramerTest, CreateSettings) { |
| { |
| const char kDescription[] = "Empty SETTINGS frame"; |
| - |
| const unsigned char kV3FrameData[] = { // Also applies for V2. |
| 0x80, spdy_version_ch_, 0x00, 0x04, |
| 0x00, 0x00, 0x00, 0x04, |
| @@ -2686,11 +2312,6 @@ TEST_P(SpdyFramerTest, CreateGoAway) { |
| { |
| const char kDescription[] = "GOAWAY frame"; |
| - const unsigned char kV2FrameData[] = { |
| - 0x80, spdy_version_ch_, 0x00, 0x07, |
| - 0x00, 0x00, 0x00, 0x04, |
| - 0x00, 0x00, 0x00, 0x00, // Stream Id |
| - }; |
| const unsigned char kV3FrameData[] = { |
| 0x80, spdy_version_ch_, 0x00, 0x07, |
| 0x00, 0x00, 0x00, 0x08, |
| @@ -2706,9 +2327,7 @@ TEST_P(SpdyFramerTest, CreateGoAway) { |
| }; |
| SpdyGoAwayIR goaway_ir(0, GOAWAY_OK, "GA"); |
| scoped_ptr<SpdyFrame> frame(framer.SerializeGoAway(goaway_ir)); |
| - if (IsSpdy2()) { |
| - CompareFrame(kDescription, *frame, kV2FrameData, arraysize(kV2FrameData)); |
| - } else if (IsSpdy3()) { |
| + if (IsSpdy3()) { |
| CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData)); |
| } else { |
| CompareFrame(kDescription, *frame, kV4FrameData, arraysize(kV4FrameData)); |
| @@ -2717,11 +2336,6 @@ TEST_P(SpdyFramerTest, CreateGoAway) { |
| { |
| const char kDescription[] = "GOAWAY frame with max stream ID, status"; |
| - const unsigned char kV2FrameData[] = { |
| - 0x80, spdy_version_ch_, 0x00, 0x07, |
| - 0x00, 0x00, 0x00, 0x04, |
| - 0x7f, 0xff, 0xff, 0xff, // Stream Id |
| - }; |
| const unsigned char kV3FrameData[] = { |
| 0x80, spdy_version_ch_, 0x00, 0x07, |
| 0x00, 0x00, 0x00, 0x08, |
| @@ -2737,9 +2351,7 @@ TEST_P(SpdyFramerTest, CreateGoAway) { |
| }; |
| SpdyGoAwayIR goaway_ir(0x7FFFFFFF, GOAWAY_INTERNAL_ERROR, "GA"); |
| scoped_ptr<SpdyFrame> frame(framer.SerializeGoAway(goaway_ir)); |
| - if (IsSpdy2()) { |
| - CompareFrame(kDescription, *frame, kV2FrameData, arraysize(kV2FrameData)); |
| - } else if (IsSpdy3()) { |
| + if (IsSpdy3()) { |
| CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData)); |
| } else { |
| CompareFrame(kDescription, *frame, kV4FrameData, arraysize(kV4FrameData)); |
| @@ -2753,18 +2365,6 @@ TEST_P(SpdyFramerTest, CreateHeadersUncompressed) { |
| { |
| const char kDescription[] = "HEADERS frame, no FIN"; |
| - |
| - const unsigned char kV2FrameData[] = { |
| - 0x80, spdy_version_ch_, 0x00, 0x08, |
| - 0x00, 0x00, 0x00, 0x1C, |
| - 0x00, 0x00, 0x00, 0x01, |
| - 0x00, 0x00, 0x00, 0x02, |
| - 0x00, 0x03, 'b', 'a', |
| - 'r', 0x00, 0x03, 'f', |
| - 'o', 'o', 0x00, 0x03, |
| - 'f', 'o', 'o', 0x00, |
| - 0x03, 'b', 'a', 'r' |
| - }; |
| const unsigned char kV3FrameData[] = { |
| 0x80, spdy_version_ch_, 0x00, 0x08, |
| 0x00, 0x00, 0x00, 0x24, |
| @@ -2791,9 +2391,7 @@ TEST_P(SpdyFramerTest, CreateHeadersUncompressed) { |
| headers_ir.SetHeader("bar", "foo"); |
| headers_ir.SetHeader("foo", "bar"); |
| scoped_ptr<SpdyFrame> frame(framer.SerializeHeaders(headers_ir)); |
| - if (IsSpdy2()) { |
| - CompareFrame(kDescription, *frame, kV2FrameData, arraysize(kV2FrameData)); |
| - } else if (IsSpdy3()) { |
| + if (IsSpdy3()) { |
| CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData)); |
| } else { |
| CompareFrame(kDescription, *frame, kV4FrameData, arraysize(kV4FrameData)); |
| @@ -2803,18 +2401,6 @@ TEST_P(SpdyFramerTest, CreateHeadersUncompressed) { |
| { |
| const char kDescription[] = |
| "HEADERS frame with a 0-length header name, FIN, max stream ID"; |
| - |
| - const unsigned char kV2FrameData[] = { |
| - 0x80, spdy_version_ch_, 0x00, 0x08, |
| - 0x01, 0x00, 0x00, 0x19, |
| - 0x7f, 0xff, 0xff, 0xff, |
| - 0x00, 0x00, 0x00, 0x02, |
| - 0x00, 0x00, 0x00, 0x03, |
| - 'f', 'o', 'o', 0x00, |
| - 0x03, 'f', 'o', 'o', |
| - 0x00, 0x03, 'b', 'a', |
| - 'r' |
| - }; |
| const unsigned char kV3FrameData[] = { |
| 0x80, spdy_version_ch_, 0x00, 0x08, |
| 0x01, 0x00, 0x00, 0x21, |
| @@ -2841,9 +2427,7 @@ TEST_P(SpdyFramerTest, CreateHeadersUncompressed) { |
| headers_ir.SetHeader("", "foo"); |
| headers_ir.SetHeader("foo", "bar"); |
| scoped_ptr<SpdyFrame> frame(framer.SerializeHeaders(headers_ir)); |
| - if (IsSpdy2()) { |
| - CompareFrame(kDescription, *frame, kV2FrameData, arraysize(kV2FrameData)); |
| - } else if (IsSpdy3()) { |
| + if (IsSpdy3()) { |
| CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData)); |
| } else { |
| CompareFrame(kDescription, *frame, kV4FrameData, arraysize(kV4FrameData)); |
| @@ -2853,18 +2437,6 @@ TEST_P(SpdyFramerTest, CreateHeadersUncompressed) { |
| { |
| const char kDescription[] = |
| "HEADERS frame with a 0-length header val, FIN, max stream ID"; |
| - |
| - const unsigned char kV2FrameData[] = { |
| - 0x80, spdy_version_ch_, 0x00, 0x08, |
| - 0x01, 0x00, 0x00, 0x19, |
| - 0x7f, 0xff, 0xff, 0xff, |
| - 0x00, 0x00, 0x00, 0x02, |
| - 0x00, 0x03, 'b', 'a', |
| - 'r', 0x00, 0x03, 'f', |
| - 'o', 'o', 0x00, 0x03, |
| - 'f', 'o', 'o', 0x00, |
| - 0x00 |
| - }; |
| const unsigned char kV3FrameData[] = { |
| 0x80, spdy_version_ch_, 0x00, 0x08, |
| 0x01, 0x00, 0x00, 0x21, |
| @@ -2891,9 +2463,7 @@ TEST_P(SpdyFramerTest, CreateHeadersUncompressed) { |
| headers_ir.SetHeader("bar", "foo"); |
| headers_ir.SetHeader("foo", ""); |
| scoped_ptr<SpdyFrame> frame(framer.SerializeHeaders(headers_ir)); |
| - if (IsSpdy2()) { |
| - CompareFrame(kDescription, *frame, kV2FrameData, arraysize(kV2FrameData)); |
| - } else if (IsSpdy3()) { |
| + if (IsSpdy3()) { |
| CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData)); |
| } else { |
| CompareFrame(kDescription, *frame, kV4FrameData, arraysize(kV4FrameData)); |
| @@ -2903,7 +2473,6 @@ TEST_P(SpdyFramerTest, CreateHeadersUncompressed) { |
| { |
| const char kDescription[] = |
| "HEADERS frame with a 0-length header val, FIN, max stream ID, pri"; |
| - |
| const unsigned char kV4FrameData[] = { |
| 0x00, 0x00, 0x14, 0x01, // Headers: FIN | END_HEADERS | PRIORITY |
| 0x25, 0x7f, 0xff, 0xff, // Stream 0x7fffffff |
| @@ -2921,9 +2490,8 @@ TEST_P(SpdyFramerTest, CreateHeadersUncompressed) { |
| headers_ir.SetHeader("bar", "foo"); |
| headers_ir.SetHeader("foo", ""); |
| scoped_ptr<SpdyFrame> frame(framer.SerializeHeaders(headers_ir)); |
| - if (IsSpdy2() || IsSpdy3()) { |
| - // HEADERS with priority not supported. |
| - } else { |
| + if (spdy_version_ > SPDY3) { |
| + // HEADERS with priority only supported in SPDY>3. |
| CompareFrame(kDescription, *frame, kV4FrameData, arraysize(kV4FrameData)); |
| } |
| } |
| @@ -2931,7 +2499,6 @@ TEST_P(SpdyFramerTest, CreateHeadersUncompressed) { |
| { |
| const char kDescription[] = |
| "HEADERS frame with a 0-length header name, FIN, max stream ID, padded"; |
| - |
| const unsigned char kV4FrameData[] = { |
| 0x00, 0x00, 0x15, 0x01, // Headers |
| 0x0d, 0x7f, 0xff, 0xff, // FIN | END_HEADERS | PADDED, Stream |
| @@ -2950,9 +2517,8 @@ TEST_P(SpdyFramerTest, CreateHeadersUncompressed) { |
| headers_ir.SetHeader("foo", "bar"); |
| headers_ir.set_padding_len(6); |
| scoped_ptr<SpdyFrame> frame(framer.SerializeHeaders(headers_ir)); |
| - if (IsSpdy2() || IsSpdy3()) { |
| - // Padding is not supported. |
| - } else { |
| + if (spdy_version_ > SPDY3) { |
| + // Padding only supported in SPDY>3. |
| CompareFrame(kDescription, *frame, kV4FrameData, arraysize(kV4FrameData)); |
| } |
| } |
| @@ -2962,29 +2528,15 @@ TEST_P(SpdyFramerTest, CreateHeadersUncompressed) { |
| // to workaround http://crbug.com/139744. |
| #if !defined(USE_SYSTEM_ZLIB) |
| TEST_P(SpdyFramerTest, CreateHeadersCompressed) { |
| + if (spdy_version_ > SPDY3) { |
| + // Deflate compression doesn't apply to HPACK. |
| + return; |
| + } |
| SpdyFramer framer(spdy_version_); |
| framer.set_enable_compression(true); |
| { |
| const char kDescription[] = "HEADERS frame, no FIN"; |
| - |
| - const unsigned char kV2FrameData[] = { |
| - 0x80, spdy_version_ch_, 0x00, 0x08, |
| - 0x00, 0x00, 0x00, 0x32, |
| - 0x00, 0x00, 0x00, 0x01, |
| - 0x00, 0x00, 0x38, 0xea, |
| - 0xdf, 0xa2, 0x51, 0xb2, |
| - 0x62, 0x60, 0x62, 0x60, |
| - 0x4e, 0x4a, 0x2c, 0x62, |
| - 0x60, 0x06, 0x08, 0xa0, |
| - 0xb4, 0xfc, 0x7c, 0x80, |
| - 0x00, 0x62, 0x60, 0x4e, |
| - 0xcb, 0xcf, 0x67, 0x60, |
| - 0x06, 0x08, 0xa0, 0xa4, |
| - 0xc4, 0x22, 0x80, 0x00, |
| - 0x02, 0x00, 0x00, 0x00, |
| - 0xff, 0xff, |
| - }; |
| const unsigned char kV3FrameData[] = { |
| 0x80, spdy_version_ch_, 0x00, 0x08, |
| 0x00, 0x00, 0x00, 0x31, |
| @@ -3002,22 +2554,6 @@ TEST_P(SpdyFramerTest, CreateHeadersCompressed) { |
| 0x00, 0x00, 0x00, 0xff, |
| 0xff, |
| }; |
| - const unsigned char kV2SIMDFrameData[] = { |
| - 0x80, spdy_version_ch_, 0x00, 0x08, |
| - 0x00, 0x00, 0x00, 0x2f, |
| - 0x00, 0x00, 0x00, 0x01, |
| - 0x00, 0x00, 0x38, 0xea, |
| - 0xdf, 0xa2, 0x51, 0xb2, |
| - 0x62, 0x60, 0x62, 0x60, |
| - 0x4e, 0x4a, 0x2c, 0x62, |
| - 0x60, 0x06, 0x08, 0xa0, |
| - 0xb4, 0xfc, 0x7c, 0x80, |
| - 0x00, 0x62, 0x60, 0x06, |
| - 0x13, 0x00, 0x01, 0x94, |
| - 0x94, 0x58, 0x04, 0x10, |
| - 0x40, 0x00, 0x00, 0x00, |
| - 0x00, 0xff, 0xff, |
| - }; |
| const unsigned char kV3SIMDFrameData[] = { |
| 0x80, spdy_version_ch_, 0x00, 0x08, |
| 0x00, 0x00, 0x00, 0x2c, |
| @@ -3040,30 +2576,14 @@ TEST_P(SpdyFramerTest, CreateHeadersCompressed) { |
| scoped_ptr<SpdyFrame> frame(framer.SerializeHeaders(headers_ir)); |
| const unsigned char* frame_data = |
| reinterpret_cast<const unsigned char*>(frame->data()); |
| - if (IsSpdy2()) { |
| - // Try comparing with SIMD version, if that fails, do a failing check |
| - // with pretty printing against non-SIMD version |
| - if (memcmp(frame_data, |
| - kV2SIMDFrameData, |
| - std::min(arraysize(kV2SIMDFrameData), frame->size())) != 0) { |
| - CompareCharArraysWithHexError(kDescription, |
| - frame_data, |
| - frame->size(), |
| - kV2FrameData, |
| - arraysize(kV2FrameData)); |
| - } |
| - } else if (IsSpdy3()) { |
| - if (memcmp(frame_data, |
| - kV3SIMDFrameData, |
| - std::min(arraysize(kV3SIMDFrameData), frame->size())) != 0) { |
| - CompareCharArraysWithHexError(kDescription, |
| - frame_data, |
| - frame->size(), |
| - kV3FrameData, |
| - arraysize(kV3FrameData)); |
| - } |
| - } else { |
| - // Deflate compression doesn't apply to HPACK. |
| + if (memcmp(frame_data, |
| + kV3SIMDFrameData, |
| + std::min(arraysize(kV3SIMDFrameData), frame->size())) != 0) { |
| + CompareCharArraysWithHexError(kDescription, |
| + frame_data, |
| + frame->size(), |
| + kV3FrameData, |
| + arraysize(kV3FrameData)); |
| } |
| } |
| } |
| @@ -3190,7 +2710,6 @@ TEST_P(SpdyFramerTest, CreatePushPromiseUncompressed) { |
| SpdyFramer framer(spdy_version_); |
| framer.set_enable_compression(false); |
| const char kDescription[] = "PUSH_PROMISE frame without padding"; |
| - |
| const unsigned char kFrameData[] = { |
| 0x00, 0x00, 0x16, 0x05, // PUSH_PROMISE |
| 0x04, 0x00, 0x00, 0x00, // END_HEADERS |
| @@ -3215,7 +2734,6 @@ TEST_P(SpdyFramerTest, CreatePushPromiseUncompressed) { |
| SpdyFramer framer(spdy_version_); |
| framer.set_enable_compression(false); |
| const char kDescription[] = "PUSH_PROMISE frame with one byte of padding"; |
| - |
| const unsigned char kFrameData[] = { |
| 0x00, 0x00, 0x17, 0x05, // PUSH_PROMISE |
| 0x0c, 0x00, 0x00, 0x00, // END_HEADERS | PADDED |
| @@ -3241,7 +2759,6 @@ TEST_P(SpdyFramerTest, CreatePushPromiseUncompressed) { |
| SpdyFramer framer(spdy_version_); |
| framer.set_enable_compression(false); |
| const char kDescription[] = "PUSH_PROMISE frame with 177 bytes of padding"; |
| - |
| const unsigned char kFrameData[] = { |
| 0x00, 0x00, 0xc7, 0x05, // PUSH_PROMISE |
| 0x0c, 0x00, 0x00, 0x00, // END_HEADERS | PADDED |
| @@ -3287,7 +2804,6 @@ TEST_P(SpdyFramerTest, CreateContinuationUncompressed) { |
| SpdyFramer framer(spdy_version_); |
| framer.set_enable_compression(false); |
| const char kDescription[] = "CONTINUATION frame"; |
| - |
| const unsigned char kFrameData[] = { |
| 0x00, 0x00, 0x12, 0x09, 0x00, // CONTINUATION |
| 0x00, 0x00, 0x00, 0x2a, // Stream 42 |
| @@ -3319,7 +2835,6 @@ TEST_P(SpdyFramerTest, CreatePushPromiseThenContinuationUncompressed) { |
| framer.set_enable_compression(false); |
| const char kDescription[] = |
| "PUSH_PROMISE and CONTINUATION frames with one byte of padding"; |
| - |
| const unsigned char kPartialPushPromiseFrameData[] = { |
| 0x00, 0x03, 0xf7, 0x05, // PUSH_PROMISE |
| 0x08, 0x00, 0x00, 0x00, // PADDED |
| @@ -3911,17 +3426,6 @@ TEST_P(SpdyFramerTest, ReadLargeSettingsFrame) { |
| TEST_P(SpdyFramerTest, ReadDuplicateSettings) { |
| SpdyFramer framer(spdy_version_); |
| - const unsigned char kV2FrameData[] = { |
| - 0x80, spdy_version_ch_, 0x00, 0x04, |
| - 0x00, 0x00, 0x00, 0x1C, |
| - 0x00, 0x00, 0x00, 0x03, |
| - 0x01, 0x00, 0x00, 0x00, // 1st Setting |
| - 0x00, 0x00, 0x00, 0x02, |
| - 0x01, 0x00, 0x00, 0x00, // 2nd (duplicate) Setting |
| - 0x00, 0x00, 0x00, 0x03, |
| - 0x03, 0x00, 0x00, 0x00, // 3rd (unprocessed) Setting |
| - 0x00, 0x00, 0x00, 0x03, |
| - }; |
| const unsigned char kV3FrameData[] = { |
| 0x80, spdy_version_ch_, 0x00, 0x04, |
| 0x00, 0x00, 0x00, 0x1C, |
| @@ -3946,9 +3450,7 @@ TEST_P(SpdyFramerTest, ReadDuplicateSettings) { |
| TestSpdyVisitor visitor(spdy_version_); |
| visitor.use_compression_ = false; |
| - if (IsSpdy2()) { |
| - visitor.SimulateInFramer(kV2FrameData, sizeof(kV2FrameData)); |
| - } else if (IsSpdy3()) { |
| + if (IsSpdy3()) { |
| visitor.SimulateInFramer(kV3FrameData, sizeof(kV3FrameData)); |
| } else { |
| visitor.SimulateInFramer(kV4FrameData, sizeof(kV4FrameData)); |
| @@ -3970,13 +3472,6 @@ TEST_P(SpdyFramerTest, ReadDuplicateSettings) { |
| TEST_P(SpdyFramerTest, ReadUnknownSettingsId) { |
| SpdyFramer framer(spdy_version_); |
| - const unsigned char kV2FrameData[] = { |
| - 0x80, spdy_version_ch_, 0x00, 0x04, |
| - 0x00, 0x00, 0x00, 0x1C, |
| - 0x00, 0x00, 0x00, 0x01, |
| - 0x10, 0x00, 0x00, 0x00, // 1st Setting |
| - 0x00, 0x00, 0x00, 0x02, |
| - }; |
| const unsigned char kV3FrameData[] = { |
| 0x80, spdy_version_ch_, 0x00, 0x04, |
| 0x00, 0x00, 0x00, 0x1C, |
| @@ -3993,9 +3488,7 @@ TEST_P(SpdyFramerTest, ReadUnknownSettingsId) { |
| TestSpdyVisitor visitor(spdy_version_); |
| visitor.use_compression_ = false; |
| - if (IsSpdy2()) { |
| - visitor.SimulateInFramer(kV2FrameData, sizeof(kV2FrameData)); |
| - } else if (IsSpdy3()) { |
| + if (IsSpdy3()) { |
| visitor.SimulateInFramer(kV3FrameData, sizeof(kV3FrameData)); |
| } else { |
| visitor.SimulateInFramer(kV4FrameData, sizeof(kV4FrameData)); |
| @@ -4015,17 +3508,6 @@ TEST_P(SpdyFramerTest, ReadUnknownSettingsId) { |
| TEST_P(SpdyFramerTest, ReadOutOfOrderSettings) { |
| SpdyFramer framer(spdy_version_); |
| - const unsigned char kV2FrameData[] = { |
| - 0x80, spdy_version_ch_, 0x00, 0x04, |
| - 0x00, 0x00, 0x00, 0x1C, |
| - 0x00, 0x00, 0x00, 0x03, |
| - 0x02, 0x00, 0x00, 0x00, // 1st Setting |
| - 0x00, 0x00, 0x00, 0x02, |
| - 0x01, 0x00, 0x00, 0x00, // 2nd (out of order) Setting |
| - 0x00, 0x00, 0x00, 0x03, |
| - 0x03, 0x00, 0x00, 0x00, // 3rd (unprocessed) Setting |
| - 0x00, 0x00, 0x00, 0x03, |
| - }; |
| const unsigned char kV3FrameData[] = { |
| 0x80, spdy_version_ch_, 0x00, 0x04, |
| 0x00, 0x00, 0x00, 0x1C, |
| @@ -4050,9 +3532,7 @@ TEST_P(SpdyFramerTest, ReadOutOfOrderSettings) { |
| TestSpdyVisitor visitor(spdy_version_); |
| visitor.use_compression_ = false; |
| - if (IsSpdy2()) { |
| - visitor.SimulateInFramer(kV2FrameData, sizeof(kV2FrameData)); |
| - } else if (IsSpdy3()) { |
| + if (IsSpdy3()) { |
| visitor.SimulateInFramer(kV3FrameData, sizeof(kV3FrameData)); |
| } else { |
| visitor.SimulateInFramer(kV4FrameData, sizeof(kV4FrameData)); |
| @@ -4165,7 +3645,7 @@ TEST_P(SpdyFramerTest, ReadWindowUpdate) { |
| } |
| TEST_P(SpdyFramerTest, ReceiveCredentialFrame) { |
| - if (!IsSpdy3()) { |
| + if (spdy_version_ > SPDY3) { |
| return; |
| } |
| SpdyFramer framer(spdy_version_); |
| @@ -4193,7 +3673,7 @@ TEST_P(SpdyFramerTest, ReceiveCredentialFrame) { |
| } |
| TEST_P(SpdyFramerTest, ReadCredentialFrameFollowedByAnotherFrame) { |
| - if (!IsSpdy3()) { |
| + if (spdy_version_ > SPDY3) { |
| return; |
| } |
| SpdyFramer framer(spdy_version_); |
| @@ -4696,12 +4176,12 @@ TEST_P(SpdyFramerTest, SizesTest) { |
| EXPECT_EQ(8u, framer.GetDataFrameMinimumSize()); |
| EXPECT_EQ(8u, framer.GetControlFrameHeaderSize()); |
| EXPECT_EQ(18u, framer.GetSynStreamMinimumSize()); |
| - EXPECT_EQ(IsSpdy2() ? 14u : 12u, framer.GetSynReplyMinimumSize()); |
| + EXPECT_EQ(12u, framer.GetSynReplyMinimumSize()); |
| EXPECT_EQ(16u, framer.GetRstStreamMinimumSize()); |
| EXPECT_EQ(12u, framer.GetSettingsMinimumSize()); |
| EXPECT_EQ(12u, framer.GetPingSize()); |
| - EXPECT_EQ(IsSpdy2() ? 12u : 16u, framer.GetGoAwayMinimumSize()); |
| - EXPECT_EQ(IsSpdy2() ? 14u : 12u, framer.GetHeadersMinimumSize()); |
| + EXPECT_EQ(16u, framer.GetGoAwayMinimumSize()); |
| + EXPECT_EQ(12u, framer.GetHeadersMinimumSize()); |
| EXPECT_EQ(16u, framer.GetWindowUpdateSize()); |
| EXPECT_EQ(8u, framer.GetFrameMinimumSize()); |
| EXPECT_EQ(16777223u, framer.GetFrameMaximumSize()); |
| @@ -4944,7 +4424,7 @@ TEST_P(SpdyFramerTest, DataFrameFlagsV4) { |
| } |
| TEST_P(SpdyFramerTest, SynStreamFrameFlags) { |
| - if (!IsSpdy2() && !IsSpdy3()) { |
| + if (spdy_version_ > SPDY3) { |
| // SYN_STREAM not supported in SPDY>3 |
| return; |
| } |
| @@ -4998,7 +4478,7 @@ TEST_P(SpdyFramerTest, SynStreamFrameFlags) { |
| } |
| TEST_P(SpdyFramerTest, SynReplyFrameFlags) { |
| - if (!IsSpdy2() && !IsSpdy3()) { |
| + if (spdy_version_ > SPDY3) { |
| // SYN_REPLY not supported in SPDY>3 |
| return; |
| } |
| @@ -5446,7 +4926,7 @@ TEST_P(SpdyFramerTest, ContinuationFrameFlags) { |
| // TODO(hkhalil): Add TEST_P(SpdyFramerTest, BlockedFrameFlags) |
| TEST_P(SpdyFramerTest, EmptySynStream) { |
| - if (!IsSpdy2() && !IsSpdy3()) { |
| + if (spdy_version_ > SPDY3) { |
| // SYN_STREAM not supported in SPDY>3. |
| return; |
| } |
| @@ -5480,7 +4960,7 @@ TEST_P(SpdyFramerTest, EmptySynStream) { |
| TEST_P(SpdyFramerTest, SettingsFlagsAndId) { |
| const uint32 kId = 0x020304; |
| const uint32 kFlags = 0x01; |
| - const uint32 kWireFormat = htonl(IsSpdy2() ? 0x04030201 : 0x01020304); |
| + const uint32 kWireFormat = htonl(0x01020304); |
| SettingsFlagsAndId id_and_flags = |
| SettingsFlagsAndId::FromWireFormat(spdy_version_, kWireFormat); |
| @@ -5557,9 +5037,6 @@ TEST_P(SpdyFramerTest, RstStreamStatusBounds) { |
| // Test handling of GOAWAY frames with out-of-bounds status code. |
| TEST_P(SpdyFramerTest, GoAwayStatusBounds) { |
| - if (spdy_version_ <= SPDY2) { |
| - return; |
| - } |
| SpdyFramer framer(spdy_version_); |
| const unsigned char kV3FrameData[] = { |
| @@ -5594,11 +5071,6 @@ TEST_P(SpdyFramerTest, GoAwayStatusBounds) { |
| // Tests handling of a GOAWAY frame with out-of-bounds stream ID. |
| TEST_P(SpdyFramerTest, GoAwayStreamIdBounds) { |
| - const unsigned char kV2FrameData[] = { |
| - 0x80, spdy_version_ch_, 0x00, 0x07, |
| - 0x00, 0x00, 0x00, 0x04, |
| - 0xff, 0xff, 0xff, 0xff, |
| - }; |
| const unsigned char kV3FrameData[] = { |
| 0x80, spdy_version_ch_, 0x00, 0x07, |
| 0x00, 0x00, 0x00, 0x08, |
| @@ -5618,10 +5090,7 @@ TEST_P(SpdyFramerTest, GoAwayStreamIdBounds) { |
| framer.set_visitor(&visitor); |
| EXPECT_CALL(visitor, OnGoAway(0x7fffffff, GOAWAY_OK)); |
| - if (IsSpdy2()) { |
| - framer.ProcessInput(reinterpret_cast<const char*>(kV2FrameData), |
| - arraysize(kV2FrameData)); |
| - } else if (IsSpdy3()) { |
| + if (IsSpdy3()) { |
| framer.ProcessInput(reinterpret_cast<const char*>(kV3FrameData), |
| arraysize(kV3FrameData)); |
| } else { |
