Fix char narrowing issues in http2_frame_builder_test.cc.

On platforms where char is signed compilation fails with errors like:
http2_frame_builder_test.cc:42:9:
error: constant expression evaluates to 255 which cannot be narrowed to type 'char' [-Wc++11-narrowing]
        0xff, 0xff, 0xff,        // Payload length: 2^24 - 1 (max uint24)
PiperOrigin-RevId: 449998883
diff --git a/quiche/http2/test_tools/http2_frame_builder_test.cc b/quiche/http2/test_tools/http2_frame_builder_test.cc
index 3ded5d7..9097458 100644
--- a/quiche/http2/test_tools/http2_frame_builder_test.cc
+++ b/quiche/http2/test_tools/http2_frame_builder_test.cc
@@ -4,6 +4,7 @@
 
 #include "quiche/http2/test_tools/http2_frame_builder.h"
 
+#include "absl/strings/escaping.h"
 #include "quiche/common/platform/api/quiche_test.h"
 
 namespace http2 {
@@ -21,13 +22,12 @@
     Http2FrameBuilder fb(Http2FrameType::DATA, 0, 123);
     EXPECT_EQ(9u, fb.size());
 
-    const char kData[] = {
-        0x00, 0x00, 0x00,        // Payload length: 0 (unset)
-        0x00,                    // Frame type: DATA
-        0x00,                    // Flags: none
-        0x00, 0x00, 0x00, 0x7b,  // Stream ID: 123
-    };
-    EXPECT_EQ(absl::string_view(kData, sizeof kData), fb.buffer());
+    const std::string kData = absl::HexStringToBytes(
+        "000000"      // Payload length: 0 (unset)
+        "00"          // Frame type: DATA
+        "00"          // Flags: none
+        "0000007b");  // Stream ID: 123
+    EXPECT_EQ(kData, fb.buffer());
   }
   {
     Http2FrameHeader header;
@@ -38,13 +38,12 @@
     Http2FrameBuilder fb(header);
     EXPECT_EQ(9u, fb.size());
 
-    const char kData[] = {
-        0xff, 0xff, 0xff,        // Payload length: 2^24 - 1 (max uint24)
-        0x01,                    // Frame type: HEADER
-        0x04,                    // Flags: END_HEADERS
-        0x7f, 0xff, 0xff, 0xff,  // Stream ID: stream id mask
-    };
-    EXPECT_EQ(absl::string_view(kData, sizeof kData), fb.buffer());
+    const std::string kData = absl::HexStringToBytes(
+        "ffffff"      // Payload length: 2^24 - 1 (max uint24)
+        "01"          // Frame type: HEADER
+        "04"          // Flags: END_HEADERS
+        "7fffffff");  // Stream ID: stream id mask
+    EXPECT_EQ(kData, fb.buffer());
   }
 }
 
@@ -64,23 +63,19 @@
   fb.SetPayloadLength();
   EXPECT_EQ(70u, fb.size());
 
-  // clang-format off
-  const char kData[] = {
-      0x00, 0x00, 0x3d,              // Payload length: 61
-      0x00,                          // Frame type: DATA
-      0x08,                          // Flags: PADDED
-      0x00, 0x00, 0x4e, 0x20,        // Stream ID: 20000
-      0x32,                          // Padding Length: 50
-      't', 'e', 'n', ' ', 'b',       // "ten b"
-      'y', 't', 'e', 's', '.',       // "ytes."
-      0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  // Padding bytes
-      0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  // Padding bytes
-      0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  // Padding bytes
-      0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  // Padding bytes
-      0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  // Padding bytes
-  };
-  // clang-format on
-  EXPECT_EQ(absl::string_view(kData, sizeof kData), fb.buffer());
+  const std::string kData = absl::HexStringToBytes(
+      "00003d"                  // Payload length: 61
+      "00"                      // Frame type: DATA
+      "08"                      // Flags: PADDED
+      "00004e20"                // Stream ID: 20000
+      "32"                      // Padding Length: 50
+      "74656e2062797465732e"    // "ten bytes."
+      "00000000000000000000"    // Padding bytes
+      "00000000000000000000"    // Padding bytes
+      "00000000000000000000"    // Padding bytes
+      "00000000000000000000"    // Padding bytes
+      "00000000000000000000");  // Padding bytes
+  EXPECT_EQ(kData, fb.buffer());
 }
 
 TEST(Http2FrameBuilderTest, Settings) {
@@ -116,66 +111,55 @@
 
   fb.SetPayloadLength(payload_size);
 
-  // clang-format off
-  const char kData[] = {
-      0x00, 0x00, 0x24,        // Payload length: 36
-      0x04,                    // Frame type: SETTINGS
-      0x00,                    // Flags: none
-      0x00, 0x00, 0x00, 0x00,  // Stream ID: 0
-      0x00, 0x01,              // HEADER_TABLE_SIZE
-      0x00, 0x00, 0x10, 0x00,  // 4096
-      0x00, 0x02,              // ENABLE_PUSH
-      0x00, 0x00, 0x00, 0x00,  // 0
-      0x00, 0x03,              // MAX_CONCURRENT_STREAMS
-      0xff, 0xff, 0xff, 0xff,  // 0xffffffff (max uint32)
-      0x00, 0x04,              // INITIAL_WINDOW_SIZE
-      0x00, 0x01, 0x00, 0x00,  // 4096
-      0x00, 0x05,              // MAX_FRAME_SIZE
-      0x00, 0x00, 0x40, 0x00,  // 4096
-      0x00, 0x06,              // MAX_HEADER_LIST_SIZE
-      0x00, 0x00, 0x04, 0x00,  // 1024
-  };
-  // clang-format on
-  EXPECT_EQ(absl::string_view(kData, 9), fb.buffer().substr(0, 9));
-  for (int n = 0; n < 6; ++n) {
-    int offset = 9 + n * 6;
-    EXPECT_EQ(absl::string_view(kData + offset, 6),
-              fb.buffer().substr(offset, 6))
-        << "Setting #" << n;
-  }
-  EXPECT_EQ(absl::string_view(kData, sizeof kData), fb.buffer());
+  const std::string kData = absl::HexStringToBytes(
+      "000024"      // Payload length: 36
+      "04"          // Frame type: SETTINGS
+      "00"          // Flags: none
+      "00000000"    // Stream ID: 0
+      "0001"        // HEADER_TABLE_SIZE
+      "00001000"    // 4096
+      "0002"        // ENABLE_PUSH
+      "00000000"    // 0
+      "0003"        // MAX_CONCURRENT_STREAMS
+      "ffffffff"    // 0xffffffff (max uint32)
+      "0004"        // INITIAL_WINDOW_SIZE
+      "00010000"    // 4096
+      "0005"        // MAX_FRAME_SIZE
+      "00004000"    // 4096
+      "0006"        // MAX_HEADER_LIST_SIZE
+      "00000400");  // 1024
+  EXPECT_EQ(kData, fb.buffer());
 }
 
 TEST(Http2FrameBuilderTest, EnhanceYourCalm) {
-  const char kData[] = {0x00, 0x00, 0x00, 0x0b};
-  const absl::string_view expected(kData, sizeof kData);
+  const std::string kData = absl::HexStringToBytes("0000000b");
   {
     Http2FrameBuilder fb;
     fb.Append(Http2ErrorCode::ENHANCE_YOUR_CALM);
-    EXPECT_EQ(expected, fb.buffer());
+    EXPECT_EQ(kData, fb.buffer());
   }
   {
     Http2FrameBuilder fb;
     Http2RstStreamFields rsp;
     rsp.error_code = Http2ErrorCode::ENHANCE_YOUR_CALM;
     fb.Append(rsp);
-    EXPECT_EQ(expected, fb.buffer());
+    EXPECT_EQ(kData, fb.buffer());
   }
 }
 
 TEST(Http2FrameBuilderTest, PushPromise) {
-  const char kData[] = {0x7f, 0xff, 0xff, 0xff};
+  const std::string kData = absl::HexStringToBytes("7fffffff");
   {
     Http2FrameBuilder fb;
     fb.Append(Http2PushPromiseFields{0x7fffffff});
-    EXPECT_EQ(absl::string_view(kData, sizeof kData), fb.buffer());
+    EXPECT_EQ(kData, fb.buffer());
   }
   {
     Http2FrameBuilder fb;
     // Will generate an error if the high-bit of the stream id is set.
     EXPECT_NONFATAL_FAILURE(fb.Append(Http2PushPromiseFields{0xffffffff}),
                             kHighBitSetMsg);
-    EXPECT_EQ(absl::string_view(kData, sizeof kData), fb.buffer());
+    EXPECT_EQ(kData, fb.buffer());
   }
 }
 
@@ -184,29 +168,28 @@
   Http2PingFields ping{"8 bytes"};
   fb.Append(ping);
 
-  const char kData[] = {'8', ' ', 'b', 'y', 't', 'e', 's', '\0'};
-  EXPECT_EQ(sizeof kData, Http2PingFields::EncodedSize());
-  EXPECT_EQ(absl::string_view(kData, sizeof kData), fb.buffer());
+  const absl::string_view kData{"8 bytes\0", 8};
+  EXPECT_EQ(kData.size(), Http2PingFields::EncodedSize());
+  EXPECT_EQ(kData, fb.buffer());
 }
 
 TEST(Http2FrameBuilderTest, GoAway) {
-  const char kData[] = {
-      0x12, 0x34, 0x56, 0x78,  // Last Stream Id
-      0x00, 0x00, 0x00, 0x01,  // Error code
-  };
-  EXPECT_EQ(sizeof kData, Http2GoAwayFields::EncodedSize());
+  const std::string kData = absl::HexStringToBytes(
+      "12345678"    // Last Stream Id
+      "00000001");  // Error code
+  EXPECT_EQ(kData.size(), Http2GoAwayFields::EncodedSize());
   {
     Http2FrameBuilder fb;
     Http2GoAwayFields ga(0x12345678, Http2ErrorCode::PROTOCOL_ERROR);
     fb.Append(ga);
-    EXPECT_EQ(absl::string_view(kData, sizeof kData), fb.buffer());
+    EXPECT_EQ(kData, fb.buffer());
   }
   {
     Http2FrameBuilder fb;
     // Will generate a test failure if the high-bit of the stream id is set.
     Http2GoAwayFields ga(0x92345678, Http2ErrorCode::PROTOCOL_ERROR);
     EXPECT_NONFATAL_FAILURE(fb.Append(ga), kHighBitSetMsg);
-    EXPECT_EQ(absl::string_view(kData, sizeof kData), fb.buffer());
+    EXPECT_EQ(kData, fb.buffer());
   }
 }
 
@@ -221,25 +204,23 @@
   // Will generate a test failure if the increment is zero.
   EXPECT_NONFATAL_FAILURE(fb.Append(Http2WindowUpdateFields{0}), "non-zero");
 
-  const char kData[] = {
-      0x00, 0x01, 0xe2, 0x40,  // Valid Window Size Increment
-      0x00, 0x00, 0x00, 0x01,  // High-bit cleared
-      0x00, 0x00, 0x00, 0x00,  // Invalid Window Size Increment
-  };
-  EXPECT_EQ(sizeof kData, 3 * Http2WindowUpdateFields::EncodedSize());
-  EXPECT_EQ(absl::string_view(kData, sizeof kData), fb.buffer());
+  const std::string kData = absl::HexStringToBytes(
+      "0001e240"    // Valid Window Size Increment
+      "00000001"    // High-bit cleared
+      "00000000");  // Invalid Window Size Increment
+  EXPECT_EQ(kData.size(), 3 * Http2WindowUpdateFields::EncodedSize());
+  EXPECT_EQ(kData, fb.buffer());
 }
 
 TEST(Http2FrameBuilderTest, AltSvc) {
   Http2FrameBuilder fb;
   fb.Append(Http2AltSvcFields{99});
   fb.Append(Http2AltSvcFields{0});  // No optional origin
-  const char kData[] = {
-      0x00, 0x63,  // Has origin.
-      0x00, 0x00,  // Doesn't have origin.
-  };
-  EXPECT_EQ(sizeof kData, 2 * Http2AltSvcFields::EncodedSize());
-  EXPECT_EQ(absl::string_view(kData, sizeof kData), fb.buffer());
+  const std::string kData = absl::HexStringToBytes(
+      "0063"    // Has origin.
+      "0000");  // Doesn't have origin.
+  EXPECT_EQ(kData.size(), 2 * Http2AltSvcFields::EncodedSize());
+  EXPECT_EQ(kData, fb.buffer());
 }
 
 }  // namespace