[SPDY] Enable tests for SPDY/3.1 and SPDY/4

net/spdy/spdy_stream_unittest.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <cstddef>
 #include <string>
 #include <vector>
 
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 119 matching lines @@
 INSTANTIATE_TEST_CASE_P(
     NextProto,
     SpdyStreamTest,
     testing::Values(kProtoSPDY2, kProtoSPDY3, kProtoSPDY31, kProtoSPDY4a2));
 
 TEST_P(SpdyStreamTest, SendDataAfterOpen) {
   GURL url(kStreamUrl);
 
   session_ = SpdySessionDependencies::SpdyCreateSession(&session_deps_);
 
-  scoped_ptr<SpdyFrame> initial_window_update(
-      spdy_util_.ConstructSpdyWindowUpdate(
-          kSessionFlowControlStreamId,
-          kDefaultInitialRecvWindowSize - kSpdySessionInitialWindowSize));
-  if (spdy_util_.protocol() >= kProtoSPDY31)
-    AddWrite(*initial_window_update);
-
   scoped_ptr<SpdyFrame> req(
       spdy_util_.ConstructSpdyPost(
           kStreamUrl, 1, kPostBodyLength, LOWEST, NULL, 0));
   AddWrite(*req);
 
   scoped_ptr<SpdyFrame> resp(
       spdy_util_.ConstructSpdyPostSynReply(NULL, 0));
   AddRead(*resp);
 
   scoped_ptr<SpdyFrame> msg(
@@ skipping 42 matching lines @@
             delegate.GetResponseHeaderValue(spdy_util_.GetVersionKey()));
   EXPECT_EQ(std::string(kPostBody, kPostBodyLength),
             delegate.TakeReceivedData());
   EXPECT_TRUE(data.at_write_eof());
 }
 
 TEST_P(SpdyStreamTest, PushedStream) {
   session_ = SpdySessionDependencies::SpdyCreateSession(&session_deps_);
   scoped_refptr<SpdySession> spdy_session(CreateSpdySession());
 
-  scoped_ptr<SpdyFrame> initial_window_update(
-      spdy_util_.ConstructSpdyWindowUpdate(
-          kSessionFlowControlStreamId,
-          kDefaultInitialRecvWindowSize - kSpdySessionInitialWindowSize));
-  if (spdy_util_.protocol() >= kProtoSPDY31)
-    AddWrite(*initial_window_update);
-
   AddReadEOF();
 
   OrderedSocketData data(GetReads(), GetNumReads(),
                          GetWrites(), GetNumWrites());
   MockConnect connect_data(SYNCHRONOUS, OK);
   data.set_connect_data(connect_data);
 
   session_deps_.socket_factory->AddSocketDataProvider(&data);
 
   InitializeSpdySession(spdy_session, host_port_pair_);
@@ skipping 34 matching lines @@
 
   spdy_session->CloseSessionOnError(
       ERR_CONNECTION_CLOSED, true, "Closing session");
 }
 
 TEST_P(SpdyStreamTest, StreamError) {
   GURL url(kStreamUrl);
 
   session_ = SpdySessionDependencies::SpdyCreateSession(&session_deps_);
 
-  scoped_ptr<SpdyFrame> initial_window_update(
-      spdy_util_.ConstructSpdyWindowUpdate(
-          kSessionFlowControlStreamId,
-          kDefaultInitialRecvWindowSize - kSpdySessionInitialWindowSize));
-  if (spdy_util_.protocol() >= kProtoSPDY31)
-    AddWrite(*initial_window_update);
-
   scoped_ptr<SpdyFrame> req(
       spdy_util_.ConstructSpdyPost(
           kStreamUrl, 1, kPostBodyLength, LOWEST, NULL, 0));
   AddWrite(*req);
 
   scoped_ptr<SpdyFrame> resp(
       spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
   AddRead(*resp);
 
   scoped_ptr<SpdyFrame> msg(
@@ skipping 65 matching lines @@
 }
 
 // Make sure that large blocks of data are properly split up into
 // frame-sized chunks for a request/response (i.e., an HTTP-like)
 // stream.
 TEST_P(SpdyStreamTest, SendLargeDataAfterOpenRequestResponse) {
   GURL url(kStreamUrl);
 
   session_ = SpdySessionDependencies::SpdyCreateSession(&session_deps_);
 
-  scoped_ptr<SpdyFrame> initial_window_update(
-      spdy_util_.ConstructSpdyWindowUpdate(
-          kSessionFlowControlStreamId,
-          kDefaultInitialRecvWindowSize - kSpdySessionInitialWindowSize));
-  if (spdy_util_.protocol() >= kProtoSPDY31)
-    AddWrite(*initial_window_update);
-
   scoped_ptr<SpdyFrame> req(
       spdy_util_.ConstructSpdyPost(
           kStreamUrl, 1, kPostBodyLength, LOWEST, NULL, 0));
   AddWrite(*req);
 
   std::string chunk_data(kMaxSpdyFrameChunkSize, 'x');
   scoped_ptr<SpdyFrame> chunk(
       spdy_util_.ConstructSpdyBodyFrame(
           1, chunk_data.data(), chunk_data.length(), false));
   AddWrite(*chunk);
@@ skipping 49 matching lines @@
 }
 
 // Make sure that large blocks of data are properly split up into
 // frame-sized chunks for a bidirectional (i.e., non-HTTP-like)
 // stream.
 TEST_P(SpdyStreamTest, SendLargeDataAfterOpenBidirectional) {
   GURL url(kStreamUrl);
 
   session_ = SpdySessionDependencies::SpdyCreateSession(&session_deps_);
 
-  scoped_ptr<SpdyFrame> initial_window_update(
-      spdy_util_.ConstructSpdyWindowUpdate(
-          kSessionFlowControlStreamId,
-          kDefaultInitialRecvWindowSize - kSpdySessionInitialWindowSize));
-  if (spdy_util_.protocol() >= kProtoSPDY31)
-    AddWrite(*initial_window_update);
-
   scoped_ptr<SpdyFrame> req(
       spdy_util_.ConstructSpdyPost(
           kStreamUrl, 1, kPostBodyLength, LOWEST, NULL, 0));
   AddWrite(*req);
 
   scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyPostSynReply(NULL, 0));
   AddRead(*resp);
 
   std::string chunk_data(kMaxSpdyFrameChunkSize, 'x');
   scoped_ptr<SpdyFrame> chunk(
@@ skipping 45 matching lines @@
 }
 
 // Receiving a header with uppercase ASCII should result in a protocol
 // error.
 TEST_P(SpdyStreamTest, UpperCaseHeaders) {
   GURL url(kStreamUrl);
 
   session_ =
       SpdySessionDependencies::SpdyCreateSessionDeterministic(&session_deps_);
 
-  scoped_ptr<SpdyFrame> initial_window_update(
-      spdy_util_.ConstructSpdyWindowUpdate(
-          kSessionFlowControlStreamId,
-          kDefaultInitialRecvWindowSize - kSpdySessionInitialWindowSize));
-  if (spdy_util_.protocol() >= kProtoSPDY31)
-    AddWrite(*initial_window_update);
-
   scoped_ptr<SpdyFrame> syn(
       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
   AddWrite(*syn);
 
   const char* const kExtraHeaders[] = {"X-UpperCase", "yes"};
   scoped_ptr<SpdyFrame>
       reply(spdy_util_.ConstructSpdyGetSynReply(kExtraHeaders, 1, 1));
   AddRead(*reply);
 
   scoped_ptr<SpdyFrame> rst(
@@ skipping 23 matching lines @@
 
   EXPECT_FALSE(stream->HasUrl());
 
   scoped_ptr<SpdyHeaderBlock> headers(
       spdy_util_.ConstructGetHeaderBlock(kStreamUrl));
   EXPECT_EQ(ERR_IO_PENDING,
             stream->SendRequestHeaders(headers.Pass(), NO_MORE_DATA_TO_SEND));
   EXPECT_TRUE(stream->HasUrl());
   EXPECT_EQ(kStreamUrl, stream->GetUrl().spec());
 
-  // For the initial window update.
-  if (spdy_util_.protocol() >= kProtoSPDY31)
-    data.RunFor(1);
-
   data.RunFor(4);
 
   EXPECT_EQ(ERR_SPDY_PROTOCOL_ERROR, delegate.WaitForClose());
 }
 
 // Receiving a header with uppercase ASCII should result in a protocol
 // error even for a push stream.
 TEST_P(SpdyStreamTest, UpperCaseHeadersOnPush) {
   GURL url(kStreamUrl);
 
   session_ =
       SpdySessionDependencies::SpdyCreateSessionDeterministic(&session_deps_);
 
-  scoped_ptr<SpdyFrame> initial_window_update(
-      spdy_util_.ConstructSpdyWindowUpdate(
-          kSessionFlowControlStreamId,
-          kDefaultInitialRecvWindowSize - kSpdySessionInitialWindowSize));
-  if (spdy_util_.protocol() >= kProtoSPDY31)
-    AddWrite(*initial_window_update);
-
   scoped_ptr<SpdyFrame> syn(
       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
   AddWrite(*syn);
 
   scoped_ptr<SpdyFrame>
       reply(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
   AddRead(*reply);
 
   const char* const extra_headers[] = {"X-UpperCase", "yes"};
   scoped_ptr<SpdyFrame>
@@ skipping 27 matching lines @@
 
   EXPECT_FALSE(stream->HasUrl());
 
   scoped_ptr<SpdyHeaderBlock> headers(
       spdy_util_.ConstructGetHeaderBlock(kStreamUrl));
   EXPECT_EQ(ERR_IO_PENDING,
             stream->SendRequestHeaders(headers.Pass(), NO_MORE_DATA_TO_SEND));
   EXPECT_TRUE(stream->HasUrl());
   EXPECT_EQ(kStreamUrl, stream->GetUrl().spec());
 
-  // For the initial window update.
-  if (spdy_util_.protocol() >= kProtoSPDY31)
-    data.RunFor(1);
-
   data.RunFor(4);
 
   base::WeakPtr<SpdyStream> push_stream;
   EXPECT_EQ(OK, session->GetPushStream(url, &push_stream, BoundNetLog()));
   EXPECT_FALSE(push_stream);
 
   data.RunFor(1);
 
   EXPECT_EQ(ERR_CONNECTION_CLOSED, delegate.WaitForClose());
 }
 
 // Receiving a header with uppercase ASCII in a HEADERS frame should
 // result in a protocol error.
 TEST_P(SpdyStreamTest, UpperCaseHeadersInHeadersFrame) {
   GURL url(kStreamUrl);
 
   session_ =
       SpdySessionDependencies::SpdyCreateSessionDeterministic(&session_deps_);
 
-  scoped_ptr<SpdyFrame> initial_window_update(
-      spdy_util_.ConstructSpdyWindowUpdate(
-          kSessionFlowControlStreamId,
-          kDefaultInitialRecvWindowSize - kSpdySessionInitialWindowSize));
-  if (spdy_util_.protocol() >= kProtoSPDY31)
-    AddWrite(*initial_window_update);
-
   scoped_ptr<SpdyFrame> syn(
       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
   AddWrite(*syn);
 
   scoped_ptr<SpdyFrame>
       reply(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
   AddRead(*reply);
 
   scoped_ptr<SpdyFrame>
       push(spdy_util_.ConstructSpdyPush(NULL, 0, 2, 1, kStreamUrl));
@@ skipping 38 matching lines @@
 
   EXPECT_FALSE(stream->HasUrl());
 
   scoped_ptr<SpdyHeaderBlock> headers(
       spdy_util_.ConstructGetHeaderBlock(kStreamUrl));
   EXPECT_EQ(ERR_IO_PENDING,
             stream->SendRequestHeaders(headers.Pass(), NO_MORE_DATA_TO_SEND));
   EXPECT_TRUE(stream->HasUrl());
   EXPECT_EQ(kStreamUrl, stream->GetUrl().spec());
 
-  // For the initial window update.
-  if (spdy_util_.protocol() >= kProtoSPDY31)
-    data.RunFor(1);
-
   data.RunFor(3);
 
   base::WeakPtr<SpdyStream> push_stream;
   EXPECT_EQ(OK, session->GetPushStream(url, &push_stream, BoundNetLog()));
   EXPECT_TRUE(push_stream);
 
   data.RunFor(1);
 
   EXPECT_EQ(OK, session->GetPushStream(url, &push_stream, BoundNetLog()));
   EXPECT_FALSE(push_stream);
 
   data.RunFor(2);
 
   EXPECT_EQ(ERR_CONNECTION_CLOSED, delegate.WaitForClose());
 }
 
 // Receiving a duplicate header in a HEADERS frame should result in a
 // protocol error.
 TEST_P(SpdyStreamTest, DuplicateHeaders) {
   GURL url(kStreamUrl);
 
   session_ =
       SpdySessionDependencies::SpdyCreateSessionDeterministic(&session_deps_);
 
-  scoped_ptr<SpdyFrame> initial_window_update(
-      spdy_util_.ConstructSpdyWindowUpdate(
-          kSessionFlowControlStreamId,
-          kDefaultInitialRecvWindowSize - kSpdySessionInitialWindowSize));
-  if (spdy_util_.protocol() >= kProtoSPDY31)
-    AddWrite(*initial_window_update);
-
   scoped_ptr<SpdyFrame> syn(
       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
   AddWrite(*syn);
 
   scoped_ptr<SpdyFrame>
       reply(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
   AddRead(*reply);
 
   scoped_ptr<SpdyFrame>
       push(spdy_util_.ConstructSpdyPush(NULL, 0, 2, 1, kStreamUrl));
@@ skipping 38 matching lines @@
 
   EXPECT_FALSE(stream->HasUrl());
 
   scoped_ptr<SpdyHeaderBlock> headers(
       spdy_util_.ConstructGetHeaderBlock(kStreamUrl));
   EXPECT_EQ(ERR_IO_PENDING,
             stream->SendRequestHeaders(headers.Pass(), NO_MORE_DATA_TO_SEND));
   EXPECT_TRUE(stream->HasUrl());
   EXPECT_EQ(kStreamUrl, stream->GetUrl().spec());
 
-  // For the initial window update.
-  if (spdy_util_.protocol() >= kProtoSPDY31)
-    data.RunFor(1);
-
   data.RunFor(3);
 
   base::WeakPtr<SpdyStream> push_stream;
   EXPECT_EQ(OK, session->GetPushStream(url, &push_stream, BoundNetLog()));
   EXPECT_TRUE(push_stream);
 
   data.RunFor(1);
 
   EXPECT_EQ(OK, session->GetPushStream(url, &push_stream, BoundNetLog()));
   EXPECT_FALSE(push_stream);
 
   data.RunFor(2);
 
   EXPECT_EQ(ERR_CONNECTION_CLOSED, delegate.WaitForClose());
 }
 
 // The tests below are only for SPDY/3 and above.
 
 // Call IncreaseSendWindowSize on a stream with a large enough delta
 // to overflow an int32. The SpdyStream should handle that case
 // gracefully.
 TEST_P(SpdyStreamTest, IncreaseSendWindowSizeOverflow) {
   if (spdy_util_.protocol() < kProtoSPDY3)
     return;
 
   session_ =
       SpdySessionDependencies::SpdyCreateSessionDeterministic(&session_deps_);
 
-  scoped_ptr<SpdyFrame> initial_window_update(
-      spdy_util_.ConstructSpdyWindowUpdate(
-          kSessionFlowControlStreamId,
-          kDefaultInitialRecvWindowSize - kSpdySessionInitialWindowSize));
-  if (spdy_util_.protocol() >= kProtoSPDY31)
-    AddWrite(*initial_window_update);
-
   scoped_ptr<SpdyFrame> req(
       spdy_util_.ConstructSpdyPost(
           kStreamUrl, 1, kPostBodyLength, LOWEST, NULL, 0));
   AddWrite(*req);
 
   // Triggered by the overflowing call to IncreaseSendWindowSize
   // below.
   scoped_ptr<SpdyFrame> rst(
       spdy_util_.ConstructSpdyRstStream(1, RST_STREAM_FLOW_CONTROL_ERROR));
   AddWrite(*rst);
@@ skipping 21 matching lines @@
   StreamDelegateSendImmediate delegate(stream, kPostBodyStringPiece);
   stream->SetDelegate(&delegate);
 
   scoped_ptr<SpdyHeaderBlock> headers(
       spdy_util_.ConstructPostHeaderBlock(kStreamUrl, kPostBodyLength));
   EXPECT_EQ(ERR_IO_PENDING,
             stream->SendRequestHeaders(headers.Pass(), MORE_DATA_TO_SEND));
   EXPECT_TRUE(stream->HasUrl());
   EXPECT_EQ(kStreamUrl, stream->GetUrl().spec());
 
-  // For the initial window update.
-  if (spdy_util_.protocol() >= kProtoSPDY31)
-    data.RunFor(1);
-
   data.RunFor(1);
 
   int32 old_send_window_size = stream->send_window_size();
   ASSERT_GT(old_send_window_size, 0);
   int32 delta_window_size = kint32max - old_send_window_size + 1;
   stream->IncreaseSendWindowSize(delta_window_size);
   EXPECT_EQ(NULL, stream.get());
 
   data.RunFor(2);
 
@@ skipping 28 matching lines @@
   EXPECT_TRUE(stream->send_stalled_by_flow_control());
   stream->AdjustSendWindowSize(+delta_window_size);
   EXPECT_FALSE(stream->send_stalled_by_flow_control());
 }
 
 // Given an unstall function, runs a test to make sure that a
 // request/response (i.e., an HTTP-like) stream resumes after a stall
 // and unstall.
 void SpdyStreamTest::RunResumeAfterUnstallRequestResponseTest(
     const UnstallFunction& unstall_function) {
-  if (spdy_util_.protocol() < kProtoSPDY3)
-    return;
-
   GURL url(kStreamUrl);
 
   session_ =
       SpdySessionDependencies::SpdyCreateSessionDeterministic(&session_deps_);
 
-  scoped_ptr<SpdyFrame> initial_window_update(
-      spdy_util_.ConstructSpdyWindowUpdate(
-          kSessionFlowControlStreamId,
-          kDefaultInitialRecvWindowSize - kSpdySessionInitialWindowSize));
-  if (spdy_util_.protocol() >= kProtoSPDY31)
-    AddWrite(*initial_window_update);
-
   scoped_ptr<SpdyFrame> req(
       spdy_util_.ConstructSpdyPost(
           kStreamUrl, 1, kPostBodyLength, LOWEST, NULL, 0));
   AddWrite(*req);
 
   scoped_ptr<SpdyFrame> body(
       spdy_util_.ConstructSpdyBodyFrame(1, kPostBody, kPostBodyLength, true));
   AddWrite(*body);
 
   scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
@@ skipping 25 matching lines @@
 
   scoped_ptr<SpdyHeaderBlock> headers(
       spdy_util_.ConstructPostHeaderBlock(kStreamUrl, kPostBodyLength));
   EXPECT_EQ(ERR_IO_PENDING,
             stream->SendRequestHeaders(headers.Pass(), MORE_DATA_TO_SEND));
   EXPECT_TRUE(stream->HasUrl());
   EXPECT_EQ(kStreamUrl, stream->GetUrl().spec());
 
   StallStream(stream);
 
-  // For the initial window update.
-  if (spdy_util_.protocol() >= kProtoSPDY31)
-    data.RunFor(1);
-
   data.RunFor(1);
 
   EXPECT_TRUE(stream->send_stalled_by_flow_control());
 
   unstall_function.Run(stream, kPostBodyLength);
 
   EXPECT_FALSE(stream->send_stalled_by_flow_control());
 
   data.RunFor(3);
 
   EXPECT_EQ(ERR_CONNECTION_CLOSED, delegate.WaitForClose());
 
   EXPECT_TRUE(delegate.send_headers_completed());
   EXPECT_EQ("200", delegate.GetResponseHeaderValue(":status"));
   EXPECT_EQ("HTTP/1.1", delegate.GetResponseHeaderValue(":version"));
   EXPECT_EQ(std::string(), delegate.TakeReceivedData());
   EXPECT_TRUE(data.at_write_eof());
 }
 
 TEST_P(SpdyStreamTest, ResumeAfterSendWindowSizeIncreaseRequestResponse) {
+  if (spdy_util_.protocol() < kProtoSPDY3)
+    return;
+
   RunResumeAfterUnstallRequestResponseTest(
       base::Bind(&IncreaseStreamSendWindowSize));
 }
 
 TEST_P(SpdyStreamTest, ResumeAfterSendWindowSizeAdjustRequestResponse) {
+  if (spdy_util_.protocol() < kProtoSPDY3)
+    return;
+
   RunResumeAfterUnstallRequestResponseTest(
       base::Bind(&AdjustStreamSendWindowSize));
 }
 
 // Given an unstall function, runs a test to make sure that a
 // bidirectional (i.e., non-HTTP-like) stream resumes after a stall
 // and unstall.
 void SpdyStreamTest::RunResumeAfterUnstallBidirectionalTest(
     const UnstallFunction& unstall_function) {
-  if (spdy_util_.protocol() < kProtoSPDY3)
-    return;
-
   GURL url(kStreamUrl);
 
   session_ =
       SpdySessionDependencies::SpdyCreateSessionDeterministic(&session_deps_);
 
-  scoped_ptr<SpdyFrame> initial_window_update(
-      spdy_util_.ConstructSpdyWindowUpdate(
-          kSessionFlowControlStreamId,
-          kDefaultInitialRecvWindowSize - kSpdySessionInitialWindowSize));
-  if (spdy_util_.protocol() >= kProtoSPDY31)
-    AddWrite(*initial_window_update);
-
   scoped_ptr<SpdyFrame> req(
       spdy_util_.ConstructSpdyPost(
           kStreamUrl, 1, kPostBodyLength, LOWEST, NULL, 0));
   AddWrite(*req);
 
   scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
   AddRead(*resp);
 
   scoped_ptr<SpdyFrame> msg(
       spdy_util_.ConstructSpdyBodyFrame(1, kPostBody, kPostBodyLength, false));
@@ skipping 32 matching lines @@
             stream->SendRequestHeaders(headers.Pass(), MORE_DATA_TO_SEND));
   EXPECT_TRUE(stream->HasUrl());
   EXPECT_EQ(kStreamUrl, stream->GetUrl().spec());
 
   data.RunFor(1);
 
   EXPECT_FALSE(stream->send_stalled_by_flow_control());
 
   StallStream(stream);
 
-  // For the initial window update.
-  if (spdy_util_.protocol() >= kProtoSPDY31)
-    data.RunFor(1);
-
   data.RunFor(1);
 
   EXPECT_TRUE(stream->send_stalled_by_flow_control());
 
   unstall_function.Run(stream, kPostBodyLength);
 
   EXPECT_FALSE(stream->send_stalled_by_flow_control());
 
   data.RunFor(3);
 
   EXPECT_EQ(ERR_CONNECTION_CLOSED, delegate.WaitForClose());
 
   EXPECT_TRUE(delegate.send_headers_completed());
   EXPECT_EQ("200", delegate.GetResponseHeaderValue(":status"));
   EXPECT_EQ("HTTP/1.1", delegate.GetResponseHeaderValue(":version"));
   EXPECT_EQ(std::string(kPostBody, kPostBodyLength),
             delegate.TakeReceivedData());
   EXPECT_TRUE(data.at_write_eof());
 }
 
 TEST_P(SpdyStreamTest, ResumeAfterSendWindowSizeIncreaseBidirectional) {
+  if (spdy_util_.protocol() < kProtoSPDY3)
+    return;
+
   RunResumeAfterUnstallBidirectionalTest(
       base::Bind(&IncreaseStreamSendWindowSize));
 }
 
 TEST_P(SpdyStreamTest, ResumeAfterSendWindowSizeAdjustBidirectional) {
+  if (spdy_util_.protocol() < kProtoSPDY3)
+    return;
+
   RunResumeAfterUnstallBidirectionalTest(
       base::Bind(&AdjustStreamSendWindowSize));
 }
 
 }  // namespace
 
 }  // namespace test
 
 }  // namespace net