Land Recent QUIC Changes.

net/quic/quic_connection.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 entity that handles framing writes for a Quic client or server.
 // Each QuicSession will have a connection associated with it.
 //
 // On the server side, the Dispatcher handles the raw reads, and hands off
 // packets via ProcessUdpPacket for framing and processing.
 //
@@ skipping 31 matching lines @@
 #include "net/quic/quic_sent_packet_manager.h"
 
 namespace net {
 
 class QuicClock;
 class QuicConfig;
 class QuicConnection;
 class QuicDecrypter;
 class QuicEncrypter;
 class QuicFecGroup;
-class QuicFlowController;
 class QuicRandom;
 
 namespace test {
 class QuicConnectionPeer;
 }  // namespace test
 
 // Class that receives callbacks from the connection when frames are received
 // and when other interesting events happen.
 class NET_EXPORT_PRIVATE QuicConnectionVisitorInterface {
  public:
@@ skipping 24 matching lines @@
 
   // Called when the connection failed to write because the socket was blocked.
   virtual void OnWriteBlocked() = 0;
 
   // Called once a specific QUIC version is agreed by both endpoints.
   virtual void OnSuccessfulVersionNegotiation(const QuicVersion& version) = 0;
 
   // Called when a blocked socket becomes writable.
   virtual void OnCanWrite() = 0;
 
-  // Called to ask if any writes are pending in this visitor. Writes may be
-  // pending because they were write-blocked, congestion-throttled or
-  // yielded to other connections.
-  virtual bool HasPendingWrites() const = 0;
+  // Called to ask if the visitor wants to schedule write resumption as it has
+  // both has pending data to write, and is able to write (e.g. based on flow

[wtc, 2014/05/19 18:58:40]

Nit: has both has => both has

[ramant (doing other things), 2014/05/20 03:22:32]

Done.

+  // control limits).
+  // Writes may be pending because they were write-blocked, congestion-throttled
+  // or yielded to other connections.
+  virtual bool WillingAndAbleToWrite() const = 0;
 
   // Called to ask if any handshake messages are pending in this visitor.
   virtual bool HasPendingHandshake() const = 0;
 
   // Called to ask if any streams are open in this visitor, excluding the
   // reserved crypto and headers stream.
   virtual bool HasOpenDataStreams() const = 0;
 };
 
 // Interface which gets callbacks from the QuicConnection at interesting
@@ skipping 99 matching lines @@
     BUNDLE_PENDING_ACK = 2,
   };
 
   // Constructs a new QuicConnection for |connection_id| and |address|.
   // |helper| and |writer| must outlive this connection.
   QuicConnection(QuicConnectionId connection_id,
                  IPEndPoint address,
                  QuicConnectionHelperInterface* helper,
                  QuicPacketWriter* writer,
                  bool is_server,
-                 const QuicVersionVector& supported_versions,
-                 uint32 max_flow_control_receive_window_bytes);
+                 const QuicVersionVector& supported_versions);
   virtual ~QuicConnection();
 
   // Sets connection parameters from the supplied |config|.
   void SetFromConfig(const QuicConfig& config);
 
   // Send the data in |data| to the peer in as few packets as possible.
   // Returns a pair with the number of bytes consumed from data, and a boolean
   // indicating if the fin bit was consumed.  This does not indicate the data
   // has been sent on the wire: it may have been turned into a packet and queued
   // if the socket was unexpectedly blocked.
@@ skipping 28 matching lines @@
   // calling CloseConnection(notifying the visitor as it does so).
   virtual void SendConnectionClose(QuicErrorCode error);
   virtual void SendConnectionCloseWithDetails(QuicErrorCode error,
                                               const std::string& details);
   // Notifies the visitor of the close and marks the connection as disconnected.
   virtual void CloseConnection(QuicErrorCode error, bool from_peer) OVERRIDE;
   virtual void SendGoAway(QuicErrorCode error,
                           QuicStreamId last_good_stream_id,
                           const std::string& reason);
 
-  QuicFlowController* flow_controller() { return flow_controller_.get(); }
-
   // Returns statistics tracked for this connection.
   const QuicConnectionStats& GetStats();
 
   // Processes an incoming UDP packet (consisting of a QuicEncryptedPacket) from
   // the peer.  If processing this packet permits a packet to be revived from
   // its FEC group that packet will be revived and processed.
   virtual void ProcessUdpPacket(const IPEndPoint& self_address,
                                 const IPEndPoint& peer_address,
                                 const QuicEncryptedPacket& packet);
 
@@ skipping 171 matching lines @@
   bool is_server() const { return is_server_; }
 
   // Returns the underlying sent packet manager.
   const QuicSentPacketManager& sent_packet_manager() const {
     return sent_packet_manager_;
   }
 
   bool CanWrite(TransmissionType transmission_type,
                 HasRetransmittableData retransmittable);
 
-  uint32 max_flow_control_receive_window_bytes() const {
-    return max_flow_control_receive_window_bytes_;
-  }
-
   // Stores current batch state for connection, puts the connection
   // into batch mode, and destruction restores the stored batch state.
   // While the bundler is in scope, any generated frames are bundled
   // as densely as possible into packets.  In addition, this bundler
   // can be configured to ensure that an ACK frame is included in the
   // first packet created, if there's new ack information to be sent.
   class ScopedPacketBundler {
    public:
     // In addition to all outgoing frames being bundled when the
     // bundler is in scope, setting |include_ack| to true ensures that
@@ skipping 276 matching lines @@
   bool self_ip_changed_;
 
   // Set to true if the UDP packet headers are addressed to a different port.
   // We do not support connection migration when the self port changed.
   bool self_port_changed_;
 
   // If non-empty this contains the set of versions received in a
   // version negotiation packet.
   QuicVersionVector server_supported_versions_;
 
-  // Initial flow control receive window size for new streams.
-  uint32 max_flow_control_receive_window_bytes_;
-
-  // Used for connection level flow control.
-  scoped_ptr<QuicFlowController> flow_controller_;
-
   DISALLOW_COPY_AND_ASSIGN(QuicConnection);
 };
 
 }  // namespace net
 
 #endif  // NET_QUIC_QUIC_CONNECTION_H_