This QUIC change includes:

net/quic/core/quic_spdy_stream_test.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 "net/quic/core/quic_spdy_stream.h"
 
 #include <memory>
 #include <utility>
 
 #include "net/quic/core/quic_connection.h"
@@ skipping 37 matching lines @@
     char buffer[2048];
     struct iovec vec;
     vec.iov_base = buffer;
     vec.iov_len = arraysize(buffer);
     size_t bytes_read = Readv(&vec, 1);
     data_ += string(buffer, bytes_read);
   }
 
   using QuicStream::WriteOrBufferData;
   using QuicStream::CloseWriteSide;
+  using QuicSpdyStream::set_ack_listener;
 
   const string& data() const { return data_; }
 
  private:
   bool should_process_data_;
   string data_;
 };
 
 class QuicSpdyStreamTest : public QuicTestWithParam<QuicVersion> {
  public:
@@ skipping 888 matching lines @@
   EXPECT_CALL(*session_, WriteHeadersMock(_, _, _, _, _));
   stream_->WriteHeaders(SpdyHeaderBlock(), /*fin=*/true, nullptr);
   EXPECT_TRUE(stream_->fin_sent());
 
   // Writing Trailers should fail, as the FIN has already been sent.
   // populated with the number of body bytes written.
   EXPECT_QUIC_BUG(stream_->WriteTrailers(SpdyHeaderBlock(), nullptr),
                   "Trailers cannot be sent after a FIN");
 }
 
+TEST_P(QuicSpdyStreamTest, HeaderStreamNotiferCorrespondingSpdyStream) {
+  Initialize(kShouldProcessData);
+  if (!session_->use_stream_notifier()) {
+    return;
+  }
+
+  EXPECT_CALL(*session_, WritevData(_, _, _, _, _, _))
+      .Times(AnyNumber())
+      .WillRepeatedly(Invoke(MockQuicSession::ConsumeAllData));
+  testing::InSequence s;
+  QuicReferenceCountedPointer<MockAckListener> ack_listener1(
+      new MockAckListener());
+  QuicReferenceCountedPointer<MockAckListener> ack_listener2(
+      new MockAckListener());
+  stream_->set_ack_listener(ack_listener1);
+  stream2_->set_ack_listener(ack_listener2);
+
+  session_->headers_stream()->WriteOrBufferData("Header1", false,
+                                                ack_listener1);
+  stream_->WriteOrBufferData("Test1", true, nullptr);
+
+  session_->headers_stream()->WriteOrBufferData("Header2", false,
+                                                ack_listener2);
+  stream2_->WriteOrBufferData("Test2", false, nullptr);
+
+  QuicStreamFrame frame1(kHeadersStreamId, false, 0, "Header1");
+  QuicStreamFrame frame2(stream_->id(), true, 0, "Test1");
+  QuicStreamFrame frame3(kHeadersStreamId, false, 7, "Header2");
+  QuicStreamFrame frame4(stream2_->id(), false, 0, "Test2");
+
+  EXPECT_CALL(*ack_listener1, OnPacketRetransmitted(7));
+  session_->OnStreamFrameRetransmitted(frame1);
+
+  EXPECT_CALL(*ack_listener1, OnPacketAcked(7, _));
+  session_->OnStreamFrameAcked(frame1, QuicTime::Delta::Zero());
+  EXPECT_CALL(*ack_listener1, OnPacketAcked(5, _));
+  session_->OnStreamFrameAcked(frame2, QuicTime::Delta::Zero());
+  EXPECT_CALL(*ack_listener2, OnPacketAcked(7, _));
+  session_->OnStreamFrameAcked(frame3, QuicTime::Delta::Zero());
+  EXPECT_CALL(*ack_listener2, OnPacketAcked(5, _));
+  session_->OnStreamFrameAcked(frame4, QuicTime::Delta::Zero());
+}
+
 }  // namespace
 }  // namespace test
 }  // namespace net