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 57 matching lines @@
   virtual bool OnStreamFrames(const std::vector<QuicStreamFrame>& frames) = 0;
 
   // Called when the stream is reset by the peer.
   virtual void OnRstStream(const QuicRstStreamFrame& frame) = 0;
 
   // Called when the connection is going away according to the peer.
   virtual void OnGoAway(const QuicGoAwayFrame& frame) = 0;
 
   // Called when the connection is closed either locally by the framer, or
   // remotely by the peer.
-  virtual void OnConnectionClosed(QuicErrorCode error,
-                                  bool from_peer) = 0;
+  virtual void OnConnectionClosed(QuicErrorCode error, bool from_peer) = 0;
+
+  // 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;
 
   // Indicates a new QuicConfig has been negotiated.
   virtual void OnConfigNegotiated() = 0;
 
   // Called when a blocked socket becomes writable.  If all pending bytes for
   // this visitor are consumed by the connection successfully this should
   // return true, otherwise it should return false.
@@ skipping 152 matching lines @@
                                 const QuicEncryptedPacket& packet);
 
   // QuicBlockedWriterInterface
   // Called when the underlying connection becomes writable to allow queued
   // writes to happen.  Returns false if the socket has become blocked.
   virtual bool OnCanWrite() OVERRIDE;
 
   // Called when a packet has been finally sent to the network.
   bool OnPacketSent(WriteResult result);
 
-  // If the socket is not blocked, this allows queued writes to happen. Returns
-  // false if the socket has become blocked.
-  bool WriteIfNotBlocked();
+  // If the socket is not blocked, writes queued packets.
+  void WriteIfNotBlocked();
 
   // Do any work which logically would be done in OnPacket but can not be
   // safely done until the packet is validated.  Returns true if the packet
   // can be handled, false otherwise.
   bool ProcessValidatedPacket();
 
   // The version of the protocol this connection is using.
   QuicVersion version() const { return framer_.version(); }
 
   // The versions of the protocol that this connection supports.
@@ skipping 67 matching lines @@
   size_t NumQueuedPackets() const { return queued_packets_.size(); }
 
   QuicEncryptedPacket* ReleaseConnectionClosePacket() {
     return connection_close_packet_.release();
   }
 
   // Flush any queued frames immediately.  Preserves the batch write mode and
   // does nothing if there are no pending frames.
   void Flush();
 
+  // Returns true if the underlying UDP socket is writable, there is
+  // no queued data and the connection is not congestion-control
+  // blocked.
+  bool CanWriteStreamData();
+
   // Returns true if the connection has queued packets or frames.
   bool HasQueuedData() const;
 
   // Sets (or resets) the idle state connection timeout. Also, checks and times
   // out the connection if network timer has expired for |timeout|.
   void SetIdleNetworkTimeout(QuicTime::Delta timeout);
   // Sets (or resets) the total time delta the connection can be alive for.
   // Also, checks and times out the connection if timer has expired for
   // |timeout|. Used to limit the time a connection can be alive before crypto
   // handshake finishes.
@@ skipping 52 matching lines @@
   }
 
   bool CanWrite(TransmissionType transmission_type,
                 HasRetransmittableData retransmittable,
                 IsHandshake handshake);
 
  protected:
   // Send a packet to the peer using encryption |level|. If |sequence_number|
   // is present in the |retransmission_map_|, then contents of this packet will
   // be retransmitted with a new sequence number if it's not acked by the peer.
-  // Deletes |packet| via WritePacket call or transfers ownership to
-  // QueuedPacket, ultimately deleted via WritePacket. Updates the
+  // Deletes |packet| if WritePacket call succeeds, or transfers ownership to
+  // QueuedPacket, ultimately deleted in WriteQueuedPackets. Updates the
   // entropy map corresponding to |sequence_number| using |entropy_hash|.
   // |transmission_type| and |retransmittable| are supplied to the congestion
   // manager, and when |forced| is true, it bypasses the congestion manager.
   // TODO(wtc): none of the callers check the return value.
   virtual bool SendOrQueuePacket(EncryptionLevel level,
                                  const SerializedPacket& packet,
                                  TransmissionType transmission_type);
 
   // Writes the given packet to socket, encrypted with |level|, with the help
   // of helper. Returns true on successful write, false otherwise. However,
   // behavior is undefined if connection is not established or broken. In any
   // circumstances, a return value of true implies that |packet| has been
-  // deleted and should not be accessed. If |sequence_number| is present in
+  // transmitted and may be destroyed. If |sequence_number| is present in
   // |retransmission_map_| it also sets up retransmission of the given packet
   // in case of successful write. If |force| is FORCE, then the packet will be
   // sent immediately and the send scheduler will not be consulted.
   bool WritePacket(EncryptionLevel level,
                    QuicPacketSequenceNumber sequence_number,
                    QuicPacket* packet,
                    TransmissionType transmission_type,
                    HasRetransmittableData retransmittable,
                    IsHandshake handshake,
                    Force force);
@@ skipping 86 matching lines @@
 
   typedef std::list<QueuedPacket> QueuedPacketList;
   typedef std::map<QuicFecGroupNumber, QuicFecGroup*> FecGroupMap;
 
   // Sends a version negotiation packet to the peer.
   void SendVersionNegotiationPacket();
 
   // Clears any accumulated frames from the last received packet.
   void ClearLastFrames();
 
-  // Called from OnCanWrite and WriteIfNotBlocked to write queued packets.
-  // Returns false if the socket has become blocked.
-  bool DoWrite();
-
   // Calculates the smallest sequence number length that can also represent four
   // times the maximum of the congestion window and the difference between the
   // least_packet_awaited_by_peer_ and |sequence_number|.
   QuicSequenceNumberLength CalculateSequenceNumberLength(
       QuicPacketSequenceNumber sequence_number);
 
   // Drop packet corresponding to |sequence_number| by deleting entries from
   // |unacked_packets_| and |retransmission_map_|, if present. We need to drop
   // all packets with encryption level NONE after the default level has been set
   // to FORWARD_SECURE.
   void DropPacket(QuicPacketSequenceNumber sequence_number);
 
   // Writes as many queued packets as possible.  The connection must not be
   // blocked when this is called.
-  bool WriteQueuedPackets();
+  void WriteQueuedPackets();
 
   // Writes as many pending retransmissions as possible.
   void WritePendingRetransmissions();
 
   // Returns true if the packet should be discarded and not sent.
   bool ShouldDiscardPacket(EncryptionLevel level,
                            QuicPacketSequenceNumber sequence_number,
                            HasRetransmittableData retransmittable);
 
   // Queues |packet| in the hopes that it can be decrypted in the
@@ skipping 69 matching lines @@
   // they are added to this list.  All corresponding frames are in
   // unacked_packets_ if they are to be retransmitted.
   QueuedPacketList queued_packets_;
 
   // Contains information about the current write in progress, if any.
   scoped_ptr<PendingWrite> pending_write_;
 
   // Contains the connection close packet if the connection has been closed.
   scoped_ptr<QuicEncryptedPacket> connection_close_packet_;
 
-  // True when the socket becomes unwritable.
-  bool write_blocked_;
-
   FecGroupMap group_map_;
 
   QuicReceivedPacketManager received_packet_manager_;
   QuicSentEntropyManager sent_entropy_manager_;
 
   // An alarm that fires when an ACK should be sent to the peer.
   scoped_ptr<QuicAlarm> ack_alarm_;
   // An alarm that fires when a packet needs to be retransmitted.
   scoped_ptr<QuicAlarm> retransmission_alarm_;
   // An alarm that is scheduled when the sent scheduler requires a
@@ skipping 55 matching lines @@
   // If non-empty this contains the set of versions received in a
   // version negotiation packet.
   QuicVersionVector server_supported_versions_;
 
   DISALLOW_COPY_AND_ASSIGN(QuicConnection);
 };
 
 }  // namespace net
 
 #endif  // NET_QUIC_QUIC_CONNECTION_H_