http2: Update priorities of pushed streams

net/spdy/spdy_network_transaction_unittest.cc

 // Copyright (c) 2012 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 <cmath>
 #include <memory>
 #include <string>
 #include <utility>
 #include <vector>
 
@@ skipping 1876 matching lines @@
   EXPECT_THAT(out.rv, IsError(ERR_SPDY_PROTOCOL_ERROR));
 
   helper.session()->spdy_session_pool()->CloseAllSessions();
   helper.VerifyDataConsumed();
 }
 
 TEST_F(SpdyNetworkTransactionTest, ResetPushWithTransferEncoding) {
   // Construct the request.
   SpdySerializedFrame req(
       spdy_util_.ConstructSpdyGet(nullptr, 0, 1, LOWEST, true));
+  SpdySerializedFrame priority(
+      spdy_util_.ConstructSpdyPriority(2, 1, IDLE, true));
   SpdySerializedFrame rst(
       spdy_util_.ConstructSpdyRstStream(2, RST_STREAM_PROTOCOL_ERROR));
   MockWrite writes[] = {
-      CreateMockWrite(req, 0), CreateMockWrite(rst, 4),
+      CreateMockWrite(req, 0), CreateMockWrite(priority, 3),
+      CreateMockWrite(rst, 5),
   };
 
   SpdySerializedFrame resp(spdy_util_.ConstructSpdyGetReply(NULL, 0, 1));
   const char* const headers[] = {
     "transfer-encoding", "chunked"
   };
   SpdySerializedFrame push(
       spdy_util_.ConstructSpdyPush(headers, arraysize(headers) / 2, 2, 1,
                                    GetDefaultUrlWithPath("/1").c_str()));
   SpdySerializedFrame body(spdy_util_.ConstructSpdyDataFrame(1, true));
   MockRead reads[] = {
-      CreateMockRead(resp, 1), CreateMockRead(push, 2), CreateMockRead(body, 3),
-      MockRead(ASYNC, 0, 5)  // EOF
+      CreateMockRead(resp, 1), CreateMockRead(push, 2), CreateMockRead(body, 4),
+      MockRead(ASYNC, 0, 6)  // EOF
   };
 
   SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
   NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
                                      NetLogWithSource(), NULL);
   helper.RunToCompletion(&data);
   TransactionHelperResult out = helper.output();
   EXPECT_THAT(out.rv, IsOk());
   EXPECT_EQ("HTTP/1.1 200", out.status_line);
   EXPECT_EQ("hello!", out.response_data);
@@ skipping 240 matching lines @@
 }
 
 TEST_F(SpdyNetworkTransactionTest,
        TestRawHeaderSizeSuccessfullPushHeadersFirst) {
   SpdyHeaderBlock headers(spdy_util_.ConstructGetHeaderBlock(kDefaultUrl));
   headers["user-agent"] = "";
   headers["accept-encoding"] = "gzip, deflate";
 
   SpdySerializedFrame req(
       spdy_util_.ConstructSpdyHeaders(1, std::move(headers), LOWEST, true));
+  SpdySerializedFrame priority(
+      spdy_util_.ConstructSpdyPriority(2, 1, IDLE, true));
   MockWrite writes[] = {
-      CreateMockWrite(req, 0),
+      CreateMockWrite(req, 0), CreateMockWrite(priority, 2),
   };
 
   SpdySerializedFrame resp(spdy_util_.ConstructSpdyGetReply(nullptr, 0, 1));
   SpdySerializedFrame response_body_frame(
       spdy_util_.ConstructSpdyDataFrame(1, "should not include", 18, true));
 
   SpdyHeaderBlock push_headers;
   spdy_util_.AddUrlToHeaderBlock(std::string(kDefaultUrl) + "b.dat",
                                  &push_headers);
 
   SpdySerializedFrame push_init_frame(
       spdy_util_.ConstructInitialSpdyPushFrame(std::move(push_headers), 2, 1));
 
   SpdySerializedFrame push_headers_frame(
       spdy_util_.ConstructSpdyPushHeaders(2, nullptr, 0));
 
   SpdySerializedFrame push_body_frame(spdy_util_.ConstructSpdyDataFrame(
       2, "should not include either", 25, false));
 
   MockRead push_init_read(CreateMockRead(push_init_frame, 1));
-  MockRead response_headers(CreateMockRead(resp, 4));
+  MockRead response_headers(CreateMockRead(resp, 5));
   // raw_header_size() will contain the size of the push promise frame
   // initialization.
   int expected_response_headers_size =
       response_headers.data_len + push_init_read.data_len;
 
   MockRead reads[] = {
       push_init_read,
-      CreateMockRead(push_headers_frame, 2),
-      CreateMockRead(push_body_frame, 3),
+      CreateMockRead(push_headers_frame, 3),
+      CreateMockRead(push_body_frame, 4),
       response_headers,
-      CreateMockRead(response_body_frame, 5),
-      MockRead(ASYNC, 0, 6)  // EOF
+      CreateMockRead(response_body_frame, 6),
+      MockRead(ASYNC, 0, 7)  // EOF
   };
 
   SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
 
   TestDelegate delegate;
   SpdyURLRequestContext spdy_url_request_context;
   TestNetworkDelegate network_delegate;
   spdy_url_request_context.set_network_delegate(&network_delegate);
   SSLSocketDataProvider ssl_data(ASYNC, OK);
   ssl_data.next_proto = kProtoHTTP2;
@@ skipping 169 matching lines @@
   }
   EXPECT_TRUE(data.AllReadDataConsumed());
   EXPECT_TRUE(data.AllWriteDataConsumed());
   EXPECT_TRUE(data2.AllReadDataConsumed());
   EXPECT_TRUE(data2.AllWriteDataConsumed());
 }
 
 TEST_F(SpdyNetworkTransactionTest, ServerPushSingleDataFrame) {
   SpdySerializedFrame stream1_syn(
       spdy_util_.ConstructSpdyGet(nullptr, 0, 1, LOWEST, true));
-  SpdySerializedFrame stream1_body(spdy_util_.ConstructSpdyDataFrame(1, true));
+  SpdySerializedFrame stream2_priority(
+      spdy_util_.ConstructSpdyPriority(2, 1, IDLE, true));
   MockWrite writes[] = {
-      CreateMockWrite(stream1_syn, 0),
+      CreateMockWrite(stream1_syn, 0), CreateMockWrite(stream2_priority, 3),
   };
 
   SpdySerializedFrame stream1_reply(
       spdy_util_.ConstructSpdyGetReply(NULL, 0, 1));
   SpdySerializedFrame stream2_syn(spdy_util_.ConstructSpdyPush(
       NULL, 0, 2, 1, GetDefaultUrlWithPath("/foo.dat").c_str()));
+  SpdySerializedFrame stream1_body(spdy_util_.ConstructSpdyDataFrame(1, true));
   const char kPushedData[] = "pushed";
   SpdySerializedFrame stream2_body(spdy_util_.ConstructSpdyDataFrame(
       2, kPushedData, strlen(kPushedData), true));
   MockRead reads[] = {
-      CreateMockRead(stream1_reply, 1),
-      CreateMockRead(stream2_syn, 2),
-      CreateMockRead(stream1_body, 3, SYNCHRONOUS),
-      CreateMockRead(stream2_body, 4),
-      MockRead(SYNCHRONOUS, ERR_IO_PENDING, 5),  // Force a pause
+      CreateMockRead(stream1_reply, 1),         CreateMockRead(stream2_syn, 2),
+      CreateMockRead(stream1_body, 4),          CreateMockRead(stream2_body, 5),
+      MockRead(SYNCHRONOUS, ERR_IO_PENDING, 6),  // Force a pause
   };
 
   HttpResponseInfo response;
   HttpResponseInfo response2;
   std::string expected_push_result("pushed");
   SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
   RunServerPushTest(&data,
                     &response,
                     &response2,
                     expected_push_result);
 
   // Verify the response headers.
   EXPECT_TRUE(response.headers);
   EXPECT_EQ("HTTP/1.1 200", response.headers->GetStatusLine());
 
   // Verify the pushed stream.
   EXPECT_TRUE(response2.headers);
   EXPECT_EQ("HTTP/1.1 200", response2.headers->GetStatusLine());
 }
 
 TEST_F(SpdyNetworkTransactionTest, ServerPushBeforeHeaders) {
   SpdySerializedFrame stream1_syn(
       spdy_util_.ConstructSpdyGet(nullptr, 0, 1, LOWEST, true));
+  SpdySerializedFrame stream2_priority(
+      spdy_util_.ConstructSpdyPriority(2, 1, IDLE, true));
   MockWrite writes[] = {
-      CreateMockWrite(stream1_syn, 0),
+      CreateMockWrite(stream1_syn, 0), CreateMockWrite(stream2_priority, 2),
   };
 
   SpdySerializedFrame stream2_syn(spdy_util_.ConstructSpdyPush(
       nullptr, 0, 2, 1, GetDefaultUrlWithPath("/foo.dat").c_str()));
   SpdySerializedFrame stream1_reply(
       spdy_util_.ConstructSpdyGetReply(NULL, 0, 1));
   SpdySerializedFrame stream1_body(spdy_util_.ConstructSpdyDataFrame(1, true));
   const char kPushedData[] = "pushed";
   SpdySerializedFrame stream2_body(spdy_util_.ConstructSpdyDataFrame(
       2, kPushedData, strlen(kPushedData), true));
   MockRead reads[] = {
       CreateMockRead(stream2_syn, 1),
-      CreateMockRead(stream1_reply, 2),
-      CreateMockRead(stream1_body, 3, SYNCHRONOUS),
-      CreateMockRead(stream2_body, 4),
-      MockRead(SYNCHRONOUS, ERR_IO_PENDING, 5),  // Force a pause
+      CreateMockRead(stream1_reply, 3),
+      CreateMockRead(stream1_body, 4, SYNCHRONOUS),
+      CreateMockRead(stream2_body, 5),
+      MockRead(SYNCHRONOUS, ERR_IO_PENDING, 6),  // Force a pause
   };
 
   HttpResponseInfo response;
   HttpResponseInfo response2;
   std::string expected_push_result("pushed");
   SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
   RunServerPushTest(&data,
                     &response,
                     &response2,
                     expected_push_result);
 
   // Verify the response headers.
   EXPECT_TRUE(response.headers);
   EXPECT_EQ("HTTP/1.1 200", response.headers->GetStatusLine());
 
   // Verify the pushed stream.
   EXPECT_TRUE(response2.headers);
   EXPECT_EQ("HTTP/1.1 200", response2.headers->GetStatusLine());
 }
 
 TEST_F(SpdyNetworkTransactionTest, ServerPushSingleDataFrame2) {
   SpdySerializedFrame stream1_syn(
       spdy_util_.ConstructSpdyGet(nullptr, 0, 1, LOWEST, true));
+  SpdySerializedFrame stream2_priority(
+      spdy_util_.ConstructSpdyPriority(2, 1, IDLE, true));
   MockWrite writes[] = {
-      CreateMockWrite(stream1_syn, 0),
+      CreateMockWrite(stream1_syn, 0), CreateMockWrite(stream2_priority, 3),
   };
 
   SpdySerializedFrame stream1_reply(
       spdy_util_.ConstructSpdyGetReply(NULL, 0, 1));
   SpdySerializedFrame stream2_syn(spdy_util_.ConstructSpdyPush(
       NULL, 0, 2, 1, GetDefaultUrlWithPath("/foo.dat").c_str()));
   const char kPushedData[] = "pushed";
   SpdySerializedFrame stream2_body(spdy_util_.ConstructSpdyDataFrame(
       2, kPushedData, strlen(kPushedData), true));
   SpdySerializedFrame stream1_body(spdy_util_.ConstructSpdyDataFrame(1, true));
   MockRead reads[] = {
       CreateMockRead(stream1_reply, 1),
       CreateMockRead(stream2_syn, 2),
-      CreateMockRead(stream2_body, 3),
-      CreateMockRead(stream1_body, 4, SYNCHRONOUS),
-      MockRead(SYNCHRONOUS, ERR_IO_PENDING, 5),  // Force a pause
+      CreateMockRead(stream2_body, 4),
+      CreateMockRead(stream1_body, 5, SYNCHRONOUS),
+      MockRead(SYNCHRONOUS, ERR_IO_PENDING, 6),  // Force a pause
   };
 
   HttpResponseInfo response;
   HttpResponseInfo response2;
   std::string expected_push_result("pushed");
   SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
   RunServerPushTest(&data,
                     &response,
                     &response2,
                     expected_push_result);
 
   // Verify the response headers.
   EXPECT_TRUE(response.headers);
   EXPECT_EQ("HTTP/1.1 200", response.headers->GetStatusLine());
 
   // Verify the pushed stream.
   EXPECT_TRUE(response2.headers);
   EXPECT_EQ("HTTP/1.1 200", response2.headers->GetStatusLine());
 }
 
+TEST_F(SpdyNetworkTransactionTest, ServerPushUpdatesPriority) {
+  SpdySerializedFrame stream1_syn(

[Bence, 2017/01/05 17:14:45]

Maybe use |req| instead of |syn|.  SYN was a SPDY concept that did not make it
to HTTP/2.

[Tom Bergan, 2017/01/06 00:08:41]

Switched to |headers|.

+      spdy_util_.ConstructSpdyGet(nullptr, 0, 1, HIGHEST, true));
+  SpdySerializedFrame stream3_syn(
+      spdy_util_.ConstructSpdyGet(nullptr, 0, 3, MEDIUM, true));
+  SpdySerializedFrame stream5_syn(
+      spdy_util_.ConstructSpdyGet(nullptr, 0, 5, MEDIUM, true));
+
+  // Stream 1 pushes two streams that are initially prioritized below stream 5.
+  // Stream 2 is later prioritized below stream 1 after it matches a request.
+  SpdySerializedFrame stream2_priority(
+      spdy_util_.ConstructSpdyPriority(2, 5, IDLE, true));
+  SpdySerializedFrame stream4_priority(
+      spdy_util_.ConstructSpdyPriority(4, 2, IDLE, true));
+  SpdySerializedFrame stream4_priority_update(
+      spdy_util_.ConstructSpdyPriority(4, 5, IDLE, true));
+  SpdySerializedFrame stream2_priority_update(
+      spdy_util_.ConstructSpdyPriority(2, 1, HIGHEST, true));
+
+  MockWrite writes[] = {
+      CreateMockWrite(stream1_syn, 0),
+      CreateMockWrite(stream3_syn, 1),
+      CreateMockWrite(stream5_syn, 2),
+      CreateMockWrite(stream2_priority, 7),
+      CreateMockWrite(stream4_priority, 9),
+      CreateMockWrite(stream4_priority_update, 11),
+      CreateMockWrite(stream2_priority_update, 12),
+  };
+
+  SpdySerializedFrame stream1_reply(
+      spdy_util_.ConstructSpdyGetReply(NULL, 0, 1));

[Bence, 2017/01/05 17:14:46]

Please use nullptr instead of NULL in new code, see
https://google.github.io/styleguide/cppguide.html#0_and_nullptr/NULL, also
https://chromium-cpp.appspot.com/.

[Tom Bergan, 2017/01/06 00:08:41]

I did s/NULL/nullptr/ in this file.

+  SpdySerializedFrame stream3_reply(
+      spdy_util_.ConstructSpdyGetReply(NULL, 0, 3));
+  SpdySerializedFrame stream5_reply(
+      spdy_util_.ConstructSpdyGetReply(NULL, 0, 5));
+  SpdySerializedFrame stream1_body(spdy_util_.ConstructSpdyDataFrame(1, true));

[Bence, 2017/01/05 17:14:46]

Please instantiate mock read data in the order that they are read, on the
principle that creating data frames might change internal state (priorities and
header compression) of SpdyFramer within |spdy_util_|.  I know this does not
apply to this particular situation, because data frames neither open new streams
nor do header compression.

[Tom Bergan, 2017/01/06 00:08:41]

Done.

+  SpdySerializedFrame stream2_body(spdy_util_.ConstructSpdyDataFrame(2, true));
+  SpdySerializedFrame stream3_body(spdy_util_.ConstructSpdyDataFrame(3, true));
+  SpdySerializedFrame stream5_body(spdy_util_.ConstructSpdyDataFrame(5, true));
+
+  SpdySerializedFrame stream2_syn(spdy_util_.ConstructSpdyPush(

[Bence, 2017/01/05 17:14:45]

Maybe use |push| instead of |syn|.

[Tom Bergan, 2017/01/06 00:08:41]

Done.

+      NULL, 0, 2, 1, GetDefaultUrlWithPath("/foo.dat").c_str()));
+  SpdySerializedFrame stream4_syn(spdy_util_.ConstructSpdyPush(
+      NULL, 0, 4, 1, GetDefaultUrlWithPath("/bar.dat").c_str()));
+
+  MockRead reads[] = {
+      CreateMockRead(stream1_reply, 3),
+      CreateMockRead(stream3_reply, 4),
+      CreateMockRead(stream5_reply, 5),
+      CreateMockRead(stream2_syn, 6),
+      CreateMockRead(stream4_syn, 8),
+      MockRead(ASYNC, ERR_IO_PENDING, 10),
+      CreateMockRead(stream1_body, 13),
+      CreateMockRead(stream2_body, 14),
+      CreateMockRead(stream3_body, 15),
+      CreateMockRead(stream5_body, 16),
+      MockRead(SYNCHRONOUS, ERR_IO_PENDING, 17),  // Force a pause
+  };
+
+  SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
+  SequencedSocketData data_placeholder1(NULL, 0, NULL, 0);
+  SequencedSocketData data_placeholder2(NULL, 0, NULL, 0);
+  SequencedSocketData data_placeholder3(NULL, 0, NULL, 0);
+
+  NormalSpdyTransactionHelper helper(CreateGetRequest(), LOWEST,
+                                     NetLogWithSource(), NULL);
+  helper.RunPreTestSetup();
+  helper.AddData(&data);
+  helper.AddData(&data_placeholder1);  // other requests reuse the same socket
+  helper.AddData(&data_placeholder2);
+  helper.AddData(&data_placeholder3);
+  HttpNetworkTransaction trans1(HIGHEST, helper.session());
+  HttpNetworkTransaction trans2(HIGHEST, helper.session());

[Bence, 2017/01/05 17:14:46]

Instantiate |trans2| further down, after "// Start a request..." comment, closer
to its first use.

[Tom Bergan, 2017/01/06 00:08:41]

Done.

+  HttpNetworkTransaction trans3(MEDIUM, helper.session());
+  HttpNetworkTransaction trans5(MEDIUM, helper.session());
+
+  TestCompletionCallback callback1;
+  TestCompletionCallback callback2;

[Bence, 2017/01/05 17:14:45]

Instantiate |callback2| further down, after "// Start a request..." comment,
closer to its first use.

[Tom Bergan, 2017/01/06 00:08:41]

Done.

+  TestCompletionCallback callback3;
+  TestCompletionCallback callback5;
+
+  // Start the ordinary requests.
+  NetLogWithSource log;
+  ASSERT_THAT(trans1.Start(&CreateGetRequest(), callback1.callback(), log),
+              IsError(ERR_IO_PENDING));
+  ASSERT_THAT(trans3.Start(&CreateGetRequest(), callback3.callback(), log),
+              IsError(ERR_IO_PENDING));
+  ASSERT_THAT(trans5.Start(&CreateGetRequest(), callback5.callback(), log),
+              IsError(ERR_IO_PENDING));
+  data.RunUntilPaused();
+
+  // Start a request that matches the push.
+  HttpRequestInfo push_req = CreateGetRequest();

[Bence, 2017/01/05 17:14:46]

Would CreatePushRequest() work here?

[Tom Bergan, 2017/01/06 00:08:41]

I don't think that method exists? Also, this is creating a GET request that will
match one of the pushes, so CreateGetRequest seems to make sense.

+  push_req.url = GURL(GetDefaultUrlWithPath("/foo.dat"));
+  ASSERT_THAT(trans2.Start(&push_req, callback2.callback(), log),
+              IsError(ERR_IO_PENDING));
+  data.Resume();
+
+  ASSERT_THAT(callback1.WaitForResult(), IsOk());
+  ASSERT_THAT(callback2.WaitForResult(), IsOk());
+  ASSERT_THAT(callback3.WaitForResult(), IsOk());
+  ASSERT_THAT(callback5.WaitForResult(), IsOk());
+}

[Bence, 2017/01/05 17:14:46]

Please call helper.VerifyDataConsumed() at the end of test, and if it fails,
remove mock data that is not consumed, or spin the message loop to consume them.

[Tom Bergan, 2017/01/06 00:08:41]

Done. Thanks for reading this closely. I admit I don't yet fully understand the
intricacies of SequencedSocketData.

+
 TEST_F(SpdyNetworkTransactionTest, ServerPushServerAborted) {
   SpdySerializedFrame stream1_syn(
       spdy_util_.ConstructSpdyGet(nullptr, 0, 1, LOWEST, true));
-  SpdySerializedFrame stream1_body(spdy_util_.ConstructSpdyDataFrame(1, true));
+  SpdySerializedFrame stream2_priority(
+      spdy_util_.ConstructSpdyPriority(2, 1, IDLE, true));
   MockWrite writes[] = {
-      CreateMockWrite(stream1_syn, 0),
+      CreateMockWrite(stream1_syn, 0), CreateMockWrite(stream2_priority, 3),
   };
 
   SpdySerializedFrame stream1_reply(
       spdy_util_.ConstructSpdyGetReply(NULL, 0, 1));
+  SpdySerializedFrame stream1_body(spdy_util_.ConstructSpdyDataFrame(1, true));

[Bence, 2017/01/05 17:14:46]

Please instantiate read frames in the order they are read, here and also in
other tests.

[Tom Bergan, 2017/01/06 00:08:41]

Done.

   SpdySerializedFrame stream2_syn(spdy_util_.ConstructSpdyPush(
       NULL, 0, 2, 1, GetDefaultUrlWithPath("/foo.dat").c_str()));
   SpdySerializedFrame stream2_rst(
       spdy_util_.ConstructSpdyRstStream(2, RST_STREAM_PROTOCOL_ERROR));
   MockRead reads[] = {
       CreateMockRead(stream1_reply, 1),
       CreateMockRead(stream2_syn, 2),
-      CreateMockRead(stream2_rst, 3),
-      CreateMockRead(stream1_body, 4, SYNCHRONOUS),
-      MockRead(SYNCHRONOUS, ERR_IO_PENDING, 5),  // Force a pause
+      CreateMockRead(stream2_rst, 4),
+      CreateMockRead(stream1_body, 5, SYNCHRONOUS),
+      MockRead(SYNCHRONOUS, ERR_IO_PENDING, 6),  // Force a pause
   };
 
   SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
   NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
                                      NetLogWithSource(), NULL);
 
   helper.RunPreTestSetup();
   helper.AddData(&data);
 
   HttpNetworkTransaction* trans = helper.trans();
@@ skipping 14 matching lines @@
   HttpResponseInfo response = *trans->GetResponseInfo();
   EXPECT_TRUE(response.headers);
   EXPECT_EQ("HTTP/1.1 200", response.headers->GetStatusLine());
 }
 
 // Verify that we don't leak streams and that we properly send a reset
 // if the server pushes the same stream twice.
 TEST_F(SpdyNetworkTransactionTest, ServerPushDuplicate) {
   SpdySerializedFrame stream1_syn(
       spdy_util_.ConstructSpdyGet(nullptr, 0, 1, LOWEST, true));
-  SpdySerializedFrame stream1_body(spdy_util_.ConstructSpdyDataFrame(1, true));
+  SpdySerializedFrame stream2_priority(
+      spdy_util_.ConstructSpdyPriority(2, 1, IDLE, true));
   SpdySerializedFrame stream3_rst(
       spdy_util_.ConstructSpdyRstStream(4, RST_STREAM_PROTOCOL_ERROR));
   MockWrite writes[] = {
-      CreateMockWrite(stream1_syn, 0), CreateMockWrite(stream3_rst, 4),
+      CreateMockWrite(stream1_syn, 0), CreateMockWrite(stream2_priority, 3),
+      CreateMockWrite(stream3_rst, 5),
   };
 
   SpdySerializedFrame stream1_reply(
       spdy_util_.ConstructSpdyGetReply(NULL, 0, 1));
+  SpdySerializedFrame stream1_body(spdy_util_.ConstructSpdyDataFrame(1, true));
   SpdySerializedFrame stream2_syn(spdy_util_.ConstructSpdyPush(
       NULL, 0, 2, 1, GetDefaultUrlWithPath("/foo.dat").c_str()));
   const char kPushedData[] = "pushed";
   SpdySerializedFrame stream2_body(spdy_util_.ConstructSpdyDataFrame(
       2, kPushedData, strlen(kPushedData), true));
   SpdySerializedFrame stream3_syn(spdy_util_.ConstructSpdyPush(
       NULL, 0, 4, 1, GetDefaultUrlWithPath("/foo.dat").c_str()));
   MockRead reads[] = {
       CreateMockRead(stream1_reply, 1),
       CreateMockRead(stream2_syn, 2),
-      CreateMockRead(stream3_syn, 3),
-      CreateMockRead(stream1_body, 5),
-      CreateMockRead(stream2_body, 6),
-      MockRead(SYNCHRONOUS, ERR_IO_PENDING, 7),  // Force a pause
+      CreateMockRead(stream3_syn, 4),
+      CreateMockRead(stream1_body, 6),
+      CreateMockRead(stream2_body, 7),
+      MockRead(SYNCHRONOUS, ERR_IO_PENDING, 8),  // Force a pause
   };
 
   HttpResponseInfo response;
   HttpResponseInfo response2;
   std::string expected_push_result("pushed");
   SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
   RunServerPushTest(&data,
                     &response,
                     &response2,
                     expected_push_result);
 
   // Verify the response headers.
   EXPECT_TRUE(response.headers);
   EXPECT_EQ("HTTP/1.1 200", response.headers->GetStatusLine());
 
   // Verify the pushed stream.
   EXPECT_TRUE(response2.headers);
   EXPECT_EQ("HTTP/1.1 200", response2.headers->GetStatusLine());
 }
 
 TEST_F(SpdyNetworkTransactionTest, ServerPushMultipleDataFrame) {
   SpdySerializedFrame stream1_syn(
       spdy_util_.ConstructSpdyGet(nullptr, 0, 1, LOWEST, true));
-  SpdySerializedFrame stream1_body(spdy_util_.ConstructSpdyDataFrame(1, true));
+  SpdySerializedFrame stream2_priority(
+      spdy_util_.ConstructSpdyPriority(2, 1, IDLE, true));
   MockWrite writes[] = {
-      CreateMockWrite(stream1_syn, 0),
+      CreateMockWrite(stream1_syn, 0), CreateMockWrite(stream2_priority, 3),
   };
 
   SpdySerializedFrame stream1_reply(
       spdy_util_.ConstructSpdyGetReply(NULL, 0, 1));
+  SpdySerializedFrame stream1_body(spdy_util_.ConstructSpdyDataFrame(1, true));
   SpdySerializedFrame stream2_syn(spdy_util_.ConstructSpdyPush(
       NULL, 0, 2, 1, GetDefaultUrlWithPath("/foo.dat").c_str()));
   static const char kPushedData[] = "pushed my darling hello my baby";
   SpdySerializedFrame stream2_body_base(spdy_util_.ConstructSpdyDataFrame(
       2, kPushedData, strlen(kPushedData), true));
   const size_t kChunkSize = strlen(kPushedData) / 4;
   SpdySerializedFrame stream2_body1(stream2_body_base.data(), kChunkSize,
                                     false);
   SpdySerializedFrame stream2_body2(stream2_body_base.data() + kChunkSize,
                                     kChunkSize, false);
   SpdySerializedFrame stream2_body3(stream2_body_base.data() + 2 * kChunkSize,
                                     kChunkSize, false);
   SpdySerializedFrame stream2_body4(stream2_body_base.data() + 3 * kChunkSize,
                                     stream2_body_base.size() - 3 * kChunkSize,
                                     false);
   MockRead reads[] = {
       CreateMockRead(stream1_reply, 1),
       CreateMockRead(stream2_syn, 2),
-      CreateMockRead(stream2_body1, 3),
-      CreateMockRead(stream2_body2, 4),
-      CreateMockRead(stream2_body3, 5),
-      CreateMockRead(stream2_body4, 6),
-      CreateMockRead(stream1_body, 7, SYNCHRONOUS),
-      MockRead(SYNCHRONOUS, ERR_IO_PENDING, 8),  // Force a pause
+      CreateMockRead(stream2_body1, 4),
+      CreateMockRead(stream2_body2, 5),
+      CreateMockRead(stream2_body3, 6),
+      CreateMockRead(stream2_body4, 7),
+      CreateMockRead(stream1_body, 8, SYNCHRONOUS),
+      MockRead(SYNCHRONOUS, ERR_IO_PENDING, 9),  // Force a pause
   };
 
   HttpResponseInfo response;
   HttpResponseInfo response2;
   std::string expected_push_result("pushed my darling hello my baby");
   SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
   RunServerPushTest(&data, &response, &response2, kPushedData);
 
   // Verify the response headers.
   EXPECT_TRUE(response.headers);
   EXPECT_EQ("HTTP/1.1 200", response.headers->GetStatusLine());
 
   // Verify the pushed stream.
   EXPECT_TRUE(response2.headers);
   EXPECT_EQ("HTTP/1.1 200", response2.headers->GetStatusLine());
 }
 
 TEST_F(SpdyNetworkTransactionTest, ServerPushMultipleDataFrameInterrupted) {
   SpdySerializedFrame stream1_syn(
       spdy_util_.ConstructSpdyGet(nullptr, 0, 1, LOWEST, true));
-  SpdySerializedFrame stream1_body(spdy_util_.ConstructSpdyDataFrame(1, true));
+  SpdySerializedFrame stream2_priority(
+      spdy_util_.ConstructSpdyPriority(2, 1, IDLE, true));
   MockWrite writes[] = {
-      CreateMockWrite(stream1_syn, 0),
+      CreateMockWrite(stream1_syn, 0), CreateMockWrite(stream2_priority, 3),
   };
 
   SpdySerializedFrame stream1_reply(
       spdy_util_.ConstructSpdyGetReply(NULL, 0, 1));
+  SpdySerializedFrame stream1_body(spdy_util_.ConstructSpdyDataFrame(1, true));
   SpdySerializedFrame stream2_syn(spdy_util_.ConstructSpdyPush(
       NULL, 0, 2, 1, GetDefaultUrlWithPath("/foo.dat").c_str()));
   static const char kPushedData[] = "pushed my darling hello my baby";
   SpdySerializedFrame stream2_body_base(spdy_util_.ConstructSpdyDataFrame(
       2, kPushedData, strlen(kPushedData), true));
   const size_t kChunkSize = strlen(kPushedData) / 4;
   SpdySerializedFrame stream2_body1(stream2_body_base.data(), kChunkSize,
                                     false);
   SpdySerializedFrame stream2_body2(stream2_body_base.data() + kChunkSize,
                                     kChunkSize, false);
   SpdySerializedFrame stream2_body3(stream2_body_base.data() + 2 * kChunkSize,
                                     kChunkSize, false);
   SpdySerializedFrame stream2_body4(stream2_body_base.data() + 3 * kChunkSize,
                                     stream2_body_base.size() - 3 * kChunkSize,
                                     false);
   MockRead reads[] = {
       CreateMockRead(stream1_reply, 1),
       CreateMockRead(stream2_syn, 2),
-      CreateMockRead(stream2_body1, 3),
-      CreateMockRead(stream2_body2, 4),
-      CreateMockRead(stream2_body3, 5),
-      CreateMockRead(stream2_body4, 6),
-      CreateMockRead(stream1_body, 7, SYNCHRONOUS),
-      MockRead(SYNCHRONOUS, ERR_IO_PENDING, 8)  // Force a pause.
+      CreateMockRead(stream2_body1, 4),
+      CreateMockRead(stream2_body2, 5),
+      CreateMockRead(stream2_body3, 6),
+      CreateMockRead(stream2_body4, 7),
+      CreateMockRead(stream1_body, 8, SYNCHRONOUS),
+      MockRead(SYNCHRONOUS, ERR_IO_PENDING, 9)  // Force a pause.
   };
 
   HttpResponseInfo response;
   HttpResponseInfo response2;
   SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
   RunServerPushTest(&data, &response, &response2, kPushedData);
 
   // Verify the response headers.
   EXPECT_TRUE(response.headers);
   EXPECT_EQ("HTTP/1.1 200", response.headers->GetStatusLine());
@@ skipping 141 matching lines @@
   // Verify the response headers.
   HttpResponseInfo response = *trans->GetResponseInfo();
   EXPECT_TRUE(response.headers);
   EXPECT_EQ("HTTP/1.1 200", response.headers->GetStatusLine());
 }
 
 // PUSH_PROMISE on a server-initiated stream should trigger GOAWAY.
 TEST_F(SpdyNetworkTransactionTest, ServerPushOnPushedStream) {
   SpdySerializedFrame stream1_syn(
       spdy_util_.ConstructSpdyGet(nullptr, 0, 1, LOWEST, true));
+  SpdySerializedFrame stream2_priority(
+      spdy_util_.ConstructSpdyPriority(2, 1, IDLE, true));
   SpdySerializedFrame goaway(spdy_util_.ConstructSpdyGoAway(
       2, GOAWAY_PROTOCOL_ERROR, "Push on even stream id."));
   MockWrite writes[] = {
-      CreateMockWrite(stream1_syn, 0), CreateMockWrite(goaway, 4),
+      CreateMockWrite(stream1_syn, 0), CreateMockWrite(stream2_priority, 3),
+      CreateMockWrite(goaway, 5),
   };
 
   SpdySerializedFrame stream1_reply(
       spdy_util_.ConstructSpdyGetReply(NULL, 0, 1));
   SpdySerializedFrame stream2_syn(spdy_util_.ConstructSpdyPush(
       nullptr, 0, 2, 1, GetDefaultUrlWithPath("/foo.dat").c_str()));
   SpdySerializedFrame stream3_syn(spdy_util_.ConstructSpdyPush(
       nullptr, 0, 4, 2, GetDefaultUrlWithPath("/bar.dat").c_str()));
   MockRead reads[] = {
       CreateMockRead(stream1_reply, 1), CreateMockRead(stream2_syn, 2),
-      CreateMockRead(stream3_syn, 3),
+      CreateMockRead(stream3_syn, 4),
   };
 
   SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
   NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
                                      NetLogWithSource(), nullptr);
   helper.RunToCompletion(&data);
 }
 
 // PUSH_PROMISE on a closed client-initiated stream should trigger RST_STREAM.
 TEST_F(SpdyNetworkTransactionTest, ServerPushOnClosedStream) {
@@ skipping 35 matching lines @@
   EXPECT_TRUE(data.AllReadDataConsumed());
   EXPECT_TRUE(data.AllWriteDataConsumed());
   VerifyStreamsClosed(helper);
 }
 
 // PUSH_PROMISE on a server-initiated stream should trigger GOAWAY even if
 // stream is closed.
 TEST_F(SpdyNetworkTransactionTest, ServerPushOnClosedPushedStream) {
   SpdySerializedFrame stream1_syn(
       spdy_util_.ConstructSpdyGet(nullptr, 0, 1, LOWEST, true));
+  SpdySerializedFrame stream2_priority(
+      spdy_util_.ConstructSpdyPriority(2, 1, IDLE, true));
   SpdySerializedFrame goaway(spdy_util_.ConstructSpdyGoAway(
       2, GOAWAY_PROTOCOL_ERROR, "Push on even stream id."));
   MockWrite writes[] = {
-      CreateMockWrite(stream1_syn, 0), CreateMockWrite(goaway, 7),
+      CreateMockWrite(stream1_syn, 0), CreateMockWrite(stream2_priority, 3),
+      CreateMockWrite(goaway, 8),
   };
 
   SpdySerializedFrame stream1_reply(
       spdy_util_.ConstructSpdyGetReply(nullptr, 0, 1));
   SpdySerializedFrame stream2_syn(spdy_util_.ConstructSpdyPush(
       nullptr, 0, 2, 1, GetDefaultUrlWithPath("/foo.dat").c_str()));
   SpdySerializedFrame stream1_body(spdy_util_.ConstructSpdyDataFrame(1, true));
   const char kPushedData[] = "pushed";
   SpdySerializedFrame stream2_body(spdy_util_.ConstructSpdyDataFrame(
       2, kPushedData, strlen(kPushedData), true));
   SpdySerializedFrame stream3_syn(spdy_util_.ConstructSpdyPush(
       nullptr, 0, 4, 2, GetDefaultUrlWithPath("/bar.dat").c_str()));
 
   MockRead reads[] = {
       CreateMockRead(stream1_reply, 1),   CreateMockRead(stream2_syn, 2),
-      CreateMockRead(stream1_body, 3),    CreateMockRead(stream2_body, 4),
-      MockRead(ASYNC, ERR_IO_PENDING, 5), CreateMockRead(stream3_syn, 6),
+      CreateMockRead(stream1_body, 4),    CreateMockRead(stream2_body, 5),
+      MockRead(ASYNC, ERR_IO_PENDING, 6), CreateMockRead(stream3_syn, 7),
   };
 
   SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
   NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
                                      NetLogWithSource(), nullptr);
   helper.RunPreTestSetup();
   helper.AddData(&data);
 
   HttpNetworkTransaction* trans1 = helper.trans();
   TestCompletionCallback callback1;
@@ skipping 1455 matching lines @@
   const HttpResponseInfo* const response_restart = trans->GetResponseInfo();
   ASSERT_TRUE(response_restart);
   ASSERT_TRUE(response_restart->headers);
   EXPECT_EQ(200, response_restart->headers->response_code());
   EXPECT_TRUE(response_restart->auth_challenge.get() == NULL);
 }
 
 TEST_F(SpdyNetworkTransactionTest, ServerPushWithHeaders) {
   SpdySerializedFrame stream1_syn(
       spdy_util_.ConstructSpdyGet(nullptr, 0, 1, LOWEST, true));
+  SpdySerializedFrame stream2_priority(
+      spdy_util_.ConstructSpdyPriority(2, 1, IDLE, true));
   MockWrite writes[] = {
-      CreateMockWrite(stream1_syn, 0),
+      CreateMockWrite(stream1_syn, 0), CreateMockWrite(stream2_priority, 3),
   };
 
   SpdySerializedFrame stream1_reply(
       spdy_util_.ConstructSpdyGetReply(nullptr, 0, 1));
 
   SpdyHeaderBlock initial_headers;
   spdy_util_.AddUrlToHeaderBlock(GetDefaultUrlWithPath("/foo.dat"),
                                  &initial_headers);
   SpdySerializedFrame stream2_syn(spdy_util_.ConstructInitialSpdyPushFrame(
       std::move(initial_headers), 2, 1));
 
   SpdyHeaderBlock late_headers;
   late_headers[spdy_util_.GetStatusKey()] = "200";
   late_headers["hello"] = "bye";
   SpdySerializedFrame stream2_headers(spdy_util_.ConstructSpdyResponseHeaders(
       2, std::move(late_headers), false));
 
   SpdySerializedFrame stream1_body(spdy_util_.ConstructSpdyDataFrame(1, true));
 
   const char kPushedData[] = "pushed";
   SpdySerializedFrame stream2_body(spdy_util_.ConstructSpdyDataFrame(
       2, kPushedData, strlen(kPushedData), true));
 
   MockRead reads[] = {
       CreateMockRead(stream1_reply, 1),
       CreateMockRead(stream2_syn, 2),
-      CreateMockRead(stream2_headers, 3),
-      CreateMockRead(stream1_body, 4, SYNCHRONOUS),
-      CreateMockRead(stream2_body, 5),
-      MockRead(SYNCHRONOUS, ERR_IO_PENDING, 6),  // Force a pause
+      CreateMockRead(stream2_headers, 4),
+      CreateMockRead(stream1_body, 5, SYNCHRONOUS),
+      CreateMockRead(stream2_body, 6),
+      MockRead(SYNCHRONOUS, ERR_IO_PENDING, 7),  // Force a pause
   };
 
   HttpResponseInfo response;
   HttpResponseInfo response2;
   std::string expected_push_result("pushed");
   SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
   RunServerPushTest(&data,
                     &response,
                     &response2,
                     expected_push_result);
 
   // Verify the response headers.
   EXPECT_TRUE(response.headers);
   EXPECT_EQ("HTTP/1.1 200", response.headers->GetStatusLine());
 
   // Verify the pushed stream.
   EXPECT_TRUE(response2.headers);
   EXPECT_EQ("HTTP/1.1 200", response2.headers->GetStatusLine());
 }
 
 TEST_F(SpdyNetworkTransactionTest, ServerPushClaimBeforeHeaders) {
   // We push a stream and attempt to claim it before the headers come down.
   SpdySerializedFrame stream1_syn(
       spdy_util_.ConstructSpdyGet(nullptr, 0, 1, LOWEST, true));
+  SpdySerializedFrame stream2_priority(
+      spdy_util_.ConstructSpdyPriority(2, 1, IDLE, true));
   MockWrite writes[] = {
       CreateMockWrite(stream1_syn, 0, SYNCHRONOUS),
+      CreateMockWrite(stream2_priority, 3),
   };
 
   SpdySerializedFrame stream1_reply(
       spdy_util_.ConstructSpdyGetReply(nullptr, 0, 1));
   SpdyHeaderBlock initial_headers;
   spdy_util_.AddUrlToHeaderBlock(GetDefaultUrlWithPath("/foo.dat"),
                                  &initial_headers);
   SpdySerializedFrame stream2_syn(spdy_util_.ConstructInitialSpdyPushFrame(
       std::move(initial_headers), 2, 1));
   SpdySerializedFrame stream1_body(spdy_util_.ConstructSpdyDataFrame(1, true));
   SpdyHeaderBlock late_headers;
   late_headers[spdy_util_.GetStatusKey()] = "200";
   late_headers["hello"] = "bye";
   SpdySerializedFrame stream2_headers(spdy_util_.ConstructSpdyResponseHeaders(
       2, std::move(late_headers), false));
   const char kPushedData[] = "pushed";
   SpdySerializedFrame stream2_body(spdy_util_.ConstructSpdyDataFrame(
       2, kPushedData, strlen(kPushedData), true));
   MockRead reads[] = {
       CreateMockRead(stream1_reply, 1),   CreateMockRead(stream2_syn, 2),
-      CreateMockRead(stream1_body, 3),    MockRead(ASYNC, ERR_IO_PENDING, 4),
-      CreateMockRead(stream2_headers, 5), CreateMockRead(stream2_body, 6),
-      MockRead(ASYNC, ERR_IO_PENDING, 7), MockRead(ASYNC, 0, 8),  // EOF
+      CreateMockRead(stream1_body, 4),    MockRead(ASYNC, ERR_IO_PENDING, 5),
+      CreateMockRead(stream2_headers, 6), CreateMockRead(stream2_body, 7),
+      MockRead(ASYNC, ERR_IO_PENDING, 8), MockRead(ASYNC, 0, 9),  // EOF
   };
 
   HttpResponseInfo response;
   HttpResponseInfo response2;
   std::string expected_push_result("pushed");
   SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
 
   NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
                                      NetLogWithSource(), NULL);
   helper.AddData(&data);
@@ skipping 232 matching lines @@
 
 // Verify that push works cross origin as long as the certificate is valid for
 // the pushed authority.
 TEST_F(SpdyNetworkTransactionTest, ServerPushValidCrossOrigin) {
   // "spdy_pooling.pem" is valid for both www.example.org and mail.example.org.
   const char* url_to_fetch = "https://www.example.org";
   const char* url_to_push = "https://mail.example.org";
 
   SpdySerializedFrame headers(
       spdy_util_.ConstructSpdyGet(url_to_fetch, 1, LOWEST));
+  SpdySerializedFrame push_priority(
+      spdy_util_.ConstructSpdyPriority(2, 1, IDLE, true));
   MockWrite writes[] = {
-      CreateMockWrite(headers, 0),
+      CreateMockWrite(headers, 0), CreateMockWrite(push_priority, 3),
   };
 
   SpdySerializedFrame reply(spdy_util_.ConstructSpdyGetReply(nullptr, 0, 1));
   SpdySerializedFrame push(
       spdy_util_.ConstructSpdyPush(nullptr, 0, 2, 1, url_to_push));
   SpdySerializedFrame body(spdy_util_.ConstructSpdyDataFrame(1, true));
   const char kPushedData[] = "pushed";
   SpdySerializedFrame pushed_body(spdy_util_.ConstructSpdyDataFrame(
       2, kPushedData, strlen(kPushedData), true));
   MockRead reads[] = {
       CreateMockRead(reply, 1),
       CreateMockRead(push, 2),
-      CreateMockRead(body, 3),
-      CreateMockRead(pushed_body, 4),
-      MockRead(SYNCHRONOUS, ERR_IO_PENDING, 5),
+      CreateMockRead(body, 4),
+      CreateMockRead(pushed_body, 5),
+      MockRead(SYNCHRONOUS, ERR_IO_PENDING, 6),
   };
 
   SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
 
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL(url_to_fetch);
   request.load_flags = 0;
 
   NetLogWithSource log;
@@ skipping 73 matching lines @@
   MockRead reads0[] = {CreateMockRead(reply0, 1), CreateMockRead(body0, 2),
                        MockRead(SYNCHRONOUS, ERR_IO_PENDING, 3)};
 
   SequencedSocketData data0(reads0, arraysize(reads0), writes0,
                             arraysize(writes0));
 
   SpdyTestUtil spdy_util_1;
 
   SpdySerializedFrame headers1(
       spdy_util_1.ConstructSpdyGet(url_to_fetch1, 1, LOWEST));
+  SpdySerializedFrame push_priority(
+      spdy_util_.ConstructSpdyPriority(2, 1, IDLE, true));
   MockWrite writes1[] = {
-      CreateMockWrite(headers1, 0),
+      CreateMockWrite(headers1, 0), CreateMockWrite(push_priority, 3),
   };
 
   SpdySerializedFrame reply1(spdy_util_1.ConstructSpdyGetReply(nullptr, 0, 1));
   SpdySerializedFrame push(
       spdy_util_1.ConstructSpdyPush(nullptr, 0, 2, 1, url_to_push));
   const char kData1[] = "second";
   SpdySerializedFrame body1(
       spdy_util_1.ConstructSpdyDataFrame(1, kData1, strlen(kData1), true));
   const char kPushedData[] = "pushed";
   SpdySerializedFrame pushed_body(spdy_util_1.ConstructSpdyDataFrame(
       2, kPushedData, strlen(kPushedData), true));
 
   MockRead reads1[] = {
       CreateMockRead(reply1, 1),
       CreateMockRead(push, 2),
-      CreateMockRead(body1, 3),
-      CreateMockRead(pushed_body, 4),
-      MockRead(SYNCHRONOUS, ERR_IO_PENDING, 5),
+      CreateMockRead(body1, 4),
+      CreateMockRead(pushed_body, 5),
+      MockRead(SYNCHRONOUS, ERR_IO_PENDING, 6),
   };
 
   SequencedSocketData data1(reads1, arraysize(reads1), writes1,
                             arraysize(writes1));
 
   // Request |url_to_fetch0| to open connection to mail.example.org.
   HttpRequestInfo request0;
   request0.method = "GET";
   request0.url = GURL(url_to_fetch0);
   request0.load_flags = 0;
@@ skipping 1094 matching lines @@
 TEST_F(SpdyNetworkTransactionTest,
        GoAwayOnPushStreamIdLesserOrEqualThanLastAccepted) {
   SpdySerializedFrame push_a(spdy_util_.ConstructSpdyPush(
       NULL, 0, 4, 1, GetDefaultUrlWithPath("/a.dat").c_str()));
   SpdyHeaderBlock push_b_headers;
   spdy_util_.AddUrlToHeaderBlock(GetDefaultUrlWithPath("/b.dat"),
                                  &push_b_headers);
   SpdySerializedFrame push_b(spdy_util_.ConstructInitialSpdyPushFrame(
       std::move(push_b_headers), 2, 1));
   MockRead reads[] = {
-      CreateMockRead(push_a, 1), CreateMockRead(push_b, 2),
+      CreateMockRead(push_a, 1), CreateMockRead(push_b, 3),
   };
 
   SpdySerializedFrame req(
       spdy_util_.ConstructSpdyGet(nullptr, 0, 1, LOWEST, true));
+  SpdySerializedFrame priority_a(
+      spdy_util_.ConstructSpdyPriority(4, 1, IDLE, true));
   SpdySerializedFrame goaway(spdy_util_.ConstructSpdyGoAway(
       4, GOAWAY_PROTOCOL_ERROR,
       "New push stream id must be greater than the last accepted."));
   MockWrite writes[] = {
-      CreateMockWrite(req, 0), CreateMockWrite(goaway, 3),
+      CreateMockWrite(req, 0), CreateMockWrite(priority_a, 2),
+      CreateMockWrite(goaway, 4),
   };
 
   SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
   NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
                                      NetLogWithSource(), NULL);
   helper.RunToCompletion(&data);
   TransactionHelperResult out = helper.output();
   EXPECT_THAT(out.rv, IsError(ERR_SPDY_PROTOCOL_ERROR));
 }
 
@@ skipping 200 matching lines @@
 TEST_F(SpdyNetworkTransactionTLSUsageCheckTest, TLSCipherSuiteSucky) {
   std::unique_ptr<SSLSocketDataProvider> ssl_provider(
       new SSLSocketDataProvider(ASYNC, OK));
   // Set to TLS_RSA_WITH_NULL_MD5
   SSLConnectionStatusSetCipherSuite(0x1, &ssl_provider->connection_status);
 
   RunTLSUsageCheckTest(std::move(ssl_provider));
 }
 
 }  // namespace net