| // 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_ |