A number of fixes to please clang_tidy. There should be no functional

net/quic/quic_packet_creator.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_packet_creator.h"
 
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "net/quic/crypto/quic_random.h"
 #include "net/quic/quic_ack_notifier.h"
@@ skipping 381 matching lines @@
   // packet size calculation worked correctly.
   if (!possibly_truncated_by_length) {
     DCHECK_EQ(packet_size_, packet->length());
   }
   // Immediately encrypt the packet, to ensure we don't encrypt the same packet
   // sequence number multiple times.
   QuicEncryptedPacket* encrypted =
       framer_->EncryptPacket(encryption_level_, sequence_number_, *packet);
   if (encrypted == nullptr) {
     LOG(DFATAL) << "Failed to encrypt packet number " << sequence_number_;
-    SerializedPacket kNoPacket(0, PACKET_1BYTE_SEQUENCE_NUMBER, nullptr, 0,
-                               nullptr);
-    return kNoPacket;
+    return NoPacket();
   }
 
   packet_size_ = 0;
   queued_frames_.clear();
   return SerializedPacket(header.packet_sequence_number,
                           header.public_header.sequence_number_length,
                           encrypted, QuicFramer::GetPacketEntropyHash(header),
                           queued_retransmittable_frames_.release());
 }
 
 SerializedPacket QuicPacketCreator::SerializeFec() {
   if (fec_group_.get() == nullptr || fec_group_->NumReceivedPackets() <= 0) {
     LOG(DFATAL) << "SerializeFEC called but no group or zero packets in group.";
     // TODO(jri): Make this a public method of framer?
-    SerializedPacket kNoPacket(0, PACKET_1BYTE_SEQUENCE_NUMBER, nullptr, 0,
-                               nullptr);
-    return kNoPacket;
+    return NoPacket();
   }
   DCHECK_EQ(0u, queued_frames_.size());
   QuicPacketHeader header;
   FillPacketHeader(fec_group_number_, true, &header);
   QuicFecData fec_data;
   fec_data.fec_group = fec_group_->min_protected_packet();
   fec_data.redundancy = fec_group_->payload_parity();
   scoped_ptr<QuicPacket> packet(framer_->BuildFecPacket(header, fec_data));
   fec_group_.reset(nullptr);
   packet_size_ = 0;
   LOG_IF(DFATAL, packet == nullptr)
       << "Failed to serialize fec packet for group:" << fec_data.fec_group;
   DCHECK_GE(max_packet_length_, packet->length());
   // Immediately encrypt the packet, to ensure we don't encrypt the same packet
   // sequence number multiple times.
   QuicEncryptedPacket* encrypted =
       framer_->EncryptPacket(encryption_level_, sequence_number_, *packet);
   if (encrypted == nullptr) {
     LOG(DFATAL) << "Failed to encrypt packet number " << sequence_number_;
-    SerializedPacket kNoPacket(0, PACKET_1BYTE_SEQUENCE_NUMBER, nullptr, 0,
-                               nullptr);
-    return kNoPacket;
+    return NoPacket();
   }
   SerializedPacket serialized(
       header.packet_sequence_number,
       header.public_header.sequence_number_length, encrypted,
       QuicFramer::GetPacketEntropyHash(header), nullptr);
   serialized.is_fec_packet = true;
   return serialized;
 }
 
 QuicEncryptedPacket* QuicPacketCreator::SerializeVersionNegotiationPacket(
     const QuicVersionVector& supported_versions) {
   DCHECK_EQ(Perspective::IS_SERVER, framer_->perspective());
   QuicPacketPublicHeader header;
   header.connection_id = connection_id_;
   header.reset_flag = false;
   header.version_flag = true;
   header.versions = supported_versions;
   QuicEncryptedPacket* encrypted =
       framer_->BuildVersionNegotiationPacket(header, supported_versions);
   DCHECK(encrypted);
   DCHECK_GE(max_packet_length_, encrypted->length());
   return encrypted;
 }
 
+SerializedPacket QuicPacketCreator::NoPacket() {
+  return SerializedPacket(0, PACKET_1BYTE_SEQUENCE_NUMBER, nullptr, 0, nullptr);
+}
+
 void QuicPacketCreator::FillPacketHeader(QuicFecGroupNumber fec_group,
                                          bool fec_flag,
                                          QuicPacketHeader* header) {
   header->public_header.connection_id = connection_id_;
   header->public_header.connection_id_length = connection_id_length_;
   header->public_header.reset_flag = false;
   header->public_header.version_flag = send_version_in_packet_;
   header->fec_flag = fec_flag;
   header->packet_sequence_number = ++sequence_number_;
   header->public_header.sequence_number_length = sequence_number_length_;
@@ skipping 70 matching lines @@
   if (!is_handshake) {
     return;
   }
 
   QuicPaddingFrame padding;
   bool success = AddFrame(QuicFrame(&padding), false);
   DCHECK(success);
 }
 
 }  // namespace net