net/disk_cache/sql/sql_backend_impl_unittest.cc - chromium/src - Git at Google

 // Copyright 2025 The Chromium Authors
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 #include "net/disk_cache/sql/sql_backend_impl.h"

 #include <cstdint>
 #include <variant>

 #include "base/containers/span.h"
 #include "base/feature_list.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/functional/callback_helpers.h"
 #include "base/hash/hash.h"
 #include "base/location.h"
 #include "base/memory/scoped_refptr.h"
 #include "base/metrics/field_trial.h"
 #include "base/pickle.h"
 #include "base/run_loop.h"
 #include "base/strings/strcat.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/task/thread_pool.h"
 #include "base/test/bind.h"
 #include "base/test/metrics/histogram_tester.h"
 #include "base/test/run_until.h"
 #include "base/test/scoped_feature_list.h"
 #include "base/test/task_environment.h"
 #include "base/test/test_file_util.h"
 #include "base/test/test_future.h"
 #include "components/performance_manager/scenario_api/performance_scenario_test_support.h"
 #include "net/base/features.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/base/network_isolation_key.h"
 #include "net/base/schemeful_site.h"
 #include "net/base/test_completion_callback.h"
 #include "net/disk_cache/backend_cleanup_tracker.h"
 #include "net/disk_cache/disk_cache_test_util.h"
 #include "net/disk_cache/sql/mock_shared_cache_client_remote.h"
 #include "net/disk_cache/sql/sql_async_task_manager.h"
 #include "net/disk_cache/sql/sql_backend_constants.h"
 #include "net/disk_cache/sql/sql_entry_impl.h"
 #include "net/disk_cache/sql/sql_shared_cache.h"
 #include "net/disk_cache/sql/sql_shared_cache_handle.h"
 #include "net/disk_cache/sql/sql_shared_cache_isolated_database_reader.h"
 #include "net/disk_cache/sql/sql_shared_cache_manager.h"
 #include "net/http/http_cache.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_response_info.h"
 #include "net/test/gtest_util.h"
 #include "sql/database.h"
 #include "sql/statement.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"

 using net::test::IsError;
 using net::test::IsOk;

 using performance_scenarios::InputScenario;
 using performance_scenarios::LoadingScenario;
 using performance_scenarios::PerformanceScenarioTestHelper;
 using performance_scenarios::ScenarioScope;

 namespace disk_cache {

 using OperationHandle = ExclusiveOperationCoordinator::OperationHandle;

 namespace {

 using testing::ElementsAre;
 using testing::Pair;
 using FakeIndexFileError = SqlBackendImpl::FakeIndexFileError;

 // Default max cache size for tests, 10 MB.
 inline constexpr int64_t kDefaultMaxBytes = 10 * 1024 * 1024;

 // Helper to create a new entry and write a data.
 Entry* CreateEntryAndWriteData(SqlBackendImpl* backend,
                                const std::string& key,
                                const std::string& data) {
   TestEntryResultCompletionCallback cb_create;
   disk_cache::EntryResult create_result = cb_create.GetResult(
       backend->CreateEntry(key, net::HIGHEST, cb_create.callback()));
   CHECK_EQ(create_result.net_error(), net::OK);
   auto* entry = create_result.ReleaseEntry();
   auto buffer = base::MakeRefCounted<net::StringIOBuffer>(data);
   net::TestCompletionCallback cb_write;
   EXPECT_EQ(
       cb_write.GetResult(entry->WriteData(1, 0, buffer.get(), buffer->size(),
                                           cb_write.callback(), false)),
       static_cast<int>(buffer->size()));
   return entry;
 }

 // Helper to read data and verify its content.
 void ReadAndVerifyData(Entry* entry, std::string_view expected_data) {
   auto read_buffer =
       base::MakeRefCounted<net::IOBufferWithSize>(expected_data.size() + 1);
   net::TestCompletionCallback cb_read;
   int rv_read = entry->ReadData(1, 0, read_buffer.get(), read_buffer->size(),
                                 cb_read.callback());
   EXPECT_EQ(cb_read.GetResult(rv_read), static_cast<int>(expected_data.size()));
   EXPECT_EQ(std::string_view(read_buffer->data(), expected_data.size()),
             expected_data);
 }

 size_t GetShardCount() {
   return std::max(std::min(net::features::kSqlDiskCacheShardCount.Get(), 255),
                   1);
 }
 std::string GetExpectedFakeIndexContents() {
   base::FieldTrial* backend_field_trial =
       net::features::kDiskCacheBackendResetCacheOnGroupChange.Get()
           ? base::FeatureList::GetFieldTrial(
                 net::features::kDiskCacheBackendExperiment)
           : nullptr;
   return base::StrCat(
       {kSqlBackendFakeIndexPrefix,
        net::features::kSqlDiskCacheWalMode.Get() ? "Wal" : "Truncate",
        base::NumberToString(GetShardCount()),
        backend_field_trial ? backend_field_trial->group_name() : ""});
 }

 class SqlBackendImplTest : public testing::Test {
  public:
   SqlBackendImplTest() = default;
   ~SqlBackendImplTest() override = default;

   // Sets up a temporary directory and a background task runner for each test.
   void SetUp() override { ASSERT_TRUE(temp_dir_.CreateUniqueTempDir()); }

  protected:
   void RunSparseDataExceedsMaxFileSizeTest(bool doom_entry);

   std::unique_ptr<SqlBackendImpl> CreateBackend(
       scoped_refptr<BackendCleanupTracker> cleanup_tracker = nullptr) {
     return std::make_unique<SqlBackendImpl>(
         temp_dir_.GetPath(), kDefaultMaxBytes, net::CacheType::DISK_CACHE,
         std::move(cleanup_tracker));
   }

   void WaitForCleanup(scoped_refptr<BackendCleanupTracker> cleanup_tracker) {
     CHECK(cleanup_tracker);
     base::RunLoop run_loop;
     cleanup_tracker->AddPostCleanupCallback(run_loop.QuitClosure());
     cleanup_tracker = nullptr;
     run_loop.Run();
   }

   std::unique_ptr<SqlBackendImpl> CreateBackendAndInit(
       int64_t max_bytes = kDefaultMaxBytes) {
     auto backend = std::make_unique<SqlBackendImpl>(
         temp_dir_.GetPath(), max_bytes, net::CacheType::DISK_CACHE,
         /*cleanup_tracker=*/nullptr);
     base::test::TestFuture<int> future;
     backend->Init(future.GetCallback());
     CHECK_EQ(future.Get(), net::OK);
     return backend;
   }
   void WaitUntilInitialized(SqlBackendImpl& backend,
                             const scoped_refptr<EntryDbHandle>& db_handle) {
     CHECK(db_handle);
     while (!db_handle->IsFinished()) {
       backend.RunUntilAllTasksCompleteForTest();
     }
   }

   void FlushQueueInTaskRunners(
       const std::vector<scoped_refptr<base::SequencedTaskRunner>>&
           task_runners) {
     for (auto& runner : task_runners) {
       base::RunLoop run_loop;
       runner->PostTask(FROM_HERE, run_loop.QuitClosure());
       run_loop.Run();
     }
   }

   bool LoadInMemoryIndex(SqlBackendImpl& backend) {
     auto* store = backend.GetSqlStoreForTest();
     base::test::TestFuture<SqlPersistentStore::Error> future;
     store->MaybeLoadInMemoryIndex(future.GetCallback());
     return future.Get() == SqlPersistentStore::Error::kOk;
   }

   SqlSharedCacheResourceId CreateEntryInSharedCache(SqlBackendImpl& backend,
                                                     std::string_view key,
                                                     std::string_view data) {
     TestEntryResultCompletionCallback cb_create;
     disk_cache::EntryResult create_result =
         cb_create.GetResult(backend.CreateEntry(std::string(key), net::HIGHEST,
                                                 cb_create.callback()));
     EXPECT_THAT(create_result.net_error(), IsOk());
     auto* entry = create_result.ReleaseEntry();
     CHECK(entry);

     net::HttpResponseInfo response_info;
     response_info.response_time = base::Time::Now();
     response_info.headers =
         base::MakeRefCounted<net::HttpResponseHeaders>("HTTP/1.1 200 OK\0\0");
     auto pickle = response_info.MakePickle(false, false);
     std::string pickle_data(reinterpret_cast<const char*>(pickle->data()),
                             pickle->size());
     auto pickle_buffer = base::MakeRefCounted<net::StringIOBuffer>(pickle_data);
     net::TestCompletionCallback cb_write_pickle;
     EXPECT_EQ(cb_write_pickle.GetResult(
                   entry->WriteData(0, 0, pickle_buffer.get(), pickle->size(),
                                    cb_write_pickle.callback(), false)),
               static_cast<int>(pickle->size()));

     auto write_buf = base::MakeRefCounted<net::IOBufferWithSize>(data.size());
     write_buf->span().copy_from(base::as_byte_span(data));
     net::TestCompletionCallback cb_write;
     EXPECT_EQ(
         cb_write.GetResult(entry->WriteData(1, 0, write_buf.get(), data.size(),
                                             cb_write.callback(), false)),
         static_cast<int>(data.size()));
     entry->Close();
     backend.RunUntilAllTasksCompleteForTest();

     GURL url("https://example.com");
     net::SchemefulSite site(url);
     net::NetworkIsolationKey nik(site, site);
     backend.OnEntryEligibleForSharedCache(
         std::string(key), url,
         std::make_unique<net::HttpResponseInfo>(response_info), nik);

     base::RunLoop process_run_loop;
     backend.ProcessSharedCacheEligibleEntriesForTest(
         base::ScopedClosureRunner(process_run_loop.QuitClosure()),
         base::NullCallback());
     process_run_loop.Run();
     backend.RunUntilAllTasksCompleteForTest();

     CacheEntryKey cache_key{std::string(key)};
     auto* store = backend.GetSqlStoreForTest();
     base::test::TestFuture<SqlPersistentStore::EntryInfoOrError> open_future;
     store->OpenEntry(cache_key, open_future.GetCallback());
     auto open_res = open_future.Take();
     CHECK(open_res.has_value());
     return open_res->shared_cache_resource_id.value_or(
         SqlSharedCacheResourceId{});
   }

   // Gets the total size of all entries.
   int64_t GetSizeOfAllEntries(SqlBackendImpl& backend) {
     return backend.GetSqlStoreForTest()->GetSizeOfAllEntries();
   }

   // Opens the database for a specific shard and returns the count of blobs
   // associated with a given resource ID.
   int64_t OpenDatabaseAndGetBlobsCount(SqlPersistentStore::ShardId shard_id,
                                        SqlPersistentStore::ResId res_id) {
     auto db = std::make_unique<sql::Database>(
         sql::DatabaseOptions()
 #if BUILDFLAG(IS_WIN)
             .set_exclusive_database_file_lock(true)
 #endif  // IS_WIN
             .set_wal_mode(true),
         sql::Database::Tag("HttpCacheDiskCache"));
     CHECK(db->Open(temp_dir_.GetPath().AppendASCII(
         base::StrCat({kSqlBackendDatabaseFileNamePrefix,
                       base::NumberToString(shard_id.value())}))));
     sql::Statement s(
         db->GetUniqueStatement("SELECT COUNT(*) FROM blobs where res_id = ?"));
     s.BindInt64(0, res_id.value());
     CHECK(s.Step());
     return s.ColumnInt64(0);
   }

   void RunDelayedPostInitializationTasksTest();

   base::test::TaskEnvironment task_environment_{
       base::test::TaskEnvironment::TimeSource::MOCK_TIME};

   base::ScopedTempDir temp_dir_;
 };

 TEST_F(SqlBackendImplTest, InitWithNoFakeIndexFile) {
   const std::string expected_contents = GetExpectedFakeIndexContents();
   base::HistogramTester histogram_tester;
   auto backend = CreateBackend();
   base::test::TestFuture<int> future;
   backend->Init(future.GetCallback());
   ASSERT_EQ(future.Get(), net::OK);
   histogram_tester.ExpectUniqueSample("Net.SqlDiskCache.FakeIndexFileError",
                                       FakeIndexFileError::kOkNew, 1);

   base::FilePath file_path =
       temp_dir_.GetPath().Append(kSqlBackendFakeIndexFileName);
   const std::optional<int64_t> file_size = base::GetFileSize(file_path);
   ASSERT_TRUE(file_size.has_value());
   EXPECT_EQ(*file_size, expected_contents.size());
   std::vector<uint8_t> contents(expected_contents.size());
   ASSERT_TRUE(base::ReadFile(file_path, contents));
   EXPECT_EQ(contents, base::as_byte_span(expected_contents));
 }

 TEST_F(SqlBackendImplTest, InitWithFakeIndexFile) {
   const std::string expected_contents = GetExpectedFakeIndexContents();
   base::HistogramTester histogram_tester;
   base::FilePath file_path =
       temp_dir_.GetPath().Append(kSqlBackendFakeIndexFileName);
   ASSERT_TRUE(
       base::WriteFile(file_path, base::as_byte_span(expected_contents)));

   auto backend = CreateBackend();
   base::test::TestFuture<int> future;
   backend->Init(future.GetCallback());
   ASSERT_EQ(future.Get(), net::OK);
   histogram_tester.ExpectUniqueSample("Net.SqlDiskCache.FakeIndexFileError",
                                       FakeIndexFileError::kOkExisting, 1);
 }

 TEST_F(SqlBackendImplTest, ExperimentGroupChangeResetsCacheWhenParamSet) {
   {
     base::test::ScopedFeatureList feature_list;
     feature_list.InitFromCommandLine(
         "DiskCacheBackendExperiment<DiskCacheBackendExperiment.GroupA:"
         "DiskCacheBackendResetCacheOnGroupChange/true",
         "FeatureParamWithCache");

     auto cleanup_tracker = BackendCleanupTracker::TryCreate(temp_dir_.GetPath(),
                                                             base::DoNothing());
     CHECK(cleanup_tracker);

     // Create and init backend. This should create fake index with "GroupA".
     auto backend = CreateBackend(cleanup_tracker);
     base::test::TestFuture<int> future;
     backend->Init(future.GetCallback());
     ASSERT_EQ(future.Get(), net::OK);

     backend.reset();
     WaitForCleanup(std::move(cleanup_tracker));
   }

   {
     base::test::ScopedFeatureList feature_list;
     feature_list.InitFromCommandLine(
         "DiskCacheBackendExperiment<DiskCacheBackendExperiment.GroupB:"
         "DiskCacheBackendResetCacheOnGroupChange/true",
         "FeatureParamWithCache");

     // Initialize backend on same directory. It should fail because the group
     // changed and reset on group change is enabled.
     auto backend = CreateBackend();
     base::test::TestFuture<int> future;
     base::HistogramTester histogram_tester;
     backend->Init(future.GetCallback());
     EXPECT_EQ(future.Get(), net::ERR_FAILED);

     // "GroupA" and "GroupB" have same length, so it should be
     // kWrongMagicNumber.
     histogram_tester.ExpectUniqueSample("Net.SqlDiskCache.FakeIndexFileError",
                                         FakeIndexFileError::kWrongMagicNumber,
                                         1);
   }
 }

 TEST_F(SqlBackendImplTest,
        ExperimentGroupChangeDoesNotResetCacheWhenParamNotSet) {
   {
     base::test::ScopedFeatureList feature_list;
     feature_list.InitFromCommandLine(
         "DiskCacheBackendExperiment<TrialC.GroupA:dummy/1",
         "FeatureParamWithCache");

     auto cleanup_tracker = BackendCleanupTracker::TryCreate(temp_dir_.GetPath(),
                                                             base::DoNothing());
     CHECK(cleanup_tracker);

     // Create and init backend.
     auto backend = CreateBackend(cleanup_tracker);
     base::test::TestFuture<int> future;
     backend->Init(future.GetCallback());
     ASSERT_EQ(future.Get(), net::OK);

     backend.reset();
     WaitForCleanup(std::move(cleanup_tracker));
   }

   {
     base::test::ScopedFeatureList feature_list;
     feature_list.InitFromCommandLine(
         "DiskCacheBackendExperiment<TrialD.GroupB:dummy/1",
         "FeatureParamWithCache");

     // Initialize backend on same directory. It should succeed because reset on
     // group change is disabled by default.
     auto backend = CreateBackend();
     base::test::TestFuture<int> future;
     base::HistogramTester histogram_tester;
     backend->Init(future.GetCallback());
     EXPECT_EQ(future.Get(), net::OK);

     histogram_tester.ExpectUniqueSample("Net.SqlDiskCache.FakeIndexFileError",
                                         FakeIndexFileError::kOkExisting, 1);
   }
 }

 TEST_F(SqlBackendImplTest, WalModeChangeResetsCache) {
   {
     base::test::ScopedFeatureList feature_list;
     feature_list.InitAndEnableFeatureWithParameters(
         net::features::kDiskCacheBackendExperiment,
         {{"SqlDiskCacheWalMode", "false"}});

     auto cleanup_tracker = BackendCleanupTracker::TryCreate(temp_dir_.GetPath(),
                                                             base::DoNothing());
     CHECK(cleanup_tracker);

     auto backend = CreateBackend(cleanup_tracker);
     base::test::TestFuture<int> future;
     backend->Init(future.GetCallback());
     ASSERT_EQ(future.Get(), net::OK);

     backend.reset();
     WaitForCleanup(std::move(cleanup_tracker));
   }

   {
     base::test::ScopedFeatureList feature_list;
     feature_list.InitAndEnableFeatureWithParameters(
         net::features::kDiskCacheBackendExperiment,
         {{"SqlDiskCacheWalMode", "true"}});

     auto backend = CreateBackend();
     base::test::TestFuture<int> future;
     base::HistogramTester histogram_tester;
     backend->Init(future.GetCallback());
     EXPECT_EQ(future.Get(), net::ERR_FAILED);

     histogram_tester.ExpectUniqueSample("Net.SqlDiskCache.FakeIndexFileError",
                                         FakeIndexFileError::kWrongFileSize, 1);
   }
 }

 TEST_F(SqlBackendImplTest, SerialInit) {
   base::test::ScopedFeatureList feature_list;
   feature_list.InitAndEnableFeatureWithParameters(
       net::features::kDiskCacheBackendExperiment,
       {{"SqlDiskCacheSerialInitialize", "true"},
        {"SqlDiskCacheShardCount", "2"}});

   auto backend = CreateBackend();
   base::test::TestFuture<int> future;
   base::HistogramTester histogram_tester;
   backend->Init(future.GetCallback());
   ASSERT_EQ(future.Get(), net::OK);

   histogram_tester.ExpectTotalCount("Net.SqlDiskCache.Init.SuccessTime", 1);
   histogram_tester.ExpectTotalCount("Net.SqlDiskCache.Init.FailureTime", 0);
 }

 TEST_F(SqlBackendImplTest, SerialInitShardFail) {
   base::test::ScopedFeatureList feature_list;
   feature_list.InitAndEnableFeatureWithParameters(
       net::features::kDiskCacheBackendExperiment,
       {{"SqlDiskCacheSerialInitialize", "true"},
        {"SqlDiskCacheShardCount", "2"}});

   auto backend = CreateBackend();
   // Fail the second shard.
   backend->GetSqlStoreForTest()->SetSimulateDbShardFailureForTesting(1, true);

   base::test::TestFuture<int> future;
   base::HistogramTester histogram_tester;
   backend->Init(future.GetCallback());
   ASSERT_EQ(future.Get(), net::ERR_FAILED);

   histogram_tester.ExpectTotalCount("Net.SqlDiskCache.Init.SuccessTime", 0);
   histogram_tester.ExpectTotalCount("Net.SqlDiskCache.Init.FailureTime", 1);
 }

 TEST_F(SqlBackendImplTest, SerialInitFail) {
   base::test::ScopedFeatureList feature_list;
   feature_list.InitAndEnableFeatureWithParameters(
       net::features::kDiskCacheBackendExperiment,
       {{"SqlDiskCacheSerialInitialize", "true"}});

   auto backend = CreateBackend();
   // Make fake index file check fail by creating a directory where the file
   // should be.
   base::CreateDirectory(
       temp_dir_.GetPath().Append(kSqlBackendFakeIndexFileName));

   base::test::TestFuture<int> future;
   base::HistogramTester histogram_tester;
   backend->Init(future.GetCallback());
   ASSERT_EQ(future.Get(), net::ERR_FAILED);
   histogram_tester.ExpectTotalCount("Net.SqlDiskCache.Init.SuccessTime", 0);
   histogram_tester.ExpectTotalCount("Net.SqlDiskCache.Init.FailureTime", 1);
 }

 TEST_F(SqlBackendImplTest, InitWithCorruptedFakeIndexFile) {
   std::string corrupted_contents = GetExpectedFakeIndexContents();
   base::span<uint8_t> corrupted_contents_span =
       base::as_writable_bytes(base::span(corrupted_contents));
   // Rewrite the last char to 'X'.
   corrupted_contents_span.subspan(corrupted_contents_span.size() - 1)
       .copy_from({'X'});
   base::HistogramTester histogram_tester;
   base::FilePath file_path =
       temp_dir_.GetPath().Append(kSqlBackendFakeIndexFileName);
   ASSERT_TRUE(base::WriteFile(file_path, corrupted_contents_span));

   auto backend = CreateBackend();
   base::test::TestFuture<int> future;
   backend->Init(future.GetCallback());
   ASSERT_EQ(future.Get(), net::ERR_FAILED);
   histogram_tester.ExpectUniqueSample("Net.SqlDiskCache.FakeIndexFileError",
                                       FakeIndexFileError::kWrongMagicNumber, 1);
 }

 TEST_F(SqlBackendImplTest, InitWithWrongSizeFakeIndexFile) {
   base::HistogramTester histogram_tester;
   base::FilePath file_path =
       temp_dir_.GetPath().Append(kSqlBackendFakeIndexFileName);
   const int32_t kWrongMagicNumber = 0xDEADBEEF;
   ASSERT_TRUE(
       base::WriteFile(file_path, base::byte_span_from_ref(kWrongMagicNumber)));

   auto backend = CreateBackend();
   base::test::TestFuture<int> future;
   backend->Init(future.GetCallback());
   ASSERT_EQ(future.Get(), net::ERR_FAILED);
   histogram_tester.ExpectUniqueSample("Net.SqlDiskCache.FakeIndexFileError",
                                       FakeIndexFileError::kWrongFileSize, 1);
 }

 TEST_F(SqlBackendImplTest, InitWithOpenFileFailed) {
   const std::string expected_contents = GetExpectedFakeIndexContents();
   base::HistogramTester histogram_tester;
   base::FilePath file_path =
       temp_dir_.GetPath().Append(kSqlBackendFakeIndexFileName);
   ASSERT_TRUE(
       base::WriteFile(file_path, base::as_byte_span(expected_contents)));
   base::FilePermissionRestorer permission_restorer(file_path);
   // Make the file unreadable.
   ASSERT_TRUE(base::MakeFileUnreadable(file_path));

   auto backend = CreateBackend();
   base::test::TestFuture<int> future;
   backend->Init(future.GetCallback());
   ASSERT_EQ(future.Get(), net::ERR_FAILED);
   histogram_tester.ExpectUniqueSample("Net.SqlDiskCache.FakeIndexFileError",
                                       FakeIndexFileError::kOpenFileFailed, 1);
 }

 TEST_F(SqlBackendImplTest, InitWithCreateFileFailed) {
   base::HistogramTester histogram_tester;
   base::FilePermissionRestorer permission_restorer(temp_dir_.GetPath());
   // Make the directory unwrittable.
   ASSERT_TRUE(base::MakeFileUnwritable(temp_dir_.GetPath()));

   auto backend = CreateBackend();
   base::test::TestFuture<int> future;
   backend->Init(future.GetCallback());
   ASSERT_EQ(future.Get(), net::ERR_FAILED);
   histogram_tester.ExpectUniqueSample("Net.SqlDiskCache.FakeIndexFileError",
                                       FakeIndexFileError::kCreateFileFailed, 1);
 }

 TEST_F(SqlBackendImplTest, InitWithFailedToCreateDirectory) {
   base::HistogramTester histogram_tester;
   base::FilePath cache_dir =
       temp_dir_.GetPath().Append(FILE_PATH_LITERAL("cache"));
   // Create a file where the cache directory is supposed to be, to simulate a
   // directory creation failure.
   ASSERT_TRUE(base::WriteFile(cache_dir, ""));

   auto backend = std::make_unique<SqlBackendImpl>(cache_dir, kDefaultMaxBytes,
                                                   net::CacheType::DISK_CACHE,
                                                   /*cleanup_tracker=*/nullptr);
   base::test::TestFuture<int> future;
   backend->Init(future.GetCallback());
   ASSERT_EQ(future.Get(), net::ERR_FAILED);
   histogram_tester.ExpectUniqueSample(
       "Net.SqlDiskCache.FakeIndexFileError",
       FakeIndexFileError::kFailedToCreateDirectory, 1);
 }

 TEST_F(SqlBackendImplTest, MaxFileSizeSmallMax) {
   const int64_t kMaxBytes = 10 * 1024 * 1024;
   auto backend = CreateBackendAndInit(kMaxBytes);
   EXPECT_EQ(backend->MaxFileSize(), kSqlBackendMinFileSizeLimit);
 }

 TEST_F(SqlBackendImplTest, MaxFileSizeCalculation) {
   const int64_t kLargeMaxBytes = 100 * 1024 * 1024;
   auto backend = CreateBackendAndInit(kLargeMaxBytes);
   EXPECT_EQ(backend->MaxFileSize(),
             kLargeMaxBytes / kSqlBackendMaxFileRatioDenominator);
 }

 TEST_F(SqlBackendImplTest, GetStats) {
   auto backend = CreateBackendAndInit();
   base::StringPairs stats;
   backend->GetStats(&stats);
   EXPECT_THAT(stats, ElementsAre(Pair("Cache type", "SQL Cache")));
 }

 // Tests a race condition where an entry is doomed via `SqlEntryImpl::Doom()`
 // while an iterator is in the process of opening it. The iterator should still
 // successfully open the entry, but the entry should be marked as doomed. This
 // works because `OpenNextEntry` is an exclusive operation that runs before the
 // normal `Doom` operation.
 TEST_F(SqlBackendImplTest, IteratorParallelEntryDoom) {
   auto backend = CreateBackendAndInit();
   TestEntryResultCompletionCallback cb_create;
   disk_cache::EntryResult create_result = cb_create.GetResult(
       backend->CreateEntry("key", net::HIGHEST, cb_create.callback()));
   auto* entry1 = create_result.ReleaseEntry();

   auto iter = backend->CreateIterator();
   TestEntryResultCompletionCallback cb;
   EntryResult result_iter = iter->OpenNextEntry(cb.callback());

   entry1->Doom();

   result_iter = cb.GetResult(std::move(result_iter));
   ASSERT_THAT(result_iter.net_error(), IsOk());
   auto* entry2 = result_iter.ReleaseEntry();

   EXPECT_EQ(entry1, entry2);
   EXPECT_TRUE((static_cast<SqlEntryImpl*>(entry1))->doomed());

   entry1->Close();
   entry2->Close();
 }

 // Tests a race condition where an entry is doomed and closed while an iterator
 // is opening it. The iterator should still get a handle to the doomed entry.
 // This verifies that the backend correctly manages the lifecycle of an entry
 // that is being operated on by multiple asynchronous calls.
 TEST_F(SqlBackendImplTest, IteratorParallelEntryDoomAndClose) {
   auto backend = CreateBackendAndInit();
   TestEntryResultCompletionCallback cb_create;
   disk_cache::EntryResult create_result = cb_create.GetResult(
       backend->CreateEntry("key", net::HIGHEST, cb_create.callback()));
   auto* entry = create_result.ReleaseEntry();

   auto iter = backend->CreateIterator();
   TestEntryResultCompletionCallback cb;
   EntryResult result_iter = iter->OpenNextEntry(cb.callback());

   entry->Doom();
   // Doom() is asynchronous. The entry is not marked as doomed until the
   // callback of OpenNextEntry is called.
   EXPECT_FALSE((static_cast<SqlEntryImpl*>(entry))->doomed());
   entry->Close();

   result_iter = cb.GetResult(std::move(result_iter));
   ASSERT_THAT(result_iter.net_error(), IsOk());

   entry = result_iter.ReleaseEntry();

   EXPECT_TRUE((static_cast<SqlEntryImpl*>(entry))->doomed());
   entry->Close();
 }

 // Tests that the iterator correctly skips over an entry that is doomed before
 // the `OpenNextEntry` operation is executed.
 TEST_F(SqlBackendImplTest, IteratorParallelEntryDoomOpenNext) {
   auto backend = CreateBackendAndInit();

   // Create the first entry.
   TestEntryResultCompletionCallback cb_create1;
   disk_cache::EntryResult create_result1 = cb_create1.GetResult(
       backend->CreateEntry("key1", net::HIGHEST, cb_create1.callback()));
   ASSERT_THAT(create_result1.net_error(), IsOk());
   create_result1.ReleaseEntry()->Close();

   // Create the second entry.
   TestEntryResultCompletionCallback cb_create2;
   disk_cache::EntryResult create_result2 = cb_create2.GetResult(
       backend->CreateEntry("key2", net::HIGHEST, cb_create2.callback()));
   ASSERT_THAT(create_result2.net_error(), IsOk());
   auto* entry = create_result2.ReleaseEntry();

   auto iter = backend->CreateIterator();
   TestEntryResultCompletionCallback cb_iter;

   entry->Doom();
   entry->Close();

   // `entry->Doom()` is called before `OpenNextEntry()` is initiated.
   // The iterator starts from the newest entry, which is `key2`. However, `key2`
   // is doomed before the iterator's `OpenNextEntry` operation is posted. The
   // iterator should detect that `key2` is doomed in the database and skip it,
   // returning `key1` instead.
   EntryResult result =
       cb_iter.GetResult(iter->OpenNextEntry(cb_iter.callback()));
   ASSERT_THAT(result.net_error(), IsOk());
   entry = result.ReleaseEntry();
   EXPECT_EQ(entry->GetKey(), "key1");
   entry->Close();

   // There should be no more entries.
   EntryResult result2 =
       cb_iter.GetResult(iter->OpenNextEntry(cb_iter.callback()));
   ASSERT_THAT(result2.net_error(), IsError(net::ERR_FAILED));
 }

 // Tests a race condition between an iterator opening an entry and a direct call
 // to `Backend::DoomEntry`.
 TEST_F(SqlBackendImplTest, IteratorParallelDoom) {
   auto backend = CreateBackendAndInit();

   // 1. Create an entry and write some data to it.
   TestEntryResultCompletionCallback cb_create;
   disk_cache::EntryResult create_result = cb_create.GetResult(
       backend->CreateEntry("key", net::HIGHEST, cb_create.callback()));
   auto* entry1 = create_result.ReleaseEntry();
   const std::string kData = "some data";
   auto buffer = base::MakeRefCounted<net::StringIOBuffer>(kData);
   net::TestCompletionCallback cb_write;
   int rv_write = entry1->WriteData(1, 0, buffer.get(), buffer->size(),
                                    cb_write.callback(), false);
   EXPECT_EQ(cb_write.GetResult(rv_write), static_cast<int>(buffer->size()));

   entry1->Close();

   // 2. Start opening the entry via an iterator. This is an async operation.
   auto iter = backend->CreateIterator();
   TestEntryResultCompletionCallback cb;
   EntryResult result_iter = iter->OpenNextEntry(cb.callback());

   // 3. Immediately call `DoomEntry` for the same key. This is also async.
   net::TestCompletionCallback cb_doom;
   int rv_doom = backend->DoomEntry("key", net::HIGHEST, cb_doom.callback());
   EXPECT_EQ(net::OK, cb_doom.GetResult(rv_doom));

   // `OpenNextEntry()` is an exclusive operation, while `DoomEntry()` is a
   // normal operation. Since `OpenNextEntry()` is posted first, it will run
   // before the `DoomEntry()` operation, which gets queued. After the iterator
   // returns the entry, the `DoomEntry()` operation runs and marks the entry as
   // doomed.
   // 4. Wait for the iterator to finish opening the entry.
   result_iter = cb.GetResult(std::move(result_iter));
   ASSERT_THAT(result_iter.net_error(), IsOk());
   auto* entry = result_iter.ReleaseEntry();
   EXPECT_TRUE(static_cast<SqlEntryImpl*>(entry)->doomed());

   // 5. Verify that the data can still be read from the doomed entry.
   auto read_buffer = base::MakeRefCounted<net::IOBufferWithSize>(kData.size());
   net::TestCompletionCallback cb_read;
   int rv_read = entry->ReadData(1, 0, read_buffer.get(), read_buffer->size(),
                                 cb_read.callback());
   EXPECT_EQ(cb_read.GetResult(rv_read), static_cast<int>(kData.size()));
   EXPECT_EQ(std::string_view(read_buffer->data(), kData.size()), kData);
   entry->Close();
 }

 // Tests a race condition between an iterator opening an entry and a call to
 // `Backend::DoomAllEntries`.
 TEST_F(SqlBackendImplTest, IteratorParallelDoomAll) {
   auto backend = CreateBackendAndInit();

   // 1. Create an entry and write some data to it.
   TestEntryResultCompletionCallback cb_create;
   disk_cache::EntryResult create_result = cb_create.GetResult(
       backend->CreateEntry("key", net::HIGHEST, cb_create.callback()));
   auto* entry1 = create_result.ReleaseEntry();
   const std::string kData = "some data";
   auto buffer = base::MakeRefCounted<net::StringIOBuffer>(kData);
   net::TestCompletionCallback cb_write;
   int rv_write = entry1->WriteData(1, 0, buffer.get(), buffer->size(),
                                    cb_write.callback(), false);
   EXPECT_EQ(cb_write.GetResult(rv_write), static_cast<int>(buffer->size()));
   entry1->Close();

   // 2. Start opening the entry via an iterator. This is an async operation.
   auto iter = backend->CreateIterator();
   TestEntryResultCompletionCallback cb;
   EntryResult result_iter = iter->OpenNextEntry(cb.callback());

   // 3. Immediately call `DoomAllEntries`. This is also an async operation.
   net::TestCompletionCallback cb_doom;
   int rv_doom = backend->DoomAllEntries(cb_doom.callback());
   EXPECT_EQ(net::OK, cb_doom.GetResult(rv_doom));

   // Both `DoomAllEntries()` and `OpenNextEntry()` are exclusive operations and
   // are serialized. Since `OpenNextEntry()` is posted first, it will run
   // first, retrieving the entry. Then, `DoomAllEntries()` will run and doom all
   // entries, including the one just opened.
   // 4. Wait for the iterator to finish opening the entry.
   result_iter = cb.GetResult(std::move(result_iter));
   ASSERT_THAT(result_iter.net_error(), IsOk());
   auto* entry = result_iter.ReleaseEntry();
   EXPECT_TRUE(static_cast<SqlEntryImpl*>(entry)->doomed());

   // 5. Verify that the data can still be read from the doomed entry.
   auto read_buffer = base::MakeRefCounted<net::IOBufferWithSize>(kData.size());
   net::TestCompletionCallback cb_read;
   int rv_read = entry->ReadData(1, 0, read_buffer.get(), read_buffer->size(),
                                 cb_read.callback());
   EXPECT_EQ(cb_read.GetResult(rv_read), static_cast<int>(kData.size()));
   EXPECT_EQ(std::string_view(read_buffer->data(), kData.size()), kData);
   entry->Close();
 }

 // Tests that an entry's `last_used` time is updated correctly when data is
 // written and the entry is closed, even if an iterator is concurrently active.
 // Also verifies the written data can be read back.
 TEST_F(SqlBackendImplTest, IteratorParallelWriteDataAndClose) {
   auto backend = CreateBackendAndInit();
   TestEntryResultCompletionCallback cb_create;
   disk_cache::EntryResult create_result = cb_create.GetResult(
       backend->CreateEntry("key", net::HIGHEST, cb_create.callback()));
   auto* entry = create_result.ReleaseEntry();

   // Advance clock to ensure `last_used` time is distinct from creation.
   task_environment_.AdvanceClock(base::Minutes(1));

   // Create an iterator and attempt to open the entry concurrently.
   auto iter = backend->CreateIterator();
   TestEntryResultCompletionCallback cb;
   EntryResult result_iter = iter->OpenNextEntry(cb.callback());

   // Record the time when data is written. This should be the new `last_used`
   // time.
   const base::Time kWriteTime = base::Time::Now();

   // Write data to stream 0 and close the entry.
   const std::string kHeadData = "header_data";
   auto buffer = base::MakeRefCounted<net::StringIOBuffer>(kHeadData);
   net::TestCompletionCallback cb_write;
   int rv_write = entry->WriteData(0, 0, buffer.get(), buffer->size(),
                                   cb_write.callback(), false);
   entry->Close();
   EXPECT_EQ(cb_write.GetResult(rv_write), buffer->size());

   // Get the result from the iterator's open operation.
   result_iter = cb.GetResult(std::move(result_iter));
   ASSERT_THAT(result_iter.net_error(), IsOk());
   entry = result_iter.ReleaseEntry();
   // Verify that the `last_used` time of the opened entry reflects the write
   // time.
   EXPECT_THAT(entry->GetLastUsed(), kWriteTime);

   // Read the data back from the entry opened via the iterator.
   auto read_buffer =
       base::MakeRefCounted<net::IOBufferWithSize>(kHeadData.size() * 2);
   net::TestCompletionCallback cb_read;
   int rv_read = entry->ReadData(0, 0, read_buffer.get(), read_buffer->size(),
                                 cb_read.callback());
   EXPECT_EQ(cb_read.GetResult(rv_read), kHeadData.size());
   entry->Close();
 }

 // Tests that an entry's `body_end` is updated correctly when data is written to
 // stream 1 and the entry is closed, even if an iterator is concurrently active.
 // Also verifies the written data can be read back.
 TEST_F(SqlBackendImplTest, IteratorParallelWriteBodyDataAndClose) {
   auto backend = CreateBackendAndInit();
   TestEntryResultCompletionCallback cb_create;
   disk_cache::EntryResult create_result = cb_create.GetResult(
       backend->CreateEntry("key", net::HIGHEST, cb_create.callback()));
   auto* entry = create_result.ReleaseEntry();

   // Create an iterator and attempt to open the entry concurrently.
   auto iter = backend->CreateIterator();
   TestEntryResultCompletionCallback cb;
   EntryResult result_iter = iter->OpenNextEntry(cb.callback());

   // Write data to stream 1 and close the entry.
   const std::string kBodyData = "body_data";
   auto buffer = base::MakeRefCounted<net::StringIOBuffer>(kBodyData);
   net::TestCompletionCallback cb_write;
   int rv_write = entry->WriteData(1, 0, buffer.get(), buffer->size(),
                                   cb_write.callback(), false);
   entry->Close();
   EXPECT_EQ(cb_write.GetResult(rv_write), static_cast<int>(buffer->size()));

   // Get the result from the iterator's open operation.
   result_iter = cb.GetResult(std::move(result_iter));
   ASSERT_THAT(result_iter.net_error(), IsOk());
   entry = result_iter.ReleaseEntry();
   // Verify that the `body_end` of the opened entry reflects the write.
   EXPECT_EQ(entry->GetDataSize(1), static_cast<int32_t>(kBodyData.size()));

   // Read the data back from the entry opened via the iterator.
   auto read_buffer =
       base::MakeRefCounted<net::IOBufferWithSize>(kBodyData.size() * 2);
   net::TestCompletionCallback cb_read;
   int rv_read = entry->ReadData(1, 0, read_buffer.get(), read_buffer->size(),
                                 cb_read.callback());
   EXPECT_EQ(cb_read.GetResult(rv_read), static_cast<int>(kBodyData.size()));
   EXPECT_EQ(std::string_view(read_buffer->data(), kBodyData.size()), kBodyData);
   entry->Close();
 }

 // Tests that an entry's `last_used` time is updated correctly when data is read
 // and the entry is closed, even if an iterator is concurrently active.
 TEST_F(SqlBackendImplTest, IteratorParallelReadDataAndClose) {
   auto backend = CreateBackendAndInit();
   TestEntryResultCompletionCallback cb_create;
   disk_cache::EntryResult create_result = cb_create.GetResult(
       backend->CreateEntry("key", net::HIGHEST, cb_create.callback()));
   auto* entry = create_result.ReleaseEntry();

   // Advance clock to ensure `last_used` time is distinct from creation.
   task_environment_.AdvanceClock(base::Minutes(1));

   // Create an iterator and attempt to open the entry concurrently.
   auto iter = backend->CreateIterator();
   TestEntryResultCompletionCallback cb;
   EntryResult result_iter = iter->OpenNextEntry(cb.callback());

   // Record the time when data is read. This should be the new `last_used` time.
   const base::Time kReadTime = base::Time::Now();

   // Read data from stream 0 and close the entry.
   auto read_buffer = base::MakeRefCounted<net::IOBufferWithSize>(1);
   net::TestCompletionCallback cb_read;
   int rv_read = entry->ReadData(0, 0, read_buffer.get(), read_buffer->size(),
                                 cb_read.callback());
   EXPECT_EQ(cb_read.GetResult(rv_read), 0);
   entry->Close();

   // Get the result from the iterator's open operation.
   result_iter = cb.GetResult(std::move(result_iter));
   ASSERT_THAT(result_iter.net_error(), IsOk());
   entry = result_iter.ReleaseEntry();

   // Verify that the `last_used` time of the opened entry reflects the read
   // time.
   EXPECT_THAT(entry->GetLastUsed(), kReadTime);
   entry->Close();
 }

 // Tests a race condition where an entry is opened simultaneously by an iterator
 // and a direct `OpenEntry` call. The backend should correctly handle this by
 // returning the same `SqlEntryImpl` instance for both operations, preventing
 // duplicate in-memory representations of the same cache entry.
 TEST_F(SqlBackendImplTest, IteratorAndOpenEntryParallelRace) {
   auto backend = CreateBackendAndInit();

   // Create an entry.
   TestEntryResultCompletionCallback cb_create;
   disk_cache::EntryResult create_result = cb_create.GetResult(
       backend->CreateEntry("key", net::HIGHEST, cb_create.callback()));
   ASSERT_THAT(create_result.net_error(), IsOk());
   create_result.ReleaseEntry()->Close();

   base::test::TestFuture<EntryResult> future_iter;
   base::test::TestFuture<EntryResult> future_open;

   auto iter = backend->CreateIterator();
   // Start opening the entry via the iterator. This posts an async task.
   ASSERT_EQ(iter->OpenNextEntry(future_iter.GetCallback()).net_error(),
             net::ERR_IO_PENDING);

   // Immediately try to open the same entry directly. This also posts an async
   // task.
   ASSERT_EQ(backend->OpenEntry("key", net::HIGHEST, future_open.GetCallback())
                 .net_error(),
             net::ERR_IO_PENDING);

   // 3. Wait for both operations to complete. This test is designed to expose a
   // race condition. The backend should handle this race correctly by ensuring
   // only one `SqlEntryImpl` is created for the same key.
   EntryResult iter_res = future_iter.Take();
   EntryResult open_res = future_open.Take();

   ASSERT_THAT(iter_res.net_error(), IsOk());
   ASSERT_THAT(open_res.net_error(), IsOk());
   auto* entry1 = iter_res.ReleaseEntry();
   auto* entry2 = open_res.ReleaseEntry();

   // Both the iterator and the direct open operation should resolve to the same
   // underlying `SqlEntryImpl` instance. The backend's logic for managing
   // active entries should prevent the creation of a second instance for the
   // same key.
   EXPECT_EQ(entry1, entry2);
   entry1->Close();
   entry2->Close();
 }

 // Tests a race condition where an entry is opened by an iterator, opened by a
 // direct call, and doomed, all in parallel.
 // The exclusive `OpenNextEntry` operation runs first. The normal `OpenEntry`
 // and `DoomEntry` operations are queued and serialized by key. `OpenEntry`
 // runs next, getting a reference to the active entry. Finally, `DoomEntry`
 // runs and marks that same entry instance as doomed.
 TEST_F(SqlBackendImplTest, IteratorAndOpenEntryAndDoomParallelRace) {
   auto backend = CreateBackendAndInit();

   // Create an entry.
   TestEntryResultCompletionCallback cb_create;
   disk_cache::EntryResult create_result = cb_create.GetResult(
       backend->CreateEntry("key", net::HIGHEST, cb_create.callback()));
   ASSERT_THAT(create_result.net_error(), IsOk());
   create_result.ReleaseEntry()->Close();

   base::test::TestFuture<EntryResult> future_iter;
   base::test::TestFuture<EntryResult> future_open;
   base::test::TestFuture<int> future_doom;

   auto iter = backend->CreateIterator();
   ASSERT_EQ(iter->OpenNextEntry(future_iter.GetCallback()).net_error(),
             net::ERR_IO_PENDING);
   ASSERT_EQ(backend->OpenEntry("key", net::HIGHEST, future_open.GetCallback())
                 .net_error(),
             net::ERR_IO_PENDING);
   ASSERT_EQ(backend->DoomEntry("key", net::HIGHEST, future_doom.GetCallback()),
             net::ERR_IO_PENDING);

   EntryResult iter_res = future_iter.Take();
   ASSERT_THAT(iter_res.net_error(), IsOk());
   auto* entry1 = iter_res.ReleaseEntry();

   EntryResult open_res = future_open.Take();
   ASSERT_THAT(open_res.net_error(), IsOk());
   auto* entry2 = open_res.ReleaseEntry();

   EXPECT_EQ(entry1, entry2);
   EXPECT_EQ(future_doom.Take(), net::OK);

   EXPECT_TRUE(static_cast<SqlEntryImpl*>(entry1)->doomed());

   entry1->Close();
   entry2->Close();
 }

 // Tests a race condition where an entry is opened via `OpenEntry` while it is
 // simultaneously being opened and then doomed by an iterator.
 TEST_F(SqlBackendImplTest, OpenEntryRacesWithIteratorAndDoom) {
   // This test simulates a race condition to verify the interaction between
   // opening an entry directly and an iterator that dooms the same entry in its
   // callback. The exclusive `OpenNextEntry` operation runs first. Its callback
   // then posts a normal `Doom` operation. The `OpenEntry` call (also a normal
   // operation) was posted before the `Doom` operation. Due to serialization by
   // key, `OpenEntry` gets a reference to the active entry first, and then the
   // `Doom` operation marks that same instance as doomed.
   auto backend = CreateBackendAndInit();

   // 1. Create an entry.
   TestEntryResultCompletionCallback cb_create;
   disk_cache::EntryResult create_result = cb_create.GetResult(
       backend->CreateEntry("key", net::HIGHEST, cb_create.callback()));
   ASSERT_THAT(create_result.net_error(), IsOk());
   create_result.ReleaseEntry()->Close();

   auto iter = backend->CreateIterator();
   // 2. Start opening the entry via an iterator. This is an async operation.
   ASSERT_EQ(iter->OpenNextEntry(
                     base::BindLambdaForTesting([&](EntryResult entry_result) {
                       // 4. Once the iterator gets the entry, doom and close it.
                       auto* entry = entry_result.ReleaseEntry();
                       entry->Doom();
                       entry->Close();
                     }))
                 .net_error(),
             net::ERR_IO_PENDING);

   // 3. While the iterator operation is in-flight, attempt to open the same
   //    entry directly. This is also an async operation.
   base::test::TestFuture<EntryResult> open_future;
   ASSERT_EQ(backend->OpenEntry("key", net::HIGHEST, open_future.GetCallback())
                 .net_error(),
             net::ERR_IO_PENDING);

   // 5. Wait for the direct `OpenEntry` call to complete.
   EntryResult open_result = open_future.Take();
   ASSERT_THAT(open_result.net_error(), IsOk());
   auto* entry = open_result.ReleaseEntry();
   EXPECT_TRUE(static_cast<SqlEntryImpl*>(entry)->doomed());
   entry->Close();
 }

 // Tests a race condition where an entry is opened via `OpenOrCreateEntry` while
 // it is simultaneously being opened and then doomed by an iterator.
 // `OpenOrCreateEntry` should find the existing entry (which is being opened by
 // the iterator) and not create a new one. The test verifies that the returned
 // entry is correctly marked as doomed, demonstrating proper serialization and
 // state management.
 TEST_F(SqlBackendImplTest, OpenOrCreateEntryEntryRacesWithIteratorAndDoom) {
   auto backend = CreateBackendAndInit();

   // 1. Create an entry and record its creation time.
   base::Time first_entry_creation_time = base::Time::Now();
   TestEntryResultCompletionCallback cb_create;
   disk_cache::EntryResult create_result = cb_create.GetResult(
       backend->CreateEntry("key", net::HIGHEST, cb_create.callback()));
   ASSERT_THAT(create_result.net_error(), IsOk());
   auto* entry = create_result.ReleaseEntry();
   EXPECT_EQ(entry->GetLastUsed(), first_entry_creation_time);
   entry->Close();

   task_environment_.AdvanceClock(base::Minutes(1));

   auto iter = backend->CreateIterator();
   // 2. Start opening the entry via an iterator. This is an async operation.
   ASSERT_EQ(iter->OpenNextEntry(
                     base::BindLambdaForTesting([&](EntryResult entry_result) {
                       // 4. Once the iterator gets the entry, doom and close it.
                       auto* entry = entry_result.ReleaseEntry();
                       EXPECT_EQ(entry->GetLastUsed(),
                                 first_entry_creation_time);
                       entry->Doom();
                       entry->Close();
                     }))
                 .net_error(),
             net::ERR_IO_PENDING);

   base::test::TestFuture<EntryResult> open_or_create_future;
   // 3. While the iterator operation is in-flight, call `OpenOrCreateEntry` for
   //    the same key.
   ASSERT_EQ(backend
                 ->OpenOrCreateEntry("key", net::HIGHEST,
                                     open_or_create_future.GetCallback())
                 .net_error(),
             net::ERR_IO_PENDING);

   EntryResult open_or_create_result = open_or_create_future.Take();
   ASSERT_THAT(open_or_create_result.net_error(), IsOk());
   entry = open_or_create_result.ReleaseEntry();
   EXPECT_EQ(entry->GetLastUsed(), first_entry_creation_time);
   EXPECT_TRUE(static_cast<SqlEntryImpl*>(entry)->doomed());
   entry->Close();
 }

 // Tests a race condition where an entry is opened via `OpenEntry` while it is
 // simultaneously being opened, written to, and closed by an iterator.
 // This test verifies that in-flight modifications (like `last_used`
 // time and header data updates) that are queued while an entry is not active
 // are correctly applied to the entry's in-memory representation when it is
 // next opened. This ensures that subsequent operations on the entry see the
 // most up-to-date state.
 TEST_F(SqlBackendImplTest, OpenEntryRacesWithIteratorAndWriteData) {
   auto backend = CreateBackendAndInit();

   // 1. Create an entry and record its creation time.
   base::Time first_entry_creation_time = base::Time::Now();
   TestEntryResultCompletionCallback cb_create;
   disk_cache::EntryResult create_result = cb_create.GetResult(
       backend->CreateEntry("key", net::HIGHEST, cb_create.callback()));
   ASSERT_THAT(create_result.net_error(), IsOk());
   auto* entry = create_result.ReleaseEntry();
   EXPECT_EQ(entry->GetLastUsed(), first_entry_creation_time);
   entry->Close();

   task_environment_.AdvanceClock(base::Minutes(1));

   const std::string kHeadData = "header_data";
   // 2. Start opening the entry via an iterator. This is an async operation.
   auto iter = backend->CreateIterator();
   ASSERT_EQ(iter->OpenNextEntry(
                     base::BindLambdaForTesting([&](EntryResult entry_result) {
                       // 4. Once the iterator gets the entry, write data to it
                       //    and close it. This updates the entry's `last_used`
                       //    time and header data in memory, and queues a write
                       //    to the persistent store.
                       auto* entry = entry_result.ReleaseEntry();
                       EXPECT_EQ(entry->GetLastUsed(),
                                 first_entry_creation_time);
                       auto buffer =
                           base::MakeRefCounted<net::StringIOBuffer>(kHeadData);
                       entry->WriteData(0, 0, buffer.get(), buffer->size(),
                                        base::DoNothing(), false);
                       entry->Close();
                     }))
                 .net_error(),
             net::ERR_IO_PENDING);

   // 3. While the iterator operation is in-flight, attempt to open the same
   //    entry directly.
   base::test::TestFuture<EntryResult> open_future;
   ASSERT_EQ(backend->OpenEntry("key", net::HIGHEST, open_future.GetCallback())
                 .net_error(),
             net::ERR_IO_PENDING);

   // 5. The `OpenEntry` operation should succeed. The backend should handle the
   //    race by applying the in-flight modifications (from the iterator's
   //    write and close) to the entry data before returning the new entry
   //    handle.
   EntryResult open_result = open_future.Take();
   ASSERT_THAT(open_result.net_error(), IsOk());
   entry = open_result.ReleaseEntry();
   // The `last_used` time should reflect the time of the write.
   EXPECT_EQ(entry->GetLastUsed(), first_entry_creation_time + base::Minutes(1));
   // The data written by the iterator should be readable.
   auto buffer =
       base::MakeRefCounted<net::IOBufferWithSize>(kHeadData.size() * 2);
   ASSERT_EQ(
       entry->ReadData(0, 0, buffer.get(), buffer->size(), base::DoNothing()),
       kHeadData.size());
   EXPECT_EQ(buffer->first(kHeadData.size()), base::as_byte_span(kHeadData));
   entry->Close();
 }

 // Tests that OnExternalCacheHit correctly updates the last_used time, even when
 // an OpenEntry operation is in-flight.
 TEST_F(SqlBackendImplTest, OnExternalCacheHitRacesWithOpen) {
   auto backend = CreateBackendAndInit();

   // 1. Create an entry and close it.
   const std::string kKey = "my-key";
   TestEntryResultCompletionCallback create_cb;
   disk_cache::EntryResult create_result = create_cb.GetResult(
       backend->CreateEntry(kKey, net::HIGHEST, create_cb.callback()));
   ASSERT_THAT(create_result.net_error(), IsOk());
   auto* created_entry = create_result.ReleaseEntry();
   base::Time create_time = created_entry->GetLastUsed();
   created_entry->Close();

   // 2. Advance time.
   task_environment_.AdvanceClock(base::Minutes(1));

   // 3. Start opening the entry. This is an async operation.
   base::test::TestFuture<EntryResult> open_future;
   ASSERT_EQ(backend->OpenEntry(kKey, net::HIGHEST, open_future.GetCallback())
                 .net_error(),
             net::ERR_IO_PENDING);

   // 4. Call OnExternalCacheHit.
   base::Time hit_time = base::Time::Now();
   EXPECT_NE(create_time, hit_time);
   backend->OnExternalCacheHit(kKey);

   // 5. Wait for OpenEntry to complete.
   EntryResult open_result = open_future.Take();
   ASSERT_THAT(open_result.net_error(), IsOk());
   auto* entry = open_result.ReleaseEntry();

   // 6. The entry's last_used time should be the time of the external hit.
   EXPECT_EQ(entry->GetLastUsed(), hit_time);
   entry->Close();
 }

 TEST_F(SqlBackendImplTest, DoomEntryNonExistent) {
   auto backend = CreateBackendAndInit();
   EXPECT_TRUE(LoadInMemoryIndex(*backend));
   backend->GetSqlStoreForTest()->SetSimulateDbFailureForTesting(true);
   const std::string kNonExistentKey = "non-existent-key";
   net::TestCompletionCallback cb_doom;
   int rv_doom =
       backend->DoomEntry(kNonExistentKey, net::HIGHEST,
                          base::BindOnce([](int rv) { NOTREACHED(); }));
   // The operation should complete synchronously due to the in-memory index
   // check, so the callback should not be reached if the DB operation were to
   // be attempted.
   EXPECT_EQ(net::OK, rv_doom);
 }

 // Tests that calling Doom() multiple times on the same entry is safe and
 // idempotent.
 TEST_F(SqlBackendImplTest, MultipleDoomsOnSameEntry) {
   auto backend = CreateBackendAndInit();

   // Create an entry.
   TestEntryResultCompletionCallback cb_create;
   disk_cache::EntryResult create_result = cb_create.GetResult(
       backend->CreateEntry("key", net::HIGHEST, cb_create.callback()));
   ASSERT_THAT(create_result.net_error(), IsOk());
   auto* entry = create_result.ReleaseEntry();

   // Doom the entry multiple times. This should not cause any issues.
   entry->Doom();
   entry->Doom();

   // When the entry was created speculatively, the doomed flag is updated
   // asynchronously. So need to flush the pending database operations.
   backend->RunUntilAllTasksCompleteForTest();

   EXPECT_TRUE(static_cast<SqlEntryImpl*>(entry)->doomed());
   entry->Close();

   // Verify that the entry is gone after being doomed and closed.
   TestEntryResultCompletionCallback cb_open;
   disk_cache::EntryResult open_result = cb_open.GetResult(
       backend->OpenEntry("key", net::HIGHEST, cb_open.callback()));
   EXPECT_THAT(open_result.net_error(), IsError(net::ERR_FAILED));
 }

 // Tests that recursive calls to OpenNextEntry from within its callback do not
 // starve normal operations. The ExclusiveOperationCoordinator's sequence-based
 // scheduling ensures that the older normal operation (CreateEntry) is executed
 // before the newer exclusive operation (the second OpenNextEntry).
 TEST_F(SqlBackendImplTest, RecursiveOpenNextEntry) {
   auto backend = CreateBackendAndInit();

   // Create two entries to iterate over.
   TestEntryResultCompletionCallback cb_create;
   disk_cache::EntryResult create_result1 = cb_create.GetResult(
       backend->CreateEntry("key1", net::HIGHEST, cb_create.callback()));
   ASSERT_THAT(create_result1.net_error(), IsOk());
   create_result1.ReleaseEntry()->Close();

   disk_cache::EntryResult create_result2 = cb_create.GetResult(
       backend->CreateEntry("key2", net::HIGHEST, cb_create.callback()));
   ASSERT_THAT(create_result2.net_error(), IsOk());
   create_result2.ReleaseEntry()->Close();

   auto iter = backend->CreateIterator();

   base::RunLoop run_loop;
   Entry* entry3 = nullptr;

   bool key_1_found = false;
   bool key_2_found = false;

   // The first call to OpenNextEntry. Inside its callback, we'll trigger the
   // second call.
   ASSERT_THAT(
       iter->OpenNextEntry(base::BindLambdaForTesting([&](EntryResult result1) {
             ASSERT_THAT(result1.net_error(), IsOk());
             auto* entry1_itr = result1.ReleaseEntry();
             key_1_found = entry1_itr->GetKey() == "key1";
             key_2_found = entry1_itr->GetKey() == "key2";
             EXPECT_TRUE(key_1_found || key_2_found);
             entry1_itr->Close();
             // Now, make the recursive call to OpenNextEntry.
             ASSERT_THAT(
                 iter->OpenNextEntry(
                         base::BindLambdaForTesting([&](EntryResult result2) {
                           ASSERT_THAT(result2.net_error(), IsOk());
                           // By this point, the CreateEntry for "key3" should
                           // have completed, proving that the normal operation
                           // was not starved.
                           CHECK(entry3);

                           auto* entry2_itr = result2.ReleaseEntry();
                           if (entry2_itr->GetKey() == "key3") {
                             EXPECT_EQ(entry2_itr, entry3);
                           } else {
                             if (key_1_found) {
                               EXPECT_EQ(entry2_itr->GetKey(), "key2");
                             } else {
                               EXPECT_EQ(entry2_itr->GetKey(), "key1");
                             }
                           }
                           entry2_itr->Close();
                           entry3->Close();
                           run_loop.Quit();
                         }))
                     .net_error(),
                 IsError(net::ERR_IO_PENDING));
           }))
           .net_error(),
       IsError(net::ERR_IO_PENDING));

   // While the first OpenNextEntry is in flight, post a normal operation to
   // create a third entry. This tests that the recursive exclusive operations
   // do not starve the normal one.
   ASSERT_THAT(
       backend
           ->CreateEntry("key3", net::HIGHEST,
                         base::BindLambdaForTesting([&](EntryResult result3) {
                           ASSERT_THAT(result3.net_error(), IsOk());
                           entry3 = result3.ReleaseEntry();
                         }))
           .net_error(),
       IsError(net::ERR_IO_PENDING));
   run_loop.Run();
 }

 // Tests that recursive calls to OpenNextEntry from within its callback do not
 // starve normal operations, even when one of the iterated entries is already
 // active.
 TEST_F(SqlBackendImplTest, RecursiveOpenNextEntryWithActiveEntry) {
   auto backend = CreateBackendAndInit();

   // Create one entry and close it.
   TestEntryResultCompletionCallback cb_create;
   disk_cache::EntryResult create_result1 = cb_create.GetResult(
       backend->CreateEntry("key1", net::HIGHEST, cb_create.callback()));
   ASSERT_THAT(create_result1.net_error(), IsOk());
   create_result1.ReleaseEntry()->Close();

   // Create a second entry and keep it active.
   disk_cache::EntryResult create_result2 = cb_create.GetResult(
       backend->CreateEntry("key2", net::HIGHEST, cb_create.callback()));
   ASSERT_THAT(create_result2.net_error(), IsOk());
   auto* entry2_active = create_result2.ReleaseEntry();

   auto iter = backend->CreateIterator();

   base::RunLoop run_loop;
   Entry* entry3 = nullptr;

   bool key_1_found = false;
   bool key_2_found = false;

   // The first call to OpenNextEntry. Inside its callback, we'll trigger the
   // second call.
   ASSERT_THAT(
       iter->OpenNextEntry(base::BindLambdaForTesting([&](EntryResult result1) {
             ASSERT_THAT(result1.net_error(), IsOk());
             auto* entry1_iter = result1.ReleaseEntry();
             key_1_found = entry1_iter->GetKey() == "key1";
             key_2_found = entry1_iter->GetKey() == "key2";
             EXPECT_TRUE(key_1_found || key_2_found);
             if (key_2_found) {
               EXPECT_EQ(entry1_iter, entry2_active);
             }
             entry1_iter->Close();
             // Now, make the recursive call to OpenNextEntry.
             ASSERT_THAT(
                 iter->OpenNextEntry(
                         base::BindLambdaForTesting([&](EntryResult result2) {
                           ASSERT_THAT(result2.net_error(), IsOk());
                           // By this point, the CreateEntry for "key3" should
                           // have completed, proving that the normal operation
                           // was not starved.
                           CHECK(entry3);

                           auto* entry2_itr = result2.ReleaseEntry();
                           if (entry2_itr->GetKey() == "key3") {
                             EXPECT_EQ(entry2_itr, entry3);
                           } else {
                             if (key_1_found) {
                               EXPECT_EQ(entry2_itr->GetKey(), "key2");
                             } else {
                               EXPECT_EQ(entry2_itr->GetKey(), "key1");
                             }
                           }
                           entry2_itr->Close();
                           entry3->Close();
                           run_loop.Quit();
                         }))
                     .net_error(),
                 IsError(net::ERR_IO_PENDING));
           }))
           .net_error(),
       IsError(net::ERR_IO_PENDING));

   // While the first OpenNextEntry is in flight, post a normal operation to
   // create a third entry.
   ASSERT_THAT(
       backend
           ->CreateEntry("key3", net::HIGHEST,
                         base::BindLambdaForTesting([&](EntryResult result3) {
                           ASSERT_THAT(result3.net_error(), IsOk());
                           entry3 = result3.ReleaseEntry();
                         }))
           .net_error(),
       IsError(net::ERR_IO_PENDING));
   run_loop.Run();

   // Close the initially active entry.
   entry2_active->Close();
 }

 // Tests that if a pending ReadData operation is aborted (e.g., due to backend
 // destruction), the callback is invoked with net::ERR_ABORTED.
 TEST_F(SqlBackendImplTest, AbortPendingReadData) {
   auto backend = CreateBackendAndInit();

   // Create an entry.
   TestEntryResultCompletionCallback create_cb;
   disk_cache::EntryResult create_result = create_cb.GetResult(
       backend->CreateEntry("key", net::HIGHEST, create_cb.callback()));
   ASSERT_THAT(create_result.net_error(), IsOk());
   auto* entry = create_result.ReleaseEntry();

   // Write some data to stream 1 so that a subsequent read will be pending.
   const std::string kBodyData = "body_data";
   auto write_buffer = base::MakeRefCounted<net::StringIOBuffer>(kBodyData);
   net::TestCompletionCallback write_cb;
   int write_rv =
       entry->WriteData(1, 0, write_buffer.get(), write_buffer->size(),
                        write_cb.callback(), false);
   ASSERT_EQ(write_cb.GetResult(write_rv),
             static_cast<int>(write_buffer->size()));

   // Initiate a ReadData operation, which will be pending.
   auto read_buffer = base::MakeRefCounted<net::IOBufferWithSize>(10);
   base::test::TestFuture<int> read_future;
   int rv = entry->ReadData(1, 0, read_buffer.get(), read_buffer->size(),
                            read_future.GetCallback());
   ASSERT_THAT(rv, IsError(net::ERR_IO_PENDING));

   // Destroy the backend while the read is in flight.
   backend.reset();

   // The callback should be aborted.
   EXPECT_EQ(read_future.Get(), net::ERR_ABORTED);

   entry->Close();
 }

 // Tests that if a pending WriteData operation is aborted (e.g., due to backend
 // destruction), the callback is invoked with net::ERR_ABORTED.
 TEST_F(SqlBackendImplTest, AbortPendingWriteData) {
   base::test::ScopedFeatureList feature_list;
   feature_list.InitAndEnableFeatureWithParameters(
       net::features::kDiskCacheBackendExperiment,
       {{net::features::kSqlDiskCacheMaxWriteBufferTotalSize.name, "0"}});

   auto backend = CreateBackendAndInit();

   // Create an entry.
   TestEntryResultCompletionCallback create_cb;
   disk_cache::EntryResult create_result = create_cb.GetResult(
       backend->CreateEntry("key", net::HIGHEST, create_cb.callback()));
   ASSERT_THAT(create_result.net_error(), IsOk());
   auto* entry = create_result.ReleaseEntry();

   backend->RunUntilAllTasksCompleteForTest();

   // Initiate a WriteData operation, which will be pending.
   auto write_buffer = base::MakeRefCounted<net::StringIOBuffer>("data");
   base::test::TestFuture<int> write_future;
   int rv = entry->WriteData(1, 0, write_buffer.get(), write_buffer->size(),
                             write_future.GetCallback(), false);
   ASSERT_THAT(rv, write_buffer->size());

   auto task_runners = backend->GetBackgroundTaskRunnersForTest();

   // Destroy the backend while the write is in flight.
   backend.reset();

   auto db_handle = static_cast<SqlEntryImpl*>(entry)->db_handle();
   while (!db_handle->GetError().has_value()) {
     FlushQueueInTaskRunners(task_runners);
   }

   // The db_handle should have been set to aborted.
   EXPECT_EQ(db_handle->GetError(), SqlPersistentStore::Error::kAborted);

   entry->Close();
 }

 // Tests that if a pending GetAvailableRange operation is aborted (e.g., due to
 // backend destruction), the callback is invoked with net::ERR_ABORTED.
 TEST_F(SqlBackendImplTest, AbortPendingGetAvailableRange) {
   auto backend = CreateBackendAndInit();

   // Create an entry.
   TestEntryResultCompletionCallback create_cb;
   disk_cache::EntryResult create_result = create_cb.GetResult(
       backend->CreateEntry("key", net::HIGHEST, create_cb.callback()));
   ASSERT_THAT(create_result.net_error(), IsOk());
   auto* entry = create_result.ReleaseEntry();

   // Initiate a GetAvailableRange operation, which will be pending.
   base::test::TestFuture<const RangeResult&> range_future;
   RangeResult result =
       entry->GetAvailableRange(0, 100, range_future.GetCallback());
   ASSERT_THAT(result.net_error, IsError(net::ERR_IO_PENDING));

   // Destroy the backend while the operation is in flight.
   backend.reset();

   // The callback should be aborted.
   const RangeResult& aborted_result = range_future.Get();
   EXPECT_THAT(aborted_result.net_error, IsError(net::ERR_ABORTED));

   entry->Close();
 }

 TEST_F(SqlBackendImplTest, DoomedEntriesCleanup) {
   // 1. Create a backend and add three entries with data.
   auto backend = CreateBackendAndInit();
   auto task_runners = backend->GetBackgroundTaskRunnersForTest();

   const std::string kKey1 = "key1";
   const std::string kKey2 = "key2";
   const std::string kKey3 = "key3";
   const std::string kData = "some data";

   auto* entry1 = CreateEntryAndWriteData(backend.get(), kKey1, kData);
   auto* entry2 = CreateEntryAndWriteData(backend.get(), kKey2, kData);
   auto* entry3 = CreateEntryAndWriteData(backend.get(), kKey3, kData);
   WaitUntilInitialized(*backend,
                        static_cast<SqlEntryImpl*>(entry3)->db_handle());
   auto res_id =
       static_cast<SqlEntryImpl*>(entry3)->db_handle()->GetResId().value();
   entry1->Close();
   entry2->Close();
   entry3->Close();

   backend.reset();

   FlushQueueInTaskRunners(task_runners);

   // 2. Open the database directly via SqlPersistentStore and doom the third
   // entry.
   {
     SqlAsyncTaskManager async_task_manager;
     auto store = std::make_unique<SqlPersistentStore>(
         temp_dir_.GetPath(), kDefaultMaxBytes, net::CacheType::DISK_CACHE,
         task_runners, async_task_manager, /*cleanup_tracker=*/nullptr);

     base::test::TestFuture<disk_cache::SqlPersistentStore::Error> future_init;
     store->Initialize(future_init.GetCallback());
     ASSERT_EQ(future_init.Get(), disk_cache::SqlPersistentStore::Error::kOk);

     base::test::TestFuture<SqlPersistentStore::Error> future_doom;
     store->DoomEntry(CacheEntryKey(kKey3), res_id,
                      /*accept_index_mismatch=*/false,
                      future_doom.GetCallback());
     EXPECT_EQ(future_doom.Get(), SqlPersistentStore::Error::kOk);

     store.reset();
   }

   FlushQueueInTaskRunners(task_runners);

   // 3. Recreate the backend
   backend = CreateBackendAndInit();
   EXPECT_TRUE(LoadInMemoryIndex(*backend));

   // 4. Open and doom the first and the second entries and let them as active.
   TestEntryResultCompletionCallback cb_open1;
   disk_cache::EntryResult open_result1 = cb_open1.GetResult(
       backend->OpenEntry(kKey1, net::HIGHEST, cb_open1.callback()));
   entry1 = open_result1.ReleaseEntry();
   entry1->Doom();

   TestEntryResultCompletionCallback cb_open2;
   disk_cache::EntryResult open_result2 = cb_open2.GetResult(
       backend->OpenEntry(kKey2, net::HIGHEST, cb_open2.callback()));
   entry2 = open_result2.ReleaseEntry();
   entry2->Doom();

   base::HistogramTester histogram_tester;
   backend->OnBrowserIdle();

   // Flush the queue to ensure that cleanup task is completed.
   backend->RunUntilAllTasksCompleteForTest();

   // Verify that `DeleteDoomedEntriesCount` UMA was recorded in the histogram.
   histogram_tester.ExpectUniqueSample(
       "Net.SqlDiskCache.DeleteDoomedEntriesCount", 1, 1);

   // 5. Verify that the data can still be read from the doomed entry.
   ReadAndVerifyData(entry1, kData);
   ReadAndVerifyData(entry2, kData);

   entry1->Close();
   entry2->Close();
 }

 TEST_F(SqlBackendImplTest, SpeculativeCreateEntry) {
   auto backend = CreateBackendAndInit();
   EXPECT_TRUE(LoadInMemoryIndex(*backend));

   const std::string kKey = "my-key";

   // Create an entry. This should return immediately with a speculatively
   // created entry.
   TestEntryResultCompletionCallback cb_create;
   disk_cache::EntryResult create_result =
       backend->CreateEntry(kKey, net::HIGHEST, cb_create.callback());
   ASSERT_THAT(create_result.net_error(), IsOk());
   auto* entry = create_result.ReleaseEntry();
   ASSERT_TRUE(entry);

   auto db_handle = static_cast<SqlEntryImpl*>(entry)->db_handle();

   // The db_handle should be in the initial state
   EXPECT_TRUE(db_handle->IsInitialState());

   // Even after flushing all DB tasks, it should still be in the initial state.
   backend->RunUntilAllTasksCompleteForTest();
   EXPECT_TRUE(db_handle->IsInitialState());

   entry->Close();

   // Once closed, the DB side entry creation process starts.
   EXPECT_TRUE(db_handle->IsCreatingState());

   // After flushing all DB tasks, it enters the finished (created) state and the
   // ResID is set.
   backend->RunUntilAllTasksCompleteForTest();
   EXPECT_TRUE(db_handle->IsFinished());
   // Now the res_id should be available.
   EXPECT_TRUE(db_handle->GetResId().has_value());

   // The entry must be available
   TestEntryResultCompletionCallback cb_open;
   disk_cache::EntryResult open_result = cb_open.GetResult(
       backend->OpenEntry(kKey, net::HIGHEST, cb_open.callback()));
   ASSERT_THAT(open_result.net_error(), IsOk());
   entry = open_result.ReleaseEntry();
   ASSERT_TRUE(entry);
   entry->Close();
 }

 TEST_F(SqlBackendImplTest, SpeculativeCreateEntryDoomClose) {
   auto backend = CreateBackendAndInit();
   EXPECT_TRUE(LoadInMemoryIndex(*backend));
   const std::string kKey = "my-key";

   TestEntryResultCompletionCallback cb_create;
   disk_cache::EntryResult create_result =
       backend->CreateEntry(kKey, net::HIGHEST, cb_create.callback());
   ASSERT_THAT(create_result.net_error(), IsOk());
   auto* entry = create_result.ReleaseEntry();
   ASSERT_TRUE(entry);
   auto db_handle = static_cast<SqlEntryImpl*>(entry)->db_handle();

   entry->Doom();
   entry->Close();

   // Verify that the entry is gone.
   TestEntryResultCompletionCallback cb_open;
   disk_cache::EntryResult open_result = cb_open.GetResult(
       backend->OpenEntry(kKey, net::HIGHEST, cb_open.callback()));
   EXPECT_THAT(open_result.net_error(), IsError(net::ERR_FAILED));

   EXPECT_TRUE(db_handle->IsInitialState());
 }

 TEST_F(SqlBackendImplTest, SpeculativeCreateEntryClose) {
   auto backend = CreateBackendAndInit();
   EXPECT_TRUE(LoadInMemoryIndex(*backend));
   const std::string kKey = "my-key";

   TestEntryResultCompletionCallback cb_create;
   disk_cache::EntryResult create_result =
       backend->CreateEntry(kKey, net::HIGHEST, cb_create.callback());
   ASSERT_THAT(create_result.net_error(), IsOk());
   auto* entry = create_result.ReleaseEntry();
   ASSERT_TRUE(entry);
   auto db_handle = static_cast<SqlEntryImpl*>(entry)->db_handle();

   entry->Close();

   TestEntryResultCompletionCallback cb_open;
   disk_cache::EntryResult open_result = cb_open.GetResult(
       backend->OpenEntry(kKey, net::HIGHEST, cb_open.callback()));
   ASSERT_THAT(open_result.net_error(), IsOk());
   entry = open_result.ReleaseEntry();
   ASSERT_TRUE(entry);
   entry->Close();

   // The res_id should be available.
   EXPECT_TRUE(db_handle->GetResId().has_value());
 }

 TEST_F(SqlBackendImplTest, SpeculativeCreateEntryAndRead) {
   auto backend = CreateBackendAndInit();
   EXPECT_TRUE(LoadInMemoryIndex(*backend));
   const std::string kKey = "my-key";

   TestEntryResultCompletionCallback cb_create;
   disk_cache::EntryResult create_result =
       backend->CreateEntry(kKey, net::HIGHEST, cb_create.callback());
   ASSERT_THAT(create_result.net_error(), IsOk());
   auto* entry = create_result.ReleaseEntry();
   ASSERT_TRUE(entry);
   auto db_handle = static_cast<SqlEntryImpl*>(entry)->db_handle();

   auto read_buffer = base::MakeRefCounted<net::IOBufferWithSize>(10);
   EXPECT_EQ(entry->ReadData(1, 0, read_buffer.get(), read_buffer->size(),
                             base::DoNothing()),
             0);

   EXPECT_TRUE(db_handle->IsInitialState());
   entry->Close();
   EXPECT_TRUE(db_handle->IsCreatingState());
   backend->RunUntilAllTasksCompleteForTest();
   // The res_id should be available now.
   EXPECT_TRUE(db_handle->GetResId().has_value());
 }

 TEST_F(SqlBackendImplTest, SpeculativeCreateEntryWriteWithinBufferLimit) {
   auto backend = CreateBackendAndInit();
   EXPECT_TRUE(LoadInMemoryIndex(*backend));
   const std::string kKey = "my-key";
   const std::string kData = "some data";

   TestEntryResultCompletionCallback cb_create;
   disk_cache::EntryResult create_result =
       backend->CreateEntry(kKey, net::HIGHEST, cb_create.callback());
   ASSERT_THAT(create_result.net_error(), IsOk());
   auto* entry = create_result.ReleaseEntry();
   ASSERT_TRUE(entry);
   auto db_handle = static_cast<SqlEntryImpl*>(entry)->db_handle();

   net::TestCompletionCallback write_cb;
   auto write_buffer = base::MakeRefCounted<net::StringIOBuffer>(kData);
   ASSERT_LT(write_buffer->size(),
             net::features::kSqlDiskCacheMaxWriteBufferSizePerEntry.Get());
   EXPECT_EQ(write_cb.GetResult(entry->WriteData(1, 0, write_buffer.get(),
                                                 write_buffer->size(),
                                                 write_cb.callback(), false)),
             static_cast<int>(write_buffer->size()));

   // If the written data is less than kSqlDiskCacheMaxWriteBufferSizePerEntry,
   // the DB side write process only starts when the entry is closed.
   EXPECT_TRUE(db_handle->IsInitialState());
   entry->Close();
   EXPECT_TRUE(db_handle->IsCreatingState());

   TestEntryResultCompletionCallback cb_open;
   disk_cache::EntryResult open_result = cb_open.GetResult(
       backend->OpenEntry(kKey, net::HIGHEST, cb_open.callback()));
   ASSERT_THAT(open_result.net_error(), IsOk());

   // The res_id should be available.
   EXPECT_TRUE(db_handle->GetResId().has_value());

   entry = open_result.ReleaseEntry();
   ASSERT_TRUE(entry);

   auto read_buffer = base::MakeRefCounted<net::IOBufferWithSize>(10);

   base::test::TestFuture<int> read_future;
   int rv = entry->ReadData(1, 0, read_buffer.get(), read_buffer->size(),
                            read_future.GetCallback());
   ASSERT_THAT(rv, IsError(net::ERR_IO_PENDING));
   ASSERT_EQ(read_future.Get(), write_buffer->size());

   EXPECT_EQ(std::string_view(read_buffer->data(), kData.size()), kData);
   entry->Close();
 }

 TEST_F(SqlBackendImplTest,
        SpeculativeCreateEntryWriteWithinBufferLimitAndDoom) {
   auto backend = CreateBackendAndInit();
   EXPECT_TRUE(LoadInMemoryIndex(*backend));
   const std::string kKey = "my-key";
   const std::string kData = "some data";

   TestEntryResultCompletionCallback cb_create;
   disk_cache::EntryResult create_result =
       backend->CreateEntry(kKey, net::HIGHEST, cb_create.callback());
   ASSERT_THAT(create_result.net_error(), IsOk());
   auto* entry = create_result.ReleaseEntry();
   ASSERT_TRUE(entry);
   auto db_handle = static_cast<SqlEntryImpl*>(entry)->db_handle();

   net::TestCompletionCallback write_cb;
   auto write_buffer = base::MakeRefCounted<net::StringIOBuffer>(kData);
   ASSERT_LT(write_buffer->size(),
             net::features::kSqlDiskCacheMaxWriteBufferSizePerEntry.Get());
   EXPECT_EQ(write_cb.GetResult(entry->WriteData(1, 0, write_buffer.get(),
                                                 write_buffer->size(),
                                                 write_cb.callback(), false)),
             static_cast<int>(write_buffer->size()));

   entry->Doom();
   entry->Close();

   // Verify that the entry is gone.
   TestEntryResultCompletionCallback cb_open;
   disk_cache::EntryResult open_result = cb_open.GetResult(
       backend->OpenEntry(kKey, net::HIGHEST, cb_open.callback()));
   EXPECT_THAT(open_result.net_error(), IsError(net::ERR_FAILED));

   // If the written data is less than kSqlDiskCacheMaxWriteBufferSizePerEntry,
   // the DB side write process does not start if the entry is doomed before
   // being closed.
   EXPECT_TRUE(db_handle->IsInitialState());
 }

 TEST_F(SqlBackendImplTest, SpeculativeCreateEntryOptimisticWriteOnBufferFlush) {
   base::test::ScopedFeatureList feature_list;
   feature_list.InitAndEnableFeatureWithParameters(
       net::features::kDiskCacheBackendExperiment,
       {{net::features::kSqlDiskCacheMaxWriteBufferSizePerEntry.name, "10"}});
   auto backend = CreateBackendAndInit();
   EXPECT_TRUE(LoadInMemoryIndex(*backend));

   const std::string kKey = "my-key";

   // Create an entry. This should return immediately with a speculatively
   // created entry.
   TestEntryResultCompletionCallback cb_create;
   disk_cache::EntryResult create_result =
       backend->CreateEntry(kKey, net::HIGHEST, cb_create.callback());
   ASSERT_THAT(create_result.net_error(), IsOk());
   auto* entry = create_result.ReleaseEntry();
   ASSERT_TRUE(entry);
   auto db_handle = static_cast<SqlEntryImpl*>(entry)->db_handle();

   const std::string k1ByteData = "X";
   auto buffer = base::MakeRefCounted<net::StringIOBuffer>(k1ByteData);

   // Write 10 bytes. These are all buffered in memory within the entry.
   for (int64_t i = 0; i < 10; ++i) {
     EXPECT_EQ(entry->WriteData(1, i, buffer.get(), buffer->size(),
                                base::DoNothing(), false),
               1);
   }
   // Even after flushing all DB tasks, it should still be in the initial state.
   backend->RunUntilAllTasksCompleteForTest();
   EXPECT_TRUE(db_handle->IsInitialState());

   // Writing one more byte triggers the buffered content to be passed to
   // SqlBackendImpl, starting the optimistic write process. Then, `db_handle`
   // enters the creating state.
   EXPECT_EQ(entry->WriteData(1, 10, buffer.get(), buffer->size(),
                              base::DoNothing(), false),
             1);
   EXPECT_TRUE(db_handle->IsCreatingState());

   // After flushing all DB tasks, it enters the finished (created) state and the
   // ResID is set.
   backend->RunUntilAllTasksCompleteForTest();
   EXPECT_TRUE(db_handle->IsFinished());
   EXPECT_TRUE(db_handle->GetResId().has_value());

   // Doom the entry.
   entry->Doom();
   entry->Close();

   // Verify that the entry is gone.
   TestEntryResultCompletionCallback cb_open;
   disk_cache::EntryResult open_result = cb_open.GetResult(
       backend->OpenEntry(kKey, net::HIGHEST, cb_open.callback()));
   EXPECT_THAT(open_result.net_error(), IsError(net::ERR_FAILED));
 }

 TEST_F(SqlBackendImplTest, SpeculativeCreateEntryNonOptmisticWrite) {
   base::test::ScopedFeatureList feature_list;
   feature_list.InitAndEnableFeatureWithParameters(
       net::features::kDiskCacheBackendExperiment,
       {{net::features::kSqlDiskCacheOptimisticWriteBufferSize.name, "10"},
        {net::features::kSqlDiskCacheMaxWriteBufferTotalSize.name, "10"}});
   auto backend = CreateBackendAndInit();
   const std::string kKey = "my-key";
   EXPECT_TRUE(LoadInMemoryIndex(*backend));
   TestEntryResultCompletionCallback cb;
   disk_cache::EntryResult entry_result =
       backend->CreateEntry(kKey, net::HIGHEST, cb.callback());
   ASSERT_THAT(entry_result.net_error(), IsOk());
   auto* entry = entry_result.ReleaseEntry();
   ASSERT_TRUE(entry);
   auto db_handle = static_cast<SqlEntryImpl*>(entry)->db_handle();

   // When WriteData is called with data larger than
   // kSqlDiskCacheMaxWriteBufferTotalSize, and
   // kSqlDiskCacheOptimisticWriteBufferSize, SqlBackendImpl starts the
   // non-optimistic write process, and the `db_handle` enters the creating
   // state.
   const std::string kData = "1234567890A";
   auto write_buffer = base::MakeRefCounted<net::StringIOBuffer>(kData);
   ASSERT_GT(write_buffer->size(),
             net::features::kSqlDiskCacheOptimisticWriteBufferSize.Get());
   ASSERT_GT(write_buffer->size(),
             net::features::kSqlDiskCacheMaxWriteBufferTotalSize.Get());
   EXPECT_TRUE(db_handle->IsInitialState());

   net::TestCompletionCallback write_cb;
   EXPECT_EQ(entry->WriteData(1, 0, write_buffer.get(), write_buffer->size(),
                              write_cb.callback(), false),
             net::ERR_IO_PENDING);
   EXPECT_TRUE(db_handle->IsCreatingState());
   EXPECT_EQ(write_cb.WaitForResult(), write_buffer->size());
   EXPECT_TRUE(db_handle->IsFinished());
   EXPECT_TRUE(db_handle->GetResId().has_value());
   entry->Close();

   TestEntryResultCompletionCallback cb_open;
   disk_cache::EntryResult open_result = cb_open.GetResult(
       backend->OpenEntry(kKey, net::HIGHEST, cb_open.callback()));
   ASSERT_THAT(open_result.net_error(), IsOk());

   entry = open_result.ReleaseEntry();
   ASSERT_TRUE(entry);

   auto read_buffer =
       base::MakeRefCounted<net::IOBufferWithSize>(kData.size() + 1);

   base::test::TestFuture<int> read_future;
   int rv = entry->ReadData(1, 0, read_buffer.get(), read_buffer->size(),
                            read_future.GetCallback());
   ASSERT_THAT(rv, IsError(net::ERR_IO_PENDING));
   ASSERT_EQ(read_future.Get(), write_buffer->size());

   EXPECT_EQ(std::string_view(read_buffer->data(), kData.size()), kData);
   entry->Close();
 }

 TEST_F(SqlBackendImplTest, SpeculativeCreateEntryWithDbFailure) {
   auto backend = CreateBackendAndInit();
   EXPECT_TRUE(LoadInMemoryIndex(*backend));
   backend->GetSqlStoreForTest()->SetSimulateDbFailureForTesting(true);
   const std::string kKey = "my-key";

   // Create an entry. This should return immediately with a speculatively
   // created entry.
   TestEntryResultCompletionCallback cb_create;
   disk_cache::EntryResult create_result =
       backend->CreateEntry(kKey, net::HIGHEST, cb_create.callback());
   ASSERT_THAT(create_result.net_error(), IsOk());
   auto* entry = create_result.ReleaseEntry();
   ASSERT_TRUE(entry);

   auto db_handle = static_cast<SqlEntryImpl*>(entry)->db_handle();

   // The db_handle should be in the initial state
   EXPECT_TRUE(db_handle->IsInitialState());

   entry->Close();

   // Once closed, the DB side entry creation process starts.
   EXPECT_TRUE(db_handle->IsCreatingState());
   backend->RunUntilAllTasksCompleteForTest();

   // After flushing all DB tasks, the db_handle should hold a kFailedForTesting
   // error.
   EXPECT_THAT(db_handle->GetError(),
               SqlPersistentStore::Error::kFailedForTesting);

   // 6. Verify that the entry is not found.
   TestEntryResultCompletionCallback cb_open;
   disk_cache::EntryResult open_result = cb_open.GetResult(
       backend->OpenEntry(kKey, net::HIGHEST, cb_open.callback()));
   EXPECT_THAT(open_result.net_error(), IsError(net::ERR_FAILED));
 }

 TEST_F(SqlBackendImplTest, SpeculativeCreateEntryDbFailureOnOptmisticWrite) {
   base::test::ScopedFeatureList feature_list;
   feature_list.InitAndEnableFeatureWithParameters(
       net::features::kDiskCacheBackendExperiment,
       {{net::features::kSqlDiskCacheOptimisticWriteBufferSize.name, "20"},
        {net::features::kSqlDiskCacheMaxWriteBufferTotalSize.name, "10"}});
   auto backend = CreateBackendAndInit();
   EXPECT_TRUE(LoadInMemoryIndex(*backend));
   backend->GetSqlStoreForTest()->SetSimulateDbFailureForTesting(true);
   TestEntryResultCompletionCallback cb;
   disk_cache::EntryResult entry_result =
       backend->CreateEntry("key", net::HIGHEST, cb.callback());
   ASSERT_THAT(entry_result.net_error(), IsOk());
   auto* entry = entry_result.ReleaseEntry();
   ASSERT_TRUE(entry);
   auto db_handle = static_cast<SqlEntryImpl*>(entry)->db_handle();

   // When WriteData is called with data larger than
   // kSqlDiskCacheMaxWriteBufferTotalSize, and smaller than
   // kSqlDiskCacheOptimisticWriteBufferSize, SqlBackendImpl starts the
   // optimistic write process, and the `db_handle` enters the creating state.
   auto write_buffer = base::MakeRefCounted<net::StringIOBuffer>("1234567890A");
   ASSERT_LE(write_buffer->size(),
             net::features::kSqlDiskCacheOptimisticWriteBufferSize.Get());
   ASSERT_GT(write_buffer->size(),
             net::features::kSqlDiskCacheMaxWriteBufferTotalSize.Get());
   EXPECT_TRUE(db_handle->IsInitialState());
   EXPECT_EQ(entry->WriteData(1, 0, write_buffer.get(), write_buffer->size(),
                              base::DoNothing(), false),
             write_buffer->size());
   EXPECT_TRUE(db_handle->IsCreatingState());

   // The second write exceeds the optimistic write limit, so it becomes async.
   ASSERT_GT(write_buffer->size() * 2,
             net::features::kSqlDiskCacheOptimisticWriteBufferSize.Get());
   net::TestCompletionCallback write_cb;
   EXPECT_EQ(entry->WriteData(1, write_buffer->size(), write_buffer.get(),
                              write_buffer->size(), write_cb.callback(), false),
             net::ERR_IO_PENDING);

   net::TestCompletionCallback read_cb;
   auto read_buffer = base::MakeRefCounted<net::IOBufferWithSize>(10);
   EXPECT_EQ(entry->ReadData(1, 0, read_buffer.get(), read_buffer->size(),
                             read_cb.callback()),
             net::ERR_IO_PENDING);

   base::test::TestFuture<const RangeResult&> range_future;
   EXPECT_EQ(
       entry->GetAvailableRange(0, 10, range_future.GetCallback()).net_error,
       net::ERR_IO_PENDING);

   EXPECT_THAT(write_cb.WaitForResult(), IsError(net::ERR_FAILED));
   EXPECT_THAT(read_cb.WaitForResult(), IsError(net::ERR_FAILED));
   EXPECT_THAT(range_future.Get().net_error, IsError(net::ERR_FAILED));

   // After finishing all DB tasks, the db_handle should hold a kFailedForTesting
   // error.
   EXPECT_THAT(db_handle->GetError(),
               SqlPersistentStore::Error::kFailedForTesting);

   entry->Close();
 }

 TEST_F(SqlBackendImplTest, SpeculativeCreateEntryDbFailureOnNonOptmisticWrite) {
   base::test::ScopedFeatureList feature_list;
   feature_list.InitAndEnableFeatureWithParameters(
       net::features::kDiskCacheBackendExperiment,
       {{net::features::kSqlDiskCacheOptimisticWriteBufferSize.name, "10"},
        {net::features::kSqlDiskCacheMaxWriteBufferTotalSize.name, "10"}});
   auto backend = CreateBackendAndInit();
   EXPECT_TRUE(LoadInMemoryIndex(*backend));
   backend->GetSqlStoreForTest()->SetSimulateDbFailureForTesting(true);
   TestEntryResultCompletionCallback cb;
   disk_cache::EntryResult entry_result =
       backend->CreateEntry("key", net::HIGHEST, cb.callback());
   ASSERT_THAT(entry_result.net_error(), IsOk());
   auto* entry = entry_result.ReleaseEntry();
   ASSERT_TRUE(entry);
   auto db_handle = static_cast<SqlEntryImpl*>(entry)->db_handle();

   // When WriteData is called with data larger than
   // kSqlDiskCacheMaxWriteBufferTotalSize, and
   // kSqlDiskCacheOptimisticWriteBufferSize, SqlBackendImpl starts the
   // non-optimistic write process, and the `db_handle` enters the creating
   // state.
   auto write_buffer = base::MakeRefCounted<net::StringIOBuffer>("1234567890A");
   ASSERT_GT(write_buffer->size(),
             net::features::kSqlDiskCacheOptimisticWriteBufferSize.Get());
   ASSERT_GT(write_buffer->size(),
             net::features::kSqlDiskCacheMaxWriteBufferTotalSize.Get());
   EXPECT_TRUE(db_handle->IsInitialState());

   net::TestCompletionCallback write_cb;
   EXPECT_EQ(entry->WriteData(1, 0, write_buffer.get(), write_buffer->size(),
                              write_cb.callback(), false),
             net::ERR_IO_PENDING);
   EXPECT_TRUE(db_handle->IsCreatingState());
   EXPECT_EQ(write_cb.WaitForResult(), net::ERR_FAILED);
   EXPECT_THAT(db_handle->GetError(),
               SqlPersistentStore::Error::kFailedForTesting);
   entry->Close();
 }

 TEST_F(SqlBackendImplTest, SpeculativeCreateEntryDbFailureDoom) {
   base::test::ScopedFeatureList feature_list;
   feature_list.InitAndEnableFeatureWithParameters(
       net::features::kDiskCacheBackendExperiment,
       {{net::features::kSqlDiskCacheMaxWriteBufferTotalSize.name, "10"}});
   auto backend = CreateBackendAndInit();
   EXPECT_TRUE(LoadInMemoryIndex(*backend));
   backend->GetSqlStoreForTest()->SetSimulateDbFailureForTesting(true);
   TestEntryResultCompletionCallback cb;
   disk_cache::EntryResult entry_result =
       backend->CreateEntry("key", net::HIGHEST, cb.callback());
   ASSERT_THAT(entry_result.net_error(), IsOk());
   auto* entry = entry_result.ReleaseEntry();
   ASSERT_TRUE(entry);
   auto db_handle = static_cast<SqlEntryImpl*>(entry)->db_handle();

   // When WriteData is called with data larger than
   // kSqlDiskCacheMaxWriteBufferTotalSize, SqlBackendImpl starts the optimistic
   // write process, and the `db_handle` enters the creating state.
   auto write_buffer = base::MakeRefCounted<net::StringIOBuffer>("1234567890A");
   ASSERT_GT(write_buffer->size(),
             net::features::kSqlDiskCacheMaxWriteBufferTotalSize.Get());
   EXPECT_TRUE(db_handle->IsInitialState());
   EXPECT_EQ(
       entry->WriteData(1, 0, write_buffer.get(), write_buffer->size(),
                        base::BindOnce([](int rv) { NOTREACHED(); }), false),
       write_buffer->size());
   EXPECT_TRUE(db_handle->IsCreatingState());
   // After flushing all DB tasks, the db_handle should hold a kFailedForTesting
   // error.
   backend->RunUntilAllTasksCompleteForTest();
   EXPECT_THAT(db_handle->GetError(),
               SqlPersistentStore::Error::kFailedForTesting);

   entry->Doom();
   EXPECT_TRUE(static_cast<SqlEntryImpl*>(entry)->doomed());
   entry->Close();
   entry = nullptr;

   TestEntryResultCompletionCallback cb_open;
   disk_cache::EntryResult open_result = cb_open.GetResult(
       backend->OpenEntry("key", net::HIGHEST, cb_open.callback()));
   EXPECT_THAT(open_result.net_error(), IsError(net::ERR_FAILED));
 }

 TEST_F(SqlBackendImplTest, OptimisticWriteBufferSize) {
   base::test::ScopedFeatureList feature_list;
   feature_list.InitAndEnableFeatureWithParameters(
       net::features::kDiskCacheBackendExperiment,
       {{net::features::kSqlDiskCacheOptimisticWriteBufferSize.name, "100"},
        {net::features::kSqlDiskCacheMaxWriteBufferTotalSize.name, "0"}});

   auto backend = CreateBackendAndInit();
   EXPECT_TRUE(LoadInMemoryIndex(*backend));
   TestEntryResultCompletionCallback cb;
   disk_cache::EntryResult entry_result =
       backend->CreateEntry("key", net::HIGHEST, cb.callback());
   ASSERT_THAT(entry_result.net_error(), IsOk());
   auto* entry = entry_result.ReleaseEntry();
   ASSERT_TRUE(entry);

   // First write is smaller than the buffer size, should be optimistic.
   auto write_buffer1 = base::MakeRefCounted<net::StringIOBuffer>("data1");
   EXPECT_EQ(entry->WriteData(1, 0, write_buffer1.get(), write_buffer1->size(),
                              base::DoNothing(), false),
             static_cast<int>(write_buffer1->size()));
   EXPECT_EQ(backend->GetOptimisticWriteBufferTotalSizeForTesting(),
             write_buffer1->size());

   // Second write exceeds the buffer size, should be pending.
   auto write_buffer2 =
       base::MakeRefCounted<net::StringIOBuffer>(std::string(100, 'a'));
   net::TestCompletionCallback write_cb;
   EXPECT_EQ(entry->WriteData(1, write_buffer1->size(), write_buffer2.get(),
                              write_buffer2->size(), write_cb.callback(), false),
             net::ERR_IO_PENDING);
   EXPECT_EQ(backend->GetOptimisticWriteBufferTotalSizeForTesting(),
             write_buffer1->size());

   EXPECT_EQ(write_cb.WaitForResult(), static_cast<int>(write_buffer2->size()));
   EXPECT_EQ(backend->GetOptimisticWriteBufferTotalSizeForTesting(), 0);

   entry->Close();
 }

 TEST_F(SqlBackendImplTest, OptimisticWriteBufferLifecycle) {
   base::test::ScopedFeatureList feature_list;
   feature_list.InitAndEnableFeatureWithParameters(
       net::features::kDiskCacheBackendExperiment,
       {{net::features::kSqlDiskCacheOptimisticWriteBufferSize.name, "100"},
        {net::features::kSqlDiskCacheMaxWriteBufferTotalSize.name, "0"}});

   auto backend = CreateBackendAndInit();
   EXPECT_TRUE(LoadInMemoryIndex(*backend));
   TestEntryResultCompletionCallback cb;
   disk_cache::EntryResult entry_result =
       backend->CreateEntry("key", net::HIGHEST, cb.callback());
   ASSERT_THAT(entry_result.net_error(), IsOk());
   auto* entry = entry_result.ReleaseEntry();
   ASSERT_TRUE(entry);

   // This write should be optimistic.
   auto write_buffer1 =
       base::MakeRefCounted<net::StringIOBuffer>(std::string(50, 'a'));
   EXPECT_EQ(entry->WriteData(1, 0, write_buffer1.get(), write_buffer1->size(),
                              base::DoNothing(), false),
             static_cast<int>(write_buffer1->size()));
   EXPECT_EQ(backend->GetOptimisticWriteBufferTotalSizeForTesting(),
             write_buffer1->size());

   // This write should also be optimistic, filling the buffer.
   auto write_buffer2 =
       base::MakeRefCounted<net::StringIOBuffer>(std::string(50, 'b'));
   EXPECT_EQ(entry->WriteData(1, 50, write_buffer2.get(), write_buffer2->size(),
                              base::DoNothing(), false),
             static_cast<int>(write_buffer2->size()));
   EXPECT_EQ(backend->GetOptimisticWriteBufferTotalSizeForTesting(),
             write_buffer1->size() + write_buffer2->size());

   // This write should be pending as the buffer is full.
   auto write_buffer3 = base::MakeRefCounted<net::StringIOBuffer>("c");
   net::TestCompletionCallback write_cb3;
   EXPECT_EQ(entry->WriteData(1, 100, write_buffer3.get(), write_buffer3->size(),
                              write_cb3.callback(), false),
             net::ERR_IO_PENDING);
   EXPECT_EQ(backend->GetOptimisticWriteBufferTotalSizeForTesting(),
             write_buffer1->size() + write_buffer2->size());

   // Flush the queue. This will ensure the first two optimistic writes complete
   // on the background thread, which will free up the buffer and allow the
   // pending write to proceed.
   backend->RunUntilAllTasksCompleteForTest();

   EXPECT_EQ(backend->GetOptimisticWriteBufferTotalSizeForTesting(), 0);

   // Now that the queue is flushed, the pending write should have completed.
   EXPECT_EQ(write_cb3.WaitForResult(), static_cast<int>(write_buffer3->size()));

   EXPECT_EQ(backend->GetOptimisticWriteBufferTotalSizeForTesting(), 0);
   // The buffer should be free again, so this write should be optimistic.
   auto write_buffer4 =
       base::MakeRefCounted<net::StringIOBuffer>(std::string(50, 'd'));
   EXPECT_EQ(entry->WriteData(1, 101, write_buffer4.get(), write_buffer4->size(),
                              base::DoNothing(), false),
             static_cast<int>(write_buffer4->size()));
   EXPECT_EQ(backend->GetOptimisticWriteBufferTotalSizeForTesting(),
             write_buffer4->size());

   entry->Close();

   backend->RunUntilAllTasksCompleteForTest();

   EXPECT_EQ(backend->GetOptimisticWriteBufferTotalSizeForTesting(), 0);
 }

 TEST_F(SqlBackendImplTest, OptimisticWriteFailure) {
   base::test::ScopedFeatureList feature_list;
   feature_list.InitAndEnableFeatureWithParameters(
       net::features::kDiskCacheBackendExperiment,
       {{net::features::kSqlDiskCacheOptimisticWriteBufferSize.name, "100"},
        {net::features::kSqlDiskCacheMaxWriteBufferTotalSize.name, "0"}});

   auto backend = CreateBackendAndInit();
   EXPECT_TRUE(LoadInMemoryIndex(*backend));
   const std::string kKey = "my-key";
   const std::string kInitialData = "initial data";

   // 1. Create an entry with some data.
   auto* entry = CreateEntryAndWriteData(backend.get(), kKey, kInitialData);
   entry->Close();

   // 2. Re-open the entry.
   TestEntryResultCompletionCallback open_cb;
   disk_cache::EntryResult open_result = open_cb.GetResult(
       backend->OpenEntry(kKey, net::HIGHEST, open_cb.callback()));
   ASSERT_THAT(open_result.net_error(), IsOk());
   entry = open_result.ReleaseEntry();
   auto* sql_entry = static_cast<SqlEntryImpl*>(entry);

   // 3. Simulate a database failure for subsequent operations.
   backend->GetSqlStoreForTest()->SetSimulateDbFailureForTesting(true);

   // 4. Perform an optimistic write, which should fail in the background.
   auto write_buffer = base::MakeRefCounted<net::StringIOBuffer>("new data");
   EXPECT_EQ(entry->WriteData(1, kInitialData.size(), write_buffer.get(),
                              write_buffer->size(), base::DoNothing(), false),
             static_cast<int>(write_buffer->size()));
   EXPECT_EQ(backend->GetOptimisticWriteBufferTotalSizeForTesting(),
             write_buffer->size());

   // 5. Disable failure simulation.
   backend->GetSqlStoreForTest()->SetSimulateDbFailureForTesting(false);

   // 6. Wait for the background write to fail and update the entry's state.
   backend->RunUntilAllTasksCompleteForTest();

   // 7. Verify that the entry is now in an error state.
   EXPECT_TRUE(sql_entry->db_handle()->IsFinished());
   EXPECT_THAT(sql_entry->db_handle()->GetError(),
               SqlPersistentStore::Error::kFailedForTesting);
   EXPECT_EQ(backend->GetOptimisticWriteBufferTotalSizeForTesting(), 0);

   // 8. Subsequent writes should fail immediately.
   EXPECT_EQ(entry->WriteData(1, 0, write_buffer.get(), write_buffer->size(),
                              base::DoNothing(), false),
             net::ERR_FAILED);
   EXPECT_EQ(backend->GetOptimisticWriteBufferTotalSizeForTesting(), 0);

   entry->Close();

   // 9. Since the entry should have been deleted from storage, OpenEntry will
   //    fail.
   TestEntryResultCompletionCallback open_cb2;
   open_result = open_cb2.GetResult(
       backend->OpenEntry(kKey, net::HIGHEST, open_cb2.callback()));
   ASSERT_THAT(open_result.net_error(), IsError(net::ERR_FAILED));
 }

 TEST_F(SqlBackendImplTest, IdleTimeEviction) {
   const int64_t kMaxBytes = 100000;
   const int64_t kIdleTimeHighWatermark =
       kMaxBytes * kSqlBackendIdleTimeEvictionHighWaterMarkPermille /
       1000;  // 92500
   auto buffer =
       base::MakeRefCounted<net::StringIOBuffer>(std::string(1000, 'x'));

   auto backend = CreateBackendAndInit(kMaxBytes);

   // Add entries to be above idle time watermark.
   int i = 0;
   while (GetSizeOfAllEntries(*backend) <= kIdleTimeHighWatermark) {
     TestEntryResultCompletionCallback cb;
     EntryResult result = cb.GetResult(backend->CreateEntry(
         base::StringPrintf("key%d", i++), net::HIGHEST, cb.callback()));
     ASSERT_THAT(result.net_error(), IsOk());
     auto* entry = result.ReleaseEntry();
     net::TestCompletionCallback write_cb;
     EXPECT_EQ(
         write_cb.GetResult(entry->WriteData(1, 0, buffer.get(), buffer->size(),
                                             write_cb.callback(), false)),
         buffer->size());
     entry->Close();
     backend->RunUntilAllTasksCompleteForTest();
   }

   auto test_helper = PerformanceScenarioTestHelper::Create();
   // Set the state to idle.
   test_helper->SetLoadingScenario(ScenarioScope::kGlobal,
                                   LoadingScenario::kNoPageLoading);
   test_helper->SetInputScenario(ScenarioScope::kGlobal,
                                 InputScenario::kNoInput);

   // Trigger idle time eviction.
   backend->OnBrowserIdle();

   // The eviction process involves multiple asynchronous steps across different
   // shards and the EvictionCandidateAggregator. Since all these steps are
   // tracked by SqlAsyncTaskManager, a single RunUntilAllTasksCompleteForTest()
   // is sufficient to wait for the entire process to complete.
   backend->RunUntilAllTasksCompleteForTest();

   // Eviction should have run and reduced the size.
   const int64_t kLowWatermark =
       kMaxBytes * kSqlBackendEvictionLowWaterMarkPermille / 1000;  // 9000
   EXPECT_LE(GetSizeOfAllEntries(*backend), kLowWatermark);
 }

 void SqlBackendImplTest::RunDelayedPostInitializationTasksTest() {
   auto backend = CreateBackendAndInit();
   auto* sql_store = backend->GetSqlStoreForTest();
   auto task_runners = backend->GetBackgroundTaskRunnersForTest();

   const auto kKey1 = CacheEntryKey("key1");
   const auto kKey2 = CacheEntryKey("key2");
   const std::string kData = "some data";
   const auto shard_id1 = sql_store->GetShardIdForHash(kKey1.hash());
   const auto shard_id2 = sql_store->GetShardIdForHash(kKey2.hash());

   // Create two entries and write some data to them.
   auto* entry1 = CreateEntryAndWriteData(backend.get(), kKey1.string(), kData);
   auto* entry2 = CreateEntryAndWriteData(backend.get(), kKey2.string(), kData);
   auto db_handle1 = static_cast<SqlEntryImpl*>(entry1)->db_handle();
   auto db_handle2 = static_cast<SqlEntryImpl*>(entry1)->db_handle();
   entry1->Close();
   entry2->Close();
   backend->RunUntilAllTasksCompleteForTest();
   ASSERT_TRUE(db_handle1->GetResId().has_value());
   ASSERT_TRUE(db_handle2->GetResId().has_value());
   auto res_id1 = db_handle1->GetResId().value();
   auto res_id2 = db_handle2->GetResId().value();

   // Close the backend to ensure everything is written to disk.
   backend.reset();

   FlushQueueInTaskRunners(task_runners);

   // This block simulates a previous session where an entry was doomed but not
   // fully cleaned up.
   {
     SqlAsyncTaskManager async_task_manager;
     auto store = std::make_unique<SqlPersistentStore>(
         temp_dir_.GetPath(), kDefaultMaxBytes, net::CacheType::DISK_CACHE,
         task_runners, async_task_manager, /*cleanup_tracker=*/nullptr);

     base::test::TestFuture<disk_cache::SqlPersistentStore::Error> future_init;
     store->Initialize(future_init.GetCallback());
     ASSERT_EQ(future_init.Get(), disk_cache::SqlPersistentStore::Error::kOk);

     // Doom one of the entries.
     base::test::TestFuture<SqlPersistentStore::Error> future_doom;
     store->DoomEntry(kKey1, res_id1, /*accept_index_mismatch=*/false,
                      future_doom.GetCallback());
     EXPECT_EQ(future_doom.Get(), SqlPersistentStore::Error::kOk);

     store.reset();

     FlushQueueInTaskRunners(task_runners);
   }

   // Verify directly in the database that the blobs for the entries still exist.
   EXPECT_EQ(OpenDatabaseAndGetBlobsCount(shard_id1, res_id1), 1);
   EXPECT_EQ(OpenDatabaseAndGetBlobsCount(shard_id2, res_id2), 1);

   // Create and initialize a new backend.
   backend = CreateBackend();
   sql_store = backend->GetSqlStoreForTest();
   base::test::TestFuture<int> future;
   backend->Init(future.GetCallback());
   ASSERT_EQ(future.Get(), net::OK);

   backend->RunUntilAllTasksCompleteForTest();

   if (net::features::kSqlDiskCacheLoadIndexOnInit.Get()) {
     // When the SqlDiskCacheLoadIndexOnInit is enabled, the index should have
     // been loaded. The doomed entry should be gone, and the other entry should
     // be present.
     EXPECT_EQ(sql_store->GetIndexStateForHash(kKey1.hash()),
               SqlPersistentStore::IndexState::kHashNotFound);
     EXPECT_EQ(sql_store->GetIndexStateForHash(kKey2.hash()),
               SqlPersistentStore::IndexState::kHashFound);
   } else {
     // At this point, the in-memory index should not be loaded yet.
     EXPECT_EQ(sql_store->GetIndexStateForHash(kKey1.hash()),
               SqlPersistentStore::IndexState::kNotReady);
     EXPECT_EQ(sql_store->GetIndexStateForHash(kKey2.hash()),
               SqlPersistentStore::IndexState::kNotReady);
   }

   // Fast forward time to trigger the delayed post-initialization tasks.
   task_environment_.FastForwardBy(kSqlBackendPostInitializationTasksDelay);

   backend->RunUntilAllTasksCompleteForTest();

   // Now, the index should be loaded even if SqlDiskCacheLoadIndexOnInit is
   // disabled. The doomed entry should be gone, and the other entry should be
   // present.
   EXPECT_EQ(sql_store->GetIndexStateForHash(kKey1.hash()),
             SqlPersistentStore::IndexState::kHashNotFound);
   EXPECT_EQ(sql_store->GetIndexStateForHash(kKey2.hash()),
             SqlPersistentStore::IndexState::kHashFound);

   task_runners = backend->GetBackgroundTaskRunnersForTest();
   backend.reset();

   FlushQueueInTaskRunners(task_runners);

   // Verify directly in the database that the blob for the doomed entry has been
   // deleted, while the other one still exists.
   EXPECT_EQ(OpenDatabaseAndGetBlobsCount(shard_id1, res_id1), 0);
   EXPECT_EQ(OpenDatabaseAndGetBlobsCount(shard_id2, res_id2), 1);
 }

 TEST_F(SqlBackendImplTest, DelayedPostInitializationTasks) {
   RunDelayedPostInitializationTasksTest();
 }

 TEST_F(SqlBackendImplTest,
        DelayedPostInitializationTasksWithLoadIndexOnInitFeature) {
   base::test::ScopedFeatureList feature_list;
   feature_list.InitWithFeaturesAndParameters(
       {{net::features::kDiskCacheBackendExperiment,
         {{net::features::kDiskCacheBackendParam.name, "sql"},
          {net::features::kSqlDiskCacheLoadIndexOnInit.name, "true"}}}},
       {});
   RunDelayedPostInitializationTasksTest();
 }

 // Regression test for https://crbug.com/456384561
 // Tests that the dangling pointer warning does not occur when the backend is
 // destroyed with a pending operation that holds the last reference to an entry.
 // This test reproduces the scenario where the destruction order of
 // `SqlBackendImpl` members (`exclusive_operation_coordinator_` before
 // `active_entries_`) could lead to a dangling `raw_ref` in `active_entries_`.
 TEST_F(SqlBackendImplTest, DestructionWithPendingOperationOnEntry) {
   auto backend = CreateBackendAndInit();

   // 1. Create an entry.
   TestEntryResultCompletionCallback cb_create;
   disk_cache::EntryResult create_result = cb_create.GetResult(
       backend->CreateEntry("key", net::HIGHEST, cb_create.callback()));
   ASSERT_THAT(create_result.net_error(), IsOk());
   auto* entry = create_result.ReleaseEntry();

   // 2. Post a separate async exclusive operation. This ensures that the
   //    subsequent `Doom()` call will be queued and not run synchronously.
   backend->CalculateSizeOfAllEntries(base::DoNothing());

   // 3. Call `entry->Doom()`. This queues a `HandleDoomActiveEntryOperation`
   //    task in the `ExclusiveOperationCoordinator`. The task's callback
   //    captures a `scoped_refptr` to the `SqlEntryImpl`.
   entry->Doom();

   // 4. Close the entry. The last owning `scoped_refptr` is now held by the
   //    pending `Doom` operation inside the coordinator. The `active_entries_`
   //    map only holds a non-owning `raw_ref`.
   entry->Close();
   entry = nullptr;

   // 5. Destroy the backend. This triggers the destruction sequence that could
   //    cause the bug if member declaration order is incorrect.
   //    a. `weak_factory_` is destroyed, invalidating the entry's `backend_`
   //       WeakPtr.
   //    b. `exclusive_operation_coordinator_` is destroyed, which destroys the
   //       pending `Doom` task. This releases the last `scoped_refptr`.
   //    c. `~SqlEntryImpl()` is called.
   //    d. Inside `~SqlEntryImpl()`, the `if (!backend_)` check now passes,
   //       causing `ReleaseActiveEntry()` to be skipped.
   //    e. `active_entries_` is destroyed, but it still contains a `raw_ref` to
   //       the now-deleted entry, causing a dangling pointer issue.
   // If the bug exists, this test will crash here.
   auto task_runners = backend->GetBackgroundTaskRunnersForTest();
   backend.reset();

   // 6. If the bug is fixed, destruction completes safely. Run any remaining
   //    tasks to ensure clean shutdown and prevent leaks.
   FlushQueueInTaskRunners(task_runners);
 }

 TEST_F(SqlBackendImplTest, DoomEntryWithInMemoryIndex) {
   auto backend = CreateBackendAndInit();
   const std::string kKey = "my-key";
   const CacheEntryKey kEntryKey(kKey);

   // 1. Create an entry and close it.
   TestEntryResultCompletionCallback create_cb;
   disk_cache::EntryResult create_result = create_cb.GetResult(
       backend->CreateEntry(kKey, net::HIGHEST, create_cb.callback()));
   ASSERT_THAT(create_result.net_error(), IsOk());
   create_result.ReleaseEntry()->Close();

   // 2. Load in-memory index.
   ASSERT_TRUE(LoadInMemoryIndex(*backend));

   // 3. Verify that the entry is in the index.
   EXPECT_EQ(
       backend->GetSqlStoreForTest()->GetIndexStateForHash(kEntryKey.hash()),
       SqlPersistentStore::IndexState::kHashFound);

   // 4. Doom the entry.
   net::TestCompletionCallback cb_doom;
   int rv_doom = backend->DoomEntry(kKey, net::HIGHEST, cb_doom.callback());

   EXPECT_THAT(cb_doom.GetResult(rv_doom), IsOk());

   // 5. Verify that the entry is removed from the in-memory index.
   EXPECT_EQ(
       backend->GetSqlStoreForTest()->GetIndexStateForHash(kEntryKey.hash()),
       SqlPersistentStore::IndexState::kHashNotFound);

   // 6. Verify that the entry is gone.
   TestEntryResultCompletionCallback cb_open;
   disk_cache::EntryResult open_result = cb_open.GetResult(
       backend->OpenEntry(kKey, net::HIGHEST, cb_open.callback()));
   EXPECT_THAT(open_result.net_error(), IsError(net::ERR_FAILED));
 }

 // Tests that dooming a non-existent key whose hash collides with an existing
 // entry's key does not affect the existing entry. The in-memory index is keyed
 // by hash only, so a single-entry hash bucket may resolve to a different key's
 // `res_id`; the backend must still keep the existing entry openable and avoid
 // creating duplicate rows for it.
 TEST_F(SqlBackendImplTest, DoomEntryWithInMemoryIndexHashCollision) {
   // Two distinct keys with the same `CacheEntryKey::hash()`.
   const std::string kExistingKey = "colliding-key-2018";
   const std::string kCollidingKey = "colliding-key-3000";
   const CacheEntryKey kExistingEntryKey(kExistingKey);
   ASSERT_EQ(kExistingEntryKey.hash(), CacheEntryKey(kCollidingKey).hash());

   auto backend = CreateBackendAndInit();

   // 1. Create an entry for `kExistingKey` and close it so it is no longer
   //    active.
   TestEntryResultCompletionCallback cb_create;
   disk_cache::EntryResult create_result = cb_create.GetResult(
       backend->CreateEntry(kExistingKey, net::HIGHEST, cb_create.callback()));
   ASSERT_THAT(create_result.net_error(), IsOk());
   create_result.ReleaseEntry()->Close();
   backend->RunUntilAllTasksCompleteForTest();

   // 2. Load the in-memory index. `kExistingKey` is the sole occupant of its
   //    hash bucket.
   ASSERT_TRUE(LoadInMemoryIndex(*backend));
   ASSERT_EQ(backend->GetSqlStoreForTest()->GetIndexStateForHash(
                 kExistingEntryKey.hash()),
             SqlPersistentStore::IndexState::kHashFound);

   // 3. Doom `kCollidingKey`, which does not exist but shares its hash with
   //    `kExistingKey`.
   net::TestCompletionCallback cb_doom;
   EXPECT_THAT(cb_doom.GetResult(backend->DoomEntry(kCollidingKey, net::HIGHEST,
                                                    cb_doom.callback())),
               IsOk());
   backend->RunUntilAllTasksCompleteForTest();

   // 4. The existing entry must remain in the in-memory index.
   EXPECT_EQ(backend->GetSqlStoreForTest()->GetIndexStateForHash(
                 kExistingEntryKey.hash()),
             SqlPersistentStore::IndexState::kHashFound);

   // 5. Opening `kExistingKey` must still succeed.
   TestEntryResultCompletionCallback cb_open;
   disk_cache::EntryResult open_result = cb_open.GetResult(
       backend->OpenEntry(kExistingKey, net::HIGHEST, cb_open.callback()));
   ASSERT_THAT(open_result.net_error(), IsOk());
   open_result.ReleaseEntry()->Close();

   // 6. OpenOrCreateEntry must open the existing entry rather than creating a
   //    duplicate row.
   TestEntryResultCompletionCallback cb_ooc;
   disk_cache::EntryResult ooc_result =
       cb_ooc.GetResult(backend->OpenOrCreateEntry(kExistingKey, net::HIGHEST,
                                                   cb_ooc.callback()));
   ASSERT_THAT(ooc_result.net_error(), IsOk());
   EXPECT_TRUE(ooc_result.opened());
   ooc_result.ReleaseEntry()->Close();
   backend->RunUntilAllTasksCompleteForTest();

   base::test::TestFuture<int32_t> count_future;
   EXPECT_EQ(backend->GetEntryCount(count_future.GetCallback()),
             base::unexpected(net::ERR_IO_PENDING));
   EXPECT_EQ(count_future.Get(), 1);
 }

 TEST_F(SqlBackendImplTest, SetDataHintsAndDoomAndWriteOptimistically) {
   auto backend = CreateBackendAndInit();
   const std::string kKey = "my-key";
   const uint8_t kUnusableHint = 1;

   // 1. Create an entry.
   TestEntryResultCompletionCallback cb_create;
   EntryResult create_result = cb_create.GetResult(
       backend->CreateEntry(kKey, net::HIGHEST, cb_create.callback()));
   ASSERT_THAT(create_result.net_error(), IsOk());
   auto* entry = create_result.ReleaseEntry();

   // 2. Set an in-memory hint.
   entry->SetEntryInMemoryData(kUnusableHint);
   EXPECT_EQ(backend->GetEntryInMemoryData(kKey), kUnusableHint);
   entry->Close();

   // 3. While write is in flight, it should still be returned from
   //    `in_flight_entry_modifications_`.
   EXPECT_EQ(backend->GetEntryInMemoryData(kKey), kUnusableHint);

   // 4. Call OnBrowserIdle() to trigger in-memory index loading.
   backend->OnBrowserIdle();
   backend->RunUntilAllTasksCompleteForTest();

   // 5. Verify the hint is set in the backend.
   EXPECT_EQ(backend->GetEntryInMemoryData(kKey), kUnusableHint);

   // 6. Doom the entry.
   base::test::TestFuture<int> doom_future;
   int doom_rv =
       backend->DoomEntry(kKey, net::HIGHEST, doom_future.GetCallback());
   EXPECT_EQ(doom_rv, net::ERR_IO_PENDING);

   // 7. OpenOrCreateEntry should create a new entry.
   TestEntryResultCompletionCallback cb_open_or_create;
   EntryResult open_or_create_result =
       cb_open_or_create.GetResult(backend->OpenOrCreateEntry(
           kKey, net::HIGHEST, cb_open_or_create.callback()));
   ASSERT_THAT(open_or_create_result.net_error(), IsOk());
   EXPECT_FALSE(open_or_create_result.opened());

   open_or_create_result.ReleaseEntry()->Close();
   EXPECT_EQ(doom_future.Get(), net::OK);
 }

 TEST_F(SqlBackendImplTest, SetEntryDataHintsWithSpeculativeCreateEntryFailure) {
   base::test::ScopedFeatureList feature_list;
   feature_list.InitAndEnableFeatureWithParameters(
       net::features::kDiskCacheBackendExperiment,
       {{net::features::kSqlDiskCacheMaxWriteBufferTotalSize.name, "10"}});
   auto backend = CreateBackendAndInit();
   EXPECT_TRUE(LoadInMemoryIndex(*backend));
   backend->GetSqlStoreForTest()->SetSimulateDbFailureForTesting(true);
   const std::string kKey = "my-key";

   // Create an entry. This should return immediately with a speculatively
   // created entry.
   TestEntryResultCompletionCallback cb_create;
   disk_cache::EntryResult create_result =
       backend->CreateEntry(kKey, net::HIGHEST, cb_create.callback());
   ASSERT_THAT(create_result.net_error(), IsOk());
   auto* entry = create_result.ReleaseEntry();
   ASSERT_TRUE(entry);
   auto db_handle = static_cast<SqlEntryImpl*>(entry)->db_handle();

   // When WriteData is called with data larger than
   // kSqlDiskCacheMaxWriteBufferTotalSize, SqlBackendImpl starts the optimistic
   // write process, and the `db_handle` enters the creating state.
   auto write_buffer = base::MakeRefCounted<net::StringIOBuffer>("1234567890A");
   ASSERT_GT(write_buffer->size(),
             net::features::kSqlDiskCacheMaxWriteBufferTotalSize.Get());
   EXPECT_TRUE(db_handle->IsInitialState());
   EXPECT_EQ(entry->WriteData(1, 0, write_buffer.get(), write_buffer->size(),
                              base::DoNothing(), false),
             write_buffer->size());
   EXPECT_TRUE(db_handle->IsCreatingState());
   // After flushing all DB tasks, the db_handle should hold a kFailedForTesting
   // error.
   backend->RunUntilAllTasksCompleteForTest();
   EXPECT_THAT(db_handle->GetError(),
               SqlPersistentStore::Error::kFailedForTesting);

   // Set an in-memory hint. This should fail silently because the entry has an
   // error.
   const uint8_t kUnusableHint = 1;
   entry->SetEntryInMemoryData(kUnusableHint);
   entry->Close();

   // Flush the queue to make sure the SetEntryInMemoryData operation is
   // processed.
   backend->RunUntilAllTasksCompleteForTest();

   // Verify the hint is not set in the backend.
   EXPECT_EQ(backend->GetEntryInMemoryData(kKey), 0);
 }

 // Regression test for https://crbug.com/473912285.
 // Tests that an optimistic write failure does not cause an index mismatch error
 // (which can lead to a CHECK failure in strict mode) if the entry has already
 // been doomed by DoomAllEntries.
 TEST_F(SqlBackendImplTest, OptimisticWriteIndexMismatchAfterDoomAllEntries) {
   auto backend = CreateBackendAndInit();
   EXPECT_TRUE(LoadInMemoryIndex(*backend));
   backend->EnableStrictCorruptionCheckForTesting();

   // 1. Create a speculative entry.
   TestEntryResultCompletionCallback cb_create;
   disk_cache::EntryResult create_result =
       backend->CreateEntry("key", net::HIGHEST, cb_create.callback());
   ASSERT_THAT(create_result.net_error(), IsOk());
   auto* entry = create_result.ReleaseEntry();
   ASSERT_TRUE(entry);

   // 2. Doom all entries.
   net::TestCompletionCallback doom_cb;
   int rv_doom = backend->DoomAllEntries(doom_cb.callback());
   EXPECT_EQ(rv_doom, net::ERR_IO_PENDING);
   EXPECT_THAT(doom_cb.WaitForResult(), IsOk());

   // 3. Set DB failure to force OptimisticWrite to fail.
   backend->GetSqlStoreForTest()->SetSimulateDbFailureForTesting(true);

   // 4. Write data optimistically.
   auto buffer = base::MakeRefCounted<net::StringIOBuffer>("data");
   int rv_write =
       entry->WriteData(1, 100, buffer.get(), 4, base::DoNothing(), false);
   EXPECT_EQ(rv_write, 4);

   // 4. Wait for operations to complete.
   // Previously, this would trigger an index mismatch error (and a CHECK failure
   // in RecordIndexMismatch).
   backend->RunUntilAllTasksCompleteForTest();

   entry->Close();
 }

 TEST_F(SqlBackendImplTest, WriteBuffering) {
   base::test::ScopedFeatureList feature_list;
   feature_list.InitAndEnableFeatureWithParameters(
       net::features::kDiskCacheBackendExperiment,
       {{net::features::kSqlDiskCacheMaxWriteBufferTotalSize.name, "10240"},
        {net::features::kSqlDiskCacheMaxWriteBufferSizePerEntry.name, "1024"},
        {net::features::kSqlDiskCacheOptimisticWriteBufferSize.name, "250"}});

   auto backend = CreateBackendAndInit();

   TestEntryResultCompletionCallback cb_create;
   disk_cache::EntryResult create_result = cb_create.GetResult(
       backend->CreateEntry("key", net::HIGHEST, cb_create.callback()));
   ASSERT_THAT(create_result.net_error(), IsOk());
   auto* entry = create_result.ReleaseEntry();

   // Write small chunk, should be buffered.
   auto buffer1 =
       base::MakeRefCounted<net::StringIOBuffer>(std::string(100, 'a'));
   EXPECT_EQ(entry->WriteData(1, 0, buffer1.get(), buffer1->size(),
                              base::DoNothing(), false),
             buffer1->size());
   EXPECT_EQ(backend->GetWriteBufferTotalSizeForTesting(), buffer1->size());

   // Write another small chunk, should be buffered.
   auto buffer2 =
       base::MakeRefCounted<net::StringIOBuffer>(std::string(100, 'b'));
   EXPECT_EQ(entry->WriteData(1, 100, buffer2.get(), buffer2->size(),
                              base::DoNothing(), false),
             buffer2->size());
   EXPECT_EQ(backend->GetWriteBufferTotalSizeForTesting(),
             buffer1->size() + buffer2->size());
   EXPECT_EQ(backend->GetOptimisticWriteBufferTotalSizeForTesting(), 0);

   // Write exceeding per-entry limit, should trigger flush of previous buffer.
   // The new data is too large to buffer, so it should be written directly.
   std::string large_data(2000, 'c');
   auto buffer3 = base::MakeRefCounted<net::StringIOBuffer>(large_data);
   net::TestCompletionCallback cb_write;
   int rv = entry->WriteData(1, 200, buffer3.get(), buffer3->size(),
                             cb_write.callback(), false);
   EXPECT_EQ(rv, net::ERR_IO_PENDING);
   EXPECT_EQ(backend->GetWriteBufferTotalSizeForTesting(), 0);
   EXPECT_EQ(backend->GetOptimisticWriteBufferTotalSizeForTesting(),
             buffer1->size() + buffer2->size());

   entry->Close();

   backend->RunUntilAllTasksCompleteForTest();
   EXPECT_EQ(backend->GetWriteBufferTotalSizeForTesting(), 0);
   EXPECT_EQ(backend->GetOptimisticWriteBufferTotalSizeForTesting(), 0);
 }

 TEST_F(SqlBackendImplTest, WriteBufferingReadFromBuffer) {
   base::test::ScopedFeatureList feature_list;
   feature_list.InitAndEnableFeatureWithParameters(
       net::features::kDiskCacheBackendExperiment,
       {{net::features::kSqlDiskCacheMaxWriteBufferTotalSize.name, "10240"},
        {net::features::kSqlDiskCacheMaxWriteBufferSizePerEntry.name, "1024"}});

   auto backend = CreateBackendAndInit();

   TestEntryResultCompletionCallback cb_create;
   disk_cache::EntryResult create_result = cb_create.GetResult(
       backend->CreateEntry("key", net::HIGHEST, cb_create.callback()));
   ASSERT_THAT(create_result.net_error(), IsOk());
   auto* entry = create_result.ReleaseEntry();

   // Buffer some data.
   std::string data = "hello world";
   auto buffer = base::MakeRefCounted<net::StringIOBuffer>(data);
   entry->WriteData(1, 0, buffer.get(), buffer->size(), base::DoNothing(),
                    false);
   EXPECT_EQ(backend->GetWriteBufferTotalSizeForTesting(), data.size());

   // Read it back.
   auto read_buffer = base::MakeRefCounted<net::IOBufferWithSize>(data.size());
   net::TestCompletionCallback cb_read;
   int rv_read = entry->ReadData(1, 0, read_buffer.get(), read_buffer->size(),
                                 cb_read.callback());
   // Should be synchronous
   EXPECT_EQ(rv_read, static_cast<int>(data.size()));
   EXPECT_EQ(std::string_view(read_buffer->data(), data.size()), data);

   // Buffer should still be there.
   EXPECT_EQ(backend->GetWriteBufferTotalSizeForTesting(), data.size());

   entry->Close();

   backend->RunUntilAllTasksCompleteForTest();
   EXPECT_EQ(backend->GetWriteBufferTotalSizeForTesting(), 0);
 }

 TEST_F(SqlBackendImplTest, WriteBufferingReadOverlapFlush) {
   base::test::ScopedFeatureList feature_list;
   feature_list.InitAndEnableFeatureWithParameters(
       net::features::kDiskCacheBackendExperiment,
       {{net::features::kSqlDiskCacheMaxWriteBufferTotalSize.name, "10240"},
        {net::features::kSqlDiskCacheMaxWriteBufferSizePerEntry.name, "1024"}});

   auto backend = CreateBackendAndInit();

   TestEntryResultCompletionCallback cb_create;
   disk_cache::EntryResult create_result = cb_create.GetResult(
       backend->CreateEntry("key", net::HIGHEST, cb_create.callback()));
   ASSERT_THAT(create_result.net_error(), IsOk());
   auto* entry = create_result.ReleaseEntry();

   // Buffer some data.
   std::string data = "hello world";
   auto buffer = base::MakeRefCounted<net::StringIOBuffer>(data);
   // Write at 0 to ensure buffering (sequential).
   entry->WriteData(1, 0, buffer.get(), buffer->size(), base::DoNothing(),
                    false);
   EXPECT_EQ(backend->GetWriteBufferTotalSizeForTesting(), data.size());

   // Read range that overlaps but is larger than buffer (e.g. from 0 to 20)
   // This should force flush.
   auto read_buffer = base::MakeRefCounted<net::IOBufferWithSize>(20);
   net::TestCompletionCallback cb_read;
   int rv_read = entry->ReadData(1, 0, read_buffer.get(), read_buffer->size(),
                                 cb_read.callback());
   // Should return data.size() (11).
   EXPECT_EQ(cb_read.GetResult(rv_read), static_cast<int>(data.size()));
   EXPECT_EQ(std::string_view(read_buffer->data(), data.size()), data);

   // Buffer should be flushed.
   EXPECT_EQ(backend->GetWriteBufferTotalSizeForTesting(), 0);

   entry->Close();
 }

 TEST_F(SqlBackendImplTest, WriteBufferingGlobalLimit) {
   base::test::ScopedFeatureList feature_list;
   feature_list.InitAndEnableFeatureWithParameters(
       net::features::kDiskCacheBackendExperiment,
       {{net::features::kSqlDiskCacheMaxWriteBufferTotalSize.name, "100"},
        {net::features::kSqlDiskCacheMaxWriteBufferSizePerEntry.name, "1000"}});

   auto backend = CreateBackendAndInit();

   // Create entry 1
   TestEntryResultCompletionCallback cb_create1;
   disk_cache::EntryResult create_result1 = cb_create1.GetResult(
       backend->CreateEntry("key1", net::HIGHEST, cb_create1.callback()));
   ASSERT_THAT(create_result1.net_error(), IsOk());
   auto* entry1 = create_result1.ReleaseEntry();

   // Create entry 2
   TestEntryResultCompletionCallback cb_create2;
   disk_cache::EntryResult create_result2 = cb_create2.GetResult(
       backend->CreateEntry("key2", net::HIGHEST, cb_create2.callback()));
   ASSERT_THAT(create_result2.net_error(), IsOk());
   auto* entry2 = create_result2.ReleaseEntry();

   // Write 60 bytes to entry 1. Buffered.
   auto buffer1 =
       base::MakeRefCounted<net::StringIOBuffer>(std::string(60, 'a'));
   entry1->WriteData(1, 0, buffer1.get(), buffer1->size(), base::DoNothing(),
                     false);
   EXPECT_EQ(backend->GetWriteBufferTotalSizeForTesting(), 60);

   // Write 60 bytes to entry 2. Should flush entry 2 immediately because global
   // limit (100) would be exceeded (60+60=120).
   auto buffer2 =
       base::MakeRefCounted<net::StringIOBuffer>(std::string(60, 'b'));
   net::TestCompletionCallback cb_write;
   int rv = entry2->WriteData(1, 0, buffer2.get(), buffer2->size(),
                              cb_write.callback(), false);
   EXPECT_EQ(cb_write.GetResult(rv), 60);

   EXPECT_EQ(backend->GetWriteBufferTotalSizeForTesting(),
             60);  // Entry 1 still buffered.

   entry1->Close();
   entry2->Close();

   EXPECT_EQ(backend->GetWriteBufferTotalSizeForTesting(), 60);
   backend->RunUntilAllTasksCompleteForTest();
   EXPECT_EQ(backend->GetWriteBufferTotalSizeForTesting(), 0);
 }

 TEST_F(SqlBackendImplTest, WriteBufferingFlushOnClose) {
   base::test::ScopedFeatureList feature_list;
   feature_list.InitAndEnableFeatureWithParameters(
       net::features::kDiskCacheBackendExperiment,
       {{net::features::kSqlDiskCacheMaxWriteBufferTotalSize.name, "10240"},
        {net::features::kSqlDiskCacheMaxWriteBufferSizePerEntry.name, "1024"}});

   auto backend = CreateBackendAndInit();

   TestEntryResultCompletionCallback cb_create;
   disk_cache::EntryResult create_result = cb_create.GetResult(
       backend->CreateEntry("key", net::HIGHEST, cb_create.callback()));
   ASSERT_THAT(create_result.net_error(), IsOk());
   auto* entry = create_result.ReleaseEntry();

   // Buffer some data.
   std::string data = "hello world";
   auto buffer = base::MakeRefCounted<net::StringIOBuffer>(data);
   entry->WriteData(1, 0, buffer.get(), buffer->size(), base::DoNothing(),
                    false);
   EXPECT_EQ(backend->GetWriteBufferTotalSizeForTesting(), data.size());

   entry->Close();

   // Closing should asynchronously flush buffer.
   EXPECT_EQ(backend->GetWriteBufferTotalSizeForTesting(), data.size());
   backend->RunUntilAllTasksCompleteForTest();
   EXPECT_EQ(backend->GetWriteBufferTotalSizeForTesting(), 0);

   // Verify data on disk by opening again.
   TestEntryResultCompletionCallback cb_open;
   disk_cache::EntryResult open_result = cb_open.GetResult(
       backend->OpenEntry("key", net::HIGHEST, cb_open.callback()));
   ASSERT_THAT(open_result.net_error(), IsOk());
   entry = open_result.ReleaseEntry();

   auto read_buffer = base::MakeRefCounted<net::IOBufferWithSize>(data.size());
   net::TestCompletionCallback cb_read;
   int rv_read = entry->ReadData(1, 0, read_buffer.get(), read_buffer->size(),
                                 cb_read.callback());
   EXPECT_EQ(cb_read.GetResult(rv_read), static_cast<int>(data.size()));
   EXPECT_EQ(std::string_view(read_buffer->data(), data.size()), data);

   entry->Close();
 }

 TEST_F(SqlBackendImplTest, WriteBufferingOptimisticBoundary) {
   base::test::ScopedFeatureList feature_list;
   feature_list.InitAndEnableFeatureWithParameters(
       net::features::kDiskCacheBackendExperiment,
       {{net::features::kSqlDiskCacheMaxWriteBufferTotalSize.name, "10240"},
        {net::features::kSqlDiskCacheMaxWriteBufferSizePerEntry.name, "1000"},
        {net::features::kSqlDiskCacheOptimisticWriteBufferSize.name, "3000"}});

   auto backend = CreateBackendAndInit();

   TestEntryResultCompletionCallback cb_create;
   disk_cache::EntryResult create_result = cb_create.GetResult(
       backend->CreateEntry("key", net::HIGHEST, cb_create.callback()));
   ASSERT_THAT(create_result.net_error(), IsOk());
   auto* entry = create_result.ReleaseEntry();

   // 1. Write 500 bytes. Should be buffered.
   auto buffer1 =
       base::MakeRefCounted<net::StringIOBuffer>(std::string(500, 'a'));
   EXPECT_EQ(entry->WriteData(1, 0, buffer1.get(), buffer1->size(),
                              base::DoNothing(), false),
             buffer1->size());
   EXPECT_EQ(backend->GetWriteBufferTotalSizeForTesting(), 500);
   // Optimistic buffer usage: 0 (buffered in entry, not sent to backend)
   EXPECT_EQ(backend->GetOptimisticWriteBufferTotalSizeForTesting(), 0);

   // 2. Write 600 bytes. 500 + 600 > 1000.
   // Should flush buffer (500) -> Optimistic (size 500).
   // Then write new data (600) to the new buffer.
   auto buffer2 =
       base::MakeRefCounted<net::StringIOBuffer>(std::string(600, 'b'));
   EXPECT_EQ(entry->WriteData(1, 500, buffer2.get(), buffer2->size(),
                              base::DoNothing(), false),
             buffer2->size());
   EXPECT_EQ(backend->GetWriteBufferTotalSizeForTesting(), 600);
   EXPECT_EQ(backend->GetOptimisticWriteBufferTotalSizeForTesting(), 500);

   // 3. Write 2000 bytes. 2000 > 1000.
   // Since 2000 > 1000 (entry limit), it CANNOT be buffered.
   // It flushes the previous buffer (600) -> Optimistic: 500 + 600 = 1100 <=
   // 3000. Then writes 2000 bytes directly (async).
   auto buffer3 =
       base::MakeRefCounted<net::StringIOBuffer>(std::string(2000, 'c'));
   net::TestCompletionCallback cb_write3;
   EXPECT_EQ(entry->WriteData(1, 1100, buffer3.get(), buffer3->size(),
                              cb_write3.callback(), false),
             net::ERR_IO_PENDING);
   EXPECT_EQ(backend->GetWriteBufferTotalSizeForTesting(), 0);
   EXPECT_EQ(backend->GetOptimisticWriteBufferTotalSizeForTesting(), 1100);
   EXPECT_EQ(cb_write3.WaitForResult(), 2000);
   EXPECT_EQ(backend->GetOptimisticWriteBufferTotalSizeForTesting(), 0);

   // 4. Write 9000 bytes.
   // Total buffer usage: 0 + 9000.
   // Cannot buffer because 9000 > 1000 (entry limit).
   // Writes 9000 bytes directly.
   // Optimistic check for new write: 0 + 9000 > 3000. Non-optimistic write.
   // Should be pending.
   auto buffer4 =
       base::MakeRefCounted<net::StringIOBuffer>(std::string(9000, 'd'));
   net::TestCompletionCallback cb_write4;
   EXPECT_EQ(entry->WriteData(1, 3100, buffer4.get(), buffer4->size(),
                              cb_write4.callback(), false),
             net::ERR_IO_PENDING);
   EXPECT_EQ(cb_write4.WaitForResult(), static_cast<int>(buffer4->size()));
   EXPECT_EQ(backend->GetWriteBufferTotalSizeForTesting(), 0);
   EXPECT_EQ(backend->GetOptimisticWriteBufferTotalSizeForTesting(), 0);

   entry->Close();
 }

 TEST_F(SqlBackendImplTest, WriteBufferingReadAcrossChunks) {
   base::test::ScopedFeatureList feature_list;
   feature_list.InitAndEnableFeatureWithParameters(
       net::features::kDiskCacheBackendExperiment,
       {{net::features::kSqlDiskCacheMaxWriteBufferTotalSize.name, "10240"},
        {net::features::kSqlDiskCacheMaxWriteBufferSizePerEntry.name, "1024"}});

   auto backend = CreateBackendAndInit();

   TestEntryResultCompletionCallback cb_create;
   disk_cache::EntryResult create_result = cb_create.GetResult(
       backend->CreateEntry("key", net::HIGHEST, cb_create.callback()));
   ASSERT_THAT(create_result.net_error(), IsOk());
   auto* entry = create_result.ReleaseEntry();

   // Write chunk 1: "AAAAA"
   std::string data1 = "AAAAA";
   auto buffer1 = base::MakeRefCounted<net::StringIOBuffer>(data1);
   entry->WriteData(1, 0, buffer1.get(), buffer1->size(), base::DoNothing(),
                    false);

   // Write chunk 2: "BBBBB"
   std::string data2 = "BBBBB";
   auto buffer2 = base::MakeRefCounted<net::StringIOBuffer>(data2);
   entry->WriteData(1, 5, buffer2.get(), buffer2->size(), base::DoNothing(),
                    false);

   EXPECT_EQ(backend->GetWriteBufferTotalSizeForTesting(),
             data1.size() + data2.size());

   // Read across chunks: Offset 3, Length 4. Should get "AABB".
   auto read_buffer = base::MakeRefCounted<net::IOBufferWithSize>(4);
   net::TestCompletionCallback cb_read;
   int rv_read = entry->ReadData(1, 3, read_buffer.get(), read_buffer->size(),
                                 cb_read.callback());
   EXPECT_EQ(cb_read.GetResult(rv_read), 4);
   EXPECT_EQ(std::string_view(read_buffer->data(), 4), "AABB");

   // Buffer should still be there.
   EXPECT_EQ(backend->GetWriteBufferTotalSizeForTesting(),
             data1.size() + data2.size());

   entry->Close();

   backend->RunUntilAllTasksCompleteForTest();
   EXPECT_EQ(backend->GetWriteBufferTotalSizeForTesting(), 0);
 }

 TEST_F(SqlBackendImplTest, CombinedWriteAndMetadataUpdate) {
   auto backend = CreateBackendAndInit();

   TestEntryResultCompletionCallback cb_create;
   disk_cache::EntryResult create_result = cb_create.GetResult(
       backend->CreateEntry("key", net::HIGHEST, cb_create.callback()));
   ASSERT_THAT(create_result.net_error(), IsOk());
   auto* entry = create_result.ReleaseEntry();

   // Write to stream 0 (header) - this will be buffered in SqlEntryImpl.
   std::string header_data = "header";
   auto header_buffer = base::MakeRefCounted<net::StringIOBuffer>(header_data);
   entry->WriteData(0, 0, header_buffer.get(), header_buffer->size(),
                    base::DoNothing(), false);

   // Write to stream 1 (body) - this will be buffered in write buffer.
   std::string body_data = "body";
   auto body_buffer = base::MakeRefCounted<net::StringIOBuffer>(body_data);
   entry->WriteData(1, 0, body_buffer.get(), body_buffer->size(),
                    base::DoNothing(), false);

   // Close the entry. This should trigger a single WriteEntryDataAndMetadata
   // call that persists both header and body.
   entry->Close();

   // Flush background tasks.
   backend->RunUntilAllTasksCompleteForTest();

   // Re-open and verify.
   TestEntryResultCompletionCallback cb_open;
   disk_cache::EntryResult open_result = cb_open.GetResult(
       backend->OpenEntry("key", net::HIGHEST, cb_open.callback()));
   ASSERT_THAT(open_result.net_error(), IsOk());
   entry = open_result.ReleaseEntry();

   // Check header.
   auto read_header_buffer =
       base::MakeRefCounted<net::IOBufferWithSize>(header_data.size());
   net::TestCompletionCallback cb_read_header;
   int rv_read_header =
       entry->ReadData(0, 0, read_header_buffer.get(),
                       read_header_buffer->size(), cb_read_header.callback());
   EXPECT_EQ(cb_read_header.GetResult(rv_read_header),
             static_cast<int>(header_data.size()));
   EXPECT_EQ(std::string_view(read_header_buffer->data(), header_data.size()),
             header_data);

   // Check body.
   auto read_body_buffer =
       base::MakeRefCounted<net::IOBufferWithSize>(body_data.size());
   net::TestCompletionCallback cb_read_body;
   int rv_read_body =
       entry->ReadData(1, 0, read_body_buffer.get(), read_body_buffer->size(),
                       cb_read_body.callback());
   EXPECT_EQ(cb_read_body.GetResult(rv_read_body),
             static_cast<int>(body_data.size()));
   EXPECT_EQ(std::string_view(read_body_buffer->data(), body_data.size()),
             body_data);

   entry->Close();
 }

 TEST_F(SqlBackendImplTest, ReadCaching) {
   auto backend = CreateBackendAndInit();

   TestEntryResultCompletionCallback cb_create;
   disk_cache::EntryResult create_result = cb_create.GetResult(
       backend->CreateEntry("key", net::HIGHEST, cb_create.callback()));
   ASSERT_THAT(create_result.net_error(), IsOk());
   auto* entry = create_result.ReleaseEntry();

   // 1. Write some data to stream 1.
   std::string data = "0123456789ABCDEF";
   auto buffer = base::MakeRefCounted<net::StringIOBuffer>(data);
   net::TestCompletionCallback cb_write;
   int rv_write = entry->WriteData(1, 0, buffer.get(), buffer->size(),
                                   cb_write.callback(), false);
   EXPECT_EQ(cb_write.GetResult(rv_write), static_cast<int>(data.size()));

   // Close and re-open the entry to ensure data is written to the DB and we
   // don't read from the write buffer.
   entry->Close();
   TestEntryResultCompletionCallback cb_open;
   disk_cache::EntryResult open_result = cb_open.GetResult(
       backend->OpenEntry("key", net::HIGHEST, cb_open.callback()));
   ASSERT_THAT(open_result.net_error(), IsOk());
   entry = open_result.ReleaseEntry();

   // 2. Read only the first 5 bytes.
   // The backend should read the whole blob (since it's a single blob in DB)
   // and cache the remaining 11 bytes.
   auto read_buffer1 = base::MakeRefCounted<net::IOBufferWithSize>(5);
   net::TestCompletionCallback cb_read1;
   int rv_read1 =
       entry->ReadData(1, 0, read_buffer1.get(), 5, cb_read1.callback());
   EXPECT_EQ(cb_read1.GetResult(rv_read1), 5);
   EXPECT_EQ(std::string_view(read_buffer1->data(), 5), "01234");

   // Verify that the read_cache_buffer is populated.
   EXPECT_TRUE(static_cast<SqlEntryImpl*>(entry)->read_cache_buffer_for_test());
   EXPECT_EQ(
       static_cast<SqlEntryImpl*>(entry)->read_cache_buffer_offset_for_test(),
       5);

   // 3. Read the next 5 bytes.
   // This should be fulfilled from the cache synchronously (no IO pending).
   auto read_buffer2 = base::MakeRefCounted<net::IOBufferWithSize>(5);
   int rv_read2 =
       entry->ReadData(1, 5, read_buffer2.get(), 5, base::DoNothing());
   // If it's cached, it returns immediately.
   EXPECT_EQ(rv_read2, 5);
   EXPECT_EQ(std::string_view(read_buffer2->data(), 5), "56789");

   // 4. Read crossing the cache boundary.
   // The cache has "56789ABCDEF" (offset 5 to 16).
   // Request 5 bytes from offset 14: "EF" + 3 more.
   // It should return 2 bytes synchronously if it uses partial cache,
   // or return the whole thing if it triggers a new read.
   // Current implementation returns copy_size = min(buf_len, cache_end -
   // offset). So it should return 2 bytes synchronously.
   auto read_buffer3 = base::MakeRefCounted<net::IOBufferWithSize>(5);
   int rv_read3 =
       entry->ReadData(1, 14, read_buffer3.get(), 5, base::DoNothing());
   EXPECT_EQ(rv_read3, 2);
   EXPECT_EQ(std::string_view(read_buffer3->data(), 2), "EF");

   // 5. Write data should invalidate read cache.
   entry->WriteData(1, 16, buffer.get(), 1, base::DoNothing(), false);
   auto read_buffer4 = base::MakeRefCounted<net::IOBufferWithSize>(5);
   int rv_read4 =
       entry->ReadData(1, 5, read_buffer4.get(), 5, base::DoNothing());
   // Now it should be pending because cache was invalidated.
   EXPECT_EQ(rv_read4, net::ERR_IO_PENDING);

   entry->Close();
 }

 TEST_F(SqlBackendImplTest, ReadCachingSparse) {
   auto backend = CreateBackendAndInit();

   TestEntryResultCompletionCallback cb_create;
   disk_cache::EntryResult create_result = cb_create.GetResult(
       backend->CreateEntry("key", net::HIGHEST, cb_create.callback()));
   ASSERT_THAT(create_result.net_error(), IsOk());
   auto* entry = create_result.ReleaseEntry();

   // 1. Write some data to stream 1.
   std::string data = "0123456789ABCDEF";
   auto buffer = base::MakeRefCounted<net::StringIOBuffer>(data);
   net::TestCompletionCallback cb_write;
   int rv_write = entry->WriteData(1, 0, buffer.get(), buffer->size(),
                                   cb_write.callback(), false);
   EXPECT_EQ(cb_write.GetResult(rv_write), static_cast<int>(data.size()));

   // Close and re-open the entry to ensure data is written to the DB and we
   // don't read from the write buffer.
   entry->Close();
   TestEntryResultCompletionCallback cb_open;
   disk_cache::EntryResult open_result = cb_open.GetResult(
       backend->OpenEntry("key", net::HIGHEST, cb_open.callback()));
   ASSERT_THAT(open_result.net_error(), IsOk());
   entry = open_result.ReleaseEntry();

   // 2. Read sparse data.
   auto read_buffer1 = base::MakeRefCounted<net::IOBufferWithSize>(5);
   net::TestCompletionCallback cb_read1;
   int rv_read1 =
       entry->ReadSparseData(0, read_buffer1.get(), 5, cb_read1.callback());
   EXPECT_EQ(cb_read1.GetResult(rv_read1), 5);
   EXPECT_EQ(std::string_view(read_buffer1->data(), 5), "01234");

   // Verify that the read_cache_buffer IS populated even for sparse reads.
   EXPECT_TRUE(static_cast<SqlEntryImpl*>(entry)->read_cache_buffer_for_test());
   EXPECT_EQ(
       static_cast<SqlEntryImpl*>(entry)->read_cache_buffer_offset_for_test(),
       5);

   // Subsequent read (could be normal or sparse) should use the cache.
   auto read_buffer2 = base::MakeRefCounted<net::IOBufferWithSize>(5);
   int rv_read2 =
       entry->ReadData(1, 5, read_buffer2.get(), 5, base::DoNothing());
   EXPECT_EQ(rv_read2, 5);
   EXPECT_EQ(std::string_view(read_buffer2->data(), 5), "56789");

   entry->Close();
 }

 TEST_F(SqlBackendImplTest, ReadCachingGlobalLimit) {
   base::test::ScopedFeatureList feature_list;
   feature_list.InitAndEnableFeatureWithParameters(
       net::features::kDiskCacheBackendExperiment,
       {{net::features::kSqlDiskCacheMaxReadBufferTotalSize.name, "90"}});

   auto backend = CreateBackendAndInit();

   std::string data(60, 'a');
   auto buffer = base::MakeRefCounted<net::StringIOBuffer>(data);

   // Create entry 1
   TestEntryResultCompletionCallback cb_create1;
   disk_cache::EntryResult create_result1 = cb_create1.GetResult(
       backend->CreateEntry("key1", net::HIGHEST, cb_create1.callback()));
   ASSERT_THAT(create_result1.net_error(), IsOk());
   auto* entry1 = create_result1.ReleaseEntry();
   entry1->WriteData(1, 0, buffer.get(), buffer->size(), base::DoNothing(),
                     false);
   entry1->Close();

   // Create entry 2
   TestEntryResultCompletionCallback cb_create2;
   disk_cache::EntryResult create_result2 = cb_create2.GetResult(
       backend->CreateEntry("key2", net::HIGHEST, cb_create2.callback()));
   ASSERT_THAT(create_result2.net_error(), IsOk());
   auto* entry2 = create_result2.ReleaseEntry();
   entry2->WriteData(1, 0, buffer.get(), buffer->size(), base::DoNothing(),
                     false);
   entry2->Close();

   // Open both
   TestEntryResultCompletionCallback cb_open1;
   auto* entry1_open = cb_open1
                           .GetResult(backend->OpenEntry("key1", net::HIGHEST,
                                                         cb_open1.callback()))
                           .ReleaseEntry();
   TestEntryResultCompletionCallback cb_open2;
   auto* entry2_open = cb_open2
                           .GetResult(backend->OpenEntry("key2", net::HIGHEST,
                                                         cb_open2.callback()))
                           .ReleaseEntry();

   // Read from entry 1. 10 bytes. 50 bytes cached. Total 50.
   auto read_buf = base::MakeRefCounted<net::IOBufferWithSize>(10);
   net::TestCompletionCallback cb_read1;
   int rv1 =
       entry1_open->ReadData(1, 0, read_buf.get(), 10, cb_read1.callback());
   EXPECT_EQ(cb_read1.GetResult(rv1), 10);
   EXPECT_TRUE(
       static_cast<SqlEntryImpl*>(entry1_open)->read_cache_buffer_for_test());

   // Read from entry 2. 10 bytes. 50 bytes to cache. Total would be 100 > 90.
   // Should NOT be cached.
   net::TestCompletionCallback cb_read2;
   int rv2 =
       entry2_open->ReadData(1, 0, read_buf.get(), 10, cb_read2.callback());
   EXPECT_EQ(cb_read2.GetResult(rv2), 10);
   EXPECT_FALSE(
       static_cast<SqlEntryImpl*>(entry2_open)->read_cache_buffer_for_test());

   entry1_open->Close();  // Releases 50 bytes. Total 0.

   // Read again from entry 2 (offset 10).
   // This will trigger a new read from DB. Since total is 0, the remaining 40
   // bytes (60-10-10) should be cached?
   net::TestCompletionCallback cb_read3;
   int rv3 =
       entry2_open->ReadData(1, 10, read_buf.get(), 10, cb_read3.callback());
   EXPECT_EQ(cb_read3.GetResult(rv3), 10);
   EXPECT_TRUE(
       static_cast<SqlEntryImpl*>(entry2_open)->read_cache_buffer_for_test());

   entry2_open->Close();
 }

 TEST_F(SqlBackendImplTest, GetAvailableRangeWithBufferedWrite) {
   base::test::ScopedFeatureList feature_list;
   feature_list.InitAndEnableFeatureWithParameters(
       net::features::kDiskCacheBackendExperiment,
       {{net::features::kSqlDiskCacheOptimisticWriteBufferSize.name, "1024"},
        {net::features::kSqlDiskCacheMaxWriteBufferTotalSize.name, "1024"}});

   auto backend = CreateBackendAndInit();
   const std::string kKey = "my-key";
   const std::string kData = "some data";

   TestEntryResultCompletionCallback cb_create;
   disk_cache::EntryResult create_result = cb_create.GetResult(
       backend->CreateEntry(kKey, net::HIGHEST, cb_create.callback()));
   ASSERT_THAT(create_result.net_error(), IsOk());
   auto* entry = create_result.ReleaseEntry();
   ASSERT_TRUE(entry);

   // Write data. This should be buffered because it's small and write buffering
   // is enabled.
   auto write_buffer = base::MakeRefCounted<net::StringIOBuffer>(kData);
   EXPECT_EQ(entry->WriteData(1, 0, write_buffer.get(), write_buffer->size(),
                              base::DoNothing(), false),
             static_cast<int>(write_buffer->size()));

   // Verify it is buffered.
   EXPECT_EQ(backend->GetWriteBufferTotalSizeForTesting(), write_buffer->size());

   // Check GetAvailableRange.
   base::test::TestFuture<const RangeResult&> range_future;
   RangeResult result =
       entry->GetAvailableRange(0, kData.size(), range_future.GetCallback());

   ASSERT_THAT(result.net_error, IsError(net::ERR_IO_PENDING));

   result = range_future.Get();
   EXPECT_THAT(result.net_error, IsOk());
   EXPECT_EQ(result.start, 0);
   EXPECT_EQ(result.available_len, static_cast<int>(kData.size()));

   entry->Close();
 }

 TEST_F(SqlBackendImplTest, CreateIteratorFlushesBuffers) {
   auto backend = CreateBackendAndInit();
   EXPECT_TRUE(LoadInMemoryIndex(*backend));
   const std::string kKey = "my-key";
   const std::string kData = "data";

   TestEntryResultCompletionCallback cb_create;
   disk_cache::EntryResult create_result = cb_create.GetResult(
       backend->CreateEntry(kKey, net::HIGHEST, cb_create.callback()));
   ASSERT_THAT(create_result.net_error(), IsOk());
   auto* entry = create_result.ReleaseEntry();
   ASSERT_TRUE(entry);
   auto db_handle = static_cast<SqlEntryImpl*>(entry)->db_handle();

   auto buffer = base::MakeRefCounted<net::StringIOBuffer>(kData);
   EXPECT_EQ(entry->WriteData(1, 0, buffer.get(), buffer->size(),
                              base::DoNothing(), false),
             static_cast<int>(buffer->size()));

   // The entry is in kInitial state and has buffered data.
   // It is NOT in the DB yet.
   EXPECT_TRUE(db_handle->IsInitialState());

   auto iter = backend->CreateIterator();

   // CreateIterator should have triggered FlushBuffer(true).
   // Which starts the creation in DB.
   EXPECT_TRUE(db_handle->IsCreatingState());

   TestEntryResultCompletionCallback cb_iter;
   EntryResult iter_res = iter->OpenNextEntry(cb_iter.callback());

   iter_res = cb_iter.GetResult(std::move(iter_res));
   ASSERT_THAT(iter_res.net_error(), IsOk());
   auto* entry_from_iter = iter_res.ReleaseEntry();
   EXPECT_EQ(entry_from_iter->GetKey(), kKey);
   EXPECT_EQ(entry_from_iter->GetDataSize(1), static_cast<int>(kData.size()));

   entry->Close();
   entry_from_iter->Close();
 }

 TEST_F(SqlBackendImplTest, GetEntryCountFlushesBuffers) {
   auto backend = CreateBackendAndInit();
   EXPECT_TRUE(LoadInMemoryIndex(*backend));
   const std::string kKey = "my-key";

   TestEntryResultCompletionCallback cb_create;
   disk_cache::EntryResult create_result = cb_create.GetResult(
       backend->CreateEntry(kKey, net::HIGHEST, cb_create.callback()));
   ASSERT_THAT(create_result.net_error(), IsOk());
   auto* entry = create_result.ReleaseEntry();
   ASSERT_TRUE(entry);
   auto db_handle = static_cast<SqlEntryImpl*>(entry)->db_handle();

   // The entry is in kInitial state and has buffered data.
   // It is NOT in the DB yet.
   EXPECT_TRUE(db_handle->IsInitialState());
   base::test::TestFuture<int32_t> future;

   EXPECT_EQ(backend->GetEntryCount(future.GetCallback()),
             base::unexpected(net::ERR_IO_PENDING));

   // GetEntryCount should have triggered FlushBuffer(true).
   // Which starts the creation in DB.
   EXPECT_TRUE(db_handle->IsCreatingState());

   CHECK_EQ(future.Get(), 1);
   EXPECT_TRUE(db_handle->IsFinished());

   entry->Close();
 }

 TEST_F(SqlBackendImplTest, CalculateSizeOfEntriesBetweenFlushesBuffers) {
   auto backend = CreateBackendAndInit();
   EXPECT_TRUE(LoadInMemoryIndex(*backend));
   const std::string kKey = "my-key";
   const std::string kData = "data";

   TestEntryResultCompletionCallback cb_create;
   disk_cache::EntryResult create_result = cb_create.GetResult(
       backend->CreateEntry(kKey, net::HIGHEST, cb_create.callback()));
   ASSERT_THAT(create_result.net_error(), IsOk());
   auto* entry = create_result.ReleaseEntry();
   ASSERT_TRUE(entry);
   auto db_handle = static_cast<SqlEntryImpl*>(entry)->db_handle();

   auto buffer = base::MakeRefCounted<net::StringIOBuffer>(kData);
   EXPECT_EQ(entry->WriteData(1, 0, buffer.get(), buffer->size(),
                              base::DoNothing(), false),
             static_cast<int>(buffer->size()));

   // The entry is in kInitial state and has buffered data.
   // It is NOT in the DB yet.
   EXPECT_TRUE(db_handle->IsInitialState());
   base::test::TestFuture<int64_t> future;

   EXPECT_EQ(backend->CalculateSizeOfEntriesBetween(
                 base::Time::Min(), base::Time::Max(), future.GetCallback()),
             net::ERR_IO_PENDING);

   // CalculateSizeOfEntriesBetween should have triggered FlushBuffer(true).
   // Which starts the creation in DB.
   EXPECT_TRUE(db_handle->IsCreatingState());

   EXPECT_EQ(future.Get(),
             kKey.length() + kData.length() + kSqlBackendStaticResourceSize);
   EXPECT_TRUE(db_handle->IsFinished());

   entry->Close();
 }

 // Tests a race condition where Doom runs while a WriteData operation
 // is pending (blocked by another operation) and the entry is in 'Creating'
 // state.
 TEST_F(SqlBackendImplTest, AsyncDoomEntryAndWrite) {
   base::test::ScopedFeatureList feature_list;
   feature_list.InitAndEnableFeatureWithParameters(
       net::features::kDiskCacheBackendExperiment,
       {{net::features::kSqlDiskCacheMaxWriteBufferSizePerEntry.name, "250"}});
   auto backend = CreateBackendAndInit();
   EXPECT_TRUE(LoadInMemoryIndex(*backend));

   const std::string kKey = "my-key";

   // Create an entry.
   disk_cache::EntryResult create_result =
       backend->CreateEntry(kKey, net::HIGHEST, base::DoNothing());
   ASSERT_THAT(create_result.net_error(), IsOk());
   auto* entry = create_result.ReleaseEntry();
   auto db_handle = static_cast<SqlEntryImpl*>(entry)->db_handle();

   // Start an exclusive operation (CalculateSizeOfAllEntries).
   // This will block subsequent operations.
   net::TestInt64CompletionCallback cb_calculate;
   EXPECT_EQ(backend->CalculateSizeOfAllEntries(cb_calculate.callback()),
             net::ERR_IO_PENDING);

   // Doom the entry.
   entry->Doom();

   // Write data to the entry.
   // Since it is larger than kSqlDiskCacheMaxWriteBufferSizePerEntry, the task
   // for writing to the DB (WriteData) is queued.
   const int kDataSize = 1024;
   auto kData = std::string(kDataSize, 'a');
   auto buffer = base::MakeRefCounted<net::StringIOBuffer>(kData);
   EXPECT_EQ(
       entry->WriteData(1, 0, buffer.get(), kDataSize, base::DoNothing(), false),
       kDataSize);
   EXPECT_TRUE(db_handle->IsCreatingState());

   // The CalculateSizeOfAllEntries should complete.
   EXPECT_GE(cb_calculate.WaitForResult(), 0);

   // Verify that the data is readable.
   ReadAndVerifyData(entry, kData);

   entry->Close();

   // Verify that the entry is not found.
   TestEntryResultCompletionCallback cb_open;
   disk_cache::EntryResult open_result = cb_open.GetResult(
       backend->OpenEntry(kKey, net::HIGHEST, cb_open.callback()));
   EXPECT_THAT(open_result.net_error(), IsError(net::ERR_FAILED));
 }

 // Tests a race condition where Doom runs while a WriteEntryDataAndMetadata
 // operation is pending (blocked by another operation) and the entry is in
 // 'Creating' state.
 TEST_F(SqlBackendImplTest, AsyncDoomEntryAndFlushBuffer) {
   base::test::ScopedFeatureList feature_list;
   feature_list.InitAndEnableFeatureWithParameters(
       net::features::kDiskCacheBackendExperiment,
       {{net::features::kSqlDiskCacheMaxWriteBufferSizePerEntry.name, "250"}});
   auto backend = CreateBackendAndInit();
   EXPECT_TRUE(LoadInMemoryIndex(*backend));

   const std::string kKey = "my-key";

   // Create an entry.
   disk_cache::EntryResult create_result =
       backend->CreateEntry(kKey, net::HIGHEST, base::DoNothing());
   ASSERT_THAT(create_result.net_error(), IsOk());
   auto* entry = create_result.ReleaseEntry();
   auto db_handle = static_cast<SqlEntryImpl*>(entry)->db_handle();

   // Start an exclusive operation (CalculateSizeOfAllEntries).
   // This will block subsequent operations.
   net::TestInt64CompletionCallback cb_calculate;
   EXPECT_EQ(backend->CalculateSizeOfAllEntries(cb_calculate.callback()),
             net::ERR_IO_PENDING);

   // Doom the entry.
   entry->Doom();

   // Calling CreateIterator() queues the task for writing to the DB
   // (WriteEntryDataAndMetadata).
   auto iter = backend->CreateIterator();
   EXPECT_TRUE(db_handle->IsCreatingState());

   // The CalculateSizeOfAllEntries should complete.
   EXPECT_GE(cb_calculate.WaitForResult(), 0);

   TestEntryResultCompletionCallback cb_iter;
   EntryResult iter_res = iter->OpenNextEntry(cb_iter.callback());

   // The iterator shouldn't see the entry.
   iter_res = cb_iter.GetResult(std::move(iter_res));
   ASSERT_THAT(iter_res.net_error(), IsError(net::ERR_FAILED));

   entry->Close();

   // Verify that the entry is not found.
   TestEntryResultCompletionCallback cb_open;
   disk_cache::EntryResult open_result = cb_open.GetResult(
       backend->OpenEntry(kKey, net::HIGHEST, cb_open.callback()));
   EXPECT_THAT(open_result.net_error(), IsError(net::ERR_FAILED));
 }

 void SqlBackendImplTest::RunSparseDataExceedsMaxFileSizeTest(bool doom_entry) {
   auto backend = CreateBackendAndInit();
   EXPECT_TRUE(LoadInMemoryIndex(*backend));
   backend->EnableStrictCorruptionCheckForTesting();
   const std::string kKey = "my-key";

   TestEntryResultCompletionCallback cb_create;
   disk_cache::EntryResult create_result = cb_create.GetResult(
       backend->CreateEntry(kKey, net::HIGHEST, cb_create.callback()));
   ASSERT_THAT(create_result.net_error(), IsOk());
   auto* entry = create_result.ReleaseEntry();
   ASSERT_TRUE(entry);

   if (doom_entry) {
     entry->Doom();
   }

   const int chunk_size = 32 * 1024;
   const int num_chunks = backend->GetSqlStoreForTest()->MaxSize() / chunk_size;
   auto buf = base::MakeRefCounted<net::IOBufferWithSize>(chunk_size);
   std::ranges::fill(buf->span(), 'a');

   base::HistogramTester histogram_tester;

   for (int i = 0; i < num_chunks; ++i) {
     net::TestCompletionCallback cb;
     EXPECT_EQ(cb.GetResult(entry->WriteSparseData(i * chunk_size, buf.get(),
                                                   chunk_size, cb.callback())),
               chunk_size);
     backend->RunUntilAllTasksCompleteForTest();
   }

   // Truncating older sparse data prevents a single entry from exceeding the
   // cache size limit and causing excessive evictions on every write. Ensure
   // eviction was not triggered.
   histogram_tester.ExpectTotalCount(
       "Net.SqlDiskCache.Backend.RunEviction.ScannedEntriesCount.Success", 0);

   // Check if the first chunk is truncated.
   TestRangeResultCompletionCallback cb_range;
   EXPECT_EQ(cb_range
                 .GetResult(entry->GetAvailableRange(0, chunk_size,
                                                     cb_range.callback()))
                 .available_len,
             0);

   entry->Close();
 }

 TEST_F(SqlBackendImplTest, SparseDataExceedsMaxFileSize) {
   RunSparseDataExceedsMaxFileSizeTest(/*doom_entry=*/false);
 }

 TEST_F(SqlBackendImplTest, SparseDataExceedsMaxFileSizeDoomedEntry) {
   RunSparseDataExceedsMaxFileSizeTest(/*doom_entry=*/true);
 }

 TEST_F(SqlBackendImplTest, SparseDataExceedsMaxFileSizeBackwards) {
   auto backend = CreateBackendAndInit();
   EXPECT_TRUE(LoadInMemoryIndex(*backend));
   backend->EnableStrictCorruptionCheckForTesting();
   const std::string kKey = "my-key";

   TestEntryResultCompletionCallback cb_create;
   disk_cache::EntryResult create_result = cb_create.GetResult(
       backend->CreateEntry(kKey, net::HIGHEST, cb_create.callback()));
   ASSERT_THAT(create_result.net_error(), IsOk());
   auto* entry = create_result.ReleaseEntry();
   ASSERT_TRUE(entry);

   const int chunk_size = 32 * 1024;
   const int num_chunks = backend->GetSqlStoreForTest()->MaxSize() / chunk_size;
   auto buf = base::MakeRefCounted<net::IOBufferWithSize>(chunk_size);
   std::ranges::fill(buf->span(), 'a');

   base::HistogramTester histogram_tester;

   // Write chunks in reverse order.
   for (int i = num_chunks - 1; i >= 0; --i) {
     net::TestCompletionCallback cb;
     EXPECT_EQ(cb.GetResult(entry->WriteSparseData(i * chunk_size, buf.get(),
                                                   chunk_size, cb.callback())),
               chunk_size);
     backend->RunUntilAllTasksCompleteForTest();
   }

   histogram_tester.ExpectTotalCount(
       "Net.SqlDiskCache.Backend.RunEviction.ScannedEntriesCount.Success", 0);

   // The truncation logic trims data before and after the current write when
   // the size limit is exceeded. Since we wrote backwards, the last written
   // chunk was at offset 0. Thus, the previously written chunks at higher
   // offsets were truncated to keep the total size within the limit.
   TestRangeResultCompletionCallback cb_range;
   EXPECT_EQ(
       cb_range
           .GetResult(entry->GetAvailableRange((num_chunks - 1) * chunk_size,
                                               chunk_size, cb_range.callback()))
           .available_len,
       0);

   entry->Close();
 }

 TEST_F(SqlBackendImplTest, ReadFromSharedCacheViaOpenEntry) {
   base::test::ScopedFeatureList feature_list;
   feature_list.InitAndEnableFeature(
       net::features::kRendererAccessibleHttpCache);
   auto backend = CreateBackendAndInit();
   EXPECT_TRUE(LoadInMemoryIndex(*backend));

   const std::string kKey = "shared-cache-key";
   const std::string kData = "Data stored in shared cache";

   SqlSharedCacheResourceId expected_resource_id =
       CreateEntryInSharedCache(*backend, kKey, kData);
   ASSERT_TRUE(expected_resource_id.db_id.value());

   // Now open the entry using OpenEntry.
   TestEntryResultCompletionCallback cb_open;
   disk_cache::EntryResult open_result = cb_open.GetResult(
       backend->OpenEntry(kKey, net::HIGHEST, cb_open.callback()));
   ASSERT_THAT(open_result.net_error(), IsOk());
   auto* opened_entry = open_result.ReleaseEntry();
   ASSERT_TRUE(opened_entry);

   // Check db_handle has shared_cache_resource_id.
   auto* opened_sql_entry = static_cast<SqlEntryImpl*>(opened_entry);
   EXPECT_TRUE(
       opened_sql_entry->db_handle()->shared_cache_resource_id().has_value());
   EXPECT_EQ(opened_sql_entry->db_handle()->shared_cache_resource_id()->db_id,
             expected_resource_id.db_id);
   EXPECT_EQ(opened_sql_entry->db_handle()->shared_cache_resource_id()->row_id,
             expected_resource_id.row_id);

   // Read data stream 1 from opened entry and verify content matches kData.
   auto read_buf = base::MakeRefCounted<net::IOBufferWithSize>(kData.size());
   net::TestCompletionCallback cb_read;
   EXPECT_EQ(cb_read.GetResult(opened_entry->ReadData(
                 1, 0, read_buf.get(), kData.size(), cb_read.callback())),
             static_cast<int>(kData.size()));
   EXPECT_EQ(std::string_view(read_buf->data(), kData.size()), kData);

   opened_entry->Close();
   backend->RunUntilAllTasksCompleteForTest();
 }

 TEST_F(SqlBackendImplTest, ReadFromSharedCacheViaOpenNextEntry) {
   base::test::ScopedFeatureList feature_list;
   feature_list.InitAndEnableFeature(
       net::features::kRendererAccessibleHttpCache);
   auto backend = CreateBackendAndInit();
   EXPECT_TRUE(LoadInMemoryIndex(*backend));

   const std::string kKey = "shared-cache-iter-key";
   const std::string kData = "Data stored in shared cache for iterator";

   SqlSharedCacheResourceId expected_resource_id =
       CreateEntryInSharedCache(*backend, kKey, kData);
   ASSERT_TRUE(expected_resource_id.db_id.value());

   // Open entry via iterator (CreateIterator & OpenNextEntry).
   auto iterator = backend->CreateIterator();
   ASSERT_TRUE(iterator);

   TestEntryResultCompletionCallback cb_next;
   disk_cache::EntryResult next_result =
       cb_next.GetResult(iterator->OpenNextEntry(cb_next.callback()));
   ASSERT_THAT(next_result.net_error(), IsOk());
   auto* next_entry = next_result.ReleaseEntry();
   ASSERT_TRUE(next_entry);
   EXPECT_EQ(next_entry->GetKey(), kKey);

   // Check db_handle has shared_cache_resource_id.
   auto* next_sql_entry = static_cast<SqlEntryImpl*>(next_entry);
   EXPECT_TRUE(
       next_sql_entry->db_handle()->shared_cache_resource_id().has_value());
   EXPECT_EQ(next_sql_entry->db_handle()->shared_cache_resource_id()->db_id,
             expected_resource_id.db_id);
   EXPECT_EQ(next_sql_entry->db_handle()->shared_cache_resource_id()->row_id,
             expected_resource_id.row_id);

   // Read data stream 1 from iterator-opened entry and verify content matches
   // kData.
   auto read_buf = base::MakeRefCounted<net::IOBufferWithSize>(kData.size());
   net::TestCompletionCallback cb_read;
   EXPECT_EQ(cb_read.GetResult(next_entry->ReadData(
                 1, 0, read_buf.get(), kData.size(), cb_read.callback())),
             static_cast<int>(kData.size()));
   EXPECT_EQ(std::string_view(read_buf->data(), kData.size()), kData);

   next_entry->Close();
   backend->RunUntilAllTasksCompleteForTest();
 }

 TEST_F(SqlBackendImplTest, ReadFromSharedCacheWithLargerBuffer) {
   base::test::ScopedFeatureList feature_list;
   feature_list.InitAndEnableFeature(
       net::features::kRendererAccessibleHttpCache);
   auto backend = CreateBackendAndInit();
   EXPECT_TRUE(LoadInMemoryIndex(*backend));

   const std::string kKey = "shared-cache-drainable-key";
   const std::string kData = "0123456789";

   SqlSharedCacheResourceId expected_resource_id =
       CreateEntryInSharedCache(*backend, kKey, kData);
   ASSERT_TRUE(expected_resource_id.db_id.value());

   TestEntryResultCompletionCallback cb_open;
   disk_cache::EntryResult open_result = cb_open.GetResult(
       backend->OpenEntry(kKey, net::HIGHEST, cb_open.callback()));
   ASSERT_THAT(open_result.net_error(), IsOk());
   auto* opened_entry = open_result.ReleaseEntry();
   ASSERT_TRUE(opened_entry);

   // Pass a buffer larger than kData.size() (20 bytes > 10 bytes) to ensure
   // buffer->size() != bytes_to_read branch is taken.
   auto read_buf = base::MakeRefCounted<net::IOBufferWithSize>(20);
   net::TestCompletionCallback cb_read;
   EXPECT_EQ(cb_read.GetResult(opened_entry->ReadData(1, 0, read_buf.get(), 20,
                                                      cb_read.callback())),
             static_cast<int>(kData.size()));
   EXPECT_EQ(std::string_view(read_buf->data(), kData.size()), kData);

   opened_entry->Close();
   backend->RunUntilAllTasksCompleteForTest();
 }

 TEST_F(SqlBackendImplTest, ReadFromSharedCacheHandleNotFound) {
   base::test::ScopedFeatureList feature_list;
   feature_list.InitAndEnableFeature(
       net::features::kRendererAccessibleHttpCache);
   auto backend = CreateBackendAndInit();
   EXPECT_TRUE(LoadInMemoryIndex(*backend));

   const std::string kKey = "shared-cache-not-found-key";
   const std::string kData = "Data in shared cache";

   SqlSharedCacheResourceId expected_resource_id =
       CreateEntryInSharedCache(*backend, kKey, kData);
   ASSERT_TRUE(expected_resource_id.db_id.value());

   TestEntryResultCompletionCallback cb_open;
   disk_cache::EntryResult open_result = cb_open.GetResult(
       backend->OpenEntry(kKey, net::HIGHEST, cb_open.callback()));
   ASSERT_THAT(open_result.net_error(), IsOk());
   auto* opened_entry = open_result.ReleaseEntry();
   ASSERT_TRUE(opened_entry);

   // Set a non-existent shared_cache_resource_id so GetCacheByDbId will fail and
   // pass a null handle.
   auto* opened_sql_entry = static_cast<SqlEntryImpl*>(opened_entry);
   opened_sql_entry->db_handle()->set_shared_cache_resource_id(
       SqlSharedCacheResourceId{SqlSharedCacheDbId(9999),
                                SqlSharedCacheRowId(1)});

   auto read_buf = base::MakeRefCounted<net::IOBufferWithSize>(kData.size());
   net::TestCompletionCallback cb_read;
   int read_res = opened_entry->ReadData(1, 0, read_buf.get(), kData.size(),
                                         cb_read.callback());
   if (read_res == net::ERR_IO_PENDING) {
     backend->RunUntilAllTasksCompleteForTest();
     read_res = cb_read.WaitForResult();
   }
   EXPECT_EQ(read_res, net::ERR_FAILED);

   opened_entry->Close();
   backend->RunUntilAllTasksCompleteForTest();
 }

 // Helper base class to ensure `base::test::ScopedFeatureList` is initialized
 // before `SqlBackendImplTest`'s `TaskEnvironment` starts and destroyed only
 // after `TaskEnvironment` has shut down and joined all worker threads.
 //
 // In C++, base classes are constructed in the order of declaration and
 // destructed in reverse order. Inheriting `SqlBackendImplFeatureInitializer`
 // before `SqlBackendImplTest` prevents `base::FeatureList` from being deleted
 // while background threads in the task environment are still running and
 // querying feature flags (e.g. on Android during thread creation; see
 // crbug.com/359904334).
 class SqlBackendImplFeatureInitializer {
  public:
   SqlBackendImplFeatureInitializer() {
     feature_list_.InitAndEnableFeature(
         net::features::kRendererAccessibleHttpCache);
   }

  private:
   base::test::ScopedFeatureList feature_list_;
 };

 class SqlBackendImplSharedCacheTest : private SqlBackendImplFeatureInitializer,
                                       public SqlBackendImplTest {
  public:
   SqlBackendImplSharedCacheTest() = default;

  protected:
   void WriteResponseInfoToEntry(disk_cache::Entry* entry,
                                 const net::HttpResponseInfo& info) {
     auto pickle = info.MakePickle(false, false);
     std::string pickle_data(reinterpret_cast<const char*>(pickle->data()),
                             pickle->size());
     auto buffer = base::MakeRefCounted<net::StringIOBuffer>(pickle_data);
     net::TestCompletionCallback cb;
     EXPECT_EQ(cb.GetResult(entry->WriteData(0, 0, buffer.get(),
                                             static_cast<int>(pickle->size()),
                                             cb.callback(), false)),
               static_cast<int>(pickle->size()));
   }

   // Helper to create an entry in store, write data and response info,
   // optionally close it, and register it to shared cache.
   disk_cache::Entry* CreateAndRegisterSharedCacheEntry(
       SqlBackendImpl* backend,
       const std::string& key,
       const std::string& data,
       const net::NetworkIsolationKey& nik,
       base::Time response_time = base::Time::Now(),
       bool close_entry = true) {
     auto* entry = CreateEntryAndWriteData(backend, key, data);
     net::HttpResponseInfo info;
     info.response_time = response_time;
     info.headers =
         base::MakeRefCounted<net::HttpResponseHeaders>("HTTP/1.1 200 OK\0\0");
     WriteResponseInfoToEntry(entry, info);
     if (close_entry) {
       entry->Close();
     }
     GURL url{net::HttpCache::GetResourceURLFromHttpCacheKey(key)};
     backend->OnEntryEligibleForSharedCache(
         key, url, std::make_unique<net::HttpResponseInfo>(info), nik);
     return close_entry ? nullptr : entry;
   }

   void VerifySharedCacheResourceIdExists(SqlBackendImpl* backend,
                                          const std::string& key) {
     base::test::TestFuture<SqlPersistentStore::EntryInfoOrError> future;
     backend->GetSqlStoreForTest()->OpenEntry(CacheEntryKey(key),
                                              future.GetCallback());
     auto result = future.Take();
     ASSERT_TRUE(result.has_value());
     EXPECT_TRUE(result->shared_cache_resource_id.has_value());
   }
 };

 TEST_F(SqlBackendImplSharedCacheTest, ProcessSharedCacheEligibleEntries) {
   auto backend = CreateBackendAndInit();
   const std::string kKey = "0/0/https://example.com/";
   const GURL kUrl("https://example.com");
   const net::SchemefulSite kSite(GURL("https://example.com"));
   const net::NetworkIsolationKey kNik(kSite, kSite);
   const std::string kData = "Hello Shared Cache";

   // 1. Save entry
   auto* entry = CreateEntryAndWriteData(backend.get(), kKey, kData);

   base::Time response_time = base::Time::Now();
   net::HttpResponseInfo response_info_for_pickle;
   response_info_for_pickle.response_time = response_time;
   response_info_for_pickle.headers =
       base::MakeRefCounted<net::HttpResponseHeaders>("HTTP/1.1 200 OK\0\0");
   std::unique_ptr<base::Pickle> pickle =
       response_info_for_pickle.MakePickle(false, false);
   std::string pickle_data(reinterpret_cast<const char*>(pickle->data()),
                           pickle->size());
   auto pickle_buffer = base::MakeRefCounted<net::StringIOBuffer>(pickle_data);
   net::TestCompletionCallback cb_write_pickle;
   EXPECT_EQ(cb_write_pickle.GetResult(
                 entry->WriteData(0, 0, pickle_buffer.get(), pickle->size(),
                                  cb_write_pickle.callback(), false)),
             static_cast<int>(pickle->size()));

   entry->Close();

   // 2. Call OnEntryEligibleForSharedCache
   auto response_info =
       std::make_unique<net::HttpResponseInfo>(response_info_for_pickle);
   backend->OnEntryEligibleForSharedCache(kKey, kUrl, std::move(response_info),
                                          kNik);
   EXPECT_EQ(backend->GetSharedCacheEligibleEntriesCountForTest(), 1u);

   // 3. Register MockSharedCacheClientRemote
   auto client = std::make_unique<MockSharedCacheClientRemote>();
   auto* client_ptr = client.get();
   backend->RegisterSharedCacheClientRemote(kNik, std::move(client));

   // 4. Process entries
   base::RunLoop process_run_loop;
   backend->ProcessSharedCacheEligibleEntriesForTest(
       base::ScopedClosureRunner(process_run_loop.QuitClosure()),
       /*on_entry_copied_callback=*/base::NullCallback());

   // 5. Wait for Initialize and OnResourcesAdded
   client_ptr->WaitUntilInitialized();
   client_ptr->WaitUntilOnResourcesAdded();
   process_run_loop.Run();

   EXPECT_TRUE(client_ptr->initialize_called());
   EXPECT_TRUE(client_ptr->on_resources_added_called());
   EXPECT_TRUE(client_ptr->has_disconnect_handler());

   // 6. Use pending_file_set_ to read
   SqlSharedCacheIsolatedDatabaseReader reader(client_ptr->TakePendingFileSet());

   std::optional<SqlSharedCacheIsolatedDatabaseReader::Response> response =
       reader.ReadResponse(kUrl.spec());
   ASSERT_TRUE(response);
   EXPECT_GT(response->GetBodySize(), 0);

   std::vector<uint8_t> buffer(kData.size());
   EXPECT_TRUE(response->ReadBody(buffer));
   EXPECT_EQ(std::string(buffer.begin(), buffer.end()), kData);

   // 7. Call disconnect_handler
   auto* manager =
       backend->GetSqlStoreForTest()->shared_cache_manager_for_testing();
   EXPECT_EQ(manager->GetSharedCachesSizeForTest(), 1u);
   EXPECT_EQ(manager->GetSharedCachesByDbIdSizeForTest(), 1u);
   EXPECT_EQ(manager->GetSharedCachesByNikSizeForTest(), 1u);

   client_ptr->RunDisconnectHandler();

   ASSERT_TRUE(base::test::RunUntil(
       [&]() { return manager->GetSharedCachesSizeForTest() == 0u; }));

   // 8. Verify empty
   EXPECT_EQ(manager->GetSharedCachesByDbIdSizeForTest(), 0u);
   EXPECT_EQ(manager->GetSharedCachesByNikSizeForTest(), 0u);
 }

 TEST_F(SqlBackendImplSharedCacheTest,
        ProcessSharedCacheEligibleEntriesIncremental) {
   auto backend = CreateBackendAndInit();

   const net::SchemefulSite kSite(GURL("https://example.test"));
   const net::NetworkIsolationKey kNik(kSite, kSite);
   const std::string kKey1 = "0/0/https://example.test/1";
   const GURL kUrl1("https://example.test/1");
   const std::string kKey2 = "0/0/https://example.test/2";
   const GURL kUrl2("https://example.test/2");

   // 1. Create entry 1 and mark eligible
   CreateAndRegisterSharedCacheEntry(backend.get(), kKey1, "Data 1", kNik);
   backend->RunUntilAllTasksCompleteForTest();
   EXPECT_EQ(backend->GetSharedCacheEligibleEntriesCountForTest(), 1u);

   // 2. Register MockSharedCacheClientRemote
   auto client = std::make_unique<MockSharedCacheClientRemote>();
   auto* client_ptr = client.get();
   backend->RegisterSharedCacheClientRemote(kNik, std::move(client));

   // 3. Process entry 1
   base::RunLoop process_run_loop1;
   backend->ProcessSharedCacheEligibleEntriesForTest(
       base::ScopedClosureRunner(process_run_loop1.QuitClosure()),
       /*on_entry_copied_callback=*/base::NullCallback());

   client_ptr->WaitUntilInitialized();
   client_ptr->WaitUntilOnResourcesAdded(1);
   process_run_loop1.Run();

   EXPECT_EQ(client_ptr->on_resources_added_call_count(), 1u);
   EXPECT_THAT(client_ptr->new_hashes(),
               testing::ElementsAre(base::PersistentHash(kUrl1.spec())));

   // 4. Create entry 2 and mark eligible
   CreateAndRegisterSharedCacheEntry(backend.get(), kKey2, "Data 2", kNik);
   backend->RunUntilAllTasksCompleteForTest();
   EXPECT_EQ(backend->GetSharedCacheEligibleEntriesCountForTest(), 1u);

   // 5. Process entry 2
   base::RunLoop process_run_loop2;
   backend->ProcessSharedCacheEligibleEntriesForTest(
       base::ScopedClosureRunner(process_run_loop2.QuitClosure()),
       /*on_entry_copied_callback=*/base::NullCallback());

   client_ptr->WaitUntilOnResourcesAdded(2);
   process_run_loop2.Run();

   // Verify that OnResourcesAdded was called again with only the newly added
   // hash.
   EXPECT_EQ(client_ptr->on_resources_added_call_count(), 2u);
   EXPECT_THAT(client_ptr->new_hashes(),
               testing::ElementsAre(base::PersistentHash(kUrl2.spec())));

   auto* manager =
       backend->GetSqlStoreForTest()->shared_cache_manager_for_testing();
   EXPECT_EQ(manager->GetSharedCachesSizeForTest(), 1u);

   client_ptr->RunDisconnectHandler();
   ASSERT_TRUE(base::test::RunUntil(
       [&]() { return manager->GetSharedCachesSizeForTest() == 0u; }));
 }

 TEST_F(SqlBackendImplSharedCacheTest,
        ProcessSharedCacheEligibleEntriesDuplicate) {
   auto backend = CreateBackendAndInit();

   const net::SchemefulSite kSite(GURL("https://example.test"));
   const net::NetworkIsolationKey kNik(kSite, kSite);
   const std::string kKey = "0/0/https://example.test/";
   const GURL kUrl("https://example.test/");
   const std::string kData = "Data";
   base::Time response_time = base::Time::Now();

   // 1. Create and copy the entry.
   CreateAndRegisterSharedCacheEntry(backend.get(), kKey, kData, kNik,
                                     response_time);
   backend->RunUntilAllTasksCompleteForTest();

   auto client = std::make_unique<MockSharedCacheClientRemote>();
   auto* client_ptr = client.get();
   backend->RegisterSharedCacheClientRemote(kNik, std::move(client));

   base::RunLoop process_run_loop1;
   backend->ProcessSharedCacheEligibleEntriesForTest(
       base::ScopedClosureRunner(process_run_loop1.QuitClosure()),
       /*on_entry_copied_callback=*/base::NullCallback());

   client_ptr->WaitUntilInitialized();
   client_ptr->WaitUntilOnResourcesAdded(1);
   process_run_loop1.Run();

   EXPECT_EQ(client_ptr->on_resources_added_call_count(), 1u);
   EXPECT_THAT(client_ptr->new_hashes(),
               testing::ElementsAre(base::PersistentHash(kUrl.spec())));

   // 2. Mark the same entry eligible again and process.
   net::HttpResponseInfo info;
   info.response_time = response_time;
   info.headers =
       base::MakeRefCounted<net::HttpResponseHeaders>("HTTP/1.1 200 OK\0\0");
   backend->OnEntryEligibleForSharedCache(
       kKey, kUrl, std::make_unique<net::HttpResponseInfo>(info), kNik);

   base::RunLoop process_run_loop2;
   backend->ProcessSharedCacheEligibleEntriesForTest(
       base::ScopedClosureRunner(process_run_loop2.QuitClosure()),
       /*on_entry_copied_callback=*/base::NullCallback());
   process_run_loop2.Run();

   // OnResourcesAdded should NOT be called again because the hash is already
   // cached.
   EXPECT_EQ(client_ptr->on_resources_added_call_count(), 1u);

   client_ptr->RunDisconnectHandler();
   auto* manager =
       backend->GetSqlStoreForTest()->shared_cache_manager_for_testing();
   ASSERT_TRUE(base::test::RunUntil(
       [&]() { return manager->GetSharedCachesSizeForTest() == 0u; }));
 }

 TEST_F(SqlBackendImplSharedCacheTest,
        ProcessSharedCacheEligibleEntriesMultipleClientsBroadcast) {
   auto backend = CreateBackendAndInit();

   const net::SchemefulSite kSite(GURL("https://example.test"));
   const net::NetworkIsolationKey kNik(kSite, kSite);
   const std::string kKey = "0/0/https://example.test/";
   const GURL kUrl("https://example.test/");
   const std::string kData = "Data";

   CreateAndRegisterSharedCacheEntry(backend.get(), kKey, kData, kNik);
   backend->RunUntilAllTasksCompleteForTest();

   // Register two clients for the same NIK.
   auto client1 = std::make_unique<MockSharedCacheClientRemote>();
   auto* client_ptr1 = client1.get();
   backend->RegisterSharedCacheClientRemote(kNik, std::move(client1));

   auto client2 = std::make_unique<MockSharedCacheClientRemote>();
   auto* client_ptr2 = client2.get();
   backend->RegisterSharedCacheClientRemote(kNik, std::move(client2));

   base::RunLoop process_run_loop;
   backend->ProcessSharedCacheEligibleEntriesForTest(
       base::ScopedClosureRunner(process_run_loop.QuitClosure()),
       /*on_entry_copied_callback=*/base::NullCallback());

   client_ptr1->WaitUntilInitialized();
   client_ptr1->WaitUntilOnResourcesAdded(1);
   client_ptr2->WaitUntilInitialized();
   client_ptr2->WaitUntilOnResourcesAdded(1);
   process_run_loop.Run();

   // Both clients should receive OnResourcesAdded with the new hash.
   EXPECT_EQ(client_ptr1->on_resources_added_call_count(), 1u);
   EXPECT_THAT(client_ptr1->new_hashes(),
               testing::ElementsAre(base::PersistentHash(kUrl.spec())));

   EXPECT_EQ(client_ptr2->on_resources_added_call_count(), 1u);
   EXPECT_THAT(client_ptr2->new_hashes(),
               testing::ElementsAre(base::PersistentHash(kUrl.spec())));

   client_ptr1->RunDisconnectHandler();
   client_ptr2->RunDisconnectHandler();

   auto* manager =
       backend->GetSqlStoreForTest()->shared_cache_manager_for_testing();
   ASSERT_TRUE(base::test::RunUntil(
       [&]() { return manager->GetSharedCachesSizeForTest() == 0u; }));
 }

 TEST_F(SqlBackendImplSharedCacheTest,
        ProcessSharedCacheEligibleEntriesPartialClientDisconnect) {
   auto backend = CreateBackendAndInit();

   const net::SchemefulSite kSite(GURL("https://example.test"));
   const net::NetworkIsolationKey kNik(kSite, kSite);
   const std::string kKey1 = "0/0/https://example.test/1";
   const GURL kUrl1("https://example.test/1");
   const std::string kKey2 = "0/0/https://example.test/2";
   const GURL kUrl2("https://example.test/2");

   // Register two clients for the same NIK.
   bool client1_destroyed = false;
   auto client1 = std::make_unique<MockSharedCacheClientRemote>();
   client1->SetOnDestroyHandler(
       base::BindLambdaForTesting([&]() { client1_destroyed = true; }));
   auto* client_ptr1 = client1.get();
   backend->RegisterSharedCacheClientRemote(kNik, std::move(client1));

   auto client2 = std::make_unique<MockSharedCacheClientRemote>();
   auto* client_ptr2 = client2.get();
   backend->RegisterSharedCacheClientRemote(kNik, std::move(client2));

   // Copy entry 1.
   CreateAndRegisterSharedCacheEntry(backend.get(), kKey1, "Data 1", kNik);
   backend->RunUntilAllTasksCompleteForTest();

   base::RunLoop process_run_loop1;
   backend->ProcessSharedCacheEligibleEntriesForTest(
       base::ScopedClosureRunner(process_run_loop1.QuitClosure()),
       /*on_entry_copied_callback=*/base::NullCallback());

   client_ptr1->WaitUntilInitialized();
   client_ptr1->WaitUntilOnResourcesAdded(1);
   client_ptr2->WaitUntilInitialized();
   client_ptr2->WaitUntilOnResourcesAdded(1);
   process_run_loop1.Run();

   // Disconnect client 1.
   client_ptr1->RunDisconnectHandler();
   EXPECT_TRUE(client1_destroyed);

   // Copy entry 2.
   CreateAndRegisterSharedCacheEntry(backend.get(), kKey2, "Data 2", kNik);
   backend->RunUntilAllTasksCompleteForTest();

   base::RunLoop process_run_loop2;
   backend->ProcessSharedCacheEligibleEntriesForTest(
       base::ScopedClosureRunner(process_run_loop2.QuitClosure()),
       /*on_entry_copied_callback=*/base::NullCallback());

   client_ptr2->WaitUntilOnResourcesAdded(2);
   process_run_loop2.Run();

   // client 1 was destroyed upon disconnect, and client 2 receives call count 2.
   EXPECT_EQ(client_ptr2->on_resources_added_call_count(), 2u);
   EXPECT_THAT(client_ptr2->new_hashes(),
               testing::ElementsAre(base::PersistentHash(kUrl2.spec())));

   client_ptr2->RunDisconnectHandler();
   auto* manager =
       backend->GetSqlStoreForTest()->shared_cache_manager_for_testing();
   ASSERT_TRUE(base::test::RunUntil(
       [&]() { return manager->GetSharedCachesSizeForTest() == 0u; }));
 }

 TEST_F(SqlBackendImplSharedCacheTest,
        RegisterSharedCacheClientRemoteTransientNik) {
   auto backend = CreateBackendAndInit();
   auto transient_nik = net::NetworkIsolationKey::CreateTransientForTesting();
   ASSERT_TRUE(transient_nik.IsTransient());

   bool client_destroyed = false;
   auto client = std::make_unique<MockSharedCacheClientRemote>();
   client->SetOnDestroyHandler(
       base::BindLambdaForTesting([&]() { client_destroyed = true; }));

   backend->RegisterSharedCacheClientRemote(transient_nik, std::move(client));

   // The client should be destroyed immediately because transient NIKs are
   // ignored.
   EXPECT_TRUE(client_destroyed);

   auto* manager =
       backend->GetSqlStoreForTest()->shared_cache_manager_for_testing();
   EXPECT_EQ(manager->GetSharedCachesSizeForTest(), 0u);
 }

 TEST_F(SqlBackendImplSharedCacheTest,
        ProcessSharedCacheEligibleEntriesMultipleNiks) {
   auto backend = CreateBackendAndInit();

   const net::SchemefulSite kSite1(GURL("https://site1.test"));
   const net::NetworkIsolationKey kNik1(kSite1, kSite1);
   const net::SchemefulSite kSite2(GURL("https://site2.test"));
   const net::NetworkIsolationKey kNik2(kSite2, kSite2);

   const std::string kKey1 = "0/0/https://example1.test";
   const std::string kKey2 = "0/0/https://example2.test";

   CreateAndRegisterSharedCacheEntry(backend.get(), kKey1, "Data 1", kNik1);
   CreateAndRegisterSharedCacheEntry(backend.get(), kKey2, "Data 2", kNik2);
   backend->RunUntilAllTasksCompleteForTest();

   EXPECT_EQ(backend->GetSharedCacheEligibleEntriesCountForTest(), 2u);

   // Register clients
   auto client1 = std::make_unique<MockSharedCacheClientRemote>();
   auto* client_ptr1 = client1.get();
   backend->RegisterSharedCacheClientRemote(kNik1, std::move(client1));

   auto client2 = std::make_unique<MockSharedCacheClientRemote>();
   auto* client_ptr2 = client2.get();
   backend->RegisterSharedCacheClientRemote(kNik2, std::move(client2));

   // Process
   base::RunLoop process_run_loop;
   backend->ProcessSharedCacheEligibleEntriesForTest(
       base::ScopedClosureRunner(process_run_loop.QuitClosure()),
       /*on_entry_copied_callback=*/base::NullCallback());

   client_ptr1->WaitUntilInitialized();
   client_ptr1->WaitUntilOnResourcesAdded();
   client_ptr2->WaitUntilInitialized();
   client_ptr2->WaitUntilOnResourcesAdded();

   process_run_loop.Run();

   VerifySharedCacheResourceIdExists(backend.get(), kKey1);
   VerifySharedCacheResourceIdExists(backend.get(), kKey2);

   EXPECT_TRUE(client_ptr1->initialize_called());
   EXPECT_TRUE(client_ptr2->initialize_called());

   auto* manager =
       backend->GetSqlStoreForTest()->shared_cache_manager_for_testing();
   EXPECT_EQ(manager->GetSharedCachesSizeForTest(), 2u);

   client_ptr1->RunDisconnectHandler();
   client_ptr2->RunDisconnectHandler();

   ASSERT_TRUE(base::test::RunUntil(
       [&]() { return manager->GetSharedCachesSizeForTest() == 0u; }));
 }

 TEST_F(SqlBackendImplSharedCacheTest,
        ProcessSharedCacheEligibleEntriesDbFailure) {
   auto backend = CreateBackendAndInit();
   auto* manager =
       backend->GetSqlStoreForTest()->shared_cache_manager_for_testing();
   manager->SetSimulateDbFailureForTesting(true);

   const net::SchemefulSite kSite(GURL("https://example.test"));
   const net::NetworkIsolationKey kNik(kSite, kSite);
   const std::string kKey = "0/0/https://example.test";

   CreateAndRegisterSharedCacheEntry(backend.get(), kKey, "Hello Shared Cache",
                                     kNik);
   EXPECT_EQ(backend->GetSharedCacheEligibleEntriesCountForTest(), 1u);

   base::RunLoop destroy_run_loop;
   auto client = std::make_unique<MockSharedCacheClientRemote>();
   client->SetOnDestroyHandler(destroy_run_loop.QuitClosure());
   backend->RegisterSharedCacheClientRemote(kNik, std::move(client));

   base::RunLoop process_run_loop;
   backend->ProcessSharedCacheEligibleEntriesForTest(
       base::ScopedClosureRunner(process_run_loop.QuitClosure()),
       base::NullCallback());
   process_run_loop.Run();

   // On DB failure, processing fails and the entries are dropped, leaving 0
   // pending eligible entries.
   EXPECT_EQ(backend->GetSharedCacheEligibleEntriesCountForTest(), 0u);

   // Due to DB failure, processing fails and cache drops, which triggers client
   // destruction.
   destroy_run_loop.Run();

   ASSERT_TRUE(base::test::RunUntil(
       [&]() { return manager->GetSharedCachesSizeForTest() == 0u; }));
 }

 TEST_F(SqlBackendImplSharedCacheTest,
        ProcessSharedCacheEligibleEntriesSkipsActiveEntry) {
   auto backend = CreateBackendAndInit();

   const net::SchemefulSite kSite1(GURL("https://site1.test"));
   const net::NetworkIsolationKey kNik1(kSite1, kSite1);
   const net::SchemefulSite kSite2(GURL("https://site2.test"));
   const net::NetworkIsolationKey kNik2(kSite2, kSite2);

   const std::string kKey1 = "0/0/https://example1.test";
   const std::string kKey2 = "0/0/https://example2.test";

   // Create entry1 and entry2 and keep BOTH open (active).
   auto* entry1 = CreateAndRegisterSharedCacheEntry(
       backend.get(), kKey1, "Data 1", kNik1, base::Time::Now(),
       /*close_entry=*/false);
   auto* entry2 = CreateAndRegisterSharedCacheEntry(
       backend.get(), kKey2, "Data 2", kNik2, base::Time::Now(),
       /*close_entry=*/false);
   backend->RunUntilAllTasksCompleteForTest();

   EXPECT_EQ(backend->GetSharedCacheEligibleEntriesCountForTest(), 2u);

   // 1. When ALL entries are active, HandleProcessSharedCacheEligibleEntries
   // finds entries_to_process is empty and returns early without processing.
   base::RunLoop process_run_loop_all_active;
   backend->ProcessSharedCacheEligibleEntriesForTest(
       base::ScopedClosureRunner(process_run_loop_all_active.QuitClosure()),
       /*on_entry_copied_callback=*/base::NullCallback());
   process_run_loop_all_active.Run();
   backend->RunUntilAllTasksCompleteForTest();

   // Both entries were active, so 0 entries were processed, leaving 2 eligible
   // entries.
   EXPECT_EQ(backend->GetSharedCacheEligibleEntriesCountForTest(), 2u);

   // 2. Close entry2, keep entry1 open.
   entry2->Close();
   backend->RunUntilAllTasksCompleteForTest();

   base::RunLoop process_run_loop;
   backend->ProcessSharedCacheEligibleEntriesForTest(
       base::ScopedClosureRunner(process_run_loop.QuitClosure()),
       /*on_entry_copied_callback=*/base::NullCallback());

   process_run_loop.Run();
   backend->RunUntilAllTasksCompleteForTest();

   // entry1 was skipped (remains active/eligible), entry2 was processed.
   EXPECT_EQ(backend->GetSharedCacheEligibleEntriesCountForTest(), 1u);
   VerifySharedCacheResourceIdExists(backend.get(), kKey2);

   // 3. Close entry1 and process again.
   entry1->Close();
   backend->RunUntilAllTasksCompleteForTest();

   base::RunLoop process_run_loop2;
   backend->ProcessSharedCacheEligibleEntriesForTest(
       base::ScopedClosureRunner(process_run_loop2.QuitClosure()),
       /*on_entry_copied_callback=*/base::NullCallback());

   process_run_loop2.Run();
   backend->RunUntilAllTasksCompleteForTest();

   // entry1 should now be processed.
   EXPECT_EQ(backend->GetSharedCacheEligibleEntriesCountForTest(), 0u);
   VerifySharedCacheResourceIdExists(backend.get(), kKey1);
 }

 TEST_F(SqlBackendImplSharedCacheTest,
        OnEntryEligibleForSharedCacheUpdateWithNewerResponseTime) {
   auto backend = CreateBackendAndInit();
   const std::string kKey = "0/0/https://example.test";
   const GURL kUrl("https://example.test");
   const net::SchemefulSite kSite(GURL("https://example.test"));
   const net::NetworkIsolationKey kNik(kSite, kSite);

   base::Time now = base::Time::Now();

   // Register an entry initially.
   {
     auto response_info = std::make_unique<net::HttpResponseInfo>();
     response_info->response_time = now;
     response_info->headers =
         base::MakeRefCounted<net::HttpResponseHeaders>("HTTP/1.1 200 OK\n\n");
     backend->OnEntryEligibleForSharedCache(kKey, kUrl, std::move(response_info),
                                            kNik);
   }
   EXPECT_EQ(backend->GetSharedCacheEligibleEntriesCountForTest(), 1u);
   {
     const auto& map = backend->GetSharedCacheEligibleEntriesForTest();
     auto it = map.find(CacheEntryKey(kKey));
     ASSERT_NE(it, map.end());
     EXPECT_EQ(it->second.response_info->response_time, now);
   }

   // Register the same key with an older response_time. It should be ignored.
   {
     auto response_info = std::make_unique<net::HttpResponseInfo>();
     response_info->response_time = now - base::Seconds(10);
     response_info->headers =
         base::MakeRefCounted<net::HttpResponseHeaders>("HTTP/1.1 200 OK\n\n");
     backend->OnEntryEligibleForSharedCache(kKey, kUrl, std::move(response_info),
                                            kNik);
   }
   EXPECT_EQ(backend->GetSharedCacheEligibleEntriesCountForTest(), 1u);
   {
     const auto& map = backend->GetSharedCacheEligibleEntriesForTest();
     auto it = map.find(CacheEntryKey(kKey));
     ASSERT_NE(it, map.end());
     EXPECT_EQ(it->second.response_info->response_time, now);
   }

   // Register the same key with a newer response_time. It should execute the if
   // branch and update the entry.
   base::Time newer = now + base::Seconds(10);
   {
     auto response_info = std::make_unique<net::HttpResponseInfo>();
     response_info->response_time = newer;
     response_info->headers =
         base::MakeRefCounted<net::HttpResponseHeaders>("HTTP/1.1 200 OK\n\n");
     backend->OnEntryEligibleForSharedCache(kKey, kUrl, std::move(response_info),
                                            kNik);
   }
   EXPECT_EQ(backend->GetSharedCacheEligibleEntriesCountForTest(), 1u);
   {
     const auto& map = backend->GetSharedCacheEligibleEntriesForTest();
     auto it = map.find(CacheEntryKey(kKey));
     ASSERT_NE(it, map.end());
     EXPECT_EQ(it->second.response_info->response_time, newer);
   }
 }

 TEST_F(SqlBackendImplSharedCacheTest,
        OnProcessSharedCacheEligibleEntriesCompleteReinsertsUnprocessedEntries) {
   auto backend = CreateBackendAndInit();

   const std::string kKey1 = "0/0/https://example1.test";
   const std::string kKey2 = "0/0/https://example2.test";
   const std::string kKey3 = "0/0/https://example3.test";

   const net::SchemefulSite kSite1(GURL("https://site1.test"));
   const net::NetworkIsolationKey kNik1(kSite1, kSite1);
   const net::SchemefulSite kSite2(GURL("https://site2.test"));
   const net::NetworkIsolationKey kNik2(kSite2, kSite2);

   // kKey1 and kKey2 share kNik1; kKey3 uses kNik2.
   CreateAndRegisterSharedCacheEntry(backend.get(), kKey1, "Data 1", kNik1);
   CreateAndRegisterSharedCacheEntry(backend.get(), kKey2, "Data 2", kNik1);
   CreateAndRegisterSharedCacheEntry(backend.get(), kKey3, "Data 3", kNik2);
   backend->RunUntilAllTasksCompleteForTest();

   EXPECT_EQ(backend->GetSharedCacheEligibleEntriesCountForTest(), 3u);

   std::unique_ptr<OperationHandle> in_flight_handle;

   base::RunLoop process_run_loop;
   // When kKey1 finishes copying, post a normal operation so that CopyEntries
   // aborts remaining entries in the same NIK group (kKey2) and subsequent NIK
   // groups (kKey3).
   backend->ProcessSharedCacheEligibleEntriesForTest(
       base::ScopedClosureRunner(process_run_loop.QuitClosure()),
       base::BindRepeating(
           [](SqlBackendImpl* backend,
              std::unique_ptr<OperationHandle>* handle_out,
              const CacheEntryKey& key) {
             if (!*handle_out) {
               backend->GetExclusiveOperationCoordinatorForTest()
                   ->PostOrRunNormalOperation(
                       CacheEntryKey("fake_key_for_abort"),
                       base::BindOnce(
                           [](std::unique_ptr<OperationHandle>* out,
                              std::unique_ptr<OperationHandle> handle) {
                             *out = std::move(handle);
                           },
                           handle_out),
                       /*low_priority=*/false);
             }
           },
           backend.get(), &in_flight_handle));

   process_run_loop.Run();

   // kKey1 was processed; kKey2 (same NIK) and kKey3 (different NIK) were
   // aborted and re-inserted.
   EXPECT_EQ(backend->GetSharedCacheEligibleEntriesCountForTest(), 2u);

   // Release normal operation so backend becomes idle again.
   in_flight_handle.reset();

   base::RunLoop process_run_loop2;
   backend->ProcessAllSharedCacheEligibleEntriesForTest(
       base::ScopedClosureRunner(process_run_loop2.QuitClosure()),
       /*on_entry_copied_callback=*/base::NullCallback());
   process_run_loop2.Run();
   backend->RunUntilAllTasksCompleteForTest();

   // All entries should now be in shared cache.
   EXPECT_EQ(backend->GetSharedCacheEligibleEntriesCountForTest(), 0u);
   VerifySharedCacheResourceIdExists(backend.get(), kKey1);
   VerifySharedCacheResourceIdExists(backend.get(), kKey2);
   VerifySharedCacheResourceIdExists(backend.get(), kKey3);
 }

 TEST_F(SqlBackendImplSharedCacheTest,
        OnProcessSharedCacheEligibleEntriesCompleteConflictResponseTime) {
   auto backend = CreateBackendAndInit();

   const std::string kKey1 = "0/0/https://example1.test";
   const std::string kKey2 = "0/0/https://example2.test";
   const net::SchemefulSite kSite1(GURL("https://site1.test"));
   const net::NetworkIsolationKey kNik1(kSite1, kSite1);
   const net::SchemefulSite kSite2(GURL("https://site2.test"));
   const net::NetworkIsolationKey kNik2(kSite2, kSite2);

   base::Time now = base::Time::Now();
   base::Time t1 = now;

   CreateAndRegisterSharedCacheEntry(backend.get(), kKey1, "Data 1", kNik1, t1);
   CreateAndRegisterSharedCacheEntry(backend.get(), kKey2, "Data 2", kNik2, t1);
   backend->RunUntilAllTasksCompleteForTest();

   std::unique_ptr<OperationHandle> in_flight_handle;
   base::Time t0 = now - base::Seconds(10);

   base::RunLoop process_run_loop;
   backend->ProcessSharedCacheEligibleEntriesForTest(
       base::ScopedClosureRunner(process_run_loop.QuitClosure()),
       base::BindRepeating(
           [](SqlBackendImpl* backend,
              std::unique_ptr<OperationHandle>* handle_out,
              const std::string& key2, const GURL& url,
              const net::NetworkIsolationKey& nik, base::Time t0,
              const CacheEntryKey& key) {
             if (!*handle_out) {
               backend->GetExclusiveOperationCoordinatorForTest()
                   ->PostOrRunNormalOperation(
                       CacheEntryKey("fake_key_for_abort"),
                       base::BindOnce(
                           [](std::unique_ptr<OperationHandle>* out,
                              std::unique_ptr<OperationHandle> handle) {
                             *out = std::move(handle);
                           },
                           handle_out),
                       /*low_priority=*/false);
               auto info = std::make_unique<net::HttpResponseInfo>();
               info->response_time = t0;
               info->headers = base::MakeRefCounted<net::HttpResponseHeaders>(
                   "HTTP/1.1 200 OK\n\n");
               backend->OnEntryEligibleForSharedCache(key2, url, std::move(info),
                                                      nik);
             }
           },
           backend.get(), &in_flight_handle, kKey2,
           GURL(net::HttpCache::GetResourceURLFromHttpCacheKey(kKey2)), kNik2,
           t0));

   process_run_loop.Run();
   in_flight_handle.reset();
   backend->RunUntilAllTasksCompleteForTest();

   // Unprocessed entry t1 for kKey2 is newer than t0, so t1 overwrites t0.
   const auto& map1 = backend->GetSharedCacheEligibleEntriesForTest();
   auto it1 = map1.find(CacheEntryKey(kKey2));
   ASSERT_TRUE(it1 != map1.end());
   EXPECT_EQ(it1->second.response_info->response_time, t1);

   // 2. Test t2 > t1 case for kKey2.
   base::Time t2 = now + base::Seconds(10);

   // Register a new entry kKey3 instead of re-registering kKey1, because
   // kKey1 was already copied to the shared cache and will be skipped.
   const std::string kKey3 = "0/0/https://example3.test";
   CreateAndRegisterSharedCacheEntry(backend.get(), kKey3, "Data 3", kNik1, t1);

   base::RunLoop process_run_loop2;
   backend->ProcessSharedCacheEligibleEntriesForTest(
       base::ScopedClosureRunner(process_run_loop2.QuitClosure()),
       base::BindRepeating(
           [](SqlBackendImpl* backend,
              std::unique_ptr<OperationHandle>* handle_out,
              const std::string& key2, const GURL& url,
              const net::NetworkIsolationKey& nik, base::Time t2,
              const CacheEntryKey& key) {
             if (!*handle_out) {
               backend->GetExclusiveOperationCoordinatorForTest()
                   ->PostOrRunNormalOperation(
                       CacheEntryKey("fake_key_for_abort"),
                       base::BindOnce(
                           [](std::unique_ptr<OperationHandle>* out,
                              std::unique_ptr<OperationHandle> handle) {
                             *out = std::move(handle);
                           },
                           handle_out),
                       /*low_priority=*/false);
               auto info = std::make_unique<net::HttpResponseInfo>();
               info->response_time = t2;
               info->headers = base::MakeRefCounted<net::HttpResponseHeaders>(
                   "HTTP/1.1 200 OK\n\n");
               backend->OnEntryEligibleForSharedCache(key2, url, std::move(info),
                                                      nik);
             }
           },
           backend.get(), &in_flight_handle, kKey2,
           GURL(net::HttpCache::GetResourceURLFromHttpCacheKey(kKey2)), kNik2,
           t2));

   process_run_loop2.Run();
   in_flight_handle.reset();
   backend->RunUntilAllTasksCompleteForTest();

   const auto& map2 = backend->GetSharedCacheEligibleEntriesForTest();
   auto it2 = map2.find(CacheEntryKey(kKey2));
   ASSERT_TRUE(it2 != map2.end());
   EXPECT_EQ(it2->second.response_info->response_time, t2);
 }

 TEST_F(SqlBackendImplSharedCacheTest,
        ProcessAllSharedCacheEligibleEntriesForTest) {
   auto backend = CreateBackendAndInit();

   const std::string kKey1 = "0/0/https://example1.test";
   const std::string kKey2 = "0/0/https://example2.test";
   const net::SchemefulSite kSite1(GURL("https://site1.test"));
   const net::NetworkIsolationKey kNik1(kSite1, kSite1);
   const net::SchemefulSite kSite2(GURL("https://site2.test"));
   const net::NetworkIsolationKey kNik2(kSite2, kSite2);

   CreateAndRegisterSharedCacheEntry(backend.get(), kKey1, "Data 1", kNik1);
   CreateAndRegisterSharedCacheEntry(backend.get(), kKey2, "Data 2", kNik2);
   backend->RunUntilAllTasksCompleteForTest();

   auto verify_count_task = base::BindOnce(
       [](SqlBackendImpl* backend, std::unique_ptr<OperationHandle> handle) {
         // While `handle` is held, pass 1 has finished and re-inserted the
         // aborted entry (kKey2) into the queue.
         EXPECT_EQ(backend->GetSharedCacheEligibleEntriesCountForTest(), 1u);
       },
       backend.get());

   auto on_normal_op = base::BindOnce(
       [](base::OnceCallback<void(std::unique_ptr<OperationHandle>)> task,
          std::unique_ptr<OperationHandle> handle) {
         base::SequencedTaskRunner::GetCurrentDefault()->PostTask(
             FROM_HERE, base::BindOnce(std::move(task), std::move(handle)));
       },
       std::move(verify_count_task));

   using NormalOpCallback =
       base::OnceCallback<void(std::unique_ptr<OperationHandle>)>;
   auto on_normal_op_holder =
       std::make_unique<NormalOpCallback>(std::move(on_normal_op));

   auto on_entry_copied = base::BindRepeating(
       [](SqlBackendImpl* backend, NormalOpCallback* on_normal_op_holder,
          const CacheEntryKey& key) {
         if (*on_normal_op_holder) {
           backend->GetExclusiveOperationCoordinatorForTest()
               ->PostOrRunNormalOperation(CacheEntryKey("fake_key_for_abort"),
                                          std::move(*on_normal_op_holder),
                                          /*low_priority=*/false);
         }
       },
       backend.get(), base::Owned(on_normal_op_holder.release()));

   base::RunLoop process_run_loop;
   backend->ProcessAllSharedCacheEligibleEntriesForTest(
       base::ScopedClosureRunner(process_run_loop.QuitClosure()),
       std::move(on_entry_copied));

   process_run_loop.Run();

   EXPECT_EQ(backend->GetSharedCacheEligibleEntriesCountForTest(), 0u);
   VerifySharedCacheResourceIdExists(backend.get(), kKey1);
   VerifySharedCacheResourceIdExists(backend.get(), kKey2);
 }

 class SqlBackendImplSharedCacheWriteTest
     : public SqlBackendImplSharedCacheTest,
       public testing::WithParamInterface<bool> {
  public:
   SqlBackendImplSharedCacheWriteTest()
       : kSite(GURL("https://example.com")), kNik(kSite, kSite) {}

   static std::string DescribeParams(const testing::TestParamInfo<bool>& info) {
     return info.param ? "WithOtherEntry" : "SingleEntry";
   }

  protected:
   static constexpr char kTargetKey[] = "0/0/https://example.com/";
   static constexpr char kOtherKey[] = "0/0/https://example.com/2";

   const net::SchemefulSite kSite;
   const net::NetworkIsolationKey kNik;

   bool WithOtherEntry() const { return GetParam(); }

   void SetupSharedCacheEntries(
       std::unique_ptr<SqlBackendImpl>& backend,
       const std::string& data,
       std::optional<SqlSharedCacheDbId>& out_db_id,
       std::optional<SqlSharedCacheRowId>& out_row_id1,
       std::optional<SqlSharedCacheRowId>& out_row_id2) {
     // 1. Create first entry
     auto* entry = CreateEntryAndWriteData(backend.get(), kTargetKey, data);

     base::Time response_time = base::Time::Now();

     // Write headers for the first entry
     net::HttpResponseInfo response_info_for_pickle;
     response_info_for_pickle.response_time = response_time;
     response_info_for_pickle.headers =
         base::MakeRefCounted<net::HttpResponseHeaders>("HTTP/1.1 200 OK\0\0");
     std::unique_ptr<base::Pickle> pickle =
         response_info_for_pickle.MakePickle(false, false);
     std::string pickle_data(reinterpret_cast<const char*>(pickle->data()),
                             pickle->size());
     auto pickle_buffer = base::MakeRefCounted<net::StringIOBuffer>(pickle_data);
     net::TestCompletionCallback cb_write_pickle;
     EXPECT_EQ(cb_write_pickle.GetResult(
                   entry->WriteData(0, 0, pickle_buffer.get(), pickle->size(),
                                    cb_write_pickle.callback(), false)),
               static_cast<int>(pickle->size()));
     entry->Close();

     // 2. Make it eligible
     auto response_info = std::make_unique<net::HttpResponseInfo>();
     response_info->response_time = response_time;
     response_info->headers =
         base::MakeRefCounted<net::HttpResponseHeaders>("HTTP/1.1 200 OK\0\0");
     backend->OnEntryEligibleForSharedCache(kTargetKey,
                                            GURL("https://example.com/"),
                                            std::move(response_info), kNik);

     // If we want another entry in the same shared cache (same NIK)
     if (WithOtherEntry()) {
       task_environment_.FastForwardBy(base::Seconds(1));
       base::Time response_time2 = base::Time::Now();

       auto* entry2 = CreateEntryAndWriteData(backend.get(), kOtherKey, data);

       net::HttpResponseInfo response_info_for_pickle2;
       response_info_for_pickle2.response_time = response_time2;
       response_info_for_pickle2.headers =
           base::MakeRefCounted<net::HttpResponseHeaders>("HTTP/1.1 200 OK\0\0");
       std::unique_ptr<base::Pickle> pickle2 =
           response_info_for_pickle2.MakePickle(false, false);
       std::string pickle_data2(reinterpret_cast<const char*>(pickle2->data()),
                                pickle2->size());
       auto pickle_buffer2 =
           base::MakeRefCounted<net::StringIOBuffer>(pickle_data2);

       net::TestCompletionCallback cb_write_pickle2;
       EXPECT_EQ(cb_write_pickle2.GetResult(entry2->WriteData(
                     0, 0, pickle_buffer2.get(), pickle2->size(),
                     cb_write_pickle2.callback(), false)),
                 static_cast<int>(pickle2->size()));
       entry2->Close();

       auto response_info2 = std::make_unique<net::HttpResponseInfo>();
       response_info2->response_time = response_time2;
       response_info2->headers =
           base::MakeRefCounted<net::HttpResponseHeaders>("HTTP/1.1 200 OK\0\0");
       backend->OnEntryEligibleForSharedCache(kOtherKey,
                                              GURL("https://example.com/2"),
                                              std::move(response_info2), kNik);
     }

     base::RunLoop process_run_loop;
     backend->ProcessAllSharedCacheEligibleEntriesForTest(
         base::ScopedClosureRunner(process_run_loop.QuitClosure()),
         /*on_entry_copied_callback=*/base::NullCallback());
     process_run_loop.Run();
     backend->RunUntilAllTasksCompleteForTest();

     // After processing, re-open the entries to capture the row IDs.
     TestEntryResultCompletionCallback cb_open;
     disk_cache::EntryResult open_result = cb_open.GetResult(
         backend->OpenEntry(kTargetKey, net::HIGHEST, cb_open.callback()));
     ASSERT_EQ(open_result.net_error(), net::OK);
     auto* opened_entry = open_result.ReleaseEntry();

     auto* sql_entry = static_cast<SqlEntryImpl*>(opened_entry);
     auto shared_resource = sql_entry->db_handle()->shared_cache_resource_id();
     ASSERT_TRUE(shared_resource);
     out_db_id = shared_resource->db_id;
     out_row_id1 = shared_resource->row_id;
     opened_entry->Close();

     if (WithOtherEntry()) {
       TestEntryResultCompletionCallback cb_open2;
       disk_cache::EntryResult open_result2 = cb_open2.GetResult(
           backend->OpenEntry(kOtherKey, net::HIGHEST, cb_open2.callback()));
       ASSERT_EQ(open_result2.net_error(), net::OK);
       auto* opened_entry2 = open_result2.ReleaseEntry();

       auto* sql_entry2 = static_cast<SqlEntryImpl*>(opened_entry2);
       auto shared_resource2 =
           sql_entry2->db_handle()->shared_cache_resource_id();
       ASSERT_TRUE(shared_resource2);
       out_row_id2 = shared_resource2->row_id;
       opened_entry2->Close();
     }
     backend->RunUntilAllTasksCompleteForTest();
   }

   void VerifySharedCacheDeleted(SqlBackendImpl* backend,
                                 std::optional<SqlSharedCacheDbId> db_id,
                                 std::optional<SqlSharedCacheRowId> row_id) {
     backend->RunUntilAllTasksCompleteForTest();

     base::FilePath file_path =
         temp_dir_.GetPath()
             .AppendASCII(
                 base::StrCat({kSqlBackendSharedCacheIsolatedFileNamePrefix,
                               base::NumberToString(db_id->value())}))
             .AddExtension(FILE_PATH_LITERAL(".db"));

     if (WithOtherEntry()) {
       // DB should still exist
       EXPECT_TRUE(base::PathExists(file_path));

       // Verify that the target entry (key) does not exist.
       {
         base::test::TestFuture<SqlPersistentStore::EntryInfoOrError> future;
         backend->GetSqlStoreForTest()->OpenEntry(CacheEntryKey(kTargetKey),
                                                  future.GetCallback());
         auto result = future.Take();
         EXPECT_FALSE(result.has_value());
       }

       // The other remaining entry (key + "2") should still be in shared cache.
       {
         base::test::TestFuture<SqlPersistentStore::EntryInfoOrError> future;
         backend->GetSqlStoreForTest()->OpenEntry(CacheEntryKey(kOtherKey),
                                                  future.GetCallback());
         auto result = future.Take();
         ASSERT_TRUE(result.has_value());
         EXPECT_TRUE(result->shared_cache_resource_id.has_value());
       }
     } else {
       // Whole DB should be gone
       EXPECT_TRUE(
           base::test::RunUntil([&]() { return !base::PathExists(file_path); }));
     }
     backend->RunUntilAllTasksCompleteForTest();
   }
 };

 INSTANTIATE_TEST_SUITE_P(All,
                          SqlBackendImplSharedCacheWriteTest,
                          testing::Bool(),
                          SqlBackendImplSharedCacheWriteTest::DescribeParams);

 TEST_P(SqlBackendImplSharedCacheWriteTest,
        WriteDataInternalOffsetZeroTruncate) {
   auto backend = CreateBackendAndInit();

   std::optional<SqlSharedCacheDbId> db_id;
   std::optional<SqlSharedCacheRowId> row_id1;
   std::optional<SqlSharedCacheRowId> row_id2;

   SetupSharedCacheEntries(backend, "Data", db_id, row_id1, row_id2);

   // Open the entry again
   TestEntryResultCompletionCallback cb_open;
   disk_cache::EntryResult open_result = cb_open.GetResult(
       backend->OpenEntry(kTargetKey, net::HIGHEST, cb_open.callback()));
   ASSERT_EQ(open_result.net_error(), net::OK);
   auto* entry = open_result.ReleaseEntry();

   // WriteData at offset 0 and truncate
   auto buffer = base::MakeRefCounted<net::StringIOBuffer>("New Data");
   net::TestCompletionCallback cb_write;
   EXPECT_EQ(cb_write.GetResult(entry->WriteData(
                 1, 0, buffer.get(), buffer->size(), cb_write.callback(), true)),
             static_cast<int>(buffer->size()));

   entry->Close();

   VerifySharedCacheDeleted(backend.get(), db_id, row_id1);
 }

 TEST_P(SqlBackendImplSharedCacheWriteTest, WriteDataInternalCopySmall) {
   auto backend = CreateBackendAndInit();

   std::optional<SqlSharedCacheDbId> db_id;
   std::optional<SqlSharedCacheRowId> row_id1;
   std::optional<SqlSharedCacheRowId> row_id2;

   // Data < 16KB
   SetupSharedCacheEntries(backend, "Small Data", db_id, row_id1, row_id2);

   TestEntryResultCompletionCallback cb_open;
   disk_cache::EntryResult open_result = cb_open.GetResult(
       backend->OpenEntry(kTargetKey, net::HIGHEST, cb_open.callback()));
   ASSERT_EQ(open_result.net_error(), net::OK);
   auto* entry = open_result.ReleaseEntry();

   // WriteData NOT offset 0 && truncate
   auto buffer = base::MakeRefCounted<net::StringIOBuffer>("Append");
   net::TestCompletionCallback cb_write;
   EXPECT_EQ(
       cb_write.GetResult(entry->WriteData(1, 5, buffer.get(), buffer->size(),
                                           cb_write.callback(), false)),
       static_cast<int>(buffer->size()));

   const std::string expected_data = "SmallAppend";
   EXPECT_EQ(entry->GetDataSize(1), static_cast<int>(expected_data.size()));
   auto read_buffer =
       base::MakeRefCounted<net::IOBufferWithSize>(expected_data.size());
   net::TestCompletionCallback cb_read;
   EXPECT_EQ(
       cb_read.GetResult(entry->ReadData(
           1, 0, read_buffer.get(), read_buffer->size(), cb_read.callback())),
       static_cast<int>(expected_data.size()));
   EXPECT_EQ(std::string_view(read_buffer->data(), read_buffer->size()),
             expected_data);

   entry->Close();

   VerifySharedCacheDeleted(backend.get(), db_id, row_id1);
 }

 TEST_P(SqlBackendImplSharedCacheWriteTest, WriteDataInternalCopyLarge) {
   auto backend = CreateBackendAndInit();

   std::optional<SqlSharedCacheDbId> db_id;
   std::optional<SqlSharedCacheRowId> row_id1;
   std::optional<SqlSharedCacheRowId> row_id2;

   // Data > 16KB to trigger multiple copy iterations
   std::string large_data(20 * 1024, '\0');
   for (size_t i = 0; i < large_data.size(); ++i) {
     large_data[i] = static_cast<char>('a' + (i % 26));
   }
   SetupSharedCacheEntries(backend, large_data, db_id, row_id1, row_id2);

   TestEntryResultCompletionCallback cb_open;
   disk_cache::EntryResult open_result = cb_open.GetResult(
       backend->OpenEntry(kTargetKey, net::HIGHEST, cb_open.callback()));
   ASSERT_EQ(open_result.net_error(), net::OK);
   auto* entry = open_result.ReleaseEntry();

   // WriteData NOT offset 0 && truncate
   auto buffer = base::MakeRefCounted<net::StringIOBuffer>("Append");
   net::TestCompletionCallback cb_write;
   EXPECT_EQ(cb_write.GetResult(entry->WriteData(1, large_data.size(),
                                                 buffer.get(), buffer->size(),
                                                 cb_write.callback(), false)),
             static_cast<int>(buffer->size()));

   const std::string expected_large_data = large_data + "Append";
   EXPECT_EQ(entry->GetDataSize(1),
             static_cast<int>(expected_large_data.size()));
   auto read_buffer_large =
       base::MakeRefCounted<net::IOBufferWithSize>(expected_large_data.size());
   net::TestCompletionCallback cb_read_large;
   EXPECT_EQ(cb_read_large.GetResult(entry->ReadData(
                 1, 0, read_buffer_large.get(), read_buffer_large->size(),
                 cb_read_large.callback())),
             static_cast<int>(expected_large_data.size()));
   EXPECT_EQ(
       std::string_view(read_buffer_large->data(), read_buffer_large->size()),
       expected_large_data);

   entry->Close();

   VerifySharedCacheDeleted(backend.get(), db_id, row_id1);
 }

 TEST_P(SqlBackendImplSharedCacheWriteTest,
        CopySharedCacheToBlobTableInFlightModification) {
   auto backend = CreateBackendAndInit();

   std::optional<SqlSharedCacheDbId> db_id;
   std::optional<SqlSharedCacheRowId> row_id1;
   std::optional<SqlSharedCacheRowId> row_id2;

   SetupSharedCacheEntries(backend, "Small Data", db_id, row_id1, row_id2);

   TestEntryResultCompletionCallback cb_open;
   disk_cache::EntryResult open_result = cb_open.GetResult(
       backend->OpenEntry(kTargetKey, net::HIGHEST, cb_open.callback()));
   ASSERT_EQ(open_result.net_error(), net::OK);
   auto* entry = open_result.ReleaseEntry();

   // Post `OpenNextEntry` on the iterator beforehand.
   // Then calling `WriteData` creates a scenario where the iterator's DB record
   // lookup and entry instantiation happen asynchronously while the background
   // copy operation (`CopySharedCacheToBlobTableAndWrite`) is in progress.
   auto iter = backend->CreateIterator();
   TestEntryResultCompletionCallback cb_next1;
   EntryResult result_iter = iter->OpenNextEntry(cb_next1.callback());

   auto buffer = base::MakeRefCounted<net::StringIOBuffer>("Append");
   base::test::TestFuture<int> write_future;
   std::ignore = entry->WriteData(1, 10, buffer.get(), buffer->size(),
                                  write_future.GetCallback(), false);
   entry->Close();

   // Retrieve the result of the iterator's open operation.
   result_iter = cb_next1.GetResult(std::move(result_iter));
   ASSERT_THAT(result_iter.net_error(), IsOk());
   entry = result_iter.ReleaseEntry();
   // When WithOtherEntry() is true, another entry in the shared cache might be
   // returned first, so advance the iterator until we reach `kTargetKey`.
   if (entry->GetKey() != kTargetKey) {
     entry->Close();
     TestEntryResultCompletionCallback cb_next2;
     result_iter = iter->OpenNextEntry(cb_next2.callback());
     result_iter = cb_next2.GetResult(std::move(result_iter));
     ASSERT_THAT(result_iter.net_error(), IsOk());
     entry = result_iter.ReleaseEntry();
   }
   EXPECT_EQ(entry->GetKey(), std::string(kTargetKey));

   // Verify that `InFlightEntryModification` is preserved and applied during
   // `CopySharedCacheToBlobTableAndWrite`, so the `body_end` of the entry opened
   // by the iterator reflects the written data size (10 + 6 = 16).
   EXPECT_EQ(entry->GetDataSize(1), 16);

   entry->Close();

   EXPECT_EQ(write_future.Get(), static_cast<int>(buffer->size()));

   VerifySharedCacheDeleted(backend.get(), db_id, row_id1);
 }

 TEST_P(SqlBackendImplSharedCacheWriteTest,
        CopySharedCacheToBlobTableAbortOnBackendDestruction) {
   auto backend = CreateBackendAndInit();

   std::optional<SqlSharedCacheDbId> db_id;
   std::optional<SqlSharedCacheRowId> row_id1;
   std::optional<SqlSharedCacheRowId> row_id2;

   SetupSharedCacheEntries(backend, "Small Data", db_id, row_id1, row_id2);

   TestEntryResultCompletionCallback cb_open;
   disk_cache::EntryResult open_result = cb_open.GetResult(
       backend->OpenEntry(kTargetKey, net::HIGHEST, cb_open.callback()));
   ASSERT_EQ(open_result.net_error(), net::OK);
   auto* entry = open_result.ReleaseEntry();

   auto buffer = base::MakeRefCounted<net::StringIOBuffer>("Append");
   base::test::TestFuture<int> write_future;
   std::ignore = entry->WriteData(1, 5, buffer.get(), buffer->size(),
                                  write_future.GetCallback(), false);

   entry->Close();
   backend.reset();

   EXPECT_EQ(write_future.Get(), net::ERR_ABORTED);
 }

 TEST_P(SqlBackendImplSharedCacheWriteTest,
        CopySharedCacheToBlobTableDbHandleHasError) {
   auto backend = CreateBackendAndInit();

   std::optional<SqlSharedCacheDbId> db_id;
   std::optional<SqlSharedCacheRowId> row_id1;
   std::optional<SqlSharedCacheRowId> row_id2;

   SetupSharedCacheEntries(backend, "Small Data", db_id, row_id1, row_id2);

   TestEntryResultCompletionCallback cb_open;
   disk_cache::EntryResult open_result = cb_open.GetResult(
       backend->OpenEntry(kTargetKey, net::HIGHEST, cb_open.callback()));
   ASSERT_EQ(open_result.net_error(), net::OK);
   auto* entry = open_result.ReleaseEntry();

   auto* sql_entry = static_cast<SqlEntryImpl*>(entry);
   sql_entry->db_handle()->MarkAsErrorOccurred(
       SqlPersistentStore::Error::kFailedForTesting);

   auto buffer = base::MakeRefCounted<net::StringIOBuffer>("Append");
   net::TestCompletionCallback cb_write;
   EXPECT_EQ(
       cb_write.GetResult(entry->WriteData(1, 5, buffer.get(), buffer->size(),
                                           cb_write.callback(), false)),
       net::ERR_FAILED);

   entry->Close();
   backend->RunUntilAllTasksCompleteForTest();
 }

 TEST_P(SqlBackendImplSharedCacheWriteTest,
        CopySharedCacheToBlobTableReadFromSharedCacheFailure) {
   auto backend = CreateBackendAndInit();

   std::optional<SqlSharedCacheDbId> db_id;
   std::optional<SqlSharedCacheRowId> row_id1;
   std::optional<SqlSharedCacheRowId> row_id2;

   SetupSharedCacheEntries(backend, "Small Data", db_id, row_id1, row_id2);

   TestEntryResultCompletionCallback cb_open;
   disk_cache::EntryResult open_result = cb_open.GetResult(
       backend->OpenEntry(kTargetKey, net::HIGHEST, cb_open.callback()));
   ASSERT_EQ(open_result.net_error(), net::OK);
   auto* entry = open_result.ReleaseEntry();

   // Set invalid shared_cache_resource_id so ReadFromSharedCache fails with
   // kNotFound.
   auto* sql_entry = static_cast<SqlEntryImpl*>(entry);
   sql_entry->db_handle()->set_shared_cache_resource_id(SqlSharedCacheResourceId(
       SqlSharedCacheDbId(99999), SqlSharedCacheRowId(99999)));

   auto buffer = base::MakeRefCounted<net::StringIOBuffer>("Append");
   net::TestCompletionCallback cb_write;
   EXPECT_EQ(
       cb_write.GetResult(entry->WriteData(1, 5, buffer.get(), buffer->size(),
                                           cb_write.callback(), false)),
       net::ERR_FAILED);
   EXPECT_TRUE(sql_entry->db_handle()->GetError().has_value());

   entry->Close();
   backend->RunUntilAllTasksCompleteForTest();
 }

 TEST_P(SqlBackendImplSharedCacheWriteTest,
        CopySharedCacheToBlobTableWriteToBlobTableFailure) {
   auto backend = CreateBackendAndInit();

   std::optional<SqlSharedCacheDbId> db_id;
   std::optional<SqlSharedCacheRowId> row_id1;
   std::optional<SqlSharedCacheRowId> row_id2;

   SetupSharedCacheEntries(backend, "Small Data", db_id, row_id1, row_id2);

   TestEntryResultCompletionCallback cb_open;
   disk_cache::EntryResult open_result = cb_open.GetResult(
       backend->OpenEntry(kTargetKey, net::HIGHEST, cb_open.callback()));
   ASSERT_EQ(open_result.net_error(), net::OK);
   auto* entry = open_result.ReleaseEntry();

   // Force store to simulate DB failure so WriteEntryData fails.
   backend->GetSqlStoreForTest()->SetSimulateDbFailureForTesting(true);

   auto buffer = base::MakeRefCounted<net::StringIOBuffer>("Append");
   net::TestCompletionCallback cb_write;
   EXPECT_EQ(
       cb_write.GetResult(entry->WriteData(1, 5, buffer.get(), buffer->size(),
                                           cb_write.callback(), false)),
       net::ERR_FAILED);
   auto* sql_entry = static_cast<SqlEntryImpl*>(entry);
   EXPECT_TRUE(sql_entry->db_handle()->GetError().has_value());

   entry->Close();
   backend->RunUntilAllTasksCompleteForTest();
 }

 }  // namespace
 }  // namespace disk_cache