http2: Update priorities of pushed streams

net/spdy/spdy_session_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 "net/spdy/spdy_session.h"
 
 #include <algorithm>
 #include <memory>
 #include <utility>
 
@@ skipping 1277 matching lines @@
   EXPECT_THAT(callback2.WaitForResult(), IsOk());
 }
 
 TEST_F(SpdySessionTest, CancelPushAfterSessionGoesAway) {
   base::HistogramTester histogram_tester;
   session_deps_.host_resolver->set_synchronous_mode(true);
   session_deps_.time_func = TheNearFuture;
 
   SpdySerializedFrame req(
       spdy_util_.ConstructSpdyGet(nullptr, 0, 1, MEDIUM, true));
-  SpdySerializedFrame rst(
+  SpdySerializedFrame priority_a(
+      spdy_util_.ConstructSpdyPriority(2, 1, IDLE, true));
+  SpdySerializedFrame priority_b(
+      spdy_util_.ConstructSpdyPriority(4, 2, IDLE, true));
+  SpdySerializedFrame rst_a(
       spdy_util_.ConstructSpdyRstStream(2, RST_STREAM_REFUSED_STREAM));
-  MockWrite writes[] = {CreateMockWrite(req, 0), CreateMockWrite(rst, 5)};
+  MockWrite writes[] = {
+      CreateMockWrite(req, 0), CreateMockWrite(priority_a, 2),
+      CreateMockWrite(priority_b, 6), CreateMockWrite(rst_a, 7),
+  };
 
   SpdySerializedFrame push_a(spdy_util_.ConstructSpdyPush(
       nullptr, 0, 2, 1, "https://www.example.org/a.dat"));
   SpdySerializedFrame push_a_body(spdy_util_.ConstructSpdyDataFrame(2, false));
   // In ascii "0" < "a". We use it to verify that we properly handle std::map
   // iterators inside. See http://crbug.com/443490
   SpdySerializedFrame push_b(spdy_util_.ConstructSpdyPush(
       nullptr, 0, 4, 1, "https://www.example.org/0.dat"));
   MockRead reads[] = {
-      CreateMockRead(push_a, 1),          CreateMockRead(push_a_body, 2),
-      MockRead(ASYNC, ERR_IO_PENDING, 3), CreateMockRead(push_b, 4),
-      MockRead(ASYNC, ERR_IO_PENDING, 6), MockRead(ASYNC, 0, 7)  // EOF
+      CreateMockRead(push_a, 1),          CreateMockRead(push_a_body, 3),
+      MockRead(ASYNC, ERR_IO_PENDING, 4), CreateMockRead(push_b, 5),
+      MockRead(ASYNC, ERR_IO_PENDING, 8), MockRead(ASYNC, 0, 9)  // EOF
   };
 
   SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
   session_deps_.socket_factory->AddSocketDataProvider(&data);
 
   AddSSLSocketData();
 
   CreateNetworkSession();
   CreateSecureSpdySession();
 
@@ skipping 50 matching lines @@
                                      6, 1);
 }
 
 TEST_F(SpdySessionTest, CancelPushAfterExpired) {
   base::HistogramTester histogram_tester;
   session_deps_.host_resolver->set_synchronous_mode(true);
   session_deps_.time_func = TheNearFuture;
 
   SpdySerializedFrame req(
       spdy_util_.ConstructSpdyGet(nullptr, 0, 1, MEDIUM, true));
-  SpdySerializedFrame rst(
+  SpdySerializedFrame priority_a(
+      spdy_util_.ConstructSpdyPriority(2, 1, IDLE, true));
+  SpdySerializedFrame priority_b(
+      spdy_util_.ConstructSpdyPriority(4, 2, IDLE, true));
+  SpdySerializedFrame rst_a(
       spdy_util_.ConstructSpdyRstStream(2, RST_STREAM_REFUSED_STREAM));
-  MockWrite writes[] = {CreateMockWrite(req, 0), CreateMockWrite(rst, 5)};
+  MockWrite writes[] = {
+      CreateMockWrite(req, 0), CreateMockWrite(priority_a, 2),
+      CreateMockWrite(priority_b, 6), CreateMockWrite(rst_a, 7),
+  };
 
   SpdySerializedFrame push_a(spdy_util_.ConstructSpdyPush(
       nullptr, 0, 2, 1, "https://www.example.org/a.dat"));
   SpdySerializedFrame push_a_body(spdy_util_.ConstructSpdyDataFrame(2, false));
   // In ascii "0" < "a". We use it to verify that we properly handle std::map
   // iterators inside. See http://crbug.com/443490
   SpdySerializedFrame push_b(spdy_util_.ConstructSpdyPush(
       nullptr, 0, 4, 1, "https://www.example.org/0.dat"));
   MockRead reads[] = {
-      CreateMockRead(push_a, 1),          CreateMockRead(push_a_body, 2),
-      MockRead(ASYNC, ERR_IO_PENDING, 3), CreateMockRead(push_b, 4),
-      MockRead(ASYNC, ERR_IO_PENDING, 6), MockRead(ASYNC, 0, 7)  // EOF
+      CreateMockRead(push_a, 1),          CreateMockRead(push_a_body, 3),
+      MockRead(ASYNC, ERR_IO_PENDING, 4), CreateMockRead(push_b, 5),
+      MockRead(ASYNC, ERR_IO_PENDING, 8), MockRead(ASYNC, 0, 9)  // EOF
   };
 
   SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
   session_deps_.socket_factory->AddSocketDataProvider(&data);
 
   AddSSLSocketData();
 
   CreateNetworkSession();
   CreateSecureSpdySession();
 
@@ skipping 51 matching lines @@
                                      6, 1);
 }
 
 TEST_F(SpdySessionTest, CancelPushBeforeClaimed) {
   base::HistogramTester histogram_tester;
   session_deps_.host_resolver->set_synchronous_mode(true);
   session_deps_.time_func = TheNearFuture;
 
   SpdySerializedFrame req(
       spdy_util_.ConstructSpdyGet(nullptr, 0, 1, MEDIUM, true));
-  SpdySerializedFrame rst(
+  SpdySerializedFrame priority_a(
+      spdy_util_.ConstructSpdyPriority(2, 1, IDLE, true));
+  SpdySerializedFrame priority_b(
+      spdy_util_.ConstructSpdyPriority(4, 2, IDLE, true));
+  SpdySerializedFrame rst_a(
       spdy_util_.ConstructSpdyRstStream(2, RST_STREAM_REFUSED_STREAM));
-  MockWrite writes[] = {CreateMockWrite(req, 0), CreateMockWrite(rst, 5)};
+  MockWrite writes[] = {
+      CreateMockWrite(req, 0), CreateMockWrite(priority_a, 2),
+      CreateMockWrite(priority_b, 6), CreateMockWrite(rst_a, 7),
+  };
 
   SpdySerializedFrame push_a(spdy_util_.ConstructSpdyPush(
       nullptr, 0, 2, 1, "https://www.example.org/a.dat"));
   SpdySerializedFrame push_a_body(spdy_util_.ConstructSpdyDataFrame(2, false));
   // In ascii "0" < "a". We use it to verify that we properly handle std::map
   // iterators inside. See http://crbug.com/443490
   SpdySerializedFrame push_b(spdy_util_.ConstructSpdyPush(
       nullptr, 0, 4, 1, "https://www.example.org/0.dat"));
   MockRead reads[] = {
-      CreateMockRead(push_a, 1),          CreateMockRead(push_a_body, 2),
-      MockRead(ASYNC, ERR_IO_PENDING, 3), CreateMockRead(push_b, 4),
-      MockRead(ASYNC, ERR_IO_PENDING, 6), MockRead(ASYNC, 0, 7)  // EOF
+      CreateMockRead(push_a, 1),          CreateMockRead(push_a_body, 3),
+      MockRead(ASYNC, ERR_IO_PENDING, 4), CreateMockRead(push_b, 5),
+      MockRead(ASYNC, ERR_IO_PENDING, 8), MockRead(ASYNC, 0, 9)  // EOF
   };
 
   SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
   session_deps_.socket_factory->AddSocketDataProvider(&data);
 
   AddSSLSocketData();
 
   CreateNetworkSession();
   CreateSecureSpdySession();
 
@@ skipping 49 matching lines @@
                                      6, 1);
 }
 
 TEST_F(SpdySessionTest, DeleteExpiredPushStreams) {
   base::HistogramTester histogram_tester;
   session_deps_.host_resolver->set_synchronous_mode(true);
   session_deps_.time_func = TheNearFuture;
 
   SpdySerializedFrame req(
       spdy_util_.ConstructSpdyGet(nullptr, 0, 1, MEDIUM, true));
-  SpdySerializedFrame rst(
+  SpdySerializedFrame priority_a(
+      spdy_util_.ConstructSpdyPriority(2, 1, IDLE, true));
+  SpdySerializedFrame priority_b(
+      spdy_util_.ConstructSpdyPriority(4, 2, IDLE, true));
+  SpdySerializedFrame rst_a(
       spdy_util_.ConstructSpdyRstStream(2, RST_STREAM_REFUSED_STREAM));
-  MockWrite writes[] = {CreateMockWrite(req, 0), CreateMockWrite(rst, 5)};
+  MockWrite writes[] = {
+      CreateMockWrite(req, 0), CreateMockWrite(priority_a, 2),
+      CreateMockWrite(priority_b, 6), CreateMockWrite(rst_a, 7),
+  };
 
   SpdySerializedFrame push_a(spdy_util_.ConstructSpdyPush(
       nullptr, 0, 2, 1, "https://www.example.org/a.dat"));
   SpdySerializedFrame push_a_body(spdy_util_.ConstructSpdyDataFrame(2, false));
   // In ascii "0" < "a". We use it to verify that we properly handle std::map
   // iterators inside. See http://crbug.com/443490
   SpdySerializedFrame push_b(spdy_util_.ConstructSpdyPush(
       nullptr, 0, 4, 1, "https://www.example.org/0.dat"));
   MockRead reads[] = {
-      CreateMockRead(push_a, 1),          CreateMockRead(push_a_body, 2),
-      MockRead(ASYNC, ERR_IO_PENDING, 3), CreateMockRead(push_b, 4),
-      MockRead(ASYNC, ERR_IO_PENDING, 6), MockRead(ASYNC, 0, 7)  // EOF
+      CreateMockRead(push_a, 1),          CreateMockRead(push_a_body, 3),
+      MockRead(ASYNC, ERR_IO_PENDING, 4), CreateMockRead(push_b, 5),
+      MockRead(ASYNC, ERR_IO_PENDING, 8), MockRead(ASYNC, 0, 9)  // EOF
   };
 
   SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
   session_deps_.socket_factory->AddSocketDataProvider(&data);
 
   AddSSLSocketData();
 
   CreateNetworkSession();
   CreateSecureSpdySession();
 
@@ skipping 44 matching lines @@
                                      6, 1);
 }
 
 TEST_F(SpdySessionTest, MetricsCollectionOnPushStreams) {
   base::HistogramTester histogram_tester;
   session_deps_.host_resolver->set_synchronous_mode(true);
   session_deps_.time_func = TheNearFuture;
 
   SpdySerializedFrame req(
       spdy_util_.ConstructSpdyGet(nullptr, 0, 1, MEDIUM, true));
-  SpdySerializedFrame rst(
+  SpdySerializedFrame priority_a(
+      spdy_util_.ConstructSpdyPriority(2, 1, IDLE, true));
+  SpdySerializedFrame priority_b(
+      spdy_util_.ConstructSpdyPriority(4, 2, IDLE, true));
+  SpdySerializedFrame priority_c(
+      spdy_util_.ConstructSpdyPriority(6, 4, IDLE, true));
+  SpdySerializedFrame rst_a(
       spdy_util_.ConstructSpdyRstStream(2, RST_STREAM_REFUSED_STREAM));
-  MockWrite writes[] = {CreateMockWrite(req, 0), CreateMockWrite(rst, 5)};
+  MockWrite writes[] = {
+      CreateMockWrite(req, 0),         CreateMockWrite(priority_a, 2),
+      CreateMockWrite(priority_b, 6),  CreateMockWrite(rst_a, 7),
+      CreateMockWrite(priority_c, 10),
+  };
 
   SpdySerializedFrame push_a(spdy_util_.ConstructSpdyPush(
       nullptr, 0, 2, 1, "https://www.example.org/a.dat"));
   SpdySerializedFrame push_a_body(spdy_util_.ConstructSpdyDataFrame(2, false));
   // In ascii "0" < "a". We use it to verify that we properly handle std::map
   // iterators inside. See http://crbug.com/443490
   SpdySerializedFrame push_b(spdy_util_.ConstructSpdyPush(
       nullptr, 0, 4, 1, "https://www.example.org/0.dat"));
   SpdySerializedFrame push_c(spdy_util_.ConstructSpdyPush(
       nullptr, 0, 6, 1, "https://www.example.org/1.dat"));
   SpdySerializedFrame push_c_body(spdy_util_.ConstructSpdyDataFrame(6, false));
 
   MockRead reads[] = {
       CreateMockRead(push_a, 1),
-      CreateMockRead(push_a_body, 2),
-      MockRead(ASYNC, ERR_IO_PENDING, 3),
-      CreateMockRead(push_b, 4),
-      MockRead(ASYNC, ERR_IO_PENDING, 6),
-      CreateMockRead(push_c, 7),
-      CreateMockRead(push_c_body, 8),
-      MockRead(ASYNC, ERR_IO_PENDING, 9),
-      MockRead(ASYNC, 0, 10)  // EOF
+      CreateMockRead(push_a_body, 3),
+      MockRead(ASYNC, ERR_IO_PENDING, 4),
+      CreateMockRead(push_b, 5),
+      MockRead(ASYNC, ERR_IO_PENDING, 8),
+      CreateMockRead(push_c, 9),
+      CreateMockRead(push_c_body, 11),
+      MockRead(ASYNC, ERR_IO_PENDING, 12),
+      MockRead(ASYNC, 0, 13)  // EOF
   };
 
   SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
   session_deps_.socket_factory->AddSocketDataProvider(&data);
 
   AddSSLSocketData();
 
   CreateNetworkSession();
   CreateSecureSpdySession();
 
@@ skipping 3186 matching lines @@
   SettingsMap new_settings;
   new_settings[SETTINGS_MAX_CONCURRENT_STREAMS] = 2;
   SpdySerializedFrame settings_frame(
       spdy_util_.ConstructSpdySettings(new_settings));
   SpdySerializedFrame pushed(spdy_util_.ConstructSpdyPush(
       nullptr, 0, 2, 1, "https://www.example.org/a.dat"));
   MockRead reads[] = {
       CreateMockRead(settings_frame, 0),
       MockRead(ASYNC, ERR_IO_PENDING, 3),
       CreateMockRead(pushed, 4),
-      MockRead(ASYNC, ERR_IO_PENDING, 5),
-      MockRead(ASYNC, 0, 6),
+      MockRead(ASYNC, ERR_IO_PENDING, 6),
+      MockRead(ASYNC, 0, 7),
   };
 
   SpdySerializedFrame settings_ack(spdy_util_.ConstructSpdySettingsAck());
   SpdySerializedFrame req(
       spdy_util_.ConstructSpdyGet(nullptr, 0, 1, LOWEST, true));
+  SpdySerializedFrame priority(
+      spdy_util_.ConstructSpdyPriority(2, 1, IDLE, true));
   MockWrite writes[] = {
       CreateMockWrite(settings_ack, 1), CreateMockWrite(req, 2),
+      CreateMockWrite(priority, 5),
   };
 
   SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
   session_deps_.socket_factory->AddSocketDataProvider(&data);
 
   AddSSLSocketData();
 
   CreateNetworkSession();
   CreateSecureSpdySession();
 
@@ skipping 51 matching lines @@
   EXPECT_FALSE(session_);
 }
 
 TEST_F(SpdySessionTest, RejectPushedStreamExceedingConcurrencyLimit) {
   SpdySerializedFrame push_a(spdy_util_.ConstructSpdyPush(
       nullptr, 0, 2, 1, "https://www.example.org/a.dat"));
   SpdySerializedFrame push_b(spdy_util_.ConstructSpdyPush(
       nullptr, 0, 4, 1, "https://www.example.org/b.dat"));
   MockRead reads[] = {
       MockRead(ASYNC, ERR_IO_PENDING, 1), CreateMockRead(push_a, 2),
-      MockRead(ASYNC, ERR_IO_PENDING, 3), CreateMockRead(push_b, 4),
-      MockRead(ASYNC, ERR_IO_PENDING, 6), MockRead(ASYNC, 0, 7),
+      MockRead(ASYNC, ERR_IO_PENDING, 4), CreateMockRead(push_b, 5),
+      MockRead(ASYNC, ERR_IO_PENDING, 8), MockRead(ASYNC, 0, 9),
   };
 
   SpdySerializedFrame req(
       spdy_util_.ConstructSpdyGet(nullptr, 0, 1, LOWEST, true));
-  SpdySerializedFrame rst(
+  SpdySerializedFrame priority_a(
+      spdy_util_.ConstructSpdyPriority(2, 1, IDLE, true));
+  SpdySerializedFrame priority_b(
+      spdy_util_.ConstructSpdyPriority(4, 2, IDLE, true));
+  SpdySerializedFrame rst_b(
       spdy_util_.ConstructSpdyRstStream(4, RST_STREAM_REFUSED_STREAM));
   MockWrite writes[] = {
-      CreateMockWrite(req, 0), CreateMockWrite(rst, 5),
+      CreateMockWrite(req, 0), CreateMockWrite(priority_a, 3),
+      CreateMockWrite(priority_b, 6), CreateMockWrite(rst_b, 7),
   };
 
   SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
   session_deps_.socket_factory->AddSocketDataProvider(&data);
 
   AddSSLSocketData();
 
   CreateNetworkSession();
   CreateSecureSpdySession();
   session_->set_max_concurrent_pushed_streams(1);
@@ skipping 56 matching lines @@
   // cross_origin_push contains HTTP resource for an origin different from the
   // origin of kDefaultUrl, and should be accepted.
   SpdySerializedFrame cross_origin_push(spdy_util_.ConstructSpdyPush(
       nullptr, 0, 2, 1, kHttpURLFromAnotherOrigin));
   // cross_origin_https_push contains HTTPS resource, and should be refused.
   SpdySerializedFrame cross_origin_https_push(spdy_util_.ConstructSpdyPush(
       nullptr, 0, 4, 1, kHttpsURLFromAnotherOrigin));
   MockRead reads[] = {
       MockRead(ASYNC, ERR_IO_PENDING, 1),
       CreateMockRead(cross_origin_push, 2),
-      MockRead(ASYNC, ERR_IO_PENDING, 3),
-      CreateMockRead(cross_origin_https_push, 4),
-      MockRead(ASYNC, ERR_IO_PENDING, 6),
-      MockRead(ASYNC, 0, 7),
+      MockRead(ASYNC, ERR_IO_PENDING, 4),
+      CreateMockRead(cross_origin_https_push, 5),
+      MockRead(ASYNC, ERR_IO_PENDING, 7),
+      MockRead(ASYNC, 0, 8),
   };
 
   SpdySerializedFrame req(
       spdy_util_.ConstructSpdyGet(nullptr, 0, 1, LOWEST, true));
-  SpdySerializedFrame rst(
+  SpdySerializedFrame priority_http(
+      spdy_util_.ConstructSpdyPriority(2, 1, IDLE, true));
+  SpdySerializedFrame rst_https(
       spdy_util_.ConstructSpdyRstStream(4, RST_STREAM_REFUSED_STREAM));
   MockWrite writes[] = {
-      CreateMockWrite(req, 0), CreateMockWrite(rst, 5),
+      CreateMockWrite(req, 0), CreateMockWrite(priority_http, 3),
+      CreateMockWrite(rst_https, 6),
   };
 
   SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
   session_deps_.socket_factory->AddSocketDataProvider(&data);
 
   std::unique_ptr<TestProxyDelegate> proxy_delegate(new TestProxyDelegate());
   proxy_delegate->set_trusted_spdy_proxy(
       net::ProxyServer(net::ProxyServer::SCHEME_HTTPS,
                        HostPortPair(GURL(kDefaultUrl).host(), 443)));
   session_deps_.proxy_delegate = std::move(proxy_delegate);
@@ skipping 117 matching lines @@
   SpdySerializedFrame push_a(spdy_util_.ConstructSpdyPush(
       nullptr, 0, 2, 1, "https://www.example.org/a.dat"));
   SpdyHeaderBlock push_headers;
   spdy_util_.AddUrlToHeaderBlock("https://www.example.org/b.dat",
                                  &push_headers);
   SpdySerializedFrame push_b(
       spdy_util_.ConstructInitialSpdyPushFrame(std::move(push_headers), 4, 1));
   SpdySerializedFrame headers_b(
       spdy_util_.ConstructSpdyPushHeaders(4, nullptr, 0));
   MockRead reads[] = {
-      MockRead(ASYNC, ERR_IO_PENDING, 1), CreateMockRead(push_a, 2),
-      MockRead(ASYNC, ERR_IO_PENDING, 3), CreateMockRead(push_b, 4),
-      MockRead(ASYNC, ERR_IO_PENDING, 5), CreateMockRead(headers_b, 6),
-      MockRead(ASYNC, ERR_IO_PENDING, 8), MockRead(ASYNC, 0, 9),
+      MockRead(ASYNC, ERR_IO_PENDING, 1),  CreateMockRead(push_a, 2),
+      MockRead(ASYNC, ERR_IO_PENDING, 4),  CreateMockRead(push_b, 5),
+      MockRead(ASYNC, ERR_IO_PENDING, 7),  CreateMockRead(headers_b, 8),
+      MockRead(ASYNC, ERR_IO_PENDING, 10), MockRead(ASYNC, 0, 11),
   };
 
   SpdySerializedFrame req(
       spdy_util_.ConstructSpdyGet(nullptr, 0, 1, LOWEST, true));
-  SpdySerializedFrame rst(
+  SpdySerializedFrame priority_a(
+      spdy_util_.ConstructSpdyPriority(2, 1, IDLE, true));
+  SpdySerializedFrame priority_b(
+      spdy_util_.ConstructSpdyPriority(4, 2, IDLE, true));
+  SpdySerializedFrame rst_b(
       spdy_util_.ConstructSpdyRstStream(4, RST_STREAM_REFUSED_STREAM));
   MockWrite writes[] = {
-      CreateMockWrite(req, 0), CreateMockWrite(rst, 7),
+      CreateMockWrite(req, 0), CreateMockWrite(priority_a, 3),
+      CreateMockWrite(priority_b, 6), CreateMockWrite(rst_b, 9),
   };
 
   SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
   session_deps_.socket_factory->AddSocketDataProvider(&data);
 
   AddSSLSocketData();
 
   CreateNetworkSession();
   CreateSecureSpdySession();
   session_->set_max_concurrent_pushed_streams(1);
@@ skipping 57 matching lines @@
 TEST_F(SpdySessionTest, CancelReservedStreamOnHeadersReceived) {
   const char kPushedUrl[] = "https://www.example.org/a.dat";
   SpdyHeaderBlock push_headers;
   spdy_util_.AddUrlToHeaderBlock(kPushedUrl, &push_headers);
   SpdySerializedFrame push_promise(
       spdy_util_.ConstructInitialSpdyPushFrame(std::move(push_headers), 2, 1));
   SpdySerializedFrame headers_frame(
       spdy_util_.ConstructSpdyPushHeaders(2, nullptr, 0));
   MockRead reads[] = {
       MockRead(ASYNC, ERR_IO_PENDING, 1), CreateMockRead(push_promise, 2),
-      MockRead(ASYNC, ERR_IO_PENDING, 3), CreateMockRead(headers_frame, 4),
-      MockRead(ASYNC, ERR_IO_PENDING, 6), MockRead(ASYNC, 0, 7),
+      MockRead(ASYNC, ERR_IO_PENDING, 4), CreateMockRead(headers_frame, 5),
+      MockRead(ASYNC, ERR_IO_PENDING, 7), MockRead(ASYNC, 0, 8),
   };
 
   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_CANCEL));
   MockWrite writes[] = {
-      CreateMockWrite(req, 0), CreateMockWrite(rst, 5),
+      CreateMockWrite(req, 0), CreateMockWrite(priority, 3),
+      CreateMockWrite(rst, 6),
   };
 
   SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
   session_deps_.socket_factory->AddSocketDataProvider(&data);
 
   AddSSLSocketData();
 
   CreateNetworkSession();
   CreateSecureSpdySession();
 
@@ skipping 24 matching lines @@
 
   // Run until pushed stream is created.
   data.Resume();
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(2u, session_->num_active_streams());
   EXPECT_EQ(0u, session_->num_created_streams());
   EXPECT_EQ(1u, session_->num_pushed_streams());
   EXPECT_EQ(0u, session_->num_active_pushed_streams());
 
   base::WeakPtr<SpdyStream> pushed_stream;
-  int rv = session_->GetPushStream(GURL(kPushedUrl), &pushed_stream,
+  int rv = session_->GetPushStream(GURL(kPushedUrl), IDLE, &pushed_stream,
                                    NetLogWithSource());
   ASSERT_THAT(rv, IsOk());
   ASSERT_TRUE(pushed_stream);
   test::StreamDelegateCloseOnHeaders delegate2(pushed_stream);
   pushed_stream->SetDelegate(&delegate2);
 
   // Receive headers for pushed stream. Delegate will cancel the stream, ensure
   // that all our counters are in consistent state.
   data.Resume();
   base::RunLoop().RunUntilIdle();
@@ skipping 608 matching lines @@
   ssl_info.cert = ImportCertFromFile(GetTestCertsDirectory(),
                                      "spdy_pooling.pem");
   ssl_info.is_issued_by_known_root = true;
   ssl_info.public_key_hashes.push_back(test::GetTestHashValue(primary_pin));
 
   EXPECT_TRUE(SpdySession::CanPool(
       &tss, ssl_info, "www.example.org", "mail.example.org"));
 }
 
 }  // namespace net