Manuarlly remove more deprecated forms of base::Base64Encode()

This CL should remove the remaining instances, but stops short of
actually removing the deprecated form itself.

Bug: 1486214
Change-Id: Id27d692d7303de538f2c7fa1978800169615024b
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/5247305
Owners-Override: Daniel Cheng <dcheng@chromium.org>
Commit-Queue: Tom Sepez <tsepez@chromium.org>
Reviewed-by: Daniel Cheng <dcheng@chromium.org>
Cr-Commit-Position: refs/heads/main@{#1255101}

chrome/browser/ash/arc/enterprise/cert_store/arc_cert_installer_utils.cc

@@ -51,7 +51,7 @@ std::string ExportSpki(crypto::RSAPrivateKey* rsa) {
     LOG(ERROR) << "Key export has failed.";
     return "";
   }
-  return base::Base64Encode(std::string(spki.begin(), spki.end()));
+  return base::Base64Encode(spki);
 }
 
 }  // namespace arc

chrome/browser/bookmarks/bookmark_html_writer.cc

@@ -337,9 +337,8 @@ class Writer : public base::RefCountedThreadSafe<Writer> {
       std::string favicon_string;
       auto itr = favicons_map_->find(*url_string);
       if (itr != favicons_map_->end()) {
-        scoped_refptr<base::RefCountedMemory> data(itr->second.get());
-        std::string favicon_base64_encoded = base::Base64Encode(
-            base::StringPiece(data->front_as<char>(), data->size()));
+        scoped_refptr<base::RefCountedMemory> data = itr->second;
+        std::string favicon_base64_encoded = base::Base64Encode(*data);
         GURL favicon_url("data:image/png;base64," + favicon_base64_encoded);
         favicon_string = favicon_url.spec();
       }

chrome/browser/devtools/device/usb/android_rsa.cc

@@ -13,6 +13,7 @@
 #include <memory>
 
 #include "base/base64.h"
+#include "base/containers/span.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/pref_names.h"
 #include "components/sync_preferences/pref_service_syncable.h"
@@ -262,7 +263,8 @@ std::string AndroidRSAPublicKey(crypto::RSAPrivateKey* key) {
   BnFree(n);
   BnFree(r);
   BnFree(rr);
-  return base::Base64Encode(base::as_bytes(base::span(&pkey, 1u)));
+
+  return base::Base64Encode(base::byte_span_from_ref(pkey));
 }
 
 std::string AndroidRSASign(crypto::RSAPrivateKey* key,

chrome/browser/download/android/available_offline_content_provider.cc

@@ -174,8 +174,7 @@ class ThumbnailFetch {
     scoped_refptr<base::RefCountedMemory> data = image.As1xPNGBytes();
     if (!data || data->size() == 0)
       return GURL();
-    std::string png_base64 = base::Base64Encode(
-        base::StringPiece(data->front_as<char>(), data->size()));
+    std::string png_base64 = base::Base64Encode(*data);
     return GURL(base::StrCat({"data:image/png;base64,", png_base64}));
   }
 

chrome/browser/download/download_browsertest.cc

@@ -2718,13 +2718,13 @@ IN_PROC_BROWSER_TEST_F(DownloadTest, MAYBE_SaveLargeImage) {
   base::FilePath data_file = ui_test_utils::GetTestFilePath(
       base::FilePath().AppendASCII("downloads"),
       base::FilePath().AppendASCII("large_image.png"));
-  std::string png_data, data_url;
+  std::string png_data;
   {
     base::ScopedAllowBlockingForTesting allow_blocking;
     CHECK(base::ReadFileToString(data_file, &png_data));
   }
 
-  data_url = base::Base64Encode(png_data);
+  std::string data_url = base::Base64Encode(png_data);
   data_url.insert(0, "data:image/png;base64,");
 
   ASSERT_GE(data_url.size(), url::kMaxURLChars);

chrome/browser/extensions/convert_user_script.cc

@@ -84,10 +84,9 @@ scoped_refptr<Extension> ConvertUserScriptToExtension(
   // identity is its namespace+name, so we hash that to create a public key.
   // There will be no corresponding private key, which means user scripts cannot
   // be auto-updated, or claimed in the gallery.
-  char raw[crypto::kSHA256Length] = {0};
+  uint8_t raw[crypto::kSHA256Length] = {0};
   crypto::SHA256HashString(script_name, raw, crypto::kSHA256Length);
-  std::string key =
-      base::Base64Encode(base::StringPiece(raw, crypto::kSHA256Length));
+  std::string key = base::Base64Encode(raw);
 
   // The script may not have a name field, but we need one for an extension. If
   // it is missing, use the filename of the original URL.

chrome/browser/serial/serial_chooser_context.cc

@@ -53,8 +53,7 @@ constexpr char kUsbDriverKey[] = "usb_driver";
 std::string EncodeToken(const base::UnguessableToken& token) {
   const uint64_t data[2] = {token.GetHighForSerialization(),
                             token.GetLowForSerialization()};
-  return base::Base64Encode(
-      base::StringPiece(reinterpret_cast<const char*>(&data[0]), sizeof(data)));
+  return base::Base64Encode(base::as_byte_span(data));
 }
 
 base::UnguessableToken DecodeToken(base::StringPiece input) {

chrome/browser/sharing/sharing_sync_preference.cc

@@ -128,9 +128,7 @@ std::optional<std::vector<uint8_t>> SharingSyncPreference::GetVapidKey() const {
 void SharingSyncPreference::SetVapidKey(
     const std::vector<uint8_t>& vapid_key) const {
   base::Time creation_timestamp = base::Time::Now();
-  std::string base64_vapid_key =
-      base::Base64Encode(std::string(vapid_key.begin(), vapid_key.end()));
-
+  std::string base64_vapid_key = base::Base64Encode(vapid_key);
   ScopedDictPrefUpdate update(prefs_, prefs::kSharingVapidKey);
   update->Set(kVapidECPrivateKey, base64_vapid_key);
   update->Set(kVapidCreationTimestamp, base::TimeToValue(creation_timestamp));

chrome/browser/ssl/ssl_browsertest.cc

@@ -806,9 +806,7 @@ class SSLUITestIgnoreCertErrors : public SSLUITest {
 };
 
 static std::string MakeCertSPKIFingerprint(net::X509Certificate* cert) {
-  net::HashValue hash = GetSPKIHash(cert->cert_buffer());
-  return base::Base64Encode(base::StringPiece(
-      reinterpret_cast<const char*>(hash.data()), hash.size()));
+  return base::Base64Encode(GetSPKIHash(cert->cert_buffer()));
 }
 
 class SSLUITestIgnoreCertErrorsBySPKIHTTPS : public SSLUITest {

chrome/browser/support_tool/screenshot_data_collector.cc

@@ -264,9 +264,8 @@ void ScreenshotDataCollector::OnScreenshotTaken(
     scoped_refptr<base::RefCountedMemory> data) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   if (data && data.get()) {
-    screenshot_base64_ = base::StrCat(
-        {kBase64Header,
-         base::Base64Encode(base::make_span(data->data(), data->size()))});
+    screenshot_base64_ =
+        base::StrCat({kBase64Header, base::Base64Encode(*data)});
     std::move(data_collector_done_callback_).Run(/*error=*/std::nullopt);
     return;
   }

chrome/browser/ui/autofill/risk_util.cc

@@ -44,7 +44,7 @@ namespace {
 
 void PassRiskData(base::OnceCallback<void(const std::string&)> callback,
                   std::unique_ptr<risk::Fingerprint> fingerprint) {
-  std::string proto_data, risk_data;
+  std::string proto_data;
   fingerprint->SerializeToString(&proto_data);
   std::move(callback).Run(base::Base64Encode(proto_data));
 }

chrome/browser/ui/webui/discards/graph_dump_impl.cc

@@ -570,10 +570,7 @@ void DiscardsGraphDumpImpl::SendFaviconNotification(
   discards::mojom::FavIconInfoPtr icon_info =
       discards::mojom::FavIconInfo::New();
   icon_info->node_id = serialization_id;
-
-  icon_info->icon_data = base::Base64Encode(
-      base::StringPiece(reinterpret_cast<const char*>(bitmap_data->front()),
-                        bitmap_data->size()));
+  icon_info->icon_data = base::Base64Encode(*bitmap_data);
 
   change_subscriber_->FavIconDataAvailable(std::move(icon_info));
 }

chrome/browser/ui/webui/omnibox/omnibox_page_handler.cc

@@ -435,8 +435,7 @@ void OmniboxPageHandler::OnBitmapFetched(mojom::AutocompleteControllerType type,
                                          const std::string& image_url,
                                          const SkBitmap& bitmap) {
   auto data = gfx::Image::CreateFrom1xBitmap(bitmap).As1xPNGBytes();
-  std::string base_64 = base::Base64Encode(
-      base::StringPiece(data->front_as<char>(), data->size()));
+  std::string base_64 = base::Base64Encode(*data);
   const char kDataUrlPrefix[] = "data:image/png;base64,";
   std::string data_url = GURL(kDataUrlPrefix + base_64).spec();
   page_->HandleAnswerImageData(type, image_url, data_url);

chrome/browser/web_applications/web_app_utils.cc

@@ -88,8 +88,7 @@ bool g_skip_main_profile_check_for_testing = false;
 GURL EncodeIconAsUrl(const SkBitmap& bitmap) {
   std::vector<unsigned char> output;
   gfx::PNGCodec::EncodeBGRASkBitmap(bitmap, false, &output);
-  std::string encoded = base::Base64Encode(base::StringPiece(
-      reinterpret_cast<const char*>(output.data()), output.size()));
+  std::string encoded = base::Base64Encode(output);
   return GURL("data:image/png;base64," + encoded);
 }
 

chromeos/ash/components/login/auth/public/key.cc

@@ -86,11 +86,11 @@ void Key::Transform(KeyType target_key_type, const std::string& salt) {
           crypto::SymmetricKey::DeriveKeyFromPasswordUsingPbkdf2(
               crypto::SymmetricKey::AES, secret_, salt, kNumIterations,
               kKeySizeInBits));
-      base::Base64Encode(key->key(), &secret_);
+      secret_ = base::Base64Encode(key->key());
       break;
     }
     case KEY_TYPE_SALTED_SHA256:
-      base::Base64Encode(crypto::SHA256HashString(salt + secret_), &secret_);
+      secret_ = base::Base64Encode(crypto::SHA256HashString(salt + secret_));
       break;
 
     default:

components/autofill/core/browser/payments/credit_card_access_manager_unittest.cc

@@ -86,8 +86,8 @@ constexpr char kTestChallenge[] = "VGhpcyBpcyBhIHRlc3QgY2hhbGxlbmdl";
 constexpr char kCredentialId[] = "VGhpcyBpcyBhIHRlc3QgQ3JlZGVudGlhbCBJRC4=";
 constexpr char kGooglePaymentsRpid[] = "google.com";
 
-std::string BytesToBase64(const std::vector<uint8_t> bytes) {
-  return base::Base64Encode(std::string(bytes.begin(), bytes.end()));
+std::string BytesToBase64(const std::vector<uint8_t>& bytes) {
+  return base::Base64Encode(bytes);
 }
 #endif
 

components/crx_file/crx_creator_unittest.cc

@@ -41,8 +41,7 @@ TEST_F(CrxCreatorTest, Create) {
   auto signing_key = crypto::RSAPrivateKey::Create(4096);
   std::vector<uint8_t> public_key;
   signing_key->ExportPublicKey(&public_key);
-  const std::string expected_public_key =
-      base::Base64Encode(std::string(public_key.begin(), public_key.end()));
+  const std::string expected_public_key = base::Base64Encode(public_key);
 
   // Create a CRX File.
   base::FilePath temp_file;
@@ -69,8 +68,7 @@ TEST_F(CrxCreatorTest, VerifyCrxWithVerifiedContents) {
   auto signing_key = crypto::RSAPrivateKey::Create(4096);
   std::vector<uint8_t> public_key;
   signing_key->ExportPublicKey(&public_key);
-  const std::string expected_public_key =
-      base::Base64Encode(std::string(public_key.begin(), public_key.end()));
+  const std::string expected_public_key = base::Base64Encode(public_key);
 
   // Create a CRX File.
   base::FilePath temp_file;

components/crx_file/crx_verifier.cc

@@ -220,7 +220,7 @@ VerifierResult VerifyCrx3(
   if (!ReadHashAndVerifyArchive(file, hash, verifiers))
     return VerifierResult::ERROR_SIGNATURE_VERIFICATION_FAILED;
 
-  base::Base64Encode(public_key_bytes, public_key);
+  *public_key = base::Base64Encode(public_key_bytes);
   *crx_id = declared_crx_id;
   return VerifierResult::OK_FULL;
 }

components/device_signals/core/system_signals/mac/mac_platform_delegate_unittest.mm

@@ -108,8 +108,7 @@ TEST_F(MacPlatformDelegateTest, GetSigningCertificatesPublicKeys_Success) {
   EXPECT_FALSE(public_keys->is_os_verified);
   EXPECT_FALSE(public_keys->subject_name);
 
-  std::string base64_hash;
-  base::Base64Encode(public_keys.value().hashes[0], &base64_hash);
+  std::string base64_hash = base::Base64Encode(public_keys.value().hashes[0]);
   EXPECT_EQ(base64_hash, "E7ahL43DGT2VrGvGpnlI9ONkEqdni9ddf4fCTN26uFc=");
 
   // Should work for the binary path too.

components/gcm_driver/instance_id/instance_id_impl.cc

@@ -244,9 +244,7 @@ void InstanceIDImpl::EnsureIDGenerated() {
   // 3) Encode the value in Android-compatible base64 scheme:
   //    * URL safe: '/' replaced by '_' and '+' replaced by '-'.
   //    * No padding: any trailing '=' will be removed.
-  base::Base64Encode(
-      base::StringPiece(reinterpret_cast<const char*>(bytes), sizeof(bytes)),
-      &id_);
+  id_ = base::Base64Encode(bytes);
   std::replace(id_.begin(), id_.end(), '+', '-');
   std::replace(id_.begin(), id_.end(), '/', '_');
   std::erase(id_, '=');

components/metrics/net/net_metrics_log_uploader.cc

@@ -240,12 +240,10 @@ net::NetworkTrafficAnnotationTag GetNetworkTrafficAnnotation(
 
 std::string SerializeReportingInfo(
     const metrics::ReportingInfo& reporting_info) {
-  std::string result;
   std::string bytes;
   bool success = reporting_info.SerializeToString(&bytes);
   DCHECK(success);
-  base::Base64Encode(bytes, &result);
-  return result;
+  return base::Base64Encode(bytes);
 }
 
 // Encrypts a |plaintext| string, using the encrypted_messages component,
@@ -276,7 +274,7 @@ bool EncryptAndBase64EncodeString(const std::string& plaintext,
     return false;
   }
 
-  base::Base64Encode(encrypted_text, encoded);
+  *encoded = base::Base64Encode(encrypted_text);
   return true;
 }
 

components/offline_pages/core/model/offline_page_test_utils.cc

@@ -94,9 +94,8 @@ std::ostream& operator<<(std::ostream& out, const OfflinePageItem& item) {
 }
 
 std::string OfflinePageVisuals::ToString() const {
-  std::string thumb_data_base64, favicon_data_base64;
-  base::Base64Encode(thumbnail, &thumb_data_base64);
-  base::Base64Encode(favicon, &favicon_data_base64);
+  std::string thumb_data_base64 = base::Base64Encode(thumbnail);
+  std::string favicon_data_base64 = base::Base64Encode(favicon);
 
   std::string s("OfflinePageVisuals(id=");
   s.append(base::NumberToString(offline_id)).append(", expiration=");

components/optimization_guide/core/hints_manager_unittest.cc

@@ -558,7 +558,7 @@ TEST_F(HintsManagerTest, ProcessHintsWithValidCommandLineOverride) {
 
   std::string encoded_config;
   config.SerializeToString(&encoded_config);
-  base::Base64Encode(encoded_config, &encoded_config);
+  encoded_config = base::Base64Encode(encoded_config);
 
   base::CommandLine::ForCurrentProcess()->AppendSwitchASCII(
       switches::kHintsProtoOverride, encoded_config);
@@ -630,7 +630,7 @@ TEST_F(HintsManagerTest,
 
   std::string encoded_config;
   config.SerializeToString(&encoded_config);
-  base::Base64Encode(encoded_config, &encoded_config);
+  encoded_config = base::Base64Encode(encoded_config);
 
   {
     base::HistogramTester histogram_tester;
@@ -2161,7 +2161,7 @@ TEST_F(HintsManagerFetchingTest,
   opt->set_optimization_type(proto::DEFER_ALL_SCRIPT);
   std::string encoded_config;
   config.SerializeToString(&encoded_config);
-  base::Base64Encode(encoded_config, &encoded_config);
+  encoded_config = base::Base64Encode(encoded_config);
   base::CommandLine::ForCurrentProcess()->AppendSwitchASCII(
       switches::kHintsProtoOverride, encoded_config);
 

components/optimization_guide/core/model_util_unittest.cc

@@ -98,7 +98,7 @@ TEST(ModelUtilTest,
   metadata.set_type_url("sometypeurl");
   std::string encoded_metadata;
   metadata.SerializeToString(&encoded_metadata);
-  base::Base64Encode(encoded_metadata, &encoded_metadata);
+  encoded_metadata = base::Base64Encode(encoded_metadata);
 
   base::CommandLine::ForCurrentProcess()->AppendSwitchASCII(
       switches::kModelOverride,
@@ -118,7 +118,7 @@ TEST(ModelUtilTest, GetModelOverrideForOptimizationTargetOneFilePath) {
   metadata.set_type_url("sometypeurl");
   std::string encoded_metadata;
   metadata.SerializeToString(&encoded_metadata);
-  base::Base64Encode(encoded_metadata, &encoded_metadata);
+  encoded_metadata = base::Base64Encode(encoded_metadata);
 #if BUILDFLAG(IS_WIN)
   base::CommandLine::ForCurrentProcess()->AppendSwitchASCII(
       switches::kModelOverride,
@@ -146,7 +146,7 @@ TEST(ModelUtilTest, GetModelOverrideForOptimizationTargetMultipleFilePath) {
   metadata.set_type_url("sometypeurl");
   std::string encoded_metadata;
   metadata.SerializeToString(&encoded_metadata);
-  base::Base64Encode(encoded_metadata, &encoded_metadata);
+  encoded_metadata = base::Base64Encode(encoded_metadata);
 #if BUILDFLAG(IS_WIN)
   base::CommandLine::ForCurrentProcess()->AppendSwitchASCII(
       switches::kModelOverride,

components/optimization_guide/core/optimization_guide_switches_unittest.cc

@@ -59,7 +59,7 @@ TEST(OptimizationGuideSwitchesTest, ParseComponentConfigFromCommandLine) {
 
   std::string encoded_config;
   config.SerializeToString(&encoded_config);
-  base::Base64Encode(encoded_config, &encoded_config);
+  encoded_config = base::Base64Encode(encoded_config);
 
   base::CommandLine::ForCurrentProcess()->AppendSwitchASCII(kHintsProtoOverride,
                                                             encoded_config);
@@ -96,7 +96,7 @@ TEST(OptimizationGuideSwitchesTest,
   host_info.set_host("whatever.com");
   std::string encoded_proto;
   host_info.SerializeToString(&encoded_proto);
-  base::Base64Encode(encoded_proto, &encoded_proto);
+  encoded_proto = base::Base64Encode(encoded_proto);
 
   base::CommandLine::ForCurrentProcess()->AppendSwitchASCII(kHintsProtoOverride,
                                                             encoded_proto);

components/optimization_guide/core/optimization_guide_test_util.cc

@@ -37,8 +37,7 @@ std::string CreateHintsConfig(
 
   std::string encoded_config;
   config.SerializeToString(&encoded_config);
-  base::Base64Encode(encoded_config, &encoded_config);
-  return encoded_config;
+  return base::Base64Encode(encoded_config);
 }
 
 }  // namespace optimization_guide

components/optimization_guide/core/prediction_manager_unittest.cc

@@ -839,7 +839,7 @@ TEST_F(PredictionManagerTest,
       "google.internal.chrome.optimizationguide.v1.PageEntitiesModelMetadata");
   std::string encoded_metadata;
   metadata.SerializeToString(&encoded_metadata);
-  base::Base64Encode(encoded_metadata, &encoded_metadata);
+  encoded_metadata = base::Base64Encode(encoded_metadata);
   base::CommandLine::ForCurrentProcess()->AppendSwitchASCII(
       switches::kModelOverride,
       base::StringPrintf("OPTIMIZATION_TARGET_PAINFUL_PAGE_LOAD:%s:%s",

components/optimization_guide/core/test_hints_component_creator.cc

@@ -24,8 +24,7 @@ std::string GetDefaultHintVersionString() {
       optimization_guide::proto::HINT_SOURCE_OPTIMIZATION_HINTS_COMPONENT);
   std::string hint_version_string;
   hint_version.SerializeToString(&hint_version_string);
-  base::Base64Encode(hint_version_string, &hint_version_string);
-  return hint_version_string;
+  return base::Base64Encode(hint_version_string);
 }
 
 }  // namespace

components/password_manager/core/browser/sharing/fake_recipients_fetcher.cc

@@ -27,7 +27,7 @@ void FakeRecipientsFetcher::FetchFamilyMembers(
       recipient.user_id = num_str;
       recipient.user_name = "user" + num_str;
       recipient.email = "user" + num_str + "@gmail.com";
-      base::Base64Encode("123456789" + num_str, &recipient.public_key.key);
+      recipient.public_key.key = base::Base64Encode("123456789" + num_str);
       recipient.public_key.key_version = 0;
       recipients.push_back(recipient);
     }

components/password_manager/core/browser/sharing/recipient_info.cc

@@ -26,7 +26,7 @@ sync_pb::CrossUserSharingPublicKey PublicKey::ToProto() const {
 PublicKey PublicKey::FromProto(
     const sync_pb::CrossUserSharingPublicKey& proto_public_key) {
   PublicKey result;
-  base::Base64Encode(proto_public_key.x25519_public_key(), &result.key);
+  result.key = base::Base64Encode(proto_public_key.x25519_public_key());
   result.key_version = proto_public_key.version();
   return result;
 }

components/payments/content/service_worker_payment_app_finder.cc

@@ -347,13 +347,10 @@ class SelfDeletingServiceWorkerPaymentAppFinder
     number_of_app_icons_to_update_++;
 
     DCHECK(!icon->empty());
-    std::string string_encoded_icon;
     gfx::Image decoded_image = gfx::Image::CreateFrom1xBitmap(*(icon));
     scoped_refptr<base::RefCountedMemory> raw_data =
         decoded_image.As1xPNGBytes();
-    base::Base64Encode(
-        base::StringPiece(raw_data->front_as<char>(), raw_data->size()),
-        &string_encoded_icon);
+    std::string string_encoded_icon = base::Base64Encode(*raw_data);
 
     content::PaymentAppProvider::GetOrCreateForWebContents(owner_)
         ->UpdatePaymentAppIcon(

components/policy/core/common/cloud/cloud_policy_core_unittest.cc

@@ -217,9 +217,8 @@ TEST_F(CloudPolicyCoreTest, RefreshSoon) {
 }
 
 TEST_F(CloudPolicyCoreTest, DmProtocolBase64Constants) {
-  std::string encoded;
-  base::Base64Encode(dm_protocol::kChromeMachineLevelUserCloudPolicyType,
-                     &encoded);
+  std::string encoded =
+      base::Base64Encode(dm_protocol::kChromeMachineLevelUserCloudPolicyType);
   EXPECT_EQ(encoded, dm_protocol::kChromeMachineLevelUserCloudPolicyTypeBase64);
 }
 

components/power_bookmarks/core/power_bookmark_utils.cc

@@ -227,7 +227,7 @@ void GetBookmarksMatchingProperties(
 void EncodeMetaForStorage(const PowerBookmarkMeta& meta, std::string* out) {
   std::string data;
   meta.SerializeToString(&data);
-  base::Base64Encode(data, out);
+  *out = base::Base64Encode(data);
 }
 
 bool DecodeMetaFromStorage(const std::string& data, PowerBookmarkMeta* out) {

components/safe_browsing/content/browser/web_ui/safe_browsing_ui.cc

@@ -2580,9 +2580,8 @@ std::string SerializeContentAnalysisRequest(
     request_data.Set("filename", request.request_data().filename());
     request_data.Set("digest", request.request_data().digest());
     if (request.request_data().has_csd()) {
-      std::string csd_base64;
-      base::Base64Encode(request.request_data().csd().SerializeAsString(),
-                         &csd_base64);
+      std::string csd_base64 =
+          base::Base64Encode(request.request_data().csd().SerializeAsString());
       request_data.Set("csd", csd_base64);
     }
     request_data.Set("content_type", request.request_data().content_type());

components/safe_browsing/core/browser/db/v4_get_hash_protocol_manager_unittest.cc

@@ -384,9 +384,9 @@ TEST_F(V4GetHashProtocolManagerTest, TestGetHashRequest) {
   }
 
   // Serialize and Base64 encode.
-  std::string req_data, req_base64;
+  std::string req_data;
   req.SerializeToString(&req_data);
-  base::Base64Encode(req_data, &req_base64);
+  std::string req_base64 = base::Base64Encode(req_data);
 
   std::vector<HashPrefixStr> prefixes_to_request = {one, two};
   EXPECT_EQ(req_base64, pm->GetHashRequest(prefixes_to_request, client_states));

components/safe_browsing/core/browser/db/v4_store.cc

@@ -832,10 +832,10 @@ ApplyUpdateResult V4Store::MergeUpdate(const HashPrefixMap& old_prefixes_map,
     for (size_t i = 0; i < crypto::kSHA256Length; i++) {
       if (checksum[i] != expected_checksum[i]) {
 #if DCHECK_IS_ON()
-        std::string checksum_b64, expected_checksum_b64;
-        base::Base64Encode(base::StringPiece(checksum, std::size(checksum)),
-                           &checksum_b64);
-        base::Base64Encode(expected_checksum, &expected_checksum_b64);
+        std::string checksum_b64 =
+            base::Base64Encode(base::as_byte_span(checksum));
+        std::string expected_checksum_b64 =
+            base::Base64Encode(expected_checksum);
         DVLOG(1) << "Failure: Checksum mismatch: calculated: " << checksum_b64
                  << "; expected: " << expected_checksum_b64
                  << "; store: " << *this;
@@ -1039,10 +1039,10 @@ bool V4Store::VerifyChecksum() {
       RecordApplyUpdateResult(kReadFromDisk, CHECKSUM_MISMATCH_FAILURE,
                               store_path_);
 #if DCHECK_IS_ON()
-      std::string checksum_b64, expected_checksum_b64;
-      base::Base64Encode(base::StringPiece(checksum, std::size(checksum)),
-                         &checksum_b64);
-      base::Base64Encode(expected_checksum_, &expected_checksum_b64);
+      std::string checksum_b64 =
+          base::Base64Encode(base::as_byte_span(checksum));
+      std::string expected_checksum_b64 =
+          base::Base64Encode(expected_checksum_);
       DVLOG(1) << "Failure: Checksum mismatch: calculated: " << checksum_b64
                << "; expected: " << expected_checksum_b64
                << "; store: " << *this;

components/safe_browsing/core/browser/verdict_cache_manager.cc

@@ -112,7 +112,7 @@ base::Value::Dict CreateDictionaryFromVerdict(const T& verdict,
              static_cast<int>(receive_time.InSecondsFSinceUnixEpoch()));
   std::string serialized_proto(verdict.SerializeAsString());
   // Performs a base64 encoding on the serialized proto.
-  base::Base64Encode(serialized_proto, &serialized_proto);
+  serialized_proto = base::Base64Encode(serialized_proto);
   result.Set(proto_name, serialized_proto);
   return result;
 }

components/safe_browsing/core/browser/verdict_cache_manager_unittest.cc

@@ -271,7 +271,7 @@ TEST_F(VerdictCacheManagerTest, TestParseInvalidVerdictEntry) {
 
   std::string verdict_serialized;
   verdict.SerializeToString(&verdict_serialized);
-  base::Base64Encode(verdict_serialized, &verdict_serialized);
+  verdict_serialized = base::Base64Encode(verdict_serialized);
 
   base::Value::Dict verdict_entry;
   verdict_entry.Set("cache_creation_time", "invalid_time");
@@ -537,7 +537,7 @@ TEST_F(VerdictCacheManagerTest, TestCleanUpExpiredVerdictWithInvalidEntry) {
 
   std::string verdict_serialized;
   verdict.SerializeToString(&verdict_serialized);
-  base::Base64Encode(verdict_serialized, &verdict_serialized);
+  verdict_serialized = base::Base64Encode(verdict_serialized);
 
   base::Value::Dict verdict_entry;
   verdict_entry.Set("cache_creation_time", "invalid_time");

components/search_engines/template_url.cc

@@ -1348,9 +1348,8 @@ std::string TemplateURLRef::HandleReplacements(
         break;
 
       case GOOGLE_IMAGE_THUMBNAIL_BASE64: {
-        std::string base64_thumbnail_content;
-        base::Base64Encode(search_terms_args.image_thumbnail_content,
-                           &base64_thumbnail_content);
+        std::string base64_thumbnail_content =
+            base::Base64Encode(search_terms_args.image_thumbnail_content);
         HandleReplacement(std::string(), base64_thumbnail_content, replacement,
                           &url);
         if (replacement.is_post_param) {

components/search_engines/template_url_unittest.cc

@@ -273,9 +273,8 @@ TEST_F(TemplateURLTest, URLRefTestImageURLWithPOST) {
                               "image/jpeg");
             break;
           case TemplateURLRef::GOOGLE_IMAGE_THUMBNAIL_BASE64: {
-            std::string base64_image_content;
-            base::Base64Encode(search_args.image_thumbnail_content,
-                               &base64_image_content);
+            std::string base64_image_content =
+                base::Base64Encode(search_args.image_thumbnail_content);
             ExpectPostParamIs(*i, "base64_image_content", base64_image_content,
                               "image/jpeg");
             break;
@@ -322,9 +321,8 @@ TEST_F(TemplateURLTest, ImageThumbnailContentTypePostParams) {
       url.image_url_ref().post_params_;
   ExpectContainsPostParam(post_params, "image_content",
                           search_args.image_thumbnail_content, "image/tiff");
-  std::string base64_image_content;
-  base::Base64Encode(search_args.image_thumbnail_content,
-                     &base64_image_content);
+  std::string base64_image_content =
+      base::Base64Encode(search_args.image_thumbnail_content);
   ExpectContainsPostParam(post_params, "base64_image_content",
                           base64_image_content, "image/tiff");
 }

components/security_interstitials/content/stateful_ssl_host_state_delegate.cc

@@ -167,11 +167,7 @@ std::string GetKey(const net::X509Certificate& cert, int error) {
   // Since a security decision will be made based on the fingerprint, Chrome
   // should use the SHA-256 fingerprint for the certificate.
   net::SHA256HashValue fingerprint = cert.CalculateChainFingerprint256();
-  std::string base64_fingerprint;
-  base::Base64Encode(
-      base::StringPiece(reinterpret_cast<const char*>(fingerprint.data),
-                        sizeof(fingerprint.data)),
-      &base64_fingerprint);
+  std::string base64_fingerprint = base::Base64Encode(fingerprint.data);
   return base::NumberToString(error) + base64_fingerprint;
 }
 

components/sync/base/progress_marker_map.cc

@@ -18,7 +18,7 @@ base::Value::Dict ProgressMarkerMapToValueDict(
     std::string printable_payload;
     base::EscapeJSONString(progress_marker, false /* put_in_quotes */,
                            &printable_payload);
-    base::Base64Encode(printable_payload, &printable_payload);
+    printable_payload = base::Base64Encode(printable_payload);
     value.Set(ModelTypeToDebugString(model_type), printable_payload);
   }
   return value;

components/sync/engine/commit_contribution_impl_unittest.cc

@@ -82,8 +82,8 @@ TEST(CommitContributionImplTest, PopulateCommitProtoDefault) {
   CommitRequestData request_data;
   request_data.sequence_number = 2;
   request_data.base_version = kBaseVersion;
-  base::Base64Encode(base::SHA1HashString(data->specifics.SerializeAsString()),
-                     &request_data.specifics_hash);
+  request_data.specifics_hash = base::Base64Encode(
+      base::SHA1HashString(data->specifics.SerializeAsString()));
   request_data.entity = std::move(data);
 
   SyncEntity entity;
@@ -123,8 +123,8 @@ TEST(CommitContributionImplTest, PopulateCommitProtoTombstone) {
   CommitRequestData request_data;
   request_data.sequence_number = 2;
   request_data.base_version = kBaseVersion;
-  base::Base64Encode(base::SHA1HashString(data->specifics.SerializeAsString()),
-                     &request_data.specifics_hash);
+  request_data.specifics_hash = base::Base64Encode(
+      base::SHA1HashString(data->specifics.SerializeAsString()));
   request_data.entity = std::move(data);
 
   SyncEntity entity;
@@ -172,8 +172,8 @@ TEST(CommitContributionImplTest, PopulateCommitProtoBookmark) {
   CommitRequestData request_data;
   request_data.sequence_number = 2;
   request_data.base_version = kBaseVersion;
-  base::Base64Encode(base::SHA1HashString(data->specifics.SerializeAsString()),
-                     &request_data.specifics_hash);
+  request_data.specifics_hash = base::Base64Encode(
+      base::SHA1HashString(data->specifics.SerializeAsString()));
   request_data.deprecated_bookmark_folder = false;
   request_data.deprecated_bookmark_unique_position =
       UniquePosition::FromProto(data->specifics.bookmark().unique_position());
@@ -217,8 +217,8 @@ TEST(CommitContributionImplTest, PopulateCommitProtoBookmarkFolder) {
   CommitRequestData request_data;
   request_data.sequence_number = 2;
   request_data.base_version = kBaseVersion;
-  base::Base64Encode(base::SHA1HashString(data->specifics.SerializeAsString()),
-                     &request_data.specifics_hash);
+  request_data.specifics_hash = base::Base64Encode(
+      base::SHA1HashString(data->specifics.SerializeAsString()));
   request_data.deprecated_bookmark_folder = true;
   request_data.deprecated_bookmark_unique_position =
       UniquePosition::FromProto(data->specifics.bookmark().unique_position());

components/sync/test/mock_model_type_processor.cc

@@ -118,8 +118,9 @@ std::unique_ptr<CommitRequestData> MockModelTypeProcessor::CommitRequest(
   request_data->entity = std::move(data);
   request_data->sequence_number = GetNextSequenceNumber(tag_hash);
   request_data->base_version = base_version;
-  base::Base64Encode(base::SHA1HashString(specifics.SerializeAsString()),
-                     &request_data->specifics_hash);
+  request_data->specifics_hash =
+      base::Base64Encode(base::SHA1HashString(specifics.SerializeAsString()));
+
   if (specifics.has_bookmark()) {
     request_data->deprecated_bookmark_folder =
         (specifics.bookmark().type() == sync_pb::BookmarkSpecifics::FOLDER);

components/sync/test/nigori_test_utils.cc

@@ -181,8 +181,8 @@ sync_pb::NigoriSpecifics BuildCustomPassphraseNigoriSpecifics(
       // Nigori.
       break;
     case KeyDerivationMethod::SCRYPT_8192_8_11:
-      base::Base64Encode(passphrase_key_params.derivation_params.scrypt_salt(),
-                         &encoded_salt);
+      encoded_salt = base::Base64Encode(
+          passphrase_key_params.derivation_params.scrypt_salt());
       nigori.set_custom_passphrase_key_derivation_salt(encoded_salt);
       break;
   }

components/sync_bookmarks/synced_bookmark_tracker.cc

@@ -37,7 +37,8 @@ namespace {
 void HashSpecifics(const sync_pb::EntitySpecifics& specifics,
                    std::string* hash) {
   DCHECK_GT(specifics.ByteSize(), 0);
-  base::Base64Encode(base::SHA1HashString(specifics.SerializeAsString()), hash);
+  *hash =
+      base::Base64Encode(base::SHA1HashString(specifics.SerializeAsString()));
 }
 
 // Returns a map from id to node for all nodes in |model|.

components/sync_bookmarks/synced_bookmark_tracker_entity.cc

@@ -27,7 +27,8 @@ namespace {
 void HashSpecifics(const sync_pb::EntitySpecifics& specifics,
                    std::string* hash) {
   DCHECK_GT(specifics.ByteSize(), 0);
-  base::Base64Encode(base::SHA1HashString(specifics.SerializeAsString()), hash);
+  *hash =
+      base::Base64Encode(base::SHA1HashString(specifics.SerializeAsString()));
 }
 
 }  // namespace

components/variations/service/variations_service.cc

@@ -644,7 +644,7 @@ bool VariationsService::DoFetchFromURL(const GURL& url, bool is_http_retry) {
       if (!EncryptString(serial_number, &serial_number)) {
         return false;
       }
-      base::Base64Encode(serial_number, &serial_number);
+      serial_number = base::Base64Encode(serial_number);
     }
     resource_request->headers.SetHeader("If-None-Match", serial_number);
   }

components/variations/variations_test_utils_unittest.cc

@@ -28,9 +28,8 @@ TEST_P(SignedSeedDataTest, HasValidBase64Data) {
   ASSERT_TRUE(compression::GzipUncompress(decoded_compressed_data,
                                           &actual_uncompressed_data));
 
-  std::string actual_encoded_uncompressed_data;
-  base::Base64Encode(actual_uncompressed_data,
-                     &actual_encoded_uncompressed_data);
+  std::string actual_encoded_uncompressed_data =
+      base::Base64Encode(actual_uncompressed_data);
   EXPECT_EQ(actual_encoded_uncompressed_data,
             signed_seed_data.base64_uncompressed_data);
 

content/browser/devtools/devtools_stream_blob.cc

@@ -201,8 +201,8 @@ void DevToolsStreamBlob::OnReadComplete(int bytes_read) {
     status = blob_reader_->remaining_bytes() ? StatusSuccess : StatusEOF;
     if (is_binary_) {
       base64_encoded = true;
-      base::Base64Encode(base::StringPiece(io_buf_->data(), bytes_read),
-                         data.get());
+      *data =
+          base::Base64Encode(base::StringPiece(io_buf_->data(), bytes_read));
     } else {
       // TODO(caseq): truncate at UTF8 boundary.
       *data = std::string(io_buf_->data(), bytes_read);

content/browser/interest_group/additional_bids_test_util.cc

@@ -44,8 +44,7 @@ std::string GenerateSignedAdditionalBidHeaderPayloadPortion(
     CHECK(ok);
     base::Value::Dict sig_dict;
     sig_dict.Set("key", base64_public_keys[i]);
-    sig_dict.Set("signature",
-                 base::Base64Encode(base::make_span(sig, sizeof(sig))));
+    sig_dict.Set("signature", base::Base64Encode(sig));
     signatures_list.Append(std::move(sig_dict));
 
     if (inject_fault == SignedAdditionalBidFault::kOneInvalidSignature) {

google_apis/gaia/oauth_request_signer.cc

@@ -207,9 +207,7 @@ bool SignHmacSha1(const std::string& text,
   bool result = hmac.Init(key) &&
       hmac.Sign(text, digest, kHmacDigestLength);
   if (result) {
-    base::Base64Encode(
-        std::string(reinterpret_cast<const char*>(digest), kHmacDigestLength),
-        signature_return);
+    *signature_return = base::Base64Encode(digest);
   }
   return result;
 }

google_apis/gcm/base/fake_encryptor.cc

@@ -12,7 +12,7 @@ FakeEncryptor::~FakeEncryptor() {}
 
 bool FakeEncryptor::EncryptString(const std::string& plaintext,
                                   std::string* ciphertext) {
-  base::Base64Encode(plaintext, ciphertext);
+  *ciphertext = base::Base64Encode(plaintext);
   return true;
 }
 

gpu/command_buffer/service/passthrough_program_cache.cc

@@ -167,10 +167,8 @@ void PassthroughProgramCache::Set(Key&& key, Value&& value) {
                                    key.size());
       base::StringPiece value_string(
           reinterpret_cast<const char*>(value.data()), value.size());
-      std::string key_string_64;
-      std::string value_string_64;
-      base::Base64Encode(key_string, &key_string_64);
-      base::Base64Encode(value_string, &value_string_64);
+      std::string key_string_64 = base::Base64Encode(key_string);
+      std::string value_string_64 = base::Base64Encode(value_string);
       cache_program_callback_.Run(key_string_64, value_string_64);
     }
 

gpu/command_buffer/service/passthrough_program_cache_unittest.cc

@@ -105,10 +105,8 @@ TEST_F(PassthroughProgramCacheTest, LoadProgram) {
     std::string binary_blob = MakeBlob(kBlobLength, key_start + 10);
 
     // Encode the strings to pretend like they came from disk.
-    std::string key_string_64;
-    std::string value_string_64;
-    base::Base64Encode(binary_key, &key_string_64);
-    base::Base64Encode(binary_blob, &value_string_64);
+    std::string key_string_64 = base::Base64Encode(binary_key);
+    std::string value_string_64 = base::Base64Encode(binary_blob);
 
     cache_->LoadProgram(key_string_64, value_string_64);
 

gpu/config/gpu_preferences.cc

@@ -73,13 +73,7 @@ GpuPreferences::~GpuPreferences() = default;
 
 std::string GpuPreferences::ToSwitchValue() {
   std::vector<uint8_t> serialized = gpu::mojom::GpuPreferences::Serialize(this);
-
-  std::string encoded;
-  base::Base64Encode(
-      base::StringPiece(reinterpret_cast<const char*>(serialized.data()),
-                        serialized.size()),
-      &encoded);
-  return encoded;
+  return base::Base64Encode(serialized);
 }
 
 bool GpuPreferences::FromSwitchValue(const std::string& data) {

ios/chrome/browser/commerce/model/push_notification/commerce_push_notification_client_unittest.mm

@@ -87,8 +87,7 @@ NSDictionary* SerializeOptGuideCommercePayload() {
   any.SerializeToString(&serialized_any);
 
   // Base 64 encoding
-  std::string serialized_any_escaped;
-  base::Base64Encode(serialized_any, &serialized_any_escaped);
+  std::string serialized_any_escaped = base::Base64Encode(serialized_any);
 
   NSDictionary* user_info = @{
     kSerializedPayloadKey : base::SysUTF8ToNSString(serialized_any_escaped)
@@ -268,8 +267,7 @@ TEST_F(CommercePushNotificationClientTest, TestParsing) {
 
   std::string serialized_any;
   any.SerializeToString(&serialized_any);
-  std::string serialized_any_escaped;
-  base::Base64Encode(serialized_any, &serialized_any_escaped);
+  std::string serialized_any_escaped = base::Base64Encode(serialized_any);
 
   std::unique_ptr<optimization_guide::proto::HintNotificationPayload> parsed =
       CommercePushNotificationClient::ParseHintNotificationPayload(
@@ -309,8 +307,7 @@ TEST_F(CommercePushNotificationClientTest, TestHintKeyRemovedUponNotification) {
 
   std::string serialized_any;
   any.SerializeToString(&serialized_any);
-  std::string serialized_any_escaped;
-  base::Base64Encode(serialized_any, &serialized_any_escaped);
+  std::string serialized_any_escaped = base::Base64Encode(serialized_any);
 
   NSDictionary* dict = @{
     kSerializedPayloadKey : base::SysUTF8ToNSString(serialized_any_escaped)

ios/chrome/browser/reading_list/model/offline_page_tab_helper.mm

@@ -69,7 +69,7 @@ std::string GetOfflineData(base::FilePath offline_root,
     if (!base::ReadFileToString(image_path, &image)) {
       continue;
     }
-    base::Base64Encode(image, &image);
+    image = base::Base64Encode(image);
     std::string src_with_file = base::StringPrintf("%s", file_name.c_str());
     std::string src_with_data =
         base::StringPrintf("data:image/png;base64,%s", image.c_str());
@@ -231,9 +231,9 @@ void OfflinePageTabHelper::ReplaceLocationUrlAndReload(const GURL& url) {
   reloading_from_offline_ = true;
   std::string encoded_url;
   if (url.is_valid() && url.SchemeIsHTTPOrHTTPS()) {
-    base::Base64Encode(url.spec(), &encoded_url);
+    encoded_url = base::Base64Encode(url.spec());
   } else {
-    base::Base64Encode("about:blank", &encoded_url);
+    encoded_url = base::Base64Encode("about:blank");
   }
   NSString* js =
       [NSString stringWithFormat:@"window.location.replace(atob('%@'));",

ios/chrome/browser/reading_list/model/url_downloader.mm

@@ -400,7 +400,7 @@ std::string URLDownloader::ReplaceImagesInHTML(
     base::Value value(images[i].url.spec());
 
     base::JSONWriter::Write(value, &image_url);
-    base::Base64Encode(images[i].data, &image_data);
+    image_data = base::Base64Encode(images[i].data);
 
     std::string src_with_data =
         base::StringPrintf("data:image/png;base64,%s", image_data.c_str());

ios/chrome/browser/view_source/model/view_source_browser_agent.mm

@@ -51,8 +51,7 @@ void ViewSourceBrowserAgent::OnHandleViewSourceForActiveWebStateResult(
 
 void ViewSourceBrowserAgent::InsertSourceViewTab(NSString* source,
                                                  web::WebState* web_state) {
-  std::string base64HTML;
-  base::Base64Encode(base::SysNSStringToUTF8(source), &base64HTML);
+  std::string base64HTML = base::Base64Encode(base::SysNSStringToUTF8(source));
   GURL URL(std::string("data:text/plain;charset=utf-8;base64,") + base64HTML);
   web::Referrer referrer(web_state->GetLastCommittedURL(),
                          web::ReferrerPolicyDefault);

ios/chrome/browser/web/model/image_fetch/image_fetch_java_script_feature_fuzzer.mm

@@ -25,8 +25,7 @@ DEFINE_PROTO_FUZZER(const web::ScriptMessageProto& proto_js_message) {
   if (script_message->body() && script_message->body()->is_dict()) {
     // At 20% rate, ensure data field is a encoded string to avoid early return.
     if (base::RandDouble() < 0.2) {
-      std::string encoded;
-      base::Base64Encode("some raw data", &encoded);
+      std::string encoded = base::Base64Encode("some raw data");
       script_message->body()->GetDict().Set("data", encoded);
     }
   }

ios/web/public/test/http_server/http_auth_response_provider.mm

@@ -44,8 +44,7 @@ bool HttpAuthResponseProvider::HeadersHaveValidCredentials(
   if (headers.GetHeader(net::HttpRequestHeaders::kAuthorization, &header)) {
     std::string auth =
         base::StringPrintf("%s:%s", username_.c_str(), password_.c_str());
-    std::string encoded_auth;
-    base::Base64Encode(auth, &encoded_auth);
+    std::string encoded_auth = base::Base64Encode(auth);
     return header == base::StringPrintf("Basic %s", encoded_auth.c_str());
   }
   return false;

ios/web_view/test/web_view_inttest_base.mm

@@ -47,9 +47,7 @@ bool StartsWith(std::string string, std::string prefix) {
 
 // Encodes the |string| for use as the value of a url parameter.
 std::string EncodeQueryParamValue(std::string string) {
-  std::string encoded_string;
-  base::Base64Encode(string, &encoded_string);
-  return encoded_string;
+  return base::Base64Encode(string);
 }
 
 // Decodes the |encoded_string|. Undoes the encoding performed by

net/http/http_network_transaction_unittest.cc

@@ -11805,26 +11805,16 @@ TEST_P(HttpNetworkTransactionTest, NTLMOverHttp2WithWebsockets) {
                        MockRead(SYNCHRONOUS, ERR_IO_PENDING, 6)};
 
   // Generate the NTLM messages based on known test data.
-  std::string negotiate_msg;
-  std::string challenge_msg;
-  std::string authenticate_msg;
-  base::Base64Encode(
-      base::StringPiece(
-          reinterpret_cast<const char*>(ntlm::test::kExpectedNegotiateMsg),
-          std::size(ntlm::test::kExpectedNegotiateMsg)),
-      &negotiate_msg);
-  base::Base64Encode(
-      base::StringPiece(
-          reinterpret_cast<const char*>(ntlm::test::kChallengeMsgFromSpecV2),
-          std::size(ntlm::test::kChallengeMsgFromSpecV2)),
-      &challenge_msg);
-  base::Base64Encode(
-      base::StringPiece(
-          reinterpret_cast<const char*>(
-              ntlm::test::kExpectedAuthenticateMsgEmptyChannelBindingsV2),
-          std::size(
-              ntlm::test::kExpectedAuthenticateMsgEmptyChannelBindingsV2)),
-      &authenticate_msg);
+  std::string negotiate_msg = base::Base64Encode(base::StringPiece(
+      reinterpret_cast<const char*>(ntlm::test::kExpectedNegotiateMsg),
+      std::size(ntlm::test::kExpectedNegotiateMsg)));
+  std::string challenge_msg = base::Base64Encode(base::StringPiece(
+      reinterpret_cast<const char*>(ntlm::test::kChallengeMsgFromSpecV2),
+      std::size(ntlm::test::kChallengeMsgFromSpecV2)));
+  std::string authenticate_msg = base::Base64Encode(base::StringPiece(
+      reinterpret_cast<const char*>(
+          ntlm::test::kExpectedAuthenticateMsgEmptyChannelBindingsV2),
+      std::size(ntlm::test::kExpectedAuthenticateMsgEmptyChannelBindingsV2)));
 
   // Retry yet again using HTTP/1.1.
   MockWrite writes1[] = {

services/network/ignore_errors_cert_verifier_unittest.cc

@@ -52,7 +52,6 @@ static std::vector<std::string> MakeAllowlist() {
   base::FilePath certs_dir = net::GetTestCertsDirectory();
   net::CertificateList certs = net::CreateCertificateListFromFile(
       certs_dir, "x509_verify_results.chain.pem", X509Certificate::FORMAT_AUTO);
-  std::string hash_base64;
   std::string_view cert_spki;
   SHA256HashValue hash;
   net::asn1::ExtractSPKIFromDERCert(
@@ -60,9 +59,7 @@ static std::vector<std::string> MakeAllowlist() {
       &cert_spki);
 
   crypto::SHA256HashString(cert_spki, &hash, sizeof(SHA256HashValue));
-  base::Base64Encode(std::string_view(reinterpret_cast<const char*>(hash.data),
-                                      sizeof(hash.data)),
-                     &hash_base64);
+  std::string hash_base64 = base::Base64Encode(hash.data);
   return {"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=", "foobar", hash_base64,
           "BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB="};
 }

ui/gfx/nine_image_painter_unittest.cc

@@ -5,6 +5,7 @@
 #include "ui/gfx/nine_image_painter.h"
 
 #include "base/base64.h"
+#include "base/strings/strcat.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/codec/png_codec.h"
@@ -21,12 +22,7 @@ namespace gfx {
 static std::string GetPNGDataUrl(const SkBitmap& bitmap) {
   std::vector<unsigned char> png_data;
   gfx::PNGCodec::EncodeBGRASkBitmap(bitmap, false, &png_data);
-  std::string data_url;
-  data_url.insert(data_url.end(), png_data.begin(), png_data.end());
-  base::Base64Encode(data_url, &data_url);
-  data_url.insert(0, "data:image/png;base64,");
-
-  return data_url;
+  return base::StrCat({"data:image/png;base64,", base::Base64Encode(png_data)});
 }
 
 void ExpectRedWithGreenRect(const SkBitmap& bitmap,