Minor style cleanup of QuicProtocol

net/quic/quic_protocol.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.
 
 #ifndef NET_QUIC_QUIC_PROTOCOL_H_
 #define NET_QUIC_QUIC_PROTOCOL_H_
 
 #include <limits>
+#include <ostream>
 #include <utility>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/hash_tables.h"
 #include "base/logging.h"
 #include "base/string_piece.h"
 #include "net/base/net_export.h"
 #include "net/quic/uint128.h"
 
@@ skipping 222 matching lines @@
   QuicAckFrame() {}
   QuicAckFrame(QuicPacketSequenceNumber largest_received,
                   QuicTransmissionTime time_received,
                   QuicPacketSequenceNumber least_unacked) {
     received_info.largest_received = largest_received;
     received_info.time_received = time_received;
     sent_info.least_unacked = least_unacked;
     congestion_info.type = kNone;
   }
 
+  NET_EXPORT_PRIVATE friend std::ostream& operator<<(std::ostream& os,
+                                                     const QuicAckFrame& s);
+
   SentPacketInfo sent_info;
   ReceivedPacketInfo received_info;
   CongestionInfo congestion_info;
-
-  friend std::ostream& operator<<(std::ostream& os, const QuicAckFrame& s) {
-    os << "largest_received: " << s.received_info.largest_received
-       << " time: " << s.received_info.time_received
-       << " missing: ";
-    for (base::hash_set<QuicPacketSequenceNumber>::const_iterator it =
-           s.received_info.missing_packets.begin();
-           it != s.received_info.missing_packets.end(); ++it) {
-      os << *it << " ";
-    }
-
-    os << " least_waiting: " << s.sent_info.least_unacked
-       << " no_retransmit: ";
-    for (base::hash_set<QuicPacketSequenceNumber>::const_iterator it =
-           s.sent_info.non_retransmiting.begin();
-         it != s.sent_info.non_retransmiting.end(); ++it) {
-      os << *it << " ";
-    }
-    os << "\n";
-    return os;
-  }
 };
 
 struct NET_EXPORT_PRIVATE QuicRstStreamFrame {
   QuicRstStreamFrame() {}
   QuicRstStreamFrame(QuicStreamId stream_id, uint64 offset,
                         QuicErrorCode error_code)
       : stream_id(stream_id), offset(offset), error_code(error_code) {
     DCHECK_LE(error_code, std::numeric_limits<uint8>::max());
   }
 
@@ skipping 37 matching lines @@
 
 typedef std::vector<QuicFrame> QuicFrames;
 
 struct NET_EXPORT_PRIVATE QuicFecData {
   QuicFecData();
   QuicFecGroupNumber fec_group;
   QuicPacketSequenceNumber first_protected_packet_sequence_number;
   // The last protected packet's sequence number will be one
   // less than the sequence number of the FEC packet.
   base::StringPiece redundancy;
-  bool operator==(const QuicFecData& other) const {
-    if (fec_group != other.fec_group) {
-      return false;
-    }
-    if (first_protected_packet_sequence_number !=
-        other.first_protected_packet_sequence_number) {
-      return false;
-    }
-    if (redundancy != other.redundancy) {
-      return false;
-    }
-    return true;
-  }
+  bool operator==(const QuicFecData& other) const;
 };
 
 struct NET_EXPORT_PRIVATE QuicPacketData {
   std::string data;
 };
 
 class NET_EXPORT_PRIVATE QuicData {
  public:
   QuicData(const char* buffer, size_t length)
       : buffer_(buffer),
@@ skipping 61 matching lines @@
     return base::StringPiece(data() + kStartOfHashData, kStartOfEncryptedData);
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(QuicEncryptedPacket);
 };
 
 }  // namespace net
 
 #endif  // NET_QUIC_QUIC_PROTOCOL_H_