Teach gtest how to print QuicConsumedData and QuicEncryptedPacket.

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 <stddef.h>
 #include <limits>
 #include <map>
@@ skipping 24 matching lines @@
 typedef uint8 QuicFecGroupNumber;
 
 // A struct for functions which consume data payloads and fins.
 // The first member of the pair indicates bytes consumed.
 // The second member of the pair indicates if an incoming fin was consumed.
 struct QuicConsumedData {
   QuicConsumedData(size_t bytes_consumed, bool fin_consumed)
       : bytes_consumed(bytes_consumed),
         fin_consumed(fin_consumed) {
   }
+  NET_EXPORT_PRIVATE friend std::ostream& operator<<(
+      std::ostream& os, const QuicConsumedData& s);
+
   size_t bytes_consumed;
   bool fin_consumed;
 };
 
 
 // TODO(rch): Consider Quic specific names for these constants.
 const size_t kMaxPacketSize = 1200;  // Maximum size in bytes of a QUIC packet.
 
 // Maximum number of open streams per connection.
 const size_t kDefaultMaxStreamsPerConnection = 100;
@@ skipping 131 matching lines @@
 // TODO(ianswett): Re-evaluate the trade-offs of hash_set vs set when framing
 // is finalized.
 typedef std::set<QuicPacketSequenceNumber> SequenceSet;
 // TODO(pwestin): Add a way to enforce the max size of this map.
 typedef std::map<QuicPacketSequenceNumber, QuicTime> TimeMap;
 
 struct NET_EXPORT_PRIVATE ReceivedPacketInfo {
   ReceivedPacketInfo();
   ~ReceivedPacketInfo();
   NET_EXPORT_PRIVATE friend std::ostream& operator<<(
       std::ostream& os, const ReceivedPacketInfo& s);

[wtc, 2013/01/17 18:59:36]

I copied the operator<< solution from several other classes
in the same file, such as this one.

But I just noticed that none of those classes have a bool
member. So the operator<< may have been added for a different
reason.

 
   // Records a packet receipt.
   void RecordReceived(QuicPacketSequenceNumber sequence_number);
 
   // True if the sequence number is greater than largest_observed or is listed
   // as missing.
   // Always returns false for sequence numbers less than least_unacked.
   bool IsAwaitingPacket(QuicPacketSequenceNumber sequence_number) const;
 
   // Clears all missing packets less than |least_unacked|.
@@ skipping 215 matching lines @@
 };
 
 class NET_EXPORT_PRIVATE QuicEncryptedPacket : public QuicData {
  public:
   QuicEncryptedPacket(const char* buffer, size_t length)
       : QuicData(buffer, length) { }
 
   QuicEncryptedPacket(char* buffer, size_t length, bool owns_buffer)
       : QuicData(buffer, length, owns_buffer) { }
 
+  NET_EXPORT_PRIVATE friend std::ostream& operator<<(
+      std::ostream& os, const QuicEncryptedPacket& s);
+
   base::StringPiece AssociatedData() const {
     return base::StringPiece(data() + kStartOfHashData, kStartOfEncryptedData);
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(QuicEncryptedPacket);
 };
 
 }  // namespace net
 
 #endif  // NET_QUIC_QUIC_PROTOCOL_H_