CL generated with data from dead-code analysis using Scythe

net/quic/quic_unacked_packet_map.h

 // Copyright 2014 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.
 
 #ifndef NET_QUIC_QUIC_UNACKED_PACKET_MAP_H_
 #define NET_QUIC_QUIC_UNACKED_PACKET_MAP_H_
 
 #include "net/base/linked_hash_map.h"
 #include "net/quic/quic_protocol.h"
 
@@ skipping 28 matching lines @@
     // Zero when the packet is serialized, non-zero once it's sent.
     QuicByteCount bytes_sent;
     size_t nack_count;
     // Stores the sequence numbers of all transmissions of this packet.
     // Can never be null.
     SequenceNumberSet* all_transmissions;
     // Pending packets have not been abandoned or lost.
     bool pending;
   };
 
-  explicit QuicUnackedPacketMap(bool is_server);
+  QuicUnackedPacketMap();
   ~QuicUnackedPacketMap();
 
   // Adds |serialized_packet| to the map.  Does not mark it pending.
   void AddPacket(const SerializedPacket& serialized_packet);
 
   // Called when a packet is retransmitted with a new sequence number.
   // |old_sequence_number| will remain unacked, but will have no
   // retransmittable data associated with it. |new_sequence_number| will
   // be both unacked and associated with retransmittable data.
   void OnRetransmittedPacket(QuicPacketSequenceNumber old_sequence_number,
@@ skipping 22 matching lines @@
   // Returns true if there are any unacked packets.
   bool HasUnackedPackets() const;
 
   // Returns true if there are any unacked packets which have retransmittable
   // frames.
   bool HasUnackedRetransmittableFrames() const;
 
   // Returns the number of unacked packets which have retransmittable frames.
   size_t GetNumRetransmittablePackets() const;
 
-  // Returns the total number of bytes associated with pending packets.
-  size_t bytes_in_flight() const {
-    return bytes_in_flight_;
-  }
-
   // Returns the largest sequence number that has been sent.
   QuicPacketSequenceNumber largest_sent_packet() const {
     return largest_sent_packet_;
   }
 
   // Returns the smallest sequence number of a serialized packet which has not
   // been acked by the peer.  If there are no unacked packets, returns 0.
   QuicPacketSequenceNumber GetLeastUnackedSentPacket() const;
 
   // Returns the set of sequence numbers of all unacked packets.
@@ skipping 54 matching lines @@
   // retransmitted, this map will contain entries for both the old and the new
   // packet. The old packet's retransmittable frames entry will be NULL, while
   // the new packet's entry will contain the frames to retransmit.
   // If the old packet is acked before the new packet, then the old entry will
   // be removed from the map and the new entry's retransmittable frames will be
   // set to NULL.
   UnackedPacketMap unacked_packets_;
 
   size_t bytes_in_flight_;
 
-  bool is_server_;
-
   DISALLOW_COPY_AND_ASSIGN(QuicUnackedPacketMap);
 };
 
 }  // namespace net
 
 #endif  // NET_QUIC_QUIC_UNACKED_PACKET_MAP_H_