net/http/http_cache.h

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

// This file declares a HttpTransactionFactory implementation that can be
// layered on top of another HttpTransactionFactory to add HTTP caching.  The
// caching logic follows RFC 7234 (any exceptions are called out in the code).
//
// The HttpCache takes a disk_cache::Backend as a parameter, and uses that for
// the cache storage.
//
// See HttpTransactionFactory and HttpTransaction for more details.

#ifndef NET_HTTP_HTTP_CACHE_H_
#define NET_HTTP_HTTP_CACHE_H_

#include <list>
#include <map>
#include <memory>
#include <optional>
#include <set>
#include <string>
#include <unordered_map>
#include <unordered_set>

#include "base/containers/flat_set.h"
#include "base/containers/lru_cache.h"
#include "base/containers/span.h"
#include "base/files/file_path.h"
#include "base/functional/callback.h"
#include "base/gtest_prod_util.h"
#include "base/hash/sha1.h"
#include "base/memory/raw_ptr.h"
#include "base/memory/scoped_refptr.h"
#include "base/memory/weak_ptr.h"
#include "base/threading/thread_checker.h"
#include "base/time/clock.h"
#include "build/build_config.h"
#include "net/base/cache_type.h"
#include "net/base/completion_once_callback.h"
#include "net/base/does_url_match_filter.h"
#include "net/base/load_states.h"
#include "net/base/net_errors.h"
#include "net/base/net_export.h"
#include "net/base/request_priority.h"
#include "net/disk_cache/disk_cache.h"
#include "net/http/http_transaction_factory.h"
#include "net/http/no_vary_search_cache.h"
#include "net/http/no_vary_search_cache_storage.h"

class GURL;

namespace base {
class Time;
}

namespace url {
class Origin;
}

namespace net {

class HttpNetworkSession;
class HttpResponseInfo;
class NetLog;
class NetworkIsolationKey;
class NoVarySearchCacheStorageFileOperations;
struct HttpRequestInfo;

class NET_EXPORT HttpCache : public HttpTransactionFactory {
 public:
  // The cache mode of operation.
  enum Mode {
    // Normal mode just behaves like a standard web cache.
    NORMAL = 0,
    // Disables reads and writes from the cache.
    // Equivalent to setting LOAD_DISABLE_CACHE on every request.
    DISABLE
  };

  // A BackendFactory creates a backend object to be used by the HttpCache.
  class NET_EXPORT BackendFactory {
   public:
    virtual ~BackendFactory() = default;

    // The actual method to build the backend. The return value and `callback`
    // conventions match disk_cache::CreateCacheBackend
    //
    // The implementation must not access the factory object after invoking the
    // `callback` because the object can be deleted from within the callback.
    virtual disk_cache::BackendResult CreateBackend(
        NetLog* net_log,
        base::OnceCallback<void(disk_cache::BackendResult)> callback) = 0;

#if BUILDFLAG(IS_ANDROID)
    virtual void SetAppStatusListenerGetter(
        disk_cache::ApplicationStatusListenerGetter
            app_status_listener_getter) {}
#endif
  };

  // A default backend factory for the common use cases.
  class NET_EXPORT DefaultBackend : public BackendFactory {
   public:
    // `file_operations_factory` can be null, in that case
    // TrivialFileOperationsFactory is used. `path` is the destination for any
    // files used by the backend. If `max_bytes` is  zero, a default value
    // will be calculated automatically.
    DefaultBackend(CacheType type,
                   BackendType backend_type,
                   scoped_refptr<disk_cache::BackendFileOperationsFactory>
                       file_operations_factory,
                   const base::FilePath& path,
                   int max_bytes,
                   bool hard_reset);
    ~DefaultBackend() override;

    // Returns a factory for an in-memory cache.
    static std::unique_ptr<BackendFactory> InMemory(int max_bytes);

    // BackendFactory implementation.
    disk_cache::BackendResult CreateBackend(
        NetLog* net_log,
        base::OnceCallback<void(disk_cache::BackendResult)> callback) override;

#if BUILDFLAG(IS_ANDROID)
    void SetAppStatusListenerGetter(disk_cache::ApplicationStatusListenerGetter
                                        app_status_listener_getter) override;
#endif

   private:
    CacheType type_;
    BackendType backend_type_;
    const scoped_refptr<disk_cache::BackendFileOperationsFactory>
        file_operations_factory_;
    const base::FilePath path_;
    int max_bytes_;
    bool hard_reset_;
#if BUILDFLAG(IS_ANDROID)
    disk_cache::ApplicationStatusListenerGetter app_status_listener_getter_;
#endif
  };

  // Whether a transaction can join parallel writing or not is a function of the
  // transaction as well as the current writers (if present). This enum
  // captures that decision as well as when a Writers object is first created.
  // This is also used to log metrics so should be consistent with the values in
  // enums.xml and should only be appended to.
  enum ParallelWritingPattern {
    // Used as the default value till the transaction is in initial headers
    // phase.
    PARALLEL_WRITING_NONE,
    // The transaction creates a writers object. This is only logged for
    // transactions that did not fail to join existing writers earlier.
    PARALLEL_WRITING_CREATE,
    // The transaction joins existing writers.
    PARALLEL_WRITING_JOIN,
    // The transaction cannot join existing writers since either itself or
    // existing writers instance is serving a range request.
    PARALLEL_WRITING_NOT_JOIN_RANGE,
    // The transaction cannot join existing writers since either itself or
    // existing writers instance is serving a non GET request.
    PARALLEL_WRITING_NOT_JOIN_METHOD_NOT_GET,
    // The transaction cannot join existing writers since it does not have cache
    // write privileges.
    PARALLEL_WRITING_NOT_JOIN_READ_ONLY,
    // Writers does not exist and the transaction does not need to create one
    // since it is going to read from the cache.
    PARALLEL_WRITING_NONE_CACHE_READ,
    // Unable to join since the entry is too big for cache backend to handle.
    PARALLEL_WRITING_NOT_JOIN_TOO_BIG_FOR_CACHE,
    // On adding a value here, make sure to add in enums.xml as well.
    PARALLEL_WRITING_MAX
  };

  // The number of minutes after a resource is prefetched that it can be used
  // again without validation.
  static const int kPrefetchReuseMins = 5;

  // Initialize the cache from its component parts. |network_layer| and
  // |backend_factory| will be destroyed when the HttpCache is.
  HttpCache(
      std::unique_ptr<HttpTransactionFactory> network_layer,
      std::unique_ptr<BackendFactory> backend_factory,
      std::unique_ptr<NoVarySearchCacheStorageFileOperations> file_operations);

  HttpCache(const HttpCache&) = delete;
  HttpCache& operator=(const HttpCache&) = delete;

  ~HttpCache() override;

  HttpTransactionFactory* network_layer() { return network_layer_.get(); }

  using GetBackendResult = std::pair<int, raw_ptr<disk_cache::Backend>>;
  using GetBackendCallback = base::OnceCallback<void(GetBackendResult)>;
  // Retrieves the cache backend for this HttpCache instance. If the backend
  // is not initialized yet, this method will initialize it. The integer portion
  // of the return value is a network error code, and it could be
  // ERR_IO_PENDING, in which case the `callback` will be notified when the
  // operation completes.
  // `callback` will get cancelled if the HttpCache is destroyed.
  GetBackendResult GetBackend(GetBackendCallback callback);

  // Returns the current backend (can be NULL).
  disk_cache::Backend* GetCurrentBackend() const;

  // Given a header data blob, convert it to a response info object.
  static bool ParseResponseInfo(base::span<const uint8_t> data,
                                HttpResponseInfo* response_info,
                                bool* response_truncated);

  // Get/Set the cache's mode.
  void set_mode(Mode value) { mode_ = value; }
  Mode mode() { return mode_; }

  // Get/Set the cache's clock. These are public only for testing.
  void SetClockForTesting(base::Clock* clock) { clock_ = clock; }
  base::Clock* clock() const { return clock_; }

  // Close currently active sockets so that fresh page loads will not use any
  // recycled connections.  For sockets currently in use, they may not close
  // immediately, but they will not be reusable. This is for debugging.
  void CloseAllConnections(int net_error, const char* net_log_reason_utf8);

  // Close all idle connections. Will close all sockets not in active use.
  void CloseIdleConnections(const char* net_log_reason_utf8);

  // Called whenever an external cache in the system reuses the resource
  // referred to by `url`, `http_method`, `network_isolation_key`, and
  // `include_credentials`.
  void OnExternalCacheHit(const GURL& url,
                          const std::string& http_method,
                          const NetworkIsolationKey& network_isolation_key,
                          bool include_credentials);

  // Delete entries matching the criteria `filter_type`, `origins`, `domains`,
  // `delete_begin` and `delete_end` from the NoVarySearchCache and refresh the
  // on-disk cache snapshot to reflect the removals if necessary. See
  // no_vary_search_cache.h for the definition of the parameters.
  void ClearNoVarySearchCache(UrlFilterType filter_type,
                              const base::flat_set<url::Origin>& origins,
                              const base::flat_set<std::string>& domains,
                              base::Time delete_begin,
                              base::Time delete_end);

  // Causes all transactions created after this point to simulate lock timeout
  // and effectively bypass the cache lock whenever there is lock contention.
  void SimulateCacheLockTimeoutForTesting() { bypass_lock_for_test_ = true; }

  // Causes all transactions created after this point to simulate lock timeout
  // and effectively bypass the cache lock whenever there is lock contention
  // after the transaction has completed its headers phase.
  void SimulateCacheLockTimeoutAfterHeadersForTesting() {
    bypass_lock_after_headers_for_test_ = true;
  }

  void DelayAddTransactionToEntryForTesting() {
    delay_add_transaction_to_entry_for_test_ = true;
  }

  // Causes all transactions created after this point to generate a failure
  // when attempting to conditionalize a network request.
  void FailConditionalizationForTest() {
    fail_conditionalization_for_test_ = true;
  }

  // HttpTransactionFactory implementation:
  std::unique_ptr<HttpTransaction> CreateTransaction(
      RequestPriority priority) override;
  HttpCache* GetCache() override;
  HttpNetworkSession* GetSession() override;

  base::WeakPtr<HttpCache> GetWeakPtr() { return weak_factory_.GetWeakPtr(); }

  // Resets the network layer to allow for tests that probe
  // network changes (e.g. host unreachable).  The old network layer is
  // returned to allow for filter patterns that only intercept
  // some creation requests.  Note ownership exchange.
  std::unique_ptr<HttpTransactionFactory>
  SetHttpNetworkTransactionFactoryForTesting(
      std::unique_ptr<HttpTransactionFactory> new_network_layer);

  // Get the URL from the entry's cache key.
  static std::string GetResourceURLFromHttpCacheKey(const std::string& key);

  // Generates the cache key for a request.
  static std::optional<std::string> GenerateCacheKeyForRequest(
      const HttpRequestInfo* request);

  // Generates the cache key for a request, but using a different URL. This is
  // more efficient than copying the HttpRequestInfo object and changing the
  // URL.
  static std::optional<std::string> GenerateCacheKeyForRequestWithAlternateURL(
      const HttpRequestInfo* request,
      const GURL& url);

  // Enable split cache feature if not already overridden in the feature list.
  // Should only be invoked during process initialization before the HTTP
  // cache is initialized.
  static void SplitCacheFeatureEnableByDefault();

  // Returns true if split cache is enabled either by default or by other means
  // like command line or field trials.
  static bool IsSplitCacheEnabled();

  // Resets g_init_cache and g_enable_split_cache for tests.
  static void ClearGlobalsForTesting();

 private:
  // Types --------------------------------------------------------------------

  // The type of operation represented by a work item.
  enum WorkItemOperation {
    WI_CREATE_BACKEND,
    WI_OPEN_OR_CREATE_ENTRY,
    WI_OPEN_ENTRY,
    WI_CREATE_ENTRY,
    WI_DOOM_ENTRY
  };

  // Disk cache entry data indices.
  enum {
    kResponseInfoIndex = 0,
    kResponseContentIndex,
    kDeprecatedMetadataIndex,
    // Must remain at the end of the enum.
    kNumCacheEntryDataIndices
  };

  class QuicServerInfoFactoryAdaptor;
  class Transaction;
  class WorkItem;
  class Writers;

  friend class WritersTest;
  friend class TestHttpCacheTransaction;
  friend class TestHttpCache;
  friend class Transaction;
  struct PendingOp;  // Info for an entry under construction.

  // To help with testing.
  friend class MockHttpCache;
  friend class HttpCacheIOCallbackTest;

  FRIEND_TEST_ALL_PREFIXES(HttpCacheTest_SplitCacheFeatureEnabled,
                           SplitCacheWithNetworkIsolationKey);
  FRIEND_TEST_ALL_PREFIXES(HttpCacheTest, NonSplitCache);
  FRIEND_TEST_ALL_PREFIXES(HttpCacheTest_SplitCacheFeatureEnabled, SplitCache);
  FRIEND_TEST_ALL_PREFIXES(HttpCacheTest_SplitCacheFeatureEnabled,
                           SplitCacheUsesRegistrableDomain);

  using TransactionList = std::list<raw_ptr<Transaction, CtnExperimental>>;
  using TransactionSet =
      std::unordered_set<raw_ptr<Transaction, CtnExperimental>>;
  typedef std::list<std::unique_ptr<WorkItem>> WorkItemList;

  // We implement a basic reader/writer lock for the disk cache entry. If there
  // is a writer, then all transactions must wait to read the body. But the
  // waiting transactions can start their headers phase in parallel. Headers
  // phase is allowed for one transaction at a time so that if it doesn't match
  // the existing headers, remaining transactions do not also try to match the
  // existing entry in parallel leading to wasted network requests. If the
  // headers do not match, this entry will be doomed.
  //
  // A transaction goes through these state transitions.
  //
  // Write mode transactions eligible for shared writing:
  // add_to_entry_queue-> headers_transaction -> writers (first writer)
  // add_to_entry_queue-> headers_transaction -> done_headers_queue -> writers
  // (subsequent writers)
  // add_to_entry_queue-> headers_transaction -> done_headers_queue -> readers
  // (transactions not eligible for shared writing - once the data is written to
  // the cache by writers)
  //
  // Read only transactions:
  // add_to_entry_queue-> headers_transaction -> done_headers_queue -> readers
  // (once the data is written to the cache by writers)

  class NET_EXPORT_PRIVATE ActiveEntry : public base::RefCounted<ActiveEntry> {
   public:
    ActiveEntry(base::WeakPtr<HttpCache> cache,
                disk_cache::Entry* entry,
                bool opened_in);

    ActiveEntry(ActiveEntry const&) = delete;
    ActiveEntry& operator=(ActiveEntry const&) = delete;

    disk_cache::Entry* GetEntry() { return disk_entry_.get(); }

    bool opened() const { return opened_; }

    void set_opened(bool opened) { opened_ = opened; }

    bool will_process_queued_transactions() {
      return will_process_queued_transactions_;
    }

    void set_will_process_queued_transactions(
        bool will_process_queued_transactions) {
      will_process_queued_transactions_ = will_process_queued_transactions;
    }

    TransactionList& add_to_entry_queue() { return add_to_entry_queue_; }

    TransactionList& done_headers_queue() { return done_headers_queue_; }

    TransactionSet& readers() { return readers_; }

    const Transaction* headers_transaction() const {
      return headers_transaction_;
    }

    void ClearHeadersTransaction() { headers_transaction_ = nullptr; }

    bool HasWriters() const { return writers_.get(); }

    // Returns true if a transaction is currently writing the response body.
    bool IsWritingInProgress() const { return writers_.get(); }

    Writers* writers() const { return writers_.get(); }

    void Doom();

    bool IsDoomed() { return doomed_; }

    bool TransactionInReaders(Transaction* transaction) const;

    // Restarts headers_transaction and done_headers_queue transactions.
    void RestartHeadersPhaseTransactions();

    // Restarts the headers_transaction by setting its state. Since the
    // headers_transaction is awaiting an asynchronous operation completion,
    // it will be restarted when it's Cache IO callback is invoked.
    void RestartHeadersTransaction();

    // Checks if a transaction can be added to `add_to_entry_queue_`. If yes, it
    // will invoke the Cache IO callback of the transaction. It will take a
    // transaction from add_to_entry_queue and make it a headers_transaction, if
    // one doesn't exist already.
    void ProcessAddToEntryQueue();

    // Removes `transaction` from the `add_to_entry_queue_`.
    bool RemovePendingTransaction(Transaction* transaction);

    // Removes and returns all queued transactions in `this` in FIFO order.
    // This includes transactions that have completed the headers phase and
    // those that have not been added to the entry yet in that order.
    TransactionList TakeAllQueuedTransactions();

    void ReleaseWriters();

    void AddTransactionToWriters(
        Transaction* transaction,
        ParallelWritingPattern parallel_writing_pattern);

    // Returns true if this transaction can write headers to the entry.
    bool CanTransactionWriteResponseHeaders(Transaction* transaction,
                                            bool is_partial,
                                            bool is_match) const;

   private:
    friend class base::RefCounted<ActiveEntry>;

    ~ActiveEntry();

    // Destroys `this`.
    void Deactivate();

    // Destroys `this` using an exhaustive search.
    void SlowDeactivate();

    // Closes a previously doomed entry.
    void FinalizeDoomed();

    // The HttpCache that created this.
    base::WeakPtr<HttpCache> cache_;

    const disk_cache::ScopedEntryPtr disk_entry_;

    // Indicates if the disk_entry was opened or not (i.e.: created).
    // It is set to true when a transaction is added to an entry so that other,
    // queued, transactions do not mistake it for a newly created entry.
    bool opened_ = false;

    // Transactions waiting to be added to entry.
    TransactionList add_to_entry_queue_;

    // Transaction currently in the headers phase, either validating the
    // response or getting new headers. This can exist simultaneously with
    // writers or readers while validating existing headers.
    raw_ptr<Transaction> headers_transaction_ = nullptr;

    // Transactions that have completed their headers phase and are waiting
    // to read the response body or write the response body.
    TransactionList done_headers_queue_;

    // Transactions currently reading from the network and writing to the cache.
    std::unique_ptr<Writers> writers_;

    // Transactions that can only read from the cache. Only one of writers or
    // readers can be non-empty at a time.
    TransactionSet readers_;

    // The following variables are true if OnProcessQueuedTransactions is posted
    bool will_process_queued_transactions_ = false;

    // True if entry is doomed.
    bool doomed_ = false;
  };

  // `ActiveEntriesMap` and `ActiveEntriesSet` holding `raw_ref`s to
  // `ActiveEntry` is safe because `ActiveEntry` removes itself from the map or
  // set it is in on destruction.
  using ActiveEntriesMap =
      std::unordered_map<std::string, base::raw_ref<ActiveEntry>>;
  using PendingOpsMap =
      std::unordered_map<std::string, raw_ptr<PendingOp, CtnExperimental>>;
  using ActiveEntriesSet = std::set<base::raw_ref<ActiveEntry>>;

  // Methods ------------------------------------------------------------------

  // Returns whether a request can be cached. Certain types of requests can't or
  // shouldn't be cached, such as requests with a transient NetworkIsolationKey
  // (when network state partitioning is enabled) or requests with an opaque
  // initiator (for HTTP cache experiment partition schemes that incorporate the
  // initiator into the cache key).
  static bool CanGenerateCacheKeyForRequest(const HttpRequestInfo* request);

  // Generates a cache key given the various pieces used to construct the key.
  // Must not be called if a corresponding `CanGenerateCacheKeyForRequest`
  // returns false.
  static std::string GenerateCacheKey(
      const GURL& url,
      int load_flags,
      const NetworkIsolationKey& network_isolation_key,
      int64_t upload_data_identifier,
      bool is_subframe_document_resource,
      bool is_mainframe_navigation,
      bool is_shared_resource,
      std::optional<url::Origin> initiator);

  // Generates a cache key for `request_info` and informs the backend it should
  // consider it used if it exists.
  void OnExternalCacheHitForRequest(const HttpRequestInfo& request_info);

  // Creates a WorkItem and sets it as the |pending_op|'s writer, or adds it to
  // the queue if a writer already exists.
  Error CreateAndSetWorkItem(scoped_refptr<ActiveEntry>* entry,
                             Transaction* transaction,
                             WorkItemOperation operation,
                             PendingOp* pending_op);

  // Creates the `disk_cache_` object and notifies the `callback` when the
  // operation completes. Returns an error code.
  int CreateBackend(CompletionOnceCallback callback);

  void ReportGetBackendResult(GetBackendCallback callback, int net_error);

  // Makes sure that the backend creation is complete before allowing the
  // provided transaction to use the object. Returns an error code.
  // |transaction| will be notified via its Cache IO callback if this method
  // returns ERR_IO_PENDING. The transaction is free to use the backend
  // directly at any time after receiving the notification.
  int GetBackendForTransaction(Transaction* transaction);

  // Dooms the entry selected by |key|, if it is currently in the list of active
  // entries.
  void DoomActiveEntry(const std::string& key);

  // Dooms the entry selected by |key|. |transaction| will be notified via its
  // Cache IO callback if this method returns ERR_IO_PENDING. The entry can be
  // currently in use or not. If entry is in use and the invoking transaction
  // is associated with this entry and this entry is already doomed, this API
  // should not be invoked.
  int DoomEntry(const std::string& key, Transaction* transaction);

  // Dooms the entry selected by |key|. |transaction| will be notified via its
  // Cache IO callback if this method returns ERR_IO_PENDING. The entry should
  // not be currently in use.
  int AsyncDoomEntry(const std::string& key, Transaction* transaction);

  // Dooms the entry associated with a GET for a given url and network
  // isolation key.
  void DoomMainEntryForUrl(const GURL& url,
                           const NetworkIsolationKey& isolation_key,
                           bool is_subframe_document_resource,
                           bool is_main_frame_navigation,
                           const std::optional<url::Origin>& initiator);

  // Returns if there is an entry that is currently in use and not doomed, or
  // NULL.
  bool HasActiveEntry(const std::string& key);

  // Returns an entry that is currently in use and not doomed, or NULL.
  scoped_refptr<ActiveEntry> GetActiveEntry(const std::string& key);

  // Creates a new ActiveEntry and starts tracking it. |disk_entry| is the disk
  // cache entry.
  scoped_refptr<ActiveEntry> ActivateEntry(disk_cache::Entry* disk_entry,
                                           bool opened);

  // Returns the PendingOp for the desired |key|. If an entry is not under
  // construction already, a new PendingOp structure is created.
  PendingOp* GetPendingOp(const std::string& key);

  // Deletes a PendingOp.
  void DeletePendingOp(PendingOp* pending_op);

  // Opens the disk cache entry associated with |key|, creating the entry if it
  // does not already exist, returning an ActiveEntry in |*entry|. |transaction|
  // will be notified via its Cache IO callback if this method returns
  // ERR_IO_PENDING. This should not be called if there already is an active
  // entry associated with |key|, e.g. you should call GetActiveEntry first.
  int OpenOrCreateEntry(const std::string& key,
                        scoped_refptr<ActiveEntry>* entry,
                        Transaction* transaction);

  // Opens the disk cache entry associated with |key|, returning an ActiveEntry
  // in |*entry|. |transaction| will be notified via its Cache IO callback if
  // this method returns ERR_IO_PENDING. This should not be called if there
  // already is an active entry associated with |key|, e.g. you should call
  // GetActiveEntry first.
  int OpenEntry(const std::string& key,
                scoped_refptr<ActiveEntry>* entry,
                Transaction* transaction);

  // Creates the disk cache entry associated with |key|, returning an
  // ActiveEntry in |*entry|. |transaction| will be notified via its Cache IO
  // callback if this method returns ERR_IO_PENDING.
  int CreateEntry(const std::string& key,
                  scoped_refptr<ActiveEntry>* entry,
                  Transaction* transaction);

  // Adds a transaction to an ActiveEntry. This method returns ERR_IO_PENDING
  // and the transaction will be notified about completion via a callback to
  // cache_io_callback().
  // In a failure case, the callback will be invoked with ERR_CACHE_RACE.
  int AddTransactionToEntry(scoped_refptr<ActiveEntry>& entry,
                            Transaction* transaction);

  // Transaction invokes this when its response headers phase is complete
  // If the transaction is responsible for writing the response body,
  // it becomes the writer and returns OK. In other cases ERR_IO_PENDING is
  // returned and the transaction will be notified about completion via its
  // Cache IO callback. In a failure case, the callback will be invoked with
  // ERR_CACHE_RACE.
  int DoneWithResponseHeaders(scoped_refptr<ActiveEntry>& entry,
                              Transaction* transaction,
                              bool is_partial);

  // Called when the transaction has finished working with this entry.
  // |entry_is_complete| is true if the transaction finished reading/writing
  // from the entry successfully, else it's false.
  void DoneWithEntry(scoped_refptr<ActiveEntry>& entry,
                     Transaction* transaction,
                     bool entry_is_complete,
                     bool is_partial);

  // Invoked when writers wants to doom the entry and restart any queued and
  // headers transactions.
  // Virtual so that it can be extended in tests.
  virtual void WritersDoomEntryRestartTransactions(ActiveEntry* entry);

  // Invoked when current transactions in writers have completed writing to the
  // cache. It may be successful completion of the response or failure as given
  // by |success|. Must delete the writers object.
  // |entry| is the owner of writers.
  // |should_keep_entry| indicates if the entry should be doomed/destroyed.
  // Virtual so that it can be extended in tests.
  virtual void WritersDoneWritingToEntry(scoped_refptr<ActiveEntry> entry,
                                         bool success,
                                         bool should_keep_entry,
                                         TransactionSet make_readers);

  // Called when the transaction has received a non-matching response to
  // validation and it's not the transaction responsible for writing the
  // response body.
  void DoomEntryValidationNoMatch(scoped_refptr<ActiveEntry> entry);

  // Processes either writer's failure to write response body or
  // headers_transactions's failure to write headers.
  void ProcessEntryFailure(ActiveEntry* entry);

  // Resumes processing the queued transactions of |entry|.
  void ProcessQueuedTransactions(scoped_refptr<ActiveEntry> entry);

  // Checks if a transaction can be added to the entry. If yes, it will
  // invoke the Cache IO callback of the transaction. This is a helper function
  // for OnProcessQueuedTransactions. It will take a transaction from
  // add_to_entry_queue and make it a headers_transaction, if one doesn't exist
  // already.
  void ProcessAddToEntryQueue(scoped_refptr<ActiveEntry> entry);

  // The implementation is split into a separate function so that it can be
  // called with a delay for testing.
  void ProcessAddToEntryQueueImpl(scoped_refptr<ActiveEntry> entry);

  // Returns if the transaction can join other transactions for writing to
  // the cache simultaneously. It is only supported for non-Read only,
  // GET requests which are not range requests.
  ParallelWritingPattern CanTransactionJoinExistingWriters(
      Transaction* transaction);

  // Invoked when a transaction that has already completed the response headers
  // phase can resume reading/writing the response body. It will invoke the IO
  // callback of the transaction. This is a helper function for
  // OnProcessQueuedTransactions.
  void ProcessDoneHeadersQueue(scoped_refptr<ActiveEntry> entry);

  // Returns the LoadState of the provided pending transaction.
  LoadState GetLoadStateForPendingTransaction(const Transaction* transaction);

  // Removes the transaction |transaction|, from the pending list of an entry
  // (PendingOp, active or doomed entry).
  void RemovePendingTransaction(Transaction* transaction);

  // Removes the transaction |transaction|, from the pending list of
  // |pending_op|.
  bool RemovePendingTransactionFromPendingOp(PendingOp* pending_op,
                                             Transaction* transaction);

  // Notes that `key` led to receiving a no-store response.
  // Stored keys rotate out in an LRU fashion so there is no guarantee that keys
  // are accounted for throughout the lifetime of this class.
  void MarkKeyNoStore(const std::string& key);

  // Returns true if the `key` is has probably led to a no-store response.
  // Collisions are possible so this function should not be used to make
  // decisions that affect correctness. A correct use is to use the information
  // to avoid attempting creating cache entries uselessly.
  bool DidKeyLeadToNoStoreResponse(const std::string& key);

  // Calls NoVarySearchCacheStorage::Load() if `file_operations_` is set. Since
  // this gives away `file_operations_`, it will only call it once.
  void MaybeLoadNoVarySearchCacheFromDisk();

  // Events (called via PostTask) ---------------------------------------------

  void OnProcessQueuedTransactions(scoped_refptr<ActiveEntry> entry);

  // Callbacks ----------------------------------------------------------------

  // Processes BackendCallback notifications.
  void OnIOComplete(int result, PendingOp* entry);

  // Helper to conditionally delete |pending_op| if HttpCache has been deleted.
  // This is necessary because |pending_op| owns a disk_cache::Backend that has
  // been passed in to CreateCacheBackend(), therefore must live until callback
  // is called.
  static void OnPendingOpComplete(base::WeakPtr<HttpCache> cache,
                                  PendingOp* pending_op,
                                  int result);

  // Variant for Open/Create method family, which has a different signature.
  static void OnPendingCreationOpComplete(base::WeakPtr<HttpCache> cache,
                                          PendingOp* pending_op,
                                          disk_cache::EntryResult result);

  // Variant for CreateCacheBackend, which has a different signature.
  static void OnPendingBackendCreationOpComplete(
      base::WeakPtr<HttpCache> cache,
      PendingOp* pending_op,
      disk_cache::BackendResult result);

  // Processes the backend creation notification.
  void OnBackendCreated(int result, PendingOp* pending_op);

  // Starts using the loaded cache if loading was successful.
  void OnNoVarySearchCacheLoadComplete(
      NoVarySearchCacheStorage::LoadResult result);

  // Constants ----------------------------------------------------------------

  // Used when generating and accessing keys if cache is split.
  static const char kDoubleKeyPrefix[];
  static const char kDoubleKeySeparator[];
  static const char kSubframeDocumentResourcePrefix[];
  static const char kCrossSiteMainFrameNavigationPrefix[];

  // Used for single-keyed entries if the cache is split.
  static const char kSingleKeyPrefix[];
  static const char kSingleKeySeparator[];

  // Variables ----------------------------------------------------------------

  raw_ptr<NetLog> net_log_;

  // Used when lazily constructing the disk_cache_.
  std::unique_ptr<BackendFactory> backend_factory_;
  bool building_backend_ = false;
  bool bypass_lock_for_test_ = false;
  bool bypass_lock_after_headers_for_test_ = false;
  bool delay_add_transaction_to_entry_for_test_ = false;
  bool fail_conditionalization_for_test_ = false;

  Mode mode_ = NORMAL;

  std::unique_ptr<HttpTransactionFactory> network_layer_;

  std::unique_ptr<disk_cache::Backend> disk_cache_;

  // The set of active entries indexed by cache key.
  ActiveEntriesMap active_entries_;

  // The set of doomed entries.
  ActiveEntriesSet doomed_entries_;

  // The set of entries "under construction".
  PendingOpsMap pending_ops_;

  // A clock that can be swapped out for testing.
  raw_ptr<base::Clock> clock_;

  // Used to track which keys led to a no-store response.
  base::LRUCacheSet<base::SHA1Digest> keys_marked_no_store_;

  // Set if the kHttpCacheNoVarySearch feature is enabled. Translates the URL in
  // the request into the URL of a previous response that is equivalent
  // according to the rules of the No-Vary-Search header in the response.
  std::unique_ptr<NoVarySearchCache> no_vary_search_cache_;

  // Implements persistence for `no_vary_search_cache_`. Only used when the
  // cache is stored on disk. Holds a raw_ptr to `no_vary_search_cache_` so must
  // be destroyed before it.
  NoVarySearchCacheStorage no_vary_search_cache_storage_;

  // Implementation of file operations for No-Vary-Search cache persistence.
  // Only non-null if the backend is on-disk, and only until a backend has been
  // created. After that ownership is transferred to
  // `no_vary_search_cache_storage_`.
  std::unique_ptr<NoVarySearchCacheStorageFileOperations> file_operations_;

  THREAD_CHECKER(thread_checker_);

  base::WeakPtrFactory<HttpCache> weak_factory_{this};
};

}  // namespace net

#endif  // NET_HTTP_HTTP_CACHE_H_