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) {
   }
+  friend std::ostream& operator<<(
+      std::ostream& os, const QuicConsumedData& s);
+
   size_t bytes_consumed;
   bool fin_consumed;

[wtc, 2013/01/17 02:34:58]

There are padding bytes after this bool member.

[Alexander Potapenko, 2013/01/17 08:20:06]

It's better to have this in the code comment rather than in Rietveld.

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

Done.

I verified the bool member was the problem using two methods.
One method was to simply defining the boolean members as
size_t to eliminate padding. That fixed the valgrind memory
errors. (The other method was to use a memset call to
initialize the padding bytes.)

 };
 
 
 // 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;
 
 // Size in bytes of the packet header common across all packets.
@@ skipping 317 matching lines @@
   base::StringPiece AsStringPiece() const {
     return base::StringPiece(data(), length());
   }
 
   const char* data() const { return buffer_; }
   size_t length() const { return length_; }
 
  private:
   const char* buffer_;
   size_t length_;
   bool owns_buffer_;

[wtc, 2013/01/17 02:34:58]

This class (QuicData) is the base class of QuicEncryptedPacket.
There are padding bytes after this bool member.

 
   DISALLOW_COPY_AND_ASSIGN(QuicData);
 };
 
 class NET_EXPORT_PRIVATE QuicPacket : public QuicData {
  public:
   QuicPacket(
       char* buffer, size_t length, bool owns_buffer, QuicPacketFlags flags)
       : QuicData(buffer, length, owns_buffer),
         buffer_(buffer),
@@ skipping 27 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) { }
 
+  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_