Fix a QUIC bug where the headers stream becomes flow control blocked and

net/quic/reliable_quic_stream.h

 // 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.
 //
 // The base class for client/server reliable streams.
 
 #ifndef NET_QUIC_RELIABLE_QUIC_STREAM_H_
 #define NET_QUIC_RELIABLE_QUIC_STREAM_H_
 
 #include <sys/types.h>
@@ skipping 93 matching lines @@
   // Called when we see a frame which could increase the highest offset.
   // Returns true if the highest offset did increase.
   bool MaybeIncreaseHighestReceivedOffset(uint64 new_offset);
   // Called when bytese are sent to the peer.
   void AddBytesSent(uint64 bytes);
   // Called by the stream sequencer as bytes are consumed from the buffer.
   // If our receive window has dropped below the threshold, then send a
   // WINDOW_UPDATE frame.
   void AddBytesConsumed(uint64 bytes);
 
+  // Updates the flow controller's send window offset and calls OnCanWrite if
+  // it was blocked before.
+  void UpdateSendWindowOffset(uint64 new_offset);
+
   // Returns true if the stream is flow control blocked, by the stream flow
   // control window or the connection flow control window.
   bool IsFlowControlBlocked();
 
   // Returns true if we have received either a RST or a FIN - either of which
   // gives a definitive number of bytes which the peer has sent. If this is not
   // true on stream termination the session must keep track of the stream's byte
   // offset until a definitive final value arrives.
   bool HasFinalReceivedByteOffset() const {
     return fin_received_ || rst_received_;
   }
 
+  // Returns true if the stream has queued data waiting to write.
+  bool HasBufferedData() const;
+
  protected:
   // Sends as much of 'data' to the connection as the connection will consume,
   // and then buffers any remaining data in queued_data_.
   void WriteOrBufferData(
       base::StringPiece data,
       bool fin,
       QuicAckNotifier::DelegateInterface* ack_notifier_delegate);
 
   // Sends as many bytes in the first |count| buffers of |iov| to the connection
   // as the connection will consume.
   // If |ack_notifier_delegate| is provided, then it will be notified once all
   // the ACKs for this write have been received.
   // Returns the number of bytes consumed by the connection.
   QuicConsumedData WritevData(
       const struct iovec* iov,
       int iov_count,
       bool fin,
       QuicAckNotifier::DelegateInterface* ack_notifier_delegate);
 
   // Helper method that returns FecProtection to use for writes to the session.
   FecProtection GetFecProtection();
 
   // Close the read side of the socket.  Further frames will not be accepted.
   virtual void CloseReadSide();
 
   // Close the write side of the socket.  Further writes will fail.
   void CloseWriteSide();
 
-  bool HasBufferedData() const;
-
   bool fin_buffered() const { return fin_buffered_; }
 
   const QuicSession* session() const { return session_; }
   QuicSession* session() { return session_; }
 
   const QuicStreamSequencer* sequencer() const { return &sequencer_; }
   QuicStreamSequencer* sequencer() { return &sequencer_; }
 
   // TODO(rjshade): Remove this method when removing QUIC_VERSION_19.
   void DisableFlowControl() {
@@ skipping 77 matching lines @@
   // connection level flow control limits (but are stream level flow control
   // limited).
   bool stream_contributes_to_connection_flow_control_;
 
   DISALLOW_COPY_AND_ASSIGN(ReliableQuicStream);
 };
 
 }  // namespace net
 
 #endif  // NET_QUIC_RELIABLE_QUIC_STREAM_H_