Remove usage of base::make_span(): components/, part 2

Replace with span() CTAD use, or more targeted helpers.

Bug: 341907909
Change-Id: If17945eb0811b5d171c1fd443b567b0990a9587f
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/6061144
Auto-Submit: Peter Kasting <pkasting@chromium.org>
Code-Coverage: findit-for-me@appspot.gserviceaccount.com <findit-for-me@appspot.gserviceaccount.com>
Commit-Queue: Cait Phillips <caitkp@google.com>
Reviewed-by: Cait Phillips <caitkp@google.com>
Cr-Commit-Position: refs/heads/main@{#1390403}

components/os_crypt/async/browser/os_crypt_async_unittest.cc

@@ -547,7 +547,7 @@ TEST_F(OSCryptAsyncTest, ShouldReencrypt) {
     Encryptor encryptor = GetInstanceSync(factory);
     ASSERT_TRUE(encryptor.EncryptString("secrets", &ciphertext));
     // FOO should be used, as it's the higher precedence.
-    EXPECT_THAT(base::make_span(ciphertext).first(3u),
+    EXPECT_THAT(base::span(ciphertext).first<3>(),
                 ::testing::ElementsAreArray(base::span_from_cstring("FOO")));
     std::string plaintext;
     Encryptor::DecryptFlags flags;

components/os_crypt/async/common/encryptor.cc

@@ -197,8 +197,7 @@ bool Encryptor::EncryptString(const std::string& plaintext,
 bool Encryptor::DecryptString(const std::string& ciphertext,
                               std::string* plaintext,
                               DecryptFlags* flags) const {
-  auto decrypted =
-      DecryptData(base::as_bytes(base::make_span(ciphertext)), flags);
+  auto decrypted = DecryptData(base::as_byte_span(ciphertext), flags);
 
   if (!decrypted.has_value()) {
     return false;
@@ -228,8 +227,7 @@ std::optional<std::vector<uint8_t>> Encryptor::EncryptString(
   }
 
   const auto& [provider, key] = *it;
-  std::vector<uint8_t> ciphertext =
-      key.Encrypt(base::as_bytes(base::make_span(data)));
+  std::vector<uint8_t> ciphertext = key.Encrypt(base::as_byte_span(data));
 
   // This adds the provider prefix on the start of the data.
   ciphertext.insert(ciphertext.begin(), provider.cbegin(), provider.cend());

components/os_crypt/async/common/encryptor_unittest.cc

@@ -239,8 +239,7 @@ TEST_P(EncryptorTest, EncryptStringDecryptSpan) {
   std::string ciphertext;
   EXPECT_TRUE(encryptor.EncryptString(plaintext, &ciphertext));
 
-  auto decrypted =
-      encryptor.DecryptData(base::as_bytes(base::make_span(ciphertext)));
+  auto decrypted = encryptor.DecryptData(base::as_byte_span(ciphertext));
 
   ASSERT_TRUE(decrypted);
 
@@ -500,10 +499,9 @@ TEST_F(EncryptorTestWithOSCrypt, ShortCiphertext) {
   static const size_t kNonceLength = 12u;
   for (size_t i = 0; i < kNonceLength * 2; i++) {
     bad_data += "a";
-    auto decrypted =
-        encryptor.DecryptData(base::as_bytes(base::make_span(bad_data)));
+    auto decrypted = encryptor.DecryptData(base::as_byte_span(bad_data));
     EXPECT_TRUE(MaybeVerifyFailedDecryptOperation(
-        decrypted, base::as_bytes(base::make_span(bad_data))));
+        decrypted, base::as_byte_span(bad_data)));
   }
 }
 

components/ownership/owner_settings_service.cc

@@ -96,8 +96,7 @@ std::unique_ptr<em::PolicyFetchResponse> AssembleAndSignPolicy(
   do {
     ++attempt_counter;
     signature_item = SignPolicy(
-        private_key,
-        base::as_bytes(base::make_span(policy_response->policy_data())),
+        private_key, base::as_byte_span(policy_response->policy_data()),
         signature_type);
   } while (!signature_item && attempt_counter < kMaxSignatureAttempts);
 

components/password_manager/core/browser/fake_form_fetcher.cc

@@ -89,7 +89,7 @@ base::span<const PasswordForm> FakeFormFetcher::GetAllRelevantMatches() const {
 }
 
 base::span<const PasswordForm> FakeFormFetcher::GetBestMatches() const {
-  return base::make_span(best_matches_);
+  return base::span(best_matches_);
 }
 
 const PasswordForm* FakeFormFetcher::GetPreferredMatch() const {

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

@@ -104,8 +104,8 @@ AnalyzeResponseResult CheckIfCredentialWasLeaked(
       CipherDecrypt(response->reencrypted_lookup_hash, encryption_key);
   if (!decrypted_username_password) {
     DLOG(ERROR) << "Can't decrypt data="
-                << base::HexEncode(base::as_bytes(
-                       base::make_span(response->reencrypted_lookup_hash)));
+                << base::HexEncode(
+                       base::as_byte_span(response->reencrypted_lookup_hash));
     return AnalyzeResponseResult::kDecryptionError;
   }
 

components/password_manager/core/browser/password_form_cache_impl.cc

@@ -102,7 +102,7 @@ bool PasswordFormCacheImpl::IsEmpty() const {
 
 base::span<const std::unique_ptr<PasswordFormManager>>
 PasswordFormCacheImpl::GetFormManagers() const {
-  return base::make_span(form_managers_);
+  return base::span(form_managers_);
 }
 
 void PasswordFormCacheImpl::SetObserver(

components/password_manager/core/browser/password_form_manager.cc

@@ -393,7 +393,7 @@ PasswordFormMetricsRecorder* PasswordFormManager::GetMetricsRecorder() {
 
 base::span<const InteractionsStats> PasswordFormManager::GetInteractionsStats()
     const {
-  return base::make_span(form_fetcher_->GetInteractionsStats());
+  return base::span(form_fetcher_->GetInteractionsStats());
 }
 
 base::span<const PasswordForm> PasswordFormManager::GetInsecureCredentials()

components/password_manager/core/browser/password_suggestion_generator_unittest.cc

@@ -290,7 +290,7 @@ class PasswordSuggestionGeneratorTest : public testing::Test {
       const std::vector<PasswordForm> suggested_credentials,
       IsTriggeredOnPasswordForm on_password_form) {
     return generator().GetManualFallbackSuggestions(
-        base::make_span(suggested_credentials),
+        base::span(suggested_credentials),
         base::span<const CredentialUIEntry>(), on_password_form);
   }
 
@@ -298,7 +298,7 @@ class PasswordSuggestionGeneratorTest : public testing::Test {
       const std::vector<CredentialUIEntry>& all_credentials,
       IsTriggeredOnPasswordForm on_password_form) {
     return generator().GetManualFallbackSuggestions(
-        base::span<const PasswordForm>(), base::make_span(all_credentials),
+        base::span<const PasswordForm>(), base::span(all_credentials),
         on_password_form);
   }
 
@@ -307,8 +307,8 @@ class PasswordSuggestionGeneratorTest : public testing::Test {
       const std::vector<CredentialUIEntry>& all_credentials,
       IsTriggeredOnPasswordForm on_password_form) {
     return generator().GetManualFallbackSuggestions(
-        base::make_span(suggested_credentials),
-        base::make_span(all_credentials), on_password_form);
+        base::span(suggested_credentials), base::span(all_credentials),
+        on_password_form);
   }
 
   void EnablePasswordSync() {

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

@@ -279,14 +279,13 @@ bool CloudPolicyValidatorBase::VerifySignature(const std::string& data,
       return false;
   }
 
-  if (!verifier.VerifyInit(algorithm,
-                           base::as_bytes(base::make_span(signature)),
-                           base::as_bytes(base::make_span(key)))) {
+  if (!verifier.VerifyInit(algorithm, base::as_byte_span(signature),
+                           base::as_byte_span(key))) {
     DLOG_POLICY(ERROR, CBCM_ENROLLMENT)
         << "Invalid verification signature/key format";
     return false;
   }
-  verifier.VerifyUpdate(base::as_bytes(base::make_span(data)));
+  verifier.VerifyUpdate(base::as_byte_span(data));
   return verifier.VerifyFinal();
 }
 

components/policy/test_support/fake_dmserver.cc

@@ -651,8 +651,7 @@ bool FakeDMServer::WriteURLToPipe(base::ScopedFD&& startup_pipe) {
                          server_url.host().c_str(), server_url.port().c_str());
 
   base::File pipe_writer(startup_pipe.release());
-  if (!pipe_writer.WriteAtCurrentPosAndCheck(
-          base::as_bytes(base::make_span(server_data)))) {
+  if (!pipe_writer.WriteAtCurrentPosAndCheck(base::as_byte_span(server_data))) {
     LOG(ERROR) << "Failed to write the server url data to the pipe, data: "
                << server_data;
     return false;

components/policy/test_support/signature_provider.cc

@@ -103,7 +103,7 @@ std::unique_ptr<crypto::RSAPrivateKey> DecodePrivateKey(
   }
 
   return crypto::RSAPrivateKey::CreateFromPrivateKeyInfo(
-      base::as_bytes(base::make_span(to_decrypt)));
+      base::as_byte_span(to_decrypt));
 }
 
 bool ExportPublicKeyAsString(const crypto::RSAPrivateKey& private_key,

components/policy/test_support/signature_provider_unittest.cc

@@ -50,9 +50,9 @@ TEST_P(SignatureProviderWithValidKeyIndexTest, TestSha256Rsa) {
   crypto::SignatureVerifier signature_verifier;
   ASSERT_TRUE(signature_verifier.VerifyInit(
       crypto::SignatureVerifier::RSA_PKCS1_SHA256,
-      base::as_bytes(base::make_span(signature)),
-      base::as_bytes(base::make_span(signing_key->public_key()))));
-  signature_verifier.VerifyUpdate(base::as_bytes(base::make_span(some_string)));
+      base::as_byte_span(signature),
+      base::as_byte_span(signing_key->public_key())));
+  signature_verifier.VerifyUpdate(base::as_byte_span(some_string));
   EXPECT_TRUE(signature_verifier.VerifyFinal());
 }
 
@@ -78,10 +78,9 @@ TEST_P(SignatureProviderWithValidKeyIndexTest, TestSha1Rsa) {
   EXPECT_FALSE(signature.empty());
   crypto::SignatureVerifier signature_verifier;
   ASSERT_TRUE(signature_verifier.VerifyInit(
-      crypto::SignatureVerifier::RSA_PKCS1_SHA1,
-      base::as_bytes(base::make_span(signature)),
-      base::as_bytes(base::make_span(signing_key->public_key()))));
-  signature_verifier.VerifyUpdate(base::as_bytes(base::make_span(some_string)));
+      crypto::SignatureVerifier::RSA_PKCS1_SHA1, base::as_byte_span(signature),
+      base::as_byte_span(signing_key->public_key())));
+  signature_verifier.VerifyUpdate(base::as_byte_span(some_string));
   EXPECT_TRUE(signature_verifier.VerifyFinal());
 }
 

components/qr_code_generator/bitmap_generator.cc

@@ -352,7 +352,7 @@ base::expected<SkBitmap, Error> GenerateBitmap(base::span<const uint8_t> data,
 
   {
     gfx::Size data_size = {qr_code.qr_size, qr_code.qr_size};
-    return RenderBitmap(base::make_span(qr_code.data), data_size, module_style,
+    return RenderBitmap(base::span(qr_code.data), data_size, module_style,
                         locator_style, center_image, quiet_zone);
   }
 }

components/reporting/encryption/primitives.cc

@@ -71,7 +71,7 @@ bool PerformSymmetricEncryption(const uint8_t symmetric_key[kKeySize],
   CHECK_EQ(aead.KeyLength(), kKeySize);
 
   // Use the symmetric key for data encryption.
-  aead.Init(base::make_span(symmetric_key, kKeySize));
+  aead.Init(base::span(symmetric_key, kKeySize));
 
   // Set nonce to 0s, since a symmetric key is only used once.
   // Note: if we ever start reusing the same symmetric key, we will need

components/reporting/encryption/testing_primitives.cc

@@ -49,7 +49,7 @@ void PerformSymmetricDecryption(const uint8_t symmetric_key[kKeySize],
   CHECK_EQ(aead.KeyLength(), kKeySize);
 
   // Use the symmetric key for data decryption.
-  aead.Init(base::make_span(symmetric_key, kKeySize));
+  aead.Init(base::span(symmetric_key, kKeySize));
 
   // Get nonce at the head of input_data.
   CHECK_EQ(aead.NonceLength(), kNonceSize);

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

@@ -1140,8 +1140,7 @@ base::Value::Dict SerializeVisualFeatures(
   const VisualFeatures::BlurredImage& image = visual_features.image();
   image_dict.Set("width", image.width());
   image_dict.Set("height", image.height());
-  image_dict.Set("data", base::Base64Encode(
-                             base::as_bytes(base::make_span(image.data()))));
+  image_dict.Set("data", base::Base64Encode(base::as_byte_span(image.data())));
 
   base::Value::Dict visual_dict;
   visual_dict.Set("blurred_image", std::move(image_dict));

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

@@ -98,8 +98,9 @@ class HashPrefixMap::BufferedFileWriter {
     if (has_error_ || data.empty())
       return;
 
-    if (!file_.WriteAtCurrentPosAndCheck(base::as_bytes(base::make_span(data))))
+    if (!file_.WriteAtCurrentPosAndCheck(base::as_byte_span(data))) {
       has_error_ = true;
+    }
   }
 
   const std::string extension_;

components/saved_tab_groups/public/saved_tab_group_unittest.cc

@@ -26,8 +26,7 @@ base::Uuid MakeUniqueGUID() {
   static uint64_t unique_value = 0;
   unique_value++;
   uint64_t kBytes[] = {0, unique_value};
-  return base::Uuid::FormatRandomDataAsV4ForTesting(
-      as_bytes(base::make_span(kBytes)));
+  return base::Uuid::FormatRandomDataAsV4ForTesting(base::as_byte_span(kBytes));
 }
 
 LocalTabID MakeUniqueTabID() {

components/security_interstitials/content/ssl_error_assistant_unittest.cc

@@ -97,8 +97,7 @@ class SSLErrorAssistantTest : public content::RenderViewHostTestHarness {
                                        const std::string& match_result) {
     net::CertificateList certs =
         net::X509Certificate::CreateCertificateListFromBytes(
-            base::as_bytes(base::make_span(cert)),
-            net::X509Certificate::FORMAT_AUTO);
+            base::as_byte_span(cert), net::X509Certificate::FORMAT_AUTO);
     ASSERT_FALSE(certs.empty());
     EXPECT_EQ(match_result,
               error_assistant()->MatchKnownMITMSoftware(certs[0]));

components/security_interstitials/content/ssl_error_handler_unittest.cc

@@ -418,8 +418,7 @@ class SSLErrorAssistantProtoTest : public content::RenderViewHostTestHarness {
                                    net::CertStatus cert_status) {
     net::CertificateList certs =
         net::X509Certificate::CreateCertificateListFromBytes(
-            base::as_bytes(base::make_span(cert_data)),
-            net::X509Certificate::FORMAT_AUTO);
+            base::as_byte_span(cert_data), net::X509Certificate::FORMAT_AUTO);
     ASSERT_FALSE(certs.empty());
     ResetErrorHandler(certs[0], cert_status);
   }

components/services/paint_preview_compositor/paint_preview_compositor_impl_unittest.cc

@@ -496,9 +496,7 @@ TEST_P(PaintPreviewCompositorBeginCompositeTest, InvalidProto) {
   {
     testing::internal::CaptureStdout();
     request->preview = mojo_base::ProtoWrapper(
-        base::make_span(reinterpret_cast<const uint8_t*>(test_data.c_str()),
-                        test_data.size()),
-        "paint_preview.PaintPreviewProto",
+        base::as_byte_span(test_data), "paint_preview.PaintPreviewProto",
         mojo_base::ProtoWrapperBytes::GetPassKey());
     BeginCompositeAndValidate(
         std::move(request),

components/services/storage/dom_storage/dom_storage_database.cc

@@ -90,8 +90,8 @@ leveldb::Slice MakeSlice(base::span<const uint8_t> data) {
 
 DomStorageDatabase::KeyValuePair MakeKeyValuePair(const leveldb::Slice& key,
                                                   const leveldb::Slice& value) {
-  auto key_span = base::make_span(key);
-  auto value_span = base::make_span(value);
+  base::span key_span(key);
+  base::span value_span(value);
   return DomStorageDatabase::KeyValuePair(
       DomStorageDatabase::Key(key_span.begin(), key_span.end()),
       DomStorageDatabase::Value(value_span.begin(), value_span.end()));

components/services/storage/dom_storage/dom_storage_database_unittest.cc

@@ -12,6 +12,7 @@
 #include "base/files/file_path.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/run_loop.h"
+#include "base/strings/strcat.h"
 #include "base/task/sequenced_task_runner.h"
 #include "base/task/thread_pool.h"
 #include "base/test/bind.h"
@@ -45,11 +46,6 @@ std::ostream& operator<<(std::ostream& os,
 
 namespace {
 
-// Helper for tests to create a |uint8_t| span from a std::string_view.
-base::span<const uint8_t> MakeBytes(std::string_view s) {
-  return base::as_bytes(base::make_span(s));
-}
-
 DomStorageDatabase::KeyValuePair MakeKeyValuePair(std::string_view key,
                                                   std::string_view value) {
   return {DomStorageDatabase::Key(key.begin(), key.end()),
@@ -57,7 +53,7 @@ DomStorageDatabase::KeyValuePair MakeKeyValuePair(std::string_view key,
 }
 
 std::string MakePrefixedKey(std::string_view prefix, std::string_view key) {
-  return std::string(prefix) + std::string(key);
+  return base::StrCat({prefix, key});
 }
 
 class StorageServiceDomStorageDatabaseTest : public testing::Test {
@@ -163,10 +159,11 @@ TEST_F(StorageServiceDomStorageDatabaseTest, BasicOperations) {
   const char kTestKey[] = "test_key";
   const char kTestValue[] = "test_value";
   DoSync(database, [&](const DomStorageDatabase& db) {
-    EXPECT_STATUS_OK(db.Put(MakeBytes(kTestKey), MakeBytes(kTestValue)));
+    EXPECT_STATUS_OK(db.Put(base::byte_span_from_cstring(kTestKey),
+                            base::byte_span_from_cstring(kTestValue)));
 
     DomStorageDatabase::Value value;
-    EXPECT_STATUS_OK(db.Get(MakeBytes(kTestKey), &value));
+    EXPECT_STATUS_OK(db.Get(base::byte_span_from_cstring(kTestKey), &value));
     EXPECT_VALUE_EQ(kTestValue, value);
   });
 }
@@ -186,7 +183,8 @@ TEST_F(StorageServiceDomStorageDatabaseTest, Reopen) {
       OpenDirectorySync(temp_dir.GetPath(), kTestDbName);
   ASSERT_TRUE(database);
   DoSync(database, [&](const DomStorageDatabase& db) {
-    EXPECT_STATUS_OK(db.Put(MakeBytes(kTestKey), MakeBytes(kTestValue)));
+    EXPECT_STATUS_OK(db.Put(base::byte_span_from_cstring(kTestKey),
+                            base::byte_span_from_cstring(kTestValue)));
   });
   database.Reset();
 
@@ -195,7 +193,7 @@ TEST_F(StorageServiceDomStorageDatabaseTest, Reopen) {
   ASSERT_TRUE(database);
   DoSync(database, [&](const DomStorageDatabase& db) {
     DomStorageDatabase::Value value;
-    EXPECT_STATUS_OK(db.Get(MakeBytes(kTestKey), &value));
+    EXPECT_STATUS_OK(db.Get(base::byte_span_from_cstring(kTestKey), &value));
     EXPECT_VALUE_EQ(kTestValue, value);
   });
   database.Reset();
@@ -215,7 +213,8 @@ TEST_F(StorageServiceDomStorageDatabaseTest, Reopen) {
   ASSERT_TRUE(database);
   DoSync(database, [&](const DomStorageDatabase& db) {
     DomStorageDatabase::Value value;
-    EXPECT_TRUE(db.Get(MakeBytes(kTestKey), &value).IsNotFound());
+    EXPECT_TRUE(
+        db.Get(base::byte_span_from_cstring(kTestKey), &value).IsNotFound());
   });
 
   // Because the database owns filesystem artifacts in the temp directory, block
@@ -231,67 +230,76 @@ TEST_F(StorageServiceDomStorageDatabaseTest, GetPrefixed) {
       OpenInMemorySync("test_db");
   ASSERT_TRUE(database);
 
-  const char kTestPrefix1[] = "prefix";
-  const char kTestPrefix2[] = "something_completely_different";
-  const char kTestUnprefixedKey[] = "moot!";
-  const char kTestKeyBase1[] = "key1";
-  const char kTestKeyBase2[] = "key2";
-  auto kTestPrefix1Key1 = MakePrefixedKey(kTestPrefix1, kTestKeyBase1);
-  auto kTestPrefix1Key2 = MakePrefixedKey(kTestPrefix1, kTestKeyBase2);
-  auto kTestPrefix2Key1 = MakePrefixedKey(kTestPrefix2, kTestKeyBase1);
-  auto kTestPrefix2Key2 = MakePrefixedKey(kTestPrefix2, kTestKeyBase2);
+  static constexpr char kTestPrefix1[] = "prefix";
+  static constexpr char kTestPrefix2[] = "something_completely_different";
+  static constexpr char kTestUnprefixedKey[] = "moot!";
+  static constexpr char kTestKeyBase1[] = "key1";
+  static constexpr char kTestKeyBase2[] = "key2";
+  std::string kTestPrefix1Key1 = MakePrefixedKey(kTestPrefix1, kTestKeyBase1);
+  std::string kTestPrefix1Key2 = MakePrefixedKey(kTestPrefix1, kTestKeyBase2);
+  std::string kTestPrefix2Key1 = MakePrefixedKey(kTestPrefix2, kTestKeyBase1);
+  std::string kTestPrefix2Key2 = MakePrefixedKey(kTestPrefix2, kTestKeyBase2);
   DoSync(database, [&](const DomStorageDatabase& db) {
     std::vector<DomStorageDatabase::KeyValuePair> entries;
 
     // No keys, so GetPrefixed should return nothing.
-    EXPECT_STATUS_OK(db.GetPrefixed(MakeBytes(kTestPrefix1), &entries));
+    EXPECT_STATUS_OK(
+        db.GetPrefixed(base::byte_span_from_cstring(kTestPrefix1), &entries));
     EXPECT_TRUE(entries.empty());
-    EXPECT_STATUS_OK(db.GetPrefixed(MakeBytes(kTestPrefix2), &entries));
+    EXPECT_STATUS_OK(
+        db.GetPrefixed(base::byte_span_from_cstring(kTestPrefix2), &entries));
     EXPECT_TRUE(entries.empty());
 
     // Insert a key which matches neither test prefix. GetPrefixed should still
     // return nothing.
-    EXPECT_STATUS_OK(db.Put(MakeBytes(kTestUnprefixedKey), MakeBytes("meh")));
-    EXPECT_STATUS_OK(db.GetPrefixed(MakeBytes(kTestPrefix1), &entries));
+    EXPECT_STATUS_OK(db.Put(base::byte_span_from_cstring(kTestUnprefixedKey),
+                            base::byte_span_from_cstring("meh")));
+    EXPECT_STATUS_OK(
+        db.GetPrefixed(base::byte_span_from_cstring(kTestPrefix1), &entries));
     EXPECT_TRUE(entries.empty());
-    EXPECT_STATUS_OK(db.GetPrefixed(MakeBytes(kTestPrefix2), &entries));
+    EXPECT_STATUS_OK(
+        db.GetPrefixed(base::byte_span_from_cstring(kTestPrefix2), &entries));
     EXPECT_TRUE(entries.empty());
 
     // Insert a single prefixed key. GetPrefixed should return it when called
     // with kTestPrefix1.
-    const char kTestValue1[] = "beep beep";
+    static constexpr char kTestValue1[] = "beep beep";
+    EXPECT_STATUS_OK(db.Put(base::as_byte_span(kTestPrefix1Key1),
+                            base::byte_span_from_cstring(kTestValue1)));
     EXPECT_STATUS_OK(
-        db.Put(MakeBytes(kTestPrefix1Key1), MakeBytes(kTestValue1)));
-    EXPECT_STATUS_OK(db.GetPrefixed(MakeBytes(kTestPrefix1), &entries));
+        db.GetPrefixed(base::byte_span_from_cstring(kTestPrefix1), &entries));
     EXPECT_THAT(entries, UnorderedElementsAreArray({MakeKeyValuePair(
                              kTestPrefix1Key1, kTestValue1)}));
 
     // But not when called with kTestPrefix2.
     entries.clear();
-    EXPECT_STATUS_OK(db.GetPrefixed(MakeBytes(kTestPrefix2), &entries));
+    EXPECT_STATUS_OK(
+        db.GetPrefixed(base::byte_span_from_cstring(kTestPrefix2), &entries));
     EXPECT_TRUE(entries.empty());
 
     // Insert a second prefixed key with kTestPrefix1, and also insert some
     // keys with kTestPrefix2.
-    const char kTestValue2[] = "beep bop boop";
-    const char kTestValue3[] = "vroom vroom";
-    const char kTestValue4[] = "this data is lit fam";
-    EXPECT_STATUS_OK(
-        db.Put(MakeBytes(kTestPrefix1Key2), MakeBytes(kTestValue2)));
-    EXPECT_STATUS_OK(
-        db.Put(MakeBytes(kTestPrefix2Key1), MakeBytes(kTestValue3)));
-    EXPECT_STATUS_OK(
-        db.Put(MakeBytes(kTestPrefix2Key2), MakeBytes(kTestValue4)));
+    static constexpr char kTestValue2[] = "beep bop boop";
+    static constexpr char kTestValue3[] = "vroom vroom";
+    static constexpr char kTestValue4[] = "this data is lit fam";
+    EXPECT_STATUS_OK(db.Put(base::as_byte_span(kTestPrefix1Key2),
+                            base::byte_span_from_cstring(kTestValue2)));
+    EXPECT_STATUS_OK(db.Put(base::as_byte_span(kTestPrefix2Key1),
+                            base::byte_span_from_cstring(kTestValue3)));
+    EXPECT_STATUS_OK(db.Put(base::as_byte_span(kTestPrefix2Key2),
+                            base::byte_span_from_cstring(kTestValue4)));
 
     // Verify that getting each prefix yields only the expected results.
-    EXPECT_STATUS_OK(db.GetPrefixed(MakeBytes(kTestPrefix1), &entries));
+    EXPECT_STATUS_OK(
+        db.GetPrefixed(base::byte_span_from_cstring(kTestPrefix1), &entries));
     EXPECT_THAT(entries,
                 UnorderedElementsAreArray(
                     {MakeKeyValuePair(kTestPrefix1Key1, kTestValue1),
                      MakeKeyValuePair(kTestPrefix1Key2, kTestValue2)}));
     entries.clear();
 
-    EXPECT_STATUS_OK(db.GetPrefixed(MakeBytes(kTestPrefix2), &entries));
+    EXPECT_STATUS_OK(
+        db.GetPrefixed(base::byte_span_from_cstring(kTestPrefix2), &entries));
     EXPECT_THAT(entries,
                 UnorderedElementsAreArray(
                     {MakeKeyValuePair(kTestPrefix2Key1, kTestValue3),
@@ -306,38 +314,43 @@ TEST_F(StorageServiceDomStorageDatabaseTest, DeletePrefixed) {
       OpenInMemorySync("test_db");
   ASSERT_TRUE(database);
 
-  const char kTestPrefix1[] = "prefix";
-  const char kTestPrefix2[] = "something_completely_different";
-  const char kTestUnprefixedKey[] = "moot!";
-  const char kTestKeyBase1[] = "key1";
-  const char kTestKeyBase2[] = "key2";
-  auto kTestPrefix1Key1 = MakePrefixedKey(kTestPrefix1, kTestKeyBase1);
-  auto kTestPrefix1Key2 = MakePrefixedKey(kTestPrefix1, kTestKeyBase2);
-  auto kTestPrefix2Key1 = MakePrefixedKey(kTestPrefix2, kTestKeyBase1);
-  auto kTestPrefix2Key2 = MakePrefixedKey(kTestPrefix2, kTestKeyBase2);
+  static constexpr char kTestPrefix1[] = "prefix";
+  static constexpr char kTestPrefix2[] = "something_completely_different";
+  static constexpr char kTestUnprefixedKey[] = "moot!";
+  static constexpr char kTestKeyBase1[] = "key1";
+  static constexpr char kTestKeyBase2[] = "key2";
+  std::string kTestPrefix1Key1 = MakePrefixedKey(kTestPrefix1, kTestKeyBase1);
+  std::string kTestPrefix1Key2 = MakePrefixedKey(kTestPrefix1, kTestKeyBase2);
+  std::string kTestPrefix2Key1 = MakePrefixedKey(kTestPrefix2, kTestKeyBase1);
+  std::string kTestPrefix2Key2 = MakePrefixedKey(kTestPrefix2, kTestKeyBase2);
   DoSync(database, [&](const DomStorageDatabase& db) {
     // Insert a bunch of entries. One unprefixed, two with one prefix, and two
     // with another prefix.
-    const char kTestValue1[] = "meh";
-    const char kTestValue2[] = "bah";
-    const char kTestValue3[] = "doh";
-    EXPECT_STATUS_OK(
-        db.Put(MakeBytes(kTestUnprefixedKey), MakeBytes(kTestValue1)));
-    EXPECT_STATUS_OK(db.Put(MakeBytes(kTestPrefix1Key1), MakeBytes("x")));
-    EXPECT_STATUS_OK(db.Put(MakeBytes(kTestPrefix1Key2), MakeBytes("x")));
-    EXPECT_STATUS_OK(
-        db.Put(MakeBytes(kTestPrefix2Key1), MakeBytes(kTestValue2)));
-    EXPECT_STATUS_OK(
-        db.Put(MakeBytes(kTestPrefix2Key2), MakeBytes(kTestValue3)));
+    static constexpr char kTestValue1[] = "meh";
+    static constexpr char kTestValue2[] = "bah";
+    static constexpr char kTestValue3[] = "doh";
+    EXPECT_STATUS_OK(db.Put(base::byte_span_from_cstring(kTestUnprefixedKey),
+                            base::byte_span_from_cstring(kTestValue1)));
+    EXPECT_STATUS_OK(db.Put(base::as_byte_span(kTestPrefix1Key1),
+                            base::byte_span_from_cstring("x")));
+    EXPECT_STATUS_OK(db.Put(base::as_byte_span(kTestPrefix1Key2),
+                            base::byte_span_from_cstring("x")));
+    EXPECT_STATUS_OK(db.Put(base::as_byte_span(kTestPrefix2Key1),
+                            base::byte_span_from_cstring(kTestValue2)));
+    EXPECT_STATUS_OK(db.Put(base::as_byte_span(kTestPrefix2Key2),
+                            base::byte_span_from_cstring(kTestValue3)));
 
     // Wipe out the first prefix. We should still see the second prefix.
     std::vector<DomStorageDatabase::KeyValuePair> entries;
     leveldb::WriteBatch batch;
-    EXPECT_STATUS_OK(db.DeletePrefixed(MakeBytes(kTestPrefix1), &batch));
+    EXPECT_STATUS_OK(
+        db.DeletePrefixed(base::byte_span_from_cstring(kTestPrefix1), &batch));
     EXPECT_STATUS_OK(db.Commit(&batch));
-    EXPECT_STATUS_OK(db.GetPrefixed(MakeBytes(kTestPrefix1), &entries));
+    EXPECT_STATUS_OK(
+        db.GetPrefixed(base::byte_span_from_cstring(kTestPrefix1), &entries));
     EXPECT_TRUE(entries.empty());
-    EXPECT_STATUS_OK(db.GetPrefixed(MakeBytes(kTestPrefix2), &entries));
+    EXPECT_STATUS_OK(
+        db.GetPrefixed(base::byte_span_from_cstring(kTestPrefix2), &entries));
     EXPECT_THAT(entries,
                 UnorderedElementsAreArray(
                     {MakeKeyValuePair(kTestPrefix2Key1, kTestValue2),
@@ -345,13 +358,16 @@ TEST_F(StorageServiceDomStorageDatabaseTest, DeletePrefixed) {
 
     // Wipe out the second prefix.
     batch.Clear();
-    EXPECT_STATUS_OK(db.DeletePrefixed(MakeBytes(kTestPrefix2), &batch));
+    EXPECT_STATUS_OK(
+        db.DeletePrefixed(base::byte_span_from_cstring(kTestPrefix2), &batch));
     EXPECT_STATUS_OK(db.Commit(&batch));
-    EXPECT_STATUS_OK(db.GetPrefixed(MakeBytes(kTestPrefix2), &entries));
+    EXPECT_STATUS_OK(
+        db.GetPrefixed(base::byte_span_from_cstring(kTestPrefix2), &entries));
 
     // The lone unprefixed value should still exist.
     DomStorageDatabase::Value value;
-    EXPECT_STATUS_OK(db.Get(MakeBytes(kTestUnprefixedKey), &value));
+    EXPECT_STATUS_OK(
+        db.Get(base::byte_span_from_cstring(kTestUnprefixedKey), &value));
     EXPECT_VALUE_EQ(kTestValue1, value);
   });
 }
@@ -363,38 +379,40 @@ TEST_F(StorageServiceDomStorageDatabaseTest, CopyPrefixed) {
       OpenInMemorySync("test_db");
   ASSERT_TRUE(database);
 
-  const char kTestUnprefixedKey[] = "moot!";
-  const char kTestPrefix1[] = "prefix";
-  const char kTestPrefix2[] = "something_completely_different";
-  const char kTestKeyBase1[] = "key1";
-  const char kTestKeyBase2[] = "key2";
-  auto kTestPrefix1Key1 = MakePrefixedKey(kTestPrefix1, kTestKeyBase1);
-  auto kTestPrefix1Key2 = MakePrefixedKey(kTestPrefix1, kTestKeyBase2);
-  auto kTestPrefix2Key1 = MakePrefixedKey(kTestPrefix2, kTestKeyBase1);
-  auto kTestPrefix2Key2 = MakePrefixedKey(kTestPrefix2, kTestKeyBase2);
-  const char kTestValue1[] = "a value";
-  const char kTestValue2[] = "another value";
-  const char kTestValue3[] = "the only other value in the world";
+  static constexpr char kTestUnprefixedKey[] = "moot!";
+  static constexpr char kTestPrefix1[] = "prefix";
+  static constexpr char kTestPrefix2[] = "something_completely_different";
+  static constexpr char kTestKeyBase1[] = "key1";
+  static constexpr char kTestKeyBase2[] = "key2";
+  std::string kTestPrefix1Key1 = MakePrefixedKey(kTestPrefix1, kTestKeyBase1);
+  std::string kTestPrefix1Key2 = MakePrefixedKey(kTestPrefix1, kTestKeyBase2);
+  std::string kTestPrefix2Key1 = MakePrefixedKey(kTestPrefix2, kTestKeyBase1);
+  std::string kTestPrefix2Key2 = MakePrefixedKey(kTestPrefix2, kTestKeyBase2);
+  static constexpr char kTestValue1[] = "a value";
+  static constexpr char kTestValue2[] = "another value";
+  static constexpr char kTestValue3[] = "the only other value in the world";
 
   DoSync(database, [&](const DomStorageDatabase& db) {
     // Populate the database with one unprefixed entry, and two values with
     // a key prefix of |kTestPrefix1|.
-    EXPECT_STATUS_OK(
-        db.Put(MakeBytes(kTestUnprefixedKey), MakeBytes(kTestValue1)));
-    EXPECT_STATUS_OK(
-        db.Put(MakeBytes(kTestPrefix1Key1), MakeBytes(kTestValue2)));
-    EXPECT_STATUS_OK(
-        db.Put(MakeBytes(kTestPrefix1Key2), MakeBytes(kTestValue3)));
+    EXPECT_STATUS_OK(db.Put(base::byte_span_from_cstring(kTestUnprefixedKey),
+                            base::byte_span_from_cstring(kTestValue1)));
+    EXPECT_STATUS_OK(db.Put(base::as_byte_span(kTestPrefix1Key1),
+                            base::byte_span_from_cstring(kTestValue2)));
+    EXPECT_STATUS_OK(db.Put(base::as_byte_span(kTestPrefix1Key2),
+                            base::byte_span_from_cstring(kTestValue3)));
 
     // Copy the prefixed entries to |kTestPrefix2| and verify that we have the
     // expected entries.
     leveldb::WriteBatch batch;
-    EXPECT_STATUS_OK(db.CopyPrefixed(MakeBytes(kTestPrefix1),
-                                     MakeBytes(kTestPrefix2), &batch));
+    EXPECT_STATUS_OK(db.CopyPrefixed(base::byte_span_from_cstring(kTestPrefix1),
+                                     base::byte_span_from_cstring(kTestPrefix2),
+                                     &batch));
     EXPECT_STATUS_OK(db.Commit(&batch));
 
     std::vector<DomStorageDatabase::KeyValuePair> entries;
-    EXPECT_STATUS_OK(db.GetPrefixed(MakeBytes(kTestPrefix2), &entries));
+    EXPECT_STATUS_OK(
+        db.GetPrefixed(base::byte_span_from_cstring(kTestPrefix2), &entries));
     EXPECT_THAT(entries,
                 UnorderedElementsAreArray(
                     {MakeKeyValuePair(kTestPrefix2Key1, kTestValue2),
@@ -402,7 +420,8 @@ TEST_F(StorageServiceDomStorageDatabaseTest, CopyPrefixed) {
 
     // The original prefixed values should still be there too.
     entries.clear();
-    EXPECT_STATUS_OK(db.GetPrefixed(MakeBytes(kTestPrefix1), &entries));
+    EXPECT_STATUS_OK(
+        db.GetPrefixed(base::byte_span_from_cstring(kTestPrefix1), &entries));
     EXPECT_THAT(entries,
                 UnorderedElementsAreArray(
                     {MakeKeyValuePair(kTestPrefix1Key1, kTestValue2),

components/services/storage/dom_storage/local_storage_impl.cc

@@ -821,7 +821,7 @@ void LocalStorageImpl::RetrieveStorageUsage(GetUsageCallback callback) {
     database_->RunDatabaseTask(
         base::BindOnce([](const DomStorageDatabase& db) {
           std::vector<DomStorageDatabase::KeyValuePair> data;
-          db.GetPrefixed(base::make_span(kWriteMetaPrefix), &data);
+          db.GetPrefixed(base::span(kWriteMetaPrefix), &data);
           return data;
         }),
         base::BindOnce(&LocalStorageImpl::OnGotWriteMetaData,
@@ -973,7 +973,7 @@ void LocalStorageImpl::DeleteStaleStorageAreas() {
   database_->RunDatabaseTask(
       base::BindOnce([](const DomStorageDatabase& db) {
         std::vector<DomStorageDatabase::KeyValuePair> data;
-        db.GetPrefixed(base::make_span(kMetaPrefix), &data);
+        db.GetPrefixed(base::span(kMetaPrefix), &data);
         return data;
       }),
       base::BindOnce(&LocalStorageImpl::OnGotMetaDataToDeleteStaleStorageAreas,

components/services/storage/dom_storage/local_storage_impl_unittest.cc

@@ -164,8 +164,7 @@ class LocalStorageImplTest : public testing::Test {
     context()->GetDatabaseForTesting().PostTaskWithThisObject(
         base::BindLambdaForTesting([&](const DomStorageDatabase& db) {
           leveldb::Status status =
-              db.Put(base::as_bytes(base::make_span(key)),
-                     base::as_bytes(base::make_span(value)));
+              db.Put(base::as_byte_span(key), base::as_byte_span(value));
           ASSERT_TRUE(status.ok());
           loop.Quit();
         }));

components/services/storage/dom_storage/session_storage_data_map_unittest.cc

@@ -36,7 +36,7 @@ MATCHER(OKStatus, "Equality matcher for type OK leveldb::Status") {
 }
 
 base::span<const uint8_t> MakeBytes(std::string_view str) {
-  return base::as_bytes(base::make_span(str));
+  return base::as_byte_span(str);
 }
 
 mojo::PendingRemote<blink::mojom::StorageAreaObserver> MakeStubObserver() {

components/services/storage/dom_storage/session_storage_impl.cc

@@ -802,18 +802,18 @@ void SessionStorageImpl::OnDatabaseOpened(leveldb::Status status) {
   database_->RunDatabaseTask(
       base::BindOnce([](const DomStorageDatabase& db) {
         ValueAndStatus version;
-        version.status = db.Get(
-            base::make_span(SessionStorageMetadata::kDatabaseVersionBytes),
-            &version.value);
+        version.status =
+            db.Get(base::span(SessionStorageMetadata::kDatabaseVersionBytes),
+                   &version.value);
 
         KeyValuePairsAndStatus namespaces;
         namespaces.status = db.GetPrefixed(
-            base::make_span(SessionStorageMetadata::kNamespacePrefixBytes),
+            base::span(SessionStorageMetadata::kNamespacePrefixBytes),
             &namespaces.key_value_pairs);
 
         ValueAndStatus next_map_id;
         next_map_id.status =
-            db.Get(base::make_span(SessionStorageMetadata::kNextMapIdKeyBytes),
+            db.Get(base::span(SessionStorageMetadata::kNextMapIdKeyBytes),
                    &next_map_id.value);
 
         return std::make_tuple(std::move(version), std::move(namespaces),

components/services/storage/dom_storage/session_storage_impl_unittest.cc

@@ -47,7 +47,7 @@ std::vector<uint8_t> StringViewToUint8Vector(std::string_view s) {
 }
 
 std::vector<uint8_t> String16ToUint8Vector(const std::u16string& s) {
-  auto bytes = base::as_bytes(base::make_span(s));
+  auto bytes = base::as_byte_span(s);
   return std::vector<uint8_t>(bytes.begin(), bytes.end());
 }
 

components/services/storage/dom_storage/session_storage_metadata.cc

@@ -98,10 +98,9 @@ SessionStorageMetadata::SetupNewDatabase() {
   tasks.push_back(base::BindOnce(
       [](int64_t next_map_id, leveldb::WriteBatch* batch,
          const DomStorageDatabase& db) {
-        batch->Put(
-            leveldb_env::MakeSlice(base::make_span(kDatabaseVersionBytes)),
-            leveldb_env::MakeSlice(LatestDatabaseVersionAsVector()));
-        batch->Put(leveldb_env::MakeSlice(base::make_span(kNextMapIdKeyBytes)),
+        batch->Put(leveldb_env::MakeSlice(base::span(kDatabaseVersionBytes)),
+                   leveldb_env::MakeSlice(LatestDatabaseVersionAsVector()));
+        batch->Put(leveldb_env::MakeSlice(base::span(kNextMapIdKeyBytes)),
                    leveldb_env::MakeSlice(NumberToValue(next_map_id)));
       },
       next_map_id_));
@@ -129,11 +128,11 @@ bool SessionStorageMetadata::ParseDatabaseVersion(
   }
   if (initial_database_version_from_disk_ < kMinSessionStorageSchemaVersion)
     return false;
-  upgrade_tasks->push_back(base::BindOnce([](leveldb::WriteBatch* batch,
-                                             const DomStorageDatabase& db) {
-    batch->Put(leveldb_env::MakeSlice(base::make_span(kDatabaseVersionBytes)),
-               leveldb_env::MakeSlice(LatestDatabaseVersionAsVector()));
-  }));
+  upgrade_tasks->push_back(base::BindOnce(
+      [](leveldb::WriteBatch* batch, const DomStorageDatabase& db) {
+        batch->Put(leveldb_env::MakeSlice(base::span(kDatabaseVersionBytes)),
+                   leveldb_env::MakeSlice(LatestDatabaseVersionAsVector()));
+      }));
   return true;
 }
 
@@ -249,7 +248,7 @@ bool SessionStorageMetadata::ParseNamespaces(
         [](std::vector<DomStorageDatabase::Key> prefix_keys_to_delete,
            leveldb::WriteBatch* batch, const DomStorageDatabase& db) {
           batch->Delete(
-              leveldb_env::MakeSlice(base::make_span(kNamespacePrefixBytes)));
+              leveldb_env::MakeSlice(base::span(kNamespacePrefixBytes)));
           // Remove all the refcount storage.
           for (const auto& key : prefix_keys_to_delete)
             batch->Delete(leveldb_env::MakeSlice(key));
@@ -303,7 +302,7 @@ SessionStorageMetadata::RegisterNewMap(
       [](int64_t new_map_id, DomStorageDatabase::Key storage_key_key,
          DomStorageDatabase::Value storage_key_map_number,
          leveldb::WriteBatch* batch, const DomStorageDatabase& db) {
-        batch->Put(leveldb_env::MakeSlice(base::make_span(kNextMapIdKeyBytes)),
+        batch->Put(leveldb_env::MakeSlice(base::span(kNextMapIdKeyBytes)),
                    leveldb_env::MakeSlice(NumberToValue(new_map_id)));
         batch->Put(leveldb_env::MakeSlice(storage_key_key),
                    leveldb_env::MakeSlice(storage_key_map_number));

components/services/storage/dom_storage/session_storage_metadata_unittest.cc

@@ -37,7 +37,7 @@ std::vector<uint8_t> StdStringToUint8Vector(const std::string& s) {
 }
 
 std::vector<uint8_t> SliceToVector(const leveldb::Slice& s) {
-  auto span = base::make_span(s);
+  base::span span(s);
   return std::vector<uint8_t>(span.begin(), span.end());
 }
 

components/services/storage/public/cpp/filesystem/filesystem_proxy_unittest.cc

@@ -200,8 +200,7 @@ TEST_P(FilesystemProxyTest, OpenFileCreateAndOpenOnlyIfNotExists) {
   EXPECT_EQ("", ReadFileContents(&new_file));
 
   const std::string kData = "yeet";
-  EXPECT_TRUE(
-      new_file.WriteAndCheck(0, base::as_bytes(base::make_span(kData))));
+  EXPECT_TRUE(new_file.WriteAndCheck(0, base::as_byte_span(kData)));
   EXPECT_EQ(kData, ReadFileContents(&new_file));
 }
 
@@ -266,8 +265,8 @@ TEST_P(FilesystemProxyTest, OpenFileReadOnly) {
   EXPECT_TRUE(file.IsValid());
 
   // Writes should fail.
-  EXPECT_FALSE(file.WriteAtCurrentPosAndCheck(
-      base::as_bytes(base::make_span("doesn't matter"))));
+  EXPECT_FALSE(
+      file.WriteAtCurrentPosAndCheck(base::as_byte_span("doesn't matter")));
   EXPECT_EQ(kFile1Contents, ReadFileContents(&file));
 }
 
@@ -284,7 +283,7 @@ TEST_P(FilesystemProxyTest, MAYBE_OpenFileWriteOnly) {
   EXPECT_TRUE(file.IsValid());
 
   const std::string kData{"files can have a little data, as a treat"};
-  EXPECT_TRUE(file.WriteAndCheck(0, base::as_bytes(base::make_span(kData))));
+  EXPECT_TRUE(file.WriteAndCheck(0, base::as_byte_span(kData)));
 
   // Reading from this handle should fail.
   std::vector<uint8_t> data;
@@ -309,14 +308,12 @@ TEST_P(FilesystemProxyTest, MAYBE_OpenFileAppendOnly) {
   EXPECT_TRUE(file.IsValid());
 
   const std::string kData{"files can have a little data, as a treat"};
-  EXPECT_TRUE(
-      file.WriteAtCurrentPosAndCheck(base::as_bytes(base::make_span(kData))));
+  EXPECT_TRUE(file.WriteAtCurrentPosAndCheck(base::as_byte_span(kData)));
 
   // Attempt to write somewhere other than the end of the file. The offset
   // should be ignored and the data should be appended instead.
   const std::string kMoreData{"!"};
-  EXPECT_TRUE(
-      file.WriteAndCheck(0, base::as_bytes(base::make_span(kMoreData))));
+  EXPECT_TRUE(file.WriteAndCheck(0, base::as_byte_span(kMoreData)));
 
   // Reading should still fail.
   std::vector<uint8_t> data;

components/services/storage/service_worker/service_worker_storage_control_impl_unittest.cc

@@ -690,7 +690,7 @@ class ServiceWorkerStorageControlImplTest : public testing::Test {
     if (result < 0)
       return result;
 
-    mojo_base::BigBuffer buffer(base::as_bytes(base::make_span(data)));
+    mojo_base::BigBuffer buffer(base::as_byte_span(data));
     result = WriteResponseData(writer.get(), std::move(buffer));
     return result;
   }
@@ -1188,7 +1188,7 @@ TEST_F(ServiceWorkerStorageControlImplTest, WriteAndReadResource) {
 
   // Write content.
   {
-    mojo_base::BigBuffer data(base::as_bytes(base::make_span(kData)));
+    mojo_base::BigBuffer data(base::as_byte_span(kData));
     int bytes_size = data.size();
 
     int result = WriteResponseData(writer.get(), std::move(data));
@@ -1215,7 +1215,7 @@ TEST_F(ServiceWorkerStorageControlImplTest, WriteAndReadResource) {
     EXPECT_EQ(data_result.data, kData);
   }
 
-  const auto kMetadata = base::as_bytes(base::make_span("metadata"));
+  const auto kMetadata = base::as_byte_span("metadata");
   int metadata_size = kMetadata.size();
 
   // Write metadata.

components/sessions/core/command_storage_backend.cc

@@ -136,7 +136,7 @@ class SessionFileReader {
         crypto_key_(crypto_key) {
     if (!crypto_key.empty()) {
       aead_ = std::make_unique<crypto::Aead>(crypto::Aead::AES_256_GCM);
-      aead_->Init(base::make_span(crypto_key_));
+      aead_->Init(base::span(crypto_key_));
     }
     file_ = std::make_unique<base::File>(
         path, base::File::FLAG_OPEN | base::File::FLAG_READ);
@@ -526,7 +526,7 @@ void CommandStorageBackend::AppendCommands(
     if (encrypt) {
       aead_ = std::make_unique<crypto::Aead>(crypto::Aead::AES_256_GCM);
       crypto_key_ = crypto_key;
-      aead_->Init(base::make_span(crypto_key_));
+      aead_->Init(base::span(crypto_key_));
     } else {
       aead_.reset();
     }

components/sharing_message/web_push/json_web_token_util.cc

@@ -55,7 +55,7 @@ std::optional<std::string> CreateJSONWebToken(
   // Create signature.
   auto signer = crypto::ECSignatureCreator::Create(private_key);
   std::vector<uint8_t> der_signature, raw_signature;
-  if (!signer->Sign(base::as_bytes(base::make_span(data)), &der_signature)) {
+  if (!signer->Sign(base::as_byte_span(data), &der_signature)) {
     LOG(ERROR) << "Failed to create DER signature";
     return std::nullopt;
   }

components/sharing_message/web_push/json_web_token_util_unittest.cc

@@ -79,7 +79,7 @@ TEST(JSONWebTokenUtilTest, VerifiesCreateJSONWebToken) {
   ASSERT_TRUE(verifier.VerifyInit(crypto::SignatureVerifier::ECDSA_SHA256,
                                   der_signature, public_key_info));
 
-  verifier.VerifyUpdate(base::as_bytes(base::make_span(data)));
+  verifier.VerifyUpdate(base::as_byte_span(data));
   ASSERT_TRUE(verifier.VerifyFinal());
 
   std::string::size_type data_dot_position = data.find(".");

components/signin/internal/identity_manager/token_binding_helper.cc

@@ -182,7 +182,7 @@ void TokenBindingHelper::SignAssertionToken(
   }
 
   unexportable_key_service_->SignSlowlyAsync(
-      *binding_key, base::as_bytes(base::make_span(*header_and_payload)),
+      *binding_key, base::as_byte_span(*header_and_payload),
       kTokenBindingPriority,
       base::BindOnce(&CreateAssertionToken, *header_and_payload, algorithm)
           .Then(base::BindOnce(&RunCallbackAndRecordMetrics,

components/signin/public/base/hybrid_encryption_key.cc

@@ -7,7 +7,7 @@
 #include "components/signin/public/base/tink_key.pb.h"
 
 namespace {
-const size_t kEncapsulatedKeySize = 32;
+constexpr size_t kEncapsulatedKeySize = 32;
 
 const EVP_HPKE_KEM* GetKem() {
   return EVP_hpke_x25519_hkdf_sha256();
@@ -131,7 +131,7 @@ std::vector<uint8_t> HybridEncryptionKey::EncryptForTesting(
                         EVP_HPKE_CTX_max_overhead(sender_context.get()));
 
   base::span<uint8_t> ciphertext =
-      base::make_span(encrypted_data).subspan(kEncapsulatedKeySize);
+      base::span(encrypted_data).subspan<kEncapsulatedKeySize>();
   size_t ciphertext_len;
 
   if (!EVP_HPKE_CTX_seal(sender_context.get(), ciphertext.data(),

components/signin/public/base/hybrid_encryption_key_unittest.cc

@@ -21,7 +21,7 @@ TEST(HybridEncryptionKeyTest, EncryptAndDecrypt) {
   HybridEncryptionKey key = CreateHybridEncryptionKeyForTesting();
   std::string plaintext = "test";
   std::vector<uint8_t> ciphertext =
-      key.EncryptForTesting(base::as_bytes(base::make_span(plaintext)));
+      key.EncryptForTesting(base::as_byte_span(plaintext));
   std::optional<std::vector<uint8_t>> maybe_plaintext = key.Decrypt(ciphertext);
   ASSERT_TRUE(maybe_plaintext.has_value());
   std::string decrypted_plaintext(maybe_plaintext->begin(),
@@ -33,7 +33,7 @@ TEST(HybridEncryptionKeyTest, EncryptAndDecryptEmpty) {
   HybridEncryptionKey key = CreateHybridEncryptionKeyForTesting();
   std::string plaintext = "";
   std::vector<uint8_t> ciphertext =
-      key.EncryptForTesting(base::as_bytes(base::make_span(plaintext)));
+      key.EncryptForTesting(base::as_byte_span(plaintext));
   std::optional<std::vector<uint8_t>> maybe_plaintext = key.Decrypt(ciphertext);
   ASSERT_TRUE(maybe_plaintext.has_value());
   std::string decrypted_plaintext(maybe_plaintext->begin(),

components/signin/public/base/session_binding_test_utils.cc

@@ -103,7 +103,7 @@ testing::AssertionResult VerifyJwtSignature(
   std::vector<uint8_t> signature(signature_str.begin(), signature_str.end());
   if (algorithm == crypto::SignatureVerifier::ECDSA_SHA256) {
     std::optional<std::vector<uint8_t>> der_signature =
-        ConvertRawSignatureToDER(base::as_bytes(base::make_span(signature)));
+        ConvertRawSignatureToDER(base::as_byte_span(signature));
     if (!der_signature) {
       return testing::AssertionFailure()
              << "Failed to convert raw signature to DER: " << signature_str;
@@ -116,11 +116,11 @@ testing::AssertionResult VerifyJwtSignature(
     return testing::AssertionFailure()
            << "Failed to initialize the signature verifier";
   }
-  verifier.VerifyUpdate(base::as_bytes(
-      base::make_span(parts[static_cast<size_t>(JwtPart::kHeader)])));
+  verifier.VerifyUpdate(
+      base::as_byte_span(parts[static_cast<size_t>(JwtPart::kHeader)]));
   verifier.VerifyUpdate(kJwtSeparatorArray);
-  verifier.VerifyUpdate(base::as_bytes(
-      base::make_span(parts[static_cast<size_t>(JwtPart::kPayload)])));
+  verifier.VerifyUpdate(
+      base::as_byte_span(parts[static_cast<size_t>(JwtPart::kPayload)]));
   return verifier.VerifyFinal()
              ? testing::AssertionSuccess()
              : (testing::AssertionFailure() << "Invalid signature");

components/signin/public/base/session_binding_utils.cc

@@ -230,7 +230,7 @@ std::optional<std::string> AppendSignatureToHeaderAndPayload(
     if (!signature_holder.has_value()) {
       return std::nullopt;
     }
-    signature = base::make_span(*signature_holder);
+    signature = base::span(*signature_holder);
   }
 
   return base::StrCat({header_and_payload, ".", Base64UrlEncode(signature)});