Create EXPECT_QUIC_BUG macro, and modify QUIC tests to use it.

net/quic/core/quic_packet_creator_test.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/core/quic_packet_creator.h"
 
 #include <cstdint>
 #include <memory>
 #include <string>
 
@@ skipping 113 matching lines @@
                        QuicTime::Zero(),
                        Perspective::IS_CLIENT),
         connection_id_(2),
         data_("foo"),
         creator_(connection_id_,
                  &client_framer_,
                  &mock_random_,
                  &buffer_allocator_,
                  &delegate_),
         serialized_packet_(creator_.NoPacket()) {
-    FLAGS_quic_always_log_bugs_for_tests = true;
     creator_.set_connection_id_length(GetParam().connection_id_length);
 
     creator_.SetEncrypter(ENCRYPTION_INITIAL, new NullEncrypter());
     creator_.SetEncrypter(ENCRYPTION_FORWARD_SECURE, new NullEncrypter());
     client_framer_.set_visitor(&framer_visitor_);
     client_framer_.set_received_entropy_calculator(&entropy_calculator_);
     server_framer_.set_visitor(&framer_visitor_);
     // TODO(ianswett): Fix this test so it uses a non-null encrypter.
     FLAGS_quic_never_write_unencrypted_data = false;
   }
@@ skipping 271 matching lines @@
   EXPECT_EQ(PACKET_1BYTE_PACKET_NUMBER,
             QuicPacketCreatorPeer::GetPacketNumberLength(&creator_));
   // Changing the packet number length with queued frames in the creator
   // should do nothing.
   EXPECT_FALSE(creator_.HasPendingFrames());
   QuicFrame ack_frame = QuicFrame(new QuicAckFrame(MakeAckFrame(0u)));
   creator_.AddSavedFrame(ack_frame);
 
   // Now change packet number length and expect a QUIC_BUG and no change in
   // packet number length.
-  EXPECT_DFATAL(creator_.UpdatePacketNumberLength(0, 256),
-                "Called UpdatePacketNumberLength with 1 queued_frames.");
+  EXPECT_QUIC_BUG(creator_.UpdatePacketNumberLength(0, 256),
+                  "Called UpdatePacketNumberLength with 1 queued_frames.");
   EXPECT_EQ(PACKET_1BYTE_PACKET_NUMBER,
             QuicPacketCreatorPeer::GetPacketNumberLength(&creator_));
   delete ack_frame.ack_frame;
 }
 
 TEST_P(QuicPacketCreatorTest, ReserializeFramesWithSequenceNumberLength) {
   // If the original packet number length, the current packet number
   // length, and the configured send packet number length are different, the
   // retransmit must sent with the original length and the others do not change.
   if (!FLAGS_quic_simple_packet_number_length) {
@@ skipping 736 matching lines @@
   ASSERT_TRUE(
       creator_.ConsumeData(1u, io_vector, 0u, 0u, false, false, &frame));
   ASSERT_TRUE(frame.stream_frame);
   size_t consumed = frame.stream_frame->data_length;
   EXPECT_EQ(4u, consumed);
   EXPECT_TRUE(creator_.HasPendingFrames());
   EXPECT_EQ(0u, creator_.packet_number());
 
   // Change current path.
   QuicPathId kPathId1 = 1;
-  EXPECT_DFATAL(creator_.SetCurrentPath(kPathId1, 1, 0),
-                "Unable to change paths when a packet is under construction");
+  EXPECT_QUIC_BUG(creator_.SetCurrentPath(kPathId1, 1, 0),
+                  "Unable to change paths when a packet is under construction");
   EXPECT_CALL(delegate_, OnSerializedPacket(_))
       .Times(1)
       .WillRepeatedly(
           Invoke(this, &QuicPacketCreatorTest::ClearSerializedPacket));
   creator_.Flush();
   EXPECT_FALSE(creator_.HasPendingFrames());
   creator_.SetCurrentPath(kPathId1, 1, 0);
   EXPECT_EQ(kPathId1, QuicPacketCreatorPeer::GetCurrentPath(&creator_));
   EXPECT_FALSE(creator_.HasPendingFrames());
   EXPECT_EQ(0u, creator_.packet_number());
@@ skipping 106 matching lines @@
   // Verify serialized data packet's path id.
   EXPECT_EQ(kPathId1, serialized_packet_.path_id);
   DeleteSerializedPacket();
 }
 
 TEST_P(QuicPacketCreatorTest, AddUnencryptedStreamDataClosesConnection) {
   FLAGS_quic_never_write_unencrypted_data = true;
   EXPECT_CALL(delegate_, OnUnrecoverableError(_, _, _));
   QuicStreamFrame stream_frame(kHeadersStreamId, /*fin=*/false, 0u,
                                StringPiece());
-  EXPECT_DFATAL(creator_.AddSavedFrame(QuicFrame(&stream_frame)),
-                "Cannot send stream data without encryption.");
+  EXPECT_QUIC_BUG(creator_.AddSavedFrame(QuicFrame(&stream_frame)),
+                  "Cannot send stream data without encryption.");
 }
 
 TEST_P(QuicPacketCreatorTest, ChloTooLarge) {
   CryptoHandshakeMessage message;
   message.set_tag(kCHLO);
   message.set_minimum_size(kMaxPacketSize);
   CryptoFramer framer;
   std::unique_ptr<QuicData> message_data;
   message_data.reset(framer.ConstructHandshakeMessage(message));
 
   struct iovec iov;
   QuicIOVector data_iovec(::net::MakeIOVector(
       StringPiece(message_data->data(), message_data->length()), &iov));
   QuicFrame frame;
   EXPECT_CALL(delegate_,
               OnUnrecoverableError(QUIC_CRYPTO_CHLO_TOO_LARGE, _, _));
-  EXPECT_DFATAL(
+  EXPECT_QUIC_BUG(
       creator_.ConsumeData(1u, data_iovec, 0u, 0u, false, false, &frame),
       "Client hello won't fit in a single packet.");
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net