Replace quic_restart_flag_quic_big_endian_connection_id with quic_restart_flag_quic_big_endian_conn…

net/quic/core/quic_framer_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_framer.h"
 
 #include <algorithm>
 #include <cstdint>
 #include <map>
 #include <memory>
@@ skipping 573 matching lines @@
   };
   // clang-format on
 
   const size_t header_size = GetPacketHeaderSize(
       framer_.version(), PACKET_8BYTE_CONNECTION_ID, !kIncludeVersion,
       !kIncludeDiversificationNonce, PACKET_6BYTE_PACKET_NUMBER);
 
   memset(packet + header_size, 0, kMaxPacketSize - header_size);
 
   QuicEncryptedPacket encrypted(
-      AsChars(FLAGS_quic_restart_flag_quic_big_endian_connection_id
-                  ? packet_cid_be
-                  : packet),
-      FLAGS_quic_restart_flag_quic_big_endian_connection_id
+      AsChars(
+          QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
+              ? packet_cid_be
+              : packet),
+      QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
           ? arraysize(packet_cid_be)
           : arraysize(packet),
       false);
   EXPECT_QUIC_BUG(framer_.ProcessPacket(encrypted), "Packet too large:1");
 
   ASSERT_TRUE(visitor_.header_.get());
   // Make sure we've parsed the packet header, so we can send an error.
   EXPECT_EQ(kConnectionId, visitor_.header_->public_header.connection_id);
   // Make sure the correct error is propagated.
   EXPECT_EQ(QUIC_PACKET_TOO_LARGE, framer_.error());
@@ skipping 14 matching lines @@
     // public flags (8 byte connection_id)
     0x38,
     // connection_id
     0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
     // packet number
     0xBC, 0x9A, 0x78, 0x56, 0x34, 0x12,
   };
   // clang-format on
 
   QuicEncryptedPacket encrypted(
-      AsChars(FLAGS_quic_restart_flag_quic_big_endian_connection_id
-                  ? packet_cid_be
-                  : packet),
-      FLAGS_quic_restart_flag_quic_big_endian_connection_id
+      AsChars(
+          QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
+              ? packet_cid_be
+              : packet),
+      QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
           ? arraysize(packet_cid_be)
           : arraysize(packet),
       false);
   EXPECT_FALSE(framer_.ProcessPacket(encrypted));
   EXPECT_EQ(QUIC_MISSING_PAYLOAD, framer_.error());
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_EQ(kConnectionId, visitor_.header_->public_header.connection_id);
   EXPECT_FALSE(visitor_.header_->public_header.multipath_flag);
   EXPECT_FALSE(visitor_.header_->public_header.reset_flag);
   EXPECT_FALSE(visitor_.header_->public_header.version_flag);
   EXPECT_EQ(kPacketNumber, visitor_.header_->packet_number);
 
   // Now test framing boundaries.
   for (size_t i = 0;
        i < GetPacketHeaderSize(framer_.version(), PACKET_8BYTE_CONNECTION_ID,
                                !kIncludeVersion, !kIncludeDiversificationNonce,
                                PACKET_6BYTE_PACKET_NUMBER);
        ++i) {
     string expected_error;
     if (i < kConnectionIdOffset) {
       expected_error = "Unable to read public flags.";
     } else if (i < GetPacketNumberOffset(!kIncludeVersion)) {
       expected_error = "Unable to read ConnectionId.";
     } else {
       expected_error = "Unable to read packet number.";
     }
-    CheckProcessingFails(FLAGS_quic_restart_flag_quic_big_endian_connection_id
-                             ? packet_cid_be
-                             : packet,
-                         i, expected_error, QUIC_INVALID_PACKET_HEADER);
+    CheckProcessingFails(
+        QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
+            ? packet_cid_be
+            : packet,
+        i, expected_error, QUIC_INVALID_PACKET_HEADER);
   }
 }
 
 TEST_P(QuicFramerTest, PacketHeaderWith0ByteConnectionId) {
   QuicFramerPeer::SetLastSerializedConnectionId(&framer_, kConnectionId);
 
   // clang-format off
   unsigned char packet[] = {
     // public flags (0 byte connection_id)
     0x30,
@@ skipping 52 matching lines @@
     // connection_id
     0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
     // version tag
     'Q', '0', GetQuicVersionDigitTens(), GetQuicVersionDigitOnes(),
     // packet number
     0xBC, 0x9A, 0x78, 0x56, 0x34, 0x12,
   };
   // clang-format on
 
   QuicEncryptedPacket encrypted(
-      AsChars(FLAGS_quic_restart_flag_quic_big_endian_connection_id
-                  ? packet_cid_be
-                  : packet),
-      FLAGS_quic_restart_flag_quic_big_endian_connection_id
+      AsChars(
+          QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
+              ? packet_cid_be
+              : packet),
+      QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
           ? arraysize(packet_cid_be)
           : arraysize(packet),
       false);
   EXPECT_FALSE(framer_.ProcessPacket(encrypted));
   EXPECT_EQ(QUIC_MISSING_PAYLOAD, framer_.error());
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_EQ(kConnectionId, visitor_.header_->public_header.connection_id);
   EXPECT_FALSE(visitor_.header_->public_header.multipath_flag);
   EXPECT_FALSE(visitor_.header_->public_header.reset_flag);
   EXPECT_TRUE(visitor_.header_->public_header.version_flag);
   EXPECT_EQ(GetParam(), visitor_.header_->public_header.versions[0]);
   EXPECT_EQ(kPacketNumber, visitor_.header_->packet_number);
 
   // Now test framing boundaries.
   for (size_t i = 0;
        i < GetPacketHeaderSize(framer_.version(), PACKET_8BYTE_CONNECTION_ID,
                                kIncludeVersion, !kIncludeDiversificationNonce,
                                PACKET_6BYTE_PACKET_NUMBER);
        ++i) {
     string expected_error;
     if (i < kConnectionIdOffset) {
       expected_error = "Unable to read public flags.";
     } else if (i < kVersionOffset) {
       expected_error = "Unable to read ConnectionId.";
     } else if (i < GetPacketNumberOffset(kIncludeVersion)) {
       expected_error = "Unable to read protocol version.";
     } else {
       expected_error = "Unable to read packet number.";
     }
-    CheckProcessingFails(FLAGS_quic_restart_flag_quic_big_endian_connection_id
-                             ? packet_cid_be
-                             : packet,
-                         i, expected_error, QUIC_INVALID_PACKET_HEADER);
+    CheckProcessingFails(
+        QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
+            ? packet_cid_be
+            : packet,
+        i, expected_error, QUIC_INVALID_PACKET_HEADER);
   }
 }
 
 TEST_P(QuicFramerTest, PacketHeaderWith4BytePacketNumber) {
   QuicFramerPeer::SetLargestPacketNumber(&framer_, kPacketNumber - 2);
 
   // clang-format off
   unsigned char packet[] = {
     // public flags (8 byte connection_id and 4 byte packet number)
     0x28,
     // connection_id
     0x10, 0x32, 0x54, 0x76, 0x98, 0xBA, 0xDC, 0xFE,
     // packet number
     0xBC, 0x9A, 0x78, 0x56,
   };
 
   unsigned char packet_cid_be[] = {
     // public flags (8 byte connection_id and 4 byte packet number)
     0x28,
     // connection_id
     0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
     // packet number
     0xBC, 0x9A, 0x78, 0x56,
   };
   // clang-format on
 
   QuicEncryptedPacket encrypted(
-      AsChars(FLAGS_quic_restart_flag_quic_big_endian_connection_id
-                  ? packet_cid_be
-                  : packet),
-      FLAGS_quic_restart_flag_quic_big_endian_connection_id
+      AsChars(
+          QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
+              ? packet_cid_be
+              : packet),
+      QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
           ? arraysize(packet_cid_be)
           : arraysize(packet),
       false);
   EXPECT_FALSE(framer_.ProcessPacket(encrypted));
   EXPECT_EQ(QUIC_MISSING_PAYLOAD, framer_.error());
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_EQ(kConnectionId, visitor_.header_->public_header.connection_id);
   EXPECT_FALSE(visitor_.header_->public_header.multipath_flag);
   EXPECT_FALSE(visitor_.header_->public_header.reset_flag);
   EXPECT_FALSE(visitor_.header_->public_header.version_flag);
   EXPECT_EQ(kPacketNumber, visitor_.header_->packet_number);
 
   // Now test framing boundaries.
   for (size_t i = 0;
        i < GetPacketHeaderSize(framer_.version(), PACKET_8BYTE_CONNECTION_ID,
                                !kIncludeVersion, !kIncludeDiversificationNonce,
                                PACKET_4BYTE_PACKET_NUMBER);
        ++i) {
     string expected_error;
     if (i < kConnectionIdOffset) {
       expected_error = "Unable to read public flags.";
     } else if (i < GetPacketNumberOffset(!kIncludeVersion)) {
       expected_error = "Unable to read ConnectionId.";
     } else {
       expected_error = "Unable to read packet number.";
     }
-    CheckProcessingFails(FLAGS_quic_restart_flag_quic_big_endian_connection_id
-                             ? packet_cid_be
-                             : packet,
-                         i, expected_error, QUIC_INVALID_PACKET_HEADER);
+    CheckProcessingFails(
+        QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
+            ? packet_cid_be
+            : packet,
+        i, expected_error, QUIC_INVALID_PACKET_HEADER);
   }
 }
 
 TEST_P(QuicFramerTest, PacketHeaderWith2BytePacketNumber) {
   QuicFramerPeer::SetLargestPacketNumber(&framer_, kPacketNumber - 2);
 
   // clang-format off
   unsigned char packet[] = {
     // public flags (8 byte connection_id and 2 byte packet number)
     0x18,
     // connection_id
     0x10, 0x32, 0x54, 0x76, 0x98, 0xBA, 0xDC, 0xFE,
     // packet number
     0xBC, 0x9A,
   };
 
   unsigned char packet_cid_be[] = {
     // public flags (8 byte connection_id and 2 byte packet number)
     0x18,
     // connection_id
     0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
     // packet number
     0xBC, 0x9A,
   };
   // clang-format on
 
   QuicEncryptedPacket encrypted(
-      AsChars(FLAGS_quic_restart_flag_quic_big_endian_connection_id
-                  ? packet_cid_be
-                  : packet),
-      FLAGS_quic_restart_flag_quic_big_endian_connection_id
+      AsChars(
+          QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
+              ? packet_cid_be
+              : packet),
+      QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
           ? arraysize(packet_cid_be)
           : arraysize(packet),
       false);
   EXPECT_FALSE(framer_.ProcessPacket(encrypted));
   EXPECT_EQ(QUIC_MISSING_PAYLOAD, framer_.error());
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_EQ(kConnectionId, visitor_.header_->public_header.connection_id);
   EXPECT_FALSE(visitor_.header_->public_header.multipath_flag);
   EXPECT_FALSE(visitor_.header_->public_header.reset_flag);
   EXPECT_FALSE(visitor_.header_->public_header.version_flag);
   EXPECT_EQ(PACKET_2BYTE_PACKET_NUMBER,
             visitor_.header_->public_header.packet_number_length);
   EXPECT_EQ(kPacketNumber, visitor_.header_->packet_number);
 
   // Now test framing boundaries.
   for (size_t i = 0;
        i < GetPacketHeaderSize(framer_.version(), PACKET_8BYTE_CONNECTION_ID,
                                !kIncludeVersion, !kIncludeDiversificationNonce,
                                PACKET_2BYTE_PACKET_NUMBER);
        ++i) {
     string expected_error;
     if (i < kConnectionIdOffset) {
       expected_error = "Unable to read public flags.";
     } else if (i < GetPacketNumberOffset(!kIncludeVersion)) {
       expected_error = "Unable to read ConnectionId.";
     } else {
       expected_error = "Unable to read packet number.";
     }
-    CheckProcessingFails(FLAGS_quic_restart_flag_quic_big_endian_connection_id
-                             ? packet_cid_be
-                             : packet,
-                         i, expected_error, QUIC_INVALID_PACKET_HEADER);
+    CheckProcessingFails(
+        QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
+            ? packet_cid_be
+            : packet,
+        i, expected_error, QUIC_INVALID_PACKET_HEADER);
   }
 }
 
 TEST_P(QuicFramerTest, PacketHeaderWith1BytePacketNumber) {
   QuicFramerPeer::SetLargestPacketNumber(&framer_, kPacketNumber - 2);
 
   // clang-format off
   unsigned char packet[] = {
     // public flags (8 byte connection_id and 1 byte packet number)
     0x08,
     // connection_id
     0x10, 0x32, 0x54, 0x76, 0x98, 0xBA, 0xDC, 0xFE,
     // packet number
     0xBC,
   };
 
   unsigned char packet_cid_be[] = {
     // public flags (8 byte connection_id and 1 byte packet number)
     0x08,
     // connection_id
     0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
     // packet number
     0xBC,
   };
   // clang-format on
 
   QuicEncryptedPacket encrypted(
-      AsChars(FLAGS_quic_restart_flag_quic_big_endian_connection_id
-                  ? packet_cid_be
-                  : packet),
-      FLAGS_quic_restart_flag_quic_big_endian_connection_id
+      AsChars(
+          QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
+              ? packet_cid_be
+              : packet),
+      QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
           ? arraysize(packet_cid_be)
           : arraysize(packet),
       false);
   EXPECT_FALSE(framer_.ProcessPacket(encrypted));
   EXPECT_EQ(QUIC_MISSING_PAYLOAD, framer_.error());
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_EQ(kConnectionId, visitor_.header_->public_header.connection_id);
   EXPECT_FALSE(visitor_.header_->public_header.multipath_flag);
   EXPECT_FALSE(visitor_.header_->public_header.reset_flag);
   EXPECT_FALSE(visitor_.header_->public_header.version_flag);
   EXPECT_EQ(PACKET_1BYTE_PACKET_NUMBER,
             visitor_.header_->public_header.packet_number_length);
   EXPECT_EQ(kPacketNumber, visitor_.header_->packet_number);
 
   // Now test framing boundaries.
   for (size_t i = 0;
        i < GetPacketHeaderSize(framer_.version(), PACKET_8BYTE_CONNECTION_ID,
                                !kIncludeVersion, !kIncludeDiversificationNonce,
                                PACKET_1BYTE_PACKET_NUMBER);
        ++i) {
     string expected_error;
     if (i < kConnectionIdOffset) {
       expected_error = "Unable to read public flags.";
     } else if (i < GetPacketNumberOffset(!kIncludeVersion)) {
       expected_error = "Unable to read ConnectionId.";
     } else {
       expected_error = "Unable to read packet number.";
     }
-    CheckProcessingFails(FLAGS_quic_restart_flag_quic_big_endian_connection_id
-                             ? packet_cid_be
-                             : packet,
-                         i, expected_error, QUIC_INVALID_PACKET_HEADER);
+    CheckProcessingFails(
+        QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
+            ? packet_cid_be
+            : packet,
+        i, expected_error, QUIC_INVALID_PACKET_HEADER);
   }
 }
 
 TEST_P(QuicFramerTest, PacketNumberDecreasesThenIncreases) {
   // Test the case when a packet is received from the past and future packet
   // numbers are still calculated relative to the largest received packet.
   QuicPacketHeader header;
   header.public_header.connection_id = kConnectionId;
   header.public_header.reset_flag = false;
   header.public_header.version_flag = false;
@@ skipping 83 matching lines @@
     // packet number
     0xBC, 0x9A, 0x78, 0x56, 0x34, 0x12,
 
     // frame type (padding)
     0x00,
     0x00, 0x00, 0x00, 0x00
   };
   // clang-format on
 
   QuicEncryptedPacket encrypted(
-      AsChars(FLAGS_quic_restart_flag_quic_big_endian_connection_id
-                  ? packet_cid_be
-                  : packet),
-      FLAGS_quic_restart_flag_quic_big_endian_connection_id
+      AsChars(
+          QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
+              ? packet_cid_be
+              : packet),
+      QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
           ? arraysize(packet_cid_be)
           : arraysize(packet),
       false);
   QuicFramerPeer::SetPerspective(&framer_, Perspective::IS_CLIENT);
   EXPECT_TRUE(framer_.ProcessPacket(encrypted));
   ASSERT_TRUE(visitor_.public_header_->nonce != nullptr);
   for (char i = 0; i < 32; ++i) {
     EXPECT_EQ(i, (*visitor_.public_header_->nonce)[static_cast<size_t>(i)]);
   }
   EXPECT_EQ(1u, visitor_.padding_frames_.size());
@@ skipping 31 matching lines @@
     // packet number
     0xBC, 0x9A, 0x78, 0x56,
     0x34, 0x12,
 
     // frame type (padding frame)
     0x00,
     0x00, 0x00, 0x00, 0x00
   };
   // clang-format on
   QuicEncryptedPacket encrypted(
-      AsChars(FLAGS_quic_restart_flag_quic_big_endian_connection_id
-                  ? packet_cid_be
-                  : packet),
-      FLAGS_quic_restart_flag_quic_big_endian_connection_id
+      AsChars(
+          QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
+              ? packet_cid_be
+              : packet),
+      QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
           ? arraysize(packet_cid_be)
           : arraysize(packet),
       false);
   EXPECT_TRUE(framer_.ProcessPacket(encrypted));
   EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_EQ(0, visitor_.frame_count_);
   EXPECT_EQ(1, visitor_.version_mismatch_);
   EXPECT_EQ(1u, visitor_.padding_frames_.size());
   EXPECT_EQ(5, visitor_.padding_frames_[0]->num_padding_bytes);
@@ skipping 55 matching lines @@
     'o',  ' ',  'w',  'o',
     'r',  'l',  'd',  '!',
   };
   // clang-format on
 
   if (framer_.version() > QUIC_VERSION_37) {
     return;
   }
 
   QuicEncryptedPacket encrypted(
-      AsChars(FLAGS_quic_restart_flag_quic_big_endian_connection_id
-                  ? packet_cid_be
-                  : packet),
-      FLAGS_quic_restart_flag_quic_big_endian_connection_id
+      AsChars(
+          QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
+              ? packet_cid_be
+              : packet),
+      QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
           ? arraysize(packet_cid_be)
           : arraysize(packet),
       false);
   EXPECT_TRUE(framer_.ProcessPacket(encrypted));
   EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion,
                               !kIncludeDiversificationNonce));
 
   ASSERT_EQ(0u, visitor_.stream_frames_.size());
   EXPECT_EQ(0u, visitor_.ack_frames_.size());
   EXPECT_EQ(1u, visitor_.padding_frames_.size());
   EXPECT_EQ(28, visitor_.padding_frames_[0]->num_padding_bytes);
   // A packet with no frames is not acceptable.
   CheckProcessingFails(
-      FLAGS_quic_restart_flag_quic_big_endian_connection_id ? packet_cid_be
-                                                            : packet,
+      QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
+          ? packet_cid_be
+          : packet,
       GetPacketHeaderSize(framer_.version(), PACKET_8BYTE_CONNECTION_ID,
                           !kIncludeVersion, !kIncludeDiversificationNonce,
                           PACKET_6BYTE_PACKET_NUMBER),
       "Packet has no frames.", QUIC_MISSING_PAYLOAD);
 }
 
 TEST_P(QuicFramerTest, NewPaddingFrame) {
   // clang-format off
   unsigned char packet[] = {
     // public flags (8 byte connection_id)
@@ skipping 51 matching lines @@
     // paddings
     0x00, 0x00,
   };
   // clang-format on
 
   if (framer_.version() <= QUIC_VERSION_37) {
     return;
   }
 
   QuicEncryptedPacket encrypted(
-      AsChars(FLAGS_quic_restart_flag_quic_big_endian_connection_id
-                  ? packet_cid_be
-                  : packet),
-      FLAGS_quic_restart_flag_quic_big_endian_connection_id
+      AsChars(
+          QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
+              ? packet_cid_be
+              : packet),
+      QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
           ? arraysize(packet_cid_be)
           : arraysize(packet),
       false);
   EXPECT_TRUE(framer_.ProcessPacket(encrypted));
   EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion,
                               !kIncludeDiversificationNonce));
 
   ASSERT_EQ(1u, visitor_.stream_frames_.size());
@@ skipping 53 matching lines @@
       // data length
       0x0c, 0x00,
       // data
       'h',  'e',  'l',  'l',
       'o',  ' ',  'w',  'o',
       'r',  'l',  'd',  '!',
   };
   // clang-format on
 
   QuicEncryptedPacket encrypted(
-      AsChars(FLAGS_quic_restart_flag_quic_big_endian_connection_id
-                  ? packet_cid_be
-                  : packet),
-      FLAGS_quic_restart_flag_quic_big_endian_connection_id
+      AsChars(
+          QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
+              ? packet_cid_be
+              : packet),
+      QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
           ? arraysize(packet_cid_be)
           : arraysize(packet),
       false);
   EXPECT_TRUE(framer_.ProcessPacket(encrypted));
 
   EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion,
                               !kIncludeDiversificationNonce));
 
   ASSERT_EQ(1u, visitor_.stream_frames_.size());
   EXPECT_EQ(0u, visitor_.ack_frames_.size());
   EXPECT_EQ(kStreamId, visitor_.stream_frames_[0]->stream_id);
   EXPECT_TRUE(visitor_.stream_frames_[0]->fin);
   EXPECT_EQ(kStreamOffset, visitor_.stream_frames_[0]->offset);
   CheckStreamFrameData("hello world!", visitor_.stream_frames_[0].get());
 
   // Now test framing boundaries.
   CheckStreamFrameBoundaries(
-      FLAGS_quic_restart_flag_quic_big_endian_connection_id ? packet_cid_be
-                                                            : packet,
+      QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
+          ? packet_cid_be
+          : packet,
       kQuicMaxStreamIdSize, !kIncludeVersion);
 }
 
 TEST_P(QuicFramerTest, MissingDiversificationNonce) {
   QuicFramerPeer::SetPerspective(&framer_, Perspective::IS_CLIENT);
   framer_.SetDecrypter(ENCRYPTION_NONE,
                        new NullDecrypter(Perspective::IS_CLIENT));
   decrypter_ = new test::TestDecrypter();
   framer_.SetAlternativeDecrypter(ENCRYPTION_INITIAL, decrypter_, false);
 
@@ skipping 42 matching lines @@
       // data length
       0x0c, 0x00,
       // data
       'h',  'e',  'l',  'l',
       'o',  ' ',  'w',  'o',
       'r',  'l',  'd',  '!',
   };
   // clang-format on
 
   QuicEncryptedPacket encrypted(
-      AsChars(FLAGS_quic_restart_flag_quic_big_endian_connection_id
-                  ? packet_cid_be
-                  : packet),
-      FLAGS_quic_restart_flag_quic_big_endian_connection_id
+      AsChars(
+          QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
+              ? packet_cid_be
+              : packet),
+      QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
           ? arraysize(packet_cid_be)
           : arraysize(packet),
       false);
   EXPECT_FALSE(framer_.ProcessPacket(encrypted));
   EXPECT_EQ(QUIC_DECRYPTION_FAILURE, framer_.error());
 }
 
 TEST_P(QuicFramerTest, StreamFrame3ByteStreamId) {
   // clang-format off
   unsigned char packet[] = {
@@ skipping 40 matching lines @@
     // data length
     0x0c, 0x00,
     // data
     'h',  'e',  'l',  'l',
     'o',  ' ',  'w',  'o',
     'r',  'l',  'd',  '!',
   };
   // clang-format on
 
   QuicEncryptedPacket encrypted(
-      AsChars(FLAGS_quic_restart_flag_quic_big_endian_connection_id
-                  ? packet_cid_be
-                  : packet),
-      FLAGS_quic_restart_flag_quic_big_endian_connection_id
+      AsChars(
+          QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
+              ? packet_cid_be
+              : packet),
+      QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
           ? arraysize(packet_cid_be)
           : arraysize(packet),
       false);
   EXPECT_TRUE(framer_.ProcessPacket(encrypted));
 
   EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion,
                               !kIncludeDiversificationNonce));
 
   ASSERT_EQ(1u, visitor_.stream_frames_.size());
   EXPECT_EQ(0u, visitor_.ack_frames_.size());
   // Stream ID should be the last 3 bytes of kStreamId.
   EXPECT_EQ(0x00FFFFFF & kStreamId, visitor_.stream_frames_[0]->stream_id);
   EXPECT_TRUE(visitor_.stream_frames_[0]->fin);
   EXPECT_EQ(kStreamOffset, visitor_.stream_frames_[0]->offset);
   CheckStreamFrameData("hello world!", visitor_.stream_frames_[0].get());
 
   // Now test framing boundaries.
   const size_t stream_id_size = 3;
   CheckStreamFrameBoundaries(
-      FLAGS_quic_restart_flag_quic_big_endian_connection_id ? packet_cid_be
-                                                            : packet,
+      QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
+          ? packet_cid_be
+          : packet,
       stream_id_size, !kIncludeVersion);
 }
 
 TEST_P(QuicFramerTest, StreamFrame2ByteStreamId) {
   // clang-format off
   unsigned char packet[] = {
     // public flags (8 byte connection_id)
     0x38,
     // connection_id
     0x10, 0x32, 0x54, 0x76,
@@ skipping 36 matching lines @@
     // data length
     0x0c, 0x00,
     // data
     'h',  'e',  'l',  'l',
     'o',  ' ',  'w',  'o',
     'r',  'l',  'd',  '!',
   };
   // clang-format on
 
   QuicEncryptedPacket encrypted(
-      AsChars(FLAGS_quic_restart_flag_quic_big_endian_connection_id
-                  ? packet_cid_be
-                  : packet),
-      FLAGS_quic_restart_flag_quic_big_endian_connection_id
+      AsChars(
+          QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
+              ? packet_cid_be
+              : packet),
+      QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
           ? arraysize(packet_cid_be)
           : arraysize(packet),
       false);
   EXPECT_TRUE(framer_.ProcessPacket(encrypted));
 
   EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion,
                               !kIncludeDiversificationNonce));
 
   ASSERT_EQ(1u, visitor_.stream_frames_.size());
   EXPECT_EQ(0u, visitor_.ack_frames_.size());
   // Stream ID should be the last 2 bytes of kStreamId.
   EXPECT_EQ(0x0000FFFF & kStreamId, visitor_.stream_frames_[0]->stream_id);
   EXPECT_TRUE(visitor_.stream_frames_[0]->fin);
   EXPECT_EQ(kStreamOffset, visitor_.stream_frames_[0]->offset);
   CheckStreamFrameData("hello world!", visitor_.stream_frames_[0].get());
 
   // Now test framing boundaries.
   const size_t stream_id_size = 2;
   CheckStreamFrameBoundaries(
-      FLAGS_quic_restart_flag_quic_big_endian_connection_id ? packet_cid_be
-                                                            : packet,
+      QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
+          ? packet_cid_be
+          : packet,
       stream_id_size, !kIncludeVersion);
 }
 
 TEST_P(QuicFramerTest, StreamFrame1ByteStreamId) {
   // clang-format off
   unsigned char packet[] = {
     // public flags (8 byte connection_id)
     0x38,
     // connection_id
     0x10, 0x32, 0x54, 0x76,
@@ skipping 36 matching lines @@
     // data length
     0x0c, 0x00,
     // data
     'h',  'e',  'l',  'l',
     'o',  ' ',  'w',  'o',
     'r',  'l',  'd',  '!',
   };
   // clang-format on
 
   QuicEncryptedPacket encrypted(
-      AsChars(FLAGS_quic_restart_flag_quic_big_endian_connection_id
-                  ? packet_cid_be
-                  : packet),
-      FLAGS_quic_restart_flag_quic_big_endian_connection_id
+      AsChars(
+          QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
+              ? packet_cid_be
+              : packet),
+      QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
           ? arraysize(packet_cid_be)
           : arraysize(packet),
       false);
   EXPECT_TRUE(framer_.ProcessPacket(encrypted));
 
   EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion,
                               !kIncludeDiversificationNonce));
 
   ASSERT_EQ(1u, visitor_.stream_frames_.size());
   EXPECT_EQ(0u, visitor_.ack_frames_.size());
   // Stream ID should be the last byte of kStreamId.
   EXPECT_EQ(0x000000FF & kStreamId, visitor_.stream_frames_[0]->stream_id);
   EXPECT_TRUE(visitor_.stream_frames_[0]->fin);
   EXPECT_EQ(kStreamOffset, visitor_.stream_frames_[0]->offset);
   CheckStreamFrameData("hello world!", visitor_.stream_frames_[0].get());
 
   // Now test framing boundaries.
   const size_t stream_id_size = 1;
   CheckStreamFrameBoundaries(
-      FLAGS_quic_restart_flag_quic_big_endian_connection_id ? packet_cid_be
-                                                            : packet,
+      QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
+          ? packet_cid_be
+          : packet,
       stream_id_size, !kIncludeVersion);
 }
 
 TEST_P(QuicFramerTest, StreamFrameWithVersion) {
   // clang-format off
   unsigned char packet[] = {
     // public flags (version, 8 byte connection_id)
     0x39,
     // connection_id
     0x10, 0x32, 0x54, 0x76,
@@ skipping 40 matching lines @@
     // data length
     0x0c, 0x00,
     // data
     'h',  'e',  'l',  'l',
     'o',  ' ',  'w',  'o',
     'r',  'l',  'd',  '!',
   };
   // clang-format on
 
   QuicEncryptedPacket encrypted(
-      AsChars(FLAGS_quic_restart_flag_quic_big_endian_connection_id
-                  ? packet_cid_be
-                  : packet),
-      FLAGS_quic_restart_flag_quic_big_endian_connection_id
+      AsChars(
+          QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
+              ? packet_cid_be
+              : packet),
+      QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
           ? arraysize(packet_cid_be)
           : arraysize(packet),
       false);
   EXPECT_TRUE(framer_.ProcessPacket(encrypted));
 
   EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(visitor_.header_->public_header.version_flag);
   EXPECT_EQ(GetParam(), visitor_.header_->public_header.versions[0]);
   EXPECT_TRUE(CheckDecryption(encrypted, kIncludeVersion,
                               !kIncludeDiversificationNonce));
 
   ASSERT_EQ(1u, visitor_.stream_frames_.size());
   EXPECT_EQ(0u, visitor_.ack_frames_.size());
   EXPECT_EQ(kStreamId, visitor_.stream_frames_[0]->stream_id);
   EXPECT_TRUE(visitor_.stream_frames_[0]->fin);
   EXPECT_EQ(kStreamOffset, visitor_.stream_frames_[0]->offset);
   CheckStreamFrameData("hello world!", visitor_.stream_frames_[0].get());
 
   // Now test framing boundaries.
   CheckStreamFrameBoundaries(
-      FLAGS_quic_restart_flag_quic_big_endian_connection_id ? packet_cid_be
-                                                            : packet,
+      QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
+          ? packet_cid_be
+          : packet,
       kQuicMaxStreamIdSize, kIncludeVersion);
 }
 
 TEST_P(QuicFramerTest, RejectPacket) {
   visitor_.accept_packet_ = false;
 
   // clang-format off
   unsigned char packet[] = {
       // public flags (8 byte connection_id)
       0x38,
@@ skipping 38 matching lines @@
       // data length
       0x0c, 0x00,
       // data
       'h',  'e',  'l',  'l',
       'o',  ' ',  'w',  'o',
       'r',  'l',  'd',  '!',
   };
   // clang-format on
 
   QuicEncryptedPacket encrypted(
-      AsChars(FLAGS_quic_restart_flag_quic_big_endian_connection_id
-                  ? packet_cid_be
-                  : packet),
-      FLAGS_quic_restart_flag_quic_big_endian_connection_id
+      AsChars(
+          QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
+              ? packet_cid_be
+              : packet),
+      QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
           ? arraysize(packet_cid_be)
           : arraysize(packet),
       false);
   EXPECT_TRUE(framer_.ProcessPacket(encrypted));
 
   EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion,
                               !kIncludeDiversificationNonce));
 
@@ skipping 14 matching lines @@
 
   unsigned char packet_cid_be[] = {
     // public flags (8 byte connection_id)
     0x38,
     // connection_id
     0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
   };
   // clang-format on
 
   QuicEncryptedPacket encrypted(
-      AsChars(FLAGS_quic_restart_flag_quic_big_endian_connection_id
-                  ? packet_cid_be
-                  : packet),
-      FLAGS_quic_restart_flag_quic_big_endian_connection_id
+      AsChars(
+          QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
+              ? packet_cid_be
+              : packet),
+      QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
           ? arraysize(packet_cid_be)
           : arraysize(packet),
       false);
   EXPECT_TRUE(framer_.ProcessPacket(encrypted));
 
   EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
   ASSERT_TRUE(visitor_.public_header_.get());
   ASSERT_FALSE(visitor_.header_.get());
 }
 
@@ skipping 36 matching lines @@
       // Zero delta time.
       0x00, 0x00,
       // first ack block length.
       0x34, 0x12,
       // num timestamps.
       0x00,
   };
   // clang-format on
 
   QuicEncryptedPacket encrypted(
-      AsChars(FLAGS_quic_restart_flag_quic_big_endian_connection_id
-                  ? packet_cid_be
-                  : packet),
-      FLAGS_quic_restart_flag_quic_big_endian_connection_id
+      AsChars(
+          QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
+              ? packet_cid_be
+              : packet),
+      QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
           ? arraysize(packet_cid_be)
           : arraysize(packet),
       false);
   EXPECT_TRUE(framer_.ProcessPacket(encrypted));
 
   EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion,
                               !kIncludeDiversificationNonce));
 
@@ skipping 18 matching lines @@
     if (i < kLargestAckedDeltaTimeOffset) {
       expected_error = "Unable to read largest acked.";
     } else if (i < kFirstAckBlockLengthOffset) {
       expected_error = "Unable to read ack delay time.";
     } else if (i < kNumTimestampsOffset) {
       expected_error = "Unable to read first ack block length.";
     } else {
       expected_error = "Unable to read num received packets.";
     }
     CheckProcessingFails(
-        FLAGS_quic_restart_flag_quic_big_endian_connection_id ? packet_cid_be
-                                                              : packet,
+        QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
+            ? packet_cid_be
+            : packet,
         i + GetPacketHeaderSize(framer_.version(), PACKET_8BYTE_CONNECTION_ID,
                                 !kIncludeVersion, !kIncludeDiversificationNonce,
                                 PACKET_6BYTE_PACKET_NUMBER),
         expected_error, QUIC_INVALID_ACK_DATA);
   }
 }
 
 TEST_P(QuicFramerTest, AckFrameTwoTimeStampsMultipleAckBlocks) {
   // clang-format off
   unsigned char packet[] = {
@@ skipping 85 matching lines @@
       // Delta time.
       0x10, 0x32, 0x54, 0x76,
       // Delta from largest observed.
       0x02,
       // Delta time.
       0x10, 0x32,
   };
   // clang-format on
 
   QuicEncryptedPacket encrypted(
-      AsChars(FLAGS_quic_restart_flag_quic_big_endian_connection_id
-                  ? packet_cid_be
-                  : packet),
-      FLAGS_quic_restart_flag_quic_big_endian_connection_id
+      AsChars(
+          QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
+              ? packet_cid_be
+              : packet),
+      QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
           ? arraysize(packet_cid_be)
           : arraysize(packet),
       false);
   EXPECT_TRUE(framer_.ProcessPacket(encrypted));
 
   EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion,
                               !kIncludeDiversificationNonce));
 
@@ skipping 69 matching lines @@
     } else if (i < kTimestampDeltaLargestObserved2) {
       expected_error = "Unable to read time delta in received packets.";
     } else if (i < kTimestampTimeDeltaLargestObserved2) {
       expected_error = "Unable to read sequence delta in received packets.";
     } else {
       expected_error =
           "Unable to read incremental time delta in received packets.";
     }
 
     CheckProcessingFails(
-        FLAGS_quic_restart_flag_quic_big_endian_connection_id ? packet_cid_be
-                                                              : packet,
+        QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
+            ? packet_cid_be
+            : packet,
         i + GetPacketHeaderSize(framer_.version(), PACKET_8BYTE_CONNECTION_ID,
                                 !kIncludeVersion, !kIncludeDiversificationNonce,
                                 PACKET_6BYTE_PACKET_NUMBER),
         expected_error, QUIC_INVALID_ACK_DATA);
   }
 }
 
 TEST_P(QuicFramerTest, NewStopWaitingFrame) {
   // clang-format off
   unsigned char packet[] = {
@@ skipping 22 matching lines @@
     0x34, 0x12,
     // frame type (stop waiting frame)
     0x06,
     // least packet number awaiting an ack, delta from packet number.
     0x08, 0x00, 0x00, 0x00,
     0x00, 0x00,
   };
   // clang-format on
 
   QuicEncryptedPacket encrypted(
-      AsChars(FLAGS_quic_restart_flag_quic_big_endian_connection_id
-                  ? packet_cid_be
-                  : packet),
-      FLAGS_quic_restart_flag_quic_big_endian_connection_id
+      AsChars(
+          QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
+              ? packet_cid_be
+              : packet),
+      QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
           ? arraysize(packet_cid_be)
           : arraysize(packet),
       false);
   EXPECT_TRUE(framer_.ProcessPacket(encrypted));
 
   EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion,
                               !kIncludeDiversificationNonce));
 
   EXPECT_EQ(0u, visitor_.stream_frames_.size());
   ASSERT_EQ(1u, visitor_.stop_waiting_frames_.size());
   const QuicStopWaitingFrame& frame = *visitor_.stop_waiting_frames_[0];
   EXPECT_EQ(kLeastUnacked, frame.least_unacked);
 
   const size_t frame_size = 7;
   for (size_t i = kQuicFrameTypeSize; i < frame_size; ++i) {
     string expected_error;
     expected_error = "Unable to read least unacked delta.";
     CheckProcessingFails(
-        FLAGS_quic_restart_flag_quic_big_endian_connection_id ? packet_cid_be
-                                                              : packet,
+        QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
+            ? packet_cid_be
+            : packet,
         i + GetPacketHeaderSize(framer_.version(), PACKET_8BYTE_CONNECTION_ID,
                                 !kIncludeVersion, !kIncludeDiversificationNonce,
                                 PACKET_6BYTE_PACKET_NUMBER),
         expected_error, QUIC_INVALID_STOP_WAITING_DATA);
   }
 }
 
 TEST_P(QuicFramerTest, RstStreamFrameQuic) {
   // clang-format off
   unsigned char packet[] = {
@@ skipping 36 matching lines @@
     // sent byte offset
     0x54, 0x76, 0x10, 0x32,
     0xDC, 0xFE, 0x98, 0xBA,
 
     // error code
     0x01, 0x00, 0x00, 0x00,
   };
   // clang-format on
 
   QuicEncryptedPacket encrypted(
-      AsChars(FLAGS_quic_restart_flag_quic_big_endian_connection_id
-                  ? packet_cid_be
-                  : packet),
-      FLAGS_quic_restart_flag_quic_big_endian_connection_id
+      AsChars(
+          QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
+              ? packet_cid_be
+              : packet),
+      QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
           ? arraysize(packet_cid_be)
           : arraysize(packet),
       false);
   EXPECT_TRUE(framer_.ProcessPacket(encrypted));
 
   EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion,
                               !kIncludeDiversificationNonce));
 
   EXPECT_EQ(kStreamId, visitor_.rst_stream_frame_.stream_id);
   EXPECT_EQ(0x01, visitor_.rst_stream_frame_.error_code);
   EXPECT_EQ(kStreamOffset, visitor_.rst_stream_frame_.byte_offset);
 
   // Now test framing boundaries.
   for (size_t i = kQuicFrameTypeSize; i < QuicFramer::GetRstStreamFrameSize();
        ++i) {
     string expected_error;
     if (i < kQuicFrameTypeSize + kQuicMaxStreamIdSize) {
       expected_error = "Unable to read stream_id.";
     } else if (i < kQuicFrameTypeSize + kQuicMaxStreamIdSize +
                        kQuicMaxStreamOffsetSize) {
       expected_error = "Unable to read rst stream sent byte offset.";
     } else if (i < kQuicFrameTypeSize + kQuicMaxStreamIdSize +
                        kQuicMaxStreamOffsetSize + kQuicErrorCodeSize) {
       expected_error = "Unable to read rst stream error code.";
     }
     CheckProcessingFails(
-        FLAGS_quic_restart_flag_quic_big_endian_connection_id ? packet_cid_be
-                                                              : packet,
+        QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
+            ? packet_cid_be
+            : packet,
         i + GetPacketHeaderSize(framer_.version(), PACKET_8BYTE_CONNECTION_ID,
                                 !kIncludeVersion, !kIncludeDiversificationNonce,
                                 PACKET_6BYTE_PACKET_NUMBER),
         expected_error, QUIC_INVALID_RST_STREAM_DATA);
   }
 }
 
 TEST_P(QuicFramerTest, ConnectionCloseFrame) {
   // clang-format off
   unsigned char packet[] = {
@@ skipping 38 matching lines @@
     0x0d, 0x00,
     // error details
     'b',  'e',  'c',  'a',
     'u',  's',  'e',  ' ',
     'I',  ' ',  'c',  'a',
     'n',
   };
   // clang-format on
 
   QuicEncryptedPacket encrypted(
-      AsChars(FLAGS_quic_restart_flag_quic_big_endian_connection_id
-                  ? packet_cid_be
-                  : packet),
-      FLAGS_quic_restart_flag_quic_big_endian_connection_id
+      AsChars(
+          QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
+              ? packet_cid_be
+              : packet),
+      QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
           ? arraysize(packet_cid_be)
           : arraysize(packet),
       false);
   EXPECT_TRUE(framer_.ProcessPacket(encrypted));
 
   EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion,
                               !kIncludeDiversificationNonce));
 
   EXPECT_EQ(0u, visitor_.stream_frames_.size());
 
   EXPECT_EQ(0x11, visitor_.connection_close_frame_.error_code);
   EXPECT_EQ("because I can", visitor_.connection_close_frame_.error_details);
 
   ASSERT_EQ(0u, visitor_.ack_frames_.size());
 
   // Now test framing boundaries.
   for (size_t i = kQuicFrameTypeSize;
        i < QuicFramer::GetMinConnectionCloseFrameSize(); ++i) {
     string expected_error;
     if (i < kQuicFrameTypeSize + kQuicErrorCodeSize) {
       expected_error = "Unable to read connection close error code.";
     } else {
       expected_error = "Unable to read connection close error details.";
     }
     CheckProcessingFails(
-        FLAGS_quic_restart_flag_quic_big_endian_connection_id ? packet_cid_be
-                                                              : packet,
+        QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
+            ? packet_cid_be
+            : packet,
         i + GetPacketHeaderSize(framer_.version(), PACKET_8BYTE_CONNECTION_ID,
                                 !kIncludeVersion, !kIncludeDiversificationNonce,
                                 PACKET_6BYTE_PACKET_NUMBER),
         expected_error, QUIC_INVALID_CONNECTION_CLOSE_DATA);
   }
 }
 
 TEST_P(QuicFramerTest, GoAwayFrame) {
   // clang-format off
   unsigned char packet[] = {
@@ skipping 40 matching lines @@
     0x0d, 0x00,
     // error details
     'b',  'e',  'c',  'a',
     'u',  's',  'e',  ' ',
     'I',  ' ',  'c',  'a',
     'n',
   };
   // clang-format on
 
   QuicEncryptedPacket encrypted(
-      AsChars(FLAGS_quic_restart_flag_quic_big_endian_connection_id
-                  ? packet_cid_be
-                  : packet),
-      FLAGS_quic_restart_flag_quic_big_endian_connection_id
+      AsChars(
+          QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
+              ? packet_cid_be
+              : packet),
+      QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
           ? arraysize(packet_cid_be)
           : arraysize(packet),
       false);
   EXPECT_TRUE(framer_.ProcessPacket(encrypted));
 
   EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion,
                               !kIncludeDiversificationNonce));
 
   EXPECT_EQ(kStreamId, visitor_.goaway_frame_.last_good_stream_id);
   EXPECT_EQ(0x9, visitor_.goaway_frame_.error_code);
   EXPECT_EQ("because I can", visitor_.goaway_frame_.reason_phrase);
 
   const size_t reason_size = arraysize("because I can") - 1;
   // Now test framing boundaries.
   for (size_t i = kQuicFrameTypeSize;
        i < QuicFramer::GetMinGoAwayFrameSize() + reason_size; ++i) {
     string expected_error;
     if (i < kQuicFrameTypeSize + kQuicErrorCodeSize) {
       expected_error = "Unable to read go away error code.";
     } else if (i <
                kQuicFrameTypeSize + kQuicErrorCodeSize + kQuicMaxStreamIdSize) {
       expected_error = "Unable to read last good stream id.";
     } else {
       expected_error = "Unable to read goaway reason.";
     }
     CheckProcessingFails(
-        FLAGS_quic_restart_flag_quic_big_endian_connection_id ? packet_cid_be
-                                                              : packet,
+        QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
+            ? packet_cid_be
+            : packet,
         i + GetPacketHeaderSize(framer_.version(), PACKET_8BYTE_CONNECTION_ID,
                                 !kIncludeVersion, !kIncludeDiversificationNonce,
                                 PACKET_6BYTE_PACKET_NUMBER),
         expected_error, QUIC_INVALID_GOAWAY_DATA);
   }
 }
 
 TEST_P(QuicFramerTest, WindowUpdateFrame) {
   // clang-format off
   unsigned char packet[] = {
@@ skipping 28 matching lines @@
       0x04,
       // stream id
       0x04, 0x03, 0x02, 0x01,
       // byte offset
       0x54, 0x76, 0x10, 0x32,
       0xDC, 0xFE, 0x98, 0xBA,
     };
   // clang-format on
 
   QuicEncryptedPacket encrypted(
-      AsChars(FLAGS_quic_restart_flag_quic_big_endian_connection_id
-                  ? packet_cid_be
-                  : packet),
-      FLAGS_quic_restart_flag_quic_big_endian_connection_id
+      AsChars(
+          QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
+              ? packet_cid_be
+              : packet),
+      QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
           ? arraysize(packet_cid_be)
           : arraysize(packet),
       false);
   EXPECT_TRUE(framer_.ProcessPacket(encrypted));
 
   EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion,
                               !kIncludeDiversificationNonce));
 
   EXPECT_EQ(kStreamId, visitor_.window_update_frame_.stream_id);
   EXPECT_EQ(kStreamOffset, visitor_.window_update_frame_.byte_offset);
 
   // Now test framing boundaries.
   for (size_t i = kQuicFrameTypeSize;
        i < QuicFramer::GetWindowUpdateFrameSize(); ++i) {
     string expected_error;
     if (i < kQuicFrameTypeSize + kQuicMaxStreamIdSize) {
       expected_error = "Unable to read stream_id.";
     } else {
       expected_error = "Unable to read window byte_offset.";
     }
     CheckProcessingFails(
-        FLAGS_quic_restart_flag_quic_big_endian_connection_id ? packet_cid_be
-                                                              : packet,
+        QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
+            ? packet_cid_be
+            : packet,
         i + GetPacketHeaderSize(framer_.version(), PACKET_8BYTE_CONNECTION_ID,
                                 !kIncludeVersion, !kIncludeDiversificationNonce,
                                 PACKET_6BYTE_PACKET_NUMBER),
         expected_error, QUIC_INVALID_WINDOW_UPDATE_DATA);
   }
 }
 
 TEST_P(QuicFramerTest, BlockedFrame) {
   // clang-format off
   unsigned char packet[] = {
@@ skipping 22 matching lines @@
       0x34, 0x12,
 
       // frame type (blocked frame)
       0x05,
       // stream id
       0x04, 0x03, 0x02, 0x01,
     };
   // clang-format on
 
   QuicEncryptedPacket encrypted(
-      AsChars(FLAGS_quic_restart_flag_quic_big_endian_connection_id
-                  ? packet_cid_be
-                  : packet),
-      FLAGS_quic_restart_flag_quic_big_endian_connection_id
+      AsChars(
+          QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
+              ? packet_cid_be
+              : packet),
+      QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
           ? arraysize(packet_cid_be)
           : arraysize(packet),
       false);
   EXPECT_TRUE(framer_.ProcessPacket(encrypted));
 
   EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion,
                               !kIncludeDiversificationNonce));
 
   EXPECT_EQ(kStreamId, visitor_.blocked_frame_.stream_id);
 
   // Now test framing boundaries.
   for (size_t i = kQuicFrameTypeSize; i < QuicFramer::GetBlockedFrameSize();
        ++i) {
     string expected_error = "Unable to read stream_id.";
     CheckProcessingFails(
-        FLAGS_quic_restart_flag_quic_big_endian_connection_id ? packet_cid_be
-                                                              : packet,
+        QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
+            ? packet_cid_be
+            : packet,
         i + GetPacketHeaderSize(framer_.version(), PACKET_8BYTE_CONNECTION_ID,
                                 !kIncludeVersion, !kIncludeDiversificationNonce,
                                 PACKET_6BYTE_PACKET_NUMBER),
         expected_error, QUIC_INVALID_BLOCKED_DATA);
   }
 }
 
 TEST_P(QuicFramerTest, PingFrame) {
   // clang-format off
   unsigned char packet[] = {
@@ skipping 18 matching lines @@
      // packet number
      0xBC, 0x9A, 0x78, 0x56,
      0x34, 0x12,
 
      // frame type (ping frame)
      0x07,
     };
   // clang-format on
 
   QuicEncryptedPacket encrypted(
-      AsChars(FLAGS_quic_restart_flag_quic_big_endian_connection_id
-                  ? packet_cid_be
-                  : packet),
-      FLAGS_quic_restart_flag_quic_big_endian_connection_id
+      AsChars(
+          QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
+              ? packet_cid_be
+              : packet),
+      QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
           ? arraysize(packet_cid_be)
           : arraysize(packet),
       false);
   EXPECT_TRUE(framer_.ProcessPacket(encrypted));
 
   EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion,
                               !kIncludeDiversificationNonce));
 
@@ skipping 50 matching lines @@
     // nonce proof
     0x89, 0x67, 0x45, 0x23,
     0x01, 0xEF, 0xCD, 0xAB,
     // rejected packet number
     0xBC, 0x9A, 0x78, 0x56,
     0x34, 0x12, 0x00, 0x00,
   };
   // clang-format on
 
   QuicEncryptedPacket encrypted(
-      AsChars(FLAGS_quic_restart_flag_quic_big_endian_connection_id
-                  ? packet_cid_be
-                  : packet),
-      FLAGS_quic_restart_flag_quic_big_endian_connection_id
+      AsChars(
+          QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
+              ? packet_cid_be
+              : packet),
+      QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
           ? arraysize(packet_cid_be)
           : arraysize(packet),
       false);
   EXPECT_TRUE(framer_.ProcessPacket(encrypted));
   ASSERT_EQ(QUIC_NO_ERROR, framer_.error());
   ASSERT_TRUE(visitor_.public_reset_packet_.get());
   EXPECT_EQ(kConnectionId,
             visitor_.public_reset_packet_->public_header.connection_id);
   EXPECT_TRUE(visitor_.public_reset_packet_->public_header.reset_flag);
   EXPECT_FALSE(visitor_.public_reset_packet_->public_header.version_flag);
   EXPECT_EQ(kNonceProof, visitor_.public_reset_packet_->nonce_proof);
   EXPECT_EQ(0u, visitor_.public_reset_packet_->rejected_packet_number);
   EXPECT_EQ(
       IpAddressFamily::IP_UNSPEC,
       visitor_.public_reset_packet_->client_address.host().address_family());
 
   // Now test framing boundaries.
-  if (!FLAGS_quic_restart_flag_quic_big_endian_connection_id) {
+  if (!QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())) {
     for (size_t i = 0; i < arraysize(packet); ++i) {
       string expected_error;
       QUIC_DLOG(INFO) << "iteration: " << i;
       if (i < kConnectionIdOffset) {
         expected_error = "Unable to read public flags.";
         CheckProcessingFails(packet, i, expected_error,
                              QUIC_INVALID_PACKET_HEADER);
       } else if (i < kPublicResetPacketMessageTagOffset) {
         expected_error = "Unable to read ConnectionId.";
         CheckProcessingFails(packet, i, expected_error,
@@ skipping 76 matching lines @@
     // nonce proof
     0x89, 0x67, 0x45, 0x23,
     0x01, 0xEF, 0xCD, 0xAB,
     // rejected packet number
     0xBC, 0x9A, 0x78, 0x56,
     0x34, 0x12, 0x00, 0x00,
   };
   // clang-format on
 
   QuicEncryptedPacket encrypted(
-      AsChars(FLAGS_quic_restart_flag_quic_big_endian_connection_id
-                  ? packet_cid_be
-                  : packet),
-      FLAGS_quic_restart_flag_quic_big_endian_connection_id
+      AsChars(
+          QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
+              ? packet_cid_be
+              : packet),
+      QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
           ? arraysize(packet_cid_be)
           : arraysize(packet),
       false);
   EXPECT_TRUE(framer_.ProcessPacket(encrypted));
   ASSERT_EQ(QUIC_NO_ERROR, framer_.error());
   ASSERT_TRUE(visitor_.public_reset_packet_.get());
   EXPECT_EQ(kConnectionId,
             visitor_.public_reset_packet_->public_header.connection_id);
   EXPECT_TRUE(visitor_.public_reset_packet_->public_header.reset_flag);
   EXPECT_FALSE(visitor_.public_reset_packet_->public_header.version_flag);
   EXPECT_EQ(kNonceProof, visitor_.public_reset_packet_->nonce_proof);
   EXPECT_EQ(0u, visitor_.public_reset_packet_->rejected_packet_number);
   EXPECT_EQ(
       IpAddressFamily::IP_UNSPEC,
       visitor_.public_reset_packet_->client_address.host().address_family());
 
   // Now test framing boundaries.
-  if (!FLAGS_quic_restart_flag_quic_big_endian_connection_id) {
+  if (!QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())) {
     for (size_t i = 0; i < arraysize(packet); ++i) {
       string expected_error;
       QUIC_DLOG(INFO) << "iteration: " << i;
       if (i < kConnectionIdOffset) {
         expected_error = "Unable to read public flags.";
         CheckProcessingFails(packet, i, expected_error,
                              QUIC_INVALID_PACKET_HEADER);
       } else if (i < kPublicResetPacketMessageTagOffset) {
         expected_error = "Unable to read ConnectionId.";
         CheckProcessingFails(packet, i, expected_error,
@@ skipping 78 matching lines @@
     0x01, 0xEF, 0xCD, 0xAB,
     // rejected packet number
     0xBC, 0x9A, 0x78, 0x56,
     0x34, 0x12, 0x00, 0x00,
     // trailing junk
     'j', 'u', 'n', 'k',
   };
   // clang-format on
 
   string expected_error = "Unable to read reset message.";
-  CheckProcessingFails(FLAGS_quic_restart_flag_quic_big_endian_connection_id
-                           ? packet_cid_be
-                           : packet,
-                       FLAGS_quic_restart_flag_quic_big_endian_connection_id
-                           ? arraysize(packet_cid_be)
-                           : arraysize(packet),
-                       expected_error, QUIC_INVALID_PUBLIC_RST_PACKET);
+  CheckProcessingFails(
+      QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
+          ? packet_cid_be
+          : packet,
+      QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
+          ? arraysize(packet_cid_be)
+          : arraysize(packet),
+      expected_error, QUIC_INVALID_PUBLIC_RST_PACKET);
 }
 
 TEST_P(QuicFramerTest, PublicResetPacketWithClientAddress) {
   // clang-format off
   unsigned char packet[] = {
     // public flags (public reset, 8 byte connection_id)
     0x0A,
     // connection_id
     0x10, 0x32, 0x54, 0x76,
     0x98, 0xBA, 0xDC, 0xFE,
@@ skipping 53 matching lines @@
     0xBC, 0x9A, 0x78, 0x56,
     0x34, 0x12, 0x00, 0x00,
     // client address: 4.31.198.44:443
     0x02, 0x00,
     0x04, 0x1F, 0xC6, 0x2C,
     0xBB, 0x01,
   };
   // clang-format on
 
   QuicEncryptedPacket encrypted(
-      AsChars(FLAGS_quic_restart_flag_quic_big_endian_connection_id
-                  ? packet_cid_be
-                  : packet),
-      FLAGS_quic_restart_flag_quic_big_endian_connection_id
+      AsChars(
+          QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
+              ? packet_cid_be
+              : packet),
+      QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
           ? arraysize(packet_cid_be)
           : arraysize(packet),
       false);
   EXPECT_TRUE(framer_.ProcessPacket(encrypted));
   ASSERT_EQ(QUIC_NO_ERROR, framer_.error());
   ASSERT_TRUE(visitor_.public_reset_packet_.get());
   EXPECT_EQ(kConnectionId,
             visitor_.public_reset_packet_->public_header.connection_id);
   EXPECT_TRUE(visitor_.public_reset_packet_->public_header.reset_flag);
   EXPECT_FALSE(visitor_.public_reset_packet_->public_header.version_flag);
   EXPECT_EQ(kNonceProof, visitor_.public_reset_packet_->nonce_proof);
   EXPECT_EQ(0u, visitor_.public_reset_packet_->rejected_packet_number);
   EXPECT_EQ("4.31.198.44",
             visitor_.public_reset_packet_->client_address.host().ToString());
   EXPECT_EQ(443, visitor_.public_reset_packet_->client_address.port());
 
   // Now test framing boundaries.
-  if (!FLAGS_quic_restart_flag_quic_big_endian_connection_id) {
+  if (!QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())) {
     for (size_t i = 0; i < arraysize(packet); ++i) {
       string expected_error;
       QUIC_DLOG(INFO) << "iteration: " << i;
       if (i < kConnectionIdOffset) {
         expected_error = "Unable to read public flags.";
         CheckProcessingFails(packet, i, expected_error,
                              QUIC_INVALID_PACKET_HEADER);
       } else if (i < kPublicResetPacketMessageTagOffset) {
         expected_error = "Unable to read ConnectionId.";
         CheckProcessingFails(packet, i, expected_error,
@@ skipping 46 matching lines @@
     0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
     // version tag
     'Q', '0', GetQuicVersionDigitTens(), GetQuicVersionDigitOnes(),
     'Q', '2', '.', '0',
   };
   // clang-format on
 
   QuicFramerPeer::SetPerspective(&framer_, Perspective::IS_CLIENT);
 
   QuicEncryptedPacket encrypted(
-      AsChars(FLAGS_quic_restart_flag_quic_big_endian_connection_id
-                  ? packet_cid_be
-                  : packet),
-      FLAGS_quic_restart_flag_quic_big_endian_connection_id
+      AsChars(
+          QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
+              ? packet_cid_be
+              : packet),
+      QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
           ? arraysize(packet_cid_be)
           : arraysize(packet),
       false);
   EXPECT_TRUE(framer_.ProcessPacket(encrypted));
   ASSERT_EQ(QUIC_NO_ERROR, framer_.error());
   ASSERT_TRUE(visitor_.version_negotiation_packet_.get());
   EXPECT_EQ(2u, visitor_.version_negotiation_packet_->versions.size());
   EXPECT_EQ(GetParam(), visitor_.version_negotiation_packet_->versions[0]);
 
   for (size_t i = 0; i <= kPublicFlagsSize + PACKET_8BYTE_CONNECTION_ID; ++i) {
     string expected_error;
     QuicErrorCode error_code = QUIC_INVALID_PACKET_HEADER;
     if (i < kConnectionIdOffset) {
       expected_error = "Unable to read public flags.";
     } else if (i < kVersionOffset) {
       expected_error = "Unable to read ConnectionId.";
     } else {
       expected_error = "Unable to read supported version in negotiation.";
       error_code = QUIC_INVALID_VERSION_NEGOTIATION_PACKET;
     }
-    CheckProcessingFails(FLAGS_quic_restart_flag_quic_big_endian_connection_id
-                             ? packet_cid_be
-                             : packet,
-                         i, expected_error, error_code);
+    CheckProcessingFails(
+        QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
+            ? packet_cid_be
+            : packet,
+        i, expected_error, error_code);
   }
 }
 
 TEST_P(QuicFramerTest, OldVersionNegotiationPacket) {
   // clang-format off
   unsigned char packet[] = {
     // public flags (version, 8 byte connection_id)
     0x3D,
     // connection_id
     0x10, 0x32, 0x54, 0x76,
@@ skipping 10 matching lines @@
     0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
     // version tag
     'Q', '0', GetQuicVersionDigitTens(), GetQuicVersionDigitOnes(),
     'Q', '2', '.', '0',
   };
   // clang-format on
 
   QuicFramerPeer::SetPerspective(&framer_, Perspective::IS_CLIENT);
 
   QuicEncryptedPacket encrypted(
-      AsChars(FLAGS_quic_restart_flag_quic_big_endian_connection_id
-                  ? packet_cid_be
-                  : packet),
-      FLAGS_quic_restart_flag_quic_big_endian_connection_id
+      AsChars(
+          QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
+              ? packet_cid_be
+              : packet),
+      QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
           ? arraysize(packet_cid_be)
           : arraysize(packet),
       false);
   EXPECT_TRUE(framer_.ProcessPacket(encrypted));
   ASSERT_EQ(QUIC_NO_ERROR, framer_.error());
   ASSERT_TRUE(visitor_.version_negotiation_packet_.get());
   EXPECT_EQ(2u, visitor_.version_negotiation_packet_->versions.size());
   EXPECT_EQ(GetParam(), visitor_.version_negotiation_packet_->versions[0]);
 
   for (size_t i = 0; i <= kPublicFlagsSize + PACKET_8BYTE_CONNECTION_ID; ++i) {
     string expected_error;
     QuicErrorCode error_code = QUIC_INVALID_PACKET_HEADER;
     if (i < kConnectionIdOffset) {
       expected_error = "Unable to read public flags.";
     } else if (i < kVersionOffset) {
       expected_error = "Unable to read ConnectionId.";
     } else {
       expected_error = "Unable to read supported version in negotiation.";
       error_code = QUIC_INVALID_VERSION_NEGOTIATION_PACKET;
     }
-    CheckProcessingFails(FLAGS_quic_restart_flag_quic_big_endian_connection_id
-                             ? packet_cid_be
-                             : packet,
-                         i, expected_error, error_code);
+    CheckProcessingFails(
+        QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
+            ? packet_cid_be
+            : packet,
+        i, expected_error, error_code);
   }
 }
 
 TEST_P(QuicFramerTest, BuildPaddingFramePacket) {
   QuicPacketHeader header;
   header.public_header.connection_id = kConnectionId;
   header.public_header.reset_flag = false;
   header.public_header.version_flag = false;
   header.packet_number = kPacketNumber;
 
@@ skipping 26 matching lines @@
 
     // frame type (padding frame)
     0x00,
     0x00, 0x00, 0x00, 0x00
   };
   // clang-format on
 
   uint64_t header_size = GetPacketHeaderSize(
       framer_.version(), PACKET_8BYTE_CONNECTION_ID, !kIncludeVersion,
       !kIncludeDiversificationNonce, PACKET_6BYTE_PACKET_NUMBER);
-  memset((FLAGS_quic_restart_flag_quic_big_endian_connection_id ? packet_cid_be
-                                                                : packet) +
+  memset((QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
+              ? packet_cid_be
+              : packet) +
              header_size + 1,
          0x00, kMaxPacketSize - header_size - 1);
 
   std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames));
   ASSERT_TRUE(data != nullptr);
 
   test::CompareCharArraysWithHexError(
       "constructed packet", data->data(), data->length(),
-      AsChars(FLAGS_quic_restart_flag_quic_big_endian_connection_id
-                  ? packet_cid_be
-                  : packet),
-      FLAGS_quic_restart_flag_quic_big_endian_connection_id
+      AsChars(
+          QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
+              ? packet_cid_be
+              : packet),
+      QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
           ? arraysize(packet_cid_be)
           : arraysize(packet));
 }
 
 TEST_P(QuicFramerTest, BuildStreamFramePacketWithNewPaddingFrame) {
   if (framer_.version() <= QUIC_VERSION_37) {
     return;
   }
   QuicPacketHeader header;
   header.public_header.connection_id = kConnectionId;
@@ skipping 64 matching lines @@
     // paddings
     0x00, 0x00,
   };
   // clang-format on
 
   std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames));
   ASSERT_TRUE(data != nullptr);
 
   test::CompareCharArraysWithHexError(
       "constructed packet", data->data(), data->length(),
-      AsChars(FLAGS_quic_restart_flag_quic_big_endian_connection_id
-                  ? packet_cid_be
-                  : packet),
-      FLAGS_quic_restart_flag_quic_big_endian_connection_id
+      AsChars(
+          QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
+              ? packet_cid_be
+              : packet),
+      QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
           ? arraysize(packet_cid_be)
           : arraysize(packet));
 }
 
 TEST_P(QuicFramerTest, Build4ByteSequenceNumberPaddingFramePacket) {
   QuicPacketHeader header;
   header.public_header.connection_id = kConnectionId;
   header.public_header.reset_flag = false;
   header.public_header.version_flag = false;
   header.public_header.packet_number_length = PACKET_4BYTE_PACKET_NUMBER;
@@ skipping 26 matching lines @@
 
     // frame type (padding frame)
     0x00,
     0x00, 0x00, 0x00, 0x00
   };
   // clang-format on
 
   uint64_t header_size = GetPacketHeaderSize(
       framer_.version(), PACKET_8BYTE_CONNECTION_ID, !kIncludeVersion,
       !kIncludeDiversificationNonce, PACKET_4BYTE_PACKET_NUMBER);
-  memset((FLAGS_quic_restart_flag_quic_big_endian_connection_id ? packet_cid_be
-                                                                : packet) +
+  memset((QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
+              ? packet_cid_be
+              : packet) +
              header_size + 1,
          0x00, kMaxPacketSize - header_size - 1);
 
   std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames));
   ASSERT_TRUE(data != nullptr);
 
   test::CompareCharArraysWithHexError(
       "constructed packet", data->data(), data->length(),
-      AsChars(FLAGS_quic_restart_flag_quic_big_endian_connection_id
-                  ? packet_cid_be
-                  : packet),
-      FLAGS_quic_restart_flag_quic_big_endian_connection_id
+      AsChars(
+          QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
+              ? packet_cid_be
+              : packet),
+      QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
           ? arraysize(packet_cid_be)
           : arraysize(packet));
 }
 
 TEST_P(QuicFramerTest, Build2ByteSequenceNumberPaddingFramePacket) {
   QuicPacketHeader header;
   header.public_header.connection_id = kConnectionId;
   header.public_header.reset_flag = false;
   header.public_header.version_flag = false;
   header.public_header.packet_number_length = PACKET_2BYTE_PACKET_NUMBER;
@@ skipping 26 matching lines @@
 
     // frame type (padding frame)
     0x00,
     0x00, 0x00, 0x00, 0x00
   };
   // clang-format on
 
   uint64_t header_size = GetPacketHeaderSize(
       framer_.version(), PACKET_8BYTE_CONNECTION_ID, !kIncludeVersion,
       !kIncludeDiversificationNonce, PACKET_2BYTE_PACKET_NUMBER);
-  memset((FLAGS_quic_restart_flag_quic_big_endian_connection_id ? packet_cid_be
-                                                                : packet) +
+  memset((QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
+              ? packet_cid_be
+              : packet) +
              header_size + 1,
          0x00, kMaxPacketSize - header_size - 1);
 
   std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames));
   ASSERT_TRUE(data != nullptr);
 
   test::CompareCharArraysWithHexError(
       "constructed packet", data->data(), data->length(),
-      AsChars(FLAGS_quic_restart_flag_quic_big_endian_connection_id
-                  ? packet_cid_be
-                  : packet),
-      FLAGS_quic_restart_flag_quic_big_endian_connection_id
+      AsChars(
+          QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
+              ? packet_cid_be
+              : packet),
+      QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
           ? arraysize(packet_cid_be)
           : arraysize(packet));
 }
 
 TEST_P(QuicFramerTest, Build1ByteSequenceNumberPaddingFramePacket) {
   QuicPacketHeader header;
   header.public_header.connection_id = kConnectionId;
   header.public_header.reset_flag = false;
   header.public_header.version_flag = false;
   header.public_header.packet_number_length = PACKET_1BYTE_PACKET_NUMBER;
@@ skipping 26 matching lines @@
 
     // frame type (padding frame)
     0x00,
     0x00, 0x00, 0x00, 0x00
   };
   // clang-format on
 
   uint64_t header_size = GetPacketHeaderSize(
       framer_.version(), PACKET_8BYTE_CONNECTION_ID, !kIncludeVersion,
       !kIncludeDiversificationNonce, PACKET_1BYTE_PACKET_NUMBER);
-  memset((FLAGS_quic_restart_flag_quic_big_endian_connection_id ? packet_cid_be
-                                                                : packet) +
+  memset((QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
+              ? packet_cid_be
+              : packet) +
              header_size + 1,
          0x00, kMaxPacketSize - header_size - 1);
 
   std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames));
   ASSERT_TRUE(data != nullptr);
 
   test::CompareCharArraysWithHexError(
       "constructed packet", data->data(), data->length(),
-      AsChars(FLAGS_quic_restart_flag_quic_big_endian_connection_id
-                  ? packet_cid_be
-                  : packet),
-      FLAGS_quic_restart_flag_quic_big_endian_connection_id
+      AsChars(
+          QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
+              ? packet_cid_be
+              : packet),
+      QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
           ? arraysize(packet_cid_be)
           : arraysize(packet));
 }
 
 TEST_P(QuicFramerTest, BuildStreamFramePacket) {
   QuicPacketHeader header;
   header.public_header.connection_id = kConnectionId;
   header.public_header.reset_flag = false;
   header.public_header.version_flag = false;
   header.packet_number = kPacketNumber;
@@ skipping 48 matching lines @@
     'o',  ' ',  'w',  'o',
     'r',  'l',  'd',  '!',
   };
   // clang-format on
 
   std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames));
   ASSERT_TRUE(data != nullptr);
 
   test::CompareCharArraysWithHexError(
       "constructed packet", data->data(), data->length(),
-      AsChars(FLAGS_quic_restart_flag_quic_big_endian_connection_id
-                  ? packet_cid_be
-                  : packet),
-      FLAGS_quic_restart_flag_quic_big_endian_connection_id
+      AsChars(
+          QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
+              ? packet_cid_be
+              : packet),
+      QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
           ? arraysize(packet_cid_be)
           : arraysize(packet));
 }
 
 TEST_P(QuicFramerTest, BuildStreamFramePacketWithVersionFlag) {
   QuicPacketHeader header;
   header.public_header.connection_id = kConnectionId;
   header.public_header.reset_flag = false;
   header.public_header.version_flag = true;
   header.packet_number = kPacketNumber;
@@ skipping 45 matching lines @@
       'h',  'e',  'l',  'l',  'o',  ' ',  'w',  'o',  'r', 'l', 'd', '!',
   };
   // clang-format on
 
   QuicFramerPeer::SetPerspective(&framer_, Perspective::IS_CLIENT);
   std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames));
   ASSERT_TRUE(data != nullptr);
 
   test::CompareCharArraysWithHexError(
       "constructed packet", data->data(), data->length(),
-      AsChars(FLAGS_quic_restart_flag_quic_big_endian_connection_id
-                  ? packet_cid_be
-                  : packet),
-      FLAGS_quic_restart_flag_quic_big_endian_connection_id
+      AsChars(
+          QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
+              ? packet_cid_be
+              : packet),
+      QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
           ? arraysize(packet_cid_be)
           : arraysize(packet));
 }
 
 TEST_P(QuicFramerTest, BuildVersionNegotiationPacket) {
   // clang-format off
   unsigned char packet[] = {
       // public flags (version, 8 byte connection_id)
       0x0D,
       // connection_id
@@ skipping 11 matching lines @@
       'Q', '0',  GetQuicVersionDigitTens(), GetQuicVersionDigitOnes(),
   };
   // clang-format on
 
   QuicConnectionId connection_id = kConnectionId;
   std::unique_ptr<QuicEncryptedPacket> data(
       framer_.BuildVersionNegotiationPacket(connection_id,
                                             SupportedVersions(GetParam())));
   test::CompareCharArraysWithHexError(
       "constructed packet", data->data(), data->length(),
-      AsChars(FLAGS_quic_restart_flag_quic_big_endian_connection_id
-                  ? packet_cid_be
-                  : packet),
-      FLAGS_quic_restart_flag_quic_big_endian_connection_id
+      AsChars(
+          QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
+              ? packet_cid_be
+              : packet),
+      QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
           ? arraysize(packet_cid_be)
           : arraysize(packet));
 }
 
 TEST_P(QuicFramerTest, BuildAckFramePacketOneAckBlock) {
   QuicPacketHeader header;
   header.public_header.connection_id = kConnectionId;
   header.public_header.reset_flag = false;
   header.public_header.version_flag = false;
   header.packet_number = kPacketNumber;
@@ skipping 48 matching lines @@
       // num timestamps.
       0x00,
   };
   // clang-format on
 
   std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames));
   ASSERT_TRUE(data != nullptr);
 
   test::CompareCharArraysWithHexError(
       "constructed packet", data->data(), data->length(),
-      AsChars(FLAGS_quic_restart_flag_quic_big_endian_connection_id
-                  ? packet_cid_be
-                  : packet),
-      FLAGS_quic_restart_flag_quic_big_endian_connection_id
+      AsChars(
+          QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
+              ? packet_cid_be
+              : packet),
+      QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
           ? arraysize(packet_cid_be)
           : arraysize(packet));
 }
 
 TEST_P(QuicFramerTest, BuildAckFramePacketMultipleAckBlocks) {
   QuicPacketHeader header;
   header.public_header.connection_id = kConnectionId;
   header.public_header.reset_flag = false;
   header.public_header.version_flag = false;
   header.packet_number = kPacketNumber;
@@ skipping 87 matching lines @@
       // num timestamps.
       0x00,
   };
   // clang-format on
 
   std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames));
   ASSERT_TRUE(data != nullptr);
 
   test::CompareCharArraysWithHexError(
       "constructed packet", data->data(), data->length(),
-      AsChars(FLAGS_quic_restart_flag_quic_big_endian_connection_id
-                  ? packet_cid_be
-                  : packet),
-      FLAGS_quic_restart_flag_quic_big_endian_connection_id
+      AsChars(
+          QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
+              ? packet_cid_be
+              : packet),
+      QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
           ? arraysize(packet_cid_be)
           : arraysize(packet));
 }
 
 TEST_P(QuicFramerTest, BuildAckFramePacketMaxAckBlocks) {
   QuicPacketHeader header;
   header.public_header.connection_id = kConnectionId;
   header.public_header.reset_flag = false;
   header.public_header.version_flag = false;
   header.packet_number = kPacketNumber;
@@ skipping 196 matching lines @@
       // num timestamps.
       0x00,
   };
   // clang-format on
 
   std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames));
   ASSERT_TRUE(data != nullptr);
 
   test::CompareCharArraysWithHexError(
       "constructed packet", data->data(), data->length(),
-      AsChars(FLAGS_quic_restart_flag_quic_big_endian_connection_id
-                  ? packet_cid_be
-                  : packet),
-      FLAGS_quic_restart_flag_quic_big_endian_connection_id
+      AsChars(
+          QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
+              ? packet_cid_be
+              : packet),
+      QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
           ? arraysize(packet_cid_be)
           : arraysize(packet));
 }
 
 TEST_P(QuicFramerTest, BuildNewStopWaitingPacket) {
   QuicPacketHeader header;
   header.public_header.connection_id = kConnectionId;
   header.public_header.reset_flag = false;
   header.public_header.version_flag = false;
   header.packet_number = kPacketNumber;
@@ skipping 34 matching lines @@
     0x1C, 0x00, 0x00, 0x00,
     0x00, 0x00,
   };
   // clang-format on
 
   std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames));
   ASSERT_TRUE(data != nullptr);
 
   test::CompareCharArraysWithHexError(
       "constructed packet", data->data(), data->length(),
-      AsChars(FLAGS_quic_restart_flag_quic_big_endian_connection_id
-                  ? packet_cid_be
-                  : packet),
-      FLAGS_quic_restart_flag_quic_big_endian_connection_id
+      AsChars(
+          QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
+              ? packet_cid_be
+              : packet),
+      QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
           ? arraysize(packet_cid_be)
           : arraysize(packet));
 }
 
 TEST_P(QuicFramerTest, BuildRstFramePacketQuic) {
   QuicPacketHeader header;
   header.public_header.connection_id = kConnectionId;
   header.public_header.reset_flag = false;
   header.public_header.version_flag = false;
   header.packet_number = kPacketNumber;
@@ skipping 46 matching lines @@
   };
   // clang-format on
 
   QuicFrames frames = {QuicFrame(&rst_frame)};
 
   std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames));
   ASSERT_TRUE(data != nullptr);
 
   test::CompareCharArraysWithHexError(
       "constructed packet", data->data(), data->length(),
-      AsChars(FLAGS_quic_restart_flag_quic_big_endian_connection_id
-                  ? packet_cid_be
-                  : packet),
-      FLAGS_quic_restart_flag_quic_big_endian_connection_id
+      AsChars(
+          QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
+              ? packet_cid_be
+              : packet),
+      QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
           ? arraysize(packet_cid_be)
           : arraysize(packet));
 }
 
 TEST_P(QuicFramerTest, BuildCloseFramePacket) {
   QuicPacketHeader header;
   header.public_header.connection_id = kConnectionId;
   header.public_header.reset_flag = false;
   header.public_header.version_flag = false;
   header.packet_number = kPacketNumber;
@@ skipping 49 matching lines @@
     'I',  ' ',  'c',  'a',
     'n',
   };
   // clang-format on
 
   std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames));
   ASSERT_TRUE(data != nullptr);
 
   test::CompareCharArraysWithHexError(
       "constructed packet", data->data(), data->length(),
-      AsChars(FLAGS_quic_restart_flag_quic_big_endian_connection_id
-                  ? packet_cid_be
-                  : packet),
-      FLAGS_quic_restart_flag_quic_big_endian_connection_id
+      AsChars(
+          QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
+              ? packet_cid_be
+              : packet),
+      QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
           ? arraysize(packet_cid_be)
           : arraysize(packet));
 }
 
 TEST_P(QuicFramerTest, BuildGoAwayPacket) {
   QuicPacketHeader header;
   header.public_header.connection_id = kConnectionId;
   header.public_header.reset_flag = false;
   header.public_header.version_flag = false;
   header.packet_number = kPacketNumber;
@@ skipping 54 matching lines @@
     'I',  ' ',  'c',  'a',
     'n',
   };
   // clang-format on
 
   std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames));
   ASSERT_TRUE(data != nullptr);
 
   test::CompareCharArraysWithHexError(
       "constructed packet", data->data(), data->length(),
-      AsChars(FLAGS_quic_restart_flag_quic_big_endian_connection_id
-                  ? packet_cid_be
-                  : packet),
-      FLAGS_quic_restart_flag_quic_big_endian_connection_id
+      AsChars(
+          QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
+              ? packet_cid_be
+              : packet),
+      QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
           ? arraysize(packet_cid_be)
           : arraysize(packet));
 }
 
 TEST_P(QuicFramerTest, BuildWindowUpdatePacket) {
   QuicPacketHeader header;
   header.public_header.connection_id = kConnectionId;
   header.public_header.reset_flag = false;
   header.public_header.version_flag = false;
   header.packet_number = kPacketNumber;
@@ skipping 41 matching lines @@
     0x88, 0x77, 0x66, 0x55,
     0x44, 0x33, 0x22, 0x11,
   };
   // clang-format on
 
   std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames));
   ASSERT_TRUE(data != nullptr);
 
   test::CompareCharArraysWithHexError(
       "constructed packet", data->data(), data->length(),
-      AsChars(FLAGS_quic_restart_flag_quic_big_endian_connection_id
-                  ? packet_cid_be
-                  : packet),
-      FLAGS_quic_restart_flag_quic_big_endian_connection_id
+      AsChars(
+          QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
+              ? packet_cid_be
+              : packet),
+      QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
           ? arraysize(packet_cid_be)
           : arraysize(packet));
 }
 
 TEST_P(QuicFramerTest, BuildBlockedPacket) {
   QuicPacketHeader header;
   header.public_header.connection_id = kConnectionId;
   header.public_header.reset_flag = false;
   header.public_header.version_flag = false;
   header.packet_number = kPacketNumber;
@@ skipping 34 matching lines @@
     // stream id
     0x04, 0x03, 0x02, 0x01,
   };
   // clang-format on
 
   std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames));
   ASSERT_TRUE(data != nullptr);
 
   test::CompareCharArraysWithHexError(
       "constructed packet", data->data(), data->length(),
-      AsChars(FLAGS_quic_restart_flag_quic_big_endian_connection_id
-                  ? packet_cid_be
-                  : packet),
-      FLAGS_quic_restart_flag_quic_big_endian_connection_id
+      AsChars(
+          QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
+              ? packet_cid_be
+              : packet),
+      QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
           ? arraysize(packet_cid_be)
           : arraysize(packet));
 }
 
 TEST_P(QuicFramerTest, BuildPingPacket) {
   QuicPacketHeader header;
   header.public_header.connection_id = kConnectionId;
   header.public_header.reset_flag = false;
   header.public_header.version_flag = false;
   header.packet_number = kPacketNumber;
@@ skipping 27 matching lines @@
     // frame type (ping frame)
     0x07,
   };
   // clang-format on
 
   std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames));
   ASSERT_TRUE(data != nullptr);
 
   test::CompareCharArraysWithHexError(
       "constructed packet", data->data(), data->length(),
-      AsChars(FLAGS_quic_restart_flag_quic_big_endian_connection_id
-                  ? packet_cid_be
-                  : packet),
-      FLAGS_quic_restart_flag_quic_big_endian_connection_id
+      AsChars(
+          QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
+              ? packet_cid_be
+              : packet),
+      QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
           ? arraysize(packet_cid_be)
           : arraysize(packet));
 }
 
 // Test that the MTU discovery packet is serialized correctly as a PING packet.
 TEST_P(QuicFramerTest, BuildMtuDiscoveryPacket) {
   QuicPacketHeader header;
   header.public_header.connection_id = kConnectionId;
   header.public_header.reset_flag = false;
   header.public_header.version_flag = false;
@@ skipping 28 matching lines @@
     // frame type (ping frame)
     0x07,
   };
   // clang-format on
 
   std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames));
   ASSERT_TRUE(data != nullptr);
 
   test::CompareCharArraysWithHexError(
       "constructed packet", data->data(), data->length(),
-      AsChars(FLAGS_quic_restart_flag_quic_big_endian_connection_id
-                  ? packet_cid_be
-                  : packet),
-      FLAGS_quic_restart_flag_quic_big_endian_connection_id
+      AsChars(
+          QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
+              ? packet_cid_be
+              : packet),
+      QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
           ? arraysize(packet_cid_be)
           : arraysize(packet));
 }
 
 TEST_P(QuicFramerTest, BuildPublicResetPacketOld) {
   FLAGS_quic_reloadable_flag_quic_use_old_public_reset_packets = true;
   QuicPublicResetPacket reset_packet;
   reset_packet.public_header.connection_id = kConnectionId;
   reset_packet.public_header.reset_flag = true;
   reset_packet.public_header.version_flag = false;
@@ skipping 89 matching lines @@
     0x01, 0xEF, 0xCD, 0xAB,
   };
   // clang-format on
 
   std::unique_ptr<QuicEncryptedPacket> data(
       framer_.BuildPublicResetPacket(reset_packet));
   ASSERT_TRUE(data != nullptr);
   if (FLAGS_quic_reloadable_flag_quic_remove_packet_number_from_public_reset) {
     test::CompareCharArraysWithHexError(
         "constructed packet", data->data(), data->length(),
-        AsChars(FLAGS_quic_restart_flag_quic_big_endian_connection_id
-                    ? packet_no_rejected_packet_number_cid_be
-                    : packet_no_rejected_packet_number),
-        FLAGS_quic_restart_flag_quic_big_endian_connection_id
+        AsChars(
+            QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
+                ? packet_no_rejected_packet_number_cid_be
+                : packet_no_rejected_packet_number),
+        QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
             ? arraysize(packet_no_rejected_packet_number_cid_be)
             : arraysize(packet_no_rejected_packet_number));
   } else {
     test::CompareCharArraysWithHexError(
         "constructed packet", data->data(), data->length(),
-        AsChars(FLAGS_quic_restart_flag_quic_big_endian_connection_id
-                    ? packet_cid_be
-                    : packet),
-        FLAGS_quic_restart_flag_quic_big_endian_connection_id
+        AsChars(
+            QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
+                ? packet_cid_be
+                : packet),
+        QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
             ? arraysize(packet_cid_be)
             : arraysize(packet));
   }
 }
 
 TEST_P(QuicFramerTest, BuildPublicResetPacket) {
   FLAGS_quic_reloadable_flag_quic_use_old_public_reset_packets = false;
   QuicPublicResetPacket reset_packet;
   reset_packet.public_header.connection_id = kConnectionId;
   reset_packet.public_header.reset_flag = true;
@@ skipping 91 matching lines @@
   };
   // clang-format on
 
   std::unique_ptr<QuicEncryptedPacket> data(
       framer_.BuildPublicResetPacket(reset_packet));
   ASSERT_TRUE(data != nullptr);
 
   if (FLAGS_quic_reloadable_flag_quic_remove_packet_number_from_public_reset) {
     test::CompareCharArraysWithHexError(
         "constructed packet", data->data(), data->length(),
-        AsChars(FLAGS_quic_restart_flag_quic_big_endian_connection_id
-                    ? packet_no_rejected_packet_number_cid_be
-                    : packet_no_rejected_packet_number),
-        FLAGS_quic_restart_flag_quic_big_endian_connection_id
+        AsChars(
+            QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
+                ? packet_no_rejected_packet_number_cid_be
+                : packet_no_rejected_packet_number),
+        QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
             ? arraysize(packet_no_rejected_packet_number_cid_be)
             : arraysize(packet_no_rejected_packet_number));
   } else {
     test::CompareCharArraysWithHexError(
         "constructed packet", data->data(), data->length(),
-        AsChars(FLAGS_quic_restart_flag_quic_big_endian_connection_id
-                    ? packet_cid_be
-                    : packet),
-        FLAGS_quic_restart_flag_quic_big_endian_connection_id
+        AsChars(
+            QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
+                ? packet_cid_be
+                : packet),
+        QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
             ? arraysize(packet_cid_be)
             : arraysize(packet));
   }
 }
 
 TEST_P(QuicFramerTest, BuildPublicResetPacketWithClientAddress) {
   FLAGS_quic_reloadable_flag_quic_use_old_public_reset_packets = false;
   QuicPublicResetPacket reset_packet;
   reset_packet.public_header.connection_id = kConnectionId;
   reset_packet.public_header.reset_flag = true;
@@ skipping 125 matching lines @@
   };
   // clang-format on
 
   std::unique_ptr<QuicEncryptedPacket> data(
       framer_.BuildPublicResetPacket(reset_packet));
   ASSERT_TRUE(data != nullptr);
 
   if (FLAGS_quic_reloadable_flag_quic_remove_packet_number_from_public_reset) {
     test::CompareCharArraysWithHexError(
         "constructed packet", data->data(), data->length(),
-        AsChars(FLAGS_quic_restart_flag_quic_big_endian_connection_id
-                    ? packet_no_rejected_packet_number_cid_be
-                    : packet_no_rejected_packet_number),
+        AsChars(
+            QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
+                ? packet_no_rejected_packet_number_cid_be
+                : packet_no_rejected_packet_number),
 
-        FLAGS_quic_restart_flag_quic_big_endian_connection_id
+        QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
             ? arraysize(packet_no_rejected_packet_number_cid_be)
             : arraysize(packet_no_rejected_packet_number));
   } else {
     test::CompareCharArraysWithHexError(
         "constructed packet", data->data(), data->length(),
-        AsChars(FLAGS_quic_restart_flag_quic_big_endian_connection_id
-                    ? packet_cid_be
-                    : packet),
+        AsChars(
+            QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
+                ? packet_cid_be
+                : packet),
 
-        FLAGS_quic_restart_flag_quic_big_endian_connection_id
+        QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
             ? arraysize(packet_cid_be)
             : arraysize(packet));
   }
 }
 
 TEST_P(QuicFramerTest, EncryptPacket) {
   QuicPacketNumber packet_number = kPacketNumber;
   // clang-format off
   unsigned char packet[] = {
     // public flags (8 byte connection_id)
@@ skipping 23 matching lines @@
 
     // redundancy
     'a',  'b',  'c',  'd',
     'e',  'f',  'g',  'h',
     'i',  'j',  'k',  'l',
     'm',  'n',  'o',  'p',
   };
   // clang-format on
 
   std::unique_ptr<QuicPacket> raw(new QuicPacket(
-      AsChars(FLAGS_quic_restart_flag_quic_big_endian_connection_id
-                  ? packet_cid_be
-                  : packet),
-      FLAGS_quic_restart_flag_quic_big_endian_connection_id
+      AsChars(
+          QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
+              ? packet_cid_be
+              : packet),
+      QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
           ? arraysize(packet_cid_be)
           : arraysize(packet),
       false, PACKET_8BYTE_CONNECTION_ID, !kIncludeVersion,
       !kIncludeDiversificationNonce, PACKET_6BYTE_PACKET_NUMBER));
   char buffer[kMaxPacketSize];
   size_t encrypted_length = framer_.EncryptPayload(
       ENCRYPTION_NONE, packet_number, *raw, buffer, kMaxPacketSize);
 
   ASSERT_NE(0u, encrypted_length);
   EXPECT_TRUE(CheckEncryption(packet_number, raw.get()));
@@ skipping 34 matching lines @@
 
     // redundancy
     'a',  'b',  'c',  'd',
     'e',  'f',  'g',  'h',
     'i',  'j',  'k',  'l',
     'm',  'n',  'o',  'p',
   };
   // clang-format on
 
   std::unique_ptr<QuicPacket> raw(new QuicPacket(
-      AsChars(FLAGS_quic_restart_flag_quic_big_endian_connection_id
-                  ? packet_cid_be
-                  : packet),
-      FLAGS_quic_restart_flag_quic_big_endian_connection_id
+      AsChars(
+          QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
+              ? packet_cid_be
+              : packet),
+      QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
           ? arraysize(packet_cid_be)
           : arraysize(packet),
       false, PACKET_8BYTE_CONNECTION_ID, kIncludeVersion,
       !kIncludeDiversificationNonce, PACKET_6BYTE_PACKET_NUMBER));
   char buffer[kMaxPacketSize];
   size_t encrypted_length = framer_.EncryptPayload(
       ENCRYPTION_NONE, packet_number, *raw, buffer, kMaxPacketSize);
 
   ASSERT_NE(0u, encrypted_length);
   EXPECT_TRUE(CheckEncryption(packet_number, raw.get()));
@@ skipping 186 matching lines @@
   EXPECT_CALL(visitor, OnPacket());
   EXPECT_CALL(visitor, OnPacketHeader(_));
   EXPECT_CALL(visitor, OnStreamFrame(_)).WillOnce(Return(false));
   EXPECT_CALL(visitor, OnAckFrame(_)).Times(0);
   EXPECT_CALL(visitor, OnPacketComplete());
   EXPECT_CALL(visitor, OnUnauthenticatedPublicHeader(_)).WillOnce(Return(true));
   EXPECT_CALL(visitor, OnUnauthenticatedHeader(_)).WillOnce(Return(true));
   EXPECT_CALL(visitor, OnDecryptedPacket(_));
 
   QuicEncryptedPacket encrypted(
-      AsChars(FLAGS_quic_restart_flag_quic_big_endian_connection_id
-                  ? packet_cid_be
-                  : packet),
-      FLAGS_quic_restart_flag_quic_big_endian_connection_id
+      AsChars(
+          QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
+              ? packet_cid_be
+              : packet),
+      QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
           ? arraysize(packet_cid_be)
           : arraysize(packet),
       false);
   EXPECT_TRUE(framer_.ProcessPacket(encrypted));
   EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
 }
 
 static char kTestString[] = "At least 20 characters.";
 static QuicStreamId kTestQuicStreamId = 1;
 static bool ExpectedStreamFrame(const QuicStreamFrame& frame) {
@@ skipping 153 matching lines @@
     0xDC, 0xFE, 0x98, 0xBA,
     // data length
     0x0c, 0x00,
     // data
     'h',  'e',  'l',  'l',
     'o',  ' ',  'w',  'o',
     'r',  'l',  'd',  '!',
   };
   // clang-format on
 
-  QuicFramerFuzzFunc(FLAGS_quic_restart_flag_quic_big_endian_connection_id
-                         ? packet_cid_be
-                         : packet,
-                     FLAGS_quic_restart_flag_quic_big_endian_connection_id
-                         ? arraysize(packet_cid_be)
-                         : arraysize(packet));
+  QuicFramerFuzzFunc(
+      QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
+          ? packet_cid_be
+          : packet,
+      QuicUtils::IsConnectionIdWireFormatBigEndian(framer_.perspective())
+          ? arraysize(packet_cid_be)
+          : arraysize(packet));
 }
 
 }  // namespace test
 }  // namespace net