Update from https://crrev.com/312398

net/quic/quic_session_test.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/quic/quic_session.h"
 
 #include <set>
 
 #include "base/basictypes.h"
 #include "base/containers/hash_tables.h"
@@ skipping 298 matching lines @@
 
 TEST_P(QuicSessionTest, StreamIdTooLarge) {
   QuicStreamId stream_id = kClientDataStreamId1;
   session_.GetIncomingDataStream(stream_id);
   EXPECT_CALL(*connection_, SendConnectionClose(QUIC_INVALID_STREAM_ID));
   session_.GetIncomingDataStream(stream_id + kMaxStreamIdDelta + 2);
 }
 
 TEST_P(QuicSessionTest, DecompressionError) {
   QuicHeadersStream* stream = QuicSessionPeer::GetHeadersStream(&session_);
+  if (version() > QUIC_VERSION_23) {
+    // This test does not apply to HPACK compression.
+    return;
+  }
   const unsigned char data[] = {
     0x80, 0x03, 0x00, 0x01,  // SPDY/3 SYN_STREAM frame
     0x00, 0x00, 0x00, 0x25,  // flags/length
     0x00, 0x00, 0x00, 0x05,  // stream id
     0x00, 0x00, 0x00, 0x00,  // associated stream id
     0x00, 0x00,
     'a',  'b',  'c',  'd'    // invalid compressed data
   };
   EXPECT_CALL(*connection_, SendConnectionCloseWithDetails(
                                 QUIC_INVALID_HEADERS_STREAM_DATA,
@@ skipping 387 matching lines @@
   EXPECT_FALSE(session_.IsStreamFlowControlBlocked());
   QuicStreamId stream_id = 5;
   // Write until the header stream is flow control blocked.
   SpdyHeaderBlock headers;
   while (!headers_stream->flow_controller()->IsBlocked() && stream_id < 2000) {
     EXPECT_FALSE(session_.IsConnectionFlowControlBlocked());
     EXPECT_FALSE(session_.IsStreamFlowControlBlocked());
     headers["header"] = base::Uint64ToString(base::RandUint64()) +
         base::Uint64ToString(base::RandUint64()) +
         base::Uint64ToString(base::RandUint64());
-    headers_stream->WriteHeaders(stream_id, headers, true, nullptr);
+    headers_stream->WriteHeaders(stream_id, headers, true, 0, nullptr);
     stream_id += 2;
   }
   // Write once more to ensure that the headers stream has buffered data. The
   // random headers may have exactly filled the flow control window.
-  headers_stream->WriteHeaders(stream_id, headers, true, nullptr);
+  headers_stream->WriteHeaders(stream_id, headers, true, 0, nullptr);
   EXPECT_TRUE(headers_stream->HasBufferedData());
 
   EXPECT_TRUE(headers_stream->flow_controller()->IsBlocked());
   EXPECT_FALSE(crypto_stream->flow_controller()->IsBlocked());
   EXPECT_FALSE(session_.IsConnectionFlowControlBlocked());
   EXPECT_TRUE(session_.IsStreamFlowControlBlocked());
   EXPECT_FALSE(session_.HasDataToWrite());
 
   // Now complete the crypto handshake, resulting in an increased flow control
   // send window.
@@ skipping 221 matching lines @@
   }
 
   // Called after any new data is received by the session, and triggers the call
   // to close the connection.
   session_.PostProcessAfterData();
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net