Eliminate separate boolean tracking socket writeability in

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 233 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 144 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_