Avoid storing values >= 0x80 in "char"s.

Since char is signed, this causes -Wc++11-narrowing to fire.  Instead
use uint8_t[], and then either cast to const char* or replace
StringPiece usage with span<const uint8_t>.

Bug: 1216696
Change-Id: I15086cb60f55096a4b6bc81a07ba06be4ac7d62d
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2951642
Reviewed-by: Scott Violet <sky@chromium.org>
Reviewed-by: Colin Blundell <blundell@chromium.org>
Reviewed-by: Eric Seckler <eseckler@chromium.org>
Reviewed-by: Daniel Cheng <dcheng@chromium.org>
Reviewed-by: Mike West <mkwst@chromium.org>
Reviewed-by: Paul Jensen <pauljensen@chromium.org>
Commit-Queue: Peter Kasting <pkasting@chromium.org>
Cr-Commit-Position: refs/heads/master@{#892058}

base/big_endian_unittest.cc

@@ -14,7 +14,7 @@
 namespace base {
 
 TEST(ReadBigEndianTest, ReadSignedPositive) {
-  char data[] = {0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x1A, 0X2A};
+  char data[] = {0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x1A, 0x2A};
   int8_t s8 = 0;
   int16_t s16 = 0;
   int32_t s32 = 0;
@@ -30,15 +30,15 @@ TEST(ReadBigEndianTest, ReadSignedPositive) {
 }
 
 TEST(ReadBigEndianTest, ReadSignedNegative) {
-  char data[] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0XFF};
+  uint8_t data[] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
   int8_t s8 = 0;
   int16_t s16 = 0;
   int32_t s32 = 0;
   int64_t s64 = 0;
-  ReadBigEndian(data, &s8);
-  ReadBigEndian(data, &s16);
-  ReadBigEndian(data, &s32);
-  ReadBigEndian(data, &s64);
+  ReadBigEndian(reinterpret_cast<const char*>(data), &s8);
+  ReadBigEndian(reinterpret_cast<const char*>(data), &s16);
+  ReadBigEndian(reinterpret_cast<const char*>(data), &s32);
+  ReadBigEndian(reinterpret_cast<const char*>(data), &s64);
   EXPECT_EQ(-1, s8);
   EXPECT_EQ(-1, s16);
   EXPECT_EQ(-1, s32);
@@ -46,15 +46,15 @@ TEST(ReadBigEndianTest, ReadSignedNegative) {
 }
 
 TEST(ReadBigEndianTest, ReadUnsignedSigned) {
-  char data[] = {0xA0, 0xB0, 0xC0, 0xD0, 0xE0, 0xF0, 0xA1, 0XA2};
+  uint8_t data[] = {0xA0, 0xB0, 0xC0, 0xD0, 0xE0, 0xF0, 0xA1, 0xA2};
   uint8_t u8 = 0;
   uint16_t u16 = 0;
   uint32_t u32 = 0;
   uint64_t u64 = 0;
-  ReadBigEndian(data, &u8);
-  ReadBigEndian(data, &u16);
-  ReadBigEndian(data, &u32);
-  ReadBigEndian(data, &u64);
+  ReadBigEndian(reinterpret_cast<const char*>(data), &u8);
+  ReadBigEndian(reinterpret_cast<const char*>(data), &u16);
+  ReadBigEndian(reinterpret_cast<const char*>(data), &u32);
+  ReadBigEndian(reinterpret_cast<const char*>(data), &u64);
   EXPECT_EQ(0xA0, u8);
   EXPECT_EQ(0xA0B0, u16);
   EXPECT_EQ(0xA0B0C0D0, u32);

chrome/browser/extensions/api/image_writer_private/xz_extractor.cc

@@ -30,7 +30,7 @@ constexpr base::FilePath::StringPieceType kExtractedBinFileName =
     FILE_PATH_LITERAL("extracted.bin");
 
 // https://tukaani.org/xz/xz-file-format-1.0.4.txt
-constexpr char kExpectedMagic[6] = {0xfd, '7', 'z', 'X', 'Z', 0x00};
+constexpr uint8_t kExpectedMagic[6] = {0xfd, '7', 'z', 'X', 'Z', 0x00};
 
 }  // namespace
 
@@ -46,8 +46,10 @@ bool XzExtractor::IsXzFile(const base::FilePath& image_path) {
   if (infile.ReadAtCurrentPos(actual_magic, kExpectedSize) != kExpectedSize)
     return false;
 
-  return std::equal(kExpectedMagic, kExpectedMagic + kExpectedSize,
-                    actual_magic);
+  return std::equal(
+      reinterpret_cast<const char*>(kExpectedMagic),
+      reinterpret_cast<const char*>(kExpectedMagic + kExpectedSize),
+      actual_magic);
 }
 
 // static

chrome/browser/ssl/sct_reporting_service_browsertest.cc

@@ -48,18 +48,18 @@ namespace {
 // log and one from a non-Google log.
 //
 // Google's "Argon2023" log ("6D7Q2j71BjUy51covIlryQPTy9ERa+zraeF3fW0GvW4="):
-const char kTestGoogleLogId[] = {
+const uint8_t kTestGoogleLogId[] = {
     0xe8, 0x3e, 0xd0, 0xda, 0x3e, 0xf5, 0x06, 0x35, 0x32, 0xe7, 0x57,
     0x28, 0xbc, 0x89, 0x6b, 0xc9, 0x03, 0xd3, 0xcb, 0xd1, 0x11, 0x6b,
     0xec, 0xeb, 0x69, 0xe1, 0x77, 0x7d, 0x6d, 0x06, 0xbd, 0x6e};
 // Cloudflare's "Nimbus2023" log
 // ("ejKMVNi3LbYg6jjgUh7phBZwMhOFTTvSK8E6V6NS61I="):
-const char kTestNonGoogleLogId1[] = {
+const uint8_t kTestNonGoogleLogId1[] = {
     0x7a, 0x32, 0x8c, 0x54, 0xd8, 0xb7, 0x2d, 0xb6, 0x20, 0xea, 0x38,
     0xe0, 0x52, 0x1e, 0xe9, 0x84, 0x16, 0x70, 0x32, 0x13, 0x85, 0x4d,
     0x3b, 0xd2, 0x2b, 0xc1, 0x3a, 0x57, 0xa3, 0x52, 0xeb, 0x52};
 // DigiCert's "Yeti2023" log ("Nc8ZG7+xbFe/D61MbULLu7YnICZR6j/hKu+oA8M71kw="):
-const char kTestNonGoogleLogId2[] = {
+const uint8_t kTestNonGoogleLogId2[] = {
     0x35, 0xcf, 0x19, 0x1b, 0xbf, 0xb1, 0x6c, 0x57, 0xbf, 0x0f, 0xad,
     0x4c, 0x6d, 0x42, 0xcb, 0xbb, 0xb6, 0x27, 0x20, 0x26, 0x51, 0xea,
     0x3f, 0xe1, 0x2a, 0xef, 0xa8, 0x03, 0xc3, 0x3b, 0xd6, 0x4c};
@@ -135,17 +135,20 @@ class SCTReportingServiceBrowserTest : public CertVerifierBrowserTest {
     MakeTestSCTAndStatus(
         net::ct::SignedCertificateTimestamp::SCT_EMBEDDED, "extensions1",
         "signature1", base::Time::Now(),
-        std::string(kTestGoogleLogId, base::size(kTestGoogleLogId)),
+        std::string(reinterpret_cast<const char*>(kTestGoogleLogId),
+                    base::size(kTestGoogleLogId)),
         net::ct::SCT_STATUS_OK, &verify_result.scts);
     MakeTestSCTAndStatus(
         net::ct::SignedCertificateTimestamp::SCT_EMBEDDED, "extensions2",
         "signature2", base::Time::Now(),
-        std::string(kTestNonGoogleLogId1, base::size(kTestNonGoogleLogId1)),
+        std::string(reinterpret_cast<const char*>(kTestNonGoogleLogId1),
+                    base::size(kTestNonGoogleLogId1)),
         net::ct::SCT_STATUS_OK, &verify_result.scts);
     MakeTestSCTAndStatus(
         net::ct::SignedCertificateTimestamp::SCT_EMBEDDED, "extensions3",
         "signature3", base::Time::Now(),
-        std::string(kTestNonGoogleLogId2, base::size(kTestNonGoogleLogId2)),
+        std::string(reinterpret_cast<const char*>(kTestNonGoogleLogId2),
+                    base::size(kTestNonGoogleLogId2)),
         net::ct::SCT_STATUS_OK, &verify_result.scts);
 
     // Set up two test hosts as using publicly-issued certificates for testing.
@@ -398,17 +401,20 @@ IN_PROC_BROWSER_TEST_F(SCTReportingServiceBrowserTest,
   MakeTestSCTAndStatus(
       net::ct::SignedCertificateTimestamp::SCT_EMBEDDED, "extensions1",
       "signature1", base::Time::Now(),
-      std::string(kTestGoogleLogId, base::size(kTestGoogleLogId)),
+      std::string(reinterpret_cast<const char*>(kTestGoogleLogId),
+                  base::size(kTestGoogleLogId)),
       net::ct::SCT_STATUS_OK, &verify_result.scts);
   MakeTestSCTAndStatus(
       net::ct::SignedCertificateTimestamp::SCT_EMBEDDED, "extensions2",
       "signature2", base::Time::Now(),
-      std::string(kTestNonGoogleLogId1, base::size(kTestNonGoogleLogId1)),
+      std::string(reinterpret_cast<const char*>(kTestNonGoogleLogId1),
+                  base::size(kTestNonGoogleLogId1)),
       net::ct::SCT_STATUS_OK, &verify_result.scts);
   MakeTestSCTAndStatus(
       net::ct::SignedCertificateTimestamp::SCT_EMBEDDED, "extensions3",
       "signature3", base::Time::Now(),
-      std::string(kTestNonGoogleLogId2, base::size(kTestNonGoogleLogId2)),
+      std::string(reinterpret_cast<const char*>(kTestNonGoogleLogId2),
+                  base::size(kTestNonGoogleLogId2)),
       net::ct::SCT_STATUS_OK, &verify_result.scts);
   mock_cert_verifier()->AddResultForCertAndHost(
       https_server()->GetCertificate().get(), "a.test", verify_result, net::OK);
@@ -435,24 +441,29 @@ IN_PROC_BROWSER_TEST_F(SCTReportingServiceBrowserTest,
   verify_result.is_issued_by_known_root = true;
   // Add three valid SCTs and one invalid SCT. The three valid SCTs meet the
   // Chrome CT policy.
-  MakeTestSCTAndStatus(net::ct::SignedCertificateTimestamp::SCT_EMBEDDED,
-                       "extensions1", "signature1", base::Time::Now(),
-                       std::string(kTestGoogleLogId, sizeof(kTestGoogleLogId)),
-                       net::ct::SCT_STATUS_OK, &verify_result.scts);
+  MakeTestSCTAndStatus(
+      net::ct::SignedCertificateTimestamp::SCT_EMBEDDED, "extensions1",
+      "signature1", base::Time::Now(),
+      std::string(reinterpret_cast<const char*>(kTestGoogleLogId),
+                  sizeof(kTestGoogleLogId)),
+      net::ct::SCT_STATUS_OK, &verify_result.scts);
   MakeTestSCTAndStatus(
       net::ct::SignedCertificateTimestamp::SCT_EMBEDDED, "extensions2",
       "signature2", base::Time::Now(),
-      std::string(kTestNonGoogleLogId1, sizeof(kTestNonGoogleLogId1)),
+      std::string(reinterpret_cast<const char*>(kTestNonGoogleLogId1),
+                  sizeof(kTestNonGoogleLogId1)),
       net::ct::SCT_STATUS_OK, &verify_result.scts);
   MakeTestSCTAndStatus(
       net::ct::SignedCertificateTimestamp::SCT_EMBEDDED, "extensions3",
       "signature3", base::Time::Now(),
-      std::string(kTestNonGoogleLogId2, sizeof(kTestNonGoogleLogId2)),
+      std::string(reinterpret_cast<const char*>(kTestNonGoogleLogId2),
+                  sizeof(kTestNonGoogleLogId2)),
       net::ct::SCT_STATUS_OK, &verify_result.scts);
   MakeTestSCTAndStatus(
       net::ct::SignedCertificateTimestamp::SCT_EMBEDDED, "extensions4",
       "signature4", base::Time::Now(),
-      std::string(kTestNonGoogleLogId2, sizeof(kTestNonGoogleLogId2)),
+      std::string(reinterpret_cast<const char*>(kTestNonGoogleLogId2),
+                  sizeof(kTestNonGoogleLogId2)),
       net::ct::SCT_STATUS_INVALID_SIGNATURE, &verify_result.scts);
 
   mock_cert_verifier()->AddResultForCertAndHost(
@@ -482,17 +493,20 @@ IN_PROC_BROWSER_TEST_F(SCTReportingServiceBrowserTest,
   MakeTestSCTAndStatus(
       net::ct::SignedCertificateTimestamp::SCT_EMBEDDED, "extensions1",
       "signature1", base::Time::Now(),
-      std::string(kTestNonGoogleLogId1, sizeof(kTestNonGoogleLogId1)),
+      std::string(reinterpret_cast<const char*>(kTestNonGoogleLogId1),
+                  sizeof(kTestNonGoogleLogId1)),
       net::ct::SCT_STATUS_OK, &verify_result.scts);
   MakeTestSCTAndStatus(
       net::ct::SignedCertificateTimestamp::SCT_EMBEDDED, "extensions2",
       "signature2", base::Time::Now(),
-      std::string(kTestNonGoogleLogId1, sizeof(kTestNonGoogleLogId1)),
+      std::string(reinterpret_cast<const char*>(kTestNonGoogleLogId1),
+                  sizeof(kTestNonGoogleLogId1)),
       net::ct::SCT_STATUS_INVALID_SIGNATURE, &verify_result.scts);
   MakeTestSCTAndStatus(
       net::ct::SignedCertificateTimestamp::SCT_EMBEDDED, "extensions3",
       "signature3", base::Time::Now(),
-      std::string(kTestNonGoogleLogId2, sizeof(kTestNonGoogleLogId2)),
+      std::string(reinterpret_cast<const char*>(kTestNonGoogleLogId2),
+                  sizeof(kTestNonGoogleLogId2)),
       net::ct::SCT_STATUS_INVALID_SIGNATURE, &verify_result.scts);
 
   mock_cert_verifier()->AddResultForCertAndHost(
@@ -517,17 +531,20 @@ IN_PROC_BROWSER_TEST_F(SCTReportingServiceBrowserTest, NoValidSCTsNoReport) {
   MakeTestSCTAndStatus(
       net::ct::SignedCertificateTimestamp::SCT_EMBEDDED, "extensions1",
       "signature1", base::Time::Now(),
-      std::string(kTestNonGoogleLogId1, sizeof(kTestNonGoogleLogId1)),
+      std::string(reinterpret_cast<const char*>(kTestNonGoogleLogId1),
+                  sizeof(kTestNonGoogleLogId1)),
       net::ct::SCT_STATUS_INVALID_TIMESTAMP, &verify_result.scts);
   MakeTestSCTAndStatus(
       net::ct::SignedCertificateTimestamp::SCT_EMBEDDED, "extensions2",
       "signature2", base::Time::Now(),
-      std::string(kTestNonGoogleLogId1, sizeof(kTestNonGoogleLogId1)),
+      std::string(reinterpret_cast<const char*>(kTestNonGoogleLogId1),
+                  sizeof(kTestNonGoogleLogId1)),
       net::ct::SCT_STATUS_INVALID_SIGNATURE, &verify_result.scts);
   MakeTestSCTAndStatus(
       net::ct::SignedCertificateTimestamp::SCT_EMBEDDED, "extensions3",
       "signature3", base::Time::Now(),
-      std::string(kTestNonGoogleLogId1, sizeof(kTestNonGoogleLogId1)),
+      std::string(reinterpret_cast<const char*>(kTestNonGoogleLogId1),
+                  sizeof(kTestNonGoogleLogId1)),
       net::ct::SCT_STATUS_INVALID_SIGNATURE, &verify_result.scts);
 
   mock_cert_verifier()->AddResultForCertAndHost(

components/bookmarks/browser/bookmark_node_data_unittest.cc

@@ -443,9 +443,10 @@ TEST_F(BookmarkNodeDataTest, MetaInfo) {
 #if !defined(OS_APPLE)
 TEST_F(BookmarkNodeDataTest, ReadFromPickleTooManyNodes) {
   // Test case determined by a fuzzer. See https://crbug.com/956583.
-  const char pickled_data[] = {0x08, 0x00, 0x00, 0x00, 0x00, 0x00,
-                               0x00, 0x00, 0xff, 0x03, 0x03, 0x41};
-  base::Pickle pickle(pickled_data, sizeof(pickled_data));
+  const uint8_t pickled_data[] = {0x08, 0x00, 0x00, 0x00, 0x00, 0x00,
+                                  0x00, 0x00, 0xff, 0x03, 0x03, 0x41};
+  base::Pickle pickle(reinterpret_cast<const char*>(pickled_data),
+                      sizeof(pickled_data));
   BookmarkNodeData bookmark_node_data;
   EXPECT_FALSE(bookmark_node_data.ReadFromPickle(&pickle));
 }

components/consent_auditor/consent_auditor_impl_unittest.cc

@@ -349,11 +349,11 @@ TEST_F(ConsentAuditorImplTest, RecordArcPlayConsent) {
   play_consent.set_consent_flow(ArcPlayTermsOfServiceConsent::SETUP);
 
   // Verify the hash: 2fd4e1c6 7a2d28fc ed849ee1 bb76e739 1b93eb12.
-  const char play_tos_hash[] = {0x2f, 0xd4, 0xe1, 0xc6, 0x7a, 0x2d, 0x28,
-                                0xfc, 0xed, 0x84, 0x9e, 0xe1, 0xbb, 0x76,
-                                0xe7, 0x39, 0x1b, 0x93, 0xeb, 0x12};
-  play_consent.set_play_terms_of_service_hash(
-      std::string(play_tos_hash, base::kSHA1Length));
+  const uint8_t play_tos_hash[] = {0x2f, 0xd4, 0xe1, 0xc6, 0x7a, 0x2d, 0x28,
+                                   0xfc, 0xed, 0x84, 0x9e, 0xe1, 0xbb, 0x76,
+                                   0xe7, 0x39, 0x1b, 0x93, 0xeb, 0x12};
+  play_consent.set_play_terms_of_service_hash(std::string(
+      reinterpret_cast<const char*>(play_tos_hash), base::kSHA1Length));
   play_consent.set_play_terms_of_service_text_length(7);
 
   consent_auditor()->RecordArcPlayConsent(kAccountId, play_consent);
@@ -371,7 +371,8 @@ TEST_F(ConsentAuditorImplTest, RecordArcPlayConsent) {
       consent.arc_play_terms_of_service_consent();
 
   EXPECT_EQ(7, actual_play_consent.play_terms_of_service_text_length());
-  EXPECT_EQ(std::string(play_tos_hash, base::kSHA1Length),
+  EXPECT_EQ(std::string(reinterpret_cast<const char*>(play_tos_hash),
+                        base::kSHA1Length),
             actual_play_consent.play_terms_of_service_hash());
 
   EXPECT_EQ(kConfirmationMessageId, actual_play_consent.confirmation_grd_id());

components/password_manager/core/browser/leak_detection/encryption_utils_unittest.cc

@@ -57,11 +57,13 @@ TEST(EncryptionUtils, CanonicalizeUsername) {
 TEST(EncryptionUtils, HashUsername) {
   // Same test case as used by the server-side implementation:
   // go/passwords-leak-test
-  constexpr char kExpected[] = {0x3D, 0x70, 0xD3, 0x7B, 0xFC, 0x1A, 0x3D, 0x81,
-                                0x45, 0xE6, 0xC7, 0xA3, 0xA4, 0xD7, 0x92, 0x76,
-                                0x61, 0xC1, 0xE8, 0xDF, 0x82, 0xBD, 0x0C, 0x9F,
-                                0x61, 0x9A, 0xA3, 0xC9, 0x96, 0xEC, 0x4C, 0xB3};
-  EXPECT_THAT(HashUsername("jonsnow"), ElementsAreArray(kExpected));
+  constexpr uint8_t kExpected[] = {
+      0x3D, 0x70, 0xD3, 0x7B, 0xFC, 0x1A, 0x3D, 0x81, 0x45, 0xE6, 0xC7,
+      0xA3, 0xA4, 0xD7, 0x92, 0x76, 0x61, 0xC1, 0xE8, 0xDF, 0x82, 0xBD,
+      0x0C, 0x9F, 0x61, 0x9A, 0xA3, 0xC9, 0x96, 0xEC, 0x4C, 0xB3};
+  EXPECT_THAT(HashUsername("jonsnow"),
+              ElementsAreArray(reinterpret_cast<const char*>(kExpected),
+                               base::size(kExpected)));
 }
 
 TEST(EncryptionUtils, BucketizeUsername) {

components/sync/nigori/nigori.cc

@@ -99,14 +99,15 @@ void Nigori::Keys::InitByDerivationUsingPbkdf2(const std::string& password) {
   // "dummy") as PBKDF2_HMAC_SHA1(Ns("dummy") + Ns("localhost"), "saltsalt",
   // 1001, 128), where Ns(S) is the NigoriStream representation of S (32-bit
   // big-endian length of S followed by S itself).
-  const char kRawConstantSalt[] = {0xc7, 0xca, 0xfb, 0x23, 0xec, 0x2a,
-                                   0x9d, 0x4c, 0x03, 0x5a, 0x90, 0xae,
-                                   0xed, 0x8b, 0xa4, 0x98};
+  const uint8_t kRawConstantSalt[] = {0xc7, 0xca, 0xfb, 0x23, 0xec, 0x2a,
+                                      0x9d, 0x4c, 0x03, 0x5a, 0x90, 0xae,
+                                      0xed, 0x8b, 0xa4, 0x98};
   const size_t kUserIterations = 1002;
   const size_t kEncryptionIterations = 1003;
   const size_t kSigningIterations = 1004;
 
-  std::string salt(kRawConstantSalt, sizeof(kRawConstantSalt));
+  std::string salt(reinterpret_cast<const char*>(kRawConstantSalt),
+                   sizeof(kRawConstantSalt));
 
   // Kuser = PBKDF2(P, Suser, Nuser, 16)
   user_key = SymmetricKey::DeriveKeyFromPasswordUsingPbkdf2(

headless/lib/headless_content_main_delegate.cc

@@ -93,9 +93,7 @@ void InitializeResourceBundle(const base::CommandLine& command_line) {
 
 #ifdef HEADLESS_USE_EMBEDDED_RESOURCES
   ui::ResourceBundle::GetSharedInstance().AddDataPackFromBuffer(
-      base::StringPiece(
-          reinterpret_cast<const char*>(kHeadlessResourcePak.contents),
-          kHeadlessResourcePak.length),
+      {kHeadlessResourcePak.contents, kHeadlessResourcePak.length},
       ui::SCALE_FACTOR_NONE);
 
 #else

mojo/public/cpp/base/byte_string_unittest.cc

@@ -14,7 +14,7 @@ namespace mojo_base {
 TEST(ByteStringTest, Test) {
   const std::string kCases[] = {
       "hello",                     // C-string
-      {0xEF, 0xB7, 0xAF},          // invalid UTF-8
+      {'\xEF', '\xB7', '\xAF'},    // invalid UTF-8
       {'h', '\0', 'w', 'd', 'y'},  // embedded null
   };
   for (size_t i = 0; i < base::size(kCases); ++i) {

net/dns/dns_response_unittest.cc

@@ -1225,7 +1225,7 @@ TEST(DnsResponseTest, ParserLimitedToBufferSize) {
 }
 
 TEST(DnsResponseWriteTest, SingleARecordAnswer) {
-  const char response_data[] = {
+  const uint8_t response_data[] = {
       0x12, 0x34,  // ID
       0x84, 0x00,  // flags, response with authoritative answer
       0x00, 0x00,  // number of questions
@@ -1253,14 +1253,15 @@ TEST(DnsResponseWriteTest, SingleARecordAnswer) {
                        {} /* additional records */, absl::nullopt);
   ASSERT_NE(nullptr, response.io_buffer());
   EXPECT_TRUE(response.IsValid());
-  std::string expected_response(response_data, sizeof(response_data));
+  std::string expected_response(reinterpret_cast<const char*>(response_data),
+                                sizeof(response_data));
   std::string actual_response(response.io_buffer()->data(),
                               response.io_buffer_size());
   EXPECT_EQ(expected_response, actual_response);
 }
 
 TEST(DnsResponseWriteTest, SingleARecordAnswerWithFinalDotInName) {
-  const char response_data[] = {
+  const uint8_t response_data[] = {
       0x12, 0x34,  // ID
       0x84, 0x00,  // flags, response with authoritative answer
       0x00, 0x00,  // number of questions
@@ -1288,14 +1289,15 @@ TEST(DnsResponseWriteTest, SingleARecordAnswerWithFinalDotInName) {
                        {} /* additional records */, absl::nullopt);
   ASSERT_NE(nullptr, response.io_buffer());
   EXPECT_TRUE(response.IsValid());
-  std::string expected_response(response_data, sizeof(response_data));
+  std::string expected_response(reinterpret_cast<const char*>(response_data),
+                                sizeof(response_data));
   std::string actual_response(response.io_buffer()->data(),
                               response.io_buffer_size());
   EXPECT_EQ(expected_response, actual_response);
 }
 
 TEST(DnsResponseWriteTest, SingleARecordAnswerWithQuestion) {
-  const char response_data[] = {
+  const uint8_t response_data[] = {
       0x12, 0x34,  // ID
       0x84, 0x00,  // flags, response with authoritative answer
       0x00, 0x01,  // number of questions
@@ -1335,7 +1337,8 @@ TEST(DnsResponseWriteTest, SingleARecordAnswerWithQuestion) {
                        query);
   ASSERT_NE(nullptr, response.io_buffer());
   EXPECT_TRUE(response.IsValid());
-  std::string expected_response(response_data, sizeof(response_data));
+  std::string expected_response(reinterpret_cast<const char*>(response_data),
+                                sizeof(response_data));
   std::string actual_response(response.io_buffer()->data(),
                               response.io_buffer_size());
   EXPECT_EQ(expected_response, actual_response);
@@ -1343,7 +1346,7 @@ TEST(DnsResponseWriteTest, SingleARecordAnswerWithQuestion) {
 
 TEST(DnsResponseWriteTest,
      SingleAnswerWithQuestionConstructedFromSizeInflatedQuery) {
-  const char response_data[] = {
+  const uint8_t response_data[] = {
       0x12, 0x34,  // ID
       0x84, 0x00,  // flags, response with authoritative answer
       0x00, 0x01,  // number of questions
@@ -1399,14 +1402,15 @@ TEST(DnsResponseWriteTest,
                        query);
   ASSERT_NE(nullptr, response.io_buffer());
   EXPECT_TRUE(response.IsValid());
-  std::string expected_response(response_data, sizeof(response_data));
+  std::string expected_response(reinterpret_cast<const char*>(response_data),
+                                sizeof(response_data));
   std::string actual_response(response.io_buffer()->data(),
                               response.io_buffer_size());
   EXPECT_EQ(expected_response, actual_response);
 }
 
 TEST(DnsResponseWriteTest, SingleQuadARecordAnswer) {
-  const char response_data[] = {
+  const uint8_t response_data[] = {
       0x12, 0x34,  // ID
       0x84, 0x00,  // flags, response with authoritative answer
       0x00, 0x00,  // number of questions
@@ -1436,7 +1440,8 @@ TEST(DnsResponseWriteTest, SingleQuadARecordAnswer) {
                        absl::nullopt);
   ASSERT_NE(nullptr, response.io_buffer());
   EXPECT_TRUE(response.IsValid());
-  std::string expected_response(response_data, sizeof(response_data));
+  std::string expected_response(reinterpret_cast<const char*>(response_data),
+                                sizeof(response_data));
   std::string actual_response(response.io_buffer()->data(),
                               response.io_buffer_size());
   EXPECT_EQ(expected_response, actual_response);
@@ -1444,7 +1449,7 @@ TEST(DnsResponseWriteTest, SingleQuadARecordAnswer) {
 
 TEST(DnsResponseWriteTest,
      SingleARecordAnswerWithQuestionAndNsecAdditionalRecord) {
-  const char response_data[] = {
+  const uint8_t response_data[] = {
       0x12, 0x34,  // ID
       0x84, 0x00,  // flags, response with authoritative answer
       0x00, 0x01,  // number of questions
@@ -1499,14 +1504,15 @@ TEST(DnsResponseWriteTest,
                        {} /* authority_records */, additional_records, query);
   ASSERT_NE(nullptr, response.io_buffer());
   EXPECT_TRUE(response.IsValid());
-  std::string expected_response(response_data, sizeof(response_data));
+  std::string expected_response(reinterpret_cast<const char*>(response_data),
+                                sizeof(response_data));
   std::string actual_response(response.io_buffer()->data(),
                               response.io_buffer_size());
   EXPECT_EQ(expected_response, actual_response);
 }
 
 TEST(DnsResponseWriteTest, TwoAnswersWithAAndQuadARecords) {
-  const char response_data[] = {
+  const uint8_t response_data[] = {
       0x12, 0x34,  // ID
       0x84, 0x00,  // flags, response with authoritative answer
       0x00, 0x00,  // number of questions
@@ -1551,14 +1557,15 @@ TEST(DnsResponseWriteTest, TwoAnswersWithAAndQuadARecords) {
                        absl::nullopt);
   ASSERT_NE(nullptr, response.io_buffer());
   EXPECT_TRUE(response.IsValid());
-  std::string expected_response(response_data, sizeof(response_data));
+  std::string expected_response(reinterpret_cast<const char*>(response_data),
+                                sizeof(response_data));
   std::string actual_response(response.io_buffer()->data(),
                               response.io_buffer_size());
   EXPECT_EQ(expected_response, actual_response);
 }
 
 TEST(DnsResponseWriteTest, AnswerWithAuthorityRecord) {
-  const char response_data[] = {
+  const uint8_t response_data[] = {
       0x12, 0x35,  // ID
       0x84, 0x00,  // flags, response with authoritative answer
       0x00, 0x00,  // number of questions
@@ -1586,14 +1593,15 @@ TEST(DnsResponseWriteTest, AnswerWithAuthorityRecord) {
                        {} /* additional records */, absl::nullopt);
   ASSERT_NE(nullptr, response.io_buffer());
   EXPECT_TRUE(response.IsValid());
-  std::string expected_response(response_data, sizeof(response_data));
+  std::string expected_response(reinterpret_cast<const char*>(response_data),
+                                sizeof(response_data));
   std::string actual_response(response.io_buffer()->data(),
                               response.io_buffer_size());
   EXPECT_EQ(expected_response, actual_response);
 }
 
 TEST(DnsResponseWriteTest, AnswerWithRcode) {
-  const char response_data[] = {
+  const uint8_t response_data[] = {
       0x12, 0x12,  // ID
       0x80, 0x03,  // flags (response with non-existent domain)
       0x00, 0x00,  // number of questions
@@ -1607,7 +1615,8 @@ TEST(DnsResponseWriteTest, AnswerWithRcode) {
                        dns_protocol::kRcodeNXDOMAIN);
   ASSERT_NE(nullptr, response.io_buffer());
   EXPECT_TRUE(response.IsValid());
-  std::string expected_response(response_data, sizeof(response_data));
+  std::string expected_response(reinterpret_cast<const char*>(response_data),
+                                sizeof(response_data));
   std::string actual_response(response.io_buffer()->data(),
                               response.io_buffer_size());
   EXPECT_EQ(expected_response, actual_response);

net/socket/ssl_connect_job_unittest.cc

@@ -760,13 +760,14 @@ TEST_F(SSLConnectJobTest, SOCKSHostResolutionFailure) {
 TEST_F(SSLConnectJobTest, SOCKSBasic) {
   for (IoMode io_mode : {SYNCHRONOUS, ASYNC}) {
     SCOPED_TRACE(io_mode);
-    const char kSOCKS5Request[] = {0x05, 0x01, 0x00, 0x03, 0x09, 's',
-                                   'o',  'c',  'k',  's',  'h',  'o',
-                                   's',  't',  0x01, 0xBB};
+    const uint8_t kSOCKS5Request[] = {0x05, 0x01, 0x00, 0x03, 0x09, 's',
+                                      'o',  'c',  'k',  's',  'h',  'o',
+                                      's',  't',  0x01, 0xBB};
 
     MockWrite writes[] = {
         MockWrite(io_mode, kSOCKS5GreetRequest, kSOCKS5GreetRequestLength),
-        MockWrite(io_mode, kSOCKS5Request, base::size(kSOCKS5Request)),
+        MockWrite(io_mode, reinterpret_cast<const char*>(kSOCKS5Request),
+                  base::size(kSOCKS5Request)),
     };
 
     MockRead reads[] = {
@@ -794,12 +795,14 @@ TEST_F(SSLConnectJobTest, SOCKSBasic) {
 }
 
 TEST_F(SSLConnectJobTest, SOCKSHasEstablishedConnection) {
-  const char kSOCKS5Request[] = {0x05, 0x01, 0x00, 0x03, 0x09, 's', 'o',  'c',
-                                 'k',  's',  'h',  'o',  's',  't', 0x01, 0xBB};
+  const uint8_t kSOCKS5Request[] = {0x05, 0x01, 0x00, 0x03, 0x09, 's',
+                                    'o',  'c',  'k',  's',  'h',  'o',
+                                    's',  't',  0x01, 0xBB};
 
   MockWrite writes[] = {
       MockWrite(SYNCHRONOUS, kSOCKS5GreetRequest, kSOCKS5GreetRequestLength, 0),
-      MockWrite(SYNCHRONOUS, kSOCKS5Request, base::size(kSOCKS5Request), 3),
+      MockWrite(SYNCHRONOUS, reinterpret_cast<const char*>(kSOCKS5Request),
+                base::size(kSOCKS5Request), 3),
   };
 
   MockRead reads[] = {

net/spdy/spdy_network_transaction_unittest.cc

@@ -10506,14 +10506,14 @@ TEST_F(SpdyNetworkTransactionTest, GreaseFrameTypeWithGetRequest) {
       spdy_util_.ConstructSpdyHeaders(1, std::move(headers), DEFAULT_PRIORITY,
                                       /* fin = */ false));
 
-  const char kRawFrameData[] = {
+  uint8_t kRawFrameData[] = {
       0x00, 0x00, 0x03,        // length
       0x0b,                    // type
       0xcc,                    // flags
       0x00, 0x00, 0x00, 0x01,  // stream ID
       'f',  'o',  'o'          // payload
   };
-  spdy::SpdySerializedFrame grease(const_cast<char*>(kRawFrameData),
+  spdy::SpdySerializedFrame grease(reinterpret_cast<char*>(kRawFrameData),
                                    base::size(kRawFrameData),
                                    /* owns_buffer = */ false);
   spdy::SpdySerializedFrame empty_body(
@@ -10565,14 +10565,14 @@ TEST_F(SpdyNetworkTransactionTest,
   spdy::SpdySerializedFrame req(spdy_util_.ConstructSpdyPost(
       kDefaultUrl, 1, kUploadDataSize, LOWEST, nullptr, 0));
 
-  const char kRawFrameData[] = {
+  uint8_t kRawFrameData[] = {
       0x00, 0x00, 0x03,        // length
       0x0b,                    // type
       0xcc,                    // flags
       0x00, 0x00, 0x00, 0x01,  // stream ID
       'f',  'o',  'o'          // payload
   };
-  spdy::SpdySerializedFrame grease(const_cast<char*>(kRawFrameData),
+  spdy::SpdySerializedFrame grease(reinterpret_cast<char*>(kRawFrameData),
                                    base::size(kRawFrameData),
                                    /* owns_buffer = */ false);
   spdy::SpdySerializedFrame request_body(
@@ -10625,14 +10625,14 @@ TEST_F(SpdyNetworkTransactionTest,
   spdy::SpdySerializedFrame req(spdy_util_.ConstructSpdyPost(
       kDefaultUrl, 1, kUploadDataSize, LOWEST, nullptr, 0));
 
-  const char kRawFrameData[] = {
+  uint8_t kRawFrameData[] = {
       0x00, 0x00, 0x03,        // length
       0x0b,                    // type
       0xcc,                    // flags
       0x00, 0x00, 0x00, 0x01,  // stream ID
       'f',  'o',  'o'          // payload
   };
-  spdy::SpdySerializedFrame grease(const_cast<char*>(kRawFrameData),
+  spdy::SpdySerializedFrame grease(reinterpret_cast<char*>(kRawFrameData),
                                    base::size(kRawFrameData),
                                    /* owns_buffer = */ false);
   spdy::SpdySerializedFrame request_body(
@@ -10771,14 +10771,14 @@ TEST_F(SpdyNetworkTransactionTest, OnDataSentDoesNotCrashWithGreasedFrameType) {
       spdy_util_.ConstructSpdyHeaders(1, std::move(headers), DEFAULT_PRIORITY,
                                       /* fin = */ false));
 
-  const char kRawFrameData[] = {
+  uint8_t kRawFrameData[] = {
       0x00, 0x00, 0x03,        // length
       0x0b,                    // type
       0xcc,                    // flags
       0x00, 0x00, 0x00, 0x01,  // stream ID
       'f',  'o',  'o'          // payload
   };
-  spdy::SpdySerializedFrame grease(const_cast<char*>(kRawFrameData),
+  spdy::SpdySerializedFrame grease(reinterpret_cast<char*>(kRawFrameData),
                                    base::size(kRawFrameData),
                                    /* owns_buffer = */ false);
   spdy::SpdySerializedFrame empty_body(

net/spdy/spdy_session_unittest.cc

@@ -6033,14 +6033,14 @@ TEST_F(SpdySessionTest, GreaseFrameTypeAfterSettings) {
       CombineFrames({&preface, &settings_frame});
 
   // Greased frame sent on stream 0 after initial SETTINGS frame.
-  const char kRawFrameData[] = {
+  uint8_t kRawFrameData[] = {
       0x00, 0x00, 0x03,        // length
       0x0b,                    // type
       0xcc,                    // flags
       0x00, 0x00, 0x00, 0x00,  // stream ID
       'f',  'o',  'o'          // payload
   };
-  spdy::SpdySerializedFrame grease(const_cast<char*>(kRawFrameData),
+  spdy::SpdySerializedFrame grease(reinterpret_cast<char*>(kRawFrameData),
                                    base::size(kRawFrameData),
                                    /* owns_buffer = */ false);
 

net/url_request/http_with_dns_over_https_unittest.cc

@@ -135,8 +135,8 @@ class HttpWithDnsOverHttpsTest : public TestWithTaskEnvironment {
       char header_data[kHeaderSize];
       base::BigEndianWriter header_writer(header_data, kHeaderSize);
       header_writer.WriteU16(query.id());  // Same ID as before
-      char flags[] = {0x81, 0x80};
-      header_writer.WriteBytes(flags, 2);
+      uint8_t flags[] = {0x81, 0x80};
+      header_writer.WriteBytes(reinterpret_cast<char*>(flags), 2);
       header_writer.WriteU16(1);  // 1 question
       header_writer.WriteU16(1);  // 1 answer
       header_writer.WriteU16(0);  // No authority records

services/network/mdns_responder_unittest.cc

@@ -212,7 +212,7 @@ class MockFailingMdnsSocketFactory : public net::MDnsSocketFactory {
 // the NSEC records are placed in the Answer section with the address records in
 // the Answer section.
 TEST(CreateMdnsResponseTest, SingleARecordAnswer) {
-  const char response_data[]{
+  const uint8_t response_data[]{
       0x00, 0x00,  // mDNS response ID mus be zero.
       0x84, 0x00,  // flags, response with authoritative answer
       0x00, 0x00,  // number of questions
@@ -240,7 +240,8 @@ TEST(CreateMdnsResponseTest, SingleARecordAnswer) {
                                // length 1, bitmap with bit 1 set
   };
 
-  std::string expected_response(response_data, sizeof(response_data));
+  std::string expected_response(reinterpret_cast<const char*>(response_data),
+                                sizeof(response_data));
   std::string actual_response = CreateResolutionResponse(
       kDefaultTtl,
       {{"www.example.com", net::IPAddress(0xc0, 0xa8, 0x00, 0x01)}});
@@ -248,7 +249,7 @@ TEST(CreateMdnsResponseTest, SingleARecordAnswer) {
 }
 
 TEST(CreateMdnsResponseTest, SingleARecordGoodbye) {
-  const char response_data[]{
+  const uint8_t response_data[]{
       0x00, 0x00,  // mDNS response ID mus be zero.
       0x84, 0x00,  // flags, response with authoritative answer
       0x00, 0x00,  // number of questions
@@ -265,7 +266,8 @@ TEST(CreateMdnsResponseTest, SingleARecordGoodbye) {
       0xc0, 0xa8, 0x00, 0x01,  // 192.168.0.1
   };
 
-  std::string expected_response(response_data, sizeof(response_data));
+  std::string expected_response(reinterpret_cast<const char*>(response_data),
+                                sizeof(response_data));
   std::string actual_response = CreateResolutionResponse(
       base::TimeDelta(),
       {{"www.example.com", net::IPAddress(0xc0, 0xa8, 0x00, 0x01)}});
@@ -273,7 +275,7 @@ TEST(CreateMdnsResponseTest, SingleARecordGoodbye) {
 }
 
 TEST(CreateMdnsResponseTest, SingleQuadARecordAnswer) {
-  const char response_data[] = {
+  const uint8_t response_data[] = {
       0x00, 0x00,  // mDNS response ID mus be zero.
       0x84, 0x00,  // flags, response with authoritative answer
       0x00, 0x00,  // number of questions
@@ -300,7 +302,8 @@ TEST(CreateMdnsResponseTest, SingleQuadARecordAnswer) {
       0x08,  // type bit map of type AAAA: window block 0, bitmap
              // length 4, bitmap with bit 28 set
   };
-  std::string expected_response(response_data, sizeof(response_data));
+  std::string expected_response(reinterpret_cast<const char*>(response_data),
+                                sizeof(response_data));
   std::string actual_response = CreateResolutionResponse(
       kDefaultTtl,
       {{"example.org",
@@ -310,7 +313,7 @@ TEST(CreateMdnsResponseTest, SingleQuadARecordAnswer) {
 }
 
 TEST(CreateMdnsResponseTest, SingleNsecRecordAnswer) {
-  const char response_data[] = {
+  const uint8_t response_data[] = {
       0x00, 0x00,  // mDNS response ID mus be zero.
       0x84, 0x00,  // flags, response with authoritative answer
       0x00, 0x00,  // number of questions
@@ -337,7 +340,8 @@ TEST(CreateMdnsResponseTest, SingleNsecRecordAnswer) {
       0x00, 0x04,              // rdlength, 32 bits
       0xc0, 0xa8, 0x00, 0x01,  // 192.168.0.1
   };
-  std::string expected_response(response_data, sizeof(response_data));
+  std::string expected_response(reinterpret_cast<const char*>(response_data),
+                                sizeof(response_data));
   std::string actual_response = CreateNegativeResponse(
       {{"www.example.com", net::IPAddress(0xc0, 0xa8, 0x00, 0x01)}});
   EXPECT_EQ(expected_response, actual_response);
@@ -345,7 +349,7 @@ TEST(CreateMdnsResponseTest, SingleNsecRecordAnswer) {
 
 TEST(CreateMdnsResponseTest,
      SingleTxtRecordAnswerToMdnsNameGeneratorServiceQuery) {
-  const char response_data[] = {
+  const uint8_t response_data[] = {
       0x00, 0x00,  // mDNS response ID mus be zero.
       0x84, 0x00,  // flags, response with authoritative answer
       0x00, 0x00,  // number of questions
@@ -365,7 +369,8 @@ TEST(CreateMdnsResponseTest,
       'a',  'l',  0x15, 'n',  'a',  'm', 'e',  '1', '=', 'w', 'w', 'w',
       '.',  'e',  'x',  'a',  'm',  'p', 'l',  'e', '.', 'c', 'o', 'm',
       0x09, 't',  'x',  't',  'v',  'e', 'r',  's', '=', '1'};
-  std::string expected_response(response_data, sizeof(response_data));
+  std::string expected_response(reinterpret_cast<const char*>(response_data),
+                                sizeof(response_data));
   std::string actual_response = CreateResponseToMdnsNameGeneratorServiceQuery(
       kDefaultTtl, {"1.local", "www.example.com"});
   EXPECT_EQ(expected_response, actual_response);

third_party/blink/renderer/bindings/core/v8/serialization/v8_script_value_serializer_test.cc

@@ -1953,11 +1953,12 @@ TEST(V8ScriptValueSerializerTest, TransformStreamIntegerOverflow) {
   // The final 5 bytes is the offset of the two message ports inside the
   // transferred message port array. In order to trigger integer overflow this
   // is set to 0xffffffff, encoded as a varint.
-  char serialized_value[] = {0xff, 0x14, 0xff, 0x0d, 0x5c, 0x6d,
-                             0xff, 0xff, 0xff, 0xff, 0x0f};
+  uint8_t serialized_value[] = {0xff, 0x14, 0xff, 0x0d, 0x5c, 0x6d,
+                                0xff, 0xff, 0xff, 0xff, 0x0f};
 
-  auto corrupted_serialized_script_value =
-      SerializedScriptValue::Create(serialized_value, sizeof(serialized_value));
+  auto corrupted_serialized_script_value = SerializedScriptValue::Create(
+      reinterpret_cast<const char*>(serialized_value),
+      sizeof(serialized_value));
   corrupted_serialized_script_value->GetStreams() =
       std::move(serialized_script_value->GetStreams());
 

third_party/blink/renderer/core/document_transition/document_transition_origin_trial_test.cc

@@ -26,7 +26,7 @@
 namespace blink {
 namespace {
 
-constexpr char kOriginTrialPublicKey[] = {
+constexpr uint8_t kOriginTrialPublicKey[] = {
     0x75, 0x10, 0xac, 0xf9, 0x3a, 0x1c, 0xb8, 0xa9, 0x28, 0x70, 0xd2,
     0x9a, 0xd0, 0x0b, 0x59, 0xe1, 0xac, 0x2b, 0xb7, 0xd5, 0xca, 0x1f,
     0x64, 0x90, 0x08, 0x8e, 0xa8, 0xe0, 0x56, 0x3a, 0x04, 0xd0,
@@ -63,7 +63,8 @@ class ScopedOriginTrialPolicy : public OriginTrialPolicy {
   }
   bool IsOriginTrialsSupported() const override { return true; }
   std::vector<base::StringPiece> GetPublicKeys() const override {
-    return {{kOriginTrialPublicKey, base::size(kOriginTrialPublicKey)}};
+    return {{reinterpret_cast<const char*>(kOriginTrialPublicKey),
+             base::size(kOriginTrialPublicKey)}};
   }
   bool IsOriginSecure(const GURL& url) const override { return true; }
 };

third_party/blink/renderer/core/speculation_rules/speculation_rules_origin_trial_test.cc

@@ -24,7 +24,7 @@
 namespace blink {
 namespace {
 
-constexpr char kOriginTrialPublicKey[] = {
+constexpr uint8_t kOriginTrialPublicKey[] = {
     0x75, 0x10, 0xac, 0xf9, 0x3a, 0x1c, 0xb8, 0xa9, 0x28, 0x70, 0xd2,
     0x9a, 0xd0, 0x0b, 0x59, 0xe1, 0xac, 0x2b, 0xb7, 0xd5, 0xca, 0x1f,
     0x64, 0x90, 0x08, 0x8e, 0xa8, 0xe0, 0x56, 0x3a, 0x04, 0xd0,
@@ -69,7 +69,8 @@ class ScopedOriginTrialPolicy : public OriginTrialPolicy {
   }
   bool IsOriginTrialsSupported() const override { return true; }
   std::vector<base::StringPiece> GetPublicKeys() const override {
-    return {{kOriginTrialPublicKey, base::size(kOriginTrialPublicKey)}};
+    return {{reinterpret_cast<const char*>(kOriginTrialPublicKey),
+             base::size(kOriginTrialPublicKey)}};
   }
   bool IsOriginSecure(const GURL& url) const override { return true; }
 };

third_party/blink/renderer/modules/encoding/text_encoder_stream.cc

@@ -101,10 +101,7 @@ class TextEncoderStream::Transformer final : public TransformStreamTransformer {
   }
 
  private:
-  static std::string ReplacementCharacterInUtf8() {
-    constexpr char kRawBytes[] = {0xEF, 0xBF, 0xBD};
-    return std::string(kRawBytes, sizeof(kRawBytes));
-  }
+  static std::string ReplacementCharacterInUtf8() { return "\ufffd"; }
 
   static DOMUint8Array* CreateDOMUint8ArrayFromTwoStdStringsConcatenated(
       const std::string& string1,

third_party/blink/renderer/platform/fonts/opentype/variable_axes_names.cc

@@ -52,9 +52,9 @@ Vector<VariationAxis> VariableAxesNames::GetVariationAxes(
       axis.name = String(buffer.get());
     }
 
-    std::array<char, 4> tag = {HB_UNTAG(axes[i].tag)};
+    std::array<uint8_t, 4> tag = {HB_UNTAG(axes[i].tag)};
 
-    axis.tag = String(tag.data(), tag.size());
+    axis.tag = String(reinterpret_cast<const char*>(tag.data()), tag.size());
     axis.minValue = axes[i].min_value;
     axis.maxValue = axes[i].max_value;
     axis.defaultValue = axes[i].default_value;

third_party/blink/renderer/platform/image-decoders/image_decoder_test.cc

@@ -364,7 +364,7 @@ TEST(ImageDecoderTest, hasSufficientDataToSniffMimeTypeAvif) {
   // Chimera-AV1-10bit-1280x720-2380kbps-100.avif. Since the major_brand is
   // not "avif" or "avis", we must parse the compatible_brands to determine if
   // this is an AVIF image.
-  constexpr char kData[] = {
+  constexpr uint8_t kData[] = {
       // A File Type Box.
       0x00, 0x00, 0x00, 0x1c,  // unsigned int(32) size; 0x1c = 28
       'f', 't', 'y', 'p',      // unsigned int(32) type = boxtype;

third_party/blink/renderer/platform/wtf/shared_buffer.h

@@ -139,6 +139,11 @@ class WTF_EXPORT SharedBuffer : public RefCounted<SharedBuffer> {
     ALLOW_NUMERIC_ARG_TYPES_PROMOTABLE_TO(size_t);
     AppendInternal(data, size);
   }
+  HAS_STRICTLY_TYPED_ARG
+  void Append(const unsigned char* data, STRICTLY_TYPED_ARG(size)) {
+    ALLOW_NUMERIC_ARG_TYPES_PROMOTABLE_TO(size_t);
+    AppendInternal(reinterpret_cast<const char*>(data), size);
+  }
   void Append(const Vector<char>& data) { Append(data.data(), data.size()); }
 
   void Clear();

ui/base/resource/data_pack.cc

@@ -246,18 +246,17 @@ class DataPack::StringDataSource : public DataPack::DataSource {
 
 class DataPack::BufferDataSource : public DataPack::DataSource {
  public:
-  explicit BufferDataSource(base::StringPiece buffer) : buffer_(buffer) {}
+  explicit BufferDataSource(base::span<const uint8_t> buffer)
+      : buffer_(buffer) {}
 
   ~BufferDataSource() override {}
 
   // DataPack::DataSource:
-  size_t GetLength() const override { return buffer_.length(); }
-  const uint8_t* GetData() const override {
-    return reinterpret_cast<const uint8_t*>(buffer_.data());
-  }
+  size_t GetLength() const override { return buffer_.size(); }
+  const uint8_t* GetData() const override { return buffer_.data(); }
 
  private:
-  base::StringPiece buffer_;
+  base::span<const uint8_t> buffer_;
 
   DISALLOW_COPY_AND_ASSIGN(BufferDataSource);
 };
@@ -329,7 +328,7 @@ bool DataPack::LoadFromFileRegion(
   return LoadImpl(std::make_unique<MemoryMappedDataSource>(std::move(mmap)));
 }
 
-bool DataPack::LoadFromBuffer(base::StringPiece buffer) {
+bool DataPack::LoadFromBuffer(base::span<const uint8_t> buffer) {
   return LoadImpl(std::make_unique<BufferDataSource>(buffer));
 }
 

ui/base/resource/data_pack.h

@@ -54,7 +54,7 @@ class UI_DATA_PACK_EXPORT DataPack : public ResourceHandle {
 
   // Loads a pack file from |buffer|, returning false on error.
   // Data is not copied, |buffer| should stay alive during |DataPack| lifetime.
-  bool LoadFromBuffer(base::StringPiece buffer);
+  bool LoadFromBuffer(base::span<const uint8_t> buffer);
 
   // Writes a pack file containing |resources| to |path|. If there are any
   // text resources to be written, their encoding must already agree to the

ui/base/resource/data_pack_literal.cc

@@ -2,14 +2,12 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include <stddef.h>
-
 #include "ui/base/resource/data_pack_literal.h"
 #include "ui/base/resource/resource_bundle.h"
 
 namespace ui {
 
-const char kSamplePakContentsV4[] = {
+const uint8_t kSamplePakContentsV4[] = {
     0x04, 0x00, 0x00, 0x00,              // header(version
     0x04, 0x00, 0x00, 0x00,              //        no. entries
     0x01,                                //        encoding)
@@ -23,7 +21,7 @@ const char kSamplePakContentsV4[] = {
 
 const size_t kSamplePakSizeV4 = sizeof(kSamplePakContentsV4);
 
-const char kSampleCompressPakContentsV5[] = {
+const uint8_t kSampleCompressPakContentsV5[] = {
     0x05, 0x00, 0x00, 0x00,              // version
     0x01, 0x00, 0x00, 0x00,              // encoding + padding
     0x03, 0x00, 0x01, 0x00,              // num_resources, num_aliases
@@ -51,7 +49,7 @@ const char kSampleCompressPakContentsV5[] = {
 
 const size_t kSampleCompressPakSizeV5 = sizeof(kSampleCompressPakContentsV5);
 
-const char kSampleCompressScaledPakContents[] = {
+const uint8_t kSampleCompressScaledPakContents[] = {
     0x05, 0x00, 0x00, 0x00,              // version
     0x01, 0x00, 0x00, 0x00,              // encoding + padding
     0x03, 0x00, 0x01, 0x00,              // num_resources, num_aliases
@@ -76,7 +74,7 @@ const char kSampleCompressScaledPakContents[] = {
 const size_t kSampleCompressScaledPakSize =
     sizeof(kSampleCompressScaledPakContents);
 
-const char kSampleCorruptPakContents[] = {
+const uint8_t kSampleCorruptPakContents[] = {
     0x04, 0x00, 0x00, 0x00,              // header(version
     0x04, 0x00, 0x00, 0x00,              //        no. entries
     0x01,                                //        encoding)
@@ -91,7 +89,7 @@ const char kSampleCorruptPakContents[] = {
 
 const size_t kSampleCorruptPakSize = sizeof(kSampleCorruptPakContents);
 
-const char kSamplePakContents2x[] = {
+const uint8_t kSamplePakContents2x[] = {
     0x04, 0x00, 0x00, 0x00,              // header(version
     0x01, 0x00, 0x00, 0x00,              //        no. entries
     0x01,                                //        encoding)
@@ -102,7 +100,7 @@ const char kSamplePakContents2x[] = {
 
 const size_t kSamplePakSize2x = sizeof(kSamplePakContents2x);
 
-const char kEmptyPakContents[] = {
+const uint8_t kEmptyPakContents[] = {
     0x04, 0x00, 0x00, 0x00,             // header(version
     0x00, 0x00, 0x00, 0x00,             //        no. entries
     0x01,                               //        encoding)

ui/base/resource/data_pack_literal.h

@@ -5,19 +5,22 @@
 #ifndef UI_BASE_RESOURCE_DATA_PACK_LITERAL_H_
 #define UI_BASE_RESOURCE_DATA_PACK_LITERAL_H_
 
+#include <stddef.h>
+#include <stdint.h>
+
 namespace ui {
 
-extern const char kSamplePakContentsV4[];
+extern const uint8_t kSamplePakContentsV4[];
 extern const size_t kSamplePakSizeV4;
-extern const char kSampleCompressPakContentsV5[];
+extern const uint8_t kSampleCompressPakContentsV5[];
 extern const size_t kSampleCompressPakSizeV5;
-extern const char kSampleCompressScaledPakContents[];
+extern const uint8_t kSampleCompressScaledPakContents[];
 extern const size_t kSampleCompressScaledPakSize;
-extern const char kSamplePakContents2x[];
+extern const uint8_t kSamplePakContents2x[];
 extern const size_t kSamplePakSize2x;
-extern const char kEmptyPakContents[];
+extern const uint8_t kEmptyPakContents[];
 extern const size_t kEmptyPakSize;
-extern const char kSampleCorruptPakContents[];
+extern const uint8_t kSampleCorruptPakContents[];
 extern const size_t kSampleCorruptPakSize;
 
 }  // namespace ui

ui/base/resource/data_pack_unittest.cc

@@ -36,8 +36,8 @@ TEST(DataPackTest, LoadFromPath) {
       dir.GetPath().Append(FILE_PATH_LITERAL("sample.pak"));
 
   // Dump contents into the pak file.
-  ASSERT_TRUE(base::WriteFile(
-      data_path, base::StringPiece(kSamplePakContentsV4, kSamplePakSizeV4)));
+  ASSERT_TRUE(
+      base::WriteFile(data_path, {kSamplePakContentsV4, kSamplePakSizeV4}));
 
   // Load the file through the data pack API.
   DataPack pack(SCALE_FACTOR_100P);
@@ -71,7 +71,7 @@ TEST(DataPackTest, LoadFromPathCompressed) {
   // Dump contents into a compressed pak file.
   std::string compressed;
   ASSERT_TRUE(compression::GzipCompress(
-      base::StringPiece(kSamplePakContentsV4, kSamplePakSizeV4), &compressed));
+      {kSamplePakContentsV4, kSamplePakSizeV4}, &compressed));
   ASSERT_TRUE(base::WriteFile(data_path, compressed));
 
   // Load the file through the data pack API.
@@ -104,8 +104,8 @@ TEST(DataPackTest, LoadFromFile) {
       dir.GetPath().Append(FILE_PATH_LITERAL("sample.pak"));
 
   // Dump contents into the pak file.
-  ASSERT_TRUE(base::WriteFile(
-      data_path, base::StringPiece(kSamplePakContentsV4, kSamplePakSizeV4)));
+  ASSERT_TRUE(
+      base::WriteFile(data_path, {kSamplePakContentsV4, kSamplePakSizeV4}));
 
   base::File file(data_path, base::File::FLAG_OPEN | base::File::FLAG_READ);
   ASSERT_TRUE(file.IsValid());
@@ -143,8 +143,8 @@ TEST(DataPackTest, LoadFromFileRegion) {
   // by the actual pak file content.
   const uint8_t kPadding[5678] = {0};
   ASSERT_TRUE(base::WriteFile(data_path, kPadding));
-  ASSERT_TRUE(base::AppendToFile(
-      data_path, base::StringPiece(kSamplePakContentsV4, kSamplePakSizeV4)));
+  ASSERT_TRUE(
+      base::AppendToFile(data_path, {kSamplePakContentsV4, kSamplePakSizeV4}));
 
   base::File file(data_path, base::File::FLAG_OPEN | base::File::FLAG_READ);
   ASSERT_TRUE(file.IsValid());
@@ -176,8 +176,7 @@ TEST(DataPackTest, LoadFromFileRegion) {
 TEST(DataPackTest, LoadFromBufferV4) {
   DataPack pack(SCALE_FACTOR_100P);
 
-  ASSERT_TRUE(pack.LoadFromBuffer(
-      base::StringPiece(kSamplePakContentsV4, kSamplePakSizeV4)));
+  ASSERT_TRUE(pack.LoadFromBuffer({kSamplePakContentsV4, kSamplePakSizeV4}));
 
   base::StringPiece data;
   ASSERT_TRUE(pack.HasResource(4));
@@ -201,8 +200,8 @@ TEST(DataPackTest, LoadFromBufferV4) {
 TEST(DataPackTest, LoadFromBufferV5) {
   DataPack pack(SCALE_FACTOR_100P);
 
-  ASSERT_TRUE(pack.LoadFromBuffer(base::StringPiece(
-      kSampleCompressPakContentsV5, kSampleCompressPakSizeV5)));
+  ASSERT_TRUE(pack.LoadFromBuffer(
+      {kSampleCompressPakContentsV5, kSampleCompressPakSizeV5}));
 
   base::StringPiece data;
   ASSERT_TRUE(pack.HasResource(4));
@@ -342,8 +341,8 @@ TEST(DataPackTest, ModifiedWhileUsed) {
       dir.GetPath().Append(FILE_PATH_LITERAL("sample.pak"));
 
   // Dump contents into the pak file.
-  ASSERT_TRUE(base::WriteFile(
-      data_path, base::StringPiece(kSamplePakContentsV4, kSamplePakSizeV4)));
+  ASSERT_TRUE(
+      base::WriteFile(data_path, {kSamplePakContentsV4, kSamplePakSizeV4}));
 
   base::File file(data_path, base::File::FLAG_OPEN | base::File::FLAG_READ);
   ASSERT_TRUE(file.IsValid());
@@ -357,8 +356,7 @@ TEST(DataPackTest, ModifiedWhileUsed) {
   ASSERT_TRUE(pack.GetStringPiece(10, &data));
 
   ASSERT_TRUE(base::WriteFile(
-      data_path,
-      base::StringPiece(kSampleCorruptPakContents, kSampleCorruptPakSize)));
+      data_path, {kSampleCorruptPakContents, kSampleCorruptPakSize}));
 
   // Reading asset #10 should now fail as it extends past the end of the file.
   ASSERT_TRUE(pack.HasResource(10));

ui/base/resource/resource_bundle.cc

@@ -341,7 +341,7 @@ void ResourceBundle::AddDataPackFromFile(base::File file,
                             scale_factor);
 }
 
-void ResourceBundle::AddDataPackFromBuffer(base::StringPiece buffer,
+void ResourceBundle::AddDataPackFromBuffer(base::span<const uint8_t> buffer,
                                            ScaleFactor scale_factor) {
   std::unique_ptr<DataPack> data_pack(new DataPack(scale_factor));
   if (data_pack->LoadFromBuffer(buffer)) {

ui/base/resource/resource_bundle.h

@@ -218,7 +218,7 @@ class COMPONENT_EXPORT(UI_BASE) ResourceBundle {
                                  ScaleFactor scale_factor);
 
   // Same as above but using contents of the given buffer.
-  void AddDataPackFromBuffer(base::StringPiece buffer,
+  void AddDataPackFromBuffer(base::span<const uint8_t> buffer,
                              ScaleFactor scale_factor);
 
   // Same as AddDataPackFromPath but does not log an error if the pack fails to

ui/base/resource/resource_bundle_unittest.cc

@@ -259,9 +259,8 @@ TEST_F(ResourceBundleTest, IsGzipped) {
   base::FilePath data_path =
       temp_dir_.GetPath().Append(FILE_PATH_LITERAL("sample.pak"));
   // Dump contents into a pak file and load it.
-  ASSERT_TRUE(
-      base::WriteFile(data_path, base::StringPiece(kSampleCompressPakContentsV5,
-                                                   kSampleCompressPakSizeV5)));
+  ASSERT_TRUE(base::WriteFile(
+      data_path, {kSampleCompressPakContentsV5, kSampleCompressPakSizeV5}));
   ResourceBundle* resource_bundle = CreateResourceBundle(nullptr);
   resource_bundle->AddDataPackFromPath(data_path, SCALE_FACTOR_100P);
 
@@ -278,9 +277,8 @@ TEST_F(ResourceBundleTest, IsBrotli) {
   base::FilePath data_path =
       temp_dir_.GetPath().Append(FILE_PATH_LITERAL("sample.pak"));
   // Dump contents into a pak file and load it.
-  ASSERT_TRUE(
-      base::WriteFile(data_path, base::StringPiece(kSampleCompressPakContentsV5,
-                                                   kSampleCompressPakSizeV5)));
+  ASSERT_TRUE(base::WriteFile(
+      data_path, {kSampleCompressPakContentsV5, kSampleCompressPakSizeV5}));
   ResourceBundle* resource_bundle = CreateResourceBundle(nullptr);
   resource_bundle->AddDataPackFromPath(data_path, SCALE_FACTOR_100P);
 
@@ -378,8 +376,8 @@ class ResourceBundleImageTest : public ResourceBundleTest {
     // Write an empty data pak for locale data.
     const base::FilePath& locale_path = dir_path().Append(
         FILE_PATH_LITERAL("locale.pak"));
-    EXPECT_TRUE(base::WriteFile(
-        locale_path, base::StringPiece(kEmptyPakContents, kEmptyPakSize)));
+    EXPECT_TRUE(
+        base::WriteFile(locale_path, {kEmptyPakContents, kEmptyPakSize}));
 
     ui::ResourceBundle* resource_bundle = CreateResourceBundle(nullptr);
 
@@ -407,9 +405,8 @@ TEST_F(ResourceBundleImageTest, LoadDataResourceBytes) {
   base::FilePath data_path = dir_path().Append(FILE_PATH_LITERAL("sample.pak"));
 
   // Dump contents into the pak files.
-  ASSERT_TRUE(
-      base::WriteFile(data_path, base::StringPiece(kSampleCompressPakContentsV5,
-                                                   kSampleCompressPakSizeV5)));
+  ASSERT_TRUE(base::WriteFile(
+      data_path, {kSampleCompressPakContentsV5, kSampleCompressPakSizeV5}));
 
   // Load pak file.
   ResourceBundle* resource_bundle = CreateResourceBundleWithEmptyLocalePak();
@@ -440,8 +437,7 @@ TEST_F(ResourceBundleImageTest, LoadDataResourceBytesNotFound) {
   base::FilePath data_path = dir_path().Append(FILE_PATH_LITERAL("sample.pak"));
 
   // Dump contents into the pak files.
-  ASSERT_TRUE(base::WriteFile(
-      data_path, base::StringPiece(kEmptyPakContents, kEmptyPakSize)));
+  ASSERT_TRUE(base::WriteFile(data_path, {kEmptyPakContents, kEmptyPakSize}));
 
   // Create a resource bundle from the file.
   ResourceBundle* resource_bundle = CreateResourceBundleWithEmptyLocalePak();
@@ -465,12 +461,10 @@ TEST_F(ResourceBundleImageTest, LoadDataResourceStringForScale) {
       dir_path().Append(FILE_PATH_LITERAL("sample_2x.pak"));
 
   // Dump content into pak files.
-  ASSERT_TRUE(
-      base::WriteFile(data_path, base::StringPiece(kSampleCompressPakContentsV5,
-                                                   kSampleCompressPakSizeV5)));
   ASSERT_TRUE(base::WriteFile(
-      data_2x_path, base::StringPiece(kSampleCompressScaledPakContents,
-                                      kSampleCompressScaledPakSize)));
+      data_path, {kSampleCompressPakContentsV5, kSampleCompressPakSizeV5}));
+  ASSERT_TRUE(base::WriteFile(data_2x_path, {kSampleCompressScaledPakContents,
+                                             kSampleCompressScaledPakSize}));
 
   // Load pak files.
   ResourceBundle* resource_bundle = CreateResourceBundleWithEmptyLocalePak();
@@ -488,9 +482,8 @@ TEST_F(ResourceBundleImageTest, LoadDataResourceStringForScale) {
 TEST_F(ResourceBundleImageTest, LoadLocalizedResourceString) {
   base::FilePath data_path = dir_path().Append(FILE_PATH_LITERAL("sample.pak"));
   // Dump content into pak file.
-  ASSERT_TRUE(
-      base::WriteFile(data_path, base::StringPiece(kSampleCompressPakContentsV5,
-                                                   kSampleCompressPakSizeV5)));
+  ASSERT_TRUE(base::WriteFile(
+      data_path, {kSampleCompressPakContentsV5, kSampleCompressPakSizeV5}));
   // Load pak file.
   ResourceBundle* resource_bundle = CreateResourceBundleWithEmptyLocalePak();
   resource_bundle->AddDataPackFromPath(data_path, SCALE_FACTOR_NONE);
@@ -503,9 +496,8 @@ TEST_F(ResourceBundleImageTest, LoadLocalizedResourceString) {
 TEST_F(ResourceBundleImageTest, LoadDataResourceString) {
   base::FilePath data_path = dir_path().Append(FILE_PATH_LITERAL("sample.pak"));
   // Dump content into pak file.
-  ASSERT_TRUE(
-      base::WriteFile(data_path, base::StringPiece(kSampleCompressPakContentsV5,
-                                                   kSampleCompressPakSizeV5)));
+  ASSERT_TRUE(base::WriteFile(
+      data_path, {kSampleCompressPakContentsV5, kSampleCompressPakSizeV5}));
   // Load pak file.
   ResourceBundle* resource_bundle = CreateResourceBundleWithEmptyLocalePak();
   resource_bundle->AddDataPackFromPath(data_path, SCALE_FACTOR_NONE);
@@ -526,10 +518,10 @@ TEST_F(ResourceBundleImageTest, GetRawDataResource) {
       dir_path().Append(FILE_PATH_LITERAL("sample_2x.pak"));
 
   // Dump contents into the pak files.
-  ASSERT_TRUE(base::WriteFile(
-      data_path, base::StringPiece(kSamplePakContentsV4, kSamplePakSizeV4)));
-  ASSERT_TRUE(base::WriteFile(
-      data_2x_path, base::StringPiece(kSamplePakContents2x, kSamplePakSize2x)));
+  ASSERT_TRUE(
+      base::WriteFile(data_path, {kSamplePakContentsV4, kSamplePakSizeV4}));
+  ASSERT_TRUE(
+      base::WriteFile(data_2x_path, {kSamplePakContents2x, kSamplePakSize2x}));
 
   // Load the regular and 2x pak files.
   ResourceBundle* resource_bundle = CreateResourceBundleWithEmptyLocalePak();