Land Recent QUIC Changes until 03/02/2015.

net/quic/quic_flow_controller.h

 // Copyright 2014 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.
 
 #ifndef NET_QUIC_QUIC_FLOW_CONTROLLER_H_
 #define NET_QUIC_QUIC_FLOW_CONTROLLER_H_
 
 #include "base/basictypes.h"
 #include "net/base/net_export.h"
 #include "net/quic/quic_protocol.h"
@@ skipping 38 matching lines @@
   // Set a new send window offset.
   // Returns true if this increases send_window_offset_ and is now blocked.
   bool UpdateSendWindowOffset(QuicStreamOffset new_send_window_offset);
 
   // Returns the current available send window.
   QuicByteCount SendWindowSize() const;
 
   // Send a BLOCKED frame if appropriate.
   void MaybeSendBlocked();
 
-  // Disable flow control.
-  void Disable();
-
-  // Returns true if flow control is enabled.
-  bool IsEnabled() const;
-
   // Returns true if flow control send limits have been reached.
   bool IsBlocked() const;
 
   // Returns true if flow control receive limits have been violated by the peer.
   bool FlowControlViolation();
 
   QuicByteCount bytes_consumed() const { return bytes_consumed_; }
 
   QuicStreamOffset highest_received_byte_offset() const {
     return highest_received_byte_offset_;
   }
 
  private:
   friend class test::QuicFlowControllerPeer;
 
   // Send a WINDOW_UPDATE frame if appropriate.
   void MaybeSendWindowUpdate();
 
   // The parent connection, used to send connection close on flow control
   // violation, and WINDOW_UPDATE and BLOCKED frames when appropriate.
   // Not owned.
   QuicConnection* connection_;
 
   // ID of stream this flow controller belongs to. This can be 0 if this is a
   // connection level flow controller.
   QuicStreamId id_;
 
-  // True if flow control is enabled.
-  bool is_enabled_;
-
   // True if this is owned by a server.
   bool is_server_;
 
   // Track number of bytes received from the peer, which have been consumed
   // locally.
   QuicByteCount bytes_consumed_;
 
   // The highest byte offset we have seen from the peer. This could be the
   // highest offset in a data frame, or a final value in a RST.
   QuicStreamOffset highest_received_byte_offset_;
@@ skipping 15 matching lines @@
   // Keep track of the last time we sent a BLOCKED frame. We should only send
   // another when the number of bytes we have sent has changed.
   QuicStreamOffset last_blocked_send_window_offset_;
 
   DISALLOW_COPY_AND_ASSIGN(QuicFlowController);
 };
 
 }  // namespace net
 
 #endif  // NET_QUIC_QUIC_FLOW_CONTROLLER_H_