net/spdy/spdy_framer_test.cc - Issue 710713002: Remove SPDY2 and SPDY/3.0 from tests.

Unified Diff: net/spdy/spdy_framer_test.cc

Issue 710713002: Remove SPDY2 and SPDY/3.0 from tests. (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master

Patch Set: Created 6 years, 1 month ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View side-by-side diff with in-line comments

Download patch

Index: net/spdy/spdy_framer_test.cc

diff --git a/net/spdy/spdy_framer_test.cc b/net/spdy/spdy_framer_test.cc

index 7a1c3df87b26bba71ce1668876cbcb0db2c7fb99..4b991da8bd3acb4285cb1cc3507f15856f8ec38f 100644

--- a/net/spdy/spdy_framer_test.cc

+++ b/net/spdy/spdy_framer_test.cc

@@ -664,7 +664,6 @@ class SpdyFramerTest : public ::testing::TestWithParam<SpdyMajorVersion> {

return true;

}

- bool IsSpdy2() { return spdy_version_ == SPDY2; }

bool IsSpdy3() { return spdy_version_ == SPDY3; }

bool IsSpdy4() { return spdy_version_ == SPDY4; }

bool IsSpdy5() { return spdy_version_ == SPDY5; }

@@ -674,10 +673,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) {

@@ -869,19 +867,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);

@@ -915,11 +905,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;

@@ -968,21 +954,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 =

@@ -1004,21 +981,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);

@@ -1052,59 +1020,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,

- 0x80, spdy_version_ch_, 0x00, 0x01, // SYN Stream #3

- 0x00, 0x00, 0x00, 0x0c,

- 0x00, 0x00, 0x00, 0x03,

- 0x00, 0x00, 0x00, 0x00,

- 0x00, 0x00, 0x00, 0x03, // DATA on Stream #3

- 0x00, 0x00, 0x00, 0x08,

- 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,

@@ -1217,9 +1132,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));

@@ -1248,32 +1161,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, 0x02, 'a', 'a',

- 0x00, 0x02, 'b', 'b',

- 0x00, 0x00, 0x00, 0x01, // DATA on Stream #1

- 0x00, 0x00, 0x00, 0x0c,

- 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,

@@ -1330,9 +1217,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));

@@ -1356,24 +1241,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,

@@ -1409,9 +1276,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));

@@ -1883,7 +1748,7 @@ TEST_P(SpdyFramerTest, CreateDataFrame) {

}

TEST_P(SpdyFramerTest, CreateSynStreamUncompressed) {

- if (!IsSpdy2() && !IsSpdy3()) {

+ if (!IsSpdy3()) {

// SYN_STREAM unsupported in SPDY>3

return;

}

@@ -1892,20 +1757,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,

@@ -1926,32 +1778,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,

- 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,

@@ -1973,33 +1806,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,

- 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,

@@ -2021,13 +1835,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));

}

@@ -2035,7 +1843,7 @@ TEST_P(SpdyFramerTest, CreateSynStreamUncompressed) {

// to workaround http://crbug.com/139744.

#if !defined(USE_SYSTEM_ZLIB)

TEST_P(SpdyFramerTest, CreateSynStreamCompressed) {

- if (!IsSpdy2() && !IsSpdy3()) {

+ if (!IsSpdy3()) {

// SYN_STREAM not supported for SPDY>3

return;

}

@@ -2045,26 +1853,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,

@@ -2083,23 +1873,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,

@@ -2125,37 +1898,21 @@ 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));

}

#endif // !defined(USE_SYSTEM_ZLIB)

TEST_P(SpdyFramerTest, CreateSynReplyUncompressed) {

- if (spdy_version_ > SPDY3) {

+ if (!IsSpdy3()) {

asanka 2014/11/10 19:18:37 Nit: IMHO assuming the numerical value of the Spdy

Bence 2014/11/10 22:52:09 Done.

// SYN_REPLY unsupported in SPDY>3

return;

}

@@ -2164,18 +1921,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,

@@ -2193,30 +1938,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,

@@ -2235,30 +1962,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,

@@ -2277,13 +1986,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));

}

@@ -2291,7 +1994,7 @@ TEST_P(SpdyFramerTest, CreateSynReplyUncompressed) {

// to workaround http://crbug.com/139744.

#if !defined(USE_SYSTEM_ZLIB)

TEST_P(SpdyFramerTest, CreateSynReplyCompressed) {

- if (spdy_version_ > SPDY3) {

+ if (!IsSpdy3()) {

// SYN_REPLY unsupported in SPDY>3

return;

}

@@ -2300,24 +2003,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,

@@ -2335,22 +2020,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,

@@ -2373,30 +2042,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));

}

@@ -2484,14 +2137,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,

@@ -2521,9 +2166,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));

@@ -2532,20 +2175,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,

@@ -2594,9 +2223,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));

@@ -2605,7 +2232,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,

@@ -2677,11 +2303,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,

@@ -2697,9 +2318,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));

@@ -2708,11 +2327,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,

@@ -2728,9 +2342,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));

@@ -2744,18 +2356,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,

@@ -2782,9 +2382,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));

@@ -2794,18 +2392,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,

@@ -2832,9 +2418,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));

@@ -2844,18 +2428,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,

@@ -2882,9 +2454,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));

@@ -2894,7 +2464,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

@@ -2912,7 +2481,7 @@ TEST_P(SpdyFramerTest, CreateHeadersUncompressed) {

headers_ir.SetHeader("bar", "foo");

headers_ir.SetHeader("foo", "");

scoped_ptr<SpdyFrame> frame(framer.SerializeHeaders(headers_ir));

- if (IsSpdy2() || IsSpdy3()) {

+ if (IsSpdy3()) {

// HEADERS with priority not supported.

} else {

CompareFrame(kDescription, *frame, kV4FrameData, arraysize(kV4FrameData));

@@ -2922,7 +2491,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

@@ -2941,7 +2509,7 @@ 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()) {

+ if (IsSpdy3()) {

// Padding is not supported.

} else {

CompareFrame(kDescription, *frame, kV4FrameData, arraysize(kV4FrameData));

@@ -2953,29 +2521,15 @@ TEST_P(SpdyFramerTest, CreateHeadersUncompressed) {

// to workaround http://crbug.com/139744.

#if !defined(USE_SYSTEM_ZLIB)

TEST_P(SpdyFramerTest, CreateHeadersCompressed) {

+ if (!IsSpdy3()) {

+ // 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,

@@ -2993,22 +2547,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,

@@ -3031,30 +2569,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));

}

@@ -3181,7 +2703,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

@@ -3206,7 +2727,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

@@ -3232,7 +2752,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

@@ -3278,7 +2797,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

@@ -3310,7 +2828,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

@@ -3902,17 +3419,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,

@@ -3937,9 +3443,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));

@@ -3961,13 +3465,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,

@@ -3984,9 +3481,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));

@@ -4006,17 +3501,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,

@@ -4041,9 +3525,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));

@@ -4687,12 +4169,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());

@@ -4935,7 +4417,7 @@ TEST_P(SpdyFramerTest, DataFrameFlagsV4) {

}

TEST_P(SpdyFramerTest, SynStreamFrameFlags) {

- if (!IsSpdy2() && !IsSpdy3()) {

+ if (!IsSpdy3()) {

// SYN_STREAM not supported in SPDY>3

return;

}

@@ -4989,7 +4471,7 @@ TEST_P(SpdyFramerTest, SynStreamFrameFlags) {

}

TEST_P(SpdyFramerTest, SynReplyFrameFlags) {

- if (!IsSpdy2() && !IsSpdy3()) {

+ if (!IsSpdy3()) {

// SYN_REPLY not supported in SPDY>3

return;

}

@@ -5436,7 +4918,7 @@ TEST_P(SpdyFramerTest, ContinuationFrameFlags) {

// TODO(hkhalil): Add TEST_P(SpdyFramerTest, BlockedFrameFlags)

TEST_P(SpdyFramerTest, EmptySynStream) {

- if (!IsSpdy2() && !IsSpdy3()) {

+ if (!IsSpdy3()) {

// SYN_STREAM not supported in SPDY>3.

return;

}

@@ -5470,7 +4952,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);

@@ -5547,9 +5029,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[] = {

@@ -5584,11 +5063,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,

@@ -5608,10 +5082,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 {

« net/http/http_network_transaction_unittest.cc ('K') | « net/spdy/spdy_frame_builder_test.cc ('k') | net/spdy/spdy_headers_block_parser_test.cc » ('j') | net/spdy/spdy_http_utils.cc » ('J')