QUIC cleanup to remove an unused bool argument in SendOrQueuePacket and

net/quic/quic_connection.cc

 // 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.
 
 #include "net/quic/quic_connection.h"
 
 #include <string.h>
 #include <sys/types.h>
 #include <algorithm>
 #include <iterator>
@@ skipping 1477 matching lines @@
   return false;
 }
 
 void QuicConnection::OnWriteError(int error_code) {
   DVLOG(1) << ENDPOINT << "Write failed with error: " << error_code
            << " (" << ErrorToString(error_code) << ")";
   // We can't send an error as the socket is presumably borked.
   CloseConnection(QUIC_PACKET_WRITE_ERROR, false);
 }
 
-bool QuicConnection::OnSerializedPacket(
+void QuicConnection::OnSerializedPacket(
     const SerializedPacket& serialized_packet) {
   if (serialized_packet.retransmittable_frames) {
     serialized_packet.retransmittable_frames->
         set_encryption_level(encryption_level_);
   }
   sent_packet_manager_.OnSerializedPacket(serialized_packet);
   // The TransmissionType is NOT_RETRANSMISSION because all retransmissions
   // serialize packets and invoke SendOrQueuePacket directly.
-  return SendOrQueuePacket(encryption_level_,
-                           serialized_packet,
-                           NOT_RETRANSMISSION);
+  SendOrQueuePacket(encryption_level_, serialized_packet, NOT_RETRANSMISSION);
 }
 
 void QuicConnection::OnCongestionWindowChange(QuicByteCount congestion_window) {
   packet_generator_.OnCongestionWindowChange(congestion_window);
   visitor_->OnCongestionWindowChange(clock_->ApproximateNow());
 }
 
 void QuicConnection::OnHandshakeComplete() {
   sent_packet_manager_.SetHandshakeConfirmed();
 }
 
-bool QuicConnection::SendOrQueuePacket(EncryptionLevel level,
+void QuicConnection::SendOrQueuePacket(EncryptionLevel level,
                                        const SerializedPacket& packet,
                                        TransmissionType transmission_type) {
   // The caller of this function is responsible for checking CanWrite().
   if (packet.packet == NULL) {
     LOG(DFATAL) << "NULL packet passed in to SendOrQueuePacket";
-    return true;
+    return;
   }
 
   sent_entropy_manager_.RecordPacketEntropyHash(packet.sequence_number,
                                                 packet.entropy_hash);
   QueuedPacket queued_packet(packet, level, transmission_type);
   LOG_IF(DFATAL, !queued_packets_.empty() && !writer_->IsWriteBlocked())
       << "Packets should only be left queued if we're write blocked.";
   if (WritePacket(queued_packet)) {
     delete packet.packet;
-    return true;
+  } else {
+    queued_packets_.push_back(queued_packet);
   }
-  queued_packets_.push_back(queued_packet);
-  return false;
 }
 
 void QuicConnection::UpdateStopWaiting(QuicStopWaitingFrame* stop_waiting) {
   stop_waiting->least_unacked = GetLeastUnacked();
   stop_waiting->entropy_hash = sent_entropy_manager_.GetCumulativeEntropy(
       stop_waiting->least_unacked - 1);
 }
 
 void QuicConnection::SendPing() {
   if (retransmission_alarm_->IsSet()) {
@@ skipping 459 matching lines @@
   }
   for (size_t i = 0; i < retransmittable_frames->frames().size(); ++i) {
     if (retransmittable_frames->frames()[i].type == CONNECTION_CLOSE_FRAME) {
       return true;
     }
   }
   return false;
 }
 
 }  // namespace net