Land Recent QUIC Changes.

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>
 
 #include <list>
 
 #include "base/basictypes.h"
 #include "base/memory/ref_counted.h"
 #include "base/strings/string_piece.h"
 #include "net/base/iovec.h"
 #include "net/base/net_export.h"
 #include "net/quic/quic_ack_notifier.h"
+#include "net/quic/quic_flow_controller.h"
 #include "net/quic/quic_protocol.h"
 #include "net/quic/quic_stream_sequencer.h"
 
 namespace net {
 
 namespace test {
 class ReliableQuicStreamPeer;
 }  // namespace test
 
 class QuicSession;
@@ skipping 56 matching lines @@
   uint64 stream_bytes_written() const { return stream_bytes_written_; }
 
   QuicVersion version() const;
 
   void set_fin_sent(bool fin_sent) { fin_sent_ = fin_sent; }
   void set_rst_sent(bool rst_sent) { rst_sent_ = rst_sent; }
 
   // Adjust our flow control windows according to new offset in |frame|.
   virtual void OnWindowUpdateFrame(const QuicWindowUpdateFrame& frame);
 
-  // True if this stream is blocked from writing due to flow control limits.
-  bool IsFlowControlBlocked() const;
-
   // Updates our send window offset (if offset larger).
   void UpdateFlowControlSendLimit(QuicStreamOffset offset);
 
   // If our receive window has dropped below the threshold, then send a
   // WINDOW_UPDATE frame. This is called whenever bytes are consumed from the
   // sequencer's buffer.
   void MaybeSendWindowUpdate();
 
   int num_frames_received();
 
   int num_duplicate_frames_received();
 
+  QuicFlowController* flow_controller() { return &flow_controller_; }
+
  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.
@@ skipping 15 matching lines @@
   bool HasBufferedData();
 
   bool fin_buffered() { return fin_buffered_; }
 
   const QuicSession* session() const { return session_; }
   QuicSession* session() { return session_; }
 
   const QuicStreamSequencer* sequencer() const { return &sequencer_; }
   QuicStreamSequencer* sequencer() { return &sequencer_; }
 
-  // Returns true if flow control is enabled for this stream.
-  virtual bool IsFlowControlEnabled() const = 0;
+  void DisableFlowControl() {
+    flow_controller_.Disable();
+  }
 
  private:
   friend class test::ReliableQuicStreamPeer;
   friend class QuicStreamUtils;
   class ProxyAckNotifierDelegate;
 
   struct PendingData {
     PendingData(string data_in,
                 scoped_refptr<ProxyAckNotifierDelegate> delegate_in);
     ~PendingData();
@@ skipping 21 matching lines @@
   uint64 stream_bytes_written_;
 
   // Stream error code received from a RstStreamFrame or error code sent by the
   // visitor or sequencer in the RstStreamFrame.
   QuicRstStreamErrorCode stream_error_;
   // Connection error code due to which the stream was closed. |stream_error_|
   // is set to |QUIC_STREAM_CONNECTION_ERROR| when this happens and consumers
   // should check |connection_error_|.
   QuicErrorCode connection_error_;
 
-  // Stream level flow control.
-  // This stream is allowed to send up to flow_control_send_limit_ bytes. Once
-  // it has reached this limit it must not send more data until it receives a
-  // suitable WINDOW_UPDATE frame from the peer.
-  QuicStreamOffset flow_control_send_limit_;
-
-  // Stream level flow control.
-  // The maximum size of the stream receive window. Used to determine by how
-  // much we should increase the window offset when sending a WINDOW_UPDATE.
-  uint64 max_flow_control_receive_window_bytes_;
-
-  // Stream level flow control.
-  // This stream expects to receive up to receive_window_offset_bytes_.
-  // If the peer sends more than this (without sending us a WINDOW_UPDATE frame
-  // first), then this is a flow control error.
-  QuicStreamOffset flow_control_receive_window_offset_bytes_;
-
   // True if the read side is closed and further frames should be rejected.
   bool read_side_closed_;
   // True if the write side is closed, and further writes should fail.
   bool write_side_closed_;
 
   bool fin_buffered_;
   bool fin_sent_;
 
   // In combination with fin_sent_, used to ensure that a FIN and/or a RST is
   // always sent before stream termination.
   bool rst_sent_;
 
   // True if the session this stream is running under is a server session.
   bool is_server_;
 
+  QuicFlowController flow_controller_;
+
   DISALLOW_COPY_AND_ASSIGN(ReliableQuicStream);
 };
 
 }  // namespace net
 
 #endif  // NET_QUIC_RELIABLE_QUIC_STREAM_H_