// Copyright (c) 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. #include "net/http/http_cache_transaction.h" #include "build/build_config.h" // For OS_POSIX #if defined(OS_POSIX) #include #endif #include #include #include #include "base/auto_reset.h" #include "base/bind.h" #include "base/bind_helpers.h" #include "base/callback_helpers.h" #include "base/compiler_specific.h" #include "base/format_macros.h" #include "base/location.h" #include "base/macros.h" #include "base/metrics/histogram_functions.h" #include "base/metrics/histogram_macros.h" #include "base/single_thread_task_runner.h" #include "base/strings/string_number_conversions.h" // For HexEncode. #include "base/strings/string_piece.h" #include "base/strings/string_util.h" // For LowerCaseEqualsASCII. #include "base/strings/stringprintf.h" #include "base/threading/thread_task_runner_handle.h" #include "base/time/clock.h" #include "base/trace_event/trace_event.h" #include "base/values.h" #include "net/base/auth.h" #include "net/base/load_flags.h" #include "net/base/load_timing_info.h" #include "net/base/trace_constants.h" #include "net/base/upload_data_stream.h" #include "net/cert/cert_status_flags.h" #include "net/cert/x509_certificate.h" #include "net/disk_cache/disk_cache.h" #include "net/http/http_cache_writers.h" #include "net/http/http_network_session.h" #include "net/http/http_request_info.h" #include "net/http/http_util.h" #include "net/log/net_log_event_type.h" #include "net/ssl/ssl_cert_request_info.h" #include "net/ssl/ssl_config_service.h" using base::Time; using base::TimeDelta; using base::TimeTicks; namespace net { using CacheEntryStatus = HttpResponseInfo::CacheEntryStatus; namespace { constexpr TimeDelta kStaleRevalidateTimeout = TimeDelta::FromSeconds(60); // From http://tools.ietf.org/html/draft-ietf-httpbis-p6-cache-21#section-6 // a "non-error response" is one with a 2xx (Successful) or 3xx // (Redirection) status code. bool NonErrorResponse(int status_code) { int status_code_range = status_code / 100; return status_code_range == 2 || status_code_range == 3; } void RecordNoStoreHeaderHistogram(int load_flags, const HttpResponseInfo* response) { if (load_flags & LOAD_MAIN_FRAME_DEPRECATED) { UMA_HISTOGRAM_BOOLEAN( "Net.MainFrameNoStore", response->headers->HasHeaderValue("cache-control", "no-store")); } } enum ExternallyConditionalizedType { EXTERNALLY_CONDITIONALIZED_CACHE_REQUIRES_VALIDATION, EXTERNALLY_CONDITIONALIZED_CACHE_USABLE, EXTERNALLY_CONDITIONALIZED_MISMATCHED_VALIDATORS, EXTERNALLY_CONDITIONALIZED_MAX }; } // namespace #define CACHE_STATUS_HISTOGRAMS(type) \ do { \ UMA_HISTOGRAM_ENUMERATION("HttpCache.Pattern" type, cache_entry_status_, \ CacheEntryStatus::ENTRY_MAX); \ if (validation_request) { \ UMA_HISTOGRAM_ENUMERATION("HttpCache.ValidationCause" type, \ validation_cause_, VALIDATION_CAUSE_MAX); \ } \ if (stale_request) { \ UMA_HISTOGRAM_COUNTS_1M( \ "HttpCache.StaleEntry.FreshnessPeriodsSinceLastUsed" type, \ freshness_periods_since_last_used); \ } \ } while (0) struct HeaderNameAndValue { const char* name; const char* value; }; // If the request includes one of these request headers, then avoid caching // to avoid getting confused. static const HeaderNameAndValue kPassThroughHeaders[] = { { "if-unmodified-since", NULL }, // causes unexpected 412s { "if-match", NULL }, // causes unexpected 412s { "if-range", NULL }, { NULL, NULL } }; struct ValidationHeaderInfo { const char* request_header_name; const char* related_response_header_name; }; static const ValidationHeaderInfo kValidationHeaders[] = { { "if-modified-since", "last-modified" }, { "if-none-match", "etag" }, }; // If the request includes one of these request headers, then avoid reusing // our cached copy if any. static const HeaderNameAndValue kForceFetchHeaders[] = { { "cache-control", "no-cache" }, { "pragma", "no-cache" }, { NULL, NULL } }; // If the request includes one of these request headers, then force our // cached copy (if any) to be revalidated before reusing it. static const HeaderNameAndValue kForceValidateHeaders[] = { { "cache-control", "max-age=0" }, { NULL, NULL } }; static bool HeaderMatches(const HttpRequestHeaders& headers, const HeaderNameAndValue* search) { for (; search->name; ++search) { std::string header_value; if (!headers.GetHeader(search->name, &header_value)) continue; if (!search->value) return true; HttpUtil::ValuesIterator v(header_value.begin(), header_value.end(), ','); while (v.GetNext()) { if (base::LowerCaseEqualsASCII( base::StringPiece(v.value_begin(), v.value_end()), search->value)) return true; } } return false; } //----------------------------------------------------------------------------- HttpCache::Transaction::Transaction(RequestPriority priority, HttpCache* cache) : next_state_(STATE_NONE), initial_request_(nullptr), request_(NULL), priority_(priority), cache_(cache->GetWeakPtr()), entry_(NULL), new_entry_(NULL), new_response_(NULL), mode_(NONE), reading_(false), invalid_range_(false), truncated_(false), is_sparse_(false), range_requested_(false), handling_206_(false), cache_pending_(false), done_headers_create_new_entry_(false), vary_mismatch_(false), couldnt_conditionalize_request_(false), bypass_lock_for_test_(false), bypass_lock_after_headers_for_test_(false), fail_conditionalization_for_test_(false), io_buf_len_(0), read_offset_(0), effective_load_flags_(0), shared_writing_error_(OK), cache_entry_status_(CacheEntryStatus::ENTRY_UNDEFINED), validation_cause_(VALIDATION_CAUSE_UNDEFINED), cant_conditionalize_zero_freshness_from_memhint_(false), recorded_histograms_(false), parallel_writing_pattern_(PARALLEL_WRITING_NONE), moved_network_transaction_to_writers_(false), websocket_handshake_stream_base_create_helper_(NULL), in_do_loop_(false), weak_factory_(this) { TRACE_EVENT0("io", "HttpCacheTransaction::Transaction"); static_assert(HttpCache::Transaction::kNumValidationHeaders == arraysize(kValidationHeaders), "invalid number of validation headers"); io_callback_ = base::BindRepeating(&Transaction::OnIOComplete, weak_factory_.GetWeakPtr()); } HttpCache::Transaction::~Transaction() { TRACE_EVENT0("io", "HttpCacheTransaction::~Transaction"); // We may have to issue another IO, but we should never invoke the callback_ // after this point. callback_.Reset(); if (cache_) { if (entry_) { DoneWithEntry(false /* entry_is_complete */); } else if (cache_pending_) { cache_->RemovePendingTransaction(this); } } } HttpCache::Transaction::Mode HttpCache::Transaction::mode() const { return mode_; } int HttpCache::Transaction::WriteMetadata(IOBuffer* buf, int buf_len, const CompletionCallback& callback) { DCHECK(buf); DCHECK_GT(buf_len, 0); DCHECK(!callback.is_null()); if (!cache_.get() || !entry_) return ERR_UNEXPECTED; // We don't need to track this operation for anything. // It could be possible to check if there is something already written and // avoid writing again (it should be the same, right?), but let's allow the // caller to "update" the contents with something new. return entry_->disk_entry->WriteData(kMetadataIndex, 0, buf, buf_len, callback, true); } LoadState HttpCache::Transaction::GetWriterLoadState() const { const HttpTransaction* transaction = network_transaction(); if (transaction) return transaction->GetLoadState(); if (entry_ || !request_) return LOAD_STATE_IDLE; return LOAD_STATE_WAITING_FOR_CACHE; } const NetLogWithSource& HttpCache::Transaction::net_log() const { return net_log_; } int HttpCache::Transaction::Start(const HttpRequestInfo* request, CompletionOnceCallback callback, const NetLogWithSource& net_log) { DCHECK(request); DCHECK(!callback.is_null()); // Ensure that we only have one asynchronous call at a time. DCHECK(callback_.is_null()); DCHECK(!reading_); DCHECK(!network_trans_.get()); DCHECK(!entry_); DCHECK_EQ(next_state_, STATE_NONE); if (!cache_.get()) return ERR_UNEXPECTED; initial_request_ = request; SetRequest(net_log); // We have to wait until the backend is initialized so we start the SM. next_state_ = STATE_GET_BACKEND; int rv = DoLoop(OK); // Setting this here allows us to check for the existence of a callback_ to // determine if we are still inside Start. if (rv == ERR_IO_PENDING) callback_ = std::move(callback); return rv; } int HttpCache::Transaction::RestartIgnoringLastError( CompletionOnceCallback callback) { DCHECK(!callback.is_null()); // Ensure that we only have one asynchronous call at a time. DCHECK(callback_.is_null()); if (!cache_.get()) return ERR_UNEXPECTED; int rv = RestartNetworkRequest(); if (rv == ERR_IO_PENDING) callback_ = std::move(callback); return rv; } int HttpCache::Transaction::RestartWithCertificate( scoped_refptr client_cert, scoped_refptr client_private_key, CompletionOnceCallback callback) { DCHECK(!callback.is_null()); // Ensure that we only have one asynchronous call at a time. DCHECK(callback_.is_null()); if (!cache_.get()) return ERR_UNEXPECTED; int rv = RestartNetworkRequestWithCertificate(std::move(client_cert), std::move(client_private_key)); if (rv == ERR_IO_PENDING) callback_ = std::move(callback); return rv; } int HttpCache::Transaction::RestartWithAuth(const AuthCredentials& credentials, CompletionOnceCallback callback) { DCHECK(auth_response_.headers.get()); DCHECK(!callback.is_null()); // Ensure that we only have one asynchronous call at a time. DCHECK(callback_.is_null()); if (!cache_.get()) return ERR_UNEXPECTED; // Clear the intermediate response since we are going to start over. SetAuthResponse(HttpResponseInfo()); int rv = RestartNetworkRequestWithAuth(credentials); if (rv == ERR_IO_PENDING) callback_ = std::move(callback); return rv; } bool HttpCache::Transaction::IsReadyToRestartForAuth() { if (!network_trans_.get()) return false; return network_trans_->IsReadyToRestartForAuth(); } int HttpCache::Transaction::Read(IOBuffer* buf, int buf_len, CompletionOnceCallback callback) { DCHECK_EQ(next_state_, STATE_NONE); DCHECK(buf); DCHECK_GT(buf_len, 0); DCHECK(!callback.is_null()); DCHECK(callback_.is_null()); if (!cache_.get()) return ERR_UNEXPECTED; // If we have an intermediate auth response at this point, then it means the // user wishes to read the network response (the error page). If there is a // previous response in the cache then we should leave it intact. if (auth_response_.headers.get() && mode_ != NONE) { UpdateCacheEntryStatus(CacheEntryStatus::ENTRY_OTHER); DCHECK(mode_ & WRITE); bool stopped = StopCachingImpl(mode_ == READ_WRITE); DCHECK(stopped); } reading_ = true; read_buf_ = buf; io_buf_len_ = buf_len; int rv = TransitionToReadingState(); if (rv != OK || next_state_ == STATE_NONE) return rv; rv = DoLoop(OK); if (rv == ERR_IO_PENDING) { DCHECK(callback_.is_null()); callback_ = std::move(callback); } return rv; } int HttpCache::Transaction::TransitionToReadingState() { if (!entry_) { if (network_trans_) { // This can happen when the request should be handled exclusively by // the network layer (skipping the cache entirely using // LOAD_DISABLE_CACHE) or there was an error during the headers phase // due to which the transaction cannot write to the cache or the consumer // is reading the auth response from the network. // TODO(http://crbug.com/740947) to get rid of this state in future. next_state_ = STATE_NETWORK_READ; return OK; } // If there is no network, and no cache entry, then there is nothing to read // from. next_state_ = STATE_NONE; // An error state should be set for the next read, else this transaction // should have been terminated once it reached this state. To assert we // could dcheck that shared_writing_error_ is set to a valid error value but // in some specific conditions (http://crbug.com/806344) it's possible that // the consumer does an extra Read in which case the assert will fail. return shared_writing_error_; } // If entry_ is present, the transaction is either a member of entry_->writers // or readers. if (!InWriters()) { // Since transaction is not a writer and we are in Read(), it must be a // reader. DCHECK(entry_->TransactionInReaders(this)); DCHECK(mode_ == READ || (mode_ == READ_WRITE && partial_)); next_state_ = STATE_CACHE_READ_DATA; return OK; } DCHECK(mode_ & WRITE || mode_ == NONE); // If it's a writer and it is partial then it may need to read from the cache // or from the network based on whether network transaction is present or not. if (partial_) { if (entry_->writers->network_transaction()) next_state_ = STATE_NETWORK_READ_CACHE_WRITE; else next_state_ = STATE_CACHE_READ_DATA; return OK; } // Full request. // If it's a writer and a full request then it may read from the cache if its // offset is behind the current offset else from the network. int disk_entry_size = entry_->disk_entry->GetDataSize(kResponseContentIndex); if (read_offset_ == disk_entry_size || entry_->writers->network_read_only()) { next_state_ = STATE_NETWORK_READ_CACHE_WRITE; } else { DCHECK_LT(read_offset_, disk_entry_size); next_state_ = STATE_CACHE_READ_DATA; } return OK; } void HttpCache::Transaction::StopCaching() { // We really don't know where we are now. Hopefully there is no operation in // progress, but nothing really prevents this method to be called after we // returned ERR_IO_PENDING. We cannot attempt to truncate the entry at this // point because we need the state machine for that (and even if we are really // free, that would be an asynchronous operation). In other words, keep the // entry how it is (it will be marked as truncated at destruction), and let // the next piece of code that executes know that we are now reading directly // from the net. if (cache_.get() && (mode_ & WRITE) && !is_sparse_ && !range_requested_ && network_transaction()) { StopCachingImpl(false); } } bool HttpCache::Transaction::GetFullRequestHeaders( HttpRequestHeaders* headers) const { const HttpTransaction* transaction = GetOwnedOrMovedNetworkTransaction(); if (transaction) { return transaction->GetFullRequestHeaders(headers); } else if (!network_transaction_info_.full_request_headers.IsEmpty()) { *headers = network_transaction_info_.full_request_headers; return true; } // TODO(juliatuttle): Read headers from cache. return false; } int64_t HttpCache::Transaction::GetTotalReceivedBytes() const { int64_t total_received_bytes = network_transaction_info_.total_received_bytes; const HttpTransaction* transaction = GetOwnedOrMovedNetworkTransaction(); if (transaction) total_received_bytes += transaction->GetTotalReceivedBytes(); return total_received_bytes; } int64_t HttpCache::Transaction::GetTotalSentBytes() const { int64_t total_sent_bytes = network_transaction_info_.total_sent_bytes; const HttpTransaction* transaction = GetOwnedOrMovedNetworkTransaction(); if (transaction) total_sent_bytes += transaction->GetTotalSentBytes(); return total_sent_bytes; } void HttpCache::Transaction::DoneReading() { if (cache_.get() && entry_) { DCHECK_NE(mode_, UPDATE); DoneWithEntry(true); } } const HttpResponseInfo* HttpCache::Transaction::GetResponseInfo() const { // Null headers means we encountered an error or haven't a response yet if (auth_response_.headers.get()) { DCHECK_EQ(cache_entry_status_, auth_response_.cache_entry_status) << "These must be in sync via SetResponse and SetAuthResponse."; return &auth_response_; } DCHECK_EQ(cache_entry_status_, response_.cache_entry_status) << "These must be in sync via SetResponse and SetAuthResponse."; return &response_; } LoadState HttpCache::Transaction::GetLoadState() const { LoadState state = GetWriterLoadState(); if (state != LOAD_STATE_WAITING_FOR_CACHE) return state; if (cache_.get()) return cache_->GetLoadStateForPendingTransaction(this); return LOAD_STATE_IDLE; } void HttpCache::Transaction::SetQuicServerInfo( QuicServerInfo* quic_server_info) {} bool HttpCache::Transaction::GetLoadTimingInfo( LoadTimingInfo* load_timing_info) const { const HttpTransaction* transaction = GetOwnedOrMovedNetworkTransaction(); if (transaction) return transaction->GetLoadTimingInfo(load_timing_info); if (network_transaction_info_.old_network_trans_load_timing) { *load_timing_info = *network_transaction_info_.old_network_trans_load_timing; return true; } if (first_cache_access_since_.is_null()) return false; // If the cache entry was opened, return that time. load_timing_info->send_start = first_cache_access_since_; // This time doesn't make much sense when reading from the cache, so just use // the same time as send_start. load_timing_info->send_end = first_cache_access_since_; return true; } bool HttpCache::Transaction::GetRemoteEndpoint(IPEndPoint* endpoint) const { const HttpTransaction* transaction = GetOwnedOrMovedNetworkTransaction(); if (transaction) return transaction->GetRemoteEndpoint(endpoint); if (!network_transaction_info_.old_remote_endpoint.address().empty()) { *endpoint = network_transaction_info_.old_remote_endpoint; return true; } return false; } void HttpCache::Transaction::PopulateNetErrorDetails( NetErrorDetails* details) const { const HttpTransaction* transaction = GetOwnedOrMovedNetworkTransaction(); if (transaction) return transaction->PopulateNetErrorDetails(details); return; } void HttpCache::Transaction::SetPriority(RequestPriority priority) { priority_ = priority; if (network_trans_) network_trans_->SetPriority(priority_); if (InWriters()) { DCHECK(!network_trans_ || partial_); entry_->writers->UpdatePriority(); } } void HttpCache::Transaction::SetWebSocketHandshakeStreamCreateHelper( WebSocketHandshakeStreamBase::CreateHelper* create_helper) { websocket_handshake_stream_base_create_helper_ = create_helper; // TODO(shivanisha). Since this function must be invoked before Start() as // per the API header, a network transaction should not exist at that point. HttpTransaction* transaction = network_transaction(); if (transaction) transaction->SetWebSocketHandshakeStreamCreateHelper(create_helper); } void HttpCache::Transaction::SetBeforeNetworkStartCallback( const BeforeNetworkStartCallback& callback) { DCHECK(!network_trans_); before_network_start_callback_ = callback; } void HttpCache::Transaction::SetBeforeHeadersSentCallback( const BeforeHeadersSentCallback& callback) { DCHECK(!network_trans_); before_headers_sent_callback_ = callback; } void HttpCache::Transaction::SetRequestHeadersCallback( RequestHeadersCallback callback) { DCHECK(!network_trans_); request_headers_callback_ = std::move(callback); } void HttpCache::Transaction::SetResponseHeadersCallback( ResponseHeadersCallback callback) { DCHECK(!network_trans_); response_headers_callback_ = std::move(callback); } int HttpCache::Transaction::ResumeNetworkStart() { if (network_trans_) return network_trans_->ResumeNetworkStart(); return ERR_UNEXPECTED; } void HttpCache::Transaction::GetConnectionAttempts( ConnectionAttempts* out) const { ConnectionAttempts new_connection_attempts; const HttpTransaction* transaction = GetOwnedOrMovedNetworkTransaction(); if (transaction) transaction->GetConnectionAttempts(&new_connection_attempts); out->swap(new_connection_attempts); out->insert(out->begin(), network_transaction_info_.old_connection_attempts.begin(), network_transaction_info_.old_connection_attempts.end()); } void HttpCache::Transaction::SetValidatingCannotProceed() { DCHECK(!reading_); // Ensure this transaction is waiting for a callback. DCHECK_NE(STATE_UNSET, next_state_); next_state_ = STATE_HEADERS_PHASE_CANNOT_PROCEED; entry_ = nullptr; } size_t HttpCache::Transaction::EstimateMemoryUsage() const { // TODO(xunjieli): Consider improving the coverage. crbug.com/669108. return 0; } void HttpCache::Transaction::WriterAboutToBeRemovedFromEntry(int result) { RecordHistograms(); // Since the transaction can no longer access the network transaction, save // all network related info now. if (moved_network_transaction_to_writers_ && entry_->writers->network_transaction()) { SaveNetworkTransactionInfo(*(entry_->writers->network_transaction())); } entry_ = nullptr; mode_ = NONE; // Transactions in the midst of a Read call through writers will get any error // code through the IO callback but for idle transactions/transactions reading // from the cache, the error for a future Read must be stored here. if (result < 0) shared_writing_error_ = result; } void HttpCache::Transaction::WriteModeTransactionAboutToBecomeReader() { mode_ = READ; if (moved_network_transaction_to_writers_ && entry_->writers->network_transaction()) { SaveNetworkTransactionInfo(*(entry_->writers->network_transaction())); } } void HttpCache::Transaction::MaybeSetParallelWritingPatternForMetrics( HttpCache::ParallelWritingPattern pattern) { // It's possible a transaction could not join existing writers and then // creates a new writers. In that case the original reason for not being able // to join writers should be logged. if (parallel_writing_pattern_ == PARALLEL_WRITING_NONE) parallel_writing_pattern_ = pattern; } //----------------------------------------------------------------------------- // A few common patterns: (Foo* means Foo -> FooComplete) // // 1. Not-cached entry: // Start(): // GetBackend* -> InitEntry -> OpenEntry* -> CreateEntry* -> AddToEntry* -> // SendRequest* -> SuccessfulSendRequest -> OverwriteCachedResponse -> // CacheWriteResponse* -> TruncateCachedData* -> TruncateCachedMetadata* -> // PartialHeadersReceived -> FinishHeaders* // // Read(): // NetworkReadCacheWrite*/CacheReadData* (if other writers are also writing to // the cache) // // 2. Cached entry, no validation: // Start(): // GetBackend* -> InitEntry -> OpenEntry* -> AddToEntry* -> CacheReadResponse* // -> CacheDispatchValidation -> BeginPartialCacheValidation() -> // BeginCacheValidation() -> SetupEntryForRead() -> FinishHeaders* // // Read(): // CacheReadData* // // 3. Cached entry, validation (304): // Start(): // GetBackend* -> InitEntry -> OpenEntry* -> AddToEntry* -> CacheReadResponse* // -> CacheDispatchValidation -> BeginPartialCacheValidation() -> // BeginCacheValidation() -> SendRequest* -> SuccessfulSendRequest -> // UpdateCachedResponse -> CacheWriteUpdatedResponse* -> // UpdateCachedResponseComplete -> OverwriteCachedResponse -> // PartialHeadersReceived -> FinishHeaders* // // Read(): // CacheReadData* // // 4. Cached entry, validation and replace (200): // Start(): // GetBackend* -> InitEntry -> OpenEntry* -> AddToEntry* -> CacheReadResponse* // -> CacheDispatchValidation -> BeginPartialCacheValidation() -> // BeginCacheValidation() -> SendRequest* -> SuccessfulSendRequest -> // OverwriteCachedResponse -> CacheWriteResponse* -> DoTruncateCachedData* -> // TruncateCachedMetadata* -> PartialHeadersReceived -> FinishHeaders* // // Read(): // NetworkReadCacheWrite*/CacheReadData* (if other writers are also writing to // the cache) // // 5. Sparse entry, partially cached, byte range request: // Start(): // GetBackend* -> InitEntry -> OpenEntry* -> AddToEntry* -> CacheReadResponse* // -> CacheDispatchValidation -> BeginPartialCacheValidation() -> // CacheQueryData* -> ValidateEntryHeadersAndContinue() -> // StartPartialCacheValidation -> CompletePartialCacheValidation -> // BeginCacheValidation() -> SendRequest* -> SuccessfulSendRequest -> // UpdateCachedResponse -> CacheWriteUpdatedResponse* -> // UpdateCachedResponseComplete -> OverwriteCachedResponse -> // PartialHeadersReceived -> FinishHeaders* // // Read() 1: // NetworkReadCacheWrite* // // Read() 2: // NetworkReadCacheWrite* -> StartPartialCacheValidation -> // CompletePartialCacheValidation -> CacheReadData* -> // // Read() 3: // CacheReadData* -> StartPartialCacheValidation -> // CompletePartialCacheValidation -> BeginCacheValidation() -> SendRequest* -> // SuccessfulSendRequest -> UpdateCachedResponse* -> OverwriteCachedResponse // -> PartialHeadersReceived -> NetworkReadCacheWrite* // // 6. HEAD. Not-cached entry: // Pass through. Don't save a HEAD by itself. // Start(): // GetBackend* -> InitEntry -> OpenEntry* -> SendRequest* // // 7. HEAD. Cached entry, no validation: // Start(): // The same flow as for a GET request (example #2) // // Read(): // CacheReadData (returns 0) // // 8. HEAD. Cached entry, validation (304): // The request updates the stored headers. // Start(): Same as for a GET request (example #3) // // Read(): // CacheReadData (returns 0) // // 9. HEAD. Cached entry, validation and replace (200): // Pass through. The request dooms the old entry, as a HEAD won't be stored by // itself. // Start(): // GetBackend* -> InitEntry -> OpenEntry* -> AddToEntry* -> CacheReadResponse* // -> CacheDispatchValidation -> BeginPartialCacheValidation() -> // BeginCacheValidation() -> SendRequest* -> SuccessfulSendRequest -> // OverwriteCachedResponse -> FinishHeaders* // // 10. HEAD. Sparse entry, partially cached: // Serve the request from the cache, as long as it doesn't require // revalidation. Ignore missing ranges when deciding to revalidate. If the // entry requires revalidation, ignore the whole request and go to full pass // through (the result of the HEAD request will NOT update the entry). // // Start(): Basically the same as example 7, as we never create a partial_ // object for this request. // // 11. Prefetch, not-cached entry: // The same as example 1. The "unused_since_prefetch" bit is stored as true in // UpdateCachedResponse. // // 12. Prefetch, cached entry: // Like examples 2-4, only CacheToggleUnusedSincePrefetch* is inserted between // CacheReadResponse* and CacheDispatchValidation if the unused_since_prefetch // bit is unset. // // 13. Cached entry less than 5 minutes old, unused_since_prefetch is true: // Skip validation, similar to example 2. // GetBackend* -> InitEntry -> OpenEntry* -> AddToEntry* -> CacheReadResponse* // -> CacheToggleUnusedSincePrefetch* -> CacheDispatchValidation -> // BeginPartialCacheValidation() -> BeginCacheValidation() -> // SetupEntryForRead() -> FinishHeaders* // // Read(): // CacheReadData* // // 14. Cached entry more than 5 minutes old, unused_since_prefetch is true: // Like examples 2-4, only CacheToggleUnusedSincePrefetch* is inserted between // CacheReadResponse* and CacheDispatchValidation. int HttpCache::Transaction::DoLoop(int result) { DCHECK_NE(STATE_UNSET, next_state_); DCHECK_NE(STATE_NONE, next_state_); DCHECK(!in_do_loop_); int rv = result; State state = next_state_; do { state = next_state_; next_state_ = STATE_UNSET; base::AutoReset scoped_in_do_loop(&in_do_loop_, true); switch (state) { case STATE_GET_BACKEND: DCHECK_EQ(OK, rv); rv = DoGetBackend(); break; case STATE_GET_BACKEND_COMPLETE: rv = DoGetBackendComplete(rv); break; case STATE_INIT_ENTRY: DCHECK_EQ(OK, rv); rv = DoInitEntry(); break; case STATE_OPEN_ENTRY: DCHECK_EQ(OK, rv); rv = DoOpenEntry(); break; case STATE_OPEN_ENTRY_COMPLETE: rv = DoOpenEntryComplete(rv); break; case STATE_DOOM_ENTRY: DCHECK_EQ(OK, rv); rv = DoDoomEntry(); break; case STATE_DOOM_ENTRY_COMPLETE: rv = DoDoomEntryComplete(rv); break; case STATE_CREATE_ENTRY: DCHECK_EQ(OK, rv); rv = DoCreateEntry(); break; case STATE_CREATE_ENTRY_COMPLETE: rv = DoCreateEntryComplete(rv); break; case STATE_ADD_TO_ENTRY: DCHECK_EQ(OK, rv); rv = DoAddToEntry(); break; case STATE_ADD_TO_ENTRY_COMPLETE: rv = DoAddToEntryComplete(rv); break; case STATE_DONE_HEADERS_ADD_TO_ENTRY_COMPLETE: rv = DoDoneHeadersAddToEntryComplete(rv); break; case STATE_CACHE_READ_RESPONSE: DCHECK_EQ(OK, rv); rv = DoCacheReadResponse(); break; case STATE_CACHE_READ_RESPONSE_COMPLETE: rv = DoCacheReadResponseComplete(rv); break; case STATE_TOGGLE_UNUSED_SINCE_PREFETCH: DCHECK_EQ(OK, rv); rv = DoCacheToggleUnusedSincePrefetch(); break; case STATE_TOGGLE_UNUSED_SINCE_PREFETCH_COMPLETE: rv = DoCacheToggleUnusedSincePrefetchComplete(rv); break; case STATE_CACHE_DISPATCH_VALIDATION: DCHECK_EQ(OK, rv); rv = DoCacheDispatchValidation(); break; case STATE_CACHE_QUERY_DATA: DCHECK_EQ(OK, rv); rv = DoCacheQueryData(); break; case STATE_CACHE_QUERY_DATA_COMPLETE: rv = DoCacheQueryDataComplete(rv); break; case STATE_START_PARTIAL_CACHE_VALIDATION: DCHECK_EQ(OK, rv); rv = DoStartPartialCacheValidation(); break; case STATE_COMPLETE_PARTIAL_CACHE_VALIDATION: rv = DoCompletePartialCacheValidation(rv); break; case STATE_CACHE_UPDATE_STALE_WHILE_REVALIDATE_TIMEOUT: DCHECK_EQ(OK, rv); rv = DoCacheUpdateStaleWhileRevalidateTimeout(); break; case STATE_CACHE_UPDATE_STALE_WHILE_REVALIDATE_TIMEOUT_COMPLETE: rv = DoCacheUpdateStaleWhileRevalidateTimeoutComplete(rv); break; case STATE_SETUP_ENTRY_FOR_READ: DCHECK_EQ(OK, rv); rv = DoSetupEntryForRead(); break; case STATE_SEND_REQUEST: DCHECK_EQ(OK, rv); rv = DoSendRequest(); break; case STATE_SEND_REQUEST_COMPLETE: rv = DoSendRequestComplete(rv); break; case STATE_SUCCESSFUL_SEND_REQUEST: DCHECK_EQ(OK, rv); rv = DoSuccessfulSendRequest(); break; case STATE_UPDATE_CACHED_RESPONSE: DCHECK_EQ(OK, rv); rv = DoUpdateCachedResponse(); break; case STATE_CACHE_WRITE_UPDATED_RESPONSE: DCHECK_EQ(OK, rv); rv = DoCacheWriteUpdatedResponse(); break; case STATE_CACHE_WRITE_UPDATED_RESPONSE_COMPLETE: rv = DoCacheWriteUpdatedResponseComplete(rv); break; case STATE_UPDATE_CACHED_RESPONSE_COMPLETE: rv = DoUpdateCachedResponseComplete(rv); break; case STATE_OVERWRITE_CACHED_RESPONSE: DCHECK_EQ(OK, rv); rv = DoOverwriteCachedResponse(); break; case STATE_CACHE_WRITE_RESPONSE: DCHECK_EQ(OK, rv); rv = DoCacheWriteResponse(); break; case STATE_CACHE_WRITE_RESPONSE_COMPLETE: rv = DoCacheWriteResponseComplete(rv); break; case STATE_TRUNCATE_CACHED_DATA: DCHECK_EQ(OK, rv); rv = DoTruncateCachedData(); break; case STATE_TRUNCATE_CACHED_DATA_COMPLETE: rv = DoTruncateCachedDataComplete(rv); break; case STATE_TRUNCATE_CACHED_METADATA: DCHECK_EQ(OK, rv); rv = DoTruncateCachedMetadata(); break; case STATE_TRUNCATE_CACHED_METADATA_COMPLETE: rv = DoTruncateCachedMetadataComplete(rv); break; case STATE_PARTIAL_HEADERS_RECEIVED: DCHECK_EQ(OK, rv); rv = DoPartialHeadersReceived(); break; case STATE_CACHE_READ_METADATA: DCHECK_EQ(OK, rv); rv = DoCacheReadMetadata(); break; case STATE_CACHE_READ_METADATA_COMPLETE: rv = DoCacheReadMetadataComplete(rv); break; case STATE_HEADERS_PHASE_CANNOT_PROCEED: rv = DoHeadersPhaseCannotProceed(rv); break; case STATE_FINISH_HEADERS: rv = DoFinishHeaders(rv); break; case STATE_FINISH_HEADERS_COMPLETE: rv = DoFinishHeadersComplete(rv); break; case STATE_NETWORK_READ_CACHE_WRITE: DCHECK_EQ(OK, rv); rv = DoNetworkReadCacheWrite(); break; case STATE_NETWORK_READ_CACHE_WRITE_COMPLETE: rv = DoNetworkReadCacheWriteComplete(rv); break; case STATE_CACHE_READ_DATA: DCHECK_EQ(OK, rv); rv = DoCacheReadData(); break; case STATE_CACHE_READ_DATA_COMPLETE: rv = DoCacheReadDataComplete(rv); break; case STATE_NETWORK_READ: DCHECK_EQ(OK, rv); rv = DoNetworkRead(); break; case STATE_NETWORK_READ_COMPLETE: rv = DoNetworkReadComplete(rv); break; default: NOTREACHED() << "bad state " << state; rv = ERR_FAILED; break; } DCHECK(next_state_ != STATE_UNSET) << "Previous state was " << state; } while (rv != ERR_IO_PENDING && next_state_ != STATE_NONE); // Assert Start() state machine's allowed last state in successful cases when // caching is happening. DCHECK(reading_ || rv != OK || !entry_ || state == STATE_FINISH_HEADERS_COMPLETE); if (rv != ERR_IO_PENDING && !callback_.is_null()) { read_buf_ = nullptr; // Release the buffer before invoking the callback. base::ResetAndReturn(&callback_).Run(rv); } return rv; } int HttpCache::Transaction::DoGetBackend() { cache_pending_ = true; TransitionToState(STATE_GET_BACKEND_COMPLETE); net_log_.BeginEvent(NetLogEventType::HTTP_CACHE_GET_BACKEND); return cache_->GetBackendForTransaction(this); } int HttpCache::Transaction::DoGetBackendComplete(int result) { DCHECK(result == OK || result == ERR_FAILED); net_log_.EndEventWithNetErrorCode(NetLogEventType::HTTP_CACHE_GET_BACKEND, result); cache_pending_ = false; // Reset mode_ that might get set in this function. This is done because this // function can be invoked multiple times for a transaction. mode_ = NONE; if (!ShouldPassThrough()) { cache_key_ = cache_->GenerateCacheKey(request_); // Requested cache access mode. if (effective_load_flags_ & LOAD_ONLY_FROM_CACHE) { if (effective_load_flags_ & LOAD_BYPASS_CACHE) { // The client has asked for nonsense. TransitionToState(STATE_FINISH_HEADERS); return ERR_CACHE_MISS; } mode_ = READ; } else if (effective_load_flags_ & LOAD_BYPASS_CACHE) { mode_ = WRITE; } else { mode_ = READ_WRITE; } // Downgrade to UPDATE if the request has been externally conditionalized. if (external_validation_.initialized) { if (mode_ & WRITE) { // Strip off the READ_DATA bit (and maybe add back a READ_META bit // in case READ was off). mode_ = UPDATE; } else { mode_ = NONE; } } } // Use PUT and DELETE only to invalidate existing stored entries. if ((method_ == "PUT" || method_ == "DELETE") && mode_ != READ_WRITE && mode_ != WRITE) { mode_ = NONE; } // Note that if mode_ == UPDATE (which is tied to external_validation_), the // transaction behaves the same for GET and HEAD requests at this point: if it // was not modified, the entry is updated and a response is not returned from // the cache. If we receive 200, it doesn't matter if there was a validation // header or not. if (method_ == "HEAD" && mode_ == WRITE) mode_ = NONE; // If must use cache, then we must fail. This can happen for back/forward // navigations to a page generated via a form post. if (!(mode_ & READ) && effective_load_flags_ & LOAD_ONLY_FROM_CACHE) { TransitionToState(STATE_FINISH_HEADERS); return ERR_CACHE_MISS; } if (mode_ == NONE) { if (partial_) { partial_->RestoreHeaders(&custom_request_->extra_headers); partial_.reset(); } TransitionToState(STATE_SEND_REQUEST); } else { TransitionToState(STATE_INIT_ENTRY); } // This is only set if we have something to do with the response. range_requested_ = (partial_.get() != NULL); return OK; } int HttpCache::Transaction::DoInitEntry() { TRACE_EVENT0("io", "HttpCacheTransaction::DoInitEntry"); DCHECK(!new_entry_); if (!cache_.get()) { TransitionToState(STATE_FINISH_HEADERS); return ERR_UNEXPECTED; } if (mode_ == WRITE) { TransitionToState(STATE_DOOM_ENTRY); return OK; } TransitionToState(STATE_OPEN_ENTRY); return OK; } int HttpCache::Transaction::DoOpenEntry() { TRACE_EVENT0("io", "HttpCacheTransaction::DoOpenEntry"); DCHECK(!new_entry_); TransitionToState(STATE_OPEN_ENTRY_COMPLETE); cache_pending_ = true; net_log_.BeginEvent(NetLogEventType::HTTP_CACHE_OPEN_ENTRY); first_cache_access_since_ = TimeTicks::Now(); // See if we already have something working with this cache key. new_entry_ = cache_->FindActiveEntry(cache_key_); if (new_entry_) return OK; // See if we could potentially quick-reject the entry based on hints the // backend keeps in memory. uint8_t in_memory_info = cache_->GetCurrentBackend()->GetEntryInMemoryData(cache_key_); if (MaybeRejectBasedOnEntryInMemoryData(in_memory_info)) { cache_->GetCurrentBackend()->DoomEntry(cache_key_, priority_, base::DoNothing()); return net::ERR_CACHE_ENTRY_NOT_SUITABLE; } return cache_->OpenEntry(cache_key_, &new_entry_, this); } int HttpCache::Transaction::DoOpenEntryComplete(int result) { TRACE_EVENT0("io", "HttpCacheTransaction::DoOpenEntryComplete"); // It is important that we go to STATE_ADD_TO_ENTRY whenever the result is // OK, otherwise the cache will end up with an active entry without any // transaction attached. net_log_.EndEventWithNetErrorCode(NetLogEventType::HTTP_CACHE_OPEN_ENTRY, result); cache_pending_ = false; if (result == OK) { TransitionToState(STATE_ADD_TO_ENTRY); return OK; } if (result == ERR_CACHE_RACE) { TransitionToState(STATE_HEADERS_PHASE_CANNOT_PROCEED); return OK; } if (result == ERR_CACHE_ENTRY_NOT_SUITABLE) { // Documents the case this applies in DCHECK_EQ(mode_, READ_WRITE); // Record this as CantConditionalize, but otherwise proceed as we would // below --- as OpenEntry has already dropped the old entry for us. couldnt_conditionalize_request_ = true; validation_cause_ = VALIDATION_CAUSE_ZERO_FRESHNESS; cant_conditionalize_zero_freshness_from_memhint_ = true; UpdateCacheEntryStatus(CacheEntryStatus::ENTRY_CANT_CONDITIONALIZE); } if (method_ == "PUT" || method_ == "DELETE" || (method_ == "HEAD" && mode_ == READ_WRITE)) { DCHECK(mode_ == READ_WRITE || mode_ == WRITE || method_ == "HEAD"); mode_ = NONE; TransitionToState(STATE_SEND_REQUEST); return OK; } if (mode_ == READ_WRITE) { mode_ = WRITE; TransitionToState(STATE_CREATE_ENTRY); return OK; } if (mode_ == UPDATE) { // There is no cache entry to update; proceed without caching. mode_ = NONE; TransitionToState(STATE_SEND_REQUEST); return OK; } // The entry does not exist, and we are not permitted to create a new entry, // so we must fail. TransitionToState(STATE_FINISH_HEADERS); return ERR_CACHE_MISS; } int HttpCache::Transaction::DoDoomEntry() { TRACE_EVENT0("io", "HttpCacheTransaction::DoDoomEntry"); TransitionToState(STATE_DOOM_ENTRY_COMPLETE); cache_pending_ = true; if (first_cache_access_since_.is_null()) first_cache_access_since_ = TimeTicks::Now(); net_log_.BeginEvent(NetLogEventType::HTTP_CACHE_DOOM_ENTRY); return cache_->DoomEntry(cache_key_, this); } int HttpCache::Transaction::DoDoomEntryComplete(int result) { TRACE_EVENT0("io", "HttpCacheTransaction::DoDoomEntryComplete"); net_log_.EndEventWithNetErrorCode(NetLogEventType::HTTP_CACHE_DOOM_ENTRY, result); cache_pending_ = false; TransitionToState(result == ERR_CACHE_RACE ? STATE_HEADERS_PHASE_CANNOT_PROCEED : STATE_CREATE_ENTRY); return OK; } int HttpCache::Transaction::DoCreateEntry() { TRACE_EVENT0("io", "HttpCacheTransaction::DoCreateEntry"); DCHECK(!new_entry_); TransitionToState(STATE_CREATE_ENTRY_COMPLETE); cache_pending_ = true; net_log_.BeginEvent(NetLogEventType::HTTP_CACHE_CREATE_ENTRY); return cache_->CreateEntry(cache_key_, &new_entry_, this); } int HttpCache::Transaction::DoCreateEntryComplete(int result) { TRACE_EVENT0("io", "HttpCacheTransaction::DoCreateEntryComplete"); // It is important that we go to STATE_ADD_TO_ENTRY whenever the result is // OK, otherwise the cache will end up with an active entry without any // transaction attached. net_log_.EndEventWithNetErrorCode(NetLogEventType::HTTP_CACHE_CREATE_ENTRY, result); cache_pending_ = false; switch (result) { case OK: TransitionToState(STATE_ADD_TO_ENTRY); break; case ERR_CACHE_RACE: TransitionToState(STATE_HEADERS_PHASE_CANNOT_PROCEED); break; default: // We have a race here: Maybe we failed to open the entry and decided to // create one, but by the time we called create, another transaction // already created the entry. If we want to eliminate this issue, we // need an atomic OpenOrCreate() method exposed by the disk cache. DLOG(WARNING) << "Unable to create cache entry"; // Set the mode to NONE in order to bypass the cache entry and read from // the network directly. mode_ = NONE; if (!done_headers_create_new_entry_) { if (partial_) partial_->RestoreHeaders(&custom_request_->extra_headers); TransitionToState(STATE_SEND_REQUEST); return OK; } // The headers have already been received as a result of validation, // triggering the doom of the old entry. So no network request needs to // be sent. Note that since mode_ is NONE, the response won't be written // to cache. Transition to STATE_CACHE_WRITE_RESPONSE as that's the state // the transaction left off on when it tried to create the new entry. done_headers_create_new_entry_ = false; TransitionToState(STATE_CACHE_WRITE_RESPONSE); } return OK; } int HttpCache::Transaction::DoAddToEntry() { TRACE_EVENT0("io", "HttpCacheTransaction::DoAddToEntry"); DCHECK(new_entry_); cache_pending_ = true; net_log_.BeginEvent(NetLogEventType::HTTP_CACHE_ADD_TO_ENTRY); DCHECK(entry_lock_waiting_since_.is_null()); int rv = cache_->AddTransactionToEntry(new_entry_, this); DCHECK_EQ(rv, ERR_IO_PENDING); // If headers phase is already done then we are here because of validation not // matching and creating a new entry. This transaction should be the // first transaction of that new entry and thus it will not have cache lock // delays, thus returning early from here. if (done_headers_create_new_entry_) { DCHECK_EQ(mode_, WRITE); TransitionToState(STATE_DONE_HEADERS_ADD_TO_ENTRY_COMPLETE); return rv; } TransitionToState(STATE_ADD_TO_ENTRY_COMPLETE); entry_lock_waiting_since_ = TimeTicks::Now(); AddCacheLockTimeoutHandler(new_entry_); return rv; } void HttpCache::Transaction::AddCacheLockTimeoutHandler(ActiveEntry* entry) { DCHECK(next_state_ == STATE_ADD_TO_ENTRY_COMPLETE || next_state_ == STATE_FINISH_HEADERS_COMPLETE); if ((bypass_lock_for_test_ && next_state_ == STATE_ADD_TO_ENTRY_COMPLETE) || (bypass_lock_after_headers_for_test_ && next_state_ == STATE_FINISH_HEADERS_COMPLETE)) { base::ThreadTaskRunnerHandle::Get()->PostTask( FROM_HERE, base::Bind(&HttpCache::Transaction::OnCacheLockTimeout, weak_factory_.GetWeakPtr(), entry_lock_waiting_since_)); } else { int timeout_milliseconds = 20 * 1000; if (partial_ && entry->writers && !entry->writers->IsEmpty() && entry->writers->IsExclusive()) { // Even though entry_->writers takes care of allowing multiple writers to // simultaneously govern reading from the network and writing to the cache // for full requests, partial requests are still blocked by the // reader/writer lock. // Bypassing the cache after 25 ms of waiting for the cache lock // eliminates a long running issue, http://crbug.com/31014, where // two of the same media resources could not be played back simultaneously // due to one locking the cache entry until the entire video was // downloaded. // Bypassing the cache is not ideal, as we are now ignoring the cache // entirely for all range requests to a resource beyond the first. This // is however a much more succinct solution than the alternatives, which // would require somewhat significant changes to the http caching logic. // // Allow some timeout slack for the entry addition to complete in case // the writer lock is imminently released; we want to avoid skipping // the cache if at all possible. See http://crbug.com/408765 timeout_milliseconds = 25; } base::ThreadTaskRunnerHandle::Get()->PostDelayedTask( FROM_HERE, base::Bind(&HttpCache::Transaction::OnCacheLockTimeout, weak_factory_.GetWeakPtr(), entry_lock_waiting_since_), TimeDelta::FromMilliseconds(timeout_milliseconds)); } } int HttpCache::Transaction::DoAddToEntryComplete(int result) { TRACE_EVENT0("io", "HttpCacheTransaction::DoAddToEntryComplete"); net_log_.EndEventWithNetErrorCode(NetLogEventType::HTTP_CACHE_ADD_TO_ENTRY, result); const TimeDelta entry_lock_wait = TimeTicks::Now() - entry_lock_waiting_since_; UMA_HISTOGRAM_TIMES("HttpCache.EntryLockWait", entry_lock_wait); entry_lock_waiting_since_ = TimeTicks(); DCHECK(new_entry_); cache_pending_ = false; if (result == OK) entry_ = new_entry_; // If there is a failure, the cache should have taken care of new_entry_. new_entry_ = NULL; if (result == ERR_CACHE_RACE) { TransitionToState(STATE_HEADERS_PHASE_CANNOT_PROCEED); return OK; } if (result == ERR_CACHE_LOCK_TIMEOUT) { if (mode_ == READ) { TransitionToState(STATE_FINISH_HEADERS); return ERR_CACHE_MISS; } // The cache is busy, bypass it for this transaction. mode_ = NONE; TransitionToState(STATE_SEND_REQUEST); if (partial_) { partial_->RestoreHeaders(&custom_request_->extra_headers); partial_.reset(); } return OK; } // TODO(crbug.com/713354) Access timestamp for histograms only if entry is // already written, to avoid data race since cache thread can also access // this. if (!cache_->IsWritingInProgress(entry_)) open_entry_last_used_ = entry_->disk_entry->GetLastUsed(); // TODO(jkarlin): We should either handle the case or DCHECK. if (result != OK) { NOTREACHED(); TransitionToState(STATE_FINISH_HEADERS); return result; } if (mode_ == WRITE) { if (partial_) partial_->RestoreHeaders(&custom_request_->extra_headers); TransitionToState(STATE_SEND_REQUEST); } else { // We have to read the headers from the cached entry. DCHECK(mode_ & READ_META); TransitionToState(STATE_CACHE_READ_RESPONSE); } return OK; } int HttpCache::Transaction::DoDoneHeadersAddToEntryComplete(int result) { // This transaction's response headers did not match its ActiveEntry so it // created a new ActiveEntry (new_entry_) to write to (and doomed the old // one). Now that the new entry has been created, start writing the response. DCHECK_EQ(result, OK); DCHECK_EQ(mode_, WRITE); DCHECK(new_entry_); DCHECK(response_.headers); cache_pending_ = false; entry_ = new_entry_; done_headers_create_new_entry_ = false; DCHECK_NE(response_.headers->response_code(), 304); DCHECK(cache_->CanTransactionWriteResponseHeaders( entry_, this, partial_ != nullptr, false)); TransitionToState(STATE_CACHE_WRITE_RESPONSE); return OK; } int HttpCache::Transaction::DoCacheReadResponse() { TRACE_EVENT0("io", "HttpCacheTransaction::DoCacheReadResponse"); DCHECK(entry_); TransitionToState(STATE_CACHE_READ_RESPONSE_COMPLETE); io_buf_len_ = entry_->disk_entry->GetDataSize(kResponseInfoIndex); read_buf_ = new IOBuffer(io_buf_len_); net_log_.BeginEvent(NetLogEventType::HTTP_CACHE_READ_INFO); return entry_->disk_entry->ReadData(kResponseInfoIndex, 0, read_buf_.get(), io_buf_len_, io_callback_); } int HttpCache::Transaction::DoCacheReadResponseComplete(int result) { TRACE_EVENT0("io", "HttpCacheTransaction::DoCacheReadResponseComplete"); net_log_.EndEventWithNetErrorCode(NetLogEventType::HTTP_CACHE_READ_INFO, result); if (result != io_buf_len_ || !HttpCache::ParseResponseInfo(read_buf_->data(), io_buf_len_, &response_, &truncated_)) { return OnCacheReadError(result, true); } // TODO(crbug.com/713354) Only get data size if there is no other transaction // currently writing the response body due to the data race mentioned in the // associated bug. if (!cache_->IsWritingInProgress(entry_)) { int current_size = entry_->disk_entry->GetDataSize(kResponseContentIndex); int64_t full_response_length = response_.headers->GetContentLength(); // Some resources may have slipped in as truncated when they're not. if (full_response_length == current_size) truncated_ = false; // The state machine's handling of StopCaching unfortunately doesn't deal // well with resources that are larger than 2GB when there is a truncated or // sparse cache entry. While the state machine is reworked to resolve this, // the following logic is put in place to defer such requests to the // network. The cache should not be storing multi gigabyte resources. See // http://crbug.com/89567. if ((truncated_ || response_.headers->response_code() == 206) && !range_requested_ && full_response_length > std::numeric_limits::max()) { DCHECK(!partial_); // Doom the entry so that no other transaction gets added to this entry // and avoid a race of not being able to check this condition because // writing is in progress. DoneWithEntry(false); TransitionToState(STATE_SEND_REQUEST); return OK; } } if (response_.unused_since_prefetch != !!(request_->load_flags & LOAD_PREFETCH)) { // Either this is the first use of an entry since it was prefetched XOR // this is a prefetch. The value of response.unused_since_prefetch is // valid for this transaction but the bit needs to be flipped in storage. TransitionToState(STATE_TOGGLE_UNUSED_SINCE_PREFETCH); return OK; } TransitionToState(STATE_CACHE_DISPATCH_VALIDATION); return OK; } int HttpCache::Transaction::DoCacheToggleUnusedSincePrefetch() { TRACE_EVENT0("io", "HttpCacheTransaction::DoCacheToggleUnusedSincePrefetch"); // Write back the toggled value for the next use of this entry. response_.unused_since_prefetch = !response_.unused_since_prefetch; // TODO(jkarlin): If DoUpdateCachedResponse is also called for this // transaction then metadata will be written to cache twice. If prefetching // becomes more common, consider combining the writes. TransitionToState(STATE_TOGGLE_UNUSED_SINCE_PREFETCH_COMPLETE); return WriteResponseInfoToEntry(false); } int HttpCache::Transaction::DoCacheToggleUnusedSincePrefetchComplete( int result) { TRACE_EVENT0( kNetTracingCategory, "HttpCacheTransaction::DoCacheToggleUnusedSincePrefetchComplete"); // Restore the original value for this transaction. response_.unused_since_prefetch = !response_.unused_since_prefetch; TransitionToState(STATE_CACHE_DISPATCH_VALIDATION); return OnWriteResponseInfoToEntryComplete(result); } int HttpCache::Transaction::DoCacheDispatchValidation() { TRACE_EVENT0("io", "HttpCacheTransaction::DoCacheDispatchValidation"); // We now have access to the cache entry. // // o if we are a reader for the transaction, then we can start reading the // cache entry. // // o if we can read or write, then we should check if the cache entry needs // to be validated and then issue a network request if needed or just read // from the cache if the cache entry is already valid. // // o if we are set to UPDATE, then we are handling an externally // conditionalized request (if-modified-since / if-none-match). We check // if the request headers define a validation request. // int result = ERR_FAILED; switch (mode_) { case READ: UpdateCacheEntryStatus(CacheEntryStatus::ENTRY_USED); result = BeginCacheRead(); break; case READ_WRITE: result = BeginPartialCacheValidation(); break; case UPDATE: result = BeginExternallyConditionalizedRequest(); break; case WRITE: default: NOTREACHED(); } return result; } int HttpCache::Transaction::DoCacheQueryData() { TransitionToState(STATE_CACHE_QUERY_DATA_COMPLETE); return entry_->disk_entry->ReadyForSparseIO(io_callback_); } int HttpCache::Transaction::DoCacheQueryDataComplete(int result) { DCHECK_EQ(OK, result); if (!cache_.get()) { TransitionToState(STATE_FINISH_HEADERS); return ERR_UNEXPECTED; } return ValidateEntryHeadersAndContinue(); } // We may end up here multiple times for a given request. int HttpCache::Transaction::DoStartPartialCacheValidation() { if (mode_ == NONE) { TransitionToState(STATE_FINISH_HEADERS); return OK; } TransitionToState(STATE_COMPLETE_PARTIAL_CACHE_VALIDATION); return partial_->ShouldValidateCache(entry_->disk_entry, io_callback_); } int HttpCache::Transaction::DoCompletePartialCacheValidation(int result) { if (!result) { // This is the end of the request. DoneWithEntry(true); TransitionToState(STATE_FINISH_HEADERS); return result; } if (result < 0) { TransitionToState(STATE_FINISH_HEADERS); return result; } partial_->PrepareCacheValidation(entry_->disk_entry, &custom_request_->extra_headers); if (reading_ && partial_->IsCurrentRangeCached()) { TransitionToState(STATE_CACHE_READ_DATA); return OK; } return BeginCacheValidation(); } int HttpCache::Transaction::DoCacheUpdateStaleWhileRevalidateTimeout() { TRACE_EVENT0( "io", "HttpCacheTransaction::DoCacheUpdateStaleWhileRevalidateTimeout"); response_.stale_revalidate_timeout = cache_->clock_->Now() + kStaleRevalidateTimeout; TransitionToState(STATE_CACHE_UPDATE_STALE_WHILE_REVALIDATE_TIMEOUT_COMPLETE); return WriteResponseInfoToEntry(false); } int HttpCache::Transaction::DoCacheUpdateStaleWhileRevalidateTimeoutComplete( int result) { TRACE_EVENT0( "io", "HttpCacheTransaction::DoCacheUpdateStaleWhileRevalidateTimeoutComplete"); TransitionToState(STATE_SETUP_ENTRY_FOR_READ); return OnWriteResponseInfoToEntryComplete(result); } int HttpCache::Transaction::DoSendRequest() { TRACE_EVENT0("io", "HttpCacheTransaction::DoSendRequest"); DCHECK(mode_ & WRITE || mode_ == NONE); DCHECK(!network_trans_.get()); send_request_since_ = TimeTicks::Now(); // Create a network transaction. int rv = cache_->network_layer_->CreateTransaction(priority_, &network_trans_); if (rv != OK) { TransitionToState(STATE_FINISH_HEADERS); return rv; } network_trans_->SetBeforeNetworkStartCallback(before_network_start_callback_); network_trans_->SetBeforeHeadersSentCallback(before_headers_sent_callback_); network_trans_->SetRequestHeadersCallback(request_headers_callback_); network_trans_->SetResponseHeadersCallback(response_headers_callback_); // Old load timing information, if any, is now obsolete. network_transaction_info_.old_network_trans_load_timing.reset(); network_transaction_info_.old_remote_endpoint = IPEndPoint(); if (websocket_handshake_stream_base_create_helper_) network_trans_->SetWebSocketHandshakeStreamCreateHelper( websocket_handshake_stream_base_create_helper_); TransitionToState(STATE_SEND_REQUEST_COMPLETE); rv = network_trans_->Start(request_, io_callback_, net_log_); return rv; } int HttpCache::Transaction::DoSendRequestComplete(int result) { TRACE_EVENT0("io", "HttpCacheTransaction::DoSendRequestComplete"); if (!cache_.get()) { TransitionToState(STATE_FINISH_HEADERS); return ERR_UNEXPECTED; } // If we tried to conditionalize the request and failed, we know // we won't be reading from the cache after this point. if (couldnt_conditionalize_request_) mode_ = WRITE; if (result == OK) { TransitionToState(STATE_SUCCESSFUL_SEND_REQUEST); return OK; } const HttpResponseInfo* response = network_trans_->GetResponseInfo(); response_.network_accessed = response->network_accessed; // Do not record requests that have network errors or restarts. UpdateCacheEntryStatus(CacheEntryStatus::ENTRY_OTHER); if (IsCertificateError(result)) { // If we get a certificate error, then there is a certificate in ssl_info, // so GetResponseInfo() should never return NULL here. DCHECK(response); response_.ssl_info = response->ssl_info; } else if (result == ERR_SSL_CLIENT_AUTH_CERT_NEEDED) { DCHECK(response); response_.cert_request_info = response->cert_request_info; } else if (response_.was_cached) { DoneWithEntry(true); } TransitionToState(STATE_FINISH_HEADERS); return result; } // We received the response headers and there is no error. int HttpCache::Transaction::DoSuccessfulSendRequest() { TRACE_EVENT0("io", "HttpCacheTransaction::DoSuccessfulSendRequest"); DCHECK(!new_response_); const HttpResponseInfo* new_response = network_trans_->GetResponseInfo(); if (new_response->headers->response_code() == 401 || new_response->headers->response_code() == 407) { SetAuthResponse(*new_response); if (!reading_) { TransitionToState(STATE_FINISH_HEADERS); return OK; } // We initiated a second request the caller doesn't know about. We should be // able to authenticate this request because we should have authenticated // this URL moments ago. if (IsReadyToRestartForAuth()) { DCHECK(!response_.auth_challenge.get()); TransitionToState(STATE_SEND_REQUEST_COMPLETE); // In theory we should check to see if there are new cookies, but there // is no way to do that from here. return network_trans_->RestartWithAuth(AuthCredentials(), io_callback_); } // We have to perform cleanup at this point so that at least the next // request can succeed. We do not retry at this point, because data // has been read and we have no way to gather credentials. We would // fail again, and potentially loop. This can happen if the credentials // expire while chrome is suspended. if (entry_) DoomPartialEntry(false); mode_ = NONE; partial_.reset(); ResetNetworkTransaction(); TransitionToState(STATE_FINISH_HEADERS); return ERR_CACHE_AUTH_FAILURE_AFTER_READ; } new_response_ = new_response; if (!ValidatePartialResponse() && !auth_response_.headers.get()) { // Something went wrong with this request and we have to restart it. // If we have an authentication response, we are exposed to weird things // hapenning if the user cancels the authentication before we receive // the new response. net_log_.AddEvent(NetLogEventType::HTTP_CACHE_RE_SEND_PARTIAL_REQUEST); UpdateCacheEntryStatus(CacheEntryStatus::ENTRY_OTHER); SetResponse(HttpResponseInfo()); ResetNetworkTransaction(); new_response_ = NULL; TransitionToState(STATE_SEND_REQUEST); return OK; } if (handling_206_ && mode_ == READ_WRITE && !truncated_ && !is_sparse_) { // We have stored the full entry, but it changed and the server is // sending a range. We have to delete the old entry. UpdateCacheEntryStatus(CacheEntryStatus::ENTRY_OTHER); DoneWithEntry(false); } if (mode_ == WRITE && cache_entry_status_ != CacheEntryStatus::ENTRY_CANT_CONDITIONALIZE) { UpdateCacheEntryStatus(CacheEntryStatus::ENTRY_NOT_IN_CACHE); } // Invalidate any cached GET with a successful PUT or DELETE. if (mode_ == WRITE && (method_ == "PUT" || method_ == "DELETE")) { if (NonErrorResponse(new_response->headers->response_code()) && (entry_ && !entry_->doomed)) { int ret = cache_->DoomEntry(cache_key_, NULL); DCHECK_EQ(OK, ret); } // Do not invalidate the entry if its a failed Delete or Put. DoneWithEntry(true); } // Invalidate any cached GET with a successful POST. if (!(effective_load_flags_ & LOAD_DISABLE_CACHE) && method_ == "POST" && NonErrorResponse(new_response->headers->response_code())) { cache_->DoomMainEntryForUrl(request_->url); } RecordNoStoreHeaderHistogram(request_->load_flags, new_response); if (new_response_->headers->response_code() == 416 && (method_ == "GET" || method_ == "POST")) { // If there is an active entry it may be destroyed with this transaction. SetResponse(*new_response_); TransitionToState(STATE_FINISH_HEADERS); return OK; } // Are we expecting a response to a conditional query? if (mode_ == READ_WRITE || mode_ == UPDATE) { if (new_response->headers->response_code() == 304 || handling_206_) { UpdateCacheEntryStatus(CacheEntryStatus::ENTRY_VALIDATED); TransitionToState(STATE_UPDATE_CACHED_RESPONSE); return OK; } UpdateCacheEntryStatus(CacheEntryStatus::ENTRY_UPDATED); mode_ = WRITE; } TransitionToState(STATE_OVERWRITE_CACHED_RESPONSE); return OK; } // We received 304 or 206 and we want to update the cached response headers. int HttpCache::Transaction::DoUpdateCachedResponse() { TRACE_EVENT0("io", "HttpCacheTransaction::DoUpdateCachedResponse"); int rv = OK; // Update the cached response based on the headers and properties of // new_response_. response_.headers->Update(*new_response_->headers.get()); response_.stale_revalidate_timeout = base::Time(); response_.response_time = new_response_->response_time; response_.request_time = new_response_->request_time; response_.network_accessed = new_response_->network_accessed; response_.unused_since_prefetch = new_response_->unused_since_prefetch; response_.ssl_info = new_response_->ssl_info; if (new_response_->vary_data.is_valid()) { response_.vary_data = new_response_->vary_data; } else if (response_.vary_data.is_valid()) { // There is a vary header in the stored response but not in the current one. // Update the data with the new request headers. HttpVaryData new_vary_data; new_vary_data.Init(*request_, *response_.headers.get()); response_.vary_data = new_vary_data; } if (response_.headers->HasHeaderValue("cache-control", "no-store")) { if (!entry_->doomed) { int ret = cache_->DoomEntry(cache_key_, NULL); DCHECK_EQ(OK, ret); } TransitionToState(STATE_UPDATE_CACHED_RESPONSE_COMPLETE); } else { // If we are already reading, we already updated the headers for this // request; doing it again will change Content-Length. if (!reading_) { TransitionToState(STATE_CACHE_WRITE_UPDATED_RESPONSE); rv = OK; } else { TransitionToState(STATE_UPDATE_CACHED_RESPONSE_COMPLETE); } } return rv; } int HttpCache::Transaction::DoCacheWriteUpdatedResponse() { TRACE_EVENT0("io", "HttpCacheTransaction::DoCacheWriteUpdatedResponse"); TransitionToState(STATE_CACHE_WRITE_UPDATED_RESPONSE_COMPLETE); return WriteResponseInfoToEntry(false); } int HttpCache::Transaction::DoCacheWriteUpdatedResponseComplete(int result) { TRACE_EVENT0("io", "HttpCacheTransaction::DoCacheWriteUpdatedResponseComplete"); TransitionToState(STATE_UPDATE_CACHED_RESPONSE_COMPLETE); return OnWriteResponseInfoToEntryComplete(result); } int HttpCache::Transaction::DoUpdateCachedResponseComplete(int result) { TRACE_EVENT0("io", "HttpCacheTransaction::DoUpdateCachedResponseComplete"); if (mode_ == UPDATE) { DCHECK(!handling_206_); // We got a "not modified" response and already updated the corresponding // cache entry above. // // By stopping to write to the cache now, we make sure that the 304 rather // than the cached 200 response, is what will be returned to the user. DoneWithEntry(true); } else if (entry_ && !handling_206_) { DCHECK_EQ(READ_WRITE, mode_); if ((!partial_ && !cache_->IsWritingInProgress(entry_)) || (partial_ && partial_->IsLastRange())) { mode_ = READ; } // We no longer need the network transaction, so destroy it. if (network_trans_) ResetNetworkTransaction(); } else if (entry_ && handling_206_ && truncated_ && partial_->initial_validation()) { // We just finished the validation of a truncated entry, and the server // is willing to resume the operation. Now we go back and start serving // the first part to the user. if (network_trans_) ResetNetworkTransaction(); new_response_ = NULL; TransitionToState(STATE_START_PARTIAL_CACHE_VALIDATION); partial_->SetRangeToStartDownload(); return OK; } TransitionToState(STATE_OVERWRITE_CACHED_RESPONSE); return OK; } int HttpCache::Transaction::DoOverwriteCachedResponse() { TRACE_EVENT0("io", "HttpCacheTransaction::DoOverwriteCachedResponse"); if (mode_ & READ) { TransitionToState(STATE_PARTIAL_HEADERS_RECEIVED); return OK; } // We change the value of Content-Length for partial content. if (handling_206_ && partial_) partial_->FixContentLength(new_response_->headers.get()); SetResponse(*new_response_); if (method_ == "HEAD") { // This response is replacing the cached one. DoneWithEntry(false); new_response_ = NULL; TransitionToState(STATE_FINISH_HEADERS); return OK; } if (handling_206_ && !CanResume(false)) { // There is no point in storing this resource because it will never be used. // This may change if we support LOAD_ONLY_FROM_CACHE with sparse entries. DoneWithEntry(false); if (partial_) partial_->FixResponseHeaders(response_.headers.get(), true); TransitionToState(STATE_PARTIAL_HEADERS_RECEIVED); return OK; } TransitionToState(STATE_CACHE_WRITE_RESPONSE); return OK; } int HttpCache::Transaction::DoCacheWriteResponse() { TRACE_EVENT0("io", "HttpCacheTransaction::DoCacheWriteResponse"); // Invalidate any current entry with a successful response if this transaction // cannot write to this entry. This transaction then continues to read from // the network without writing to the backend. bool is_match = response_.headers->response_code() == 304; if (entry_ && response_.headers && !cache_->CanTransactionWriteResponseHeaders( entry_, this, partial_ != nullptr, is_match)) { done_headers_create_new_entry_ = true; // The transaction needs to overwrite this response. Doom the current entry, // create a new one (by going to STATE_INIT_ENTRY), and then jump straight // to writing out the response, bypassing the headers checks. The mode_ is // set to WRITE in order to doom any other existing entries that might exist // so that this transaction can go straight to writing a response. mode_ = WRITE; TransitionToState(STATE_INIT_ENTRY); cache_->DoomEntryValidationNoMatch(entry_); entry_ = nullptr; return OK; } TransitionToState(STATE_CACHE_WRITE_RESPONSE_COMPLETE); return WriteResponseInfoToEntry(truncated_); } int HttpCache::Transaction::DoCacheWriteResponseComplete(int result) { TRACE_EVENT0("io", "HttpCacheTransaction::DoCacheWriteResponseComplete"); TransitionToState(STATE_TRUNCATE_CACHED_DATA); return OnWriteResponseInfoToEntryComplete(result); } int HttpCache::Transaction::DoTruncateCachedData() { TRACE_EVENT0("io", "HttpCacheTransaction::DoTruncateCachedData"); TransitionToState(STATE_TRUNCATE_CACHED_DATA_COMPLETE); if (!entry_) return OK; if (net_log_.IsCapturing()) net_log_.BeginEvent(NetLogEventType::HTTP_CACHE_WRITE_DATA); // Truncate the stream. return WriteToEntry(kResponseContentIndex, 0, NULL, 0, io_callback_); } int HttpCache::Transaction::DoTruncateCachedDataComplete(int result) { TRACE_EVENT0("io", "HttpCacheTransaction::DoInitEntry"); if (entry_) { if (net_log_.IsCapturing()) { net_log_.EndEventWithNetErrorCode(NetLogEventType::HTTP_CACHE_WRITE_DATA, result); } } TransitionToState(STATE_TRUNCATE_CACHED_METADATA); return OK; } int HttpCache::Transaction::DoTruncateCachedMetadata() { TRACE_EVENT0("io", "HttpCacheTransaction::DoTruncateCachedMetadata"); TransitionToState(STATE_TRUNCATE_CACHED_METADATA_COMPLETE); if (!entry_) return OK; if (net_log_.IsCapturing()) net_log_.BeginEvent(NetLogEventType::HTTP_CACHE_WRITE_INFO); return WriteToEntry(kMetadataIndex, 0, NULL, 0, io_callback_); } int HttpCache::Transaction::DoTruncateCachedMetadataComplete(int result) { TRACE_EVENT0("io", "HttpCacheTransaction::DoTruncateCachedMetadataComplete"); if (entry_) { if (net_log_.IsCapturing()) { net_log_.EndEventWithNetErrorCode(NetLogEventType::HTTP_CACHE_WRITE_INFO, result); } } TransitionToState(STATE_PARTIAL_HEADERS_RECEIVED); return OK; } int HttpCache::Transaction::DoPartialHeadersReceived() { new_response_ = NULL; if (!partial_) { if (entry_ && entry_->disk_entry->GetDataSize(kMetadataIndex)) { TransitionToState(STATE_CACHE_READ_METADATA); } else { TransitionToState(STATE_FINISH_HEADERS); } return OK; } if (mode_ != NONE && !reading_) { // We are about to return the headers for a byte-range request to the user, // so let's fix them. partial_->FixResponseHeaders(response_.headers.get(), true); } TransitionToState(STATE_FINISH_HEADERS); return OK; } int HttpCache::Transaction::DoHeadersPhaseCannotProceed(int result) { // If its the Start state machine and it cannot proceed due to a cache // failure, restart this transaction. DCHECK(!reading_); // Reset before invoking SetRequest() which can reset the request info sent to // network transaction. if (network_trans_) network_trans_.reset(); new_response_ = nullptr; SetRequest(net_log_); entry_ = nullptr; // Bypass the cache for timeout scenario. if (result == ERR_CACHE_LOCK_TIMEOUT) effective_load_flags_ |= LOAD_DISABLE_CACHE; TransitionToState(STATE_GET_BACKEND); return OK; } int HttpCache::Transaction::DoFinishHeaders(int result) { if (!cache_.get() || !entry_ || result != OK) { TransitionToState(STATE_NONE); return result; } TransitionToState(STATE_FINISH_HEADERS_COMPLETE); // If it was an auth failure, this transaction should continue to be // headers_transaction till consumer takes an action, so no need to do // anything now. // TODO(crbug.com/740947). See the issue for a suggestion for cleaning the // state machine to be able to remove this condition. if (auth_response_.headers.get()) return OK; // If the transaction needs to wait because another transaction is still // writing the response body, it will return ERR_IO_PENDING now and the // io_callback_ will be invoked when the wait is done. int rv = cache_->DoneWithResponseHeaders(entry_, this, partial_ != nullptr); DCHECK(!reading_ || rv == OK) << "Expected OK, but got " << rv; if (rv == ERR_IO_PENDING) { DCHECK(entry_lock_waiting_since_.is_null()); entry_lock_waiting_since_ = TimeTicks::Now(); AddCacheLockTimeoutHandler(entry_); } return rv; } int HttpCache::Transaction::DoFinishHeadersComplete(int rv) { entry_lock_waiting_since_ = TimeTicks(); if (rv == ERR_CACHE_RACE || rv == ERR_CACHE_LOCK_TIMEOUT) { TransitionToState(STATE_HEADERS_PHASE_CANNOT_PROCEED); return rv; } if (network_trans_ && InWriters()) { entry_->writers->SetNetworkTransaction(this, std::move(network_trans_)); moved_network_transaction_to_writers_ = true; } // If already reading, that means it is a partial request coming back to the // headers phase, continue to the appropriate reading state. if (reading_) { int rv = TransitionToReadingState(); DCHECK_EQ(OK, rv); return OK; } TransitionToState(STATE_NONE); return rv; } int HttpCache::Transaction::DoCacheReadMetadata() { TRACE_EVENT0("io", "HttpCacheTransaction::DoCacheReadMetadata"); DCHECK(entry_); DCHECK(!response_.metadata.get()); TransitionToState(STATE_CACHE_READ_METADATA_COMPLETE); response_.metadata = new IOBufferWithSize(entry_->disk_entry->GetDataSize(kMetadataIndex)); net_log_.BeginEvent(NetLogEventType::HTTP_CACHE_READ_INFO); return entry_->disk_entry->ReadData(kMetadataIndex, 0, response_.metadata.get(), response_.metadata->size(), io_callback_); } int HttpCache::Transaction::DoCacheReadMetadataComplete(int result) { TRACE_EVENT0("io", "HttpCacheTransaction::DoCacheReadMetadataComplete"); net_log_.EndEventWithNetErrorCode(NetLogEventType::HTTP_CACHE_READ_INFO, result); if (result != response_.metadata->size()) return OnCacheReadError(result, false); TransitionToState(STATE_FINISH_HEADERS); return OK; } int HttpCache::Transaction::DoNetworkReadCacheWrite() { TRACE_EVENT0("io", "HttpCacheTransaction::DoNetworkReadCacheWrite"); DCHECK(InWriters()); TransitionToState(STATE_NETWORK_READ_CACHE_WRITE_COMPLETE); return entry_->writers->Read(read_buf_, io_buf_len_, io_callback_, this); } int HttpCache::Transaction::DoNetworkReadCacheWriteComplete(int result) { TRACE_EVENT0("io", "HttpCacheTransaction::DoNetworkReadCacheWriteComplete"); if (!cache_.get()) { TransitionToState(STATE_NONE); return ERR_UNEXPECTED; } // |result| will be error code in case of network read failure and |this| // cannot proceed further, so set entry_ to null. |result| will not be error // in case of cache write failure since |this| can continue to read from the // network. If response is completed, then also set entry to null. if (result < 0) { // We should have discovered this error in WriterAboutToBeRemovedFromEntry DCHECK_EQ(result, shared_writing_error_); DCHECK_EQ(NONE, mode_); DCHECK(!entry_); TransitionToState(STATE_NONE); return result; } if (partial_) { return DoPartialNetworkReadCompleted(result); } if (result == 0) { DCHECK_EQ(NONE, mode_); DCHECK(!entry_); } else { read_offset_ += result; } TransitionToState(STATE_NONE); return result; } int HttpCache::Transaction::DoPartialNetworkReadCompleted(int result) { DCHECK(partial_); // Go to the next range if nothing returned or return the result. // TODO(shivanisha) Simplify this condition if possible. It was introduced // in https://codereview.chromium.org/545101 if (result != 0 || truncated_ || !(partial_->IsLastRange() || mode_ == WRITE)) { partial_->OnNetworkReadCompleted(result); if (result == 0) { // We need to move on to the next range. if (network_trans_) { ResetNetworkTransaction(); } else if (InWriters() && entry_->writers->network_transaction()) { SaveNetworkTransactionInfo(*(entry_->writers->network_transaction())); entry_->writers->ResetNetworkTransaction(); } TransitionToState(STATE_START_PARTIAL_CACHE_VALIDATION); } else { TransitionToState(STATE_NONE); } return result; } // Request completed. if (result == 0) { DoneWithEntry(true); } TransitionToState(STATE_NONE); return result; } int HttpCache::Transaction::DoNetworkRead() { TRACE_EVENT0("io", "HttpCacheTransaction::DoNetworkRead"); TransitionToState(STATE_NETWORK_READ_COMPLETE); return network_trans_->Read(read_buf_.get(), io_buf_len_, io_callback_); } int HttpCache::Transaction::DoNetworkReadComplete(int result) { TRACE_EVENT0("io", "HttpCacheTransaction::DoNetworkReadComplete"); if (!cache_.get()) { TransitionToState(STATE_NONE); return ERR_UNEXPECTED; } if (partial_) return DoPartialNetworkReadCompleted(result); TransitionToState(STATE_NONE); return result; } int HttpCache::Transaction::DoCacheReadData() { TRACE_EVENT0("io", "HttpCacheTransaction::DoCacheReadData"); if (method_ == "HEAD") { TransitionToState(STATE_NONE); return 0; } DCHECK(entry_); TransitionToState(STATE_CACHE_READ_DATA_COMPLETE); if (net_log_.IsCapturing()) net_log_.BeginEvent(NetLogEventType::HTTP_CACHE_READ_DATA); if (partial_) { return partial_->CacheRead(entry_->disk_entry, read_buf_.get(), io_buf_len_, io_callback_); } return entry_->disk_entry->ReadData(kResponseContentIndex, read_offset_, read_buf_.get(), io_buf_len_, io_callback_); } int HttpCache::Transaction::DoCacheReadDataComplete(int result) { TRACE_EVENT0("io", "HttpCacheTransaction::DoCacheReadDataComplete"); if (net_log_.IsCapturing()) { net_log_.EndEventWithNetErrorCode(NetLogEventType::HTTP_CACHE_READ_DATA, result); } if (!cache_.get()) { TransitionToState(STATE_NONE); return ERR_UNEXPECTED; } if (partial_) { // Partial requests are confusing to report in histograms because they may // have multiple underlying requests. UpdateCacheEntryStatus(CacheEntryStatus::ENTRY_OTHER); return DoPartialCacheReadCompleted(result); } if (result > 0) { read_offset_ += result; } else if (result == 0) { // End of file. DoneWithEntry(true); } else { return OnCacheReadError(result, false); } TransitionToState(STATE_NONE); return result; } //----------------------------------------------------------------------------- void HttpCache::Transaction::SetRequest(const NetLogWithSource& net_log) { net_log_ = net_log; // Reset the variables that might get set in this function. This is done // because this function can be invoked multiple times for a transaction. cache_entry_status_ = CacheEntryStatus::ENTRY_UNDEFINED; external_validation_.Reset(); range_requested_ = false; partial_.reset(); request_ = initial_request_; custom_request_.reset(); effective_load_flags_ = request_->load_flags; method_ = request_->method; if (cache_->mode() == DISABLE) effective_load_flags_ |= LOAD_DISABLE_CACHE; // Some headers imply load flags. The order here is significant. // // LOAD_DISABLE_CACHE : no cache read or write // LOAD_BYPASS_CACHE : no cache read // LOAD_VALIDATE_CACHE : no cache read unless validation // // The former modes trump latter modes, so if we find a matching header we // can stop iterating kSpecialHeaders. // static const struct { const HeaderNameAndValue* search; int load_flag; } kSpecialHeaders[] = { { kPassThroughHeaders, LOAD_DISABLE_CACHE }, { kForceFetchHeaders, LOAD_BYPASS_CACHE }, { kForceValidateHeaders, LOAD_VALIDATE_CACHE }, }; bool range_found = false; bool external_validation_error = false; bool special_headers = false; if (request_->extra_headers.HasHeader(HttpRequestHeaders::kRange)) range_found = true; for (size_t i = 0; i < arraysize(kSpecialHeaders); ++i) { if (HeaderMatches(request_->extra_headers, kSpecialHeaders[i].search)) { effective_load_flags_ |= kSpecialHeaders[i].load_flag; special_headers = true; break; } } // Check for conditionalization headers which may correspond with a // cache validation request. for (size_t i = 0; i < arraysize(kValidationHeaders); ++i) { const ValidationHeaderInfo& info = kValidationHeaders[i]; std::string validation_value; if (request_->extra_headers.GetHeader( info.request_header_name, &validation_value)) { if (!external_validation_.values[i].empty() || validation_value.empty()) { external_validation_error = true; } external_validation_.values[i] = validation_value; external_validation_.initialized = true; } } if (range_found || special_headers || external_validation_.initialized) { // Log the headers before request_ is modified. std::string empty; net_log_.AddEvent( NetLogEventType::HTTP_CACHE_CALLER_REQUEST_HEADERS, base::Bind(&HttpRequestHeaders::NetLogCallback, base::Unretained(&request_->extra_headers), &empty)); } // We don't support ranges and validation headers. if (range_found && external_validation_.initialized) { LOG(WARNING) << "Byte ranges AND validation headers found."; effective_load_flags_ |= LOAD_DISABLE_CACHE; } // If there is more than one validation header, we can't treat this request as // a cache validation, since we don't know for sure which header the server // will give us a response for (and they could be contradictory). if (external_validation_error) { LOG(WARNING) << "Multiple or malformed validation headers found."; effective_load_flags_ |= LOAD_DISABLE_CACHE; } if (range_found && !(effective_load_flags_ & LOAD_DISABLE_CACHE)) { UpdateCacheEntryStatus(CacheEntryStatus::ENTRY_OTHER); partial_.reset(new PartialData); if (method_ == "GET" && partial_->Init(request_->extra_headers)) { // We will be modifying the actual range requested to the server, so // let's remove the header here. // Note that custom_request_ is a shallow copy so will keep the same // pointer to upload data stream as in the original request. custom_request_.reset(new HttpRequestInfo(*request_)); custom_request_->extra_headers.RemoveHeader(HttpRequestHeaders::kRange); request_ = custom_request_.get(); partial_->SetHeaders(custom_request_->extra_headers); } else { // The range is invalid or we cannot handle it properly. VLOG(1) << "Invalid byte range found."; effective_load_flags_ |= LOAD_DISABLE_CACHE; partial_.reset(NULL); } } } bool HttpCache::Transaction::ShouldPassThrough() { // We may have a null disk_cache if there is an error we cannot recover from, // like not enough disk space, or sharing violations. if (!cache_->disk_cache_.get()) return true; if (effective_load_flags_ & LOAD_DISABLE_CACHE) return true; if (method_ == "GET" || method_ == "HEAD") return false; if (method_ == "POST" && request_->upload_data_stream && request_->upload_data_stream->identifier()) { return false; } if (method_ == "PUT" && request_->upload_data_stream) return false; if (method_ == "DELETE") return false; return true; } int HttpCache::Transaction::BeginCacheRead() { // We don't support any combination of LOAD_ONLY_FROM_CACHE and byte ranges. // TODO(jkarlin): Either handle this case or DCHECK. if (response_.headers->response_code() == 206 || partial_) { NOTREACHED(); TransitionToState(STATE_FINISH_HEADERS); return ERR_CACHE_MISS; } // We don't have the whole resource. if (truncated_) { TransitionToState(STATE_FINISH_HEADERS); return ERR_CACHE_MISS; } if (RequiresValidation() != VALIDATION_NONE) { TransitionToState(STATE_FINISH_HEADERS); return ERR_CACHE_MISS; } if (method_ == "HEAD") FixHeadersForHead(); if (entry_->disk_entry->GetDataSize(kMetadataIndex)) TransitionToState(STATE_CACHE_READ_METADATA); else TransitionToState(STATE_FINISH_HEADERS); return OK; } int HttpCache::Transaction::BeginCacheValidation() { DCHECK_EQ(mode_, READ_WRITE); ValidationType required_validation = RequiresValidation(); bool skip_validation = (required_validation == VALIDATION_NONE); bool needs_stale_while_revalidate_cache_update = false; if ((effective_load_flags_ & LOAD_SUPPORT_ASYNC_REVALIDATION) && required_validation == VALIDATION_ASYNCHRONOUS) { DCHECK_EQ(request_->method, "GET"); skip_validation = true; response_.async_revalidation_requested = true; needs_stale_while_revalidate_cache_update = response_.stale_revalidate_timeout.is_null(); } if (method_ == "HEAD" && (truncated_ || response_.headers->response_code() == 206)) { DCHECK(!partial_); if (skip_validation) { TransitionToState(STATE_SETUP_ENTRY_FOR_READ); return OK; } // Bail out! TransitionToState(STATE_SEND_REQUEST); mode_ = NONE; return OK; } if (truncated_) { // Truncated entries can cause partial gets, so we shouldn't record this // load in histograms. UpdateCacheEntryStatus(CacheEntryStatus::ENTRY_OTHER); skip_validation = !partial_->initial_validation(); } if (partial_ && (is_sparse_ || truncated_) && (!partial_->IsCurrentRangeCached() || invalid_range_)) { // Force revalidation for sparse or truncated entries. Note that we don't // want to ignore the regular validation logic just because a byte range was // part of the request. skip_validation = false; } if (skip_validation) { UpdateCacheEntryStatus(CacheEntryStatus::ENTRY_USED); TransitionToState(needs_stale_while_revalidate_cache_update ? STATE_CACHE_UPDATE_STALE_WHILE_REVALIDATE_TIMEOUT : STATE_SETUP_ENTRY_FOR_READ); return OK; } else { // Make the network request conditional, to see if we may reuse our cached // response. If we cannot do so, then we just resort to a normal fetch. // Our mode remains READ_WRITE for a conditional request. Even if the // conditionalization fails, we don't switch to WRITE mode until we // know we won't be falling back to using the cache entry in the // LOAD_FROM_CACHE_IF_OFFLINE case. if (!ConditionalizeRequest()) { couldnt_conditionalize_request_ = true; UpdateCacheEntryStatus(CacheEntryStatus::ENTRY_CANT_CONDITIONALIZE); if (partial_) return DoRestartPartialRequest(); DCHECK_NE(206, response_.headers->response_code()); } TransitionToState(STATE_SEND_REQUEST); } return OK; } int HttpCache::Transaction::BeginPartialCacheValidation() { DCHECK_EQ(mode_, READ_WRITE); if (response_.headers->response_code() != 206 && !partial_ && !truncated_) return BeginCacheValidation(); // Partial requests should not be recorded in histograms. UpdateCacheEntryStatus(CacheEntryStatus::ENTRY_OTHER); if (method_ == "HEAD") return BeginCacheValidation(); if (!range_requested_) { // The request is not for a range, but we have stored just ranges. partial_.reset(new PartialData()); partial_->SetHeaders(request_->extra_headers); if (!custom_request_.get()) { custom_request_.reset(new HttpRequestInfo(*request_)); request_ = custom_request_.get(); } } TransitionToState(STATE_CACHE_QUERY_DATA); return OK; } // This should only be called once per request. int HttpCache::Transaction::ValidateEntryHeadersAndContinue() { DCHECK_EQ(mode_, READ_WRITE); if (!partial_->UpdateFromStoredHeaders(response_.headers.get(), entry_->disk_entry, truncated_, cache_->IsWritingInProgress(entry_))) { return DoRestartPartialRequest(); } if (response_.headers->response_code() == 206) is_sparse_ = true; if (!partial_->IsRequestedRangeOK()) { // The stored data is fine, but the request may be invalid. invalid_range_ = true; } TransitionToState(STATE_START_PARTIAL_CACHE_VALIDATION); return OK; } int HttpCache::Transaction::BeginExternallyConditionalizedRequest() { DCHECK_EQ(UPDATE, mode_); DCHECK(external_validation_.initialized); for (size_t i = 0; i < arraysize(kValidationHeaders); i++) { if (external_validation_.values[i].empty()) continue; // Retrieve either the cached response's "etag" or "last-modified" header. std::string validator; response_.headers->EnumerateHeader( NULL, kValidationHeaders[i].related_response_header_name, &validator); if (response_.headers->response_code() != 200 || truncated_ || validator.empty() || validator != external_validation_.values[i]) { // The externally conditionalized request is not a validation request // for our existing cache entry. Proceed with caching disabled. UpdateCacheEntryStatus(CacheEntryStatus::ENTRY_OTHER); DoneWithEntry(true); } } TransitionToState(STATE_SEND_REQUEST); return OK; } int HttpCache::Transaction::RestartNetworkRequest() { DCHECK(mode_ & WRITE || mode_ == NONE); DCHECK(network_trans_.get()); DCHECK_EQ(STATE_NONE, next_state_); next_state_ = STATE_SEND_REQUEST_COMPLETE; int rv = network_trans_->RestartIgnoringLastError(io_callback_); if (rv != ERR_IO_PENDING) return DoLoop(rv); return rv; } int HttpCache::Transaction::RestartNetworkRequestWithCertificate( scoped_refptr client_cert, scoped_refptr client_private_key) { DCHECK(mode_ & WRITE || mode_ == NONE); DCHECK(network_trans_.get()); DCHECK_EQ(STATE_NONE, next_state_); next_state_ = STATE_SEND_REQUEST_COMPLETE; int rv = network_trans_->RestartWithCertificate( std::move(client_cert), std::move(client_private_key), io_callback_); if (rv != ERR_IO_PENDING) return DoLoop(rv); return rv; } int HttpCache::Transaction::RestartNetworkRequestWithAuth( const AuthCredentials& credentials) { DCHECK(mode_ & WRITE || mode_ == NONE); DCHECK(network_trans_.get()); DCHECK_EQ(STATE_NONE, next_state_); next_state_ = STATE_SEND_REQUEST_COMPLETE; int rv = network_trans_->RestartWithAuth(credentials, io_callback_); if (rv != ERR_IO_PENDING) return DoLoop(rv); return rv; } ValidationType HttpCache::Transaction::RequiresValidation() { // TODO(darin): need to do more work here: // - make sure we have a matching request method // - watch out for cached responses that depend on authentication if (!(effective_load_flags_ & LOAD_SKIP_VARY_CHECK) && response_.vary_data.is_valid() && !response_.vary_data.MatchesRequest(*request_, *response_.headers.get())) { vary_mismatch_ = true; validation_cause_ = VALIDATION_CAUSE_VARY_MISMATCH; return VALIDATION_SYNCHRONOUS; } if (effective_load_flags_ & LOAD_SKIP_CACHE_VALIDATION) return VALIDATION_NONE; if (response_.unused_since_prefetch && !(effective_load_flags_ & LOAD_PREFETCH) && response_.headers->GetCurrentAge( response_.request_time, response_.response_time, cache_->clock_->Now()) < TimeDelta::FromMinutes(kPrefetchReuseMins)) { // The first use of a resource after prefetch within a short window skips // validation. return VALIDATION_NONE; } if (effective_load_flags_ & LOAD_VALIDATE_CACHE) { validation_cause_ = VALIDATION_CAUSE_VALIDATE_FLAG; return VALIDATION_SYNCHRONOUS; } if (method_ == "PUT" || method_ == "DELETE") return VALIDATION_SYNCHRONOUS; ValidationType validation_required_by_headers = response_.headers->RequiresValidation(response_.request_time, response_.response_time, cache_->clock_->Now()); if (validation_required_by_headers != VALIDATION_NONE) { HttpResponseHeaders::FreshnessLifetimes lifetimes = response_.headers->GetFreshnessLifetimes(response_.response_time); if (lifetimes.freshness == base::TimeDelta()) { validation_cause_ = VALIDATION_CAUSE_ZERO_FRESHNESS; } else { validation_cause_ = VALIDATION_CAUSE_STALE; stale_entry_freshness_ = lifetimes.freshness; stale_entry_age_ = response_.headers->GetCurrentAge( response_.request_time, response_.response_time, cache_->clock_->Now()); } } if (validation_required_by_headers == VALIDATION_ASYNCHRONOUS) { // Asynchronous revalidation is only supported for GET methods. if (request_->method != "GET") return VALIDATION_SYNCHRONOUS; // If the timeout on the staleness revalidation is set don't hand out // a resource that hasn't been async validated. if (!response_.stale_revalidate_timeout.is_null() && response_.stale_revalidate_timeout < cache_->clock_->Now()) { return VALIDATION_SYNCHRONOUS; } } return validation_required_by_headers; } bool HttpCache::Transaction::IsResponseConditionalizable( std::string* etag_value, std::string* last_modified_value) const { DCHECK(response_.headers.get()); // This only makes sense for cached 200 or 206 responses. if (response_.headers->response_code() != 200 && response_.headers->response_code() != 206) { return false; } // Just use the first available ETag and/or Last-Modified header value. // TODO(darin): Or should we use the last? if (response_.headers->GetHttpVersion() >= HttpVersion(1, 1)) response_.headers->EnumerateHeader(NULL, "etag", etag_value); response_.headers->EnumerateHeader(NULL, "last-modified", last_modified_value); if (etag_value->empty() && last_modified_value->empty()) return false; return true; } bool HttpCache::Transaction::ConditionalizeRequest() { DCHECK(response_.headers.get()); if (method_ == "PUT" || method_ == "DELETE") return false; if (fail_conditionalization_for_test_) return false; std::string etag_value; std::string last_modified_value; if (!IsResponseConditionalizable(&etag_value, &last_modified_value)) return false; DCHECK(response_.headers->response_code() != 206 || response_.headers->HasStrongValidators()); if (vary_mismatch_) { // Can't rely on last-modified if vary is different. last_modified_value.clear(); if (etag_value.empty()) return false; } if (!partial_) { // Need to customize the request, so this forces us to allocate :( custom_request_.reset(new HttpRequestInfo(*request_)); request_ = custom_request_.get(); } DCHECK(custom_request_.get()); bool use_if_range = partial_ && !partial_->IsCurrentRangeCached() && !invalid_range_; if (!etag_value.empty()) { if (use_if_range) { // We don't want to switch to WRITE mode if we don't have this block of a // byte-range request because we may have other parts cached. custom_request_->extra_headers.SetHeader( HttpRequestHeaders::kIfRange, etag_value); } else { custom_request_->extra_headers.SetHeader( HttpRequestHeaders::kIfNoneMatch, etag_value); } // For byte-range requests, make sure that we use only one way to validate // the request. if (partial_ && !partial_->IsCurrentRangeCached()) return true; } if (!last_modified_value.empty()) { if (use_if_range) { custom_request_->extra_headers.SetHeader( HttpRequestHeaders::kIfRange, last_modified_value); } else { custom_request_->extra_headers.SetHeader( HttpRequestHeaders::kIfModifiedSince, last_modified_value); } } return true; } bool HttpCache::Transaction::MaybeRejectBasedOnEntryInMemoryData( uint8_t in_memory_info) { // Not going to be clever with those... if (partial_) return false; // Avoiding open based on in-memory hints requires us to be permitted to // modify the cache, including deleting an old entry. Only the READ_WRITE // and WRITE modes permit that... and WRITE never tries to open entries in the // first place, so we shouldn't see it here. DCHECK_NE(mode_, WRITE); if (mode_ != READ_WRITE) return false; // If we are loading ignoring cache validity (aka back button), obviously // can't reject things based on it. Also if LOAD_ONLY_FROM_CACHE there is no // hope of network offering anything better. if (effective_load_flags_ & LOAD_SKIP_CACHE_VALIDATION || effective_load_flags_ & LOAD_ONLY_FROM_CACHE) return false; return (in_memory_info & HINT_UNUSABLE_PER_CACHING_HEADERS) == HINT_UNUSABLE_PER_CACHING_HEADERS; } bool HttpCache::Transaction::ComputeUnusablePerCachingHeaders() { // unused_since_prefetch overrides some caching headers, so it may be useful // regardless of what they say. if (response_.unused_since_prefetch) return false; // Has an e-tag or last-modified: we can probably send a conditional request, // so it's potentially useful. std::string etag_ignored, last_modified_ignored; if (IsResponseConditionalizable(&etag_ignored, &last_modified_ignored)) return false; // If none of the above is true and the entry has zero freshness, then it // won't be usable absent load flag override. return response_.headers->GetFreshnessLifetimes(response_.response_time) .freshness.is_zero(); } // We just received some headers from the server. We may have asked for a range, // in which case partial_ has an object. This could be the first network request // we make to fulfill the original request, or we may be already reading (from // the net and / or the cache). If we are not expecting a certain response, we // just bypass the cache for this request (but again, maybe we are reading), and // delete partial_ (so we are not able to "fix" the headers that we return to // the user). This results in either a weird response for the caller (we don't // expect it after all), or maybe a range that was not exactly what it was asked // for. // // If the server is simply telling us that the resource has changed, we delete // the cached entry and restart the request as the caller intended (by returning // false from this method). However, we may not be able to do that at any point, // for instance if we already returned the headers to the user. // // WARNING: Whenever this code returns false, it has to make sure that the next // time it is called it will return true so that we don't keep retrying the // request. bool HttpCache::Transaction::ValidatePartialResponse() { const HttpResponseHeaders* headers = new_response_->headers.get(); int response_code = headers->response_code(); bool partial_response = (response_code == 206); handling_206_ = false; if (!entry_ || method_ != "GET") return true; if (invalid_range_) { // We gave up trying to match this request with the stored data. If the // server is ok with the request, delete the entry, otherwise just ignore // this request DCHECK(!reading_); if (partial_response || response_code == 200) { DoomPartialEntry(true); mode_ = NONE; } else { if (response_code == 304) { // Change the response code of the request to be 416 (Requested range // not satisfiable). SetResponse(*new_response_); partial_->FixResponseHeaders(response_.headers.get(), false); } IgnoreRangeRequest(); } return true; } if (!partial_) { // We are not expecting 206 but we may have one. if (partial_response) IgnoreRangeRequest(); return true; } // TODO(rvargas): Do we need to consider other results here?. bool failure = response_code == 200 || response_code == 416; if (partial_->IsCurrentRangeCached()) { // We asked for "If-None-Match: " so a 206 means a new object. if (partial_response) failure = true; if (response_code == 304 && partial_->ResponseHeadersOK(headers)) return true; } else { // We asked for "If-Range: " so a 206 means just another range. if (partial_response) { if (partial_->ResponseHeadersOK(headers)) { handling_206_ = true; return true; } else { failure = true; } } if (!reading_ && !is_sparse_ && !partial_response) { // See if we can ignore the fact that we issued a byte range request. // If the server sends 200, just store it. If it sends an error, redirect // or something else, we may store the response as long as we didn't have // anything already stored. if (response_code == 200 || (!truncated_ && response_code != 304 && response_code != 416)) { // The server is sending something else, and we can save it. DCHECK((truncated_ && !partial_->IsLastRange()) || range_requested_); partial_.reset(); truncated_ = false; return true; } } // 304 is not expected here, but we'll spare the entry (unless it was // truncated). if (truncated_) failure = true; } if (failure) { // We cannot truncate this entry, it has to be deleted. UpdateCacheEntryStatus(CacheEntryStatus::ENTRY_OTHER); mode_ = NONE; if (is_sparse_ || truncated_) { // There was something cached to start with, either sparsed data (206), or // a truncated 200, which means that we probably modified the request, // adding a byte range or modifying the range requested by the caller. if (!reading_ && !partial_->IsLastRange()) { // We have not returned anything to the caller yet so it should be safe // to issue another network request, this time without us messing up the // headers. ResetPartialState(true); return false; } LOG(WARNING) << "Failed to revalidate partial entry"; } DoomPartialEntry(true); return true; } IgnoreRangeRequest(); return true; } void HttpCache::Transaction::IgnoreRangeRequest() { // We have a problem. We may or may not be reading already (in which case we // returned the headers), but we'll just pretend that this request is not // using the cache and see what happens. Most likely this is the first // response from the server (it's not changing its mind midway, right?). UpdateCacheEntryStatus(CacheEntryStatus::ENTRY_OTHER); DoneWithEntry(mode_ != WRITE); partial_.reset(NULL); } void HttpCache::Transaction::FixHeadersForHead() { if (response_.headers->response_code() == 206) { response_.headers->RemoveHeader("Content-Range"); response_.headers->ReplaceStatusLine("HTTP/1.1 200 OK"); } } int HttpCache::Transaction::DoSetupEntryForRead() { if (network_trans_) ResetNetworkTransaction(); if (partial_) { if (truncated_ || is_sparse_ || !invalid_range_) { // We are going to return the saved response headers to the caller, so // we may need to adjust them first. TransitionToState(STATE_PARTIAL_HEADERS_RECEIVED); return OK; } else { partial_.reset(); } } if (!cache_->IsWritingInProgress(entry_)) mode_ = READ; if (method_ == "HEAD") FixHeadersForHead(); if (entry_->disk_entry->GetDataSize(kMetadataIndex)) TransitionToState(STATE_CACHE_READ_METADATA); else TransitionToState(STATE_FINISH_HEADERS); return OK; } int HttpCache::Transaction::WriteToEntry(int index, int offset, IOBuffer* data, int data_len, const CompletionCallback& callback) { if (!entry_) return data_len; int rv = 0; if (!partial_ || !data_len) { rv = entry_->disk_entry->WriteData(index, offset, data, data_len, callback, true); } else { rv = partial_->CacheWrite(entry_->disk_entry, data, data_len, callback); } return rv; } int HttpCache::Transaction::WriteResponseInfoToEntry(bool truncated) { if (!entry_) return OK; if (net_log_.IsCapturing()) net_log_.BeginEvent(NetLogEventType::HTTP_CACHE_WRITE_INFO); // Do not cache no-store content. Do not cache content with cert errors // either. This is to prevent not reporting net errors when loading a // resource from the cache. When we load a page over HTTPS with a cert error // we show an SSL blocking page. If the user clicks proceed we reload the // resource ignoring the errors. The loaded resource is then cached. If that // resource is subsequently loaded from the cache, no net error is reported // (even though the cert status contains the actual errors) and no SSL // blocking page is shown. An alternative would be to reverse-map the cert // status to a net error and replay the net error. if ((response_.headers->HasHeaderValue("cache-control", "no-store")) || IsCertStatusError(response_.ssl_info.cert_status)) { bool stopped = StopCachingImpl(false); DCHECK(stopped); if (net_log_.IsCapturing()) net_log_.EndEvent(NetLogEventType::HTTP_CACHE_WRITE_INFO); return OK; } if (truncated) DCHECK_EQ(200, response_.headers->response_code()); // When writing headers, we normally only write the non-transient headers. bool skip_transient_headers = true; scoped_refptr data(new PickledIOBuffer()); response_.Persist(data->pickle(), skip_transient_headers, truncated); data->Done(); io_buf_len_ = data->pickle()->size(); // Summarize some info on cacheability in memory. Don't do it if doomed // since then |entry_| isn't definitive for |cache_key_|. if (!entry_->doomed) { cache_->GetCurrentBackend()->SetEntryInMemoryData( cache_key_, ComputeUnusablePerCachingHeaders() ? HINT_UNUSABLE_PER_CACHING_HEADERS : 0); } return entry_->disk_entry->WriteData(kResponseInfoIndex, 0, data.get(), io_buf_len_, io_callback_, true); } int HttpCache::Transaction::OnWriteResponseInfoToEntryComplete(int result) { if (!entry_) return OK; if (net_log_.IsCapturing()) { net_log_.EndEventWithNetErrorCode(NetLogEventType::HTTP_CACHE_WRITE_INFO, result); } if (result != io_buf_len_) { DLOG(ERROR) << "failed to write response info to cache"; DoneWithEntry(false); } return OK; } bool HttpCache::Transaction::StopCachingImpl(bool success) { bool stopped = false; // Let writers know so that it doesn't attempt to write to the cache. if (InWriters()) { stopped = entry_->writers->StopCaching(success /* keep_entry */); if (stopped) mode_ = NONE; } else if (entry_) { stopped = true; DoneWithEntry(success /* entry_is_complete */); } return stopped; } void HttpCache::Transaction::DoneWithEntry(bool entry_is_complete) { if (!entry_) return; // For a writer, histograms will be recorded in // WriterAboutToBeRemovedFromEntry. if (!InWriters()) RecordHistograms(); cache_->DoneWithEntry(entry_, this, entry_is_complete, partial_ != nullptr); entry_ = nullptr; mode_ = NONE; // switch to 'pass through' mode } int HttpCache::Transaction::OnCacheReadError(int result, bool restart) { DLOG(ERROR) << "ReadData failed: " << result; const int result_for_histogram = std::max(0, -result); if (restart) { base::UmaHistogramSparse("HttpCache.ReadErrorRestartable", result_for_histogram); } else { base::UmaHistogramSparse("HttpCache.ReadErrorNonRestartable", result_for_histogram); } // Avoid using this entry in the future. if (cache_.get()) cache_->DoomActiveEntry(cache_key_); if (restart) { DCHECK(!reading_); DCHECK(!network_trans_.get()); // Since we are going to add this to a new entry, not recording histograms // or setting mode to NONE at this point by invoking the wrapper // DoneWithEntry. cache_->DoneWithEntry(entry_, this, true /* entry_is_complete */, partial_ != nullptr); entry_ = NULL; is_sparse_ = false; partial_.reset(); TransitionToState(STATE_GET_BACKEND); return OK; } TransitionToState(STATE_NONE); return ERR_CACHE_READ_FAILURE; } void HttpCache::Transaction::OnCacheLockTimeout(base::TimeTicks start_time) { if (entry_lock_waiting_since_ != start_time) return; DCHECK(next_state_ == STATE_ADD_TO_ENTRY_COMPLETE || next_state_ == STATE_FINISH_HEADERS_COMPLETE); if (!cache_) return; if (next_state_ == STATE_ADD_TO_ENTRY_COMPLETE) cache_->RemovePendingTransaction(this); else DoneWithEntry(false /* entry_is_complete */); OnIOComplete(ERR_CACHE_LOCK_TIMEOUT); } void HttpCache::Transaction::DoomPartialEntry(bool delete_object) { DVLOG(2) << "DoomPartialEntry"; if (entry_ && !entry_->doomed) { int rv = cache_->DoomEntry(cache_key_, NULL); DCHECK_EQ(OK, rv); } cache_->DoneWithEntry(entry_, this, false /* entry_is_complete */, partial_ != nullptr); entry_ = NULL; is_sparse_ = false; truncated_ = false; if (delete_object) partial_.reset(NULL); } int HttpCache::Transaction::DoPartialCacheReadCompleted(int result) { partial_->OnCacheReadCompleted(result); if (result == 0 && mode_ == READ_WRITE) { // We need to move on to the next range. TransitionToState(STATE_START_PARTIAL_CACHE_VALIDATION); } else if (result < 0) { return OnCacheReadError(result, false); } else { TransitionToState(STATE_NONE); } return result; } int HttpCache::Transaction::DoRestartPartialRequest() { // The stored data cannot be used. Get rid of it and restart this request. net_log_.AddEvent(NetLogEventType::HTTP_CACHE_RESTART_PARTIAL_REQUEST); // WRITE + Doom + STATE_INIT_ENTRY == STATE_CREATE_ENTRY (without an attempt // to Doom the entry again). mode_ = WRITE; ResetPartialState(!range_requested_); TransitionToState(STATE_CREATE_ENTRY); return OK; } void HttpCache::Transaction::ResetPartialState(bool delete_object) { partial_->RestoreHeaders(&custom_request_->extra_headers); DoomPartialEntry(delete_object); if (!delete_object) { // The simplest way to re-initialize partial_ is to create a new object. partial_.reset(new PartialData()); // Reset the range header to the original value (http://crbug.com/820599). custom_request_->extra_headers.RemoveHeader(HttpRequestHeaders::kRange); if (partial_->Init(initial_request_->extra_headers)) partial_->SetHeaders(custom_request_->extra_headers); else partial_.reset(); } } void HttpCache::Transaction::ResetNetworkTransaction() { SaveNetworkTransactionInfo(*network_trans_); network_trans_.reset(); } const HttpTransaction* HttpCache::Transaction::network_transaction() const { if (network_trans_) return network_trans_.get(); if (InWriters()) return entry_->writers->network_transaction(); return nullptr; } const HttpTransaction* HttpCache::Transaction::GetOwnedOrMovedNetworkTransaction() const { if (network_trans_) return network_trans_.get(); if (InWriters() && moved_network_transaction_to_writers_) return entry_->writers->network_transaction(); return nullptr; } HttpTransaction* HttpCache::Transaction::network_transaction() { return const_cast( static_cast(this)->network_transaction()); } // Histogram data from the end of 2010 show the following distribution of // response headers: // // Content-Length............... 87% // Date......................... 98% // Last-Modified................ 49% // Etag......................... 19% // Accept-Ranges: bytes......... 25% // Accept-Ranges: none.......... 0.4% // Strong Validator............. 50% // Strong Validator + ranges.... 24% // Strong Validator + CL........ 49% // bool HttpCache::Transaction::CanResume(bool has_data) { // Double check that there is something worth keeping. if (has_data && !entry_->disk_entry->GetDataSize(kResponseContentIndex)) return false; if (method_ != "GET") return false; // Note that if this is a 206, content-length was already fixed after calling // PartialData::ResponseHeadersOK(). if (response_.headers->GetContentLength() <= 0 || response_.headers->HasHeaderValue("Accept-Ranges", "none") || !response_.headers->HasStrongValidators()) { return false; } return true; } void HttpCache::Transaction::SetResponse(const HttpResponseInfo& response) { response_ = response; SyncCacheEntryStatusToResponse(); } void HttpCache::Transaction::SetAuthResponse( const HttpResponseInfo& auth_response) { auth_response_ = auth_response; SyncCacheEntryStatusToResponse(); } void HttpCache::Transaction::UpdateCacheEntryStatus( CacheEntryStatus new_cache_entry_status) { DCHECK_NE(CacheEntryStatus::ENTRY_UNDEFINED, new_cache_entry_status); if (cache_entry_status_ == CacheEntryStatus::ENTRY_OTHER) return; DCHECK(cache_entry_status_ == CacheEntryStatus::ENTRY_UNDEFINED || new_cache_entry_status == CacheEntryStatus::ENTRY_OTHER); cache_entry_status_ = new_cache_entry_status; SyncCacheEntryStatusToResponse(); } void HttpCache::Transaction::SyncCacheEntryStatusToResponse() { if (cache_entry_status_ == CacheEntryStatus::ENTRY_UNDEFINED) return; response_.cache_entry_status = cache_entry_status_; if (auth_response_.headers.get()) { auth_response_.cache_entry_status = cache_entry_status_; } } void HttpCache::Transaction::RecordHistograms() { DCHECK(!recorded_histograms_); recorded_histograms_ = true; UMA_HISTOGRAM_ENUMERATION("HttpCache.ParallelWritingPattern", parallel_writing_pattern_, PARALLEL_WRITING_MAX); if (CacheEntryStatus::ENTRY_UNDEFINED == cache_entry_status_) return; if (!cache_.get() || !cache_->GetCurrentBackend() || cache_->GetCurrentBackend()->GetCacheType() != DISK_CACHE || cache_->mode() != NORMAL || method_ != "GET") { return; } bool validation_request = cache_entry_status_ == CacheEntryStatus::ENTRY_VALIDATED || cache_entry_status_ == CacheEntryStatus::ENTRY_UPDATED; bool stale_request = validation_cause_ == VALIDATION_CAUSE_STALE && (validation_request || cache_entry_status_ == CacheEntryStatus::ENTRY_CANT_CONDITIONALIZE); int64_t freshness_periods_since_last_used = 0; if (stale_request && !open_entry_last_used_.is_null()) { // Note that we are not able to capture those transactions' histograms which // when added to entry, the response was being written by another // transaction because getting the last used timestamp might lead to a data // race in that case. TODO(crbug.com/713354). // For stale entries, record how many freshness periods have elapsed since // the entry was last used. DCHECK(!stale_entry_freshness_.is_zero()); base::TimeDelta time_since_use = base::Time::Now() - open_entry_last_used_; freshness_periods_since_last_used = (time_since_use * 1000) / stale_entry_freshness_; if (validation_request) { int64_t age_in_freshness_periods = (stale_entry_age_ * 100) / stale_entry_freshness_; if (cache_entry_status_ == CacheEntryStatus::ENTRY_VALIDATED) { UMA_HISTOGRAM_COUNTS_1M("HttpCache.StaleEntry.Validated.Age", stale_entry_age_.InSeconds()); UMA_HISTOGRAM_COUNTS_1M( "HttpCache.StaleEntry.Validated.AgeInFreshnessPeriods", age_in_freshness_periods); } else { UMA_HISTOGRAM_COUNTS_1M("HttpCache.StaleEntry.Updated.Age", stale_entry_age_.InSeconds()); UMA_HISTOGRAM_COUNTS_1M( "HttpCache.StaleEntry.Updated.AgeInFreshnessPeriods", age_in_freshness_periods); } } } std::string mime_type; HttpResponseHeaders* response_headers = GetResponseInfo()->headers.get(); if (response_headers && response_headers->GetMimeType(&mime_type)) { // Record the cache pattern by resource type. The type is inferred by // response header mime type, which could be incorrect, so this is just an // estimate. if (mime_type == "text/html" && (effective_load_flags_ & LOAD_MAIN_FRAME_DEPRECATED)) { CACHE_STATUS_HISTOGRAMS(".MainFrameHTML"); } else if (mime_type == "text/html") { CACHE_STATUS_HISTOGRAMS(".NonMainFrameHTML"); } else if (mime_type == "text/css") { CACHE_STATUS_HISTOGRAMS(".CSS"); } else if (base::StartsWith(mime_type, "image/", base::CompareCase::SENSITIVE)) { int64_t content_length = response_headers->GetContentLength(); if (content_length >= 0 && content_length < 100) { CACHE_STATUS_HISTOGRAMS(".TinyImage"); } else if (content_length >= 100) { CACHE_STATUS_HISTOGRAMS(".NonTinyImage"); } CACHE_STATUS_HISTOGRAMS(".Image"); } else if (base::EndsWith(mime_type, "javascript", base::CompareCase::SENSITIVE) || base::EndsWith(mime_type, "ecmascript", base::CompareCase::SENSITIVE)) { CACHE_STATUS_HISTOGRAMS(".JavaScript"); } else if (mime_type.find("font") != std::string::npos) { CACHE_STATUS_HISTOGRAMS(".Font"); } else if (base::StartsWith(mime_type, "audio/", base::CompareCase::SENSITIVE)) { CACHE_STATUS_HISTOGRAMS(".Audio"); } else if (base::StartsWith(mime_type, "video/", base::CompareCase::SENSITIVE)) { CACHE_STATUS_HISTOGRAMS(".Video"); } } CACHE_STATUS_HISTOGRAMS(""); if (cache_entry_status_ == CacheEntryStatus::ENTRY_CANT_CONDITIONALIZE) { UMA_HISTOGRAM_ENUMERATION("HttpCache.CantConditionalizeCause", validation_cause_, VALIDATION_CAUSE_MAX); if (validation_cause_ == VALIDATION_CAUSE_ZERO_FRESHNESS) { UMA_HISTOGRAM_BOOLEAN( "HttpCache.CantConditionalizeZeroFreshnessFromMemHint", cant_conditionalize_zero_freshness_from_memhint_); } } if (cache_entry_status_ == CacheEntryStatus::ENTRY_OTHER) return; DCHECK(!range_requested_) << "Cache entry status " << cache_entry_status_; DCHECK(!first_cache_access_since_.is_null()); base::TimeTicks now = base::TimeTicks::Now(); TimeDelta total_time = now - first_cache_access_since_; UMA_HISTOGRAM_TIMES("HttpCache.AccessToDone", total_time); bool did_send_request = !send_request_since_.is_null(); DCHECK( (did_send_request && (cache_entry_status_ == CacheEntryStatus::ENTRY_NOT_IN_CACHE || cache_entry_status_ == CacheEntryStatus::ENTRY_VALIDATED || cache_entry_status_ == CacheEntryStatus::ENTRY_UPDATED || cache_entry_status_ == CacheEntryStatus::ENTRY_CANT_CONDITIONALIZE)) || (!did_send_request && cache_entry_status_ == CacheEntryStatus::ENTRY_USED)); if (!did_send_request) { DCHECK(cache_entry_status_ == CacheEntryStatus::ENTRY_USED); UMA_HISTOGRAM_TIMES("HttpCache.AccessToDone.Used", total_time); return; } TimeDelta before_send_time = send_request_since_ - first_cache_access_since_; TimeDelta after_send_time = now - send_request_since_; int64_t before_send_percent = (total_time.ToInternalValue() == 0) ? 0 : before_send_time * 100 / total_time; DCHECK_GE(before_send_percent, 0); DCHECK_LE(before_send_percent, 100); base::HistogramBase::Sample before_send_sample = static_cast(before_send_percent); UMA_HISTOGRAM_TIMES("HttpCache.AccessToDone.SentRequest", total_time); UMA_HISTOGRAM_TIMES("HttpCache.BeforeSend", before_send_time); UMA_HISTOGRAM_PERCENTAGE("HttpCache.PercentBeforeSend", before_send_sample); // TODO(gavinp): Remove or minimize these histograms, particularly the ones // below this comment after we have received initial data. switch (cache_entry_status_) { case CacheEntryStatus::ENTRY_CANT_CONDITIONALIZE: { UMA_HISTOGRAM_TIMES("HttpCache.BeforeSend.CantConditionalize", before_send_time); UMA_HISTOGRAM_TIMES("HttpCache.AfterSend.CantConditionalize", after_send_time); UMA_HISTOGRAM_PERCENTAGE("HttpCache.PercentBeforeSend.CantConditionalize", before_send_sample); break; } case CacheEntryStatus::ENTRY_NOT_IN_CACHE: { UMA_HISTOGRAM_TIMES("HttpCache.BeforeSend.NotCached", before_send_time); UMA_HISTOGRAM_TIMES("HttpCache.AfterSend.NotCached", after_send_time); UMA_HISTOGRAM_PERCENTAGE("HttpCache.PercentBeforeSend.NotCached", before_send_sample); break; } case CacheEntryStatus::ENTRY_VALIDATED: { UMA_HISTOGRAM_TIMES("HttpCache.BeforeSend.Validated", before_send_time); UMA_HISTOGRAM_TIMES("HttpCache.AfterSend.Validated", after_send_time); UMA_HISTOGRAM_PERCENTAGE("HttpCache.PercentBeforeSend.Validated", before_send_sample); break; } case CacheEntryStatus::ENTRY_UPDATED: { UMA_HISTOGRAM_TIMES("HttpCache.AfterSend.Updated", after_send_time); UMA_HISTOGRAM_TIMES("HttpCache.BeforeSend.Updated", before_send_time); UMA_HISTOGRAM_PERCENTAGE("HttpCache.PercentBeforeSend.Updated", before_send_sample); break; } default: NOTREACHED(); } } bool HttpCache::Transaction::InWriters() const { return entry_ && entry_->writers && entry_->writers->HasTransaction(this); } HttpCache::Transaction::NetworkTransactionInfo::NetworkTransactionInfo() = default; HttpCache::Transaction::NetworkTransactionInfo::~NetworkTransactionInfo() = default; void HttpCache::Transaction::SaveNetworkTransactionInfo( const HttpTransaction& transaction) { DCHECK(!network_transaction_info_.old_network_trans_load_timing); LoadTimingInfo load_timing; if (transaction.GetLoadTimingInfo(&load_timing)) network_transaction_info_.old_network_trans_load_timing.reset( new LoadTimingInfo(load_timing)); network_transaction_info_.total_received_bytes += transaction.GetTotalReceivedBytes(); network_transaction_info_.total_sent_bytes += transaction.GetTotalSentBytes(); ConnectionAttempts attempts; transaction.GetConnectionAttempts(&attempts); for (const auto& attempt : attempts) network_transaction_info_.old_connection_attempts.push_back(attempt); network_transaction_info_.old_remote_endpoint = IPEndPoint(); transaction.GetRemoteEndpoint(&network_transaction_info_.old_remote_endpoint); transaction.GetFullRequestHeaders( &network_transaction_info_.full_request_headers); } void HttpCache::Transaction::OnIOComplete(int result) { DoLoop(result); } void HttpCache::Transaction::TransitionToState(State state) { // Ensure that the state is only set once per Do* state. DCHECK(in_do_loop_); DCHECK_EQ(STATE_UNSET, next_state_) << "Next state is " << state; next_state_ = state; } } // namespace net